up

requirements.txt

@@ -0,0 +1,8 @@
+pymongo[srv]==3.12.0
+numpy==1.21.3
+pandas==1.3.3
+scikit-learn==0.24.2
+streamlit
+tensorflow==2.7.0
+protobuf==3.18.0
+matplotlib

run.py

@@ -0,0 +1,164 @@
+import os
+import streamlit as st
+import numpy as np
+import tensorflow as tf
+from sklearn.preprocessing import StandardScaler
+from pymongo import MongoClient
+from pymongo.errors import ServerSelectionTimeoutError, AutoReconnect
+import matplotlib.pyplot as plt
+import time
+
+# Replace these values with your MongoDB connection details
+mongo_uri = "mongodb+srv://uorfot1138:a94DUMIAk3JYFj0t@cluster0.kenwsba.mongodb.net/?retryWrites=true&w=majority"
+database_name = "game"
+collection_name = "aviator"
+prediction_history_collection_name = "aviator_prediction_history"
+
+def connect_to_mongodb():
+    try:
+        client = MongoClient(mongo_uri)
+        database = client[database_name]
+        collection = database[collection_name]
+        prediction_history_collection = database[prediction_history_collection_name]
+        return collection, prediction_history_collection
+    except Exception as e:
+        st.error(f"Error connecting to MongoDB: {e}")
+
+def retrieve_data_from_mongodb(collection):
+    data =[]    
+    try:
+        cursor = collection.find()
+
+        for document in cursor:
+            _data = document['data']
+            __data = _data.split("x")
+            data.extend(__data)
+       
+    except (ServerSelectionTimeoutError, AutoReconnect) as e:
+        st.error(f"MongoDB connection error: {e}")
+
+    return data
+
+def save_prediction_to_mongodb(prediction, collection):
+    try:
+        collection.insert_one({'prediction': prediction})
+    except Exception as e:
+        st.error(f"Error saving prediction to MongoDB: {e}")
+
+def get_prediction_history_from_mongodb(collection):
+    try:
+        cursor = collection.find()
+        prediction_history = [document['prediction'] for document in cursor]
+        return prediction_history
+    except Exception as e:
+        st.error(f"Error retrieving prediction history from MongoDB: {e}")
+        return []
+
+def train_and_predict_aviator_model(aviator_game_history, prediction_history_collection, save_path='aviator_model'):
+    aviator_game_history = [float(value) if value.strip() else np.nan for value in aviator_game_history]
+
+    if not aviator_game_history:
+        st.warning("No valid data found.")
+        return None
+
+    # Interpolate missing values
+    aviator_game_history = np.array(aviator_game_history)
+    aviator_game_history = np.interp(np.arange(len(aviator_game_history)), np.arange(len(aviator_game_history))[~np.isnan(aviator_game_history)], aviator_game_history[~np.isnan(aviator_game_history)])
+
+    aviator_game_history = aviator_game_history.reshape(-1, 1)
+
+    # Normalize data to a consistent range
+    scaler = StandardScaler()
+    aviator_game_history_normalized = scaler.fit_transform(aviator_game_history)
+
+    # Get the prediction history from MongoDB
+    prediction_history = get_prediction_history_from_mongodb(prediction_history_collection)
+    prediction_history = np.array(prediction_history).reshape(-1, 1)
+
+    # Concatenate historical predictions with actual data
+    training_data = np.concatenate((aviator_game_history_normalized, prediction_history))
+
+    # Create sequences for training
+    sequence_length = 20  # Adjusted sequence length
+    X, y = [], []
+
+    for i in range(len(training_data) - sequence_length):
+        X.append(training_data[i:i + sequence_length])
+        y.append(training_data[i + sequence_length])
+
+    X, y = np.array(X), np.array(y)
+
+    model = tf.keras.Sequential([
+        tf.keras.layers.LSTM(128, activation='relu', input_shape=(sequence_length, 1), return_sequences=True),
+        tf.keras.layers.LSTM(64, activation='relu'),
+        tf.keras.layers.Dense(32, activation='relu'),
+        tf.keras.layers.Dense(1)
+    ])
+
+    model.compile(optimizer='adam', loss='mse')
+
+    model.fit(X, y, epochs=100, verbose=2)
+
+    # Predict the next sequence
+    last_sequence = aviator_game_history_normalized[-sequence_length:].reshape(1, sequence_length, 1)
+    predicted_sequence_normalized = model.predict(last_sequence)
+    predicted_sequence = scaler.inverse_transform(predicted_sequence_normalized)
+
+    # Apply a minimum value of 1
+    predicted_multiplier = np.maximum(predicted_sequence[0][0], 1.0)
+
+    # Save the prediction to MongoDB
+    save_prediction_to_mongodb(predicted_multiplier, prediction_history_collection)
+
+    # Save the model
+    model.save(save_path)
+    st.write(f"Model saved to {save_path}")
+
+    return predicted_multiplier
+
+# Streamlit UI
+st.title("Aviator Game Predictor")
+st.write("This app predicts the multiplier for the next round of the Aviator Game.")
+
+# Example usage:
+collection, prediction_history_collection = connect_to_mongodb()
+aviator_game_history = retrieve_data_from_mongodb(collection)
+
+# Create a placeholder for the predicted multiplier
+predicted_multiplier_placeholder = st.empty()
+
+# Create a placeholder for the chart
+chart_placeholder = st.empty()
+
+# Loop to continuously predict and display the next multiplier
+while True:
+    predicted_next_multiplier = train_and_predict_aviator_model(aviator_game_history, prediction_history_collection)
+
+    if predicted_next_multiplier is not None:
+        predicted_multiplier_placeholder.write(f'Predicted Next Multiplier: {predicted_next_multiplier}')
+
+        # Update the Aviator game history with the predicted value
+        aviator_game_history = np.append(aviator_game_history, predicted_next_multiplier)
+
+        # Get the prediction history from MongoDB
+        prediction_history = get_prediction_history_from_mongodb(prediction_history_collection)
+
+        # Plot the chart
+        plt.figure(figsize=(10, 6))
+        plt.plot(range(1, len(aviator_game_history) + 1), aviator_game_history, label='Actual Multiplier', marker='o')
+        plt.scatter(range(len(aviator_game_history), len(aviator_game_history) + len(prediction_history)), prediction_history, color='g', label='Predicted Multiplier')
+        plt.axvline(x=len(aviator_game_history), color='r', linestyle='--', label='Predicted Next Round')
+        plt.xlabel('Round')
+        plt.ylabel('Multiplier')
+        plt.title('Aviator Game Multiplier Prediction')
+        plt.legend()
+        chart_placeholder.pyplot(plt)
+
+        # Display the chart continuously
+        st.experimental_rerun()
+
+    else:
+        predicted_multiplier_placeholder.warning('Prediction failed due to lack of valid data.')
+
+    # Add a delay before the next iteration
+    time.sleep(8)  # Adjust the delay as needed