x / 255);
+ let label = training[i].label;
+ let targets = [0, 0, 0];
+ targets[label] = 1;
+ // console.log(inputs);
+ // console.log(targets);
+ nn.train(inputs, targets);
+ }
+}
+
+function testAll(testing) {
+
+ let correct = 0;
+ // Train for one epoch
+ for (let i = 0; i < testing.length; i++) {
+ // for (let i = 0; i < 1; i++) {
+ let data = testing[i];
+ let inputs = Array.from(data).map(x => x / 255);
+ let label = testing[i].label;
+ let guess = nn.predict(inputs);
+
+ let m = max(guess);
+ let classification = guess.indexOf(m);
+ // console.log(guess);
+ // console.log(classification);
+ // console.log(label);
+
+ if (classification === label) {
+ correct++;
+ }
+ }
+ let percent = 100 * correct / testing.length;
+ return percent;
+
+}
diff --git a/examples/neuroevolution-flappybird/bird.js b/examples/neuroevolution-flappybird/bird.js
new file mode 100644
index 0000000..2cccc5b
--- /dev/null
+++ b/examples/neuroevolution-flappybird/bird.js
@@ -0,0 +1,114 @@
+// Daniel Shiffman
+// Nature of Code: Intelligence and Learning
+// https://github.com/shiffman/NOC-S17-2-Intelligence-Learning
+
+// This flappy bird implementation is adapted from:
+// https://youtu.be/cXgA1d_E-jY&
+
+// Mutation function to be passed into bird.brain
+function mutate(x) {
+ if (random(1) < 0.1) {
+ let offset = randomGaussian() * 0.5;
+ let newx = x + offset;
+ return newx;
+ } else {
+ return x;
+ }
+}
+
+class Bird {
+ constructor(brain) {
+ // position and size of bird
+ this.x = 64;
+ this.y = height / 2;
+ this.r = 12;
+
+ // Gravity, lift and velocity
+ this.gravity = 0.8;
+ this.lift = -12;
+ this.velocity = 0;
+
+ // Is this a copy of another Bird or a new one?
+ // The Neural Network is the bird's "brain"
+ if (brain instanceof NeuralNetwork) {
+ this.brain = brain.copy();
+ this.brain.mutate(mutate);
+ } else {
+ this.brain = new NeuralNetwork(5, 8, 2);
+ }
+
+ // Score is how many frames it's been alive
+ this.score = 0;
+ // Fitness is normalized version of score
+ this.fitness = 0;
+ }
+
+ // Create a copy of this bird
+ copy() {
+ return new Bird(this.brain);
+ }
+
+ // Display the bird
+ show() {
+ fill(255, 100);
+ stroke(255);
+ ellipse(this.x, this.y, this.r * 2, this.r * 2);
+ }
+
+ // This is the key function now that decides
+ // if it should jump or not jump!
+ think(pipes) {
+ // First find the closest pipe
+ let closest = null;
+ let record = Infinity;
+ for (let i = 0; i < pipes.length; i++) {
+ let diff = pipes[i].x - this.x;
+ if (diff > 0 && diff < record) {
+ record = diff;
+ closest = pipes[i];
+ }
+ }
+
+ if (closest != null) {
+ // Now create the inputs to the neural network
+ let inputs = [];
+ // x position of closest pipe
+ inputs[0] = map(closest.x, this.x, width, 0, 1);
+ // top of closest pipe opening
+ inputs[1] = map(closest.top, 0, height, 0, 1);
+ // bottom of closest pipe opening
+ inputs[2] = map(closest.bottom, 0, height, 0, 1);
+ // bird's y position
+ inputs[3] = map(this.y, 0, height, 0, 1);
+ // bird's y velocity
+ inputs[4] = map(this.velocity, -5, 5, 0, 1);
+
+ // Get the outputs from the network
+ let action = this.brain.predict(inputs);
+ // Decide to jump or not!
+ if (action[1] > action[0]) {
+ this.up();
+ }
+ }
+ }
+
+ // Jump up
+ up() {
+ this.velocity += this.lift;
+ }
+
+ bottomTop() {
+ // Bird dies when hits bottom?
+ return (this.y > height || this.y < 0);
+ }
+
+ // Update bird's position based on velocity, gravity, etc.
+ update() {
+ this.velocity += this.gravity;
+ // this.velocity *= 0.9;
+ this.y += this.velocity;
+
+ // Every frame it is alive increases the score
+ this.score++;
+ }
+}
\ No newline at end of file
diff --git a/examples/neuroevolution-flappybird/ga.js b/examples/neuroevolution-flappybird/ga.js
new file mode 100644
index 0000000..da9585a
--- /dev/null
+++ b/examples/neuroevolution-flappybird/ga.js
@@ -0,0 +1,87 @@
+// Daniel Shiffman
+// Nature of Code: Intelligence and Learning
+// https://github.com/shiffman/NOC-S17-2-Intelligence-Learning
+
+// This flappy bird implementation is adapted from:
+// https://youtu.be/cXgA1d_E-jY&
+
+
+// This file includes functions for creating a new generation
+// of birds.
+
+// Start the game over
+function resetGame() {
+ counter = 0;
+ // Resetting best bird score to 0
+ if (bestBird) {
+ bestBird.score = 0;
+ }
+ pipes = [];
+}
+
+// Create the next generation
+function nextGeneration() {
+ resetGame();
+ // Normalize the fitness values 0-1
+ normalizeFitness(allBirds);
+ // Generate a new set of birds
+ activeBirds = generate(allBirds);
+ // Copy those birds to another array
+ allBirds = activeBirds.slice();
+}
+
+// Generate a new population of birds
+function generate(oldBirds) {
+ let newBirds = [];
+ for (let i = 0; i < oldBirds.length; i++) {
+ // Select a bird based on fitness
+ let bird = poolSelection(oldBirds);
+ newBirds[i] = bird;
+ }
+ return newBirds;
+}
+
+// Normalize the fitness of all birds
+function normalizeFitness(birds) {
+ // Make score exponentially better?
+ for (let i = 0; i < birds.length; i++) {
+ birds[i].score = pow(birds[i].score, 2);
+ }
+
+ // Add up all the scores
+ let sum = 0;
+ for (let i = 0; i < birds.length; i++) {
+ sum += birds[i].score;
+ }
+ // Divide by the sum
+ for (let i = 0; i < birds.length; i++) {
+ birds[i].fitness = birds[i].score / sum;
+ }
+}
+
+
+// An algorithm for picking one bird from an array
+// based on fitness
+function poolSelection(birds) {
+ // Start at 0
+ let index = 0;
+
+ // Pick a random number between 0 and 1
+ let r = random(1);
+
+ // Keep subtracting probabilities until you get less than zero
+ // Higher probabilities will be more likely to be fixed since they will
+ // subtract a larger number towards zero
+ while (r > 0) {
+ r -= birds[index].fitness;
+ // And move on to the next
+ index += 1;
+ }
+
+ // Go back one
+ index -= 1;
+
+ // Make sure it's a copy!
+ // (this includes mutation)
+ return birds[index].copy();
+}
\ No newline at end of file
diff --git a/examples/neuroevolution-flappybird/index.html b/examples/neuroevolution-flappybird/index.html
new file mode 100755
index 0000000..e540f29
--- /dev/null
+++ b/examples/neuroevolution-flappybird/index.html
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ speed: 1
+
high score: 0
+
all time high score: 0
+
+
+
+
+
+
+
+
+
diff --git a/examples/neuroevolution-flappybird/pipe.js b/examples/neuroevolution-flappybird/pipe.js
new file mode 100644
index 0000000..7ee05d8
--- /dev/null
+++ b/examples/neuroevolution-flappybird/pipe.js
@@ -0,0 +1,58 @@
+// Daniel Shiffman
+// Nature of Code: Intelligence and Learning
+// https://github.com/shiffman/NOC-S17-2-Intelligence-Learning
+
+// This flappy bird implementation is adapted from:
+// https://youtu.be/cXgA1d_E-jY&
+
+class Pipe {
+ constructor() {
+
+ // How big is the empty space
+ let spacing = 125;
+ // Where is th center of the empty space
+ let centery = random(spacing, height - spacing);
+
+ // Top and bottom of pipe
+ this.top = centery - spacing / 2;
+ this.bottom = height - (centery + spacing / 2);
+ // Starts at the edge
+ this.x = width;
+ // Width of pipe
+ this.w = 80;
+ // How fast
+ this.speed = 6;
+ }
+
+ // Did this pipe hit a bird?
+ hits(bird) {
+ if ((bird.y - bird.r) < this.top || (bird.y + bird.r) > (height - this.bottom)) {
+ if (bird.x > this.x && bird.x < this.x + this.w) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // Draw the pipe
+ show() {
+ stroke(255);
+ fill(200);
+ rect(this.x, 0, this.w, this.top);
+ rect(this.x, height - this.bottom, this.w, this.bottom);
+ }
+
+ // Update the pipe
+ update() {
+ this.x -= this.speed;
+ }
+
+ // Has it moved offscreen?
+ offscreen() {
+ if (this.x < -this.w) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
\ No newline at end of file
diff --git a/examples/neuroevolution-flappybird/sketch.js b/examples/neuroevolution-flappybird/sketch.js
new file mode 100644
index 0000000..58fe6f0
--- /dev/null
+++ b/examples/neuroevolution-flappybird/sketch.js
@@ -0,0 +1,179 @@
+// Daniel Shiffman
+// Nature of Code: Intelligence and Learning
+// https://github.com/shiffman/NOC-S18
+
+// This flappy bird implementation is adapted from:
+// https://youtu.be/cXgA1d_E-jY&
+
+// How big is the population
+let totalPopulation = 500;
+// All active birds (not yet collided with pipe)
+let activeBirds = [];
+// All birds for any given population
+let allBirds = [];
+// Pipes
+let pipes = [];
+// A frame counter to determine when to add a pipe
+let counter = 0;
+
+// Interface elements
+let speedSlider;
+let speedSpan;
+let highScoreSpan;
+let allTimeHighScoreSpan;
+
+// All time high score
+let highScore = 0;
+
+// Training or just showing the current best
+let runBest = false;
+let runBestButton;
+
+function setup() {
+ let canvas = createCanvas(600, 400);
+ canvas.parent('canvascontainer');
+
+ // Access the interface elements
+ speedSlider = select('#speedSlider');
+ speedSpan = select('#speed');
+ highScoreSpan = select('#hs');
+ allTimeHighScoreSpan = select('#ahs');
+ runBestButton = select('#best');
+ runBestButton.mousePressed(toggleState);
+
+ // Create a population
+ for (let i = 0; i < totalPopulation; i++) {
+ let bird = new Bird();
+ activeBirds[i] = bird;
+ allBirds[i] = bird;
+ }
+}
+
+// Toggle the state of the simulation
+function toggleState() {
+ runBest = !runBest;
+ // Show the best bird
+ if (runBest) {
+ resetGame();
+ runBestButton.html('continue training');
+ // Go train some more
+ } else {
+ nextGeneration();
+ runBestButton.html('run best');
+ }
+}
+
+
+
+function draw() {
+ background(0);
+
+ // Should we speed up cycles per frame
+ let cycles = speedSlider.value();
+ speedSpan.html(cycles);
+
+
+ // How many times to advance the game
+ for (let n = 0; n < cycles; n++) {
+ // Show all the pipes
+ for (let i = pipes.length - 1; i >= 0; i--) {
+ pipes[i].update();
+ if (pipes[i].offscreen()) {
+ pipes.splice(i, 1);
+ }
+ }
+ // Are we just running the best bird
+ if (runBest) {
+ bestBird.think(pipes);
+ bestBird.update();
+ for (let j = 0; j < pipes.length; j++) {
+ // Start over, bird hit pipe
+ if (pipes[j].hits(bestBird)) {
+ resetGame();
+ break;
+ }
+ }
+
+ if (bestBird.bottomTop()) {
+ resetGame();
+ }
+ // Or are we running all the active birds
+ } else {
+ for (let i = activeBirds.length - 1; i >= 0; i--) {
+ let bird = activeBirds[i];
+ // Bird uses its brain!
+ bird.think(pipes);
+ bird.update();
+
+ // Check all the pipes
+ for (let j = 0; j < pipes.length; j++) {
+ // It's hit a pipe
+ if (pipes[j].hits(activeBirds[i])) {
+ // Remove this bird
+ activeBirds.splice(i, 1);
+ break;
+ }
+ }
+
+ if (bird.bottomTop()) {
+ activeBirds.splice(i, 1);
+ }
+
+ }
+ }
+
+ // Add a new pipe every so often
+ if (counter % 75 == 0) {
+ pipes.push(new Pipe());
+ }
+ counter++;
+ }
+
+ // What is highest score of the current population
+ let tempHighScore = 0;
+ // If we're training
+ if (!runBest) {
+ // Which is the best bird?
+ let tempBestBird = null;
+ for (let i = 0; i < activeBirds.length; i++) {
+ let s = activeBirds[i].score;
+ if (s > tempHighScore) {
+ tempHighScore = s;
+ tempBestBird = activeBirds[i];
+ }
+ }
+
+ // Is it the all time high scorer?
+ if (tempHighScore > highScore) {
+ highScore = tempHighScore;
+ bestBird = tempBestBird;
+ }
+ } else {
+ // Just one bird, the best one so far
+ tempHighScore = bestBird.score;
+ if (tempHighScore > highScore) {
+ highScore = tempHighScore;
+ }
+ }
+
+ // Update DOM Elements
+ highScoreSpan.html(tempHighScore);
+ allTimeHighScoreSpan.html(highScore);
+
+ // Draw everything!
+ for (let i = 0; i < pipes.length; i++) {
+ pipes[i].show();
+ }
+
+ if (runBest) {
+ bestBird.show();
+ } else {
+ for (let i = 0; i < activeBirds.length; i++) {
+ activeBirds[i].show();
+ }
+ // If we're out of birds go to the next generation
+ if (activeBirds.length == 0) {
+ nextGeneration();
+ }
+ }
+}
\ No newline at end of file
diff --git a/examples/neuroevolution-steering/index.html b/examples/neuroevolution-steering/index.html
new file mode 100755
index 0000000..a079f88
--- /dev/null
+++ b/examples/neuroevolution-steering/index.html
@@ -0,0 +1,27 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/examples/neuroevolution-steering/sketch.js b/examples/neuroevolution-steering/sketch.js
new file mode 100644
index 0000000..cb303dc
--- /dev/null
+++ b/examples/neuroevolution-steering/sketch.js
@@ -0,0 +1,123 @@
+// Daniel Shiffman
+// Nature of Code: Intelligence and Learning
+// https://github.com/shiffman/NOC-S17-2-Intelligence-Learning
+
+// Evolutionary "Steering Behavior" Simulation
+
+// An array of vehicles
+let population = [];
+
+// An array of "food"
+let food = [];
+
+// Checkbox to show additional info
+let debug;
+
+// Slider to speed up simulation
+let speedSlider;
+let speedSpan;
+
+// How big is the food?
+let foodRadius = 8;
+// How much food should there?
+let foodAmount = 25;
+// Don't put food near the edge
+let foodBuffer = 50;
+
+
+// How many sensors does each vehicle have?
+let totalSensors = 8;
+// How far can each vehicle see?
+let sensorLength = 150;
+// What's the angle in between sensors
+let sensorAngle = (Math.PI * 2) / totalSensors;
+
+let best = null;
+
+function setup() {
+
+ // Add canvas and grab checkbox and slider
+ let canvas = createCanvas(640, 360);
+ canvas.parent('canvascontainer');
+ debug = select('#debug');
+ speedSlider = select('#speedSlider');
+ speedSpan = select('#speed');
+
+ // Create initial population
+ for (let i = 0; i < 20; i++) {
+ population[i] = new Vehicle();
+ }
+}
+
+function draw() {
+ background(0);
+
+ // How fast should we speed up
+ let cycles = speedSlider.value();
+ speedSpan.html(cycles);
+
+ // Variable to keep track of highest scoring vehicle
+
+ // Run the simulation "cycles" amount of time
+ for (let n = 0; n < cycles; n++) {
+ // Always keep a minimum amount of food
+ while (food.length < foodAmount) {
+ food.push(createVector(random(foodBuffer, width - foodBuffer), random(foodBuffer, height - foodBuffer)));
+ }
+
+ // Eat any food
+ for (let v of population) {
+ v.eat(food);
+ }
+
+ // Go through all vehicles and find the best!
+ let record = -1;
+ for (let i = population.length - 1; i >= 0; i--) {
+ let v = population[i];
+ // Eat the food (index 0)
+ v.think(food);
+ v.update(food);
+
+ // If the vehicle has died, remove
+ if (v.dead()) {
+ population.splice(i, 1);
+ } else {
+ // Is it the vehicles that has lived the longest?
+ if (v.score > record) {
+ record = v.score;
+ best = v;
+ }
+ }
+ }
+
+ // If there is less than 20 apply reproduction
+ if (population.length < 20) {
+ for (let v of population) {
+ // Every vehicle has a chance of cloning itself according to score
+ // Argument to "clone" is probability
+ let newVehicle = v.clone(0.1 * v.score / record);
+ // If there is a child
+ if (newVehicle != null) {
+ population.push(newVehicle);
+ }
+ }
+ }
+ }
+
+ // Draw all the food
+ for (let i = 0; i < food.length; i++) {
+ fill(100, 255, 100, 200);
+ stroke(100, 255, 100);
+ ellipse(food[i].x, food[i].y, foodRadius * 2);
+ }
+
+ // Highlight the best if in debug mode
+ if (debug.checked()) {
+ best.highlight();
+ }
+
+ // Draw all the vehicles
+ for (let v of population) {
+ v.display();
+ }
+}
diff --git a/examples/neuroevolution-steering/vehicle.js b/examples/neuroevolution-steering/vehicle.js
new file mode 100644
index 0000000..c866a40
--- /dev/null
+++ b/examples/neuroevolution-steering/vehicle.js
@@ -0,0 +1,241 @@
+// Daniel Shiffman
+// Nature of Code 2018
+// https://github.com/shiffman/NOC-S18
+
+// Evolutionary "Steering Behavior" Simulation
+
+
+// Mutation function to be passed into Vehicle's brain
+function mutate(x) {
+ if (random(1) < 0.1) {
+ let offset = randomGaussian() * 0.5;
+ let newx = x + offset;
+ return newx;
+ } else {
+ return x;
+ }
+}
+
+// This is a class for an individual sensor
+// Each vehicle will have N sensors
+class Sensor {
+ constructor(angle) {
+ // The vector describes the sensor's direction
+ this.dir = p5.Vector.fromAngle(angle);
+ // This is the sensor's reading
+ this.val = 0;
+ }
+}
+
+// This is the class for each Vehicle
+class Vehicle {
+ // A vehicle can be from a "brain" (Neural Network)
+ constructor(brain) {
+
+ // All the physics stuff
+ this.acceleration = createVector();
+ this.velocity = createVector();
+ this.position = createVector(random(width), random(height));
+ this.r = 4;
+ this.maxforce = 0.1;
+ this.maxspeed = 4;
+ this.minspeed = 0.25;
+ this.maxhealth = 3;
+
+ // This indicates how well it is doing
+ this.score = 0;
+
+ // Create an array of sensors
+ this.sensors = [];
+ for (let angle = 0; angle < TWO_PI; angle += sensorAngle) {
+ this.sensors.push(new Sensor(angle));
+ }
+
+ // If a brain is passed via constructor copy it
+ if (brain) {
+ this.brain = brain.copy();
+ this.brain.mutate(mutate);
+ // Otherwise make a new brain
+ } else {
+ // inputs are all the sensors plus position and velocity info
+ let inputs = this.sensors.length + 6;
+ // Arbitrary hidden layer
+ // 2 outputs for x and y desired velocity
+ this.brain = new NeuralNetwork(inputs, 32, 2);
+ }
+
+ // Health keeps vehicl alive
+ this.health = 1;
+ }
+
+
+ // Called each time step
+ update() {
+ // Update velocity
+ this.velocity.add(this.acceleration);
+ // Limit speed to max
+ this.velocity.limit(this.maxspeed);
+ // Keep speed at a minimum
+ if (this.velocity.mag() < this.minspeed) {
+ this.velocity.setMag(this.minspeed);
+ }
+ // Update position
+ this.position.add(this.velocity);
+ // Reset acceleration to 0 each cycle
+ this.acceleration.mult(0);
+
+ // Decrease health
+ this.health = constrain(this.health, 0, this.maxhealth);
+ this.health -= 0.005;
+ // Increase score
+ this.score += 1;
+ }
+
+ // Return true if health is less than zero
+ // or if vehicle leaves the canvas
+ dead() {
+ return (this.health < 0 ||
+ this.position.x > width + this.r ||
+ this.position.x < -this.r ||
+ this.position.y > height + this.r ||
+ this.position.y < -this.r
+ );
+ }
+
+ // Make a copy of this vehicle according to probability
+ clone(prob) {
+ // Pick a random number
+ let r = random(1);
+ if (r < prob) {
+ // New vehicle with brain copy
+ return new Vehicle(this.brain);
+ }
+ // otherwise will return undefined
+ }
+
+ // Function to calculate all sensor readings
+ // And predict a "desired velocity"
+ think(food) {
+ // All sensors start with maximum length
+ for (let j = 0; j < this.sensors.length; j++) {
+ this.sensors[j].val = sensorLength;
+ }
+
+ for (let i = 0; i < food.length; i++) {
+ // Where is the food
+ let otherPosition = food[i];
+ // How far away?
+ let dist = p5.Vector.dist(this.position, otherPosition);
+ // Skip if it's too far away
+ if (dist > sensorLength) {
+ continue;
+ }
+
+ // What is vector pointint to food
+ let toFood = p5.Vector.sub(otherPosition, this.position);
+
+ // Check all the sensors
+ for (let j = 0; j < this.sensors.length; j++) {
+ // If the relative angle of the food is in between the range
+ let delta = this.sensors[j].dir.angleBetween(toFood);
+ if (delta < sensorAngle / 2) {
+ // Sensor value is the closest food
+ this.sensors[j].val = min(this.sensors[j].val, dist);
+ }
+ }
+ }
+
+ // Create inputs
+ let inputs = [];
+ // This is goofy but these 4 inputs are mapped to distance from edges
+ inputs[0] = constrain(map(this.position.x, foodBuffer, 0, 0, 1), 0, 1);
+ inputs[1] = constrain(map(this.position.y, foodBuffer, 0, 0, 1), 0, 1);
+ inputs[2] = constrain(map(this.position.x, width - foodBuffer, width, 0, 1), 0, 1);
+ inputs[3] = constrain(map(this.position.y, height - foodBuffer, height, 0, 1), 0, 1);
+ // These inputs are the current velocity vector
+ inputs[4] = this.velocity.x / this.maxspeed;
+ inputs[5] = this.velocity.y / this.maxspeed;
+ // All the sensor readings
+ for (let j = 0; j < this.sensors.length; j++) {
+ inputs[j + 6] = map(this.sensors[j].val, 0, sensorLength, 1, 0);
+ }
+
+ // Get two outputs
+ let outputs = this.brain.predict(inputs);
+ // Turn it into a desired velocity and apply steering formula
+ let desired = createVector(2 * outputs[0] - 1, 2 * outputs[1] - 1);
+ desired.mult(this.maxspeed);
+ // Craig Reynolds steering formula
+ let steer = p5.Vector.sub(desired, this.velocity);
+ steer.limit(this.maxforce);
+ // Apply the force
+ this.applyForce(steer);
+ }
+
+ // Check against array of food
+ eat(list) {
+ for (let i = list.length - 1; i >= 0; i--) {
+ // Calculate distance
+ let d = p5.Vector.dist(list[i], this.position);
+ // If vehicle is within food radius, eat it!
+ if (d < foodRadius) {
+ list.splice(i, 1);
+ // Add health when it eats food
+ this.health++;
+ }
+ }
+ }
+
+ // Add force to acceleration
+ applyForce(force) {
+ this.acceleration.add(force);
+ }
+
+ display() {
+ // Color based on health
+ let green = color(0, 255, 255, 255);
+ let red = color(255, 0, 100, 100);
+ let col = lerpColor(red, green, this.health)
+
+ push();
+ // Translate to vehicle position
+ translate(this.position.x, this.position.y);
+
+ // Draw lines for all the activated sensors
+ if (debug.checked()) {
+ for (let i = 0; i < this.sensors.length; i++) {
+ let val = this.sensors[i].val;
+ if (val > 0) {
+ stroke(col);
+ strokeWeight(map(val, 0, sensorLength, 4, 0));
+ let position = this.sensors[i].dir;
+ line(0, 0, position.x * val, position.y * val);
+ }
+ }
+ // Display score next to each vehicle
+ noStroke();
+ fill(255, 200);
+ text(int(this.score), 10, 0);
+ }
+ // Draw a triangle rotated in the direction of velocity
+ let theta = this.velocity.heading() + PI / 2;
+ rotate(theta);
+ // Draw the vehicle itself
+ fill(col);
+ strokeWeight(1);
+ stroke(col);
+ beginShape();
+ vertex(0, -this.r * 2);
+ vertex(-this.r, this.r * 2);
+ vertex(this.r, this.r * 2);
+ endShape(CLOSE);
+ pop();
+ }
+
+ // Highlight with a grey bubble
+ highlight() {
+ fill(255, 255, 255, 50);
+ stroke(255);
+ ellipse(this.position.x, this.position.y, 32, 32);
+ }
+}
\ No newline at end of file
diff --git a/examples/xor/README.md b/examples/xor/README.md
new file mode 100644
index 0000000..dfc9875
--- /dev/null
+++ b/examples/xor/README.md
@@ -0,0 +1,3 @@
+## Variations:
+
+* [NN XOR](https://codemehtm.github.io/nn) by cdeMtHtm - "I literally copied this from the video, but then, I added a little bit more."
diff --git a/lib/matrix.js b/lib/matrix.js
index 5897718..b232d36 100644
--- a/lib/matrix.js
+++ b/lib/matrix.js
@@ -8,12 +8,22 @@ class Matrix {
this.data = Array(this.rows).fill().map(() => Array(this.cols).fill(0));
}
+ copy() {
+ let m = new Matrix(this.rows, this.cols);
+ for (let i = 0; i < this.rows; i++) {
+ for (let j = 0; j < this.cols; j++) {
+ m.data[i][j] = this.data[i][j];
+ }
+ }
+ return m;
+ }
+
static fromArray(arr) {
return new Matrix(arr.length, 1).map((e, i) => arr[i]);
}
static subtract(a, b) {
- if(a.rows!==b.rows || a.cols!==b.cols){
+ if (a.rows !== b.rows || a.cols !== b.cols) {
console.log('Columns and Rows of A must match Columns and Rows of B.');
return;
}
@@ -39,11 +49,11 @@ class Matrix {
add(n) {
if (n instanceof Matrix) {
- if(this.rows!==n.rows || this.cols!==n.cols){
+ if (this.rows !== n.rows || this.cols !== n.cols) {
console.log('Columns and Rows of A must match Columns and Rows of B.');
return;
}
- return this.map((e, i, j) => e + n.data[i][j]);
+ return this.map((e, i, j) => e + n.data[i][j]);
} else {
return this.map(e => e + n);
}
@@ -57,7 +67,7 @@ class Matrix {
static multiply(a, b) {
// Matrix product
if (a.cols !== b.rows) {
- console.log('Columns of A must match rows of B.')
+ console.log('Columns of A must match rows of B.');
return;
}
@@ -74,7 +84,7 @@ class Matrix {
multiply(n) {
if (n instanceof Matrix) {
- if(this.rows!==n.rows || this.cols!==n.cols){
+ if (this.rows !== n.rows || this.cols !== n.cols) {
console.log('Columns and Rows of A must match Columns and Rows of B.');
return;
}
@@ -114,8 +124,7 @@ class Matrix {
}
static deserialize(data) {
- if(typeof data == 'string')
- {
+ if (typeof data == 'string') {
data = JSON.parse(data);
}
let matrix = new Matrix(data.rows, data.cols);
@@ -126,4 +135,4 @@ class Matrix {
if (typeof module !== 'undefined') {
module.exports = Matrix;
-}
\ No newline at end of file
+}
diff --git a/lib/matrix.test.js b/lib/matrix.test.js
index 4933895..49fc653 100644
--- a/lib/matrix.test.js
+++ b/lib/matrix.test.js
@@ -363,6 +363,7 @@ test('static map with row and column params', () => {
]
});
});
+
test('matrix (de)serialization', () => {
let m = new Matrix(5, 5);
m.randomize();
@@ -375,3 +376,16 @@ test('matrix (de)serialization', () => {
data: m.data
});
});
+
+test('matrix copy', () => {
+ let m = new Matrix(5, 5);
+ m.randomize();
+
+ let n = m.copy();
+
+ expect(n).toEqual({
+ rows: m.rows,
+ cols: m.cols,
+ data: m.data
+ });
+});
diff --git a/lib/nn.js b/lib/nn.js
index 5cce746..0cb4527 100644
--- a/lib/nn.js
+++ b/lib/nn.js
@@ -1,7 +1,7 @@
// Other techniques for learning
-class ActivationFunction{
- constructor(func, dfunc){
+class ActivationFunction {
+ constructor(func, dfunc) {
this.func = func;
this.dfunc = dfunc;
}
@@ -9,34 +9,53 @@ class ActivationFunction{
let sigmoid = new ActivationFunction(
x => 1 / (1 + Math.exp(-x)),
- y => y * (1- y)
+ y => y * (1 - y)
);
let tanh = new ActivationFunction(
x => Math.tanh(x),
- y => 1-(y*y)
+ y => 1 - (y * y)
);
class NeuralNetwork {
- constructor(input_nodes, hidden_nodes, output_nodes) {
- this.input_nodes = input_nodes;
- this.hidden_nodes = hidden_nodes;
- this.output_nodes = output_nodes;
-
- this.weights_ih = new Matrix(this.hidden_nodes, this.input_nodes);
- this.weights_ho = new Matrix(this.output_nodes, this.hidden_nodes);
- this.weights_ih.randomize();
- this.weights_ho.randomize();
-
- this.bias_h = new Matrix(this.hidden_nodes, 1);
- this.bias_o = new Matrix(this.output_nodes, 1);
- this.bias_h.randomize();
- this.bias_o.randomize();
- this.setLearningRate();
+ /*
+ * if first argument is a NeuralNetwork the constructor clones it
+ * USAGE: cloned_nn = new NeuralNetwork(to_clone_nn);
+ */
+ constructor(in_nodes, hid_nodes, out_nodes) {
+ if (in_nodes instanceof NeuralNetwork) {
+ let a = in_nodes;
+ this.input_nodes = a.input_nodes;
+ this.hidden_nodes = a.hidden_nodes;
+ this.output_nodes = a.output_nodes;
+
+ this.weights_ih = a.weights_ih.copy();
+ this.weights_ho = a.weights_ho.copy();
+
+ this.bias_h = a.bias_h.copy();
+ this.bias_o = a.bias_o.copy();
+ } else {
+ this.input_nodes = in_nodes;
+ this.hidden_nodes = hid_nodes;
+ this.output_nodes = out_nodes;
+
+ this.weights_ih = new Matrix(this.hidden_nodes, this.input_nodes);
+ this.weights_ho = new Matrix(this.output_nodes, this.hidden_nodes);
+ this.weights_ih.randomize();
+ this.weights_ho.randomize();
+
+ this.bias_h = new Matrix(this.hidden_nodes, 1);
+ this.bias_o = new Matrix(this.output_nodes, 1);
+ this.bias_h.randomize();
+ this.bias_o.randomize();
+ }
+ // TODO: copy these as well
+ this.setLearningRate();
this.setActivationFunction();
+
}
predict(input_array) {
@@ -128,8 +147,7 @@ class NeuralNetwork {
}
static deserialize(data) {
- if(typeof data == 'string')
- {
+ if (typeof data == 'string') {
data = JSON.parse(data);
}
let nn = new NeuralNetwork(data.input_nodes, data.hidden_nodes, data.output_nodes);
@@ -141,4 +159,20 @@ class NeuralNetwork {
return nn;
}
+
+ // Adding function for neuro-evolution
+ copy() {
+ return new NeuralNetwork(this);
+ }
+
+ // Accept an arbitrary function for mutation
+ mutate(func) {
+ this.weights_ih.map(func);
+ this.weights_ho.map(func);
+ this.bias_h.map(func);
+ this.bias_o.map(func);
+ }
+
+
+
}