solves bug in inference pipeline

README.md

@@ -11,65 +11,96 @@ license: mit
 short_description: Use Amazon Chronos To Predict Stock Prices
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Stock Analysis and Prediction Demo
 
-
-# Stock Price Prediction with Amazon Chronos
-
-A neural network application that uses Amazon's Chronos model for time series forecasting to predict stock prices.
+A comprehensive stock analysis and prediction tool built with Gradio, featuring multiple prediction strategies and technical analysis indicators.
 
 ## Features
 
-- Real-time stock price predictions using Amazon Chronos
-- Interactive visualization of predictions with confidence intervals
-- Support for multiple timeframes (daily, hourly, 15-minute)
-- User-friendly Gradio interface
-- Free stock data using yfinance API
+- **Multiple Prediction Strategies**:
+  - Chronos ML-based prediction
+  - Technical analysis-based prediction
 
-## Hugging Face Spaces Deployment
+- **Technical Indicators**:
+  - RSI (Relative Strength Index)
+  - MACD (Moving Average Convergence Divergence)
+  - Bollinger Bands
+  - Simple Moving Averages (20 and 50-day)
 
-This application is configured to run on Hugging Face Spaces. To deploy:
+- **Trading Signals**:
+  - Buy/Sell recommendations based on multiple indicators
+  - Overall trading signal combining all indicators
+  - Confidence intervals for predictions
 
-1. Create a new Space on Hugging Face
-2. Choose "Docker" as the SDK
-3. Upload all the files to your Space
+- **Interactive Visualizations**:
+  - Price prediction with confidence intervals
+  - Technical indicators overlay
+  - Volume analysis
+  - Historical price trends
 
-## Local Development
+## Installation
 
-To run locally:
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd stock-prediction
+```
 
+2. Create and activate a virtual environment:
 ```bash
-# Create and activate virtual environment
 python -m venv .venv
 source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
 
-# Install dependencies
+3. Install dependencies:
+```bash
 pip install -r requirements.txt
+```
+
+## Usage
 
-# Run the application
+1. Start the Gradio demo:
+```bash
 python app.py
 ```
 
-## Model Details
+2. Open your web browser and navigate to the URL shown in the terminal (typically http://localhost:7860)
 
-The application uses Amazon's Chronos model for time series forecasting. The model is configured to:
+3. Enter a stock symbol (e.g., AAPL, GOOGL, MSFT) and select your desired parameters:
+   - Timeframe (1d, 1h, 15m)
+   - Number of days to predict
+   - Prediction strategy (Chronos or Technical)
 
-- Make predictions for stock prices
-- Calculate confidence intervals
-- Generate interactive visualizations
-- Support multiple prediction horizons
+4. Click "Analyze Stock" to get predictions and trading signals
 
-## Usage
+## Prediction Strategies
+
+### Chronos Strategy
+Uses Amazon's Chronos model for ML-based price prediction. This strategy:
+- Analyzes historical price patterns
+- Generates probabilistic forecasts
+- Provides confidence intervals
+
+### Technical Strategy
+Uses traditional technical analysis indicators to generate predictions:
+- RSI for overbought/oversold conditions
+- MACD for trend direction
+- Bollinger Bands for volatility
+- Moving Averages for trend confirmation
+
+## Trading Signals
+
+The demo provides trading signals based on multiple technical indicators:
+- RSI: Oversold (<30), Overbought (>70), Neutral
+- MACD: Buy (MACD > Signal), Sell (MACD < Signal)
+- Bollinger Bands: Buy (price < lower band), Sell (price > upper band)
+- SMA: Buy (20-day > 50-day), Sell (20-day < 50-day)
+
+An overall trading signal is calculated by combining all individual signals.
 
-1. Enter a stock symbol (e.g., AAPL, GOOGL, MSFT)
-2. Select the desired timeframe (1d, 1h, 15m)
-3. Choose the number of days to predict (1-30)
-4. Click "Make Prediction" to generate forecasts
+## Contributing
 
-The application will display:
-- A plot showing historical prices and predictions
-- Confidence intervals for the predictions
-- A separate plot showing prediction uncertainty
+Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## License
 

app.py

@@ -7,34 +7,39 @@ import torch
 from chronos import BaseChronosPipeline
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-import spaces
+from sklearn.preprocessing import MinMaxScaler
+import plotly.express as px
+from typing import Dict, List, Tuple, Optional
+import json
 
-# Initialize Chronos pipeline
+# Initialize global variables
 pipeline = None
+scaler = MinMaxScaler(feature_range=(-1, 1))
+scaler.fit_transform([[-1, 1]])
 
-@spaces.GPU
 def load_pipeline():
-    """Load the Chronos model with GPU configuration"""
+    """Load the Chronos model with CPU configuration"""
     global pipeline
     if pipeline is None:
         pipeline = BaseChronosPipeline.from_pretrained(
             "amazon/chronos-bolt-base",
-            device_map="auto",  # Let the model use GPU if available
-            torch_dtype=torch.float16  # Use float16 for better GPU performance
+            device_map="cpu",
+            torch_dtype=torch.float32
         )
         pipeline.model = pipeline.model.eval()
     return pipeline
 
-def get_historical_data(symbol: str, timeframe: str = "1d") -> np.ndarray:
+def get_historical_data(symbol: str, timeframe: str = "1d", lookback_days: int = 365) -> pd.DataFrame:
     """
     Fetch historical data using yfinance.
     
     Args:
         symbol (str): The stock symbol (e.g., 'AAPL')
         timeframe (str): The timeframe for data ('1d', '1h', '15m')
+        lookback_days (int): Number of days to look back
     
     Returns:
-        np.ndarray: Array of historical prices for Chronos model
+        pd.DataFrame: Historical data with OHLCV and technical indicators
     """
     try:
         # Map timeframe to yfinance interval
@@ -47,83 +52,118 @@ def get_historical_data(symbol: str, timeframe: str = "1d") -> np.ndarray:
         
         # Calculate date range
         end_date = datetime.now()
-        if timeframe == "1d":
-            start_date = end_date - timedelta(days=365)  # 1 year of daily data
-        elif timeframe == "1h":
-            start_date = end_date - timedelta(days=30)   # 30 days of hourly data
-        else:  # 15m
-            start_date = end_date - timedelta(days=7)    # 7 days of 15-min data
+        start_date = end_date - timedelta(days=lookback_days)
         
         # Fetch data using yfinance
         ticker = yf.Ticker(symbol)
         df = ticker.history(start=start_date, end=end_date, interval=interval)
         
-        # Calculate returns
-        df['returns'] = df['Close'].pct_change()
+        # Calculate technical indicators
+        df['SMA_20'] = df['Close'].rolling(window=20).mean()
+        df['SMA_50'] = df['Close'].rolling(window=50).mean()
+        df['RSI'] = calculate_rsi(df['Close'])
+        df['MACD'], df['MACD_Signal'] = calculate_macd(df['Close'])
+        df['BB_Upper'], df['BB_Middle'], df['BB_Lower'] = calculate_bollinger_bands(df['Close'])
+        
+        # Calculate returns and volatility
+        df['Returns'] = df['Close'].pct_change()
+        df['Volatility'] = df['Returns'].rolling(window=20).std()
         
         # Drop NaN values
         df = df.dropna()
         
-        # Normalize the data
-        returns = df['returns'].values
-        normalized_returns = (returns - returns.mean()) / returns.std()
-        
-        # Convert to the format expected by Chronos
-        return normalized_returns.reshape(-1, 1)
+        return df
         
     except Exception as e:
         raise Exception(f"Error fetching historical data for {symbol}: {str(e)}")
 
-@spaces.GPU
-def make_prediction(symbol: str, timeframe: str = "1d", prediction_days: int = 5):
+def calculate_rsi(prices: pd.Series, period: int = 14) -> pd.Series:
+    """Calculate Relative Strength Index"""
+    delta = prices.diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+    rs = gain / loss
+    return 100 - (100 / (1 + rs))
+
+def calculate_macd(prices: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> Tuple[pd.Series, pd.Series]:
+    """Calculate MACD and Signal line"""
+    exp1 = prices.ewm(span=fast, adjust=False).mean()
+    exp2 = prices.ewm(span=slow, adjust=False).mean()
+    macd = exp1 - exp2
+    signal_line = macd.ewm(span=signal, adjust=False).mean()
+    return macd, signal_line
+
+def calculate_bollinger_bands(prices: pd.Series, period: int = 20, std_dev: int = 2) -> Tuple[pd.Series, pd.Series, pd.Series]:
+    """Calculate Bollinger Bands"""
+    middle_band = prices.rolling(window=period).mean()
+    std = prices.rolling(window=period).std()
+    upper_band = middle_band + (std * std_dev)
+    lower_band = middle_band - (std * std_dev)
+    return upper_band, middle_band, lower_band
+
+def make_prediction(symbol: str, timeframe: str = "1d", prediction_days: int = 5, strategy: str = "chronos") -> Dict:
     """
-    Make prediction using Chronos model.
+    Make prediction using selected strategy.
     
     Args:
         symbol (str): Stock symbol
         timeframe (str): Data timeframe
         prediction_days (int): Number of days to predict
+        strategy (str): Prediction strategy to use
     
     Returns:
         dict: Prediction results and visualization
     """
     try:
-        # Load pipeline
-        pipe = load_pipeline()
-        
         # Get historical data
-        historical_data = get_historical_data(symbol, timeframe)
-        
-        # Convert to tensor and move to GPU
-        context = torch.tensor(historical_data, dtype=torch.float32).to(pipe.model.device)
-        
-        # Make prediction
-        with torch.inference_mode():
-            prediction = pipe.predict(
-                context=context,
-                prediction_length=prediction_days,
-                num_samples=100
-            ).detach().cpu().numpy()
+        df = get_historical_data(symbol, timeframe)
         
-        # Get actual historical prices for plotting
-        ticker = yf.Ticker(symbol)
-        hist_data = ticker.history(period="1mo")
+        if strategy == "chronos":
+            # Prepare data for Chronos
+            returns = df['Returns'].values
+            normalized_returns = (returns - returns.mean()) / returns.std()
+            context = torch.tensor(normalized_returns.reshape(-1, 1), dtype=torch.float32)
+            
+            # Make prediction
+            pipe = load_pipeline()
+            with torch.inference_mode():
+                prediction = pipe.predict(
+                    context=context,
+                    prediction_length=prediction_days
+                ).detach().cpu().numpy()
+            
+            # Reshape prediction to get mean and std
+            mean_pred = prediction.mean(axis=0)
+            std_pred = prediction.std(axis=0)
+            
+        elif strategy == "technical":
+            # Technical analysis based prediction
+            last_price = df['Close'].iloc[-1]
+            rsi = df['RSI'].iloc[-1]
+            macd = df['MACD'].iloc[-1]
+            macd_signal = df['MACD_Signal'].iloc[-1]
+            
+            # Simple prediction based on technical indicators
+            trend = 1 if (rsi > 50 and macd > macd_signal) else -1
+            volatility = df['Volatility'].iloc[-1]
+            
+            # Generate predictions
+            mean_pred = np.array([last_price * (1 + trend * volatility * i) for i in range(1, prediction_days + 1)])
+            std_pred = np.array([volatility * last_price * i for i in range(1, prediction_days + 1)])
         
         # Create prediction dates
-        last_date = hist_data.index[-1]
+        last_date = df.index[-1]
         pred_dates = pd.date_range(start=last_date + timedelta(days=1), periods=prediction_days)
         
-        # Calculate prediction statistics
-        mean_pred = prediction.mean(axis=0)
-        std_pred = prediction.std(axis=0)
-        
         # Create visualization
-        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
-                           vertical_spacing=0.03, subplot_titles=('Price Prediction', 'Confidence Interval'))
+        fig = make_subplots(rows=3, cols=1, 
+                           shared_xaxes=True,
+                           vertical_spacing=0.05,
+                           subplot_titles=('Price Prediction', 'Technical Indicators', 'Volume'))
         
-        # Add historical data
+        # Add historical price
         fig.add_trace(
-            go.Scatter(x=hist_data.index, y=hist_data['Close'], name='Historical Price',
+            go.Scatter(x=df.index, y=df['Close'], name='Historical Price',
                       line=dict(color='blue')),
             row=1, col=1
         )
@@ -149,38 +189,81 @@ def make_prediction(symbol: str, timeframe: str = "1d", prediction_days: int = 5
             row=1, col=1
         )
         
-        # Add confidence interval plot
+        # Add technical indicators
         fig.add_trace(
-            go.Scatter(x=pred_dates, y=std_pred, name='Prediction Uncertainty',
+            go.Scatter(x=df.index, y=df['RSI'], name='RSI',
+                      line=dict(color='purple')),
+            row=2, col=1
+        )
+        fig.add_trace(
+            go.Scatter(x=df.index, y=df['MACD'], name='MACD',
+                      line=dict(color='orange')),
+            row=2, col=1
+        )
+        fig.add_trace(
+            go.Scatter(x=df.index, y=df['MACD_Signal'], name='MACD Signal',
                       line=dict(color='green')),
             row=2, col=1
         )
         
+        # Add volume
+        fig.add_trace(
+            go.Bar(x=df.index, y=df['Volume'], name='Volume',
+                  marker_color='gray'),
+            row=3, col=1
+        )
+        
         # Update layout
         fig.update_layout(
-            title=f'{symbol} Price Prediction',
+            title=f'{symbol} Analysis and Prediction',
             xaxis_title='Date',
             yaxis_title='Price',
-            height=800,
+            height=1000,
             showlegend=True
         )
         
+        # Calculate trading signals
+        signals = calculate_trading_signals(df)
+        
         return {
             "symbol": symbol,
             "prediction": mean_pred.tolist(),
             "confidence": std_pred.tolist(),
             "dates": pred_dates.strftime('%Y-%m-%d').tolist(),
-            "plot": fig
+            "plot": fig,
+            "signals": signals
         }
         
     except Exception as e:
         raise Exception(f"Prediction error: {str(e)}")
 
-# Create Gradio interface
+def calculate_trading_signals(df: pd.DataFrame) -> Dict:
+    """Calculate trading signals based on technical indicators"""
+    signals = {
+        "RSI": "Oversold" if df['RSI'].iloc[-1] < 30 else "Overbought" if df['RSI'].iloc[-1] > 70 else "Neutral",
+        "MACD": "Buy" if df['MACD'].iloc[-1] > df['MACD_Signal'].iloc[-1] else "Sell",
+        "Bollinger": "Buy" if df['Close'].iloc[-1] < df['BB_Lower'].iloc[-1] else "Sell" if df['Close'].iloc[-1] > df['BB_Upper'].iloc[-1] else "Hold",
+        "SMA": "Buy" if df['SMA_20'].iloc[-1] > df['SMA_50'].iloc[-1] else "Sell"
+    }
+    
+    # Calculate overall signal
+    buy_signals = sum(1 for signal in signals.values() if signal == "Buy")
+    sell_signals = sum(1 for signal in signals.values() if signal == "Sell")
+    
+    if buy_signals > sell_signals:
+        signals["Overall"] = "Buy"
+    elif sell_signals > buy_signals:
+        signals["Overall"] = "Sell"
+    else:
+        signals["Overall"] = "Hold"
+    
+    return signals
+
 def create_interface():
-    with gr.Blocks(title="Stock Price Prediction with Amazon Chronos") as demo:
-        gr.Markdown("# Stock Price Prediction with Amazon Chronos")
-        gr.Markdown("Enter a stock symbol and select prediction parameters to get price forecasts.")
+    """Create the Gradio interface"""
+    with gr.Blocks(title="Stock Analysis and Prediction") as demo:
+        gr.Markdown("# Stock Analysis and Prediction")
+        gr.Markdown("Enter a stock symbol and select parameters to get price forecasts and trading signals.")
         
         with gr.Row():
             with gr.Column():
@@ -197,16 +280,21 @@ def create_interface():
                     step=1,
                     label="Days to Predict"
                 )
-                predict_btn = gr.Button("Make Prediction")
+                strategy = gr.Dropdown(
+                    choices=["chronos", "technical"],
+                    label="Prediction Strategy",
+                    value="chronos"
+                )
+                predict_btn = gr.Button("Analyze Stock")
             
             with gr.Column():
-                plot = gr.Plot(label="Prediction Visualization")
-                results = gr.JSON(label="Prediction Results")
+                plot = gr.Plot(label="Analysis and Prediction")
+                signals = gr.JSON(label="Trading Signals")
         
         predict_btn.click(
             fn=make_prediction,
-            inputs=[symbol, timeframe, prediction_days],
-            outputs=[results, plot]
+            inputs=[symbol, timeframe, prediction_days, strategy],
+            outputs=[signals, plot]
         )
     
     return demo

requirements.txt

@@ -67,7 +67,7 @@ certifi
 patsy
 regex
 cachetools>=5.3.0
-python-dateutil
+python-dateutil>=2.8.2
 cmaes
 alembic
 colorlog
@@ -104,7 +104,7 @@ gunicorn
 uvicorn
 # git+https://github.com/amazon-science/chronos-forecasting.git
 chronos-forecasting
-scikit-learn
+scikit-learn>=1.0.0
 
 python-binance
 typer
@@ -116,4 +116,5 @@ numpy>=1.24.0
 torch>=2.0.0
 yfinance>=0.2.0
 plotly>=5.0.0
-chronos>=0.1.0
+chronos>=0.1.0
+chronos-pytorch>=0.1.0