Neural-Cellular-Automata

This project involves the creation of a cellular automata model trained using neural networks, which will be hosted online.

Progress so Far

Initial project setup is complete

• Initial versions of the following models of cell perception have been developed (work will be done to make them more efficient)
  • Conway's game of Life
  • LifeLike CA
  • Larger than Life
  • Continuous CA

To Do List

General

• Modularise .js code
• Bigger frame with more cells
• Update template
• explanations for each CA
  • Life
  • Life-like
  • LTL
  • Convolving CA
  • Vec4, Vec16

Model Development (Cell Perception)

• Life
  • Get Running
  • Find some good start state templates (bunnies, stable configurations, gliders, calculator)
  • Implement interactions
    • Pause / play (spacebar)
    • Move forward one frame (full-stop button)
    • change speed while sim is running
    • allow selectable start state templates
    • Change state (click)
  • Place into template
• Life-like CA
  • Implement a couple different basic rule sets
  • find good templates for select ruleset
  • Dynamic shaders, respond to user inputted rule-strings
  • Place into template
• LTL CA
  • Implement wider neighbourhoods: see line 22ish of computeShader.js
  • Figure out what to do with rule strings
  • Insert into template
• Continuous CA
  • Implement 3x3 weighted kernel
  • Implement discrete convolution as shader function
  • Make convolution shader function dynamic (respond to input convolution)
  • Insert into template
• Ltl/Contunuous CA hybridisation
• Vec4 based CA
  • Understand vector convolutions
  • Implement efficient way to pull info from the picture
  • Insert into template
• vec16 based CA (haven't written this out yet)
  • insert into template

Model Training (Cell behaviours)

• WebGPU compatibility with python training code
• Waiting for:
  • continuity
  • convolutions
• ?? Create a training method that allows us to find interesting behaviours on the simple implementation as seen here

Resources

This project is currently using the Notion platform to document project progress and important information. This Notion workspace will be made public at a later point in time.

However, some useful resources for this project include:

• Understanding Cellular Automata (CA)

  • Introduction to Conway's Game of Life
  • Explaining CA
  • What are "Life-Like" CAs

• Implementing CAs

  • Neural Patterns
  • Growing Neural Cellular Automata

• Tutorials for Building CAs

  • Daniel Shiffman's Tutorial
  • Building Conway's Game of Life using WebGPU
  • Physics Simulation with CA

• Other

  • Noita uses CA to make physics simulation
  • "Rule-String" Notation
  • CAs and Computational Systems
  • Emergent Gardens

• WebGPU Resources

  • WebGPU Shader Tips
  • Typescript & WebGPU Examples

• Event Handling in JavaScript

  • HTML DOM Events
  • JavaScript Events
  • Event handling (overview) More resources will be made available in this repo as the project progresses.

Repository Maintenance

We will maintain at most 3 types of branches on the repository for this project. How each branch type will be used is detailed in dev cycles. Details on each branch type are elaborated here:

Main Branch

The branch that is always operational. It contains features that have been tested, are fully functional, and are ready to be seen by the public. As such, this branch is to be treated extremely carefully. Main will only branch to dev, and only dev will merge to main. The reason for this is so we can vet and check everything before anything goes up to main. Pushing straight to main should only be done never.

Dev Branch

This is the branch that hold all things under development. Every time a feature is finished, it will be merged to dev. On dev we then have the chance to do bug fixing and benchmarking. We do all the necessary test to ensure the stuff we upload is genuinely ready.

Feature Branches

These branches are where actual programming occurs. Create a feature branch from main, and name it accordingly. Try to keep it down to one feature per brach, so the git history will clearly outline our development process.

There is a lot of freedom in what you are allowed to do in this branch type, since everything will be vetted when you merge to dev, and more vetting will be done before merging to main. The principle is just try to keep things reasonable and clear.

Dev Cycles

This project will be done in "dev cycles". That's just an outline how we will conduct development and keep everything organised. The general progression of a dev cycle is as follows.

1. Branch a new dev branch from main.
2. Create feature branches from dev, and add your new features.
3. Upon completion, feature branches merge back to dev.
4. Bug testing on dev. These may occur as a result of feature integration.
5. After bug testing (and more benchmarking maybe) is complete, Then Dev should be merged back to main.
6. Dev is archived, and the Dev cycle is complete.