Text-to-Image Summary

What Are Text-to-Image Systems

Text-to-Image systems/models/scripts/networks (what is the official correct term for these?) are machine learning based models that take a descriptive phrase as input and attempt to generate images that match the input phrase. No other training is required by the end user.

Requirements

You do need a decent NVIDIA GPU. 3090 recommended for 512×512 resolution, 2080 for smaller 256×256 images, 10xx possibly for tiny images or if you want to try reduced settings and wait ages for results.

To run these scripts from Visions of Chaos you need to have installed these prerequisites.

If you want to run these scripts yourself outside Visions of Chaos I have included links to the original scripts/colabs/githubs.

To make these scripts easier to use I have added a GUI front end in Visions of Chaos. Once you get all the prerequisites setup it really is as simple as typing your prompt text and clicking a button. I do include a lot of other settings so you can tweak the script parameters as you do more experimentation.

Text-to-Image GUI

Text-to-Image Scripts Included With Visions of Chaos

The rest of this blog post lists the 21 (so far) Text-to-Image colabs and githubs that I have been able to edit to work under Python 1.8 and Visions of Chaos.

If you are the author of one of these scripts then many thanks to you for sharing the code publicly. If you are a creator of a script I do not include here, please leave a comment with a link or send me an email so I can try it out. If you are a better coder than I am and improve any of these also let me know and I will share your fixes with the world.

I have included a few sample image outputs from each script. Each of these sample images is generated at the default settings from Visions of Chaos at the maximum supported resolution of 512×512. The displayed times are for a single image at 512×512 resolution running on a 3090 RTX GPU.

Note also that these samples all use the default settings for GAN and CLIP models. Most of the included scripts allow tweaking of settings and different models to alter the outputs. There is a much wider range of output images possible. Download Visions of Chaos and get hooked on the endless fascination of trying different input phrases.


Name: Deep Daze
Author: Phil Wang
Original script: https://github.com/lucidrains/deep-daze
Time: 2 minutes 3 seconds.
Description: This is the first Text-to-Image script I ever found and tested. It tends to give washed out pastel shaded images (I do include an option to deepen the colors, so untweaked results are even more washed out that these are).

'H R Giger' Deep Daze Text-to-Image
H R Giger

'surrealism' Deep Daze Text-to-Image
surrealism

'rainforest' Deep Daze Text-to-Image
rainforest


Name: Big Sleep
Author: Phil Wang
Original script: https://github.com/lucidrains/big-sleep
Time: 4 minutes 0 seconds
Description: I still consider Big Sleep to be the best Text-to-Image system I have tried so far. It always gives a good variety of images for any prompt text and does not suffer from the coloring or tiled image issues some of the other methods do. If I only had one of these to choose from it would be Big Sleep. That is why it is still the default script in Visions of Chaos. See here for my older post with a lot of Big Sleep examples.

'H R Giger' Big Sleep Text-to-Image
H R Giger

'surrealism' Big Sleep Text-to-Image
surrealism

'colorful surrealism' Big Sleep Text-to-Image
colorful surrealism


Name: CLIP-GLaSS
Author: Frederico Galatolo
Original script: https://github.com/galatolofederico/clip-glass
Time: 4 minutes 51 seconds
Description: This one is different. Difficult to get it to output anything resembling the input. Rather than slowly converge to the final image it seems to jump around a lot, or maybe I converted something wrong. Needs a closer look when I get more time.

'H R Giger' CLIP-GLaSS Text-to-Image
H R Giger


Name: VQGAN+CLIP z-quantize
Author: Katherine Crowson
Original script: https://colab.research.google.com/drive/1L8oL-vLJXVcRzCFbPwOoMkPKJ8-aYdPN
Time: 2 minutes 28 seconds
Description: The outputs tend to be divided up into rectangular regions, but the resulting imagery can be interesting.

'H R Giger' VQGAN+CLIP z-quantize Text-to-Image
H R Giger

'seascape painting' VQGAN+CLIP z-quantize Text-to-Image
seascape painting

'flowing water' VQGAN+CLIP z-quantize Text-to-Image
flowing water

VQGAN+CLIP z-quantize allows specifying an image as the input starting point. If you take the output, stretch it very slightly, and then feed it back into the system each frame you get a movie zooming in. For this movie I used SRCNN Super Resolution to double the resolution of the frames and then Super Slo-Mo for optical flow frame interpolation (both SRCNN and Super Slo-Mo are included with Visions of Chaos). The VQGAN model was “vqgan_imagenet_f16_16384” and the CLIP model was “ViT-B/32”. The prompts were the seven deadly sins, ie “a watercolor painting depicting pride”, “a watercolor painting depicting greed” etc.

The more astute viewers among you will notice there are only 6 of the sins in the previous video. What happened to “lust”? A while back one of my uploads was flagged as porn by the YouTube robots. Their (what I assume is) machine learning based system detected my upload as porn when there was no porn in it. An appeal was met with instant denial and so I now have a permanent “warning” on my channel with no way to talk to a person who could spend 1 minute looking at the video to tell it isn’t porn. Another warning would lead to a strike, so I am being overly cautious and omitting the lust part from the YouTube video. Those who want to see the full 7 part movie can click the following link to watch it on my LBRY channel.

https://open.lbry.com/@Softology:5/Seven-Deadly-Sins:6

Thanks LBRY!


Name: VQGAN+CLIP codebook
Author: Katherine Crowson
Original script: https://colab.research.google.com/drive/15UwYDsnNeldJFHJ9NdgYBYeo6xPmSelP
Time: 3 minutes 19 seconds
Description: VQGAN-CLIP codebook seem to give very similar images for the same prompt phrase, so repeatedly running the script (with different seed values) does not give a wide variety of resulting images. Still gives interesting results.

'H R Giger' VQGAN+CLIP codebook Text-to-Image
H R Giger

'seascape painting' VQGAN+CLIP codebook Text-to-Image
seascape painting

'flowing water' VQGAN+CLIP codebook Text-to-Image
flowing water


Name: Aleph2Image Gamma
Author: Ryan Murdock
Original script: https://colab.research.google.com/drive/1VAO22MNQekkrVq8ey2pCRznz4A0_jY29
Time: 2 minutes 1 second
Description: This one seems to evolve white blotches that grow and take over the entire image. Before the white out stage the images tend to have too much contrast. Previous results from Deep Daze were too washed out, this one is too “contrasty”. If they could both be pushed towards that “sweet spot” they would both look much better.

'H R Giger' Aleph2Image Gamma Text-to-Image
H R Giger

'surrealism' Aleph2Image Gamma Text-to-Image
surrealism

'seascape painting' Aleph2Image Gamma Text-to-Image
seascape painting


Name: Aleph2Image Delta
Author: Ryan Murdock
Original script: https://colab.research.google.com/drive/1oA1fZP7N1uPBxwbGIvOEXbTsq2ORa9vb
Time: 2 minutes 1 second
Description: A newer revision of Aleph2Image that doesn’t have the white out issues. The resulting images have much more vibrant colors and that may be a good or bad point depending on your preferences.

'H R Giger' Aleph2Image Delta Text-to-Image
H R Giger

'surrealism' Aleph2Image Delta Text-to-Image
surrealism

'seascape painting' Aleph2Image Delta Text-to-Image
seascape painting


Name: Aleph2Image Delta v2
Author: Ryan Murdock
Original script: https://colab.research.google.com/drive/1NGM9L8qP0gwl5z5GAuB_bd0wTNsxqclG
Time: 3 minutes 42 seconds
Description: A newer revision of Aleph2Image Delta that gives much sharper results. The resulting images tend to be similar to each other for each prompt text so not a lot of variety.

'H R Giger' Aleph2Image Delta v2 Text-to-Image
H R Giger

'surrealism' Aleph2Image Delta v2 Text-to-Image
surrealism

'seascape painting' Aleph2Image v2 Delta Text-to-Image
seascape painting


Name: Deep Daze Fourier
Author: Vadim Epstein
Original script: https://colab.research.google.com/gist/afiaka87/e018dfa86d8a716662d30c543ce1b78e/text2image-siren.ipynb
Time: 4 minutes 54 seconds
Description: Compared to the original Deep Daze that generated washed out and pastel shaded results this Deep Daze Fourier creates images with sharp, crisp bright colors.

'H R Giger' Deep Daze Fourier Text-to-Image
H R Giger

'Shrek eating pizza' Deep Daze Fourier Text-to-Image
Shrek eating pizza

'surrealist Homer Simpson' Deep Daze Fourier Text-to-Image
surrealist Homer Simpson


Name: Text2Image v2
Author: Denis Malimonov
Original script: https://colab.research.google.com/github/tg-bomze/collection-of-notebooks/blob/master/Text2Image_v2.ipynb
Time: 1 minute 48 seconds
Description: This one is good. Colors and details are sharp. Good variety of output for each input phrase. Definitely worth a try. Gives the original Big Sleep a challenge for the best system shown here.

'H R Giger' Text2Image v2 Text-to-Image
H R Giger

'surrealism' Text2Image v2 Text-to-Image
surrealism

'seascape painting' Text2Image v2 Text-to-Image
seascape painting


Name: The Big Sleep Customized
Author: NMKD
Original script: https://colab.research.google.com/drive/1Q2DIeMqYm_Sc5mlurnnurMMVqlgXpZNO
Time: 1 minute 45 seconds
Description: Another good one. Worth exploring further.

'H R Giger' The Big Sleep Customized Text-to-Image
H R Giger

'surrealism' The Big Sleep Customized Text-to-Image
surrealism

'seascape painting' The Big Sleep Customized Text-to-Image
seascape painting


Name: Big Sleep Minmax
Author: @!goose
Original script: https://colab.research.google.com/drive/12CnlS6lRGtieWujXs3GQ_OlghmFyl8ch
Time: 1 minute 45 seconds
Description: Another interesting Big Sleep variation. Allows a second phrase to be specified that is minimized in the output. For example if your prompt for a landscape painting has too many clouds you could specify clouds as the minimize prompt so the system outputs less clouds in the resulting image.

'H R Giger' Big Sleep Minmax Text-to-Image
H R Giger

'surrealism' Big Sleep Minmax Text-to-Image
surrealism

'seascape painting' Big Sleep Minmax Text-to-Image
seascape painting


Name: CLIP Pseudo Slime Mold
Author: hotgrits
Original script: https://discord.com/channels/729741769192767510/730484623028519072/850857930881892372
Time: 2 minutes 57 seconds
Description: This one gives unique output compared to the others. Really nicely defined sharp details. The colors come from any color palette you select (currently all the 3,479 palettes within Visions of Chaos can be used) so you can “tint” the resulting images with color shades you prefer.

'H R Giger' CLIP Pseudo Slime Mold Text-to-Image
H R Giger

'H R Giger' CLIP Pseudo Slime Mold Text-to-Image
H R Giger with a different color palette

'Shrek eating pizza' CLIP Pseudo Slime Mold Text-to-Image
Shrek eating pizza

'seascape painting' CLIP Pseudo Slime Mold Text-to-Image
seascape painting


Name: Aleph2Image Dall-E Remake
Author: danielrussruss
Original script: https://colab.research.google.com/drive/17ZSyxCyHUnwI1BgZG22-UFOtCWFvqQjy
Time: 3 minutes 42 seconds
Description: Another Aleph2Image variant.

'H R Giger' Aleph2Image Dall-E Remake Text-to-Image
H R Giger

'surrealism' Aleph2Image Dall-E Remake Text-to-Image
surrealism

'seascape painting' Aleph2Image Dall-E Remake Text-to-Image
seascape painting


Name: VQGAN+CLIP v3
Author: Eleiber
Original script: https://colab.research.google.com/drive/1go6YwMFe5MX6XM9tv-cnQiSTU50N9EeT
Time: 2 minutes 52 seconds
Description: The best of the VQGAN systems so far. “v3” because it is the third VQGAN system I have tried and it didn’t have a unique specific name. Gives clear sharp images. Can give very painterly results with visible brush strokes if you use “a painting of” before the prompt subject.

'H R Giger' VQGAN+CLIP v3 Text-to-Image
H R Giger

'surrealism' VQGAN+CLIP v3 Text-to-Image
surrealism

'seascape painting' VQGAN+CLIP v3 Text-to-Image
seascape painting

'flowing water' VQGAN+CLIP v3 Text-to-Image
flowing water

VQGAN+CLIP v3 allows specifying an image as the input starting point. If you take the output and repeatedly use it as the input with some minor image stretching each frame you can get a movie zooming into the Text-to-Image output. For this movie I used SRCNN Super Resolution to double the resolution of the frames and then Super Slo-Mo for optical flow frame interpolation (both SRCNN and Super Slo-Mo are included with Visions of Chaos). The VQGAN model was “vqgan_imagenet_f16_16384” and the CLIP model was “ViT-B/32”.


Name: VQGAN+CLIP v4
Author: crimeacs
Original script: https://colab.research.google.com/drive/1ZAus_gn2RhTZWzOWUpPERNC0Q8OhZRTZ
Time: 2 minutes 37 seconds
Description: Another improved VQGAN system utilizing pooling. “v4” because it is the forth VQGAN system I have tried and it didn’t have a unique specific name.

'H R Giger' VQGAN+CLIP v4 Text-to-Image
H R Giger

'surrealism' VQGAN+CLIP v4 Text-to-Image
surrealism

'rainforest' VQGAN+CLIP v4 Text-to-Image
rainforest

'clouds at sunset' VQGAN+CLIP v4 Text-to-Image
clouds at sunset

'snowy mountain landscape' VQGAN+CLIP v4 Text-to-Image
snowy mountain landscape

VQGAN+CLIP v4 allows specifying an image as the input starting point. If you take the output and repeatedly use it as the input with some minor image stretching each frame you can get a movie zooming into the Text-to-Image output. For this movie I used SRCNN Super Resolution to double the resolution of the frames and then Super Slo-Mo for optical flow frame interpolation (both SRCNN and Super Slo-Mo are included with Visions of Chaos). The VQGAN model was “vqgan_imagenet_f16_16384” and the CLIP model was “ViT-B/32”.

The text prompts for each part came from an idea in a YouTube comment to try more non-specific terms to see what happens, so here are the results of “an image of fear”, “an image of humanity”, “an image of knowledge”, “an image of love”, “an image of morality” and “an image of serenity”.

Here is another example. This time using the prompt of various directors, ie “Stanley Kubrick imagery”, “David Lynch imagery” etc. No super resolution this time. Super Slo-Mo was used for optical flow. I wasn’t sure if YouTube would accept the potentially unsettling horror visuals and I do not want to risk the hassle of a strike, so being on the safe side I am hosting this one on my LBRY channel only. Click the following image to open the movie in a new window. Note that LBRY can be a lot slower to buffer, so you may need to pause it for a while to let the movie load in.

Directors Text-to-Image

If you find that too slow to buffer/load I also have a copy on my BitChute channel here.


Name: VQGAN Gumbel
Author: Eleiber
Original script: https://colab.research.google.com/drive/1tim3xTsZXafK-A2rOUsevckdl4OitIiw
Time: 3 minutes 27 seconds
Description: Variation using the gumbel-8192 model. Results are a bit rougher than others.

'H R Giger' VQGAN Gumbel Text-to-Image
H R Giger

'surrealism' VQGAN Gumbel Text-to-Image
surrealism

'rainforest' VQGAN Gumbel Text-to-Image
rainforest


Name: OpenAI DVAE+CLIP
Author: Katherine Crowson
Original script: https://colab.research.google.com/drive/10DzGECHlEnL4oeqsN-FWCkIe_sq3wVqt
Time: 3 minutes 07 seconds
Description: Results are very colorful and more abstract. By default it gives more noisy output images but this can be disabled if you prefer.

'H R Giger' OpenAI DVAE+CLIP Text-to-Image
H R Giger

'surrealism' OpenAI DVAE+CLIP Text-to-Image
surrealism

'rainforest' OpenAI DVAE+CLIP Text-to-Image
rainforest


Name: Aphantasia
Author: Vadim Epstein
Original script: https://github.com/eps696/aphantasia
Time: 4 minutes 35 seconds
Description: Different and more abstract output to the other scripts. Does allow images at 1280×720 resolution on a 3090 GPU.

H R Giger
H R Giger

Surrealism
surrealism

Rainforest
rainforest


Name: Text2Image VQGAN
Author: Vadim Epstein
Original script: https://colab.research.google.com/github/eps696/aphantasia/blob/master/CLIP_VQGAN.ipynb
Time: 6 minutes 19 seconds
Description: Allows larger sized 480p images (854×480) on a 3090 GPU.

H R Giger
H R Giger

Surrealism
surrealism

Rainforest
rainforest


Name: MSE VQGAN+CLIP z+quantize
Author: jbustter
Original script: https://colab.research.google.com/drive/1gFn9u3oPOgsNzJWEFmdK-N9h_y65b8fj
Time: 6 minutes 19 seconds
Description: Awesome crisp results. Allows larger sized 480p images (854×480) on a 3090 GPU. One of the best scripts in this list worth exploring.

H R Giger
H R Giger

surrealism
surrealism

dense rainforest
dense rainforest

cumulonimbus clouds at sunset
cumulonimbus clouds at sunset

a hyperrealistic cyberpunk cityscape
a hyperrealistic cyberpunk cityscape

snowy mountain landscape
snowy mountain landscape

hyperrealistic homer simpson
hyperrealistic homer simpson

space cat
space cat

homer simpson as painted by beksinski
homer simpson as painted by beksinski

MSE VQGAN+CLIP z+quantize allows specifying an image as the input starting point. If you take the output and repeatedly use it as the input with some minor image stretching each frame you can get a movie zooming into the Text-to-Image output. No blending of frames or optical flow for this one, just straight combining of the 854×480 resolution frames into a movie. The VQGAN model was “vqgan_imagenet_f16_16384” and the CLIP model was “ViT-B/32”. The prompts for this movie were “hyperrealistic homer simpson”, “hyperrealistic marge simpson”, “hyperrealistic bart simpson”, “hyperrealistic lisa simpson” and “hyperrealistic maggie simpson”. The original 480p upload was badly compressed and looked terrible after YouTube compressed it, so I upscaled the 480p to 2160p (4K) in DaVinci Resolve and reuploaded to YouTube. This caused their compression to do a better encoding job so the movie is now watchable.

This next example is how MSE VQGAN+CLIP z+quantize interprets various common human phobias. Text prompts were “a hyperrealistic painting depicting acrophobia” etc. To try and smooth out the “flickering” when zooming I started using ImageMagick for zooming. ImageMagick allows sub pixel image resizing options. This movie was also originally 480p and upsized to 4K in Davinci Resolve before uploading.


Visions of Chaos Text-to-Image Tutorial

You can watch the following tutorial video to get an idea of how the Text-to-Image mode works in Visions of Chaos.


Getting these CLIP based Text-to-Image scripts working under Python 1.8

I have seen people thinking that CLIP will not work under the latest Python 1.8. It will (at least as far as the CLIP functionality required to get these Text-to-Image systems working).
If you get an error about “RuntimeError: Method ‘forward’ is not defined.” then add jit=Flase to the clip.load command.
ie change


clip.load('ViT-B/32')

into


clip.load('ViT-B/32',jit=False)

Then CLIP seems to work fine with Python 1.8.
All of the Text-to-Image systems in this post are working fine under Python 1.8 using the latest CLIP with only that single change.



Deterministic Results Impossible?

Setting the random seed does not seem to work with these systems.

Even if you declare


import numpy as np
np.random.seed(args.seed)
import random
random.seed(args.seed)
torch.use_deterministic_algorithms(True)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False 

The line


torch.use_deterministic_algorithms(True)

sets torch to use deterministic functions (may be slower), but when this is set other CUDA based routines complain that they have no deterministic version so the scripts fail to run.

If anyone works out a way to get these scripts to be deterministic (ie multiple runs with the same seed give identical outputs) let me know.



Using These Scripts Outside Visions of Chaos

If you want to see the changes I made to the scripts or want to run the scripts from a command line, see the links to the original code above, or you can see my edits of the scripts under the folder


C:\Users\YOURUSERNAME\AppData\Roaming\Visions of Chaos\Examples\MachineLearning\Text To Image\

once Visions of Chaos is installed.

They can all be run from the command line. To see example command lines for each script you can run them once in Visions of Chaos. The command line will be shown in the progress dialog box. That will allow you to copy/paste the command(s) into a command prompt window if you do not want the GUI front end.

If you do not have a powerful enough GPU you can always resort to running them in the colabs linked to above.



Any Others I Missed?

Do you know of any other colabs and/or github Text-to-Image systems I have missed? Let me know and I will see if I can convert them to work with Visions of Chaos for a future release. If you know of any public Discords with other colabs being shared let me know too.

Jason.

Deep Daze Fourier Text-to-Image

More Fascinating Text-to-Image

This time “Deep Daze Fourier” from Vadim Epstein. Code available in this notebook.

Compared to the last Deep Daze that generated washed out and pastel shaded results this Deep Daze creates images with sharp, crisp bright colors.

Sample results

“Shrek eating pizza”

Deep Daze Fourier - Shrek Eating Pizza

Deep Daze Fourier - Shrek Eating Pizza

Deep Daze Fourier - Shrek Eating Pizza

Deep Daze Fourier - Shrek Eating Pizza

“H R Giger”

Deep Daze Fourier - H R Giger

Deep Daze Fourier - H R Giger

Deep Daze Fourier - H R Giger

Deep Daze Fourier - H R Giger

“Freddy Krueger”

Deep Daze Fourier - Freddy Krueger

Deep Daze Fourier - Freddy Krueger

Deep Daze Fourier - Freddy Krueger

Deep Daze Fourier - Freddy Krueger

“Surrealist Homer Simpson”

Deep Daze Fourier - Surrealist Homer Simpson

Deep Daze Fourier - Surrealist Homer Simpson

Deep Daze Fourier - Surrealist Homer Simpson

Deep Daze Fourier - Surrealist Homer Simpson

“rose bush”

Deep Daze Fourier - Rose Bush

Deep Daze Fourier - Rose Bush

Deep Daze Fourier - Rose Bush

Deep Daze Fourier - Rose Bush

Availability

This and the previous Text-to-Image systems I have experimented with (here, here and here) are now supported by a GUI front end in Visions of Chaos. As long as you install these prerequisites and have a decent GPU you will be able to run these systems yourself.

Text-to-Image GUI

For those who love to tinker I have now added a bunch more of the script parameters so you no longer have to edit the Python source code outside Visions of Chaos.

Other Text-to-Image

If you know of any other Text-to-Image systems (with sharable open-source code) then please let me know. All of the Text-to-Image systems I have tested so far all have their own unique behaviors and outputs so I will always be on the lookout for more new variations.

Jason.

Aleph2Image Text-to-Image

Previously I experimented with Big Sleep and other Text-to-Image systems.

This post covers variations of Aleph2Image Text-to_Image. Originally coded by Ryan Murdock.


Aleph2Image “Gamma”

Code from this colab. This one seems to evolve white blotches that grow and take over the entire image. Before the white out stage the images tend to have too much contrast. Previous results from Deep Daze were too washed out, this one is too “contrasty”. If they could both be pushed towards that “sweet spot” they would both look much better.

“surrealism”

Aleph2Image Gamma - Surrealism

Aleph2Image Gamma - Surrealism

Aleph2Image Gamma - Surrealism

Aleph2Image Gamma - Surrealism

“H R Giger”

Aleph2Image Gamma - H R Giger

Aleph2Image Gamma - H R Giger

Aleph2Image Gamma - H R Giger

Aleph2Image Gamma - H R Giger

“seascape oil painting”

Aleph2Image Gamma - Seascape Oil Painting

Aleph2Image Gamma - Seascape Oil Painting

Aleph2Image Gamma - Seascape Oil Painting

Aleph2Image Gamma - Seascape Oil Painting

“frogs in the rain”

Aleph2Image Gamma - Frogs In The Rain

Aleph2Image Gamma - Frogs In The Rain

Aleph2Image Gamma - Frogs In The Rain

Aleph2Image Gamma - Frogs In The Rain


Aleph2Image “Delta”

Code from this colab. A newer revision of Aleph2Image that doesn’t have the white out issues. The resulting images have much more vibrant colors.

“surrealism”

Aleph2Image Delta - Surrealism

Aleph2Image Delta - Surrealism

Aleph2Image Delta - Surrealism

Aleph2Image Delta - Surrealism

“H R Giger”

Aleph2Image Delta - H R Giger

Aleph2Image Delta - H R Giger

Aleph2Image Delta - H R Giger

Aleph2Image Delta - H R Giger

“seascape oil painting”

Aleph2Image Delta - Seascape Oil Painting

Aleph2Image Delta - Seascape Oil Painting

Aleph2Image Delta - Seascape Oil Painting

Aleph2Image Delta - Seascape Oil Painting

“frogs in the rain”

Aleph2Image Delta - Frogs In The Rain

Aleph2Image Delta - Frogs In The Rain

Aleph2Image Delta - Frogs In The Rain

Aleph2Image Delta - Frogs In The Rain


Improved Aleph2Image “Delta” v2

Code from this colab. A newer revision of Aleph2Image Delta that gives much better results, although the results tend to be similar to each other for each prompt text. This and Big Sleep would be the best 2 Text-to-Image systems I have experimented with so far.

“surrealism”

Aleph2Image Delta v2 - Surrealism

Aleph2Image Delta v2 - Surrealism

Aleph2Image Delta v2 - Surrealism

Aleph2Image Delta v2 - Surrealism

“H R Giger”

Aleph2Image Delta v2 - H R Giger

Aleph2Image Delta v2 - H R Giger

Aleph2Image Delta v2 - H R Giger

Aleph2Image Delta v2 - H R Giger

“seascape oil painting”

Aleph2Image Delta v2 - Seascape Oil Painting

Aleph2Image Delta v2 - Seascape Oil Painting

Aleph2Image Delta v2 - Seascape Oil Painting

Aleph2Image Delta v2 - Seascape Oil Painting

“frogs in the rain”

Aleph2Image Delta v2 - Frogs In The Rain

Aleph2Image Delta v2 - Frogs In The Rain

Aleph2Image Delta v2 - Frogs In The Rain

Aleph2Image Delta v2 - Frogs In The Rain


Easy GUI Front End

I include a simple GUI dialog front end for these Text-to-Image systems in Visions of Chaos. As long as you have the prerequisites installed you will be able to convert text prompts into single or multiple images.

Text-to-Image GUI

You do need a GPU with lots of VRAM for these to work (especially the 512×512 image models).

Jason.

Further Explorations Into Text-to-Image Machine Learning

After my initial experiments with Big Sleep Text-to-Image generation I looked around for some more examples to play with. I was really impressed with Big Sleep and you can see some examples of Big Sleep output in that original post. I still think Big Sleep is the best Text-to-Image code I have used so far and better than what is in this post.


Deep Daze

Deep Daze is by Phil Wang and the source code is available here.

Deep Daze tends to generate collage-like images. As the first example image shows the resulting images have a washed out or faded look. I put the rest of the example Deep Daze images through a quick Auto White Balance pass in GIMP.

“H R Giger”

DeepDaze - H R Giger

DeepDaze - H R Giger

“Rainforest”

DeepDaze - Rainforest

“night club”

DeepDaze - Night Club

“seascape painting”

DeepDaze - Seascape Painting

“flowing water”

DeepDaze - Flowing Water


VQGAN-CLIP z+quantize

VQGAN-CLIP using a z+quantize method is from Katherine Crowson. Source code is available here.

This method also has the option to use an image to seed the initial model rather than just random noise, but the following examples were all seeded with noise. The resulting images tend to be divided up into rectangular regions, but the resulting imagery is interesting.

“H R Giger”

VQGAN-CLIP z+quantize - H R Giger

VQGAN-CLIP z+quantize - H R Giger

VQGAN-CLIP z+quantize - H R Giger

VQGAN-CLIP z+quantize - H R Giger

“rainforest”

VQGAN-CLIP z+quantize - Rainforest

VQGAN-CLIP z+quantize - Rainforest

VQGAN-CLIP z+quantize - Rainforest

VQGAN-CLIP z+quantize - Rainforest

“night club”

VQGAN-CLIP z+quantize - Night Club

VQGAN-CLIP z+quantize - Night Club

VQGAN-CLIP z+quantize - Night Club

VQGAN-CLIP z+quantize - Night Club

“seascape painting”

VQGAN-CLIP z+quantize - Seascape Painting

VQGAN-CLIP z+quantize - Seascape Painting

VQGAN-CLIP z+quantize - Seascape Painting

VQGAN-CLIP z+quantize - Seascape Painting

“flowing water”

VQGAN-CLIP z+quantize - Flowing Water

VQGAN-CLIP z+quantize - Flowing Water

VQGAN-CLIP z+quantize - Flowing Water

VQGAN-CLIP z+quantize - Flowing Water


VQGAN-CLIP codebook

VQGAN-CLIP using a codebook method is also from Katherine Crowson. Source code is available here.

VQGAN-CLIP codebook seem to give very similar images for different seeds, so I have only shown two examples for each phrase.

“H R Giger”

VQGAN-CLIP codebook - H R Giger

VQGAN-CLIP codebook - H R Giger

“rainforest”

VQGAN-CLIP codebook - Rainforest

VQGAN-CLIP codebook - Rainforest

“night club”

VQGAN-CLIP codebook - Night Club

VQGAN-CLIP codebook - Night Club

“seascape painting”

VQGAN-CLIP codebook - Seascape Painting

VQGAN-CLIP codebook - Seascape Painting

“flowing water”

VQGAN-CLIP codebook - Flowing Water

VQGAN-CLIP codebook - Flowing Water


Other Text-to-Image Models?

If you know of any other available Text-to-Image systems (that are freely available and shareable) let me know.


Availability

You can follow the above links and download the Python code yourself if you are so inclined.

I do include a basic GUI front-end for these Text-to-Image generators in Visions of Chaos. As long as you have the prerequisites installed (which you would need to install to run these outside Visions of Chaos) then you can experiment with these models yourself without needing to use the command line.

Text-to-Image GUI

Jason.

Super Resolution

The Dream

For years now you would have seen scenes in TV shows like CSI or movies like Blade Runner the “enhance” functionality of software that allows details to be enhanced in images that are only a blur or a few pixels in size. In Blade Runner, Deckard’s system even allowed him to look around corners.

The Reality

I have recently been testing machine learning neural network enhancers (aka super resolution) models. They resize an image while trying to maintain or enhance details without losing detail (or with losing a lot less detail than if the image was zoomed with an image editing tool using linear or bicubic zoom).

Some of my results with these models follows. I am using the following test image from here.

Unprocessed Test Image

To best see the differences between the algorithms I recommend you open the x4 zoomed images in new tabs and switch between them.

SRCNN – Super-Resolution Convolutional Neural Network

To see the original paper on SRCNN, click here.
I am using the PyTorch script by Mirwaisse Djanbaz here.

SRCNN x4

SRCNN x4

SRRESNET

To see the original paper on SRRESNET, click here.
I am using the PyTorch script by Sagar Vinodababu here.

SRRESNET x4

SRRESNET x4

SRGAN – Super Resolution Generative Adversarial Network

To see the original paper on SRGAN, click here.
I am using the PyTorch script by Sagar Vinodababu here.

SRGAN x4

SRGAN x4

ESRGAN – Enhanced Super Resolution Generative Adversarial Network

I am using the PyTorch script by Xintao Wang et al here.

ESRGAN x4

ESRGAN x4

PSNR

I am using the PyTorch script by Xintao Wang et al here.

PSNR x4

PSNR x4

Differences

Each of the algorithms gives different results. For an unknown source image it would probably be best to run it through them all and then see which gives you the best result. These are not the Hollywood or TV enhance magic fix just yet.

If you know of any other PyTorch implementations of super resolution I missed, let me know.

Availability

You can follow the links to the original GitHub repositories to get the software, but I have also added a simple GUI front end for these scripts in Visions of Chaos. That allows you to try the above algorithms on any image you like.

Jason.

Text-to-Image Machine Learning

Text-to-Image

Input a short phrase or sentence into a neural network and see what image it creates.

I am using Big Sleep from Phil Wang (@lucidrains).

Phil used the code/models from Ryan Murdock (@advadnoun). Ryan has a blog post explaining the basics of how all the parts connect up here. Ryan has some newer Text-to-Image experiments but they are behind a Patreon paywall, so I have not played with them. Hopefully he (or anyone) releases the colabs publicly sometime in the future. I don’t want to experiment with a Text-to-Image system that I cannot share with everyone, otherwise it is just a tease.

The most simple explanation is that BigGAN generates images that try to satisfy CLIP which rates how closely the image matches the input phrase. BigGAN creates an image and CLIP looks at it and says “sorry, that does not look like a cat to me, try again”. As each repeated iteration is performed BigGAN gets better at generating an image that matches the desired phrase text.

Big Sleep Examples

Big Sleep uses a seed number which means you can have thousands/millions of different outputs for the same input phrase. Note there is an issue with the seed not always being able to create the same images though. From my testing, even with the torch_deterministic flag set to True and setting the CUDA envirnmental variable does not help. Every time Big Sleep is called it will generate a different image with the same seed. That means you will never be able to reproduce the same output in the future.

These images are 512×512 pixels square (the largest resolution Big Sleep supports) and took 4 minutes each to generate on an RTX 3090 GPU. The same code takes 6 minutes 45 seconds per image on an older 2080 Super GPU.

Also note that these are the “cherry picked” best results. Big Sleep is not going to create awesome art every time. For these examples or when experimenting with new phrases I usually run a batch of multiple images and then manually select the best 4 or 8 to show off (4 or 8 because that satisfies one or two tweets).

To start, these next four images were created from the prompt phrase “Gandalf and the Balrog”

Big Sleep - Gandalf and the Balrog

Big Sleep - Gandalf and the Balrog

Big Sleep - Gandalf and the Balrog

Big Sleep - Gandalf and the Balrog

Here are results from “disturbing flesh”. These are like early David Cronenberg nightmare visuals.

Big Sleep - Disturbing Flesh

Big Sleep - Disturbing Flesh

Big Sleep - Disturbing Flesh

Big Sleep - Disturbing Flesh

A suggestion from @MatthewKafker on Twitter “spatially ambiguous water lillies painting”

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

Big Sleep - Spatially Ambiguous Water Lillies Painting

“stormy seascape”

Big Sleep - Stormy Seascape

Big Sleep - Stormy Seascape

Big Sleep - Stormy Seascape

Big Sleep - Stormy Seascape

After experimenting with acrylic pour painting in the past I wanted to see what BigSleep could generate from “acrylic pour painting”

Big Sleep - Acrylic Pour Painting

Big Sleep - Acrylic Pour Painting

Big Sleep - Acrylic Pour Painting

Big Sleep - Acrylic Pour Painting

I have always enjoyed David Lynch movies so let’s see what “david lynch visuals” results in. This one got a lot of surprises and worked great. These images really capture the feeling of a Lynchian cinematic look. A lot of these came out fairly dark so I have tweaked exposure in GIMP.

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

More from “david lynch visuals” but these are more portraits. The famous hair comes through.

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

Big Sleep - David Lynch Visuals

“H.R.Giger”

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

Big Sleep - H.R.Giger

“metropolis”

Big Sleep - Metropolis

Big Sleep - Metropolis

Big Sleep - Metropolis

Big Sleep - Metropolis

“surrealism”

Big Sleep - Surrealsim

Big Sleep - Surrealsim

Big Sleep - Surrealsim

Big Sleep - Surrealsim

“colorful surrealism”

Big Sleep - Colorful Surrealsim

Big Sleep - Colorful Surrealsim

Big Sleep - Colorful Surrealsim

Big Sleep - Colorful Surrealsim

Availability

I have now added a simple GUI front end for Big Sleep into Visions of Chaos, so once you have installed all the pre-requisites you can run these models on any prompt phrase you feed into them. The following images shows Big Sleep in the process of generating an image for the prompt text “cyberpunk aesthetic”.

Text-to-Image GUI

After spending a lot of time experimenting with Big Sleep over the last few days, I highly encourage anyone with a decent GPU to try these. The results are truly fascinating. This page says at least a 2070 8GB or greater is required, but Martin in the comments managed to generate a 128×128 image on a 1060 6GB GPU after 26 (!!) minutes.

Jason.

Adding PyTorch support to Visions of Chaos

TensorFlow 2

Recently after getting a new 3090 GPU I needed to update TensorFlow to version 2. Going from TensorFlow version 1 to TensorFlow version 2 had way too many code breaking changes for me. Looking at other github examples for TensorFlow 2 code (eg an updated Style Transfer script) gave me all sorts of errors. Not just one git repo either, lots of supposed TensorFlow 2 code would not work for me. If it is a pain for me it is going to be a bigger annoyance for my users. I already get enough emails saying “I followed your TensorFlow instructions exactly, but it doesn’t work”. I am in no way an expert in Python, TensorFlow or PyTorch, so I need something that for most of the time “just works”.

I did manage to get the current TensorFlow 1 scripts in Visions of Chaos running under TensorFlow 2, so at least the existing TensorFlow functionality will still work.

PyTorch

After having a look around and watching some YouTube videos I wanted to give PyTorch a go.

The install is one pip command they build for you on their home page after you select OS, CUDA, etc. So for my current TensorFlow tutorial (maybe I now need to change that to “Machine Learning Tutorial”) all I needed to do was add 1 more line to the pip install section.


pip install torch==1.8.1+cu111 torchvision==0.9.1+cu111 torchaudio===0.8.1 -f https://download.pytorch.org/whl/torch_stable.html

PyTorch Style Transfer

First Google hit is the PyTorch tutorial here. After spending most of a day banging my head against the wall with TensorFlow 2 errors, that single self contained Python script using PyTorch “just worked”! The settings do seem harder to tweak to get a good looking output compared to the previous TensorFlow Style Transfer script I use. After making the following examples I may need to look for another PyTorch Style Transfer script.

Here are some example results using Biscuit as the source image.

Biscuit

Biscuit Style Transfer

Biscuit Style Transfer

Biscuit Style Transfer

Biscuit Style Transfer

PyTorch DeepDream

Next up was ProGamerGov’s PyTorch DeepDream implementation. Again, worked fine. I have used ProGamerGov‘s TensorFlow DeepDream code in the past and it worked just as well this time. It gives a bunch of other models to use too, so more different DeepDream outputs for Visions of Chaos are now available.

Biscuit DeepDream

Biscuit DeepDream

Biscuit DeepDream

Biscuit DeepDream

PyTorch StyleGAN2 ADA

Using NVIDIA’s official PyTorch implentation from here. Also easy to get working. You can quickly generate images from existing models.

StyleGAN2 ADA

Metropolitan Museum of Art Faces – NVIDIA – metfaces.pkl

StyleGAN2 ADA

Trypophobia – Sid Black – trypophobia.pkl

StyleGAN2 ADA

Alfred E Neuman – Unknown – AlfredENeuman24_ADA.pkl

StyleGAN2 ADA

Trypophobia – Sid Black – trypophobia.pkl

I include the option to train your own models from a bunch of images. Pro tip: if you do not want to have nightmares do not experiment with training a model based on a bunch of naked women photos.

Going Forward

After these early experiments with PyTorch, I am going to use PyTorch from now on wherever possible.

Jason.

TensorFlow 2 and RTX 3090 Performance

A Pleasant Surprise

Just in time for when 3090 GPUs started to become available again in Sydney I was very generously gifted the funds to finally purchase a new GeForce RTX 3090 for my main development PC. After including a 1000 Watt power supply the total cost came to around $4000 AUD ($3000 USD). Such a rip off.

GeForce RTX™ 3090 GAMING X TRIO 24G

The card itself is really heavy and solid. They include a bracket to add support to help it not sag over time which is a nice touch. Like all recent hardware parts it lights up in various RGB colors and shades. These RGB rigs are going to look so out of date once this fad goes away. After upgrading my PC parts over the last few years I now have PCs that flash and blink more than my Christmas tree does when fully setup and lit.

Who needs a Christmas tree?

Not So Fast

I naively assumed that a quick GPU swap would give me the boost in performance that previous GPU upgrades did (like when I upgraded to the 1080 and then to the 2080 Super). Not this time. I ran a few quick machine learning TensorFlow (version 1) tests from Visions of Chaos and the result was either the Python scripts ran extremely slow (around 10x to 30x SLOWER) or they just crashed. So much for a simple upgrade for more power.

Turns out the Ampere architecture the 3090 GPUs use is only supported by CUDA 11.0 or higher. After updating CUDA, cuDNN, all the various Python libraries and the Python scripts I was back to where I was before the upgrades. If you have been through the tedious process of installing TensorFlow before for Visions of Chaos, you will need to follow my new instructions to get TensorFlow version 2 support. Updating TensorFlow v1 code to TensorFlow v2 code is a pain. From now on I am going to use PyTorch scripts for all my machine learning related needs.

High Temperatures

These newer GPUs can run hot. Under 100% load (when I was doing a Style Transfer movie with repeated frames being calculated one after the other) the 3090 peaks around 80 degrees C (176 F). I do have reasonable cooling in the case, but the air being blown out is noticeably hot. The 2080 running the same test peaks around 75 degrees.

The 2080 and my older 1080 seem to push all the hot exhaust air out the rear vents of the card, but the 3090 has no rear exhaust so all the hot air goes directly into the case. I can only assume this is due to them not being able to handle all that heat going “through” the card and out the back, so it needs to just vent that heat anywhere it can. This means if the card is running hot a lot of hot air goes straight into the case. When I touched the side of the case next to the GPU it was very warm.

Apparently 80 and under is perfectly fine and safe for a GPU, but they would say that wouldn’t they. They would be bragging about low temps if they could manufacture cooler running cards.

After some experimenting with Afterburner I lowered the temp limit from the GPU default of 83 degrees down to 75 degrees. This resulted in more throttling but only a slight performance hit (style transfer took 1 minute 21 seconds rather than 1 minute 14 seconds). The case was noticeably cooler and the average temp was now down to a much more chilly 65 degrees. Afterburner allows tweaking (overclocking/underclocking) of your GPU, but the most useful feature is its graphing capabilities to see what is really going on. You can monitor temperatures and throttling as you run complex GPU operations.

Extra Cooling

I wanted to see if more case fans would help, so I removed the current 3 stock case fans and installed 6 of these fans (2 sucking in at the front, 3 blowing out at the top, and 1 blowing out at the rear of the case). My silent PC is no longer silent. I set the GPU back to its default profile with a temp limit of 83 degrees and started another Style Transfer movie to keep the GPU pegged as close to 100% usage as possible for an extended period of time. Watching the temp graph in Afterburner shows peaks still up to 76 degrees, but much less throttling with the core clock graph around 95% to 100% maximum possible MHz when running so that results in a better overall performance.

After a week the extra noise annoyed me too much though so I replaced the Gamdias fans with Corsair fans. 6 of these fans and one of these controllers. Setting the fans to the default “quiet” profile gets the noise back down to near silent sound levels. When I start a machine learning batch run the temp sensors detect the increased heat in the case and ramp up the fans to compensate. Watching Afterburner graphs shows they may even be slightly better at cooling than the Gamdias fans. The problem with the auto-adjust speed control is that there is this noticeable ramping up and down of the fan speeds as they compensate for temp changes all the time (not just when the GPU is 100%). That was more annoying than always on full speed fans. After some adjustments and tests with the excellent Corsair software I settled on a custom temp curve that only cranked up as necessary when I start full 100% GPU load processing. Once the GPU usage drops back to normal the fans ramp down and are silent again.

Power Usage

Using one of those cheap inline watt meters shows the PC pulls 480 watts when the GPU is at 100% usage. Afterburner reports the card using around 290 watts under full load.

I have basically been using the 3090 24 hours a day training and testing machine learning setups since I bought it. 3 weeks with the 3090 usage made my latest quarterly electricity bill go up from $284 to $313. That works out to roughly $1.40 a day to power the GPU full time. If you can afford the GPU you should be able to afford the cost of powering it.

Final Advice

When experimenting with one of these newer GPUs use all the monitoring you need to make sure the card is not overheating and throttling performance. Afterburner is great to setup a graph showing GPU temp, usage, MHz and power usage. Monitor levels when the GPU is under 100% load and over an extended period of time.

Temperature controlled fans like the Corsair Commander Pro setup can work as a set and forget cooling solution once you tweak a custom temp curve that suits your usage and hardware.

Final Opinion

Was it worth spending roughly three times the cost of the 2080 on the 3090? No, definitely not. These current over inflated priced GPUs are not worth the money. But if you need or want one you have to pay the price. If the prices were not so artificially inflated and they sold at the initial recommended retail prices then it would be a more reasonable price (still expensive, but not ridiculously so).

After testing the various GPU related modes in Visions of Chaos, the 3090 is only between 10% to 70% faster than the 2080 Super depending on what GPU calculations are being made, and more often on the slower end of that scale. OpenGLSL shader performance is a fairly consistent speed boost between 10% and 15%.

The main reason I wanted the 3090 was for the big jump in VRAM from 8GB to 24GB so I am now able to train and run larger machine learning models without the dreaded out of memory errors. StyleGAN2 ADA models are the first things I have now successfully been able to train.

StyleGAN2 ADA - Alfred E Neuman

Upgrading the 1080 in my older PC to the 2080 Super is a big jump in performance and allows me to run less VRAM intensive sessions. Can you tell I am trying to convince myself this was a good purchase? I just expected more. Cue the “Ha ha, you idiot! Serves you right for not researching first.” comments.

Jason.

GPU accelerated Root-Finding Fractals

See this post for my previous explorations of Root-Finding Fractals.

A while back I implemented a Custom Formula Editor in Visions of Chaos. The Custom Formula Editor allows users of Visions of Chaos to program their own fractal formulas which run on their GPUs for much faster performance than when using the CPU for calculations.

One of my hopes for coding the custom editor was that users of Visions of Chaos would make their own formulas and share them with me to include in future releases.

Recently I was contacted by Dr Bernd Frassek who was working with Root-Finding Fractals. See here for more of Dr Frassek’s information about these root-finding methods. For an English version see this Google translated version. Being much more of a mathematician than I am, he was able to implement a lot more root-finding methods that I had never experimented with or even heard of. The total count of methods for finding roots went from 4 in my previous version to 23 in the new mode.

With some more testing and a bit of back and forth emails we were able to get the code working and the end result is a new GPU accelerated Root-Finding Fractals mode in Visions of Chaos. You can find this new mode under “Mode->Fractals->Root-Finding Fractals 2”. All of the formulas, methods, coloring and orbit trap settings from the older Root-Finding Fractals mode have been migrated to the new mode.

If you are interested in coding these sort of fractals yourself you can see the latest GLSL shader source code (as of the 8th of March, 2021) by clicking here.

You can also check the “Show shader code” checkbox in the Root-Finding Settings dialog which will cause Visions of Chaos to show you the generated shader code before rendering the fractal image.

Here is a sample movie showing some results from the new mode.

This next movie uses orbit traps.

If you have any other formulas or root-finding methods that you would like to see implemented let me know. The structure of the shader allows new formulas and root-finding methods to be added relatively easily.

Jason.

Even more explorations with Multiple Neighborhoods Cellular Automata

History

If you are not aware what Multiple Neighborhoods Cellular Automata (aka MNCA) are, you can refer to this post and this post for some history.

Multiple Neighborhoods Cellular Automata were created by Slackermanz (see his Reddit history or his GitHub repository).

The basic principal of these cellular automata is to have multiple neighborhoods (usually in circular and/or toroidal shapes) of different sizes that are used to determine the next state of each cell in the grid. Using these more complicated neighborhoods has lead to these fascinating examples of cellular automata beyond the usual simpler versions of cellular automata I usually see or experiment with.

New Discoveries

Two years have passed since those first two blog posts. I saw Slackermanz was still generating new versions of MNCA. He shared a bunch (over 11,000) of his shaders he created as he continues to experiment with MNCA. It only took a little coding to write a converter that massaged his shaders into a format that Visions of Chaos supported. I spent a few days going through these examples and whittled it down to 162 of the “best of the best” MNCA shaders in my opinion. Here is a sample movie showing some of the newer MNCA results.

The shaders that were used for creating the above movie are included with Visions of Chaos under the “Mode->OpenGL Shading Language->Shader Editor” mode as the GLSL shaders starting with “Cellular automaton”.

Multi-scale Multiple Neighborhoods Cellular Automata

During some of his recent developments Slackermanz started to get results that look similar to Multi-scale Turing Patterns (MSTP). I find these results are more interesting with much finer structures that evolve and change more than with MSTP. MSTP tend to reach a relative stable state after a while, the small structures stabilize and only the larger sized shapes pulsate. Compare MSTP to the following example of multi-scale multiple neighborhood cellular automata (MSMNCA?)

The first 3 minutes and 20 seconds are Slackermanz original multi-scale shaders. The next 3 minutes and 20 seconds are those same shaders “zoomed in” by multiplying the neighborhood sizes by 4. The last minute are examples of the very latest experiments with using the multi-scale principals.

The shaders that were used for creating the above movie are included with Visions of Chaos under the “Mode->OpenGL Shading Language->Shader Editor” mode as the GLSL shaders starting with “Cellular automaton”.

To see the shader code than generates the multi-scale image thumbnail for the video, click here.

New Shaders Part 1

After that bunch of shaders the ever prolific Slackermanz shared another set of his new shaders with me.

To see an example shader used in the above movie click here. The only difference between the movie parts are the 32 e0 array parameters in the shader at line 141. Otherwise the shader code remains the same for all movie parts.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 2

Click here to see the shader that makes the first part of the above movie. All other parts use the same shader, only altering the 32 float values of the ubvn array at line 156.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 3

I did say Slackermanz was prolific. Here is another set of samples from his latest work.

Click here to see the shader that makes the first part of the above movie. All other parts use the same shader, only altering the 32 float values of the ubvn array at line 138.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 4

Slackermanz is not a slacker man and shared another bunch of new shaders. Here is another sample movie showing some of the latest MNCA results.

Click here to see the shader code that makes these results. The only part of the shader code that changes between the examples is the 32 float values of the ubvn array at line 136.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 5

These next bunch of Slackermanz shaders include a bit of color shading that helps bring out more of the structures within the blobs and other shapes.

See here to see the shader code that makes these results. Note that this shader code has more commenting than the above shaders so if the earlier ones didn’t make any sense this one may help. The only part of the shader code that changes between the movie examples is the 32 float values of the ubvn array at line 107.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 6

These MNCA shaders continue to be impressively intriguing with new and unique features in each new version.

See here to see the shader code that makes these results. The only part of the shader code that changes between the movie examples is the 52 float values of the ubvn array at line 117. Yes, 52 parameters in these newer shaders compared to the 32 parameters of the above examples.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 7

Another new MNCA shader from Slackermanz.

See here to see the shader code that makes these results. The only part of the shader code that changes between the movie examples is the 52 float values of the ubvn array at line 117.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 8

New MNCA variations.

See here to see the shader code that makes these results. The only part of the shader code that changes between the movie examples is the 52 float values of the ubvn array at line 117.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 9

More absorbing and intriguing (thanks Thesaurus.com) examples.

See here to see the shader code that makes these results. The only part of the shader code that changes between the movie examples is the 52 float values of the ubvn array at line 117.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 10

More compelling and appealing (thanks Thesaurus.com) examples.

See here to see the shader code that makes these results. The only part of the shader code that changes between the movie examples is the 52 float values of the ubvn array at line 117.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 11

More beautiful and astonishing (thanks Thesaurus.com) examples.

See here to see the shader code that makes these results. The only part of the shader code that changes between the movie examples is the 52 float values of the ubvn array at line 117.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 12

The parts in the following movie came from a few different shaders so no specific code this time. If you are curious you can see the shader code within Visions of Chaos when you open the preset/sample MCA files that are listed in the description of the video.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

New Shaders Part 13

The final sample movie for now. The parts in the following movie came from a few different shaders so no specific code this time. If you are curious you can see the shader code within Visions of Chaos when you open the preset/sample MCA files that are listed in the description of the video.

These MNCA are included with Visions of Chaos under the “Mode->Cellular Automata->2D->Multiple Neighborhoods Cellular Automata 2” mode.

Variations of MNCA in Visions of Chaos

The above movies show only a tiny subset of all the MNCA examples Slackermanz has experimented with. There are thousands more variations of MNCA included with Visions of Chaos to explore.

Enough With The MNCA Movies Already!

Yes, there were a lot of Multiple Neighborhoods Cellular Automata movies in this post that I have been uploading to my YouTube channel lately.

Each of the movies in order of uploading show the steps and evolution that Slackermanz went through while creating these cellular automata. Each movie is a selection of samples from one of his MNCA shaders (code links after each movie). They are all unique, or at least I have tried to pick the best unique results from each batch to create the sample movies that show off what each of the shaders can do.

These discoveries deserve to be seen by more people, especially people interested in cellular automata.

The Same As Other CA Types?

Yes, you may see structures that look like Stephan Rafler’s SmoothLife, Kellie Evans’ Larger Than Life and/or Bert Chan’s Lenia (see also here), but the techniques and components found in the construction of MNCA are unique and individual and were developed outside academia separately from the previous linked papers.

Jason.