Update app.py

app.py

@@ -1,175 +1,142 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
-from sklearn.preprocessing import LabelEncoder, StandardScaler
-from sklearn.model_selection import train_test_split
-import tensorflow as tf
-from tensorflow.keras.models import Sequential, load_model
-from tensorflow.keras.layers import Dense
-import joblib
-import os
-
-# Set page config
-st.set_page_config(page_title="Dynamic Game Pricing App", layout="wide")
-
-# Function to load or create data
-@st.cache_data
-def load_data():
-    if os.path.exists('game_data.csv'):
-        df = pd.read_csv('game_data.csv')
-    else:
-        # Sample dataset
-        data = {
-            'game_id': range(1, 101),
-            'genre': np.random.choice(['RPG', 'FPS', 'Strategy', 'Puzzle', 'Sports'], 100),
-            'region': np.random.choice(['Africa', 'NA', 'EU', 'Asia', 'SA'], 100),
-            'release_year': np.random.randint(2018, 2024, 100),
-            'demand_index': np.random.uniform(0.1, 1.0, 100),
-            'competitor_price': np.random.uniform(20, 60, 100),
-            'past_sales': np.random.randint(100, 1000, 100),
-            'suggested_price': np.random.uniform(25, 65, 100)
-        }
-        df = pd.DataFrame(data)
-        df.to_csv('game_data.csv', index=False)
-    
-    # Print column names for debugging
-    st.sidebar.write("Available columns:", df.columns.tolist())
-    
-    return df
+import plotly.graph_objects as go
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense
+import gym
+from stable_baselines3 import PPO
 
-# Load data
-df = load_data()
-
-# Sidebar for navigation and target column selection
-page = st.sidebar.selectbox("Choose a page", ["Data Explorer", "Model Training", "Price Prediction"])
-target_col = st.sidebar.selectbox("Select target column", df.columns.tolist())
+# Simulated data and functions
+def generate_sample_data(n_samples=1000):
+    dates = pd.date_range(start='2023-01-01', periods=n_samples)
+    df = pd.DataFrame({
+        'date': dates,
+        'base_price': np.random.uniform(4000000, 6000000, n_samples),
+        'competitor_price': np.random.uniform(4500000, 5500000, n_samples),
+        'demand': np.random.normal(100, 20, n_samples),
+        'social_media_sentiment': np.random.uniform(-1, 1, n_samples),
+        'economic_indicator': np.random.uniform(0.8, 1.2, n_samples),
+    })
+    df['price'] = df['base_price'] * (1 + 0.1 * df['social_media_sentiment']) * df['economic_indicator']
+    return df
 
-if page == "Data Explorer":
-    st.title("Data Explorer")
-    st.write(df)
-    
-    st.subheader("Data Statistics")
-    st.write(df.describe())
-    
-    st.subheader("Data Visualization")
-    fig, ax = plt.subplots(1, 2, figsize=(15, 5))
-    
-    numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns
-    x_col1 = st.selectbox("Select X-axis for first plot", numeric_cols, index=0)
-    x_col2 = st.selectbox("Select X-axis for second plot", numeric_cols, index=min(1, len(numeric_cols)-1))
-    
-    ax[0].scatter(df[x_col1], df[target_col])
-    ax[0].set_xlabel(x_col1)
-    ax[0].set_ylabel(target_col)
-    ax[0].set_title(f'{x_col1} vs {target_col}')
-    
-    ax[1].scatter(df[x_col2], df[target_col])
-    ax[1].set_xlabel(x_col2)
-    ax[1].set_ylabel(target_col)
-    ax[1].set_title(f'{x_col2} vs {target_col}')
-    
-    st.pyplot(fig)
+# Step 1: Regression Model
+def train_regression_model(data):
+    X = data[['competitor_price', 'demand', 'social_media_sentiment', 'economic_indicator']]
+    y = data['price']
+    model = GradientBoostingRegressor()
+    model.fit(X, y)
+    return model
 
-elif page == "Model Training":
-    st.title("Model Training")
-    
-    # Data preprocessing
-    categorical_cols = df.select_dtypes(include=['object']).columns
-    numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns
-    
-    # Remove target column from features
-    feature_cols = [col for col in numeric_cols if col != target_col]
-    
-    encoders = {}
-    for col in categorical_cols:
-        encoders[col] = LabelEncoder()
-        df[f'{col}_encoded'] = encoders[col].fit_transform(df[col])
-        feature_cols.append(f'{col}_encoded')
-    
-    X = df[feature_cols]
-    y = df[target_col]
-    
-    scaler = StandardScaler()
-    X_scaled = scaler.fit_transform(X)
-    
-    # Split the data
-    X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
-    
-    # Model architecture
+# Step 2: LSTM Model
+def create_lstm_model(input_shape):
     model = Sequential([
-        Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
-        Dense(32, activation='relu'),
-        Dense(16, activation='relu'),
+        LSTM(64, input_shape=input_shape, return_sequences=True),
+        LSTM(32),
         Dense(1)
     ])
-    
-    model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae'])
-    
-    # Training
-    if st.button("Train Model"):
-        with st.spinner("Training in progress..."):
-            history = model.fit(X_train, y_train, validation_split=0.2, epochs=100, batch_size=32, verbose=0)
-        
-        st.success("Model trained successfully!")
-        
-        # Plot training history
-        fig, ax = plt.subplots(figsize=(10, 5))
-        ax.plot(history.history['loss'], label='Training Loss')
-        ax.plot(history.history['val_loss'], label='Validation Loss')
-        ax.set_xlabel('Epoch')
-        ax.set_ylabel('Loss')
-        ax.legend()
-        st.pyplot(fig)
-        
-        # Save model and preprocessing objects
-        model.save('dynamic_pricing_model.h5')
-        joblib.dump(scaler, 'scaler.pkl')
-        joblib.dump(encoders, 'encoders.pkl')
-        joblib.dump(feature_cols, 'feature_cols.pkl')
-        joblib.dump(target_col, 'target_col.pkl')
-        
-        st.info("Model and preprocessing objects saved.")
-
-elif page == "Price Prediction":
-    st.title("Price Prediction")
-    
-    # Load saved model and objects
-    if os.path.exists('dynamic_pricing_model.h5'):
-        model = load_model('dynamic_pricing_model.h5')
-        scaler = joblib.load('scaler.pkl')
-        encoders = joblib.load('encoders.pkl')
-        feature_cols = joblib.load('feature_cols.pkl')
-        saved_target_col = joblib.load('target_col.pkl')
-        
-        if saved_target_col != target_col:
-            st.warning(f"Warning: The current target column ({target_col}) is different from the one used for training ({saved_target_col}). Consider retraining the model.")
-        
-        # User input
-        input_data = {}
-        for col in feature_cols:
-            if col.endswith('_encoded'):
-                original_col = col[:-8]  # Remove '_encoded' suffix
-                if original_col in encoders:
-                    value = st.selectbox(f"Select {original_col}", encoders[original_col].classes_)
-                    input_data[col] = encoders[original_col].transform([value])[0]
-            else:
-                if 'year' in col.lower():
-                    input_data[col] = st.slider(f"{col}", int(df[col].min()), int(df[col].max()), int(df[col].mean()))
-                elif 'price' in col.lower() or 'sales' in col.lower():
-                    input_data[col] = st.slider(f"{col}", float(df[col].min()), float(df[col].max()), float(df[col].mean()))
-                else:
-                    input_data[col] = st.slider(f"{col}", float(df[col].min()), float(df[col].max()), float(df[col].mean()))
-        
-        # Prepare input for prediction
-        input_df = pd.DataFrame([input_data])
-        input_scaled = scaler.transform(input_df)
-        
-        # Make prediction
-        if st.button("Predict Price"):
-            predicted_price = model.predict(input_scaled)[0][0]
-            st.success(f"Predicted {saved_target_col}: {predicted_price:.2f}")
-    else:
-        st.warning("Please train the model first!")
-
-st.sidebar.info("This app demonstrates dynamic pricing for game codes using a Feedforward ANN.")
+    model.compile(optimizer='adam', loss='mse')
+    return model
+
+def prepare_lstm_data(data, look_back=30):
+    X, y = [], []
+    for i in range(len(data) - look_back):
+        X.append(data[i:(i + look_back)])
+        y.append(data[i + look_back])
+    return np.array(X), np.array(y)
+
+# Step 3: Reinforcement Learning Environment
+class PricingEnv(gym.Env):
+    def __init__(self, data):
+        super(PricingEnv, self).__init__()
+        self.data = data
+        self.current_step = 0
+        self.action_space = gym.spaces.Box(low=0.9, high=1.1, shape=(1,))
+        self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(5,))
+
+    def reset(self):
+        self.current_step = 0
+        return self._get_observation()
+
+    def step(self, action):
+        self.current_step += 1
+        if self.current_step >= len(self.data):
+            return self._get_observation(), 0, True, {}
+
+        current_price = self.data.iloc[self.current_step]['price']
+        new_price = current_price * action[0]
+        reward = self._calculate_reward(new_price)
+
+        return self._get_observation(), reward, False, {}
+
+    def _get_observation(self):
+        obs = self.data.iloc[self.current_step][['competitor_price', 'demand', 'social_media_sentiment', 'economic_indicator', 'price']].values
+        return obs
+
+    def _calculate_reward(self, new_price):
+        base_demand = self.data.iloc[self.current_step]['demand']
+        price_elasticity = -1.5
+        demand = base_demand * (new_price / self.data.iloc[self.current_step]['price']) ** price_elasticity
+        revenue = new_price * demand
+        cost = 3000000  # Assuming a fixed cost
+        profit = revenue - cost
+        return profit
+
+# Streamlit App
+def main():
+    st.title("Dynamic Pricing System for GTA V Source Code")
+
+    # Generate sample data
+    data = generate_sample_data()
+
+    # Step 1: Regression Model
+    st.header("Step 1: Regression Model")
+    regression_model = train_regression_model(data)
+    latest_data = data.iloc[-1]
+    initial_price = regression_model.predict(latest_data[['competitor_price', 'demand', 'social_media_sentiment', 'economic_indicator']].values.reshape(1, -1))[0]
+    st.write(f"Initial price estimation: ${initial_price:,.2f}")
+
+    # Step 2: LSTM Model
+    st.header("Step 2: LSTM Model for Time-Series Adjustment")
+    scaler = StandardScaler()
+    scaled_data = scaler.fit_transform(data[['price']])
+    X, y = prepare_lstm_data(scaled_data)
+    lstm_model = create_lstm_model((X.shape[1], 1))
+    lstm_model.fit(X, y, epochs=50, batch_size=32, verbose=0)
+    
+    last_30_days = scaled_data[-30:].reshape(1, 30, 1)
+    lstm_prediction = lstm_model.predict(last_30_days)
+    adjusted_price = scaler.inverse_transform(lstm_prediction)[0][0]
+    st.write(f"LSTM adjusted price: ${adjusted_price:,.2f}")
+
+    # Step 3: Reinforcement Learning
+    st.header("Step 3: Reinforcement Learning for Dynamic Optimization")
+    env = PricingEnv(data)
+    model = PPO("MlpPolicy", env, verbose=0)
+    model.learn(total_timesteps=10000)
+
+    obs = env.reset()
+    rl_action, _ = model.predict(obs)
+    final_price = adjusted_price * rl_action[0]
+    st.write(f"Final dynamically optimized price: ${final_price:,.2f}")
+
+    # Interactive price adjustment
+    st.header("Interactive Price Adjustment")
+    user_adjustment = st.slider("Adjust the final price (%)", -20, 20, 0)
+    user_price = final_price * (1 + user_adjustment / 100)
+    st.write(f"User adjusted price: ${user_price:,.2f}")
+
+    # Visualize pricing history
+    st.header("Pricing History")
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=data['date'], y=data['price'], mode='lines', name='Historical Price'))
+    fig.add_trace(go.Scatter(x=[data['date'].iloc[-1]], y=[final_price], mode='markers', name='AI Suggested Price', marker=dict(size=10, color='red')))
+    fig.add_trace(go.Scatter(x=[data['date'].iloc[-1]], y=[user_price], mode='markers', name='User Adjusted Price', marker=dict(size=10, color='green')))
+    fig.update_layout(title='GTA V Source Code Pricing History', xaxis_title='Date', yaxis_title='Price ($)')
+    st.plotly_chart(fig)
+
+if __name__ == "__main__":
+    main()