Skip to main content
Home
Browse packagesDocsSign in
This release is 136 versions behind 0.168.1 — the latest version of @stsoftware/neat-ai. Jump to latest

@stsoftware/neat-ai@0.121.0
Built and signed on GitHub Actions

stSoftwareAU/NEAT-AI

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

This package works with Deno
This package works with Deno
JSR Score
94%
Published
5 months ago (0.121.0)
Package root>test>Evolve.ts
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146
import { assert, fail } from "jsr:@std/assert@^1.0.8";
import { Creature } from "../src/Creature.ts";
import { Mutation } from "../src/NEAT/Mutation.ts";
import { createBackPropagationConfig } from "../src/propagate/BackPropagation.ts";
import { SparseConfig } from "../src/propagate/sparse/SparseConfig.ts";

((globalThis as unknown) as { DEBUG: boolean }).DEBUG = true;

// Compact form: name and function
Deno.test("AND", async () => {
  // Train the AND gate
  const trainingSet = [
    { input: [0, 0], output: [0] },
    { input: [0, 1], output: [0] },
    { input: [1, 0], output: [0] },
    { input: [1, 1], output: [1] },
  ];

  const creature = new Creature(2, 1);

  const results = await creature.evolveDataSet(trainingSet, {
    mutation: Mutation.FFW,
    elitism: 10,
    mutationRate: 0.5,
    log: 1,
    targetError: 0.03,
    threads: 1,
  });

  assert(results.error <= 0.03, "Error rate was: " + results.error);
});

Deno.test("evolve-MT", async () => {
  // Train the AND gate
  const trainingSet = [
    { input: [0, 0], output: [0] },
    { input: [0, 1], output: [0] },
    { input: [1, 0], output: [0] },
    { input: [1, 1], output: [1] },
  ];

  const creature = new Creature(2, 1);

  const results = await creature.evolveDataSet(trainingSet, {
    mutation: Mutation.FFW,
    elitism: 10,
    mutationRate: 0.5,
    targetError: 0.03,
    threads: 1,
  });

  assert(results.error <= 0.03, "Error rate was: " + results.error);
});

Deno.test("XOR-evolve", async () => {
  // Train the XOR gate
  const trainingSet = [
    { input: [0, 0], output: [0] },
    { input: [0, 1], output: [1] },
    { input: [1, 0], output: [1] },
    { input: [1, 1], output: [0] },
  ];

  let results = { error: 0 };
  for (let attempt = 0; attempt < 10; attempt++) {
    const creature = new Creature(2, 1);
    results = await creature.evolveDataSet(trainingSet, {
      mutation: Mutation.FFW,
      elitism: 10,
      mutationRate: 0.5,
      targetError: 0.03,
      threads: 1,
      iterations: 10_000,
    });

    if (results.error <= 0.03) break;
    console.info("Attempt", attempt, "failed with error", results.error);
  }

  assert(results.error <= 0.03, "Error rate was: " + results.error);
});

Deno.test("booleanXOR", async () => {
  // Train the XOR gate
  const trainingSet = [
    { input: [0, 0], output: [0] },
    { input: [0, 1], output: [1] },
    { input: [1, 0], output: [1] },
    { input: [1, 1], output: [0] },
  ];

  let creature = new Creature(2, 1);
  let results = { error: 1 };
  for (let attempt = 0; attempt < 30; attempt++) {
    creature.validate();
    results = await creature.evolveDataSet(trainingSet, {
      mutation: Mutation.FFW,
      elitism: 10,
      mutationRate: 0.5,
      targetError: 0.025,
      threads: 1,
      iterations: 1000,
    });

    creature.validate();
    if (results.error <= 0.03) break;
    creature = new Creature(2, 1);
  }
  assert(results.error <= 0.03, "Error rate was: " + results.error);
  const sparseConfig = new SparseConfig(
    creature.exportJSON(),
    createBackPropagationConfig({}),
  );
  const value =
    creature.activateAndTrace(new Float32Array([1, 0]), false, sparseConfig)[0];

  assert(value > 0.65, "Should be more than 0.65 was: " + value);
});

Deno.test("XNOR - evolve", async () => {
  const trainingSet = [
    { input: [0, 0], output: [1] },
    { input: [0, 1], output: [0] },
    { input: [1, 0], output: [0] },
    { input: [1, 1], output: [1] },
  ];

  for (let attempt = 0; true; attempt++) {
    const creature = new Creature(2, 1);
    const results = await creature.evolveDataSet(trainingSet, {
      targetError: 0.05,
      iterations: 20_000,
      enableRepetitiveTraining: true,
    });

    if (results.error > 0.05) {
      if (attempt < 24) {
        console.info(`attempt: ${attempt}`, results);
        continue;
      } else {
        fail(`Error rate was: ${results.error}`);
      }
    }
    break;
  }
});