Update app.py

app.py

@@ -4,7 +4,7 @@ import csv
 import numpy as np
 import tensorflow as tf
 import gradio as gr
-from tensorflow.keras.models import Sequential
+from tensorflow.keras.models import Sequential, load_model
 from tensorflow.keras.layers import LSTM, Dense, Embedding
 from tensorflow.keras.preprocessing.sequence import pad_sequences
 from tensorflow.keras.preprocessing.text import Tokenizer
@@ -13,12 +13,15 @@ from tensorflow.keras.preprocessing.text import Tokenizer
 os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
 os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
 
+# File paths
+csv_filename = "game_moves.csv"
+model_filename = "lstm_model.h5"
+
 # 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)
@@ -26,12 +29,12 @@ if not os.path.exists(csv_filename):
 
 def get_computer_choice(model, past_moves):
     """ Predicts player's next move and counteracts it. """
-    if len(past_moves) < 3:
+    if len(past_moves) < 5:  # Adjusted sequence length to 5
         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)
+    sequence = [choices[move] for move in past_moves[-5:]]
+    sequence = pad_sequences([sequence], maxlen=5)
     
     prediction = model.predict(sequence, verbose=0)
     predicted_choice = rev_choices[np.argmax(prediction)]
@@ -69,30 +72,37 @@ def load_data():
 
 def train_lstm_model(data):
     """ Trains an LSTM model to predict the player's next move. """
-    if len(data) < 4:
+    if len(data) < 6:  # Adjusted for longer training sequences
         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)
+    X = pad_sequences(sequences, maxlen=5)  # Using longer sequences
     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),
+        Embedding(input_dim=3, output_dim=10, input_length=5),
+        LSTM(30, return_sequences=False),  # Increased LSTM units for better learning
         Dense(3, activation="softmax")
     ])
     model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
-    
+
     if len(X) > 1:
-        model.fit(X[:-1], y, epochs=10, verbose=0)
+        model.fit(X[:-1], y, epochs=15, verbose=0)  # Increased epochs for better training
+        model.save(model_filename)  # Save trained model
+
     return model
 
-# Load past moves and train model
+# Load past moves
 past_moves = load_data()
-model = train_lstm_model(past_moves) if len(past_moves) >= 4 else None
+
+# Load existing model if available
+if os.path.exists(model_filename):
+    model = load_model(model_filename)
+else:
+    model = train_lstm_model(past_moves) if len(past_moves) >= 6 else None
 
 def play_game(player_choice):
     """ Handles the game logic and returns the result. """
@@ -113,8 +123,8 @@ def play_game(player_choice):
     save_move(player_choice, computer_choice, result)
     past_moves.append(player_choice)
 
-    # Retrain the model after each move
-    if len(past_moves) >= 4:
+    # Retrain the model only when enough new data is available
+    if len(past_moves) >= 6:
         model = train_lstm_model(past_moves)
 
     return f"Computer chose: {computer_choice}\n{result}"