ai-snake-lab 0.1.0__py3-none-any.whl → 0.4.4__py3-none-any.whl

ai_snake_lab/ai/ReplayMemory.py

@@ -10,10 +10,14 @@ ai/ReplayMemory.py
 This file contains the ReplayMemory class.
 """
 
+import os
 from collections import deque
 import random, sys
+import sqlite3, pickle
 
 from constants.DReplayMemory import MEM_TYPE
+from constants.DFile import DFile
+from constants.DDir import DDir
 
 
 class ReplayMemory:
@@ -27,6 +31,11 @@ class ReplayMemory:
         self.max_states = 15000
         self.max_shuffle_games = 40
         self.max_games = 500
+        self.db_file = os.path.join(DDir.AI_SNAKE_LAB, DDir.DB, DFile.REPLAY_DB)
+
+        # Delete the replay memory file, if it exists
+        if os.path.exists(self.db_file):
+            os.remove(self.db_file)
 
         if self._mem_type == MEM_TYPE.SHUFFLE:
             # States are stored in a deque and a random sample will be returned
@@ -35,35 +44,50 @@ class ReplayMemory:
         elif self._mem_type == MEM_TYPE.RANDOM_GAME:
             # All of the states for a game are stored, in order, in a deque.
             # A complete game will be returned
-            self.memories = deque(maxlen=self.max_shuffle_games)
             self.cur_memory = []
 
-        else:
-            print(f"ERROR: Unrecognized replay memory type ({self._mem_type}), exiting")
-            sys.exit(1)
+        # Connect to SQLite
+        self.conn = sqlite3.connect(self.db_file, check_same_thread=False)
+        self.cursor = self.conn.cursor()
+        self.init_db()
 
-    def append(self, transition):
-        ## Add memories
+    def __len__(self):
+        return len(self.memories)
 
-        # States are stored in a deque and a random sample will be returned
-        if self._mem_type == MEM_TYPE.SHUFFLE:
-            self.memories.append(transition)
+    def append(self, transition):
+        """Add a transition to the current game."""
+        if self._mem_type != MEM_TYPE.RANDOM_GAME:
+            raise NotImplementedError(
+                "Only RANDOM_GAME memory type is implemented for SQLite backend"
+            )
+
+        self.cur_memory.append(transition)
+        _, _, _, _, done = transition
+
+        if done:
+            # Serialize the full game to JSON
+            serialized = pickle.dumps(self.cur_memory)
+            self.cursor.execute(
+                "INSERT INTO games (transitions) VALUES (?)", (serialized,)
+            )
+            self.conn.commit()
+            self.cur_memory = []
 
-        # All of the states for a game are stored, in order, in a deque.
-        # A set of ordered states representing a complete game will be returned
-        elif self._mem_type == MEM_TYPE.RANDOM_GAME:
-            self.cur_memory.append(transition)
-            state, action, reward, next_state, done = transition
-            if done:
-                self.memories.append(self.cur_memory)
-                self.cur_memory = []
+    def close(self):
+        """Close the database connection."""
+        self.conn.close()
 
     def get_random_game(self):
-        if len(self.memories) >= self.min_games:
-            rand_game = random.sample(self.memories, 1)
-            return rand_game
-        else:
-            return False
+        """Return a random full game from the database."""
+        self.cursor.execute("SELECT id FROM games")
+        all_ids = [row[0] for row in self.cursor.fetchall()]
+        if len(all_ids) >= self.min_games:
+            rand_id = random.choice(all_ids)
+            self.cursor.execute("SELECT transitions FROM games WHERE id=?", (rand_id,))
+            row = self.cursor.fetchone()
+            if row:
+                return pickle.loads(row[0])
+        return False
 
     def get_random_states(self):
         mem_size = len(self.memories)
@@ -78,8 +102,21 @@ class ReplayMemory:
         elif self._mem_type == MEM_TYPE.RANDOM_GAME:
             return self.get_random_game()
 
-    def get_num_memories(self):
-        return len(self.memories)
+    def get_num_games(self):
+        """Return number of games stored in the database."""
+        self.cursor.execute("SELECT COUNT(*) FROM games")
+        return self.cursor.fetchone()[0]
+
+    def init_db(self):
+        self.cursor.execute(
+            """
+        CREATE TABLE IF NOT EXISTS games (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            transitions TEXT NOT NULL
+        )
+        """
+        )
+        self.conn.commit()
 
     def mem_type(self, mem_type=None):
         if mem_type is not None:

ai_snake_lab/ai/models/ModelL.py

@@ -12,15 +12,18 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
+from ai_snake_lab.constants.DSim import DSim
+from ai_snake_lab.constants.DModelL import DModelL
+
 
 class ModelL(nn.Module):
     def __init__(self, seed: int):
         super(ModelL, self).__init__()
         torch.manual_seed(seed)
-        input_size = 27  # Size of the "state" as tracked by the GameBoard
-        hidden_size = 170
-        output_size = 3
-        p_value = 0.1
+        input_size = DSim.STATE_SIZE  # Size of the "state" as tracked by the GameBoard
+        hidden_size = DModelL.HIDDEN_SIZE
+        output_size = DSim.OUTPUT_SIZE
+        p_value = DModelL.P_VALUE
         self.input_block = nn.Sequential(
             nn.Linear(input_size, hidden_size),
             nn.ReLU(),

ai_snake_lab/ai/models/ModelRNN.py

@@ -17,7 +17,7 @@ class ModelRNN(nn.Module):
     def __init__(self, seed: int):
         super(ModelRNN, self).__init__()
         torch.manual_seed(seed)
-        input_size = 27
+        input_size = 30
         hidden_size = 200
         output_size = 3
         rnn_layers = 4

ai_snake_lab/constants/DDb4EPlot.py

@@ -0,0 +1,20 @@
+"""
+constants/DDb4EPlot.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from ai_snake_lab.utils.ConstGroup import ConstGroup
+
+
+class Plot(ConstGroup):
+    """Db4EPlot Constants"""
+
+    # Simulation loop states
+    AVERAGE: str = "average"
+    SLIDING: str = "sliding"
+    MAX_DATA_POINTS: int = 200

ai_snake_lab/constants/DDef.py

@@ -8,11 +8,11 @@ constants/DDef.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DDef(ConstGroup):
     """Defaults"""
 
-    APP_TITLE: str = "AI Snake Game Simulator"
+    APP_TITLE: str = "AI Snake Game Lab"
     MOVE_DELAY: float = 0.0

ai_snake_lab/constants/DDir.py

@@ -8,9 +8,12 @@ constants/DDir.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DDir(ConstGroup):
     """Directories"""
-    UTILS : str = "utils"
+
+    AI_SNAKE_LAB: str = "ai_snake_lab"
+    DB: str = "db"
+    UTILS: str = "utils"

ai_snake_lab/constants/DEpsilon.py

@@ -8,7 +8,7 @@ constants/DEpsilon.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DEpsilon(ConstGroup):

ai_snake_lab/constants/DFields.py

@@ -8,11 +8,17 @@ constants/DFields.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DField(ConstGroup):
     """Fields"""
 
+    # Simulation loop states
+    PAUSED: str = "paused"
     RUNNING: str = "running"
     STOPPED: str = "stopped"
+
+    # Stats dictionary keys
+    GAME_SCORE: str = "game_score"
+    GAME_NUM: str = "game_num"

ai_snake_lab/constants/DFile.py

@@ -8,10 +8,11 @@ constants/DFile.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DFile(ConstGroup):
     """Files"""
 
-    CSS_PATH: str = "AISim.tcss"
+    CSS_FILE: str = "AISim.tcss"
+    REPLAY_DB: str = "replay_mem.db"

ai_snake_lab/constants/DLabels.py

@@ -8,27 +8,47 @@ constants/DLabels.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.ai.models.ModelL import ModelL
+from ai_snake_lab.ai.models.ModelRNN import ModelRNN
+
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DLabel(ConstGroup):
     """Labels"""
 
+    AVERAGE: str = "Average"
+    CURRENT: str = "Current"
+    CURRENT_EPSILON: str = "Current Epsilon"
+    DEFAULTS: str = "Defaults"
     EPSILON: str = "Epsilon"
     EPSILON_DECAY: str = "Epsilon Decay"
     EPSILON_INITIAL: str = "Initial Epsilon"
     EPSILON_MIN: str = "Minimum Epsilon"
     GAME: str = "Game"
+    GAMES: str = "Games"
+    GAME_SCORE: str = "Game Score"
+    GAME_NUM: str = "Game Number"
     HIGHSCORE: str = "Highscore"
     MEM_TYPE: str = "Memory Type"
-    MEMORIES: str = "Memories"
     MIN_EPSILON: str = "Minimum Epsilon"
+    MODEL_LINEAR: str = "Linear"
+    MODEL_RNN: str = "RNN"
+    MODEL_TYPE: str = "Model Type"
     MOVE_DELAY: str = "Move Delay"
     PAUSE: str = "Pause"
     QUIT: str = "Quit"
-    RUNTIME: str = "Runtime Values"
+    RESTART: str = "Restart"
+    RUNTIME: str = "Runtime"
+    RUNTIME_VALUES: str = "Runtime Values"
     SCORE: str = "Score"
     SETTINGS: str = "Configuration Settings"
     START: str = "Start"
-    RESET: str = "Reset"
+    STORED_GAMES: str = "Stored Games"
+    RESTART: str = "Restart"
     UPDATE: str = "Update"
+
+    MODEL_TYPE_TABLE: dict = {
+        str(ModelL): MODEL_LINEAR,
+        ModelRNN: MODEL_RNN,
+    }

ai_snake_lab/constants/DLayout.py

@@ -8,22 +8,35 @@ constants/DLayout.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DLayout(ConstGroup):
     """Layout"""
 
+    BUTTON_BOX: str = "button_box"
     BUTTON_PAUSE: str = "button_pause"
     BUTTON_QUIT: str = "button_quit"
+    BUTTON_RESTART: str = "button_restart"
     BUTTON_ROW: str = "button_row"
     BUTTON_START: str = "button_start"
-    BUTTON_RESET: str = "button_reset"
+    BUTTON_DEFAULTS: str = "button_defaults"
     BUTTON_UPDATE: str = "button_update"
     CUR_EPSILON: str = "cur_epsilon"
     CUR_MEM_TYPE: str = "cur_mem_type"
+    CUR_MODEL_TYPE: str = "cur_model_type"
+    FILLER_1: str = "filler_1"
+    FILLER_2: str = "filler_2"
+    FILLER_3: str = "filler_3"
+    FILLER_4: str = "filler_4"
+    FILLER_5: str = "filler_5"
+    FILLER_6: str = "filler_6"
+    FILLER_7: str = "filler_7"
+    FILLER_8: str = "filler_8"
     GAME_BOARD: str = "game_board"
     GAME_BOX: str = "game_box"
+    GAME_SCORE: str = "game_score"
+    GAME_SCORE_PLOT: str = "game_score_plot"
     EPSILON_DECAY: str = "epsilon_decay"
     EPSILON_INITIAL: str = "initial_epsilon"
     EPSILON_MIN: str = "epsilon_min"
@@ -31,8 +44,9 @@ class DLayout(ConstGroup):
     LABEL: str = "label"
     LABEL_SETTINGS: str = "label_settings"
     MOVE_DELAY: str = "move_delay"
-    NUM_MEMORIES: str = "num_memories"
+    NUM_GAMES: str = "num_games"
     RUNTIME_BOX: str = "runtime_box"
+    RUNTIME: str = "runtime"
     SCORE: str = "score"
     SETTINGS_BOX: str = "settings_box"
     TITLE: str = "title"

ai_snake_lab/constants/DModelL.py

@@ -8,10 +8,14 @@ constants/DModelL.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DModelL(ConstGroup):
     """Linear Model Defaults"""
 
     LEARNING_RATE: float = 0.000009
+    # The number of nodes in the hidden layer
+    HIDDEN_SIZE: int = 170
+    # The dropout value, 0.2 represents 20%
+    P_VALUE: float = 0.2

ai_snake_lab/constants/DModelLRNN.py

@@ -8,7 +8,7 @@ constants/DModelRNN.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class DModelRNN(ConstGroup):

ai_snake_lab/constants/DReplayMemory.py

@@ -8,7 +8,7 @@ constants/DReplayMemory.py
     License: GPL 3.0
 """
 
-from utils.ConstGroup import ConstGroup
+from ai_snake_lab.utils.ConstGroup import ConstGroup
 
 
 class MEM_TYPE(ConstGroup):

ai_snake_lab/constants/DSim.py

@@ -0,0 +1,20 @@
+"""
+constants/DGameBoard.py
+
+    AI Snake Game Simulator
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/ai
+    License: GPL 3.0
+"""
+
+from ai_snake_lab.utils.ConstGroup import ConstGroup
+
+
+class DSim(ConstGroup):
+    """Simulation Constants"""
+
+    # Size of the statemap, this is from the GameBoard class
+    STATE_SIZE: int = 30
+    # The number of "choices" the snake has: go forward, left or right.
+    OUTPUT_SIZE: int = 3

ai_snake_lab/game/GameBoard.py

@@ -68,6 +68,19 @@ class GameBoard(ScrollView):
     def board_size(self) -> int:
         return self._board_size
 
+    def get_binary(self, bits_needed, some_int):
+        # This is used in the state map, the get_state() function.
+        some_int = int(some_int)
+        bin_str = format(some_int, "b")
+        out_list = []
+        for bit in range(len(bin_str)):
+            out_list.append(bin_str[bit])
+        for zero in range(bits_needed - len(out_list)):
+            out_list.insert(0, "0")
+        for x in range(bits_needed):
+            out_list[x] = int(out_list[x])
+        return out_list
+
     def get_state(self):
 
         head = self.snake_head
@@ -80,7 +93,7 @@ class GameBoard(ScrollView):
         dir_r = direction == Direction.RIGHT
         dir_u = direction == Direction.UP
         dir_d = direction == Direction.DOWN
-
+        slb = self.get_binary(7, len(self.snake_body))
         state = [
             # 1. Snake collision straight ahead
             (dir_r and self.is_snake_collision(point_r))
@@ -97,47 +110,48 @@ class GameBoard(ScrollView):
             or (dir_u and self.is_snake_collision(point_l))
             or (dir_r and self.is_snake_collision(point_u))
             or (dir_l and self.is_snake_collision(point_d)),
-            # 4. divider
-            0,
-            # 5. Wall collision straight ahead
+            # 4. Wall collision straight ahead
             (dir_r and self.is_wall_collision(point_r))
             or (dir_l and self.is_wall_collision(point_l))
             or (dir_u and self.is_wall_collision(point_u))
             or (dir_d and self.is_wall_collision(point_d)),
-            # 6. Wall collision to the right
+            # 5. Wall collision to the right
             (dir_u and self.is_wall_collision(point_r))
             or (dir_d and self.is_wall_collision(point_l))
             or (dir_l and self.is_wall_collision(point_u))
             or (dir_r and self.is_wall_collision(point_d)),
-            # 7. Wall collision to the left
+            # 6. Wall collision to the left
             (dir_d and self.is_wall_collision(point_r))
             or (dir_u and self.is_wall_collision(point_l))
             or (dir_r and self.is_wall_collision(point_u))
             or (dir_l and self.is_wall_collision(point_d)),
-            # 8. divider
-            0,
-            # 9, 10, 11, 12. Last move direction
+            # 7 - 10. Last move direction
             dir_l,
             dir_r,
             dir_u,
             dir_d,
-            # 13. divider
-            0,
-            # 14 - 23. Food location
-            self.food.x < self.snake_head.x,  # Food left
-            self.food.x > self.snake_head.x,  # Food right
-            self.food.y < self.snake_head.y,  # Food up
-            self.food.y > self.snake_head.y,  # Food down
-            self.food.x == self.snake_head.x,
+            # 11 - 19. Food location
+            self.food.x < self.snake_head.x,  # 11. Food left
+            self.food.x > self.snake_head.x,  # 12. Food right
+            self.food.y < self.snake_head.y,  # 13. Food up
+            self.food.y > self.snake_head.y,  # 14. Food down
+            self.food.x == self.snake_head.x,  # 15.
             self.food.x == self.snake_head.x
-            and self.food.y > self.snake_head.y,  # Food ahead
+            and self.food.y > self.snake_head.y,  # 16. Food ahead
             self.food.x == self.snake_head.x
-            and self.food.y < self.snake_head.y,  # Food behind
-            self.food.y == self.snake_head.y,
+            and self.food.y < self.snake_head.y,  # 17. Food behind
             self.food.y == self.snake_head.y
-            and self.food.x > self.snake_head.x,  # Food above
+            and self.food.x > self.snake_head.x,  # 18. Food above
             self.food.y == self.snake_head.y
-            and self.food.x < self.snake_head.x,  # Food below
+            and self.food.x < self.snake_head.x,  # 19. Food below
+            # 20 - 26. Snake length in binary
+            slb[0],
+            slb[1],
+            slb[2],
+            slb[3],
+            slb[4],
+            slb[5],
+            slb[6],
         ]
 
         # 24, 25, 26 and 27. Previous direction of the snake

ai_snake_lab/game/SnakeGame.py

@@ -54,6 +54,9 @@ class SnakeGame:
         self.game_board.update_snake(snake=self.snake, direction=self.direction)
         self.game_board.update_food(food=self.food)
 
+        # Track the distance from the snake head to the food to feed the reward system
+        self.distance_to_food = self.game_board.board_size() // 2
+
         # The current game score
         self.game_score = 0
 
@@ -126,6 +129,12 @@ class SnakeGame:
             game_over = True
             reward = -10
 
+        # Set a negative reward if the snake head is adjacent to the snake body.
+        # This is to discourage snake collisions.
+        for segment in self.snake[1:]:
+            if abs(self.head.x - segment.x) < 2 and abs(self.head.y - segment.y) < 2:
+                reward -= -1
+
         if game_over == True:
             # Game is over: Snake or wall collision or exceeded max moves
             self.game_reward += reward
@@ -142,6 +151,14 @@ class SnakeGame:
         else:
             self.snake.pop()
 
+        ## 5. See if we're closer to the food than the last move, or further away
+        cur_distance = abs(self.head.x - self.food.x) + abs(self.head.y - self.food.y)
+        if cur_distance < self.distance_to_food:
+            reward += 2
+        elif cur_distance > self.distance_to_food:
+            reward -= 2
+        self.distance_to_food = cur_distance
+
         self.game_reward += reward
         self.game_board.update_snake(snake=self.snake, direction=self.direction)
         self.game_board.update_food(food=self.food)