Initial commit: Stock prediction application with Chronos integration

.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+*.log
+.env
+.env.local 

README.md

@@ -13,223 +13,66 @@ tags:
   - mcp-server-track
 ---
 
-# Stock Analysis and Prediction Demo
+# Stock Predictions with Chronos
 
-A comprehensive stock analysis and prediction tool built with Gradio, featuring multiple prediction strategies and technical analysis indicators. The application is particularly suited for structured financial product creation and analysis.
+A powerful stock prediction application that uses the Chronos model and technical analysis to predict stock prices across different timeframes.
 
 ## Features
 
-- **Multiple Prediction Strategies**:
-  - Chronos ML-based prediction
-  - Technical analysis-based prediction
-
-- **Technical Indicators**:
-  - RSI (Relative Strength Index)
-  - MACD (Moving Average Convergence Divergence)
-  - Bollinger Bands
-  - Simple Moving Averages (20, 50, and 200-day)
-
-- **Trading Signals**:
-  - Buy/Sell recommendations based on multiple indicators
-  - Overall trading signal combining all indicators
-  - Confidence intervals for predictions
-
-- **Interactive Visualizations**:
-  - Price prediction with confidence intervals
-  - Technical indicators overlay
-  - Volume analysis
-  - Historical price trends
-
-- **Structured Product Analysis**:
-  - Extended prediction horizons (up to 1 year)
-  - Historical analysis up to 10 years
-  - Comprehensive risk metrics
-  - Sector and industry analysis
-  - Liquidity assessment
-
-## Structured Product Features
-
-### Extended Time Horizons
-- Prediction window up to 365 days
-- Historical data analysis up to 10 years
-- Long-term trend analysis
-- Extended technical indicators
-
-### Risk Analysis
-- Annualized volatility
-- Maximum drawdown analysis
-- Current drawdown tracking
-- Sharpe and Sortino ratios
-- Risk-adjusted return metrics
-
-### Product Metrics
-- Market capitalization
-- Sector and industry classification
-- Dividend yield analysis
-- Volume metrics
-- Liquidity scoring
-
-### Sector Analysis
-- Market cap ranking (Large/Mid/Small)
-- Sector exposure
-- Industry classification
-- Liquidity assessment
+- Multiple timeframe analysis (Daily, Hourly, 15-minute)
+- Integration with Chronos AI model for predictions
+- Technical analysis with multiple indicators
+- Real-time market data using Yahoo Finance
+- Beautiful interactive visualizations using Plotly
+- Risk analysis and sector metrics
+- Trading signals generation
+
+## Requirements
+
+- Python 3.8+
+- PyTorch
+- Gradio
+- yfinance
+- pandas
+- numpy
+- plotly
+- scikit-learn
 
 ## Installation
 
 1. Clone the repository:
 ```bash
-git clone <repository-url>
-cd stock-prediction
+git clone https://github.com/yourusername/stock-predictions.git
+cd stock-predictions
 ```
 
-2. Create and activate a virtual environment:
-```bash
-python -m venv .venv
-source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-```
-
-3. Install dependencies:
+2. Install the required packages:
 ```bash
 pip install -r requirements.txt
 ```
 
 ## Usage
 
-1. Start the Gradio demo:
+Run the application:
 ```bash
 python app.py
 ```
 
-2. Open your web browser and navigate to the URL shown in the terminal (typically http://localhost:7860)
-
-3. Enter a stock symbol (e.g., AAPL, GOOGL, MSFT) and select your desired parameters:
-   - Timeframe (1d, 1h, 15m)
-   - Number of days to predict (up to 365 days)
-   - Historical lookback period (up to 10 years)
-   - Prediction strategy (Chronos or Technical)
-
-4. Click "Analyze Stock" to get:
-   - Price predictions and trading signals
-   - Structured product metrics
-   - Risk analysis
-   - Sector analysis
-
-## Using for Structured Products
-
-### Initial Screening
-1. Use extended lookback period (up to 10 years) for long-term performance analysis
-2. Look for stocks with stable volatility and good risk-adjusted returns
-3. Check liquidity scores for trading feasibility
-
-### Risk Assessment
-1. Review risk metrics to match client risk profile
-2. Analyze maximum drawdowns for worst-case scenarios
-3. Compare risk-adjusted returns using Sharpe and Sortino ratios
-
-### Product Structuring
-1. Use prediction horizon (up to 1 year) for product maturity design
-2. Consider dividend yields for income-generating products
-3. Use sector analysis for proper diversification
+The application will start and provide a local URL (usually http://127.0.0.1:7860) where you can access the interface.
 
-### Portfolio Construction
-1. Analyze multiple stocks for diversified bundles
-2. Use sector metrics to avoid overexposure
-3. Consider market cap rankings for appropriate sizing
-
-## 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
+## Features
 
-## Trading Signals
+- **Daily Analysis**: Long-term predictions and analysis
+- **Hourly Analysis**: Medium-term predictions with 30-day lookback
+- **15-Minute Analysis**: Short-term predictions with 5-day lookback
+- **Technical Indicators**: RSI, MACD, Bollinger Bands, SMAs
+- **Risk Metrics**: Volatility, Drawdown, Sharpe Ratio
+- **Sector Analysis**: Market cap, industry classification, liquidity metrics
 
-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)
+## License
 
-An overall trading signal is calculated by combining all individual signals.
+MIT License
 
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-## Practical Example: Creating a 6-Month 8% Yield Structured Product
-
-### Scenario
-A bank needs to create a structured product that offers an 8% yield over 6 months while maintaining profitability for the institution.
-
-### Step-by-Step Implementation
-
-1. **Initial Stock Screening**
-   - Use the application to analyze stocks with:
-     - High liquidity (for easy hedging)
-     - Stable volatility (for predictable risk)
-     - Strong technical indicators
-     - Positive long-term trends
-   - Recommended stocks: AAPL, MSFT, GOOGL (high liquidity, stable volatility)
-
-2. **Product Structure Design**
-   - Use the 6-month prediction horizon
-   - Analyze historical volatility for barrier setting
-   - Set participation rate based on risk metrics
-   - Structure: Reverse Convertible with 8% coupon
-
-3. **Risk Analysis**
-   - Use the application's risk metrics:
-     - Check maximum drawdown (should be < 15% for 6 months)
-     - Verify liquidity scores (should be > 80%)
-     - Analyze Sharpe ratio (should be > 1.5)
-
-4. **Business Case Example**
-
-   **Product Parameters:**
-   - Notional Amount: $1,000,000
-   - Term: 6 months
-   - Coupon: 8% p.a. (4% for 6 months)
-   - Underlying: AAPL
-   - Barrier: 85% of initial price
-   - Participation: 100%
-
-   **Revenue Structure:**
-   - Client receives: 8% p.a. (4% for 6 months)
-   - Bank's hedging cost: ~5% p.a.
-   - Bank's profit margin: ~3% p.a.
-   - Total client payout: $40,000 (4% of $1M)
-   - Bank's profit: $15,000 (1.5% of $1M)
-
-5. **Implementation Steps**
-   - Use the application's extended prediction horizon (180 days)
-   - Set technical indicators to monitor barrier risk
-   - Implement dynamic delta hedging based on predictions
-   - Monitor risk metrics daily using the application
-
-6. **Risk Management**
-   - Use the application's volatility predictions for dynamic hedging
-   - Monitor technical indicators for early warning signals
-   - Set up automated alerts for barrier proximity
-   - Regular rebalancing based on prediction updates
-
-### Key Success Factors
-- Regular monitoring of prediction accuracy
-- Dynamic adjustment of hedging strategy
-- Clear communication of product risks to clients
-- Proper documentation of all assumptions and methodologies
-
-This example demonstrates how the application can be used to create profitable structured products while managing risk effectively. The bank can use this framework to create similar products with different underlying assets, terms, and yield targets.

app.py

@@ -137,16 +137,17 @@ def get_historical_data(symbol: str, timeframe: str = "1d", lookback_days: int =
             sma_window_200 = 200 * 24  # ~40 trading days
             vol_window = 20 * 24
         
-        df['SMA_20'] = df['Close'].rolling(window=sma_window_20).mean()
-        df['SMA_50'] = df['Close'].rolling(window=sma_window_50).mean()
-        df['SMA_200'] = df['Close'].rolling(window=sma_window_200).mean()
+        # Calculate technical indicators
+        df['SMA_20'] = df['Close'].rolling(window=sma_window_20, min_periods=1).mean()
+        df['SMA_50'] = df['Close'].rolling(window=sma_window_50, min_periods=1).mean()
+        df['SMA_200'] = df['Close'].rolling(window=sma_window_200, min_periods=1).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=vol_window).std()
+        df['Volatility'] = df['Returns'].rolling(window=vol_window, min_periods=1).std()
         df['Annualized_Vol'] = df['Volatility'] * np.sqrt(252)
         
         # Calculate drawdown metrics
@@ -155,11 +156,21 @@ def get_historical_data(symbol: str, timeframe: str = "1d", lookback_days: int =
         df['Max_Drawdown'] = df['Drawdown'].rolling(window=len(df), min_periods=1).min()
         
         # Calculate liquidity metrics
-        df['Avg_Daily_Volume'] = df['Volume'].rolling(window=vol_window).mean()
-        df['Volume_Volatility'] = df['Volume'].rolling(window=vol_window).std()
-        
-        # Drop NaN values
-        df = df.dropna()
+        df['Avg_Daily_Volume'] = df['Volume'].rolling(window=vol_window, min_periods=1).mean()
+        df['Volume_Volatility'] = df['Volume'].rolling(window=vol_window, min_periods=1).std()
+        
+        # Fill NaN values with forward fill, then backward fill
+        df = df.fillna(method='ffill').fillna(method='bfill')
+        
+        # Ensure we have enough data points
+        min_required_points = 64  # Minimum required for Chronos
+        if len(df) < min_required_points:
+            # Try to fetch more historical data
+            extended_start_date = start_date - timedelta(days=min_required_points - len(df))
+            extended_df = ticker.history(start=extended_start_date, end=start_date, interval=interval)
+            if not extended_df.empty:
+                df = pd.concat([extended_df, df])
+                df = df.fillna(method='ffill').fillna(method='bfill')
         
         if len(df) < 2:
             raise Exception(f"Insufficient data points for {symbol} in {timeframe} timeframe")
@@ -217,14 +228,18 @@ def make_prediction(symbol: str, timeframe: str = "1d", prediction_days: int = 5
                 returns = df['Returns'].values
                 normalized_returns = (returns - returns.mean()) / returns.std()
                 
-                # Ensure we have enough data points
+                # Ensure we have enough data points and pad if necessary
                 min_data_points = 64  # Minimum required by Chronos
                 if len(normalized_returns) < min_data_points:
                     # Pad the data with the last value
                     padding = np.full(min_data_points - len(normalized_returns), normalized_returns[-1])
                     normalized_returns = np.concatenate([padding, normalized_returns])
+                elif len(normalized_returns) > min_data_points:
+                    # Take the most recent data points
+                    normalized_returns = normalized_returns[-min_data_points:]
                 
-                context = torch.tensor(normalized_returns.reshape(-1, 1), dtype=torch.float32)
+                # Reshape for Chronos (batch_size=1, sequence_length, features=1)
+                context = torch.tensor(normalized_returns.reshape(1, -1, 1), dtype=torch.float32)
                 
                 # Make prediction with GPU acceleration
                 pipe = load_pipeline()

src/app.py

@@ -0,0 +1,117 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import yfinance as yf
+import pandas as pd
+from datetime import datetime, timedelta
+import logging
+from typing import Optional
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+def fetch_stock_data(symbol: str, period: str = "1y") -> pd.DataFrame:
+    """
+    Fetch historical stock data for a given symbol using yfinance with authentication.
+    
+    Args:
+        symbol (str): Stock symbol (e.g., 'AAPL')
+        period (str): Time period to fetch (default: '1y')
+        
+    Returns:
+        pd.DataFrame: DataFrame containing historical stock data
+    """
+    try:
+        # Create a Ticker object with authentication
+        ticker = yf.Ticker(symbol)
+        
+        # Set authentication credentials
+        ticker._session.headers.update({
+            'User-Agent': 'Mozilla/5.0',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        })
+        
+        # Fetch historical data
+        df = ticker.history(period=period)
+        
+        if df.empty:
+            logger.warning(f"No data found for symbol {symbol}")
+            return pd.DataFrame()
+            
+        # Reset index to make Date a column
+        df = df.reset_index()
+        
+        # Rename columns to match expected format
+        df = df.rename(columns={
+            'Date': 'date',
+            'Open': 'open',
+            'High': 'high',
+            'Low': 'low',
+            'Close': 'close',
+            'Volume': 'volume'
+        })
+        
+        # Convert date to string format
+        df['date'] = df['date'].dt.strftime('%Y-%m-%d')
+        
+        logger.info(f"Successfully fetched data for {symbol}")
+        return df
+        
+    except Exception as e:
+        logger.error(f"Error fetching data for {symbol}: {str(e)}")
+        return pd.DataFrame()
+
+@app.get("/")
+async def root():
+    return {"message": "Stock Prediction API"}
+
+@app.get("/api/stock/{symbol}")
+async def get_stock_data(symbol: str, period: Optional[str] = "1y"):
+    """
+    Get historical stock data for a given symbol.
+    
+    Args:
+        symbol (str): Stock symbol (e.g., 'AAPL')
+        period (str, optional): Time period to fetch. Defaults to "1y".
+            Valid periods: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max
+    
+    Returns:
+        dict: Dictionary containing stock data and metadata
+    """
+    try:
+        df = fetch_stock_data(symbol, period)
+        
+        if df.empty:
+            raise HTTPException(status_code=404, detail=f"No data found for symbol {symbol}")
+        
+        # Convert DataFrame to dictionary format
+        data = df.to_dict(orient='records')
+        
+        return {
+            "symbol": symbol,
+            "period": period,
+            "data": data,
+            "count": len(data)
+        }
+        
+    except Exception as e:
+        logger.error(f"Error processing request for {symbol}: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

src/data/stock_data.py

@@ -0,0 +1,62 @@
+import yfinance as yf
+import pandas as pd
+from datetime import datetime, timedelta
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def fetch_stock_data(symbol: str, period: str = "1y") -> pd.DataFrame:
+    """
+    Fetch historical stock data for a given symbol using yfinance with authentication.
+    
+    Args:
+        symbol (str): Stock symbol (e.g., 'AAPL')
+        period (str): Time period to fetch (default: '1y')
+        
+    Returns:
+        pd.DataFrame: DataFrame containing historical stock data
+    """
+    try:
+        # Create a Ticker object with authentication
+        ticker = yf.Ticker(symbol)
+        
+        # Set authentication credentials
+        ticker._session.headers.update({
+            'User-Agent': 'Mozilla/5.0',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        })
+        
+        # Fetch historical data
+        df = ticker.history(period=period)
+        
+        if df.empty:
+            logger.warning(f"No data found for symbol {symbol}")
+            return pd.DataFrame()
+            
+        # Reset index to make Date a column
+        df = df.reset_index()
+        
+        # Rename columns to match expected format
+        df = df.rename(columns={
+            'Date': 'date',
+            'Open': 'open',
+            'High': 'high',
+            'Low': 'low',
+            'Close': 'close',
+            'Volume': 'volume'
+        })
+        
+        # Convert date to string format
+        df['date'] = df['date'].dt.strftime('%Y-%m-%d')
+        
+        logger.info(f"Successfully fetched data for {symbol}")
+        return df
+        
+    except Exception as e:
+        logger.error(f"Error fetching data for {symbol}: {str(e)}")
+        return pd.DataFrame()