MichaelB-AI/lstm-roulette-prediction

LSTM Roulette Betting Prediction Model

Model Description

This LSTM model is designed to predict the total outcome of a betting session in a roulette game. The model takes in features such as bet amount, payout odds, total wagered, and session duration to make predictions.

Training

The model is trained using the following steps:

1. Preprocessing: The input data is preprocessed to ensure numeric values and scaled using a MinMaxScaler.
2. Data Splitting: The data is split into training and testing sets.
3. Model Building: An LSTM model is built with an input shape of (1, number_of_features).
4. Training: The model is trained for 20 epochs with a batch size of 32, using the training data and validating on the testing data.

Usage

To use this model, you need to preprocess your session data and scale it using the same MinMaxScaler used during training. The model can then make predictions for each bet in the session, and the total winnings can be calculated by summing the predictions.

Example Code

import joblib
import pandas as pd
import tensorflow as tf

# Load the model and scaler
model = tf.keras.models.load_model('model.pkl')
scaler = joblib.load('scaler.pkl')

# Example session data
session_data = pd.DataFrame({
    'bet_amount': [30, 50],
    'payout_odds': [35, 17],
    'total_wagered': [30, 80],
    'session_duration': [10, 20]
})

# Ensure correct data types and scale the session data
numeric_columns = ['bet_amount', 'payout_odds', 'total_wagered', 'session_duration']
session_data[numeric_columns] = session_data[numeric_columns].apply(pd.to_numeric, errors='coerce')
session_data = session_data.dropna(subset=numeric_columns)

features = ['bet_amount', 'payout_odds', 'total_wagered', 'session_duration']
X_scaled = scaler.transform(session_data[features])

# Reshape for LSTM input (each row corresponds to a bet)
X_scaled = X_scaled.reshape((X_scaled.shape[0], 1, X_scaled.shape[1]))

# Make predictions for each bet
predictions_scaled = model.predict(X_scaled)

# Inverse transform the predictions back to the original scale
predictions = scaler.inverse_transform([[0, 0, 0, pred] for pred in predictions_scaled.flatten()])[:, -1]

# Sum the predictions to get the total winnings for the entire session
total_winnings = predictions.sum()
print(f"Total Winnings: {total_winnings}")


## Model Details

**Input Features:** 
- `bet_amount`
- `payout_odds`
- `total_wagered`
- `session_duration`

**Output:** 
- Predicted total winnings for the session

**Architecture:** 
- LSTM with 64 units
- Dense layer with 32 units and ReLU activation
- Dense output layer with a single unit and linear activation

## Limitations

- The accuracy of model depends on the quality and quantity of the training data.
- The model may not generalize well to unseen data if the training data is not representative of real-world scenarios.

## Example Bets

**First Bet:**
- **Bet Amount:** 30 USD
- **Payout Odds:** 2.0 (e.g., bet on a Dozen)
- **Outcome:**  
    Since the bet is won, the outcome is calculated as:
    ```
    Outcome = 30 × 2.0 = 60 USD
    ```
Total Wagered: 30 USD
Total Winnings: The total winnings after the first bet is 60 USD.

**Second Bet:**
- **Bet Amount:** 50 USD
- **Payout Odds:** 1.0 (e.g., bet on Red/Black)
- **Outcome:**  
    The bet is lost, so the outcome is:
    ```
    Outcome = 0 USD
    ```
Total Wagered: The total wagered now becomes 80 USD (30 from the first bet + 50 from the second bet).
Total Winnings: The total winnings after both bets is updated to 60 USD.

## About AI

### Understanding LSTM
LSTM (Long Short-Term Memory) is a type of Recurrent Neural Network (RNN) that is particularly good at learning from sequential data. It is designed to remember information for long periods, which is beneficial for time-series data such as betting sessions.

**Key Features:**
- **Cell State:** LSTMs maintain a cell state that carries relevant information across time steps, allowing them to remember past inputs that may be critical for predicting future outcomes.
- **Forget Gate:** It determines which information should be discarded from the cell state.
- **Input Gate:** It decides which new information will be added to the cell state.
- **Output Gate:** It determines what the next hidden state (output) should be, based on the cell state.

## Preprocessing Data
The `preprocess_data` function is responsible for preparing the data for training the LSTM model. It performs the following steps:
- Ensures that the input data contains numeric values for the relevant columns.
- Drops rows with missing values in the numeric columns.
- Aggregates the data by `player_id` and `session_id` to compute the sum, mean, or max of the numeric features.
- Scales the numeric features using a `MinMaxScaler`.
- Returns the scaled features, target variable (`total_winnings`), and the scaler.

## Building the LSTM Model
The `build_lstm_model` function constructs an LSTM model with the following architecture:
- An LSTM layer with 64 units.
- A Dense layer with 32 units and ReLU activation.
- A Dense output layer with a single unit and linear activation for regression.
The model is compiled with the Adam optimizer and mean squared error loss function.

## Training the LSTM Model
The `train_lstm_model` function trains the LSTM model using the preprocessed data. It performs the following steps:
- Calls `preprocess_data` to get the scaled features, target variable, and scaler.
- Splits the data into training and testing sets.
- Reshapes the data for LSTM input.
- Builds the LSTM model using `build_lstm_model`.
- Trains the model for 20 epochs with a batch size of 32, using the training data and validating on the testing data.
- Returns the trained model and the scaler.

## Predicting Session Outcomes
The `predict_lstm_session` function predicts the total outcome of a betting session using the trained LSTM model. It performs the following steps:
- Ensures that the session data contains numeric values for the relevant columns and drops rows with missing values.
- Scales the session data using the provided scaler.
- Reshapes the scaled data for LSTM input.
- Makes predictions for each bet in the session.
- Inverse transforms the predictions to the original scale.
- Sums the predictions to get the total winnings for the session.

## Citation
If you use this model in your research, please cite it as follows:

@misc{your-username_lstm_roulette_prediction, author = {MichaelB-AI}, title = {LSTM Roulette Betting Prediction Model}, year = {2024}, publisher = {HuggingFace}, url = {https://huggingface.co/MichaelB-AI/lstm-roulette-prediction} }

## Contact
For questions or issues, please contact [[email protected]].