added NeuralNetwork and genetic algorithm functions

Author: Tanish0019

bird.js

@@ -3,7 +3,8 @@ class Bird {
 		this.actualHeight = height - groundImg.height;
 		this.x = 50;
 		this.y = this.actualHeight / 2;
-		this.radius = birdImg.width / 2;
+		this.width = birdImg.width;
+		this.height = birdImg.height;
 		this.gravity = 0.8;
 		this.upLift = -12;
 		this.velocity = 0;
@@ -16,7 +17,7 @@ class Bird {
 
 		if (brain instanceof NeuralNetwork) {
 			this.brain = brain.copy();
-			this.brain.mutate(mutate);
+			this.brain.mutate(0.1);
 		} else {
 			// Parameters are number of inputs, number of units in hidden Layer, number of outputs
 			this.brain = new NeuralNetwork(5, 8, 1);
@@ -27,6 +28,10 @@ class Bird {
 		return new Bird(this.brain);
 	}
 
+	// mutate(rate) {
+	// 	this.brain.mutate(rate);
+	// }
+
 	show() {
 		image(birdImg, this.x, this.y);
 	}
@@ -61,8 +66,7 @@ class Bird {
 			// 5. bird's velocity
 			inputs[4] = map(this.velocity, -12, 12, 0, 1);
 
-			// const action = this.brain.predict(inputs);
-			const action = [0.3];
+			const action = this.brain.predict(inputs);
 			if (action[0] > 0.5) {
 				this.jump();
 			}
@@ -75,7 +79,7 @@ class Bird {
 	}
 
 	bottomTopCollision() {
-		return this.y + this.radius > this.actualHeight || this.y - this.radius < 0;
+		return this.y + this.height / 2 > this.actualHeight || this.y - this.hieght / 2 < 0;
 	}
 
 	update() {

geneticAlgorithm.js

@@ -0,0 +1,62 @@
+function resetGame() {
+	frameCounter = 0;
+	pipes = [];
+}
+
+function createNextGeneration() {
+	resetGame();
+	normalizeFitness(allBirds);
+	aliveBirds = generate(allBirds);
+	allBirds = aliveBirds.slice();
+}
+
+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;
+}
+
+function normalizeFitness(birds) {
+	for (let i = 0; i < birds.length; i++) {
+		birds[i].score = pow(birds[i].score, 2);
+	}
+
+	let sum = 0;
+	for (let i = 0; i < birds.length; i++) {
+		sum += birds[i].score;
+	}
+
+	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();
+}

neuralNetwork.js

@@ -1,5 +1,78 @@
 class NeuralNetwork {
-	constructor() {
-		
+	constructor(inputs, hiddenUnits, outputs, model = {}) {
+		this.input_nodes = inputs;
+		this.hidden_nodes = hiddenUnits;
+		this.output_nodes = outputs;
+
+		if (model instanceof tf.Sequential) {
+			this.model = model;
+
+		} else {
+			this.model = this.createModel();
+		}
 	}
-};
+
+	// Copy a model
+	copy() {
+		return tf.tidy(() => {
+			const modelCopy = this.createModel();
+			const weights = this.model.getWeights();
+			const weightCopies = [];
+			for (let i = 0; i < weights.length; i++) {
+				weightCopies[i] = weights[i].clone();
+			}
+			modelCopy.setWeights(weightCopies);
+			return new NeuralNetwork(this.input_nodes, this.hidden_nodes, this.output_nodes, modelCopy);
+		});
+	}
+
+	mutate(rate) {
+		tf.tidy(() => {
+			const weights = this.model.getWeights();
+			const mutatedWeights = [];
+			for (let i = 0; i < weights.length; i++) {
+				let tensor = weights[i];
+				let shape = weights[i].shape;
+				let values = tensor.dataSync().slice();
+				for (let j = 0; j < values.length; j++) {
+					if (random(1) < rate) {
+						let w = values[j];
+						values[j] = w + randomGaussian();
+					}
+				}
+				let newTensor = tf.tensor(values, shape);
+				mutatedWeights[i] = newTensor;
+			}
+			this.model.setWeights(mutatedWeights);
+		});
+	}
+
+	dispose() {
+		this.model.dispose();
+	}
+
+	predict(inputs) {
+		return tf.tidy(() => {
+			const xs = tf.tensor2d([inputs]);
+			const ys = this.model.predict(xs);
+			const output = ys.dataSync();
+			return output;
+		});
+	}
+
+	createModel() {
+		const model = tf.sequential();
+		const hiddenLayer = tf.layers.dense({
+			units: this.hidden_nodes,
+			inputShape: [this.input_nodes],
+			activation: "relu"
+		});
+		model.add(hiddenLayer);
+		const outputLayer = tf.layers.dense({
+			units: this.output_nodes,
+			activation: "sigmoid"
+		});
+		model.add(outputLayer);
+		return model;
+	}
+}

pipe.js

@@ -23,8 +23,8 @@ class Pipe {
 	}
 
 	checkCollision(bird) {
-		if (bird.x + bird.radius >= this.x && bird.x - bird.radius <= this.x + this.width) {
-			if (bird.y - bird.radius <= this.top || bird.y + bird.radius >= this.bottom) {
+		if (bird.x + bird.width / 2 >= this.x && bird.x - bird.width / 2 <= this.x + this.width) {
+			if (bird.y - bird.height / 2 <= this.top || bird.y + bird.height / 2 >= this.bottom) {
 				return true;
 			}
 		}

sketch.js

@@ -1,6 +1,6 @@
 // The number of birds in each population
 const totalPopulation = 300;
-
+let generation = 0;
 // Birds currently alived
 let aliveBirds = [];
 
@@ -20,6 +20,7 @@ function preload() {
 }
 
 function setup() {
+	tf.setBackend("cpu");
 	let canvas = createCanvas(bg.width, bg.height);
 	canvas.parent("sketch");
 	for (let i = 0; i < totalPopulation; i++) {
@@ -49,12 +50,11 @@ function draw() {
 			}
 		}
 		if (bird.bottomTopCollision()) {
-			console.log("dead");
 			aliveBirds.splice(i, 1);
 		}
 	}
 
-	if (frameCounter % 75 === 0) {
+	if (frameCounter % 50 === 0) {
 		pipes.push(new Pipe());
 	}
 
@@ -66,5 +66,11 @@ function draw() {
 	for (let i = 0; i < aliveBirds.length; i++) {
 		aliveBirds[i].show();
 	}
+	if (aliveBirds.length == 0) {
+		generation++;
+		console.log("generation ", generation);
+		createNextGeneration();
+	}
+
 	image(groundImg, 0, height - groundImg.height);
 }