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

ai_snake_lab/AISim.py

@@ -0,0 +1,274 @@
+"""
+AISim.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
+"""
+
+import threading
+import time
+import sys
+
+from textual.app import App, ComposeResult
+from textual.widgets import Label, Input, Button
+from textual.containers import Vertical, Horizontal
+from textual.reactive import var
+
+from constants.DDef import DDef
+from constants.DEpsilon import DEpsilon
+from constants.DFields import DField
+from constants.DFile import DFile
+from constants.DLayout import DLayout
+from constants.DLabels import DLabel
+from constants.DReplayMemory import MEM_TYPE
+
+from ai.AIAgent import AIAgent
+from ai.EpsilonAlgo import EpsilonAlgo
+from game.GameBoard import GameBoard
+from game.SnakeGame import SnakeGame
+
+RANDOM_SEED = 1970
+
+
+class AISim(App):
+    """A Textual app that has an AI Agent playing the Snake Game."""
+
+    TITLE = DDef.APP_TITLE
+    CSS_PATH = DFile.CSS_PATH
+
+    ## Runtime values
+    # Current epsilon value (degrades in real-time)
+    cur_epsilon_widget = Label("N/A", id=DLayout.CUR_EPSILON)
+    # Current memory type
+    cur_mem_type_widget = Label("N/A", id=DLayout.CUR_MEM_TYPE)
+    # Number of stored memories
+    cur_num_memories_widget = Label("N/A", id=DLayout.NUM_MEMORIES)
+    # Runtime move delay value
+    cur_move_delay = DDef.MOVE_DELAY
+
+    # Intial Settings for Epsilon
+    initial_epsilon_input = Input(
+        restrict=f"0.[0-9]*",
+        compact=True,
+        id=DLayout.EPSILON_INITIAL,
+        classes=DLayout.INPUT_10,
+    )
+    epsilon_min_input = Input(
+        restrict=f"0.[0-9]*",
+        compact=True,
+        id=DLayout.EPSILON_MIN,
+        classes=DLayout.INPUT_10,
+    )
+    epsilon_decay_input = Input(
+        restrict=f"0.[0-9]*",
+        compact=True,
+        id=DLayout.EPSILON_DECAY,
+        classes=DLayout.INPUT_10,
+    )
+    move_delay_input = Input(
+        restrict=f"[0-9]*.[0-9]*",
+        compact=True,
+        id=DLayout.MOVE_DELAY,
+        classes=DLayout.INPUT_10,
+    )
+
+    # Buttons
+    pause_button = Button(label=DLabel.PAUSE, id=DLayout.BUTTON_PAUSE, compact=True)
+    start_button = Button(label=DLabel.START, id=DLayout.BUTTON_START, compact=True)
+    quit_button = Button(label=DLabel.QUIT, id=DLayout.BUTTON_QUIT, compact=True)
+    reset_button = Button(label=DLabel.RESET, id=DLayout.BUTTON_RESET, compact=True)
+    update_button = Button(label=DLabel.UPDATE, id=DLayout.BUTTON_UPDATE, compact=True)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.game_board = GameBoard(20, id=DLayout.GAME_BOARD)
+        self.snake_game = SnakeGame(game_board=self.game_board, id=DLayout.GAME_BOARD)
+        self.epsilon_algo = EpsilonAlgo(seed=RANDOM_SEED)
+        self.agent = AIAgent(self.epsilon_algo, seed=RANDOM_SEED)
+        self.running = False
+
+        self.score = Label("Game: 0, Highscore: 0, Score: 0")
+
+        # Setup the simulator in a background thread
+        self.stop_event = threading.Event()
+        self.simulator_thread = threading.Thread(target=self.start_sim, daemon=True)
+
+    async def action_quit(self) -> None:
+        """Quit the application."""
+        self.stop_event.set()
+        if self.simulator_thread.is_alive():
+            self.simulator_thread.join(timeout=2)
+        await super().action_quit()
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        yield Label(DDef.APP_TITLE, id=DLayout.TITLE)
+        yield Horizontal(
+            Vertical(
+                Vertical(
+                    Horizontal(
+                        Label(
+                            f"{DLabel.EPSILON_INITIAL} : ",
+                            classes=DLayout.LABEL_SETTINGS,
+                        ),
+                        self.initial_epsilon_input,
+                    ),
+                    Horizontal(
+                        Label(
+                            f"{DLabel.EPSILON_DECAY}   : ",
+                            classes=DLayout.LABEL_SETTINGS,
+                        ),
+                        self.epsilon_decay_input,
+                    ),
+                    Horizontal(
+                        Label(
+                            f"{DLabel.EPSILON_MIN} : ", classes=DLayout.LABEL_SETTINGS
+                        ),
+                        self.epsilon_min_input,
+                    ),
+                    Horizontal(
+                        Label(
+                            f"{DLabel.MOVE_DELAY}      : ",
+                            classes=DLayout.LABEL_SETTINGS,
+                        ),
+                        self.move_delay_input,
+                    ),
+                    id=DLayout.SETTINGS_BOX,
+                ),
+                Vertical(
+                    Horizontal(
+                        self.start_button,
+                        self.reset_button,
+                        self.update_button,
+                        self.quit_button,
+                    ),
+                    id=DLayout.BUTTON_ROW,
+                ),
+            ),
+            Vertical(
+                self.game_board,
+                id=DLayout.GAME_BOX,
+            ),
+            Vertical(
+                Horizontal(
+                    Label(f"{DLabel.EPSILON} : ", classes=DLayout.LABEL),
+                    self.cur_epsilon_widget,
+                ),
+                Horizontal(
+                    Label(f"{DLabel.MEM_TYPE} : ", classes=DLayout.LABEL),
+                    self.cur_mem_type_widget,
+                ),
+                Horizontal(
+                    Label(f"{DLabel.MEMORIES} : ", classes=DLayout.LABEL),
+                    self.cur_num_memories_widget,
+                ),
+                id=DLayout.RUNTIME_BOX,
+            ),
+        )
+
+    def on_mount(self):
+        self.initial_epsilon_input.value = str(DEpsilon.EPSILON_INITIAL)
+        self.epsilon_decay_input.value = str(DEpsilon.EPSILON_DECAY)
+        self.epsilon_min_input.value = str(DEpsilon.EPSILON_MIN)
+        self.move_delay_input.value = str(DDef.MOVE_DELAY)
+        settings_box = self.query_one(f"#{DLayout.SETTINGS_BOX}", Vertical)
+        settings_box.border_title = DLabel.SETTINGS
+        runtime_box = self.query_one(f"#{DLayout.RUNTIME_BOX}", Vertical)
+        runtime_box.border_title = DLabel.RUNTIME
+        self.cur_mem_type_widget.update(
+            MEM_TYPE.MEM_TYPE_TABLE[self.agent.memory.mem_type()]
+        )
+        self.cur_num_memories_widget.update(str(self.agent.memory.get_num_memories()))
+        # Initial state is that the app is stopped
+        self.add_class(DField.STOPPED)
+
+    def on_quit(self):
+        if self.running == True:
+            self.stop_event.set()
+            if self.simulator_thread.is_alive():
+                self.simulator_thread.join()
+        sys.exit(0)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id
+        # Start button was pressed
+        if button_id == DLayout.BUTTON_START:
+            self.start_thread()
+            self.running = True
+            self.add_class(DField.RUNNING)
+            self.remove_class(DField.STOPPED)
+            self.cur_move_delay = float(self.move_delay_input.value)
+        # Reset button was pressed
+        elif button_id == DLayout.BUTTON_RESET:
+            self.initial_epsilon_input.value = str(DEpsilon.EPSILON_INITIAL)
+            self.epsilon_decay_input.value = str(DEpsilon.EPSILON_DECAY)
+            self.epsilon_min_input.value = str(DEpsilon.EPSILON_MIN)
+            self.move_delay_input.value = str(DDef.MOVE_DELAY)
+        # Quit button was pressed
+        elif button_id == DLayout.BUTTON_QUIT:
+            self.on_quit()
+        # Update button was pressed
+        elif button_id == DLayout.BUTTON_UPDATE:
+            self.cur_move_delay = float(self.move_delay_input.value)
+
+    def start_sim(self):
+        self.snake_game.reset()
+        game_board = self.game_board
+        agent = self.agent
+        snake_game = self.snake_game
+        score = 0
+        highscore = 0
+        self.epoch = 1
+        game_box = self.query_one(f"#{DLayout.GAME_BOX}", Vertical)
+        game_box.border_title = f"{DLabel.GAME} #{self.epoch}"
+
+        while not self.stop_event.is_set():
+            # The actual training loop...
+            old_state = game_board.get_state()
+            move = agent.get_move(old_state)
+            reward, game_over, score = snake_game.play_step(move)
+            if score > highscore:
+                highscore = score
+            game_box.border_subtitle = (
+                f"{DLabel.HIGHSCORE}: {highscore}, {DLabel.SCORE}: {score}"
+            )
+            if not game_over:
+                ## Keep playing
+                time.sleep(self.cur_move_delay)
+                new_state = game_board.get_state()
+                agent.train_short_memory(old_state, move, reward, new_state, game_over)
+                agent.remember(old_state, move, reward, new_state, game_over)
+            else:
+                ## Game over
+                self.epoch += 1
+                game_box = self.query_one(f"#{DLayout.GAME_BOX}", Vertical)
+                game_box.border_title = f"{DLabel.GAME} #{self.epoch}"
+                # Remember the last move
+                agent.remember(old_state, move, reward, new_state, game_over)
+                # Train long memory
+                agent.train_long_memory()
+                # Reset the game
+                snake_game.reset()
+                # Let the agent know we've finished a game
+                agent.played_game(score)
+                # Get the current epsilon value
+                cur_epsilon = self.epsilon_algo.epsilon()
+                if cur_epsilon < 0.0001:
+                    self.cur_epsilon_widget.update("0.0000")
+                else:
+                    self.cur_epsilon_widget.update(str(round(cur_epsilon, 4)))
+                # Update the number of stored memories
+                self.cur_num_memories_widget.update(
+                    str(self.agent.memory.get_num_memories())
+                )
+
+    def start_thread(self):
+        self.simulator_thread.start()
+
+
+if __name__ == "__main__":
+    app = AISim()
+    app.run()

ai_snake_lab/ai/AIAgent.py

@@ -0,0 +1,84 @@
+"""
+ai/Agent.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
+"""
+
+import torch
+from ai.EpsilonAlgo import EpsilonAlgo
+from ai.ReplayMemory import ReplayMemory
+from ai.AITrainer import AITrainer
+from ai.models.ModelL import ModelL
+from ai.models.ModelRNN import ModelRNN
+
+from constants.DReplayMemory import MEM_TYPE
+
+
+class AIAgent:
+
+    def __init__(self, epsilon_algo: EpsilonAlgo, seed: int):
+        self.epsilon_algo = epsilon_algo
+        self.memory = ReplayMemory(seed=seed)
+        self.model = ModelL(seed=seed)
+        # self.model = ModelRNN(seed=seed)
+        self.trainer = AITrainer(self.model)
+
+        if type(self.model) == ModelRNN:
+            self.memory.mem_type(MEM_TYPE.RANDOM_GAME)
+
+    def get_model(self):
+        return self.model
+
+    def get_move(self, state):
+        random_move = self.epsilon_algo.get_move()  # Explore with epsilon
+        if random_move != False:
+            return random_move  # Random move was returned
+
+        # Exploit with an AI agent based action
+        final_move = [0, 0, 0]
+        if type(state) != torch.Tensor:
+            state = torch.tensor(state, dtype=torch.float)  # Convert to a tensor
+        prediction = self.model(state)  # Get the prediction
+        move = torch.argmax(prediction).item()  # Select the move with the highest value
+        final_move[move] = 1  # Set the move
+        return final_move  # Return
+
+    def get_optimizer(self):
+        return self.trainer.get_optimizer()
+
+    def played_game(self, score):
+        self.epsilon_algo.played_game()
+
+    def remember(self, state, action, reward, next_state, done):
+        # Store the state, action, reward, next_state, and done in memory
+        self.memory.append((state, action, reward, next_state, done))
+
+    def set_model(self, model):
+        self.model = model
+
+    def set_optimizer(self, optimizer):
+        self.trainer.set_optimizer(optimizer)
+
+    def train_long_memory(self):
+        # Get the states, actions, rewards, next_states, and dones from the mini_sample
+        memory = self.memory.get_memory()
+        memory_type = self.memory.mem_type()
+
+        if type(self.model) == ModelRNN:
+            for state, action, reward, next_state, done in memory[0]:
+                self.trainer.train_step(state, action, reward, next_state, [done])
+
+        elif memory_type == MEM_TYPE.SHUFFLE:
+            for state, action, reward, next_state, done in memory:
+                self.trainer.train_step(state, action, reward, next_state, [done])
+
+        else:
+            for state, action, reward, next_state, done in memory[0]:
+                self.trainer.train_step(state, action, reward, next_state, [done])
+
+    def train_short_memory(self, state, action, reward, next_state, done):
+        self.trainer.train_step(state, action, reward, next_state, [done])

ai_snake_lab/ai/AITrainer.py

@@ -0,0 +1,90 @@
+"""
+ai/AITrainer.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
+"""
+
+import torch.optim as optim
+import torch.nn as nn
+import torch
+import numpy as np
+import time
+import sys
+
+from ai.models.ModelL import ModelL
+from ai.models.ModelRNN import ModelRNN
+
+from constants.DModelL import DModelL
+from constants.DModelLRNN import DModelRNN
+
+
+class AITrainer:
+
+    def __init__(self, model):
+        torch.manual_seed(1970)
+        self.model = model
+        # The learning rate needs to be adjusted for the model type
+        if type(model) == ModelL:
+            learning_rate = DModelL.LEARNING_RATE
+        elif type(model) == ModelRNN:
+            learning_rate = DModelRNN.LEARNING_RATE
+        self.optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)
+        self.criterion = nn.MSELoss()
+        self.gamma = 0.9
+
+    def get_optimizer(self):
+        return self.optimizer
+
+    def set_optimizer(self, optimizer):
+        self.optimizer = optimizer
+
+    def train_step_cnn(self, state, action, reward, next_state, game_over):
+        state = torch.tensor(np.array(state), dtype=torch.float)
+        next_state = torch.tensor(np.array(next_state), dtype=torch.float)
+        action = torch.tensor(action, dtype=torch.long)
+        reward = torch.tensor(reward, dtype=torch.float)
+        pred = self.model(state)
+        target = pred.clone()
+        if game_over:
+            Q_new = reward  # No future rewards, the game is over.
+        else:
+            Q_new = reward + self.gamma * torch.max(self.model(next_state).detach())
+        target[0][action.argmax().item()] = Q_new  # Update Q value
+        self.optimizer.zero_grad()  # Reset gradients
+        loss = self.criterion(target, pred)  # Calculate the loss
+        loss.backward()
+        self.optimizer.step()  # Adjust the weights
+
+    def train_step(self, state, action, reward, next_state, game_over):
+        state = torch.tensor(np.array(state), dtype=torch.float)
+        next_state = torch.tensor(np.array(next_state), dtype=torch.float)
+        action = torch.tensor(action, dtype=torch.long)
+        reward = torch.tensor(reward, dtype=torch.float)
+        if len(state.shape) == 1:
+            # Add a batch dimension
+            state = torch.unsqueeze(state, 0)
+            next_state = torch.unsqueeze(next_state, 0)
+            action = torch.unsqueeze(action, 0)
+            reward = torch.unsqueeze(reward, 0)
+            game_over = (game_over,)
+
+        pred = self.model(state)
+        target = pred.clone().detach()
+
+        for idx in range(len(game_over)):
+            Q_new = reward[idx]
+            if not game_over[idx][0]:
+                Q_new = reward[idx] + self.gamma * torch.max(
+                    self.model(next_state[idx])
+                )
+            target[idx][action[idx].argmax().item()] = Q_new  # Update Q value
+
+        self.optimizer.zero_grad()  # Reset gradients
+
+        loss = self.criterion(target, pred)  # Calculate the loss
+        loss.backward()
+        self.optimizer.step()  # Adjust the weights

ai_snake_lab/ai/EpsilonAlgo.py

@@ -0,0 +1,73 @@
+"""
+ai/EpsilonAlgo.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
+
+
+A class to encapsulate the functionality of the epsilon algorithm. The algorithm
+injects random moves at the beginning of the simulation. The amount of moves
+is controlled by the epsilon_value parameter which is in the AISnakeGame.ini and
+can also be passed in when invoking the main asg.py front end.
+"""
+
+import random
+from random import randint
+import os, sys
+
+from constants.DEpsilon import DEpsilon
+
+
+class EpsilonAlgo:
+
+    def __init__(self, seed):
+        # Set this random seed so things are repeatable
+        random.seed(seed)
+        self._initial_epsilon = DEpsilon.EPSILON_INITIAL
+        self._epsilon_min = DEpsilon.EPSILON_MIN
+        self._epsilon_decay = DEpsilon.EPSILON_DECAY
+        self._epsilon = self._initial_epsilon
+        self._num_games = 0
+        self._injected = 0
+        self._depleted = False
+
+    def get_move(self):
+        if random.random() < self._epsilon:
+            rand_move = [0, 0, 0]
+            rand_idx = randint(0, 2)
+            rand_move[rand_idx] = 1
+            self._injected += 1
+            return rand_move
+        return False
+
+    def epsilon(self):
+        return self._epsilon
+
+    def epsilon_decay(self, epsilon_decay=None):
+        if epsilon_decay is not None:
+            self._epsilon_decay = epsilon_decay
+        return self._epsilon_decay
+
+    def epsilon_min(self, epsilon_min=None):
+        if epsilon_min is not None:
+            self._epsilon_min = epsilon_min
+        return self._epsilon_min
+
+    def initial_epsilon(self, initial_epsilon=None):
+        if initial_epsilon is not None:
+            self._initial_epsilon = initial_epsilon
+        return self._initial_epsilon
+
+    def injected(self):
+        return self._injected
+
+    def played_game(self):
+        self._num_games += 1
+        self._epsilon = max(self._epsilon_min, self._epsilon * self._epsilon_decay)
+        self.reset_injected()
+
+    def reset_injected(self):
+        self._injected = 0

ai_snake_lab/ai/ReplayMemory.py

@@ -0,0 +1,90 @@
+"""
+ai/ReplayMemory.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
+
+This file contains the ReplayMemory class.
+"""
+
+from collections import deque
+import random, sys
+
+from constants.DReplayMemory import MEM_TYPE
+
+
+class ReplayMemory:
+
+    def __init__(self, seed: int):
+        random.seed(seed)
+        self.batch_size = 250
+        # Valid options: shuffle, random_game, targeted_score, random_targeted_score
+        self._mem_type = MEM_TYPE.RANDOM_GAME
+        self.min_games = 1
+        self.max_states = 15000
+        self.max_shuffle_games = 40
+        self.max_games = 500
+
+        if self._mem_type == MEM_TYPE.SHUFFLE:
+            # States are stored in a deque and a random sample will be returned
+            self.memories = deque(maxlen=self.max_states)
+
+        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)
+
+    def append(self, transition):
+        ## Add 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)
+
+        # 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 get_random_game(self):
+        if len(self.memories) >= self.min_games:
+            rand_game = random.sample(self.memories, 1)
+            return rand_game
+        else:
+            return False
+
+    def get_random_states(self):
+        mem_size = len(self.memories)
+        if mem_size < self.batch_size:
+            return self.memories
+        return random.sample(self.memories, self.batch_size)
+
+    def get_memory(self):
+        if self._mem_type == MEM_TYPE.SHUFFLE:
+            return self.get_random_states()
+
+        elif self._mem_type == MEM_TYPE.RANDOM_GAME:
+            return self.get_random_game()
+
+    def get_num_memories(self):
+        return len(self.memories)
+
+    def mem_type(self, mem_type=None):
+        if mem_type is not None:
+            self._mem_type = mem_type
+        return self._mem_type
+
+    def set_memory(self, memory):
+        self.memory = memory

ai_snake_lab/ai/models/ModelL.py

@@ -0,0 +1,40 @@
+"""
+Modules/ModelL.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
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+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
+        self.input_block = nn.Sequential(
+            nn.Linear(input_size, hidden_size),
+            nn.ReLU(),
+        )
+        self.hidden_block = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.ReLU(),
+        )
+        self.dropout_block = nn.Dropout(p=p_value)
+        self.output_block = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        x = self.input_block(x)
+        x = self.hidden_block(x)
+        x = self.dropout_block(x)
+        x = self.output_block(x)
+        return x

ai_snake_lab/ai/models/ModelRNN.py

@@ -0,0 +1,43 @@
+"""
+Modules/ModelRNN.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
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ModelRNN(nn.Module):
+    def __init__(self, seed: int):
+        super(ModelRNN, self).__init__()
+        torch.manual_seed(seed)
+        input_size = 27
+        hidden_size = 200
+        output_size = 3
+        rnn_layers = 4
+        rnn_dropout = 0.2
+        self.m_in = nn.Sequential(
+            nn.Linear(input_size, hidden_size),
+            nn.ReLU(),
+        )
+        self.m_rnn = nn.RNN(
+            input_size=hidden_size,
+            hidden_size=hidden_size,
+            nonlinearity="tanh",
+            num_layers=rnn_layers,
+            dropout=rnn_dropout,
+        )
+        self.m_out = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        x = self.m_in(x)
+        inputs = x.view(1, -1, 200)
+        x, h_n = self.m_rnn(inputs)
+        x = self.m_out(x)
+        return x[len(x) - 1]