What possibilities do I get with titan pascal sli

[Grume]

I have plans to buy 2 titans. Will it be possible to use 24 GB for one image at once? What will give nvlink technology for this project?

[jcjohnson]

neural-style cannot distribute computation over multiple GPUs. It would be theoretically possible, but a bit of a pain to implement.

[Grume]

@jcjohnson thx for fast reply!
if theoritically its possible, how long it might take to develop and at what price it can be ordered?

[endymion]

A way to split neural-style over multiple GPUs so that artists could achieve higher-resolution output would be a gift to the world. I'm still on a quest to do any kind of style transfer with output in the 4K+ range so that it could be used as a serious art tool for printing on paper. The main limitation is fitting the entire thing into one GPU. It's easy to rent a cloud instance with a bunch of GPUs or buy multiple GPUs but even if you have the money you still can't achieve high-resolution output with any implementation that I've found, even with 24+ GB of GPU memory and optimized settings.

[crasse2]

If the process over a single source image can't be distributed over multiple GPUs, maybe another solution for multi GPU processing is closer to the tiling system that some people are trying to build (in another thread, here #337).
I didn't have time to try it yet, but this could be a way (dividing the source into tiles, and send each tile neural-art process to different GPUs at once) ?

[htoyryla]

Another problem is when the image resolution increases, the receptive fields of the CNN see smaller parts of the image and the style of the output image is no longer the same as for a smaller image. Also the tiling method suffers from the same problem.

This phenomenon has been mentioned now and then since neural-style was introduced and I have for a long time suspected that it happens because the model works best with a certain resolution and when it scales for a larger image the nodes see a smaller part of the image. Now the following paper confirms this (see section 6.2) and states that VGG19 works best with 512x512px images. With this size, the style features are best reserved. The paper also proposes a method to overcome this problem.

https://arxiv.org/pdf/1611.07865v1.pdf

[jcjohnson]

@htoyryla You are exactly correct. I've also read the linked paper, and it's very easy to implement their multiscale generation in neural-style. I've been playing around with it for the past few days, and it works really well for generating high-resolution outputs. Here's an example:

This image was generated with this script:

https://gist.github.com/jcjohnson/ca1f29057a187bc7721a3a8c418cc7db

Where the style image is a super-high res scan of Starry Night from the Google Art project:

https://upload.wikimedia.org/wikipedia/commons/e/ea/Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg

[crasse2]

wow ! that's an awesome method here ! so basicly it generates the main stylisation structure on the first small output, which lead to larger graphic interpretation of large shapes from the source image and then "repaint" it on larger scales with more details from the style image while keeping the stylisation structure from the small one ! I've already experienced also problems with large outputs (giving homogeneous results with swarming details and the loss of the main graphic structure of the source image)
So thanks for sharing this, I have to try it :D !

[jcjohnson]

@crasse2 Yep, that's the right way to think about it.

With single-scale generation, the absolute scale of style features in the style image will be the same as the absolute scale of transferred style features in the generated image. Multi-scale generation allows you to decouple these; by tuning the multiscale schedule, you can select features from the style image at an arbitrary scale, and render them at an arbitrary scale in the generated image. The other benefit is speed: you don't need to run many iterations at the high resolutions. The example I posted takes about 5 minutes to generate on a Pascal Titan X.

For fun, here's another example using Compostion VII as the style:

[xpeng]

Great improvement! can this Multi-Scale tech be used on fast-neural-style?

[crasse2]

gorgeous result here ! awesome

[jcjohnson]

@xpeng There is a paper on arXiv from a few days ago explaining how to apply this multi-scale tech to fast-neural-style:

https://arxiv.org/abs/1612.01895

I haven't implemented it yet, but I'd expect it to give similarly good results.

[xpeng]

@jcjohnson , oh thanks! works explosion!

[jcjohnson]

I'm happy to announce that neural-style now supports multiple GPUs!

The multi-GPU implementation splits the VGG loss network so that different layers are computed on different GPUs; this allows you to process very large images. On my desktop with two Titan X, I can create images up to about 2800px in width; on a server with four Titan X I can create images up to about 3600px in width. Here's an example:

To use multiple GPUs you pass a comma-separated list to the -gpu flag, and also give a flag -multigpu_strategy giving a comma-separated list of layer indices at which to split the network.

To achieve this I've also implemented a couple of other fixes, including a more memory-efficient method of computing Gram matrices and exposing the nCorrection parameter of the L-BFGS algorithm as a command-line flag.

Getting good results at high resolutions is a bit tricky: you need to use multiscale generation, and for multigpu you may need to tune the -multigpu_strategy flag for your workload; in addition for the very highest resolutions you need to use a small value for -lbfgs_num_correction to avoid a ton of memory usage in the L-BFGS cache variables; you also need to disable cudnn autotuning since it uses a ton of auxillary memory.

To demonstrate these tricks, check out this script:

https://github.com/jcjohnson/neural-style/blob/multi-gpu/examples/multigpu_scripts/starry_stanford.sh

which was used to generate the 3620px Starry Stanford result on a quad Titan X server.

[ProGamerGov]

@jcjohnson With the new update, are the Spatial Control, Colour Control, and Luminance-only transfer features described by the, "Controlling Perceptual Factors in Neural Style Transfer" research paper, also added into Neural-Style? Or just support for multiple GPUs?

[jcjohnson]

This update only adds multi-GPU support; the example script shows how to use neural-style for scale control as described in the paper.