ai-snake-lab 0.1.0__py3-none-any.whl → 0.4.3__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 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

@@ -14,5 +14,5 @@ from 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

@@ -13,4 +13,7 @@ from 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/DFields.py

@@ -14,5 +14,11 @@ from 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

@@ -14,4 +14,5 @@ from 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

@@ -14,16 +14,29 @@ from 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

@@ -15,3 +15,7 @@ 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/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 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)

ai_snake_lab/ui/Db4EPlot.py

@@ -0,0 +1,160 @@
+"""
+db4e/Modules/Db4EPlot.py
+
+    Database 4 Everything
+    Author: Nadim-Daniel Ghaznavi
+    Copyright: (c) 2024-2025 Nadim-Daniel Ghaznavi
+    GitHub: https://github.com/NadimGhaznavi/db4e
+    License: GPL 3.0
+"""
+
+import math
+from collections import deque
+from textual_plot import PlotWidget, HiResMode, LegendLocation
+from textual.app import ComposeResult
+
+from ai_snake_lab.constants.DDb4EPlot import Plot
+from ai_snake_lab.constants.DLabels import DLabel
+
+
+MAX_DATA_POINTS = Plot.MAX_DATA_POINTS
+
+
+class Db4EPlot(PlotWidget):
+    """
+    A widget for plotting data based on TextualPlot's PlotWidget.
+    """
+
+    def __init__(self, title, id, thin_method=None):
+        super().__init__(title, id, allow_pan_and_zoom=False)
+        self._plot_id = id
+        self._title = title
+        self._thin_method = thin_method
+        if thin_method == Plot.SLIDING:
+            self._all_days = deque(maxlen=MAX_DATA_POINTS)
+            self._all_values = deque(maxlen=MAX_DATA_POINTS)
+        else:
+            self._all_days = None
+            self._all_values = None
+
+    def compose(self) -> ComposeResult:
+        yield PlotWidget()
+
+    def load_data(self, days, values, units):
+        self._all_days = days
+        self._all_values = values
+        if units:
+            self.set_ylabel(self._title + " (" + units + ")")
+        else:
+            self.set_ylabel(self._title)
+
+    def add_data(self, day, value):
+        self._all_days.append(day)
+        self._all_values.append(value)
+
+    def set_xlabel(self, label):
+        return super().set_xlabel(label)
+
+    def db4e_plot(self, days=None, values=None) -> None:
+        if days is not None and values is not None:
+            plot_days = days
+            plot_values = values
+        else:
+            plot_days = self._all_days
+            plot_values = self._all_values
+        self.clear()
+        if len(plot_days) == 0:
+            return
+        if self._thin_method == Plot.AVERAGE:
+            reduced_days, reduced_values = self.reduce_data(plot_days, plot_values)
+        else:
+            reduced_days, reduced_values = list(self._all_days), list(self._all_values)
+
+        self.plot(
+            x=reduced_days,
+            y=reduced_values,
+            hires_mode=HiResMode.BRAILLE,
+            line_style="green",
+            label=DLabel.CURRENT,
+        )
+
+        # Add an average plot over 20 to wash out the spikes and identify when the
+        # AI is maxing out.
+        window = max(1, len(reduced_values) // 20)  # e.g., 5% smoothing window
+        if len(reduced_values) > window:
+            smoothed = [
+                sum(reduced_values[i : i + window])
+                / len(reduced_values[i : i + window])
+                for i in range(len(reduced_values) - window + 1)
+            ]
+            smoothed_days = reduced_days[window - 1 :]
+            self.plot(
+                x=smoothed_days,
+                y=smoothed,
+                hires_mode=HiResMode.BRAILLE,
+                line_style="red",  # distinct color for trend
+                label=DLabel.AVERAGE,
+            )
+        self.show_legend(location=LegendLocation.TOPLEFT)
+
+    def reduce_data2(self, times, values):
+        # Reduce the total number of data points, otherwise the plot gets "blurry"
+        step = max(1, len(times) // MAX_DATA_POINTS)
+
+        # Reduce times with step
+        reduced_times = times[::step]
+
+        # Bin values by step (average)
+        reduced_values = [
+            sum(values[i : i + step]) / len(values[i : i + step])
+            for i in range(0, len(values), step)
+        ]
+        results = reduced_times[: len(reduced_values)], reduced_values
+        return results
+
+    def reduce_data(self, times, values):
+        """Reduce times and values into <= MAX_DATA_POINTS bins.
+        Each bin's value is the average of the values in the bin.
+        Each bin's time is chosen as the last time in the bin (so last bin -> times[-1]).
+        """
+        if not times or not values:
+            return [], []
+
+        assert len(times) == len(values), "times and values must be same length"
+
+        step = max(1, math.ceil(len(times) / MAX_DATA_POINTS))
+
+        reduced_times = []
+        reduced_values = []
+        for i in range(0, len(times), step):
+            chunk_times = times[i : i + step]
+            chunk_vals = values[i : i + step]
+
+            # average values (works for floats or Decimal)
+            avg_val = sum(chunk_vals) / len(chunk_vals)
+
+            # representative time: choose last item in the chunk so final rep is times[-1]
+            rep_time = chunk_times[-1]
+
+            reduced_times.append(rep_time)
+            reduced_values.append(avg_val)
+
+        # Guarantee the final time equals the exact last time (safety)
+        if reduced_times:
+            reduced_times[-1] = times[-1]
+
+        return reduced_times, reduced_values
+
+    def update_time_range(self, selected_time):
+        if selected_time == -1:
+            return
+
+        selected_time = int(selected_time)
+        max_length = len(self._all_days)
+        if selected_time > max_length:
+            new_values = self._all_values
+            new_times = self._all_days
+        else:
+            new_values = self._all_values[-selected_time:]
+            new_times = self._all_days[-selected_time:]
+        self.db4e_plot(new_times, new_values)