NOTE: Make sure you also see this post that has a summary of all the Text-to-Image scripts supported by Visions of Chaos with example images.
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”
“H R Giger”
“seascape oil painting”
“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”
“H R Giger”
“seascape oil painting”
“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”
“H R Giger”
“seascape oil painting”
“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.
You do need a GPU with lots of VRAM for these to work (especially the 512×512 image models).
NOTE: Make sure you also see this post that has a summary of all the Text-to-Image scripts supported by Visions of Chaos with example images.
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”
“Rainforest”
“night club”
“seascape painting”
“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”
“rainforest”
“night club”
“seascape painting”
“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”
“rainforest”
“night club”
“seascape painting”
“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.
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.
To best see the differences between the algorithms I recommend you open the x4 zoomed images in new tabs and switch between them.
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 single images or batch process a directory of images.
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”
Here are results from “disturbing flesh”. These are like early David Cronenberg nightmare visuals.
A suggestion from @MatthewKafker on Twitter “spatially ambiguous water lillies painting”
“stormy seascape”
After experimenting with acrylic pour painting in the past I wanted to see what BigSleep could generate from “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.
More from “david lynch visuals” but these are more portraits. The famous hair comes through.
“H.R.Giger”
“metropolis”
“surrealism”
“colorful surrealism”
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”.
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.
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.
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.
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.
PyTorch StyleGAN2 ADA
Using NVIDIA’s official PyTorch implentation from here. Also easy to get working. You can quickly generate images from existing models.
Metropolitan Museum of Art Faces – NVIDIA – metfaces.pkl
Trypophobia – Sid Black – trypophobia.pkl
Alfred E Neuman – Unknown – AlfredENeuman24_ADA.pkl
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.
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.
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.
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.
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.
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.
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.
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”.
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.
This cellular automaton comes from Matthew Guay who describes it in this post on r/cellular_automata on Reddit. There was no name given for these CAs so I have called them “Rule Table Cellular Automata” for my implementation in Visions of Chaos.
The usual behavior for a cellular automata with more than 2 states is that a living (state 1) cell that dies does not become a dead (state 0) cell immediately. Instead the cell goes through a refractory dying period. In a 5 state automata such as this one a state 1 cell that dies would first go through states 2 to 4 each step before finally disappearing and leaving a state 0 empty cell. Using the rule table described below this does not always happen. A cell in a refractory period can suddenly turn back into an alive cell or any other state. This opens up a much wider variety of possible results.
This CA uses a rule table to determine how the cells update. It is a 5 state CA with rules like the following
The current cell state (5 states so cell values are between 0 and 4) is shown down the left hand side. Depending on how many state 1 neighbor cells the current cell has determines the new state value.
For example, for that rule table, if a cell has a state of 3 and has 5 neighbor cells that are state 1, then the next state for the cell will be 2. Take the 4th row down for state 3, then go across until you find count 5, then use that column value for the new cell state.
Matthew also uses C and A characters.
“C” means “all states not already shown in this row”. For the 0 state row only count 4 is specified. The C in count 0 column means any cell that does not have 4 neighbor cells becomes state 0.
“A” means all possible count values. So with the above table, any cell that is in state 4 becomes state 0.
To make it easier, compare the above rule table to a state lookup arrays as follows. This is basically what I construct internally for the CA to use as the CA runs. After playing with the rules a while having the GUI interface be a grid as follows would be much easier to use and easier to understand at a glance. Maybe the idea of using C and A to reduce complexity of displaying the rules makes it more complicated to read? Anyway, I do show the rule table as above to match the original.
State 0 [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
State 1 [2,2,2,2,2,2,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
State 2 [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3]
State 3 [4,4,4,2,2,2,2,1,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4]
State 4 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
That shows the 27 possible results (0 to 26 neighbors) for each cell state. Count a cell’s 26 neighbors and use that count as an index to the new state.
Results
As with all new CA rules the first challenge is finding some good examples within the usual vast search space. Seeing as I have not found a way to detect interesting rules looking for new rules comes down to repeatedly trying random rules hoping for a visually pleasing result. After experimenting with so many CA types over the years I am used to this random process by now. Put a movie on to watch as I repeatedly try random setups. Save the ones that show potential and then manually tweak them to see if anything really interesting happens.
Here is a compilation of interesting rules I found so far.
Availability
If you want to experiment with these CAs yourself they are now included with Visions of Chaos.
After 4D cellular automata the next logical step was to another dimension and see what 5D cellular automata can do.
If you are familiar with lesser dimension CAs then 5D is just an additional value in the cell arrays. 3D uses [X,Y,Z], 4D uses [X,Y,Z,W], and for 5D you use [X,Y,Z,W,V]. 5D extends the number of immediate Moore neighbors of each cell to 242 (3^5-1) (4D has 80, 3D has 26).
The settings dialog gets even more checkbox chock-a-block as follows.
Looping through the additional dimension makes calculating these 5D CAs much slower than 4D and lesser dimension CAs to process. I was able to go up to 50x50x50x50x50 sized arrays, but beyond that was too slow for my patience.
Coloring these CAs use the same methods as the 4D cellular automata. The only change is for the “4D density” display method. Rather than using the density of the 4th dimension to show a cell color, the 5D version uses the density of both the 4th and 5th array dimensions for color.
I have not found any really interesting 5D CA rules yet. Because they are so much slower and the search space is so vast, trying multiple random rules really needs to fluke it to find an interesting result. For now here is a simple example starting from a single active cell. Click the image to watch a short animated GIF.
5D CAs are now available in Visions of Chaos. If you do happen to find any interesting 5D CA rules, let me know. I asked the same for 3D and 4D and got no responses, but who knows, maybe you reading this now will be the one to find a bunch of new and interesting rules for higher dimension cellular automata. Stay tuned for a YouTube sample movie once I get enough interesting 5D rules.
Softology's Blog 