Update app.py

app.py

@@ -11,20 +11,22 @@ import plotly.graph_objects as go
 def fetch_ethereum_data():
     """
     Fetch historical Ethereum price data using yfinance.
-    Returns DataFrame with date and price information.
+    Returns DataFrame with datetime index and price information.
+    The data is sampled hourly for the past week.
     """
     eth_ticker = yf.Ticker("ETH-USD")
-    # Get data for the past week
+    # Get hourly data for the past week
     hist_data = eth_ticker.history(period="7d", interval="1h")
-    return hist_data[['Close']].reset_index()
+    # Keep the datetime index and Close price
+    return hist_data[['Close']]
 
 def prepare_data(data, sequence_length=24):
     """
     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
+        data: DataFrame with price data and datetime index
+        sequence_length: Number of time steps to use for prediction (default: 24 hours)
     """
     # Scale the data
     scaler = MinMaxScaler()
@@ -47,6 +49,7 @@ def prepare_data(data, sequence_length=24):
 def create_model(sequence_length):
     """
     Create and compile LSTM model for time series prediction.
+    Uses a two-layer LSTM architecture followed by dense layers.
     """
     model = Sequential([
         LSTM(50, return_sequences=True, input_shape=(sequence_length, 1)),
@@ -66,14 +69,17 @@ def predict_future_prices(model, last_sequence, scaler, days=7):
         model: Trained LSTM model
         last_sequence: Last sequence of known prices
         scaler: Fitted MinMaxScaler
-        days: Number of days to predict
+        days: Number of days to predict (default: 7)
     """
     future_predictions = []
     current_sequence = last_sequence.copy()
     
-    for _ in range(days):
+    # Convert days to hours since we're using hourly data
+    hours = days * 24
+    
+    for _ in range(hours):
         # Predict next price
-        scaled_prediction = model.predict(current_sequence.reshape(1, -1, 1))
+        scaled_prediction = model.predict(current_sequence.reshape(1, -1, 1), verbose=0)
         # Inverse transform to get actual price
         prediction = scaler.inverse_transform(scaled_prediction)[0][0]
         future_predictions.append(prediction)
@@ -86,21 +92,19 @@ def predict_future_prices(model, last_sequence, scaler, days=7):
 
 def create_prediction_plot(historical_data, future_predictions, future_dates):
     """
-    Create an interactive plot showing the last week of historical prices and week-ahead predictions.
+    Create an interactive plot showing the last week of historical prices 
+    and week-ahead predictions with hourly granularity.
     
     Args:
-        historical_data: DataFrame with historical price data
+        historical_data: DataFrame with historical price data and datetime index
         future_predictions: List of predicted prices
-        future_dates: List of future dates for predictions
-    """
-    """
-    Create an interactive plot showing historical prices and predictions.
+        future_dates: List of future datetime indices for predictions
     """
     fig = go.Figure()
     
-    # Plot historical data
+    # Plot historical data using the datetime index
     fig.add_trace(go.Scatter(
-        x=historical_data['Date'],
+        x=historical_data.index,
         y=historical_data['Close'],
         name='Historical Prices',
         line=dict(color='blue')
@@ -115,7 +119,7 @@ def create_prediction_plot(historical_data, future_predictions, future_dates):
     ))
     
     fig.update_layout(
-        title='Ethereum Price Prediction',
+        title='Ethereum Price Prediction (Hourly)',
         xaxis_title='Date',
         yaxis_title='Price (USD)',
         hovermode='x unified'
@@ -126,10 +130,11 @@ def create_prediction_plot(historical_data, future_predictions, future_dates):
 def predict_ethereum():
     """
     Main function for Gradio interface that orchestrates the prediction process.
+    Handles hourly data and generates predictions for the next week.
     """
     # Fetch and prepare data
     data = fetch_ethereum_data()
-    sequence_length = 24
+    sequence_length = 24  # Use 24 hours of data for prediction
     X, y, scaler = prepare_data(data, sequence_length)
     
     # Create and train model
@@ -142,9 +147,9 @@ def predict_ethereum():
     # 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 future dates (hourly intervals)
+    last_date = data.index[-1]
+    future_dates = [last_date + timedelta(hours=i+1) for i in range(len(future_predictions))]
     
     # Create and return plot
     fig = create_prediction_plot(data, future_predictions, future_dates)
@@ -156,7 +161,7 @@ iface = gr.Interface(
     inputs=None,
     outputs=gr.Plot(),
     title="Ethereum Price Prediction",
-    description="Click to generate a 7-day price prediction for Ethereum based on historical data.",
+    description="Click to generate a 7-day price prediction for Ethereum based on hourly historical data.",
     theme=gr.themes.Base()
 )