NEAT Neural Network for DenoJS

This project is a unique implementation of a neural network based on the NEAT (NeuroEvolution of Augmenting Topologies) algorithm, written in DenoJS using TypeScript.

Feature Highlights

1. Extendable Observations: The observations can be extended over time as the indexing is done via UUIDs, not numbers. This prevents the need to restart the evolution process as new observations are added, providing flexibility and scalability.

2. Distributed Training: Training and evolution can be run on multiple independent nodes. The best-of-breed creatures can later be combined on a centralized controller node. This feature allows for distributed computing and potentially faster training times, enhancing the efficiency of the learning process.

3. Life Long Learning: Unlike many pre-trained neural networks, this project is designed for continuous learning, making it adaptable and potentially more effective in changing environments. This feature ensures the model remains relevant and accurate over time.

4. Efficient Model Utilization: Once trained, the current best model can be utilized efficiently by calling the activate function. This allows for quick and easy deployment of the trained model.

5. Unique Squash Functions: The neural network supports unique squash functions such as IF, MAX and MIN. These functions provide more options for the activation function, which can lead to different network behaviours, offering a wider range of potential solutions. More about Activation Functions.

6. Neuron Pruning: Neurons whose activations don’t vary during training are removed, and the biases in the associated neurons are adjusted. This feature optimizes the network by reducing redundancy and computational load. More about Pruning (Neural Networks).

7. CRISPR: Allows injection of genes into a population of creatures during evolution. This feature can introduce new traits and potentially improve the performance of the population. More about CRISPR.

8. Grafting: If parents aren’t “genetically compatible”, then the “grafting” algorithm from one parent to another parent onto the child will be used. This allows for species from islands to interbreed.

9. Memetic Evolution: The algorithm can now record and utilize the biases and weights of the fittest creatures to fine-tune future generations. This process, inspired by the concept of memes, allows the system to “remember” and build upon successful traits, enhancing the evolutionary process. Learn more about Memetic Algorithms.

10. Error-Guided Structural Evolution: Dynamically identifies and creates new synapses by analyzing neuron activations and errors. This targeted structural adaptation improves performance by explicitly reducing neuron-level errors, blending evolutionary topology adjustments with error-driven learning.

    Note: Error-Guided Structural Evolution requires the NEAT-AI-Discovery Rust extension library to be built and installed. The discovery process will gracefully skip if the Rust library is not available, but discovery functionality requires it.

11. Visualization

12. Discovery Integration Guide: Step-by-step instructions for running discovery via Creature.discoveryDir() are available in the DiscoveryDir guide.

Usage

This project is designed to be used in a DenoJS environment. Please refer to the DenoJS documentation for setup and usage instructions.

Discovery Integration

Discovery is now documented in detail in docs/DiscoveryDir.md. The guide covers data preparation, orchestration patterns, and safe-write practices for Creature.discoveryDir().

Enabling the Rust Discovery Module

The Rust FFI extension shipped via NEAT-AI-Discovery provides the accelerated structural hints used by discoveryDir(). To enable it:

1. Clone the repository alongside this project and build the library:

   git clone https://github.com/stSoftwareAU/NEAT-AI-Discovery.git
   cd NEAT-AI-Discovery
   cargo build --release

2. Expose the compiled artefact to Deno by either copying it into ~/.cargo/lib or exporting an explicit path:

   export NEAT_AI_DISCOVERY_LIB_PATH="/absolute/path/to/NEAT-AI-Discovery/target/release/libneat_ai_discovery.$(uname | tr '[:upper:]' '[:lower:]' | sed 's/darwin/dylib/;s/linux/so/;s/windows/dll/')"

3. Grant FFI permissions and validate the installation:

   deno run --allow-env --allow-ffi --allow-read scripts/check_discovery.ts

4. In your application, guard discovery calls with isRustDiscoveryEnabled() so that controllers fail fast when the module is unavailable.

When the library cannot be resolved, set NEAT_RUST_DISCOVERY_OPTIONAL=true in environments where skipping discovery should not abort the worker. Otherwise, treat a missing module as a deployment error and halt the job.

Contributions

Contributions are welcome. Please submit a pull request or open an issue to discuss potential changes/additions.

License

This project is licensed under the terms of the Apache License 2.0. For the full license text, please see LICENSE