Upload 6 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+output.mp4 filter=lfs diff=lfs merge=lfs -text
+Screenshot[[:space:]]2025-11-20[[:space:]]at[[:space:]]10.45.11 AM.png filter=lfs diff=lfs merge=lfs -text
+Screenshot[[:space:]]2025-11-20[[:space:]]at[[:space:]]11.04.13 AM.png filter=lfs diff=lfs merge=lfs -text

mario_ai_app.py

@@ -0,0 +1,399 @@
+import sys
+import random
+import numpy as np
+from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
+                             QHBoxLayout, QLabel, QFrame, QGridLayout, QProgressBar)
+from PyQt5.QtCore import QTimer, Qt, pyqtSignal
+from PyQt5.QtGui import QFont, QPainter, QColor, QPen, QBrush
+import math
+
+class NeuralNetworkWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setMinimumSize(400, 300)
+        self.layers = [80, 9, 6]  # Input, Hidden, Output layers
+        self.activations = [random.random() for _ in range(sum(self.layers))]
+        self.connection_strengths = {}
+        
+    def update_activations(self, new_activations=None):
+        if new_activations:
+            self.activations = new_activations
+        else:
+            # Simulate some neural activity
+            self.activations = [max(0, min(1, x + random.uniform(-0.2, 0.2))) 
+                              for x in self.activations]
+        self.update()
+        
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        
+        # Set up colors
+        bg_color = QColor(30, 30, 40)
+        neuron_color = QColor(100, 150, 255)
+        active_neuron_color = QColor(255, 100, 100)
+        connection_color = QColor(100, 100, 150, 100)
+        
+        # Fill background
+        painter.fillRect(self.rect(), bg_color)
+        
+        width = self.width()
+        height = self.height()
+        
+        # Calculate positions for neurons
+        neuron_positions = []
+        activation_index = 0
+        
+        for layer_idx, neuron_count in enumerate(self.layers):
+            layer_positions = []
+            layer_x = (layer_idx + 1) * width / (len(self.layers) + 1)
+            
+            for neuron_idx in range(neuron_count):
+                neuron_y = (neuron_idx + 1) * height / (neuron_count + 1)
+                layer_positions.append((layer_x, neuron_y))
+                
+                # Draw connections to next layer
+                if layer_idx < len(self.layers) - 1:
+                    next_layer_count = self.layers[layer_idx + 1]
+                    for next_neuron_idx in range(next_layer_count):
+                        next_x = (layer_idx + 2) * width / (len(self.layers) + 1)
+                        next_y = (next_neuron_idx + 1) * height / (next_layer_count + 1)
+                        
+                        # Vary connection strength and color
+                        strength = random.random()
+                        alpha = int(50 + strength * 100)
+                        pen_color = QColor(connection_color)
+                        pen_color.setAlpha(alpha)
+                        
+                        painter.setPen(QPen(pen_color, 1 + strength * 2))
+                        painter.drawLine(int(layer_x), int(neuron_y), 
+                                       int(next_x), int(next_y))
+                
+                activation_index += 1
+            neuron_positions.append(layer_positions)
+        
+        # Draw neurons
+        activation_index = 0
+        for layer_idx, positions in enumerate(neuron_positions):
+            for pos_idx, (x, y) in enumerate(positions):
+                activation = self.activations[activation_index]
+                activation_index += 1
+                
+                # Determine neuron color based on activation
+                if activation > 0.7:
+                    color = active_neuron_color
+                elif activation > 0.3:
+                    color = QColor(255, 200, 100)  # Orange for medium activation
+                else:
+                    color = neuron_color
+                
+                # Draw neuron
+                radius = 8 + activation * 8
+                painter.setBrush(QBrush(color))
+                painter.setPen(QPen(QColor(200, 200, 255), 2))
+                painter.drawEllipse(int(x - radius/2), int(y - radius/2), 
+                                  int(radius), int(radius))
+
+class ControlButtonWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setup_ui()
+        
+    def setup_ui(self):
+        layout = QGridLayout()
+        layout.setSpacing(10)
+        layout.setContentsMargins(10, 10, 10, 10)
+        
+        # Button labels and their positions
+        buttons = [
+            ('U', 0, 1),  # Up
+            ('L', 1, 0),  # Left
+            ('D', 1, 1),  # Down  
+            ('R', 1, 2),  # Right
+            ('A', 0, 3),  # A button
+            ('B', 1, 3),  # B button
+        ]
+        
+        self.labels = {}
+        
+        for text, row, col in buttons:
+            label = QLabel(text)
+            label.setAlignment(Qt.AlignCenter)
+            label.setStyleSheet("""
+                QLabel {
+                    background-color: #2d2d2d;
+                    color: #cccccc;
+                    border: 2px solid #555555;
+                    border-radius: 10px;
+                    font-weight: bold;
+                    font-size: 14px;
+                    min-width: 40px;
+                    min-height: 40px;
+                }
+            """)
+            label.setMinimumSize(50, 50)
+            layout.addWidget(label, row, col)
+            self.labels[text] = label
+            
+        self.setLayout(layout)
+        
+    def activate_button(self, button, active=True):
+        if button in self.labels:
+            if active:
+                self.labels[button].setStyleSheet("""
+                    QLabel {
+                        background-color: #ff4444;
+                        color: white;
+                        border: 2px solid #ff6666;
+                        border-radius: 10px;
+                        font-weight: bold;
+                        font-size: 14px;
+                        min-width: 40px;
+                        min-height: 40px;
+                    }
+                """)
+            else:
+                self.labels[button].setStyleSheet("""
+                    QLabel {
+                        background-color: #2d2d2d;
+                        color: #cccccc;
+                        border: 2px solid #555555;
+                        border-radius: 10px;
+                        font-weight: bold;
+                        font-size: 14px;
+                        min-width: 40px;
+                        min-height: 40px;
+                    }
+                """)
+
+class MetricWidget(QWidget):
+    def __init__(self, title, value, unit=""):
+        super().__init__()
+        self.title = title
+        self.value = value
+        self.unit = unit
+        self.setup_ui()
+        
+    def setup_ui(self):
+        layout = QVBoxLayout()
+        layout.setSpacing(2)
+        layout.setContentsMargins(5, 5, 5, 5)
+        
+        self.title_label = QLabel(self.title)
+        self.title_label.setAlignment(Qt.AlignCenter)
+        self.title_label.setStyleSheet("color: #888888; font-size: 10px;")
+        
+        self.value_label = QLabel(f"{self.value}{self.unit}")
+        self.value_label.setAlignment(Qt.AlignCenter)
+        self.value_label.setStyleSheet("color: #ffffff; font-size: 12px; font-weight: bold;")
+        
+        layout.addWidget(self.title_label)
+        layout.addWidget(self.value_label)
+        
+        self.setLayout(layout)
+        
+    def update_value(self, new_value):
+        self.value_label.setText(f"{new_value}{self.unit}")
+
+class MarioAIApp(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.generation = 1214
+        self.individual = "Replay"
+        self.best_fitness = 0
+        self.max_distance = 3161
+        self.num_inputs = 80
+        self.trainable_params = 789
+        self.offspring = "10, 90"
+        self.lifespan = "Infinite"
+        self.mutation = "Static 5.0%"
+        self.crossover = "Roulette"
+        self.sbx_eta = 100.0
+        self.layers = "[80, 9, 6]"
+        
+        self.setup_ui()
+        self.setup_timers()
+        
+    def setup_ui(self):
+        self.setWindowTitle("MARIO 000500 - AI Learns to Play Super Mario Bros!")
+        self.setGeometry(100, 100, 900, 700)
+        
+        # Central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QVBoxLayout(central_widget)
+        
+        # Header
+        header_layout = QVBoxLayout()
+        
+        title_label = QLabel("MARIO 000500")
+        title_label.setAlignment(Qt.AlignCenter)
+        title_label.setStyleSheet("""
+            QLabel {
+                color: #ff4444;
+                font-size: 24px;
+                font-weight: bold;
+                margin: 10px;
+            }
+        """)
+        
+        world_label = QLabel("WORLD 1-1")
+        world_label.setAlignment(Qt.AlignCenter)
+        world_label.setStyleSheet("""
+            QLabel {
+                color: #ffffff;
+                font-size: 18px;
+                font-weight: bold;
+                margin: 5px;
+            }
+        """)
+        
+        time_label = QLabel("TIME 344")
+        time_label.setAlignment(Qt.AlignCenter)
+        time_label.setStyleSheet("""
+            QLabel {
+                color: #ffff44;
+                font-size: 16px;
+                font-weight: bold;
+                margin: 5px;
+            }
+        """)
+        
+        header_layout.addWidget(title_label)
+        header_layout.addWidget(world_label)
+        header_layout.addWidget(time_label)
+        
+        # Separator
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        separator.setStyleSheet("background-color: #555555;")
+        
+        # Main content area
+        content_layout = QHBoxLayout()
+        
+        # Left panel - Metrics
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        
+        # Metrics grid
+        metrics_grid = QGridLayout()
+        metrics_grid.setSpacing(10)
+        
+        # First column
+        metrics_grid.addWidget(MetricWidget("Generation", self.generation), 0, 0)
+        metrics_grid.addWidget(MetricWidget("Individual", self.individual), 1, 0)
+        metrics_grid.addWidget(MetricWidget("Best Fitness", self.best_fitness), 2, 0)
+        metrics_grid.addWidget(MetricWidget("Max Distance", self.max_distance), 3, 0)
+        metrics_grid.addWidget(MetricWidget("Num Inputs", self.num_inputs), 4, 0)
+        metrics_grid.addWidget(MetricWidget("Trainable Params", self.trainable_params), 5, 0)
+        
+        # Second column
+        metrics_grid.addWidget(MetricWidget("Offspring", self.offspring), 0, 1)
+        metrics_grid.addWidget(MetricWidget("Lifespan", self.lifespan), 1, 1)
+        metrics_grid.addWidget(MetricWidget("Mutation", self.mutation), 2, 1)
+        metrics_grid.addWidget(MetricWidget("Crossover", self.crossover), 3, 1)
+        metrics_grid.addWidget(MetricWidget("SBX Eta", self.sbx_eta), 4, 1)
+        metrics_grid.addWidget(MetricWidget("Layers", self.layers), 5, 1)
+        
+        left_layout.addLayout(metrics_grid)
+        
+        # Control buttons
+        left_layout.addWidget(QLabel("Controller:"))
+        self.control_widget = ControlButtonWidget()
+        left_layout.addWidget(self.control_widget)
+        
+        # Right panel - Neural Network
+        right_panel = QWidget()
+        right_layout = QVBoxLayout(right_panel)
+        
+        right_layout.addWidget(QLabel("Neural Network Visualization:"))
+        self.nn_widget = NeuralNetworkWidget()
+        right_layout.addWidget(self.nn_widget)
+        
+        # Add panels to content layout
+        content_layout.addWidget(left_panel, 1)
+        content_layout.addWidget(right_panel, 2)
+        
+        # Footer
+        footer_label = QLabel("AI Learns to Play Super Mario Bros!\nUsing a Genetic Algorithm and Neural Network, a population of AI were able to learn to play different levels of Super Mario Bros for the NES.")
+        footer_label.setAlignment(Qt.AlignCenter)
+        footer_label.setStyleSheet("""
+            QLabel {
+                color: #cccccc;
+                font-size: 12px;
+                margin: 10px;
+                padding: 10px;
+                background-color: #2a2a2a;
+                border-radius: 5px;
+            }
+        """)
+        footer_label.setWordWrap(True)
+        
+        # Assemble main layout
+        main_layout.addLayout(header_layout)
+        main_layout.addWidget(separator)
+        main_layout.addLayout(content_layout)
+        main_layout.addWidget(footer_label)
+        
+        # Set dark theme
+        self.setStyleSheet("""
+            QMainWindow {
+                background-color: #1a1a1a;
+            }
+            QWidget {
+                background-color: #1a1a1a;
+                color: #ffffff;
+            }
+        """)
+    
+    def setup_timers(self):
+        # Timer for neural network updates
+        self.nn_timer = QTimer()
+        self.nn_timer.timeout.connect(self.update_neural_network)
+        self.nn_timer.start(100)  # Update every 100ms
+        
+        # Timer for button activations
+        self.button_timer = QTimer()
+        self.button_timer.timeout.connect(self.update_buttons)
+        self.button_timer.start(200)  # Update every 200ms
+        
+        # Timer for metrics updates
+        self.metrics_timer = QTimer()
+        self.metrics_timer.timeout.connect(self.update_metrics)
+        self.metrics_timer.start(1000)  # Update every second
+    
+    def update_neural_network(self):
+        self.nn_widget.update_activations()
+    
+    def update_buttons(self):
+        # Randomly activate buttons to simulate gameplay
+        buttons = ['U', 'D', 'L', 'R', 'A', 'B']
+        for button in buttons:
+            if random.random() < 0.3:  # 30% chance to activate each button
+                self.control_widget.activate_button(button, True)
+            else:
+                self.control_widget.activate_button(button, False)
+    
+    def update_metrics(self):
+        # Simulate metric updates
+        self.max_distance += random.randint(1, 10)
+        self.best_fitness += random.randint(0, 5)
+        
+        # Update UI (in a real app, you'd update the actual metric widgets)
+        # For now, we'll just store the updated values
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Set application-wide font
+    font = QFont("Courier New", 10)
+    app.setFont(font)
+    
+    window = MarioAIApp()
+    window.show()
+    
+    sys.exit(app.exec_())
+
+if __name__ == "__main__":
+    main()

mario_ai_app_2.py

@@ -0,0 +1,664 @@
+import sys
+import random
+import numpy as np
+from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
+                             QHBoxLayout, QLabel, QFrame, QGridLayout, 
+                             QPushButton, QProgressBar)
+from PyQt5.QtCore import QTimer, Qt, QThread, pyqtSignal
+from PyQt5.QtGui import QFont, QPainter, QColor, QPen, QBrush, QPixmap, QImage
+import gym_super_mario_bros
+from gym_super_mario_bros.actions import RIGHT_ONLY, SIMPLE_MOVEMENT, COMPLEX_MOVEMENT
+from nes_py.wrappers import JoypadSpace
+import cv2
+from collections import deque
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+
+class GeneticNetwork(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(GeneticNetwork, self).__init__()
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.fc2 = nn.Linear(hidden_size, output_size)
+        self.relu = nn.ReLU()
+        
+    def forward(self, x):
+        x = self.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+class MarioAIWorker(QThread):
+    update_signal = pyqtSignal(dict)
+    frame_signal = pyqtSignal(np.ndarray)
+    
+    def __init__(self):
+        super().__init__()
+        self.running = False
+        self.generation = 1
+        self.population_size = 50
+        self.current_individual = 0
+        self.best_fitness = 0
+        self.max_distance = 0
+        self.env = None
+        self.population = []
+        self.fitness_scores = []
+        self.setup_environment()
+        self.setup_population()
+        
+    def setup_environment(self):
+        """Initialize the Mario environment"""
+        self.env = gym_super_mario_bros.make('SuperMarioBros-1-1-v0')
+        self.env = JoypadSpace(self.env, SIMPLE_MOVEMENT)
+        
+    def setup_population(self):
+        """Initialize the population of neural networks"""
+        self.population = []
+        self.fitness_scores = [0] * self.population_size
+        
+        for i in range(self.population_size):
+            network = GeneticNetwork(80, 9, 6)  # Match the layers from screenshot
+            # Initialize with random weights
+            for param in network.parameters():
+                nn.init.normal_(param, mean=0.0, std=0.1)
+            self.population.append(network)
+    
+    def preprocess_state(self, state):
+        """Preprocess the game state for the neural network"""
+        # Convert to grayscale and resize
+        gray = cv2.cvtColor(state, cv2.COLOR_RGB2GRAY)
+        resized = cv2.resize(gray, (10, 8))  # 80 pixels total
+        flattened = resized.flatten()
+        normalized = flattened / 255.0  # Normalize to [0, 1]
+        return normalized
+    
+    def run(self):
+        """Main training loop"""
+        self.running = True
+        while self.running:
+            # Evaluate current individual
+            fitness, distance, frame = self.evaluate_individual(self.current_individual)
+            self.fitness_scores[self.current_individual] = fitness
+            self.max_distance = max(self.max_distance, distance)
+            self.best_fitness = max(self.best_fitness, fitness)
+            
+            # Emit update signals
+            self.update_signal.emit({
+                'generation': self.generation,
+                'individual': f"Individual {self.current_individual + 1}",
+                'best_fitness': int(self.best_fitness),
+                'max_distance': int(self.max_distance),
+                'current_fitness': int(fitness),
+                'current_distance': int(distance)
+            })
+            
+            if frame is not None:
+                self.frame_signal.emit(frame)
+            
+            # Move to next individual
+            self.current_individual += 1
+            if self.current_individual >= self.population_size:
+                self.evolve_population()
+                self.current_individual = 0
+                self.generation += 1
+            
+            # Small delay to prevent UI freezing
+            self.msleep(50)
+    
+    def evaluate_individual(self, individual_idx):
+        """Evaluate one individual in the environment"""
+        network = self.population[individual_idx]
+        state = self.env.reset()
+        total_reward = 0
+        max_distance = 0
+        last_frame = None
+        
+        for step in range(1000):  # Limit steps per evaluation
+            # Preprocess state
+            processed_state = self.preprocess_state(state)
+            state_tensor = torch.FloatTensor(processed_state)
+            
+            # Get action from neural network
+            with torch.no_grad():
+                output = network(state_tensor)
+                action = torch.argmax(output).item()
+            
+            # Take action
+            state, reward, done, info = self.env.step(action)
+            total_reward += reward
+            max_distance = max(max_distance, info['x_pos'])
+            last_frame = state
+            
+            if done:
+                break
+        
+        # Calculate fitness (reward + distance bonus)
+        fitness = total_reward + (max_distance / 10)
+        return fitness, max_distance, last_frame
+    
+    def evolve_population(self):
+        """Evolve the population using genetic algorithm"""
+        # Select parents based on fitness (tournament selection)
+        new_population = []
+        
+        # Keep best individual
+        best_idx = np.argmax(self.fitness_scores)
+        new_population.append(self.population[best_idx])
+        
+        # Create offspring through mutation and crossover
+        while len(new_population) < self.population_size:
+            # Tournament selection
+            parent1 = self.tournament_select()
+            parent2 = self.tournament_select()
+            
+            # Crossover and mutation
+            child = self.crossover(parent1, parent2)
+            child = self.mutate(child)
+            new_population.append(child)
+        
+        self.population = new_population
+        self.fitness_scores = [0] * self.population_size
+    
+    def tournament_select(self, tournament_size=3):
+        """Tournament selection"""
+        candidates = random.sample(range(self.population_size), tournament_size)
+        best_candidate = max(candidates, key=lambda x: self.fitness_scores[x])
+        return self.population[best_candidate]
+    
+    def crossover(self, parent1, parent2):
+        """Single-point crossover"""
+        child = GeneticNetwork(80, 9, 6)
+        child_state = child.state_dict()
+        parent1_state = parent1.state_dict()
+        parent2_state = parent2.state_dict()
+        
+        for key in child_state.keys():
+            # Randomly choose weights from parents
+            mask = torch.rand_like(parent1_state[key]) > 0.5
+            child_state[key] = torch.where(mask, parent1_state[key], parent2_state[key])
+        
+        child.load_state_dict(child_state)
+        return child
+    
+    def mutate(self, network, mutation_rate=0.05):
+        """Apply random mutations"""
+        mutated_state = network.state_dict()
+        
+        for key in mutated_state.keys():
+            mask = torch.rand_like(mutated_state[key]) < mutation_rate
+            mutation = torch.randn_like(mutated_state[key]) * 0.1
+            mutated_state[key] = torch.where(mask, mutated_state[key] + mutation, mutated_state[key])
+        
+        network.load_state_dict(mutated_state)
+        return network
+    
+    def stop(self):
+        """Stop the training thread"""
+        self.running = False
+        if self.env:
+            self.env.close()
+
+class NeuralNetworkWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setMinimumSize(400, 300)
+        self.layers = [80, 9, 6]
+        self.activations = [0.1] * sum(self.layers)
+        self.connection_strengths = {}
+        
+    def update_activations(self, activations=None):
+        if activations is not None:
+            self.activations = activations
+        self.update()
+        
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        
+        bg_color = QColor(30, 30, 40)
+        neuron_color = QColor(100, 150, 255)
+        active_neuron_color = QColor(255, 100, 100)
+        
+        painter.fillRect(self.rect(), bg_color)
+        width = self.width()
+        height = self.height()
+        
+        neuron_positions = []
+        activation_index = 0
+        
+        for layer_idx, neuron_count in enumerate(self.layers):
+            layer_positions = []
+            layer_x = (layer_idx + 1) * width / (len(self.layers) + 1)
+            
+            for neuron_idx in range(neuron_count):
+                neuron_y = (neuron_idx + 1) * height / (neuron_count + 1)
+                layer_positions.append((layer_x, neuron_y))
+                
+                if layer_idx < len(self.layers) - 1:
+                    next_layer_count = self.layers[layer_idx + 1]
+                    for next_neuron_idx in range(next_layer_count):
+                        next_x = (layer_idx + 2) * width / (len(self.layers) + 1)
+                        next_y = (next_neuron_idx + 1) * height / (next_layer_count + 1)
+                        
+                        strength = random.random()
+                        alpha = int(50 + strength * 100)
+                        pen_color = QColor(100, 100, 150, alpha)
+                        
+                        painter.setPen(QPen(pen_color, 1 + strength * 2))
+                        painter.drawLine(int(layer_x), int(neuron_y), 
+                                       int(next_x), int(next_y))
+                
+                activation_index += 1
+            neuron_positions.append(layer_positions)
+        
+        activation_index = 0
+        for layer_idx, positions in enumerate(neuron_positions):
+            for pos_idx, (x, y) in enumerate(positions):
+                activation = self.activations[activation_index]
+                activation_index += 1
+                
+                if activation > 0.7:
+                    color = active_neuron_color
+                elif activation > 0.3:
+                    color = QColor(255, 200, 100)
+                else:
+                    color = neuron_color
+                
+                radius = 8 + activation * 8
+                painter.setBrush(QBrush(color))
+                painter.setPen(QPen(QColor(200, 200, 255), 2))
+                painter.drawEllipse(int(x - radius/2), int(y - radius/2), 
+                                  int(radius), int(radius))
+
+class ControlButtonWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setup_ui()
+        
+    def setup_ui(self):
+        layout = QGridLayout()
+        layout.setSpacing(10)
+        layout.setContentsMargins(10, 10, 10, 10)
+        
+        buttons = [
+            ('U', 0, 1),
+            ('L', 1, 0),
+            ('D', 1, 1), 
+            ('R', 1, 2),
+            ('A', 0, 3),
+            ('B', 1, 3),
+        ]
+        
+        self.labels = {}
+        
+        for text, row, col in buttons:
+            label = QLabel(text)
+            label.setAlignment(Qt.AlignCenter)
+            label.setStyleSheet("""
+                QLabel {
+                    background-color: #2d2d2d;
+                    color: #cccccc;
+                    border: 2px solid #555555;
+                    border-radius: 10px;
+                    font-weight: bold;
+                    font-size: 14px;
+                    min-width: 40px;
+                    min-height: 40px;
+                }
+            """)
+            label.setMinimumSize(50, 50)
+            layout.addWidget(label, row, col)
+            self.labels[text] = label
+            
+        self.setLayout(layout)
+        
+    def activate_button(self, button, active=True):
+        if button in self.labels:
+            if active:
+                self.labels[button].setStyleSheet("""
+                    QLabel {
+                        background-color: #ff4444;
+                        color: white;
+                        border: 2px solid #ff6666;
+                        border-radius: 10px;
+                        font-weight: bold;
+                        font-size: 14px;
+                        min-width: 40px;
+                        min-height: 40px;
+                    }
+                """)
+            else:
+                self.labels[button].setStyleSheet("""
+                    QLabel {
+                        background-color: #2d2d2d;
+                        color: #cccccc;
+                        border: 2px solid #555555;
+                        border-radius: 10px;
+                        font-weight: bold;
+                        font-size: 14px;
+                        min-width: 40px;
+                        min-height: 40px;
+                    }
+                """)
+
+class MetricWidget(QWidget):
+    def __init__(self, title, value, unit=""):
+        super().__init__()
+        self.title = title
+        self.value = str(value)
+        self.unit = unit
+        self.setup_ui()
+        
+    def setup_ui(self):
+        layout = QVBoxLayout()
+        layout.setSpacing(2)
+        layout.setContentsMargins(5, 5, 5, 5)
+        
+        self.title_label = QLabel(self.title)
+        self.title_label.setAlignment(Qt.AlignCenter)
+        self.title_label.setStyleSheet("color: #888888; font-size: 10px;")
+        
+        self.value_label = QLabel(f"{self.value}{self.unit}")
+        self.value_label.setAlignment(Qt.AlignCenter)
+        self.value_label.setStyleSheet("color: #ffffff; font-size: 12px; font-weight: bold;")
+        
+        layout.addWidget(self.title_label)
+        layout.addWidget(self.value_label)
+        
+        self.setLayout(layout)
+        
+    def update_value(self, new_value):
+        self.value_label.setText(f"{new_value}{self.unit}")
+
+class GameDisplayWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setMinimumSize(320, 240)
+        self.current_frame = None
+        
+    def update_frame(self, frame):
+        self.current_frame = frame
+        self.update()
+        
+    def paintEvent(self, event):
+        if self.current_frame is not None:
+            painter = QPainter(self)
+            
+            # Convert BGR to RGB
+            rgb_frame = cv2.cvtColor(self.current_frame, cv2.COLOR_BGR2RGB)
+            
+            # Resize frame to fit widget
+            h, w = rgb_frame.shape[:2]
+            q_image = QImage(rgb_frame.data, w, h, QImage.Format_RGB888)
+            pixmap = QPixmap.fromImage(q_image)
+            
+            # Scale pixmap to fit widget while maintaining aspect ratio
+            scaled_pixmap = pixmap.scaled(self.width(), self.height(), 
+                                        Qt.KeepAspectRatio, Qt.FastTransformation)
+            
+            # Center the pixmap
+            x = (self.width() - scaled_pixmap.width()) // 2
+            y = (self.height() - scaled_pixmap.height()) // 2
+            painter.drawPixmap(x, y, scaled_pixmap)
+        else:
+            # Show placeholder when no frame is available
+            painter = QPainter(self)
+            painter.fillRect(self.rect(), QColor(50, 50, 50))
+            painter.setPen(QColor(200, 200, 200))
+            painter.drawText(self.rect(), Qt.AlignCenter, "Game Display\n(Mario will appear here)")
+
+class MarioAITrainer(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.generation = 1
+        self.individual = "Individual 1"
+        self.best_fitness = 0
+        self.max_distance = 0
+        self.num_inputs = 80
+        self.trainable_params = 789
+        self.offspring = "10, 90"
+        self.lifespan = "Infinite"
+        self.mutation = "Static 5.0%"
+        self.crossover = "Roulette"
+        self.sbx_eta = 100.0
+        self.layers = "[80, 9, 6]"
+        
+        self.ai_worker = MarioAIWorker()
+        self.setup_ui()
+        self.connect_signals()
+        
+    def setup_ui(self):
+        self.setWindowTitle("MARIO 000500 - AI Learns to Play Super Mario Bros!")
+        self.setGeometry(100, 100, 1200, 800)
+        
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QVBoxLayout(central_widget)
+        
+        # Header
+        header_layout = QVBoxLayout()
+        
+        title_label = QLabel("MARIO 000500")
+        title_label.setAlignment(Qt.AlignCenter)
+        title_label.setStyleSheet("""
+            QLabel {
+                color: #ff4444;
+                font-size: 24px;
+                font-weight: bold;
+                margin: 10px;
+            }
+        """)
+        
+        world_label = QLabel("WORLD 1-1")
+        world_label.setAlignment(Qt.AlignCenter)
+        world_label.setStyleSheet("""
+            QLabel {
+                color: #ffffff;
+                font-size: 18px;
+                font-weight: bold;
+                margin: 5px;
+            }
+        """)
+        
+        time_label = QLabel("TIME 344")
+        time_label.setAlignment(Qt.AlignCenter)
+        time_label.setStyleSheet("""
+            QLabel {
+                color: #ffff44;
+                font-size: 16px;
+                font-weight: bold;
+                margin: 5px;
+            }
+        """)
+        
+        header_layout.addWidget(title_label)
+        header_layout.addWidget(world_label)
+        header_layout.addWidget(time_label)
+        
+        # Control buttons
+        control_buttons_layout = QHBoxLayout()
+        self.start_button = QPushButton("Start Training")
+        self.stop_button = QPushButton("Stop Training")
+        self.reset_button = QPushButton("Reset")
+        
+        self.start_button.setStyleSheet("QPushButton { background-color: #4CAF50; color: white; font-weight: bold; }")
+        self.stop_button.setStyleSheet("QPushButton { background-color: #f44336; color: white; font-weight: bold; }")
+        self.reset_button.setStyleSheet("QPushButton { background-color: #ff9800; color: white; font-weight: bold; }")
+        
+        control_buttons_layout.addWidget(self.start_button)
+        control_buttons_layout.addWidget(self.stop_button)
+        control_buttons_layout.addWidget(self.reset_button)
+        control_buttons_layout.addStretch()
+        
+        # Main content
+        content_layout = QHBoxLayout()
+        
+        # Left panel - Metrics and Controls
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        
+        # Metrics grid
+        metrics_grid = QGridLayout()
+        metrics_grid.setSpacing(10)
+        
+        # First column
+        self.gen_widget = MetricWidget("Generation", self.generation)
+        self.ind_widget = MetricWidget("Individual", self.individual)
+        self.fit_widget = MetricWidget("Best Fitness", self.best_fitness)
+        self.dist_widget = MetricWidget("Max Distance", self.max_distance)
+        self.inputs_widget = MetricWidget("Num Inputs", self.num_inputs)
+        self.params_widget = MetricWidget("Trainable Params", self.trainable_params)
+        
+        # Second column
+        self.offspring_widget = MetricWidget("Offspring", self.offspring)
+        self.lifespan_widget = MetricWidget("Lifespan", self.lifespan)
+        self.mutation_widget = MetricWidget("Mutation", self.mutation)
+        self.crossover_widget = MetricWidget("Crossover", self.crossover)
+        self.sbx_widget = MetricWidget("SBX Eta", self.sbx_eta)
+        self.layers_widget = MetricWidget("Layers", self.layers)
+        
+        metrics_grid.addWidget(self.gen_widget, 0, 0)
+        metrics_grid.addWidget(self.ind_widget, 1, 0)
+        metrics_grid.addWidget(self.fit_widget, 2, 0)
+        metrics_grid.addWidget(self.dist_widget, 3, 0)
+        metrics_grid.addWidget(self.inputs_widget, 4, 0)
+        metrics_grid.addWidget(self.params_widget, 5, 0)
+        
+        metrics_grid.addWidget(self.offspring_widget, 0, 1)
+        metrics_grid.addWidget(self.lifespan_widget, 1, 1)
+        metrics_grid.addWidget(self.mutation_widget, 2, 1)
+        metrics_grid.addWidget(self.crossover_widget, 3, 1)
+        metrics_grid.addWidget(self.sbx_widget, 4, 1)
+        metrics_grid.addWidget(self.layers_widget, 5, 1)
+        
+        left_layout.addLayout(metrics_grid)
+        
+        # Controller
+        left_layout.addWidget(QLabel("Controller:"))
+        self.control_widget = ControlButtonWidget()
+        left_layout.addWidget(self.control_widget)
+        
+        # Right panel - Game and Neural Network
+        right_panel = QWidget()
+        right_layout = QVBoxLayout(right_panel)
+        
+        # Game display
+        right_layout.addWidget(QLabel("Game Display:"))
+        self.game_widget = GameDisplayWidget()
+        right_layout.addWidget(self.game_widget)
+        
+        # Neural Network
+        right_layout.addWidget(QLabel("Neural Network Visualization:"))
+        self.nn_widget = NeuralNetworkWidget()
+        right_layout.addWidget(self.nn_widget)
+        
+        content_layout.addWidget(left_panel, 1)
+        content_layout.addWidget(right_panel, 2)
+        
+        # Footer
+        footer_label = QLabel("AI Learns to Play Super Mario Bros!\nUsing a Genetic Algorithm and Neural Network, a population of AI were able to learn to play different levels of Super Mario Bros for the NES.")
+        footer_label.setAlignment(Qt.AlignCenter)
+        footer_label.setStyleSheet("""
+            QLabel {
+                color: #cccccc;
+                font-size: 12px;
+                margin: 10px;
+                padding: 10px;
+                background-color: #2a2a2a;
+                border-radius: 5px;
+            }
+        """)
+        footer_label.setWordWrap(True)
+        
+        # Assemble main layout
+        main_layout.addLayout(header_layout)
+        main_layout.addLayout(control_buttons_layout)
+        main_layout.addLayout(content_layout)
+        main_layout.addWidget(footer_label)
+        
+        self.setStyleSheet("""
+            QMainWindow, QWidget {
+                background-color: #1a1a1a;
+                color: #ffffff;
+            }
+        """)
+    
+    def connect_signals(self):
+        """Connect signals from AI worker to UI updates"""
+        self.start_button.clicked.connect(self.start_training)
+        self.stop_button.clicked.connect(self.stop_training)
+        self.reset_button.clicked.connect(self.reset_training)
+        
+        self.ai_worker.update_signal.connect(self.update_metrics)
+        self.ai_worker.frame_signal.connect(self.update_game_display)
+    
+    def start_training(self):
+        """Start the AI training"""
+        self.ai_worker.start()
+        self.start_button.setEnabled(False)
+        self.stop_button.setEnabled(True)
+    
+    def stop_training(self):
+        """Stop the AI training"""
+        self.ai_worker.stop()
+        self.ai_worker.wait()
+        self.start_button.setEnabled(True)
+        self.stop_button.setEnabled(False)
+    
+    def reset_training(self):
+        """Reset the training"""
+        self.stop_training()
+        self.ai_worker = MarioAIWorker()
+        self.connect_signals()
+        self.generation = 1
+        self.best_fitness = 0
+        self.max_distance = 0
+        self.update_ui_metrics()
+    
+    def update_metrics(self, data):
+        """Update metrics from AI worker"""
+        self.generation = data['generation']
+        self.individual = data['individual']
+        self.best_fitness = data['best_fitness']
+        self.max_distance = data['max_distance']
+        
+        self.update_ui_metrics()
+        
+        # Update neural network visualization with random activations
+        random_activations = [random.random() for _ in range(sum([80, 9, 6]))]
+        self.nn_widget.update_activations(random_activations)
+        
+        # Update controller buttons based on random actions
+        buttons = ['U', 'D', 'L', 'R', 'A', 'B']
+        for button in buttons:
+            self.control_widget.activate_button(button, random.random() > 0.7)
+    
+    def update_ui_metrics(self):
+        """Update the UI metric widgets"""
+        self.gen_widget.update_value(self.generation)
+        self.ind_widget.update_value(self.individual)
+        self.fit_widget.update_value(self.best_fitness)
+        self.dist_widget.update_value(self.max_distance)
+    
+    def update_game_display(self, frame):
+        """Update the game display with new frame"""
+        self.game_widget.update_frame(frame)
+    
+    def closeEvent(self, event):
+        """Ensure clean shutdown"""
+        self.stop_training()
+        event.accept()
+
+def main():
+    app = QApplication(sys.argv)
+    
+    font = QFont("Courier New", 10)
+    app.setFont(font)
+    
+    window = MarioAITrainer()
+    window.show()
+    
+    sys.exit(app.exec_())
+
+if __name__ == "__main__":
+    main()

output.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03553c2d38c2055be02b0a484bc0f332dcddbd010f9a248b660575338661c8ef
+size 55795271

requirements.txt

@@ -0,0 +1,10 @@
+numpy==1.26.4
+torch>=1.6.0
+torchvision
+gym==0.23
+nes-py
+gym-super-mario-bros==7.2.3
+opencv-python
+matplotlib
+PyQt5
+pygame