Update app.py

app.py

@@ -1,4 +1,3 @@
-# crypto_price_prediction.py
 import os
 import torch
 import torch.nn as nn
@@ -6,9 +5,7 @@ from torch.optim.lr_scheduler import ReduceLROnPlateau
 import numpy as np
 import pandas as pd
 import yfinance as yf
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import gradio as gr
+import streamlit as st
 from sklearn.preprocessing import MinMaxScaler
 from datetime import datetime, timedelta
 import joblib
@@ -173,10 +170,10 @@ class CryptoAnalyzer:
             model.eval()
             with torch.no_grad():
                 predictions, confidence = model(X)
-                predictions = predictions.cpu().numpy().reshape(-1, 1)
-                predictions = self.price_scaler.inverse_transform(predictions).flatten()
-                y_np = y.cpu().numpy().reshape(-1, 1)
-                actual_prices = self.price_scaler.inverse_transform(y_np).flatten()
+                predictions_reshaped = predictions.cpu().numpy().reshape(-1, 1)
+                predictions = self.price_scaler.inverse_transform(predictions_reshaped).flatten()
+                y_np_reshaped = y.cpu().numpy().reshape(-1, 1)
+                actual_prices = self.price_scaler.inverse_transform(y_np_reshaped).flatten()
                 rmse = float(np.sqrt(np.mean((actual_prices - predictions) ** 2)))
                 mape = float(np.mean(np.abs((actual_prices - predictions) / actual_prices)) * 100)
                 r2 = float(1 - np.sum((actual_prices - predictions) ** 2) / np.sum((actual_prices - actual_prices.mean()) ** 2))
@@ -198,172 +195,39 @@ class CryptoAnalyzer:
         except Exception as e:
             raise ValueError(f"Prediction failed: {str(e)}")
 
-def create_analysis_plots(symbol, days=180, lookback=30):
-    try:
-        analyzer = CryptoAnalyzer()
-        predictions = analyzer.get_predictions(symbol, days, lookback)
-        fig = make_subplots(
-            rows=3, cols=1,
-            subplot_titles=(
-                f"{symbol} Price Prediction with Confidence Bands",
-                "Technical Indicators",
-                "Model Performance Metrics"
-            ),
-            vertical_spacing=0.1,
-            specs=[[{"secondary_y": True}],
-                  [{"secondary_y": True}],
-                  [{"secondary_y": True}]]
-        )
-        confidence_upper = np.array(predictions['predicted']) * (1 + np.array(predictions['confidence']))
-        confidence_lower = np.array(predictions['predicted']) * (1 - np.array(predictions['confidence']))
-        fig.add_trace(
-            go.Scatter(
-                x=predictions['dates'],
-                y=predictions['actual'],
-                name='Actual Price',
-                line=dict(color='blue', width=2)
-            ),
-            row=1, col=1
-        )
-        fig.add_trace(
-            go.Scatter(
-                x=predictions['dates'],
-                y=predictions['predicted'],
-                name='Predicted Price',
-                line=dict(color='red', width=2)
-            ),
-            row=1, col=1
-        )
-        fig.add_trace(
-            go.Scatter(
-                x=predictions['dates'] + predictions['dates'][::-1],
-                y=list(confidence_upper) + list(confidence_lower)[::-1],
-                fill='toself',
-                fillcolor='rgba(255,0,0,0.1)',
-                line=dict(color='rgba(255,0,0,0)'),
-                name='Confidence Band'
-            ),
-            row=1, col=1
-        )
-        fig.update_layout(
-            height=1200,
-            title_text=f"📈 {symbol} Price Analysis Dashboard",
-            showlegend=True,
-            template="plotly_dark",
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            font=dict(size=12)
-        )
-        summary = f"""
-### 📊 Analysis Summary for {symbol}
-
-#### Current Market Status
-- **Current Price:** ${predictions['current_price']:,.2f}
-- **Predicted Next Price:** ${predictions['predicted'][-1]:,.2f}
-- **Expected Change:** {((predictions['predicted'][-1] - predictions['current_price']) / predictions['current_price'] * 100):,.2f}%
-- **24h Volume:** {predictions['volume']:,.0f}
-
-#### Technical Indicators
-- **RSI:** {predictions['rsi']:,.2f}
-- **MACD:** {predictions['macd']:,.2f}
-- **Volatility:** {predictions['volatility']:,.2f}%
-
-#### Model Performance Metrics
-- **R² Score:** {predictions['r2']:,.4f}
-- **RMSE:** ${predictions['rmse']:,.2f}
-- **MAPE:** {predictions['mape']:,.2f}%
-
-#### Prediction Confidence
-- **Average Confidence:** {np.mean(predictions['confidence']) * 100:,.2f}%
-- **Trend Direction:** {'🔺 Upward' if predictions['predicted'][-1] > predictions['actual'][-1] else '🔻 Downward'}
+def main():
+    st.title("🚀 Cryptocurrency Price Prediction")
+    st.sidebar.header("Settings")
+    symbol = st.sidebar.selectbox("Select Cryptocurrency", ["BTC", "ETH", "BNB", "XRP", "ADA", "SOL", "DOT", "DOGE"], index=0)
+    custom_symbol = st.sidebar.text_input("Or enter custom symbol (e.g., MATIC)", "")
+    days = st.sidebar.slider("Historical Days", 30, 365, 180)
+    lookback = st.sidebar.slider("Lookback Period (Days)", 7, 60, 30)
+    symbol = custom_symbol if custom_symbol else symbol
 
-> *Note: Past performance does not guarantee future results. This analysis is for informational purposes only.*
-        """
-        return fig, summary
-    except Exception as e:
-        fig = go.Figure()
-        fig.add_annotation(
-            text=str(e),
-            xref="paper",
-            yref="paper",
-            x=0.5,
-            y=0.5,
-            showarrow=False
-        )
-        return fig, f"⚠️ Error: {str(e)}"
-
-def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft()) as iface:
-        gr.Markdown("""
-        # 🚀 Advanced Cryptocurrency Price Prediction
-
-        This app uses deep learning to predict cryptocurrency prices and provide comprehensive market analysis.
-
-        ### Features:
-        - Real-time price predictions
-        - Technical indicators analysis
-        - Confidence metrics
-        - Performance visualization
-        """)
-        with gr.Row():
-            with gr.Column(scale=1):
-                crypto_input = gr.Dropdown(
-                    choices=['BTC', 'ETH', 'BNB', 'XRP', 'ADA', 'SOL', 'DOT', 'DOGE'],
-                    label="Select Cryptocurrency",
-                    value="BTC"
-                )
-                custom_crypto = gr.Textbox(
-                    label="Or enter custom symbol",
-                    placeholder="e.g., MATIC"
-                )
-                with gr.Row():
-                    days_slider = gr.Slider(
-                        minimum=30, maximum=365, value=180, step=30,
-                        label="Historical Days"
-                    )
-                    lookback_slider = gr.Slider(
-                        minimum=7, maximum=60, value=30, step=1,
-                        label="Lookback Period (Days)"
-                    )
-                submit_btn = gr.Button("📊 Generate Analysis", variant="primary")
-            with gr.Column(scale=2):
-                plot_output = gr.Plot(label="Analysis Plots")
-        with gr.Row():
-            analysis_output = gr.Markdown(label="Analysis Summary")
-            error_output = gr.Markdown(visible=False)
-        def handle_analysis(symbol, custom_symbol, days, lookback):
-            try:
-                final_symbol = custom_symbol if custom_symbol else symbol
-                figure, summary = create_analysis_plots(final_symbol, days, lookback)
-                return figure, summary, gr.update(visible=False, value="")
-            except Exception as e:
-                empty_fig = go.Figure()
-                error_msg = f"⚠️ Error during analysis: {str(e)}"
-                return empty_fig, "", gr.update(visible=True, value=error_msg)
-        submit_btn.click(
-            fn=handle_analysis,
-            inputs=[crypto_input, custom_crypto, days_slider, lookback_slider],
-            outputs=[plot_output, analysis_output, error_output]
-        )
-    return iface
+    if st.sidebar.button("📊 Generate Analysis"):
+        analyzer = CryptoAnalyzer()
+        try:
+            st.info("Fetching data and generating predictions...")
+            predictions = analyzer.get_predictions(symbol, days, lookback)
+
+            # Display results
+            st.subheader("📈 Price Prediction Results")
+            st.line_chart({
+                "Actual Prices": predictions['actual'],
+                "Predicted Prices": predictions['predicted']
+            })
+
+            st.subheader("📊 Model Metrics")
+            st.write(f"**R² Score:** {predictions['r2']:.4f}")
+            st.write(f"**RMSE:** ${predictions['rmse']:.2f}")
+            st.write(f"**MAPE:** {predictions['mape']:.2f}%")
+
+            st.subheader("🔍 Additional Indicators")
+            st.write(f"**RSI:** {predictions['rsi']:.2f}")
+            st.write(f"**MACD:** {predictions['macd']:.2f}")
+            st.write(f"**Volatility:** {predictions['volatility']:.2f}%")
+        except Exception as e:
+            st.error(f"⚠️ Error: {str(e)}")
 
 if __name__ == "__main__":
-    import logging
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.FileHandler('crypto_predictor.log'),
-            logging.StreamHandler()
-        ]
-    )
-    try:
-        os.makedirs("models", exist_ok=True)
-        os.makedirs("cache", exist_ok=True)
-        iface = create_interface()
-        iface.launch(
-            share=False, server_name="0.0.0.0", server_port=7860, debug=True
-        )
-    except Exception as e:
-        logging.error(f"Application failed to start: {str(e)}")
-        raise
+    main()