Similar to Neural Style

The paper builds on A Neural Algorithm of Artistic Style by Leon A. Gatys, Alexander S. Ecker, and Matthias Bethge by training feedforward neural networks that apply artistic styles to images. After training, our feedforward networks can stylize images hundreds of times faster than the optimization-based method presented by Gatys et al.
This repository also includes an implementation of instance normalization as described in the paper Instance Normalization: The Missing Ingredient for Fast Stylization by Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. This simple trick significantly improves the quality of feedforward style transfer models.

This is the torch implementation for the paper "Artistic style transfer for videos", based on neural-style code by Justin Johnson https://github.com/jcjohnson/neural-style .
It's the same as Neural-Style but with support for creating video instead of just single images.

code for paper "Combining Markov Random Fields and Convolutional Neural Networks for Image Synthesis".
Seems to work well for using real images as styles.
Work similar to Neural-Style in how you input your commands. Requires a style image and content image, just like Neural-Style.

A different implementation of A Neural Algorithm of Artistic Style. A method to transfer the style of one image to the subject of another image.

Turn your two-bit doodles into fine artworks with deep neural networks, generate seamless textures from photos, transfer style from one image to another, perform example-based upscaling, but wait... there's more! (An implementation of Semantic Style Transfer.)

crowsonkb's implementation of Google's Deepdream
Capable of creating high resolution images in just a matter of minutes due to tiling.
Tiling allows for even GPU's and CPUs with few resources, to create high res images.

Reddit announcement post.
The image is divided into tiles which are processed one at a time (with one GPU). Since the tiles can be sized so as to fit into GPU memory, this allows arbitrary size images to be processed—including print size. (ex: --size 2048 --tile-size 512)
Images can be processed at multiple scales for speed. For instance, --size 512 1024 2048 -i 100 will run 100 iterations (the default is 200) at 512x512, then 100 at 1024x1024, then 100 more at 2048x2048.
Multi-GPU support (ex: --devices 0 1 2 3). Four GPUs, for instance, can process four tiles at a time.

This is basically an implementation of this "Image Analogies" paper, In our case, we use feature maps from VGG16. The patch matching and blending is inspired by the method described in "Combining Markov Random Fields and Convolutional Neural Networks for Image Synthesis". Effects similar to that paper can be achieved by turning off the analogy loss (or leave it on!) --analogy-w=0 and turning on the B/B' content weighting via the --b-content-w parameter. Also, instead of using brute-force patch matching we use the PatchMatch algorithm to approximate the best patch matches. Brute-force matching can be re-enabled by setting --model=brute

An implementation of neural style in TensorFlow.
This implementation is a lot simpler than a lot of the other ones out there, thanks to TensorFlow's really nice API and automatic differentiation.
TensorFlow doesn't support L-BFGS (which is what the original authors used), so we use Adam. This may require require a little bit more hyperparameter tuning to get nice results.
TensorFlow seems to be slower than a lot of the other deep learning frameworks out there. I'm sure this implementation could be improved, but it would probably take improvements in TensorFlow itself as well to get it to operate at the same speed as other implementations. As of now, it seems to be around 3x slower than implementations using Torch.

A project that trains a convolutional neural network over a dataset to repaint an novel image in the style of a given painting. This is the implementation of Neural Style Transfer from the paper A Neural Algorithm of Artistic Style in Keras 1.0.2. This is also the code for 'Build an AI Artist' on Youtube.

Neural net operations are handled by Caffe, while loss minimization and other miscellaneous matrix operations are performed using numpy and scipy. L-BFGS is used for minimization.
Can use GoogLeNet models?

A deep learning software that easily generates images with a few brushstrokes (from UC Berkeley and Adobe CTL)
iGAN (aka. interactive GAN) is the author's implementation of interactive image generation interface described in: "Generative Visual Manipulation on the Natural Image Manifold" Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, Alexei A. Efros In European Conference on Computer Vision (ECCV) 2016
Realistic Photoshop with two adversarial neural networks.

Provide feedback