yay_ or nay_ achieved 80 % accuracy

Author: =

.gitignore

@@ -2,6 +2,5 @@ __pycache__/
 target/*
 .idea/*
 tensorflow/screenshots/*
-labels.txt
-tensorflow/dataset
+tensorflow/dataset/samples/*
 .zip

gym/README.md

@@ -0,0 +1 @@
+https://www.youtube.com/watch?v=3zeg7H6cAJw

gym/try_gym.py

@@ -0,0 +1,28 @@
+import gym
+import random
+import numpy as np
+import tflearn
+from tflearn.layers.core import input_data, dropout, fully_connected
+from tflearn.layers.estimator import regression
+from statistics import mean, median
+from collections import Counter
+
+# learning rate
+LR = 1e-3
+env = gym.make('CartPole-v0')
+env.reset()
+goal_steps = 500
+score_requirement = 50
+initial_games = 10000
+
+def some_random_games_first():
+	for episode in range(5):
+		env.reset()
+		for t in range(goal_steps):
+			env.render()
+			action = env.action_space.sample()
+			observation, reward, done, info = env.step(action)
+			if done:
+				break
+				
+#some_random_games_first()

snake_game/README.md

@@ -0,0 +1 @@
+https://towardsdatascience.com/today-im-going-to-talk-about-a-small-practical-example-of-using-neural-networks-training-one-to-6b2cbd6efdb3?gi=cb32f92347a5

snake_game/checkpoint

@@ -0,0 +1,2 @@
+model_checkpoint_path: "D:\\work\\LearnANN\\snake_game\\snake_nn_2.tflearn"
+all_model_checkpoint_paths: "D:\\work\\LearnANN\\snake_game\\snake_nn_2.tflearn"

snake_game/log/snake_nn.tflearn/events.out.tfevents.1540565479.BHEGDE-DT

@@ -0,0 +1,154 @@
+from snake_game import SnakeGame
+from random import randint
+import numpy as np
+import tflearn
+import math
+from tflearn.layers.core import input_data, fully_connected
+from tflearn.layers.estimator import regression
+from statistics import mean
+from collections import Counter
+
+class SnakeNN:
+    def __init__(self, initial_games = 100, test_games = 100, goal_steps = 100, lr = 1e-2, filename = 'snake_nn.tflearn'):
+        self.initial_games = initial_games
+        self.test_games = test_games
+        self.goal_steps = goal_steps
+        self.lr = lr
+        self.filename = filename
+        self.vectors_and_keys = [
+                [[-1, 0], 0],
+                [[0, 1], 1],
+                [[1, 0], 2],
+                [[0, -1], 3]
+                ]
+
+    def initial_population(self):
+        training_data = []
+        for _ in range(self.initial_games):
+            game = SnakeGame()
+            _, _, snake, _ = game.start()
+            prev_observation = self.generate_observation(snake)
+            for _ in range(self.goal_steps):
+                action, game_action = self.generate_action(snake)
+                done, _, snake, _  = game.step(game_action)
+                if done:
+                    training_data.append([self.add_action_to_observation(prev_observation, action), 0])
+                    break
+                else:
+                    training_data.append([self.add_action_to_observation(prev_observation, action), 1])
+                    prev_observation = self.generate_observation(snake)
+        print(len(training_data))
+        return training_data
+
+    def generate_action(self, snake):
+        action = randint(0,2) - 1
+        return action, self.get_game_action(snake, action)
+
+    def get_game_action(self, snake, action):
+        snake_direction = self.get_snake_direction_vector(snake)
+        new_direction = snake_direction
+        if action == -1:
+            new_direction = self.turn_vector_to_the_left(snake_direction)
+        elif action == 1:
+            new_direction = self.turn_vector_to_the_right(snake_direction)
+        for pair in self.vectors_and_keys:
+            if pair[0] == new_direction.tolist():
+                game_action = pair[1]
+        return game_action
+
+    def generate_observation(self, snake):
+        snake_direction = self.get_snake_direction_vector(snake)
+        barrier_left = self.is_direction_blocked(snake, self.turn_vector_to_the_left(snake_direction))
+        barrier_front = self.is_direction_blocked(snake, snake_direction)
+        barrier_right = self.is_direction_blocked(snake, self.turn_vector_to_the_right(snake_direction))
+        return np.array([int(barrier_left), int(barrier_front), int(barrier_right)])
+
+    def add_action_to_observation(self, observation, action):
+        return np.append([action], observation)
+
+    def get_snake_direction_vector(self, snake):
+        return np.array(snake[0]) - np.array(snake[1])
+
+    def is_direction_blocked(self, snake, direction):
+        point = np.array(snake[0]) + np.array(direction)
+        return point.tolist() in snake[:-1] or point[0] == 0 or point[1] == 0 or point[0] == 21 or point[1] == 21
+
+    def turn_vector_to_the_left(self, vector):
+        return np.array([-vector[1], vector[0]])
+
+    def turn_vector_to_the_right(self, vector):
+        return np.array([vector[1], -vector[0]])
+
+    def model(self):
+        network = input_data(shape=[None, 4, 1], name='input')
+        network = fully_connected(network, 1, activation='linear')
+        network = regression(network, optimizer='adam', learning_rate=self.lr, loss='mean_square', name='target')
+        model = tflearn.DNN(network, tensorboard_dir='log')
+        return model
+
+    def train_model(self, training_data, model):
+        X = np.array([i[0] for i in training_data]).reshape(-1, 4, 1)
+        y = np.array([i[1] for i in training_data]).reshape(-1, 1)
+        model.fit(X,y, n_epoch = 1, shuffle = True, run_id = self.filename)
+        model.save(self.filename)
+        return model
+
+    def test_model(self, model):
+        steps_arr = []
+        for _ in range(self.test_games):
+            steps = 0
+            game_memory = []
+            game = SnakeGame()
+            _, _, snake, _ = game.start()
+            prev_observation = self.generate_observation(snake)
+            for _ in range(self.goal_steps):
+                predictions = []
+                for action in range(-1, 2):
+                   predictions.append(model.predict(self.add_action_to_observation(prev_observation, action).reshape(-1, 4, 1)))
+                action = np.argmax(np.array(predictions))
+                game_action = self.get_game_action(snake, action - 1)
+                done, _, snake, _  = game.step(game_action)
+                game_memory.append([prev_observation, action])
+                if done:
+                    break
+                else:
+                    prev_observation = self.generate_observation(snake)
+                    steps += 1
+            steps_arr.append(steps)
+        print('Average steps:',mean(steps_arr))
+        print(Counter(steps_arr))
+
+    def visualise_game(self, model):
+        game = SnakeGame(gui = True)
+        _, _, snake, _ = game.start()
+        prev_observation = self.generate_observation(snake)
+        for _ in range(self.goal_steps):
+            predictions = []
+            for action in range(-1, 2):
+               predictions.append(model.predict(self.add_action_to_observation(prev_observation, action).reshape(-1, 4, 1)))
+            action = np.argmax(np.array(predictions))
+            game_action = self.get_game_action(snake, action - 1)
+            done, _, snake, _  = game.step(game_action)
+            if done:
+                break
+            else:
+                prev_observation = self.generate_observation(snake)
+
+    def train(self):
+        training_data = self.initial_population()
+        nn_model = self.model()
+        nn_model = self.train_model(training_data, nn_model)
+        self.test_model(nn_model)
+
+    def visualise(self):
+        nn_model = self.model()
+        nn_model.load(self.filename)
+        self.visualise_game(nn_model)
+
+    def test(self):
+        nn_model = self.model()
+        nn_model.load(self.filename)
+        self.test_model(nn_model)
+
+if __name__ == "__main__":
+    SnakeNN().train()

snake_game/log/snake_nn_2.tflearn/events.out.tfevents.1540566862.BHEGDE-DT

@@ -0,0 +1,186 @@
+from snake_game import SnakeGame
+from random import randint
+import numpy as np
+import tflearn
+import math
+from tflearn.layers.core import input_data, fully_connected
+from tflearn.layers.estimator import regression
+from statistics import mean
+from collections import Counter
+
+class SnakeNN:
+    def __init__(self, initial_games = 10000, test_games = 1000, goal_steps = 2000, lr = 1e-2, filename = 'snake_nn_2.tflearn'):
+        self.initial_games = initial_games
+        self.test_games = test_games
+        self.goal_steps = goal_steps
+        self.lr = lr
+        self.filename = filename
+        self.vectors_and_keys = [
+                [[-1, 0], 0],
+                [[0, 1], 1],
+                [[1, 0], 2],
+                [[0, -1], 3]
+                ]
+
+    def initial_population(self):
+        training_data = []
+        for _ in range(self.initial_games):
+            game = SnakeGame()
+            _, prev_score, snake, food = game.start()
+            prev_observation = self.generate_observation(snake, food)
+            prev_food_distance = self.get_food_distance(snake, food)
+            for _ in range(self.goal_steps):
+                action, game_action = self.generate_action(snake)
+                done, score, snake, food  = game.step(game_action)
+                if done:
+                    training_data.append([self.add_action_to_observation(prev_observation, action), -1])
+                    break
+                else:
+                    food_distance = self.get_food_distance(snake, food)
+                    if score > prev_score or food_distance < prev_food_distance:
+                        training_data.append([self.add_action_to_observation(prev_observation, action), 1])
+                    else:
+                        training_data.append([self.add_action_to_observation(prev_observation, action), 0])
+                    prev_observation = self.generate_observation(snake, food)
+                    prev_food_distance = food_distance
+        return training_data
+
+    def generate_action(self, snake):
+        action = randint(0,2) - 1
+        return action, self.get_game_action(snake, action)
+
+    def get_game_action(self, snake, action):
+        snake_direction = self.get_snake_direction_vector(snake)
+        new_direction = snake_direction
+        if action == -1:
+            new_direction = self.turn_vector_to_the_left(snake_direction)
+        elif action == 1:
+            new_direction = self.turn_vector_to_the_right(snake_direction)
+        for pair in self.vectors_and_keys:
+            if pair[0] == new_direction.tolist():
+                game_action = pair[1]
+        return game_action
+
+    def generate_observation(self, snake, food):
+        snake_direction = self.get_snake_direction_vector(snake)
+        food_direction = self.get_food_direction_vector(snake, food)
+        barrier_left = self.is_direction_blocked(snake, self.turn_vector_to_the_left(snake_direction))
+        barrier_front = self.is_direction_blocked(snake, snake_direction)
+        barrier_right = self.is_direction_blocked(snake, self.turn_vector_to_the_right(snake_direction))
+        angle = self.get_angle(snake_direction, food_direction)
+        return np.array([int(barrier_left), int(barrier_front), int(barrier_right), angle])
+
+    def add_action_to_observation(self, observation, action):
+        return np.append([action], observation)
+
+    def get_snake_direction_vector(self, snake):
+        return np.array(snake[0]) - np.array(snake[1])
+
+    def get_food_direction_vector(self, snake, food):
+        return np.array(food) - np.array(snake[0])
+
+    def normalize_vector(self, vector):
+        return vector / np.linalg.norm(vector)
+
+    def get_food_distance(self, snake, food):
+        return np.linalg.norm(self.get_food_direction_vector(snake, food))
+
+    def is_direction_blocked(self, snake, direction):
+        point = np.array(snake[0]) + np.array(direction)
+        return point.tolist() in snake[:-1] or point[0] == 0 or point[1] == 0 or point[0] == 21 or point[1] == 21
+
+    def turn_vector_to_the_left(self, vector):
+        return np.array([-vector[1], vector[0]])
+
+    def turn_vector_to_the_right(self, vector):
+        return np.array([vector[1], -vector[0]])
+
+    def get_angle(self, a, b):
+        a = self.normalize_vector(a)
+        b = self.normalize_vector(b)
+        return math.atan2(a[0] * b[1] - a[1] * b[0], a[0] * b[0] + a[1] * b[1]) / math.pi
+
+    def model(self):
+        network = input_data(shape=[None, 5, 1], name='input')
+        network = fully_connected(network, 25, activation='relu')
+        network = fully_connected(network, 1, activation='linear')
+        network = regression(network, optimizer='adam', learning_rate=self.lr, loss='mean_square', name='target')
+        model = tflearn.DNN(network, tensorboard_dir='log')
+        return model
+
+    def train_model(self, training_data, model):
+        X = np.array([i[0] for i in training_data]).reshape(-1, 5, 1)
+        y = np.array([i[1] for i in training_data]).reshape(-1, 1)
+        model.fit(X,y, n_epoch = 3, shuffle = True, run_id = self.filename)
+        model.save(self.filename)
+        return model
+
+    def test_model(self, model):
+        steps_arr = []
+        scores_arr = []
+        for _ in range(self.test_games):
+            steps = 0
+            game_memory = []
+            game = SnakeGame()
+            _, score, snake, food = game.start()
+            prev_observation = self.generate_observation(snake, food)
+            for _ in range(self.goal_steps):
+                predictions = []
+                for action in range(-1, 2):
+                   predictions.append(model.predict(self.add_action_to_observation(prev_observation, action).reshape(-1, 5, 1)))
+                action = np.argmax(np.array(predictions))
+                game_action = self.get_game_action(snake, action - 1)
+                done, score, snake, food  = game.step(game_action)
+                game_memory.append([prev_observation, action])
+                if done:
+                    print('-----')
+                    print(steps)
+                    print(snake)
+                    print(food)
+                    print(prev_observation)
+                    print(predictions)
+                    break
+                else:
+                    prev_observation = self.generate_observation(snake, food)
+                    steps += 1
+            steps_arr.append(steps)
+            scores_arr.append(score)
+        print('Average steps:',mean(steps_arr))
+        print(Counter(steps_arr))
+        print('Average score:',mean(scores_arr))
+        print(Counter(scores_arr))
+
+    def visualise_game(self, model):
+        game = SnakeGame(gui = True)
+        _, _, snake, food = game.start()
+        prev_observation = self.generate_observation(snake, food)
+        for _ in range(self.goal_steps):
+            precictions = []
+            for action in range(-1, 2):
+               precictions.append(model.predict(self.add_action_to_observation(prev_observation, action).reshape(-1, 5, 1)))
+            action = np.argmax(np.array(precictions))
+            game_action = self.get_game_action(snake, action - 1)
+            done, _, snake, food  = game.step(game_action)
+            if done:
+                break
+            else:
+                prev_observation = self.generate_observation(snake, food)
+
+    def train(self):
+        training_data = self.initial_population()
+        nn_model = self.model()
+        nn_model = self.train_model(training_data, nn_model)
+        self.test_model(nn_model)
+
+    def visualise(self):
+        nn_model = self.model()
+        nn_model.load(self.filename)
+        self.visualise_game(nn_model)
+
+    def test(self):
+        nn_model = self.model()
+        nn_model.load(self.filename)
+        self.test_model(nn_model)
+
+if __name__ == "__main__":
+    SnakeNN().train()