Update app.py

app.py

@@ -1,23 +1,38 @@
+import os
 import random
 import csv
 import numpy as np
 import tensorflow as tf
+import gradio as gr
 from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import LSTM, Dense, Embedding
 from tensorflow.keras.preprocessing.sequence import pad_sequences
 from tensorflow.keras.preprocessing.text import Tokenizer
 
+# Disable GPU for Hugging Face Spaces
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+
 # Mapping choices to numerical values
 choices = {'rock': 0, 'paper': 1, 'scissors': 2}
 rev_choices = {0: 'rock', 1: 'paper', 2: 'scissors'}
 
+# Ensure CSV exists
+csv_filename = "game_moves.csv"
+if not os.path.exists(csv_filename):
+    with open(csv_filename, mode='w', newline='') as file:
+        writer = csv.writer(file)
+        writer.writerow(["Player Choice", "Computer Choice", "Result"])
+
 def get_computer_choice(model, past_moves):
+    """ Predicts player's next move and counteracts it. """
     if len(past_moves) < 3:
-        return random.choice(['rock', 'paper', 'scissors'])
+        return random.choice(["rock", "paper", "scissors"])
     
     # Prepare input data for prediction
     sequence = [choices[move] for move in past_moves[-3:]]
     sequence = pad_sequences([sequence], maxlen=3)
+    
     prediction = model.predict(sequence, verbose=0)
     predicted_choice = rev_choices[np.argmax(prediction)]
     
@@ -26,74 +41,92 @@ def get_computer_choice(model, past_moves):
     return counter_choices[predicted_choice]
 
 def get_winner(player, computer):
+    """ Determines the winner of the game. """
     if player == computer:
         return "It's a tie!"
-    elif (player == 'rock' and computer == 'scissors') or \
-         (player == 'scissors' and computer == 'paper') or \
-         (player == 'paper' and computer == 'rock'):
+    elif (player == "rock" and computer == "scissors") or \
+         (player == "scissors" and computer == "paper") or \
+         (player == "paper" and computer == "rock"):
         return "You win!"
     else:
         return "Computer wins!"
 
 def save_move(player, computer, result):
-    with open('game_moves.csv', mode='a', newline='') as file:
+    """ Saves game move to CSV file. """
+    with open(csv_filename, mode="a", newline="") as file:
         writer = csv.writer(file)
         writer.writerow([player, computer, result])
 
 def load_data():
+    """ Loads past player moves from CSV file. """
     try:
-        with open('game_moves.csv', mode='r') as file:
+        with open(csv_filename, mode="r") as file:
             reader = csv.reader(file)
             next(reader)  # Skip header
-            data = [row[0] for row in reader]
-            return data
+            return [row[0] for row in reader]
     except FileNotFoundError:
         return []
 
 def train_lstm_model(data):
+    """ Trains an LSTM model to predict the player's next move. """
+    if len(data) < 4:
+        return None  # Not enough data for meaningful training
+    
     tokenizer = Tokenizer(num_words=3)
     tokenizer.fit_on_texts(data)
     sequences = tokenizer.texts_to_sequences(data)
+    
     X = pad_sequences(sequences, maxlen=3)
     y = np.array([choices[move] for move in data[1:]])
     
     model = Sequential([
         Embedding(input_dim=3, output_dim=10, input_length=3),
         LSTM(20, return_sequences=False),
-        Dense(3, activation='softmax')
+        Dense(3, activation="softmax")
     ])
-    model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+    model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
     
     if len(X) > 1:
         model.fit(X[:-1], y, epochs=10, verbose=0)
     return model
 
-def main():
-    print("Welcome to Rock, Paper, Scissors!")
-    with open('game_moves.csv', mode='w', newline='') as file:
-        writer = csv.writer(file)
-        writer.writerow(["Player Choice", "Computer Choice", "Result"])
-    
-    past_moves = load_data()
-    model = train_lstm_model(past_moves)
-    
-    while True:
-        player_choice = input("Enter rock, paper, or scissors (or 'quit' to exit): ").lower()
-        if player_choice == 'quit':
-            print("Thanks for playing!")
-            break
-        if player_choice not in ['rock', 'paper', 'scissors']:
-            print("Invalid choice. Please try again.")
-            continue
-        
+# Load past moves and train model
+past_moves = load_data()
+model = train_lstm_model(past_moves) if len(past_moves) >= 4 else None
+
+def play_game(player_choice):
+    """ Handles the game logic and returns the result. """
+    global past_moves, model
+
+    if player_choice not in choices:
+        return "Invalid choice. Choose rock, paper, or scissors."
+
+    # Ensure model exists before predicting
+    if model is None:
+        computer_choice = random.choice(["rock", "paper", "scissors"])
+    else:
         computer_choice = get_computer_choice(model, past_moves)
-        result = get_winner(player_choice, computer_choice)
-        print(f"Computer chose: {computer_choice}")
-        print(result)
-        print()
-        
-        save_move(player_choice, computer_choice, result)
-        past_moves.append(player_choice)
+
+    result = get_winner(player_choice, computer_choice)
+
+    # Save the move
+    save_move(player_choice, computer_choice, result)
+    past_moves.append(player_choice)
+
+    # Retrain the model after each move
+    if len(past_moves) >= 4:
+        model = train_lstm_model(past_moves)
+
+    return f"Computer chose: {computer_choice}\n{result}"
+
+# Gradio UI
+iface = gr.Interface(
+    fn=play_game,
+    inputs=gr.Radio(["rock", "paper", "scissors"], label="Choose your move"),
+    outputs="text",
+    title="Rock, Paper, Scissors AI",
+    description="Play against an AI that learns from your moves and tries to beat you!"
+)
 
 if __name__ == "__main__":
-    main()
+    iface.launch()