Update app.py

app.py

@@ -1,79 +1,156 @@
 import gradio as gr
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
 import yfinance as yf
+from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense
 import plotly.graph_objects as go
-from statsmodels.tsa.arima.model import ARIMA
-import pandas as pd
-import logging
 
-logging.basicConfig(level=logging.INFO)
+def fetch_ethereum_data():
+    """
+    Fetch historical Ethereum price data using yfinance.
+    Returns DataFrame with date and price information.
+    """
+    eth_ticker = yf.Ticker("ETH-USD")
+    # Get data for the past year
+    hist_data = eth_ticker.history(period="1y")
+    return hist_data[['Close']].reset_index()
 
-def fetch_eth_price(period):
-    eth = yf.Ticker("ETH-USD")
-    if period == '1d':
-        data = eth.history(period="1d", interval="1m")
-        predict_steps = 60  # Next 60 minutes
-        freq = 'min'  # Minute frequency
-    elif period == '5d':
-        data = eth.history(period="5d", interval="15m")
-        predict_steps = 96  # Next 24 hours
-        freq = '15min'  # 15 minutes frequency
-    elif period == '1wk':
-        data = eth.history(period="1wk", interval="30m")
-        predict_steps = 336  # Next 7 days
-        freq = '30min'  # 30 minutes frequency
-    elif period == '1mo':
-        data = eth.history(period="1mo", interval="1h")
-        predict_steps = 720  # Next 30 days
-        freq = 'H'  # Hourly frequency
-    else:
-        return None, None, None
-    
-    data.index = pd.DatetimeIndex(data.index)
-    data = data.asfreq(freq)  # Ensure the data has a consistent frequency
-    
-    # Limit the data to the last 200 points to reduce prediction time
-    data = data[-200:]
-    
-    return data, predict_steps, freq
+def prepare_data(data, sequence_length=60):
+    """
+    Prepare data for LSTM model by creating sequences and scaling.
+    
+    Args:
+        data: DataFrame with price data
+        sequence_length: Number of time steps to use for prediction
+    """
+    # Scale the data
+    scaler = MinMaxScaler()
+    scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))
+    
+    # Create sequences for training
+    X, y = [], []
+    for i in range(sequence_length, len(scaled_data)):
+        X.append(scaled_data[i-sequence_length:i, 0])
+        y.append(scaled_data[i, 0])
+    
+    X = np.array(X)
+    y = np.array(y)
+    
+    # Reshape X for LSTM input
+    X = X.reshape(X.shape[0], X.shape[1], 1)
+    
+    return X, y, scaler
 
-def make_predictions(data, predict_steps, freq):
-    if data is None or data.empty:
-        logging.error("No data available for prediction.")
-        return pd.DataFrame(index=pd.date_range(start=pd.Timestamp.now(), periods=predict_steps+1, freq=freq)[1:])
+def create_model(sequence_length):
+    """
+    Create and compile LSTM model for time series prediction.
+    """
+    model = Sequential([
+        LSTM(50, return_sequences=True, input_shape=(sequence_length, 1)),
+        LSTM(50, return_sequences=False),
+        Dense(25),
+        Dense(1)
+    ])
+    
+    model.compile(optimizer='adam', loss='mse')
+    return model
 
-    logging.info(f"Starting model training with {len(data)} data points...")
-    model = ARIMA(data['Close'], order=(5, 1, 0))
-    model_fit = model.fit()
-    logging.info("Model training completed.")
+def predict_future_prices(model, last_sequence, scaler, days=7):
+    """
+    Predict future prices using the trained model.
     
-    forecast = model_fit.forecast(steps=predict_steps)
-    future_dates = pd.date_range(start=data.index[-1], periods=predict_steps+1, freq=freq, inclusive='right')
-    forecast_df = pd.DataFrame(forecast, index=future_dates[1:], columns=['Prediction'])
+    Args:
+        model: Trained LSTM model
+        last_sequence: Last sequence of known prices
+        scaler: Fitted MinMaxScaler
+        days: Number of days to predict
+    """
+    future_predictions = []
+    current_sequence = last_sequence.copy()
     
-    logging.info("Predictions generated successfully.")
-    return forecast_df
-
-def plot_eth(period):
-    data, predict_steps, freq = fetch_eth_price(period)
-    forecast_df = make_predictions(data, predict_steps, freq)
+    for _ in range(days):
+        # Predict next price
+        scaled_prediction = model.predict(current_sequence.reshape(1, -1, 1))
+        # Inverse transform to get actual price
+        prediction = scaler.inverse_transform(scaled_prediction)[0][0]
+        future_predictions.append(prediction)
+        
+        # Update sequence for next prediction
+        current_sequence = np.roll(current_sequence, -1)
+        current_sequence[-1] = scaled_prediction
     
+    return future_predictions
+
+def create_prediction_plot(historical_data, future_predictions, future_dates):
+    """
+    Create an interactive plot showing historical prices and predictions.
+    """
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='ETH Price'))
-    fig.add_trace(go.Scatter(x=forecast_df.index, y=forecast_df['Prediction'], mode='lines', name='Prediction', line=dict(dash='dash', color='orange')))
-    fig.update_layout(title=f"ETH Price and Predictions ({period})", xaxis_title="Date", yaxis_title="Price (USD)")
     
-    logging.info("Plotting completed.")
+    # Plot historical data
+    fig.add_trace(go.Scatter(
+        x=historical_data['Date'],
+        y=historical_data['Close'],
+        name='Historical Prices',
+        line=dict(color='blue')
+    ))
+    
+    # Plot predictions
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=future_predictions,
+        name='Predictions',
+        line=dict(color='red', dash='dash')
+    ))
+    
+    fig.update_layout(
+        title='Ethereum Price Prediction',
+        xaxis_title='Date',
+        yaxis_title='Price (USD)',
+        hovermode='x unified'
+    )
+    
     return fig
 
-def refresh_predictions(period):
-    return plot_eth(period)
-
-with gr.Blocks() as iface:
-    period = gr.Radio(["1d", "5d", "1wk", "1mo"], label="Select Period")
-    plot = gr.Plot()
-    refresh_button = gr.Button("Refresh Predictions and Prices")
+def predict_ethereum():
+    """
+    Main function for Gradio interface that orchestrates the prediction process.
+    """
+    # Fetch and prepare data
+    data = fetch_ethereum_data()
+    sequence_length = 60
+    X, y, scaler = prepare_data(data, sequence_length)
+    
+    # Create and train model
+    model = create_model(sequence_length)
+    model.fit(X, y, epochs=50, batch_size=32, verbose=0)
     
-    period.change(fn=plot_eth, inputs=period, outputs=plot)
-    refresh_button.click(fn=refresh_predictions, inputs=period, outputs=plot)
+    # Prepare last sequence for prediction
+    last_sequence = scaler.transform(data['Close'].values[-sequence_length:].reshape(-1, 1))
     
-iface.launch()
+    # Generate future predictions
+    future_predictions = predict_future_prices(model, last_sequence, scaler)
+    
+    # Create future dates
+    last_date = data['Date'].iloc[-1]
+    future_dates = [last_date + timedelta(days=i+1) for i in range(7)]
+    
+    # Create and return plot
+    fig = create_prediction_plot(data, future_predictions, future_dates)
+    return fig
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_ethereum,
+    inputs=None,
+    outputs=gr.Plot(),
+    title="Ethereum Price Prediction",
+    description="Click to generate a 7-day price prediction for Ethereum based on historical data.",
+    theme=gr.themes.Base()
+)
+
+if __name__ == "__main__":
+    iface.launch()