Create app.py

app.py

@@ -0,0 +1,195 @@
+# app.py
+# =============
+# This is a complete app.py file for an Arkanoid game that a neural network will play and learn using reinforcement learning.
+# The game is built using pygame, and the neural network is trained using stable-baselines3. Gradio is used for the interface.
+
+import os
+import numpy as np
+import pygame
+import random
+from stable_baselines3 import DQN
+from stable_baselines3.common.env_util import make_atari_env
+from stable_baselines3.common.vec_env import VecFrameStack
+from stable_baselines3.common.evaluation import evaluate_policy
+import gradio as gr
+
+# Constants
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 480
+PADDLE_WIDTH = 100
+PADDLE_HEIGHT = 10
+BALL_RADIUS = 10
+BRICK_WIDTH = 60
+BRICK_HEIGHT = 20
+BRICK_ROWS = 5
+BRICK_COLS = 10
+FPS = 60
+
+# Colors
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+RED = (255, 0, 0)
+
+# Initialize Pygame
+pygame.init()
+screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+pygame.display.set_caption("Arkanoid")
+
+# Game classes
+class Paddle:
+    def __init__(self):
+        self.rect = pygame.Rect(SCREEN_WIDTH // 2 - PADDLE_WIDTH // 2, SCREEN_HEIGHT - PADDLE_HEIGHT - 10, PADDLE_WIDTH, PADDLE_HEIGHT)
+
+    def move(self, direction):
+        if direction == -1:
+            self.rect.x -= 10
+        elif direction == 1:
+            self.rect.x += 10
+        self.rect.clamp_ip(pygame.Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT))
+
+class Ball:
+    def __init__(self):
+        self.rect = pygame.Rect(SCREEN_WIDTH // 2 - BALL_RADIUS, SCREEN_HEIGHT // 2 - BALL_RADIUS, BALL_RADIUS * 2, BALL_RADIUS * 2)
+        self.velocity = [random.choice([-5, 5]), -5]
+
+    def move(self):
+        self.rect.x += self.velocity[0]
+        self.rect.y += self.velocity[1]
+
+        if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH:
+            self.velocity[0] = -self.velocity[0]
+        if self.rect.top <= 0:
+            self.velocity[1] = -self.velocity[1]
+
+    def reset(self):
+        self.rect = pygame.Rect(SCREEN_WIDTH // 2 - BALL_RADIUS, SCREEN_HEIGHT // 2 - BALL_RADIUS, BALL_RADIUS * 2, BALL_RADIUS * 2)
+        self.velocity = [random.choice([-5, 5]), -5]
+
+class Brick:
+    def __init__(self, x, y):
+        self.rect = pygame.Rect(x, y, BRICK_WIDTH, BRICK_HEIGHT)
+
+class ArkanoidEnv:
+    def __init__(self):
+        self.paddle = Paddle()
+        self.ball = Ball()
+        self.bricks = [Brick(x, y) for y in range(BRICK_HEIGHT, BRICK_HEIGHT * (BRICK_ROWS + 1), BRICK_HEIGHT) for x in range(BRICK_WIDTH, SCREEN_WIDTH - BRICK_WIDTH, BRICK_WIDTH)]
+        self.clock = pygame.time.Clock()
+        self.done = False
+        self.score = 0
+
+    def reset(self):
+        self.paddle = Paddle()
+        self.ball = Ball()
+        self.bricks = [Brick(x, y) for y in range(BRICK_HEIGHT, BRICK_HEIGHT * (BRICK_ROWS + 1), BRICK_HEIGHT) for x in range(BRICK_WIDTH, SCREEN_WIDTH - BRICK_WIDTH, BRICK_WIDTH)]
+        self.done = False
+        self.score = 0
+        return self._get_state()
+
+    def step(self, action):
+        self.paddle.move(action)
+        self.ball.move()
+
+        if self.ball.rect.colliderect(self.paddle.rect):
+            self.ball.velocity[1] = -self.ball.velocity[1]
+
+        for brick in self.bricks[:]:
+            if self.ball.rect.colliderect(brick.rect):
+                self.bricks.remove(brick)
+                self.ball.velocity[1] = -self.ball.velocity[1]
+                self.score += 1
+
+        if self.ball.rect.bottom >= SCREEN_HEIGHT:
+            self.done = True
+
+        if not self.bricks:
+            self.done = True
+
+        reward = 1 if self.score > 0 else -1
+        return self._get_state(), reward, self.done, {}
+
+    def _get_state(self):
+        state = [
+            self.paddle.rect.x,
+            self.ball.rect.x,
+            self.ball.rect.y,
+            self.ball.velocity[0],
+            self.ball.velocity[1]
+        ]
+        for brick in self.bricks:
+            state.extend([brick.rect.x, brick.rect.y])
+        return np.array(state, dtype=np.float32)
+
+    def render(self):
+        screen.fill(BLACK)
+        pygame.draw.rect(screen, WHITE, self.paddle.rect)
+        pygame.draw.ellipse(screen, WHITE, self.ball.rect)
+        for brick in self.bricks:
+            pygame.draw.rect(screen, RED, brick.rect)
+        pygame.display.flip()
+        self.clock.tick(FPS)
+
+# Training function
+def train_model():
+    env = ArkanoidEnv()
+    model = DQN('MlpPolicy', env, verbose=1)
+    model.learn(total_timesteps=10000)
+    model.save("arkanoid_model")
+    return model
+
+# Evaluation function
+def evaluate_model(model):
+    env = ArkanoidEnv()
+    mean_reward, _ = evaluate_policy(model, env, n_eval_episodes=10, render=False)
+    return mean_reward
+
+# Gradio interface
+def play_game():
+    env = ArkanoidEnv()
+    model = DQN.load("arkanoid_model")
+    obs = env.reset()
+    done = False
+    frames = []
+    while not done:
+        action, _states = model.predict(obs, deterministic=True)
+        obs, rewards, done, info = env.step(action)
+        env.render()
+        pygame.image.save(screen, "frame.png")
+        frames.append(gr.Image(value="frame.png"))
+    return frames
+
+# Main function
+def main():
+    if not os.path.exists("arkanoid_model.zip"):
+        print("Training model...")
+        train_model()
+    else:
+        print("Model already trained.")
+
+    print("Evaluating model...")
+    model = DQN.load("arkanoid_model")
+    mean_reward = evaluate_model(model)
+    print(f"Mean reward: {mean_reward}")
+
+    # Gradio interface
+    iface = gr.Interface(
+        fn=play_game,
+        inputs=None,
+        outputs="image",
+        live=True
+    )
+    iface.launch()
+
+if __name__ == "__main__":
+    main()
+
+# Dependencies
+# =============
+# The following dependencies are required to run this app:
+# - pygame
+# - stable-baselines3
+# - torch
+# - gradio
+#
+# You can install these dependencies using pip:
+# pip install pygame stable-baselines3 torch gradio