initial commit

Author: dev-abir

.gitignore

@@ -0,0 +1,10 @@
+.*
+!.gitignore
+
+# pycahrm file
+*.iml
+
+# virtual environment
+venv
+
+__pycache__

Bird.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import numpy as np
+import pyglet
+from icecream import ic
+
+import settings
+from NeuralNet import NeuralNet
+from settings import WINDOW_HEIGHT, NEURALNET_VISIBILITY_DIST, BIRD_JUMP_VEL, GRAVITY_ACCL
+
+
+class Bird(pyglet.sprite.Sprite):
+    def __init__(self, brain: NeuralNet, bird_img, batch: pyglet.graphics.Batch, group: pyglet.graphics.group, x_offset: int, default_y: int):
+        # anchor centre, for rotations...
+        bird_img.anchor_x = bird_img.width // 2
+        bird_img.anchor_y = bird_img.height // 2
+
+        super().__init__(img=bird_img, batch=batch, group=group)
+        self.scale = settings.BIRD_IMG_SCALE
+        self.brain = brain  # the neural net object, backing the bird
+        self.default_batch = batch
+        self.batch = batch
+        self.x_offset = x_offset
+        self.default_y = default_y
+        self.score = 0
+        self.velocity_y = 0
+        self.died = False
+        self.x = x_offset
+        self.y = default_y
+        #self.color = (np.random.randint(low=0, high=255), np.random.randint(low=0, high=255), np.random.randint(low=0, high=255))
+
+    def take_decision(self, y_dist_to_top_pipe: float,
+                      y_dist_to_bottom_pipe: float,
+                      x_dist_to_pipe: float):
+        max_vel = settings.WINDOW_HEIGHT // 2
+        bird_vel = self.velocity_y / max_vel
+
+        y_dist_to_top_pipe = abs(y_dist_to_top_pipe / WINDOW_HEIGHT)
+        y_dist_to_bottom_pipe = abs(y_dist_to_bottom_pipe / WINDOW_HEIGHT)
+        if x_dist_to_pipe > NEURALNET_VISIBILITY_DIST:
+            x_dist_to_pipe = 1
+        else:
+            x_dist_to_pipe = abs(x_dist_to_pipe / NEURALNET_VISIBILITY_DIST)
+
+        if y_dist_to_top_pipe < 0 or y_dist_to_top_pipe > 1:
+            ic(y_dist_to_top_pipe, "out of bounds")
+        if y_dist_to_bottom_pipe < 0 or y_dist_to_bottom_pipe > 1:
+            ic(y_dist_to_bottom_pipe, "out of bounds")
+        if x_dist_to_pipe > 1:
+            ic(x_dist_to_pipe, "out of bounds")
+        if bird_vel < -1 or bird_vel > 1:
+            ic(bird_vel, "out of bounds")
+
+        if self.brain.get_choice(np.array([[bird_vel, y_dist_to_top_pipe, y_dist_to_bottom_pipe, x_dist_to_pipe]])) > 0.5:
+            self._jump()
+
+    def _jump(self):
+        if self.velocity_y <= 0:
+            self.velocity_y += BIRD_JUMP_VEL
+
+    def update_movement(self):
+        self.velocity_y -= GRAVITY_ACCL
+        self.y += self.velocity_y
+
+    def mate(self, other: Bird) -> Bird:
+        child = Bird(bird_img=self.image,
+                     batch=self.default_batch,
+                     group=self.group,
+                     x_offset=self.x_offset,
+                     default_y=self.default_y,
+                     brain=self.brain.mate(other.brain))
+        return child
+
+    def get_clone(self) -> Bird:
+        child = Bird(bird_img=self.image,
+                     batch=self.default_batch,
+                     group=self.group,
+                     x_offset=self.x_offset,
+                     default_y=self.default_y,
+                     brain=self.brain)
+        return child
+
+    def die(self):
+        self.died = True
+        self.batch = None  # remove from batch, so it won't draw...
+
+    def get_x_dist(self, coord: float) -> float:
+        # FIXME: pos, neg dist...!!!
+        # + self.width // 2, as it's anchored in the centre...
+        return coord - (self.x + self.width // 2)
+
+    def get_y_dist(self, coord: float) -> float:
+        # FIXME: pos, neg dist...!!!
+        # + self.height // 2, as it's anchored in the centre...
+        return coord - (self.y + self.height // 2)

Ecosystem.py

@@ -0,0 +1,51 @@
+import pyglet.graphics
+from icecream import ic
+
+from Bird import Bird
+from NeuralNet import NeuralNet
+
+import numpy as np
+
+
+class Ecosystem:
+    def __init__(self, population_size: int, num_generations: int, holdout: int, bird_spawner_func):
+        self.population_size = population_size
+        self.num_generations = num_generations
+        self.birds = []
+        self.generation_id = 1
+        self.max_score = 0
+        self.holdout = holdout
+        self.bird_spawner_func = bird_spawner_func
+        for _ in range(population_size):
+            self.birds.append(bird_spawner_func())
+
+    def new_generation(self):
+        self.generation_id += 1
+
+        # arrange birds in descending order of their scores
+        # TODO: any better way of doing this...?
+        scores = [bird.score for bird in self.birds]
+        self.birds = [self.birds[x] for x in np.argsort(scores)[::-1]]
+        self.max_score = np.max(scores)
+
+        new_population = []
+
+        if self.max_score == 0 and self.generation_id % 15 == 0:
+            # if for every 15 generations passed, no one scored above 0,
+            # then demolish the species...
+            for _ in range(self.population_size):
+                new_population.append(self.bird_spawner_func())
+        else:
+            for i in range(self.population_size):
+                parent_1_idx = i % self.holdout  # parent_1_idx will be within 0 to self.holdout - 1
+                # TODO: why np.random.exponential...?
+                parent_2_idx = min(self.population_size - 1, int(np.random.exponential(self.holdout)))
+                offspring = self.birds[parent_1_idx].mate(self.birds[parent_2_idx])
+                new_population.append(offspring)
+
+            new_population[-1] = self.birds[0].get_clone()  # Ensure best organism survives
+            # new_population[-1].color = (255, 0, 0)
+        self.birds = new_population
+
+    def max_gen_reached(self) -> bool:
+        return self.num_generations == self.generation_id

NeuralNet.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import copy
+import numpy as np
+
+
+class NeuralNet:
+    def __init__(self, dimensions: list):
+        self.layers = []
+        self.biases = []
+        # TODO: do a study on these output activation funcs...
+        self.output = self._activation()
+        for i in range(len(dimensions) - 1):
+            shape = (dimensions[i], dimensions[i + 1])
+            std = np.sqrt(2 / sum(shape))  # TODO: why std dev is calculated like this...?
+            layer = np.random.normal(0, std, shape)
+            bias = np.random.normal(0, std, (1, dimensions[i + 1]))
+            self.layers.append(layer)
+            self.biases.append(bias)
+
+    def _activation(self, output: str = 'linear'):
+        if output == 'sigmoid':
+            return lambda X: (1 / (1 + np.exp(-X)))
+        else:
+            return lambda X: X  # linear output
+
+    def mutate(self, stdev=0.03):
+        # TODO: change stdev...?
+        for i in range(len(self.layers)):
+            self.layers[i] += np.random.normal(0, stdev, self.layers[i].shape)
+            self.biases[i] += np.random.normal(0, stdev, self.biases[i].shape)
+
+    def mate(self, other: NeuralNet) -> NeuralNet:
+        # TODO: remove the checks...?
+        if not len(self.layers) == len(other.layers):
+            raise ValueError('Both parents must have same number of layers')
+        if not all(self.layers[x].shape == other.layers[x].shape for x in range(len(self.layers))):
+            raise ValueError('Both parents must have same shape')
+
+        child = copy.deepcopy(self)
+        for i in range(len(child.layers)):
+            pass_on = np.random.rand(1, child.layers[i].shape[1]) < 0.5
+            child.layers[i] = pass_on * self.layers[i] + ~pass_on * other.layers[i]
+            child.biases[i] = pass_on * self.biases[i] + ~pass_on * other.biases[i]
+            child.mutate()
+        return child
+
+    def get_choice(self, X: np.ndarray) -> float:
+        # TODO: remove the checks...?
+        if not X.ndim == 2:
+            raise ValueError(f'Input has {X.ndim} dimensions, expected 2')
+        if not X.shape[1] == self.layers[0].shape[0]:
+            raise ValueError(f'Input has {X.shape[1]} features, expected {self.layers[0].shape[0]}')
+        for index, (layer, bias) in enumerate(zip(self.layers, self.biases)):
+            X = X @ layer + np.ones((X.shape[0], 1)) @ bias
+            if index == len(self.layers) - 1:
+                X = self.output(X)  # output activation
+            else:
+                X = np.clip(X, 0, np.inf)  # ReLU
+
+        return X[0][0]
+        # return np.argmax(X, axis=1).reshape((-1, 1))  # TODO: is it reshaping from -1 to +1?

README.md

@@ -0,0 +1,28 @@
+# AI plays-python
+
+A simple flappy bird game, where the player is AI.
+
+A flock of birds will try to survive in this game (rather environment), the best ones will continue, rest will die. Much like our evolution :)
+
+It uses the concept of Evolutionary artificial neural networks (EANNs), or Evolving Neural Networks. I did this project mainly to get some idea of neural networks, machine learning in a somewhat interesting way. I used [this](https://towardsdatascience.com/evolving-neural-networks-b24517bb3701) article a lot, and also studied some free content whatever I could get on the internet :)
+
+Wrote this a couple of months back, around May and uploading this on November. There are places, where this codebase can be improved.... Suggestions, bug-reports, bug-fixes are always welcome :)
+
+## How to play
+
+Assuming that you have `python` installed properly...
+
+1. Clone this repo or use the code button in github and download the zip ([see this](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository#cloning-a-repository))
+
+2. Create a virtual environment (recommended), so that there will be no conflicts between previously installed packages and the packages we will install now. At first `cd` into the downloaded repo, then issue the command: `python3 -m pip venv`
+
+3. Depending on the OS, the command to activate your virtual environment will be: `.\venv\Scripts\activate.ps1` (issue a PR if something is wrong here) or `source venv\bin\activate`
+(On closing the terminal the virtual environment will be gone, you should do step 3 again)
+
+4. To install libraries used in this project, issue the command: `pip install -r requirements.txt`
+
+5. Last step: `python main.py`
+
+6. **Use UP and DOWN arrow to increase the speed of the simulation and vice-versa.**
+
+7. To change settings, like resolution etc, edit the `settings.py` file.