Update app.py

app.py

@@ -1,142 +1,82 @@
 import streamlit as st
-import pandas as pd
 import numpy as np
-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
-
-# 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
-
-# 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
-
-# Step 2: LSTM Model
-def create_lstm_model(input_shape):
-    model = Sequential([
-        LSTM(64, input_shape=input_shape, return_sequences=True),
-        LSTM(32),
-        Dense(1)
-    ])
-    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()
+import pandas as pd
+import tensorflow as tf
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+import joblib
 
-    # 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}")
+# Load the trained model
+model = tf.keras.models.load_model('trained_game_price_model.h5')
 
-    # 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)
+# Function to preprocess the input data
+def preprocess_input(data, ohe, scaler):
+    # Convert input into DataFrame for processing
+    input_data = pd.DataFrame([data], columns=['genre', 'targetPlatform', 'gamePlays', 'competitorPricing', 'currencyFluctuations'])
     
-    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)
+    # Apply OneHotEncoder for categorical features
+    input_data_transformed = ohe.transform(input_data[['genre', 'targetPlatform']])
+    
+    # Merge with numerical features
+    input_data = np.hstack((input_data_transformed, input_data[['gamePlays', 'competitorPricing', 'currencyFluctuations']].values))
+    
+    # Scale the numerical features
+    input_data_scaled = scaler.transform(input_data)
+    
+    return input_data_scaled
 
-if __name__ == "__main__":
-    main()
+# Function to make a prediction
+def make_prediction(input_data):
+    # Preprocess the data for the model
+    input_data_scaled = preprocess_input(input_data, ohe, scaler)
+    
+    # Make prediction
+    prediction = model.predict(input_data_scaled)
+    
+    return prediction[0][0]
+
+# Load pre-trained OneHotEncoder and StandardScaler (assuming you have these saved)
+ohe = joblib.load('ohe.pkl')  # Load the OneHotEncoder
+scaler = joblib.load('scaler.pkl')  # Load the StandardScaler
+
+# Streamlit application
+st.title("Game Price Prediction App")
+
+st.write("""
+### Enter the game details below to predict its price.
+""")
+
+# Game details form
+with st.form("game_details_form"):
+    genre = st.selectbox('Genre', ['Action', 'RPG', 'Puzzle', 'Adventure', 'Simulation', 'Strategy', 'Horror', 'Fighting', 'Sports', 'Racing', 'Casual', 'MOBA', 'Sandbox'])
+    target_platform = st.selectbox('Platform', ['PC', 'PlayStation', 'Xbox', 'Mobile', 'Switch', 'Nintendo 3DS', 'VR', 'Web'])
+    game_plays = st.number_input('Number of Game Plays', min_value=0, value=50000)
+    competitor_pricing = st.number_input('Competitor Pricing', min_value=0.0, value=30.0, format="%.2f")
+    currency_fluctuations = st.number_input('Currency Fluctuations', min_value=0.5, max_value=1.5, value=1.0, format="%.2f")
+
+    # Submit button
+    submitted = st.form_submit_button("Predict Price")
+
+# Prediction logic
+if submitted:
+    # Prepare input data
+    input_data = {
+        'genre': genre,
+        'targetPlatform': target_platform,
+        'gamePlays': game_plays,
+        'competitorPricing': competitor_pricing,
+        'currencyFluctuations': currency_fluctuations
+    }
+    
+    # Make prediction
+    predicted_price = make_prediction(input_data)
+    
+    # Display results
+    st.write(f"### Predicted Game Price: ${predicted_price:.2f}")
+    
+    # Show the input details for reference
+    st.write("#### Input Details:")
+    st.write(f"- **Genre**: {genre}")
+    st.write(f"- **Platform**: {target_platform}")
+    st.write(f"- **Game Plays**: {game_plays}")
+    st.write(f"- **Competitor Pricing**: ${competitor_pricing:.2f}")
+    st.write(f"- **Currency Fluctuations**: {currency_fluctuations}")