Lion

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# VSCode
+.vscode/
+
+# PyCharm
+.idea/
+
+# OS specific
+.DS_Store
+Thumbs.db 

Description.md

@@ -0,0 +1,330 @@
+**STAT 4830 Frontend Technical Description**  
+---
+
+Dhruv Gupta, Kelly Wang, Didrik Wiig-Andersen, Aiden Lee, Frank Ma  
+STAT 4830, Project PRISM 							      	        		   
+
+**Project Proposal**
+
+As part of our class, we have created an online gradient ascent based model for portfolio allocation and optimization. We want to make an interactive frontend for the project that allows users to simulate and test performance on several different year ranges, hyperparameter combinations, and stock market universes.
+
+They should receive quick and immediate feedback, as well as comparisons with several different benchmarks in terms of both cumulative returns and annualized sharpe ratio.
+
+We should try and include as many relevant and valid graphs as possible to make the website visually appealing.
+
+**Proposed Technical Stack**
+
+* **Hugging Face:** Our Python backend will be hosted in a Huggingface space, which will be in charge of actually running the model and providing back the results  
+* **React:** The frontend will be all react. The app has been created using npx create-react-app to begin with.
+
+**Backend Setup**
+
+We have cloned our Hugging Face space into our project (a blank Gradio template project). We have renamed the folder it is in to be called "backend"
+
+**Necessary Dependencies**  
+import torch  
+import pandas as pd  
+import matplotlib as mpl  
+import matplotlib.pyplot as plt  
+import matplotlib.dates as mdates  
+import yfinance as yf  
+from datetime import datetime  
+import numpy as np  
+import seaborn as sns  
+import wrds
+import random
+
+**Backend Development Steps**
+
+These steps are to be followed by Cursor Agent running Claude 3.7 Sonnet. Each step should only be completed one at a time, and after each step is completed, the readme file should be updated accordingly. Do NOT go ahead at all and do not set up extra steps in advance. We have begun by cloning our HuggingFace spcae into our project and named the folder backend (Gradio blank template).
+
+1. Set up the file directory and all necessary introductory files for the project. Ensure we have installed and are able to run any necessary dependencies.  
+   *Completed: Created `backend/requirements.txt` and `backend/app.py`.*  
+2. Store the following list of stock tickers, organized by sector, in a JSON file  
+   *Completed: Created `backend/data/tickers_by_sector.json`.*  
+
+\[  
+  {  
+    "sector": "Technology",  
+    "tickers": \["AAPL", "MSFT", "NVDA", "GOOGL", "META", "AVGO", "ORCL", "IBM", "CSCO", "TSM", "ASML", "AMD", "TXN", "INTC", "MU", "QCOM", "LRCX", "NXPI", "ADI"\]  
+  },  
+  {  
+    "sector": "Consumer Discretionary",  
+    "tickers": \["AMZN", "TSLA", "NKE", "MCD", "SBUX", "YUM", "GM", "F", "RIVN", "NIO", "TTWO", "EA", "GME", "AMC"\]  
+  },  
+  {  
+    "sector": "Financials",  
+    "tickers": \["JPM", "V", "MA", "GS", "MS", "BAC", "C", "AXP", "SCHW"\]  
+  },  
+  {  
+    "sector": "Health Care",  
+    "tickers": \["UNH", "JNJ", "LLY", "PFE", "MRNA", "BMY", "GILD", "CVS", "VRTX", "ISRG"\]  
+  },  
+  {  
+    "sector": "Consumer Staples",  
+    "tickers": \["WMT", "PG", "TGT", "KO", "PEP", "TSN", "CAG", "SYY", "HRL", "MDLZ"\]  
+  },  
+  {  
+    "sector": "Energy",  
+    "tickers": \["XOM", "CVX", "NEE", "DUK", "SO", "D", "ENB", "SLB", "EOG", "PSX"\]  
+  },  
+  {  
+    "sector": "Industrials",  
+    "tickers": \["DE", "LMT", "RTX", "BA", "CAT", "GE", "HON", "UPS", "EMR", "NOC", "FDX", "CSX", "UNP", "DAL"\]  
+  },  
+  {  
+    "sector": "Real Estate",  
+    "tickers": \["PLD", "AMT", "EQIX", "O", "SPG", "VICI", "DLR", "WY", "EQR", "PSA"\]  
+  },  
+  {  
+    "sector": "Materials",  
+    "tickers": \["ADM", "BG", "CF", "MOS", "FMC"\]  
+  },  
+  {  
+    "sector": "Communication Services",  
+    "tickers": \["NFLX", "DIS", "PARA", "WBD", "CMCSA", "SPOT", "LYV"\]  
+  }  
+\]
+
+3. We have stored the data for each of these tickers from 1-1-2007 to 4-1-2025 in a file called data/stock_data.csv and the risk free returns values for each day in data/risk_free_data.csv. Please read them in and save them as df for future reference  
+   *Completed: Loaded data into global DataFrames in `backend/app.py`.*  
+4. Create a route that, given optional inputs of start date, end date, and tickers, creates a dataframe that only contains data on the given tickers for the given timeframe  
+   *Completed: Created `filter_data` function in `backend/utils.py` and test interface in `backend/app.py`.*  
+5. Build out a route that runs our OGD on a given dataframe which takes in hyperparameters and returns both the day to day weights and day to day returns (both cumulative and by ticker)  
+   *Completed: Created `run_ogd` function in `backend/optimization.py` and integrated into Gradio interface in `backend/app.py`.*
+
+\# Objective function  
+def calculate\_sharpe(  
+        returns: torch.tensor,  
+        risk\_free\_rate: torch.tensor \= None  
+    ):  
+    if risk\_free\_rate is not None:  
+        excess\_returns \= returns \- risk\_free\_rate  
+    else:  
+        excess\_returns \= returns  
+    sharpe \= torch.mean(excess\_returns, dim=0) / torch.std(excess\_returns, dim=0)  
+    return sharpe
+
+def calculate\_sortino(  
+        returns: torch.tensor,  
+        min\_acceptable\_return: torch.tensor  
+    ):  
+    if min\_acceptable\_return is not None:  
+        excess\_returns \= returns \- min\_acceptable\_return  
+    downside\_deviation \= torch.std(  
+        torch.where(excess\_returns \< 0, excess\_returns, torch.tensor(0.0)),  
+    )  
+    sortino \= torch.mean(excess\_returns, dim=0) / (downside\_deviation \+ eps\*\*2)  
+    return sortino
+
+def calculate\_max\_drawdown(  
+        returns: torch.tensor  
+):  
+    """calculates max drawdown for the duration of the returns passed  
+    i.e. expects returns to be trimmed to the period of interest
+
+    max drawdown is defined to be positive, takes the range \[0, \\infty)  
+    """  
+    cum\_returns \= (returns \+ 1).cumprod(dim=0)  
+    return (cum\_returns.max() \- cum\_returns\[-1\]) / (cum\_returns.max() \+ eps \*\*2)
+
+def calculate\_turnover(  
+        new\_weights: torch.tensor,  
+        prev\_weights: torch.tensor  
+):  
+    """Turnover is defined to be the sum of absolute differences  
+    between the new weights and the previous weights, divided by 2\.  
+    Takes the range \[0, \\infty)
+
+    This value should be minimized  
+    """  
+    return torch.sum(torch.abs(new\_weights \- prev\_weights)) / 2
+
+def calculate\_objective\_func(  
+        returns: torch.tensor,  
+        risk\_free\_rate: torch.tensor,  
+        new\_weights,  
+        prev\_weights,  
+        alphas \= \[1,1,1\]  
+    ):  
+    return (  
+        a\[0\] \* calculate\_sortino(returns, risk\_free\_rate)   
+        \- a\[1\] \* calculate\_max\_drawdown(returns)  
+        \- a\[2\] \* calculate\_turnover(  
+            new\_weights,  
+            prev\_weights  
+        )  
+    )
+
+\# set up  
+window\_size \= 10
+
+return\_logs \= torch.zeros(  
+    size \= (returns.shape\[0\],),   
+    dtype=torch.float32  
+)  
+rolling\_return\_list \= \[\]
+
+\# returns.shape\[1\] \- 1 because we don't allow investing in   
+\# risk free asset for the moment   
+print(f"Initializing optimization...")  
+weights \= torch.rand(  
+    size \= (returns.shape\[1\] \- 1,),   
+    requires\_grad=True  
+)  
+optimizer \= torch.optim.SGD(\[weights\], lr=0.5)  
+weights\_log \= torch.zeros((returns.shape\[0\], returns.shape\[1\] \- 1))
+
+for i, date in enumerate(returns.index):  
+    if i % 5 \== 0:  
+        print(f"Step {i} of {returns.shape\[0\]}", end \= '\\r')
+
+    normalized\_weights \= torch.nn.functional.softmax(weights, dim=0)  
+    daily\_returns \= torch.tensor(  
+        returns.loc\[date\].T\[:-1\],  
+        dtype=torch.float32  
+    )  
+    ret \= torch.dot(normalized\_weights, daily\_returns)
+
+    \# for logging  
+    return\_logs\[i\] \= ret.detach()  
+    rolling\_return\_list.append(ret)
+
+    if len(rolling\_return\_list) \> window\_size:  
+        rolling\_return\_list.pop(0)  
+        past\_returns \= torch.stack(rolling\_return\_list)  
+        past\_rf \= torch.tensor(  
+            returns.iloc\[max(0, i \- window\_size):i\]\['rf'\].values,  
+            dtype=torch.float32  
+        )  
+        objective \= \-calculate\_objective\_func(  
+            past\_returns,  
+            past\_rf,  
+            normalized\_weights,  
+            weights\_log\[i \- 1\]  
+        )  
+        optimizer.zero\_grad()  
+        objective.backward(retain\_graph=True)  
+        optimizer.step()  
+      
+    weights\_log\[i\] \= normalized\_weights
+
+6. Build out a route that given a dataframe returns the day to day returns for an equal weight portfolio  
+7. Build out a route that given a dataframe returns the day to day returns for a "random portfolio" – you fully (and equally) invest in 3 randomly selected stocks on any given day  
+8. Build out a unified route that, given a set of hyperparameters, start date, and end date, creates the dataframe, runs OGD, and also runs both the benchmarks, then returns all the data
+9. Bundle it all into a well structured API
+
+**Frontend Development Steps**
+
+1. Create a file directory with images, components, data and pages. Create a global API variable that is set and can be edited for where the server is hosted  
+2. Develop a header and footer for the project  
+3. Create the layout for a dashboard that will take up exactly 100vh  
+   1. On the right 1/4th we should have a list of our 111 stock tickers, grouped by sector. There should be a way to select our stock tickers in batches (i.e. toggle all, toggle by sector, etc) or individually  
+4. On the left hand side Top 2/3, we should have 2 graphs; cumulative returns and weight evolution. These graphs must be highly reflexive, running across the run's time and necessary tickers, etc  
+   2. On the top of the left hand side above the stock tickers, we should have a horizontal menu to set our 4 variables  
+   3. There should also be a smart and relevant place to run "Allocate Portfolio"  
+5. On the bottom 1/3rd of the left, we should have 3 graphs in a row that provide more specific statistics. I will leave it up to you to decide what these graphs should show
+
+**Frontend Considerations**
+
+1. We want the frontend to be as clean and modern as possible, considering our target audience is 16-24 year olds. Take heavy inspiration from the UI of Notion. Have it be by default in a "dark mode"  
+2. We want the frontend to feel responsive and provide micro or fake feedback while we're waiting for the OGD as it may take quite long. Maybe run some fake simulations through geometric brownian motions while we're waiting
+
+# Small epsilon for Sharpe calculation
+eps = 1e-8
+ANNUAL_TRADING_DAYS = 252
+
+def run_equal_weight(data_df: pd.DataFrame) -> pd.Series:
+    """Calculates daily returns for a static equal-weight portfolio.
+
+    Args:
+        data_df (pd.DataFrame): DataFrame with dates as index, ticker returns,
+                                and an 'rf' column.
+
+    Returns:
+        pd.Series: Daily returns of the equal-weight portfolio.
+    """
+    stock_returns = data_df.drop(columns=['rf'], errors='ignore')
+    if stock_returns.empty:
+        return pd.Series(dtype=float, name="EqualWeightReturn")
+    # Calculate the mean return across all stocks for each day
+    daily_returns = stock_returns.mean(axis=1)
+    return daily_returns.rename("EqualWeightReturn")
+
+def run_random_portfolio(
+        data_df: pd.DataFrame,
+        num_stocks: int = 3,
+        rebalance_days: int = 20
+    ) -> pd.Series:
+    """Calculates daily returns for a randomly selected portfolio,
+       rebalanced periodically.
+
+    Args:
+        data_df (pd.DataFrame): DataFrame with dates as index, ticker returns,
+                                and an 'rf' column.
+        num_stocks (int): Number of stocks to randomly select.
+        rebalance_days (int): How often to re-select stocks.
+
+    Returns:
+        pd.Series: Daily returns of the random portfolio.
+    """
+    stock_returns = data_df.drop(columns=['rf'], errors='ignore')
+    if stock_returns.empty or stock_returns.shape[1] < num_stocks:
+        print("Warning: Not enough stocks available for random portfolio.")
+        return pd.Series(dtype=float, name="RandomPortfolioReturn")
+
+    tickers = stock_returns.columns.tolist()
+    portfolio_returns = pd.Series(index=data_df.index, dtype=float)
+    selected_tickers = []
+
+    for i, date in enumerate(data_df.index):
+        # Rebalance check
+        if i % rebalance_days == 0 or not selected_tickers:
+            if len(tickers) >= num_stocks:
+                 selected_tickers = random.sample(tickers, num_stocks)
+            else: # Should not happen based on initial check, but safe
+                 selected_tickers = tickers
+            # print(f"Rebalancing Random Portfolio on {date.date()}: {selected_tickers}")
+
+        # Calculate return for the day using selected tickers
+        daily_returns = stock_returns.loc[date, selected_tickers]
+        portfolio_returns[date] = daily_returns.mean() # Equal weight among selected
+
+    return portfolio_returns.rename("RandomPortfolioReturn")
+
+# --- Performance Metrics --- 
+
+def calculate_cumulative_returns(returns_series: pd.Series) -> pd.Series:
+    """Calculates cumulative returns from a daily returns series."""
+    return (1 + returns_series.fillna(0)).cumprod()
+
+def calculate_performance_metrics(returns_series: pd.Series, rf_series: pd.Series) -> dict:
+    """Calculates annualized Sharpe Ratio and Max Drawdown."""
+    if returns_series.empty or returns_series.isnull().all():
+        return {"Annualized Sharpe Ratio": 0.0, "Max Drawdown": 0.0, "Cumulative Return": 1.0}
+    
+    cumulative_return = (1 + returns_series.fillna(0)).cumprod().iloc[-1]
+    
+    # Align risk-free rate series to the returns series index
+    aligned_rf = rf_series.reindex(returns_series.index).fillna(0)
+    
+    # Calculate Excess Returns
+    excess_returns = returns_series - aligned_rf
+    
+    # Annualized Sharpe Ratio
+    # Use np.sqrt(ANNUAL_TRADING_DAYS) for annualization factor
+    mean_excess_return = excess_returns.mean()
+    std_dev_excess_return = excess_returns.std()
+    sharpe_ratio = (mean_excess_return / (std_dev_excess_return + eps)) * np.sqrt(ANNUAL_TRADING_DAYS)
+    
+    # Max Drawdown
+    cumulative = calculate_cumulative_returns(returns_series)
+    peak = cumulative.expanding(min_periods=1).max()
+    drawdown = (cumulative - peak) / (peak + eps) # Drawdown is negative or zero
+    max_drawdown = abs(drawdown.min()) # Max drawdown is positive
+    
+    return {
+        "Annualized Sharpe Ratio": round(sharpe_ratio, 4),
+        "Max Drawdown": round(max_drawdown, 4),
+        "Cumulative Return": round(cumulative_return, 4)
+    }

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . /app/
+
+# Make sure assets directory exists
+RUN mkdir -p /app/assets/static
+
+# Expose port
+EXPOSE 8000
+
+# Command to run the application
+CMD ["python", "app.py"] 

README.md

@@ -1,10 +1,46 @@
 ---
-title: Opt
-emoji: 📉
-colorFrom: purple
+title: Portfolio Optimization with OGD
+emoji: 📈
+colorFrom: indigo
 colorTo: gray
 sdk: docker
-pinned: false
+app_port: 8000
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Portfolio Optimization with OGD
+
+An interactive portfolio optimization tool using Online Gradient Descent (OGD) to find optimal stock weights. 
+
+## Features
+
+- **Modern UI**: Sleek dark-themed interface inspired by Notion
+- **Interactive Charts**: Visualize cumulative returns and weight evolution
+- **Stock Selection**: Choose from 100+ stocks grouped by sector
+- **Performance Metrics**: Compare OGD with equal-weight and random portfolios
+- **Responsive Design**: Works on desktop and mobile devices
+
+## How to Use
+
+1. Select your desired date range and optimization parameters
+2. Choose stocks from the sector lists on the right
+3. Click "Run Allocation" to run the optimization
+4. View results in the interactive charts and metrics panels
+
+## Technical Details
+
+This application combines:
+- A FastAPI backend for API endpoints and serving static files
+- A custom HTML/CSS/JS frontend for a modern UI experience
+- A Gradio interface (accessible at `/gradio`) for simplified usage
+
+## Running Locally
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+```
+
+The application will be available at http://localhost:8000

app.py

@@ -0,0 +1,323 @@
+import gradio as gr
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use('Agg')  # Use Agg backend for non-interactive plotting
+import json
+import os
+from fastapi import FastAPI, Request, Response, Body
+from fastapi.responses import JSONResponse, HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from pathlib import Path
+import numpy as np
+import datetime
+
+from utils import load_data, filter_data
+from optimization import run_ogd
+# Import benchmark functions and metrics
+from benchmarks import (
+    run_equal_weight,
+    run_random_portfolio,
+    calculate_cumulative_returns,
+    calculate_performance_metrics
+)
+
+# --- Load Data Globally ---
+stock_data_df, rf_data_df = load_data()
+
+if stock_data_df is None or rf_data_df is None:
+    print("Exiting application due to data loading error.")
+    exit()
+
+# --- Create FastAPI app ---
+app = FastAPI()
+
+# --- Setup Static Files ---
+static_dir = Path(__file__).parent / "assets" / "static"
+if not static_dir.exists():
+    static_dir.mkdir(parents=True, exist_ok=True)
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+# --- Main Optimization Pipeline Function ---
+def run_optimization_pipeline(
+    start_date, end_date, tickers_str,
+    window_size, learning_rate,
+    alpha_sortino, alpha_max_drawdown, alpha_turnover
+):
+    """Runs the full pipeline: filter data -> run OGD & benchmarks -> calculate metrics & plots -> return results."""
+    if not tickers_str:
+        tickers = None
+    else:
+        tickers = [t.strip().upper() for t in tickers_str.split(',')]
+    try:
+        window_size = int(window_size)
+        learning_rate = float(learning_rate)
+        alphas = [float(alpha_sortino), float(alpha_max_drawdown), float(alpha_turnover)]
+    except ValueError as e:
+        return {"error": f"Invalid hyperparameter input. Details: {e}"}
+
+    print(f"Filtering data: Start={start_date}, End={end_date}, Tickers={tickers}")
+    # 2. Filter Data
+    filtered_df = filter_data(stock_data_df, rf_data_df, start_date, end_date, tickers)
+
+    if filtered_df is None or filtered_df.empty:
+        return {"error": "Filtering resulted in empty data. Cannot run."}
+    
+    # Extract risk-free series for metric calculation
+    rf_series = filtered_df['rf']
+
+    print(f"Running OGD: Window={window_size}, LR={learning_rate}, Alphas={alphas}")
+    # 3. Run OGD
+    ogd_weights_df, ogd_returns_series = run_ogd(
+        filtered_df, window_size=window_size, learning_rate=learning_rate, alphas=alphas
+    )
+    if ogd_weights_df.empty or ogd_returns_series.empty:
+         return {"error": "OGD failed or returned empty results."}
+
+    print("Running Benchmarks...")
+    # 4. Run Benchmarks
+    equal_weight_returns = run_equal_weight(filtered_df)
+    random_portfolio_returns = run_random_portfolio(filtered_df)
+
+    # 5. Calculate Metrics & Cumulative Returns
+    ogd_metrics = calculate_performance_metrics(ogd_returns_series, rf_series)
+    ew_metrics = calculate_performance_metrics(equal_weight_returns, rf_series)
+    rp_metrics = calculate_performance_metrics(random_portfolio_returns, rf_series)
+
+    # Calculate cumulative returns for charts
+    ogd_cumulative = calculate_cumulative_returns(ogd_returns_series)
+    ew_cumulative = calculate_cumulative_returns(equal_weight_returns)
+    rp_cumulative = calculate_cumulative_returns(random_portfolio_returns)
+
+    # Convert cumulative returns to chart-friendly format
+    ogd_returns_data = [{"date": date.strftime("%Y-%m-%d"), "value": float(value)} 
+                      for date, value in ogd_cumulative.items()]
+    ew_returns_data = [{"date": date.strftime("%Y-%m-%d"), "value": float(value)} 
+                     for date, value in ew_cumulative.items()]
+    rp_returns_data = [{"date": date.strftime("%Y-%m-%d"), "value": float(value)} 
+                     for date, value in rp_cumulative.items()]
+
+    # Convert weights to chart-friendly format
+    weights_data = []
+    for date, row in ogd_weights_df.iterrows():
+        # Filter out very small weights to keep chart readable
+        significant_weights = {ticker: float(weight) for ticker, weight in row.items() 
+                             if weight > 0.01}  # Only include weights > 1%
+        weights_data.append({
+            "date": date.strftime("%Y-%m-%d"),
+            "weights": significant_weights
+        })
+
+    return {
+        "success": True,
+        "cumulative_returns": {
+            "ogd": ogd_returns_data,
+            "equal_weight": ew_returns_data,
+            "random": rp_returns_data
+        },
+        "weights": weights_data,
+        "metrics": {
+            "ogd": {
+                "sharpe": float(ogd_metrics["Annualized Sharpe Ratio"]),
+                "max_drawdown": float(ogd_metrics["Max Drawdown"]),
+                "cumulative_return": float(ogd_metrics["Cumulative Return"])
+            },
+            "equal_weight": {
+                "sharpe": float(ew_metrics["Annualized Sharpe Ratio"]),
+                "max_drawdown": float(ew_metrics["Max Drawdown"]),
+                "cumulative_return": float(ew_metrics["Cumulative Return"])
+            },
+            "random": {
+                "sharpe": float(rp_metrics["Annualized Sharpe Ratio"]),
+                "max_drawdown": float(rp_metrics["Max Drawdown"]),
+                "cumulative_return": float(rp_metrics["Cumulative Return"])
+            }
+        }
+    }
+
+# --- API Endpoints ---
+@app.get("/")
+async def serve_frontend():
+    """Serve the custom frontend HTML."""
+    html_path = Path(__file__).parent / "assets" / "static" / "index.html"
+    if html_path.exists():
+        with open(html_path) as f:
+            content = f.read()
+        return HTMLResponse(content=content)
+    else:
+        return {"error": "Frontend HTML file not found"}
+
+@app.get("/api/tickers_by_sector")
+async def get_tickers_by_sector():
+    """Return the tickers grouped by sector."""
+    json_path = Path(__file__).parent / "data" / "tickers_by_sector.json"
+    if json_path.exists():
+        with open(json_path) as f:
+            return json.load(f)
+    else:
+        # Fallback to generating sectors from available tickers
+        tickers = stock_data_df.columns.tolist()
+        if 'rf' in tickers:
+            tickers.remove('rf')
+        return [{"sector": "All Available Tickers", "tickers": tickers}]
+
+@app.post("/api/run_optimization")
+async def api_run_optimization(data: dict = Body(...)):
+    """API endpoint for running the optimization pipeline."""
+    try:
+        result = run_optimization_pipeline(
+            start_date=data.get('start_date'),
+            end_date=data.get('end_date'),
+            tickers_str=data.get('tickers', ''),
+            window_size=data.get('window_size', 20),
+            learning_rate=data.get('learning_rate', 0.1),
+            alpha_sortino=data.get('alpha_sortino', 1.0),
+            alpha_max_drawdown=data.get('alpha_max_drawdown', 1.0),
+            alpha_turnover=data.get('alpha_turnover', 0.1)
+        )
+        return result
+    except Exception as e:
+        return {"error": f"An error occurred: {str(e)}"}
+
+# --- Gradio Interface ---
+# Create a custom dark theme for Gradio
+dark_theme = gr.themes.Monochrome(
+    primary_hue="indigo",
+    secondary_hue="slate",
+    neutral_hue="slate",
+    radius_size=gr.themes.sizes.radius_sm,
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"]
+)
+
+with gr.Blocks(theme=dark_theme) as demo:
+    gr.Markdown("""# Portfolio Optimization with OGD
+    *Optimize your portfolio using Online Gradient Descent and compare against benchmarks.*""")
+
+    # Add a link to the custom frontend
+    gr.Markdown("""
+    ## View Enhanced UI
+    
+    Try our enhanced, modern UI with interactive charts and stock selection:
+    
+    * [Open Modern Interface](/)
+    
+    Below is the basic Gradio interface for quick testing:
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1): # Input Column
+            gr.Markdown("### Configure Simulation")
+            with gr.Accordion("Data Selection", open=True): # Group data inputs
+                start_date_input = gr.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="Default: Earliest", info="Leave blank for earliest available date.")
+                end_date_input = gr.Textbox(label="End Date (YYYY-MM-DD)", placeholder="Default: Latest", info="Leave blank for latest available date.")
+                tickers_input = gr.Textbox(
+                    label="Tickers (comma-separated)",
+                    placeholder="e.g., AAPL, MSFT, GOOGL",
+                    info="Leave blank to use all available tickers in the date range."
+                )
+            
+            with gr.Accordion("OGD Hyperparameters", open=True): # Group hyperparameters
+                window_size_input = gr.Number(label="Lookback Window (days)", value=20, minimum=5, step=1, info="Days of past returns used for optimization.")
+                learning_rate_input = gr.Number(label="Learning Rate", value=0.1, minimum=0.001, info="Step size for gradient updates.")
+                
+                gr.Markdown("##### Objective Function Weights (Alphas)")
+                alpha_sortino_input = gr.Number(label="Sortino Ratio Weight", value=1.0, minimum=0, info="Emphasis on maximizing risk-adjusted returns (downside risk).")
+                alpha_max_drawdown_input = gr.Number(label="Max Drawdown Weight", value=1.0, minimum=0, info="Emphasis on minimizing the largest peak-to-trough decline.")
+                alpha_turnover_input = gr.Number(label="Turnover Weight", value=0.1, minimum=0, info="Emphasis on minimizing trading frequency/costs.")
+
+            run_button = gr.Button("Run Optimization", variant="primary", scale=1) # Made button full width within column
+
+        with gr.Column(scale=3): # Output Column
+            gr.Markdown("### Results")
+            # Output components:
+            run_status_text = gr.Textbox(label="Run Status", interactive=False, lines=1)
+            metrics_output_df = gr.DataFrame(label="Performance Metrics Summary", interactive=False)
+            plot_output = gr.Plot(label="Cumulative Returns Comparison")
+            weights_output_df = gr.DataFrame(label="OGD Portfolio Weights (Daily)", interactive=False) # Removed height parameter
+
+
+    # This is the same function as before but wrapped to match the Gradio interface
+    def gradio_run_optimization(
+        start_date, end_date, tickers_str,
+        window_size, learning_rate,
+        alpha_sortino, alpha_max_drawdown, alpha_turnover
+    ):
+        result = run_optimization_pipeline(
+            start_date, end_date, tickers_str,
+            window_size, learning_rate,
+            alpha_sortino, alpha_max_drawdown, alpha_turnover
+        )
+        
+        if "error" in result:
+            return result["error"], None, None, None
+        
+        # Generate the metrics dataframe for Gradio
+        metrics_df = pd.DataFrame({
+            'OGD Portfolio': {
+                'Annualized Sharpe Ratio': result['metrics']['ogd']['sharpe'],
+                'Max Drawdown': result['metrics']['ogd']['max_drawdown'],
+                'Cumulative Return': result['metrics']['ogd']['cumulative_return']
+            },
+            'Equal Weight': {
+                'Annualized Sharpe Ratio': result['metrics']['equal_weight']['sharpe'],
+                'Max Drawdown': result['metrics']['equal_weight']['max_drawdown'],
+                'Cumulative Return': result['metrics']['equal_weight']['cumulative_return']
+            },
+            'Random Portfolio': {
+                'Annualized Sharpe Ratio': result['metrics']['random']['sharpe'],
+                'Max Drawdown': result['metrics']['random']['max_drawdown'],
+                'Cumulative Return': result['metrics']['random']['cumulative_return']
+            }
+        }).T
+        
+        # Create the matplotlib plot
+        fig, ax = plt.subplots(figsize=(10, 6))
+        
+        # Convert API-friendly format back to series for plotting
+        ogd_data = pd.Series({datetime.datetime.strptime(d['date'], '%Y-%m-%d').date(): d['value'] 
+                              for d in result['cumulative_returns']['ogd']})
+        ew_data = pd.Series({datetime.datetime.strptime(d['date'], '%Y-%m-%d').date(): d['value'] 
+                            for d in result['cumulative_returns']['equal_weight']})
+        rp_data = pd.Series({datetime.datetime.strptime(d['date'], '%Y-%m-%d').date(): d['value'] 
+                            for d in result['cumulative_returns']['random']})
+        
+        ogd_data.plot(ax=ax, label='OGD Portfolio')
+        ew_data.plot(ax=ax, label='Equal Weight')
+        rp_data.plot(ax=ax, label='Random Portfolio')
+        ax.set_title('Cumulative Portfolio Returns')
+        ax.set_ylabel('Cumulative Return')
+        ax.set_xlabel('Date')
+        ax.legend()
+        ax.grid(True)
+        plt.tight_layout()
+        
+        # Convert weights data back to DataFrame for Gradio
+        weights_df = pd.DataFrame()
+        for day_data in result['weights']:
+            date = datetime.datetime.strptime(day_data['date'], '%Y-%m-%d').date()
+            weights_df = pd.concat([weights_df, pd.Series(day_data['weights'], name=date)])
+        
+        return "Run successful!", metrics_df, fig, weights_df
+
+    run_button.click(
+        gradio_run_optimization,
+        inputs=[
+            start_date_input, end_date_input, tickers_input,
+            window_size_input, learning_rate_input,
+            alpha_sortino_input, alpha_max_drawdown_input, alpha_turnover_input
+        ],
+        outputs=[
+            run_status_text,
+            metrics_output_df,
+            plot_output, 
+            weights_output_df
+        ]
+    )
+
+# --- Mount Gradio app to FastAPI ---
+app = gr.mount_gradio_app(app, demo, path="/gradio")
+
+# Run the application
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

assets/static/index.html

@@ -0,0 +1,157 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Portfolio Optimizer</title>
+  <link rel="stylesheet" href="/static/style.css">
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap">
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/luxon@3.0.1/build/global/luxon.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-luxon@1.2.0/dist/chartjs-adapter-luxon.min.js"></script>
+</head>
+<body>
+  <div class="container">
+    <header class="header">
+      <div class="title-container">
+        <h1>Portfolio Optimizer</h1>
+      </div>
+    </header>
+    
+    <div class="main-content">
+      <div class="left-panel">
+        <!-- Configuration Card -->
+        <div class="config-card">
+          <h2 class="config-title">Portfolio Configuration</h2>
+          <div class="config-grid">
+            <div class="config-field">
+              <label class="config-label">Start Date:</label>
+              <input type="date" id="startDate" class="config-input">
+            </div>
+            <div class="config-field">
+              <label class="config-label">End Date:</label>
+              <input type="date" id="endDate" class="config-input">
+            </div>
+            <div class="config-field">
+              <label class="config-label">Learning Rate:</label>
+              <input type="number" id="learningRate" class="config-input" value="0.1" min="0.001" step="0.001">
+            </div>
+            <div class="config-field">
+              <label class="config-label">Window Size:</label>
+              <input type="number" id="windowSize" class="config-input" value="20" min="5">
+            </div>
+            <button id="runButton" class="run-button">Run Allocation</button>
+          </div>
+          
+          <div class="alpha-controls">
+            <h3 class="alpha-title">Objective Function Weights</h3>
+            <div class="alpha-grid">
+              <div class="config-field">
+                <label class="config-label">Sortino Ratio:</label>
+                <input type="number" id="alphaSortino" class="config-input" value="1.0" min="0" step="0.1">
+              </div>
+              <div class="config-field">
+                <label class="config-label">Max Drawdown:</label>
+                <input type="number" id="alphaMaxDrawdown" class="config-input" value="1.0" min="0" step="0.1">
+              </div>
+              <div class="config-field">
+                <label class="config-label">Turnover:</label>
+                <input type="number" id="alphaTurnover" class="config-input" value="0.1" min="0" step="0.1">
+              </div>
+            </div>
+          </div>
+        </div>
+        
+        <!-- Charts -->
+        <div class="graph-container">
+          <!-- Cumulative Returns Chart -->
+          <div class="chart-card">
+            <h3 class="chart-title">Cumulative Returns</h3>
+            <div class="chart-content">
+              <canvas id="returnsChart"></canvas>
+            </div>
+          </div>
+          
+          <!-- Weight Evolution Chart -->
+          <div class="chart-card">
+            <h3 class="chart-title">Weight Evolution</h3>
+            <div class="chart-content">
+              <canvas id="weightsChart"></canvas>
+            </div>
+          </div>
+          
+          <!-- Stats Row -->
+          <div class="stats-row">
+            <div class="stat-card">
+              <div class="stat-title">OGD Portfolio</div>
+              <div class="stat-value" id="ogdSharpeRatio">-</div>
+              <div class="stat-subtitle">Sharpe Ratio</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">OGD Portfolio</div>
+              <div class="stat-value" id="ogdMaxDrawdown">-</div>
+              <div class="stat-subtitle">Max Drawdown</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">OGD Portfolio</div>
+              <div class="stat-value" id="ogdReturn">-</div>
+              <div class="stat-subtitle">Return</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">Equal Weight</div>
+              <div class="stat-value" id="ewSharpeRatio">-</div>
+              <div class="stat-subtitle">Sharpe Ratio</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">Equal Weight</div>
+              <div class="stat-value" id="ewMaxDrawdown">-</div>
+              <div class="stat-subtitle">Max Drawdown</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">Equal Weight</div>
+              <div class="stat-value" id="ewReturn">-</div>
+              <div class="stat-subtitle">Return</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">Random Portfolio</div>
+              <div class="stat-value" id="randomSharpeRatio">-</div>
+              <div class="stat-subtitle">Sharpe Ratio</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">Random Portfolio</div>
+              <div class="stat-value" id="randomMaxDrawdown">-</div>
+              <div class="stat-subtitle">Max Drawdown</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-title">Random Portfolio</div>
+              <div class="stat-value" id="randomReturn">-</div>
+              <div class="stat-subtitle">Return</div>
+            </div>
+          </div>
+        </div>
+      </div>
+      
+      <div class="right-panel">
+        <div class="panel-header">
+          <h3 class="panel-title">Select Tickers</h3>
+          <div class="ticker-controls">
+            <button id="selectAllBtn" class="ticker-button">Select All</button>
+            <button id="deselectAllBtn" class="ticker-button">Deselect All</button>
+          </div>
+        </div>
+        <div class="stock-list" id="stockList">
+          <!-- Stock sectors and tickers will be populated here -->
+          <div class="loading-text">Loading tickers...</div>
+        </div>
+      </div>
+    </div>
+    
+    <div class="loading-overlay" id="loadingOverlay" style="display: none;">
+      <div class="spinner"></div>
+      <div class="loading-text">Optimizing Portfolio...</div>
+    </div>
+  </div>
+
+  <script src="/static/script.js"></script>
+</body>
+</html> 

assets/static/script.js

@@ -0,0 +1,533 @@
+// Global variables
+let returnChart = null;
+let weightChart = null;
+let sectorData = null;
+let selectedTickers = new Set();
+
+// Fetch tickers grouped by sector
+async function fetchTickersBySector() {
+  try {
+    const response = await fetch('/api/tickers_by_sector');
+    return await response.json();
+  } catch (error) {
+    console.error('Error fetching tickers:', error);
+    return [];
+  }
+}
+
+// Format date to YYYY-MM-DD
+function formatDate(date) {
+  return date.toISOString().split('T')[0];
+}
+
+// Populate the stock list with sectors and tickers
+function populateStockList(sectors) {
+  const stockListElement = document.getElementById('stockList');
+  stockListElement.innerHTML = '';
+  
+  // Setup select/deselect buttons
+  document.getElementById('selectAllBtn').addEventListener('click', () => {
+    const allCheckboxes = document.querySelectorAll('.stock-checkbox');
+    allCheckboxes.forEach(checkbox => {
+      checkbox.checked = true;
+      selectedTickers.add(checkbox.value);
+    });
+  });
+  
+  document.getElementById('deselectAllBtn').addEventListener('click', () => {
+    const allCheckboxes = document.querySelectorAll('.stock-checkbox');
+    allCheckboxes.forEach(checkbox => {
+      checkbox.checked = false;
+      selectedTickers.delete(checkbox.value);
+    });
+  });
+  
+  // Create sector groups
+  sectors.forEach(sector => {
+    const sectorGroup = document.createElement('div');
+    sectorGroup.className = 'sector-group';
+    
+    // Sector header
+    const sectorHeader = document.createElement('div');
+    sectorHeader.className = 'sector-header';
+    
+    const sectorNameContainer = document.createElement('div');
+    sectorNameContainer.className = 'sector-name';
+    
+    const sectorArrow = document.createElement('span');
+    sectorArrow.className = 'sector-arrow';
+    sectorArrow.textContent = '▶';
+    sectorArrow.classList.add('open'); // Start with open sections
+    
+    const sectorNameText = document.createElement('span');
+    sectorNameText.textContent = sector.sector;
+    
+    sectorNameContainer.appendChild(sectorArrow);
+    sectorNameContainer.appendChild(sectorNameText);
+    
+    const sectorToggle = document.createElement('button');
+    sectorToggle.className = 'sector-toggle';
+    sectorToggle.textContent = 'Toggle All';
+    
+    sectorHeader.appendChild(sectorNameContainer);
+    sectorHeader.appendChild(sectorToggle);
+    sectorGroup.appendChild(sectorHeader);
+    
+    // Collapsible ticker grid
+    const tickerGrid = document.createElement('div');
+    tickerGrid.className = 'ticker-grid';
+    
+    // Create stock items in a grid
+    sector.tickers.forEach(ticker => {
+      const stockItem = document.createElement('div');
+      stockItem.className = 'stock-item';
+      
+      const checkbox = document.createElement('input');
+      checkbox.type = 'checkbox';
+      checkbox.className = 'stock-checkbox';
+      checkbox.value = ticker;
+      checkbox.id = `ticker-${ticker}`;
+      checkbox.addEventListener('change', () => {
+        if (checkbox.checked) {
+          selectedTickers.add(ticker);
+        } else {
+          selectedTickers.delete(ticker);
+        }
+      });
+      
+      const label = document.createElement('label');
+      label.className = 'stock-ticker';
+      label.textContent = ticker;
+      label.htmlFor = `ticker-${ticker}`;
+      
+      stockItem.appendChild(checkbox);
+      stockItem.appendChild(label);
+      tickerGrid.appendChild(stockItem);
+    });
+    
+    sectorGroup.appendChild(tickerGrid);
+    stockListElement.appendChild(sectorGroup);
+    
+    // Toggle functionality
+    sectorToggle.addEventListener('click', () => {
+      const checkboxes = tickerGrid.querySelectorAll('.stock-checkbox');
+      const allChecked = Array.from(checkboxes).every(cb => cb.checked);
+      
+      checkboxes.forEach(checkbox => {
+        checkbox.checked = !allChecked;
+        if (!allChecked) {
+          selectedTickers.add(checkbox.value);
+        } else {
+          selectedTickers.delete(checkbox.value);
+        }
+      });
+    });
+    
+    // Collapsible section
+    sectorNameContainer.addEventListener('click', () => {
+      sectorArrow.classList.toggle('open');
+      tickerGrid.style.display = sectorArrow.classList.contains('open') ? 'grid' : 'none';
+    });
+  });
+}
+
+// Initialize charts
+function initializeCharts() {
+  const returnsCtx = document.getElementById('returnsChart').getContext('2d');
+  const weightsCtx = document.getElementById('weightsChart').getContext('2d');
+  
+  // Configure Chart.js global defaults for dark theme
+  Chart.defaults.color = '#b0b0b8';
+  Chart.defaults.scale.grid.color = 'rgba(56, 56, 64, 0.5)';
+  Chart.defaults.scale.grid.borderColor = 'rgba(56, 56, 64, 0.8)';
+  
+  // Returns chart configuration
+  returnChart = new Chart(returnsCtx, {
+    type: 'line',
+    data: {
+      datasets: [
+        {
+          label: 'OGD Portfolio',
+          borderColor: '#3f88e2',
+          backgroundColor: 'rgba(63, 136, 226, 0.1)',
+          borderWidth: 1.5,
+          pointRadius: 0, // Hide points completely
+          tension: 0.1,
+          data: []
+        },
+        {
+          label: 'Equal Weight',
+          borderColor: '#4caf50',
+          backgroundColor: 'rgba(76, 175, 80, 0.1)',
+          borderWidth: 1.5,
+          pointRadius: 0, // Hide points completely
+          tension: 0.1,
+          data: []
+        },
+        {
+          label: 'Random Portfolio',
+          borderColor: '#e2b53f',
+          backgroundColor: 'rgba(226, 181, 63, 0.1)',
+          borderWidth: 1.5,
+          pointRadius: 0, // Hide points completely
+          tension: 0.1,
+          data: []
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      interaction: {
+        mode: 'index',
+        intersect: false,
+      },
+      scales: {
+        x: {
+          type: 'time',
+          time: {
+            unit: 'month',
+            tooltipFormat: 'MMM dd, yyyy'
+          }
+        },
+        y: {
+          title: {
+            display: true,
+            text: 'Cumulative Return'
+          },
+          beginAtZero: false
+        }
+      },
+      plugins: {
+        legend: {
+          position: 'bottom'
+        },
+        tooltip: {
+          mode: 'index',
+          intersect: false,
+          backgroundColor: 'rgba(42, 42, 48, 0.9)',
+          titleColor: '#ffffff',
+          bodyColor: '#ffffff',
+          borderColor: 'rgba(56, 56, 64, 1)',
+          borderWidth: 1
+        }
+      }
+    }
+  });
+  
+  // Weights chart configuration (empty initially)
+  weightChart = new Chart(weightsCtx, {
+    type: 'line',
+    data: {
+      datasets: []
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      interaction: {
+        mode: 'index',
+        intersect: false,
+      },
+      scales: {
+        x: {
+          type: 'time',
+          time: {
+            unit: 'month',
+            tooltipFormat: 'MMM dd, yyyy'
+          }
+        },
+        y: {
+          title: {
+            display: true,
+            text: 'Weight'
+          },
+          min: 0,
+          suggestedMax: 1
+        }
+      },
+      plugins: {
+        legend: {
+          position: 'right',
+          maxHeight: 200,
+          labels: {
+            boxWidth: 12,
+            boxHeight: 12
+          }
+        },
+        tooltip: {
+          mode: 'index',
+          intersect: false,
+          backgroundColor: 'rgba(42, 42, 48, 0.9)',
+          titleColor: '#ffffff',
+          bodyColor: '#ffffff',
+          borderColor: 'rgba(56, 56, 64, 1)',
+          borderWidth: 1
+        }
+      }
+    }
+  });
+}
+
+// Function to run the optimization
+async function runOptimization() {
+  const startDate = document.getElementById('startDate').value;
+  const endDate = document.getElementById('endDate').value || formatDate(new Date());
+  const windowSize = document.getElementById('windowSize').value;
+  const learningRate = document.getElementById('learningRate').value;
+  
+  // Get alpha values from inputs
+  const alphaSortino = document.getElementById('alphaSortino').value;
+  const alphaMaxDrawdown = document.getElementById('alphaMaxDrawdown').value;
+  const alphaTurnover = document.getElementById('alphaTurnover').value;
+  
+  // Get all selected tickers
+  const tickers = Array.from(selectedTickers).join(',');
+  
+  // Validate inputs
+  if (!startDate) {
+    alert('Please select a start date');
+    return;
+  }
+  
+  if (selectedTickers.size === 0) {
+    alert('Please select at least one ticker');
+    return;
+  }
+  
+  try {
+    document.getElementById('loadingOverlay').style.display = 'flex';
+    runFakeSimulation(); // Start showing fake simulation while waiting
+    
+    const response = await fetch('/api/run_optimization', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        start_date: startDate,
+        end_date: endDate,
+        tickers: tickers,
+        window_size: windowSize,
+        learning_rate: learningRate,
+        alpha_sortino: alphaSortino,
+        alpha_max_drawdown: alphaMaxDrawdown,
+        alpha_turnover: alphaTurnover
+      }),
+    });
+    
+    const result = await response.json();
+    
+    if (result.error) {
+      alert(`Error: ${result.error}`);
+      return;
+    }
+    
+    updateCharts(result.cumulative_returns, result.weights);
+    updateMetrics(result.metrics);
+    
+  } catch (error) {
+    console.error('Error running optimization:', error);
+    alert('An error occurred while running the optimization. Please try again.');
+  } finally {
+    document.getElementById('loadingOverlay').style.display = 'none';
+  }
+}
+
+// Update charts with new data
+function updateCharts(returnsData, weightsData) {
+  // Update cumulative returns chart
+  returnChart.data.datasets[0].data = returnsData.ogd.map(d => ({ x: d.date, y: d.value }));
+  returnChart.data.datasets[1].data = returnsData.equal_weight.map(d => ({ x: d.date, y: d.value }));
+  returnChart.data.datasets[2].data = returnsData.random.map(d => ({ x: d.date, y: d.value }));
+  returnChart.update();
+  
+  // Update weights chart (clear old datasets first)
+  weightChart.data.datasets = [];
+  
+  // Get top N stocks by average weight
+  const stocksSummary = {};
+  const dates = [];
+  let maxWeight = 0; // Track maximum weight for y-axis scaling
+  
+  weightsData.forEach(dataPoint => {
+    const date = dataPoint.date;
+    dates.push(date);
+    
+    Object.entries(dataPoint.weights).forEach(([ticker, weight]) => {
+      if (!stocksSummary[ticker]) {
+        stocksSummary[ticker] = { total: 0, count: 0 };
+      }
+      stocksSummary[ticker].total += weight;
+      stocksSummary[ticker].count += 1;
+      
+      // Track the maximum weight seen
+      maxWeight = Math.max(maxWeight, weight);
+    });
+  });
+  
+  // Calculate average weight
+  Object.keys(stocksSummary).forEach(ticker => {
+    stocksSummary[ticker].average = stocksSummary[ticker].total / stocksSummary[ticker].count;
+  });
+  
+  // Sort by average weight and take top 10
+  const topStocks = Object.entries(stocksSummary)
+    .sort((a, b) => b[1].average - a[1].average)
+    .slice(0, 10)
+    .map(entry => entry[0]);
+  
+  // Create dataset for each top stock
+  const colors = [
+    '#3f88e2', '#4caf50', '#e2b53f', '#e24d3f', '#9c27b0',
+    '#00bcd4', '#ffeb3b', '#795548', '#607d8b', '#e91e63'
+  ];
+  
+  topStocks.forEach((ticker, index) => {
+    const data = weightsData.map(dataPoint => ({
+      x: dataPoint.date,
+      y: dataPoint.weights[ticker] || 0
+    }));
+    
+    // Track max weight for y-axis scaling
+    data.forEach(point => {
+      maxWeight = Math.max(maxWeight, point.y);
+    });
+    
+    weightChart.data.datasets.push({
+      label: ticker,
+      borderColor: colors[index % colors.length],
+      backgroundColor: colors[index % colors.length] + '33',
+      data: data,
+      borderWidth: 1.5,
+      pointRadius: 0,
+      tension: 0.1
+    });
+  });
+  
+  // Set the y-axis max to be the highest weight + 0.1
+  weightChart.options.scales.y.max = maxWeight + 0.1;
+  
+  weightChart.update();
+}
+
+// Update performance metrics for all three portfolios
+function updateMetrics(metrics) {
+  // OGD Portfolio metrics
+  document.getElementById('ogdSharpeRatio').textContent = metrics.ogd.sharpe.toFixed(2);
+  document.getElementById('ogdMaxDrawdown').textContent = (metrics.ogd.max_drawdown * 100).toFixed(2) + '%';
+  document.getElementById('ogdReturn').textContent = ((metrics.ogd.cumulative_return - 1) * 100).toFixed(2) + '%';
+  
+  // Equal Weight Portfolio metrics
+  document.getElementById('ewSharpeRatio').textContent = metrics.equal_weight.sharpe.toFixed(2);
+  document.getElementById('ewMaxDrawdown').textContent = (metrics.equal_weight.max_drawdown * 100).toFixed(2) + '%';
+  document.getElementById('ewReturn').textContent = ((metrics.equal_weight.cumulative_return - 1) * 100).toFixed(2) + '%';
+  
+  // Random Portfolio metrics
+  document.getElementById('randomSharpeRatio').textContent = metrics.random.sharpe.toFixed(2);
+  document.getElementById('randomMaxDrawdown').textContent = (metrics.random.max_drawdown * 100).toFixed(2) + '%';
+  document.getElementById('randomReturn').textContent = ((metrics.random.cumulative_return - 1) * 100).toFixed(2) + '%';
+}
+
+// Create a fake simulation for visual feedback during loading
+function runFakeSimulation() {
+  const loadingOverlay = document.getElementById('loadingOverlay');
+  if (loadingOverlay.style.display === 'none') return;
+  
+  // Generate fake return data
+  const dates = [];
+  const today = new Date();
+  for (let i = 365; i >= 0; i--) {
+    const date = new Date(today);
+    date.setDate(today.getDate() - i);
+    dates.push(date.toISOString().split('T')[0]);
+  }
+  
+  // Generate fake returns
+  const generateFakeData = (volatility, bias = 0) => {
+    let value = 1.0;
+    return dates.map(date => {
+      value *= (1 + (Math.random() - 0.45 + bias) * volatility);
+      return { date, value };
+    });
+  };
+  
+  const fakeReturns = {
+    ogd: generateFakeData(0.015, 0.02),
+    equal_weight: generateFakeData(0.01, 0.01),
+    random: generateFakeData(0.02, 0)
+  };
+  
+  // Generate fake weights
+  const fakeWeights = [];
+  const fakeTickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'META', 'TSLA', 'NVDA', 'JPM', 'JNJ', 'V'];
+  
+  dates.forEach(date => {
+    const weights = {};
+    let totalWeight = 0;
+    
+    fakeTickers.forEach(ticker => {
+      // Random weight but normalized later
+      weights[ticker] = Math.random();
+      totalWeight += weights[ticker];
+    });
+    
+    // Normalize weights
+    fakeTickers.forEach(ticker => {
+      weights[ticker] = weights[ticker] / totalWeight;
+    });
+    
+    fakeWeights.push({ date, weights });
+  });
+  
+  // Update charts with fake data
+  updateCharts(fakeReturns, fakeWeights);
+  
+  // Update metrics with fake data
+  const fakeMetrics = {
+    ogd: {
+      sharpe: 1.2 + Math.random() * 0.6,
+      max_drawdown: 0.15 + Math.random() * 0.1,
+      cumulative_return: 1.6 + Math.random() * 0.8
+    },
+    equal_weight: {
+      sharpe: 0.9 + Math.random() * 0.4,
+      max_drawdown: 0.18 + Math.random() * 0.1,
+      cumulative_return: 1.3 + Math.random() * 0.5
+    },
+    random: {
+      sharpe: 0.6 + Math.random() * 0.5,
+      max_drawdown: 0.25 + Math.random() * 0.15,
+      cumulative_return: 1.2 + Math.random() * 0.4
+    }
+  };
+  
+  updateMetrics(fakeMetrics);
+}
+
+// Initialize the application
+async function initialize() {
+  try {
+    // Initialize charts
+    initializeCharts();
+    
+    // Set default dates to match the data range
+    document.getElementById('startDate').value = '2007-01-01'; // Jan 1, 2007
+    document.getElementById('endDate').value = '2025-04-01';   // Apr 1, 2025
+    
+    // Fetch tickers and populate stock list
+    sectorData = await fetchTickersBySector();
+    populateStockList(sectorData);
+    
+    // Add event listener to run button
+    document.getElementById('runButton').addEventListener('click', runOptimization);
+    
+    // Run fake simulation for initial visual
+    runFakeSimulation();
+    
+  } catch (error) {
+    console.error('Error initializing application:', error);
+  }
+}
+
+// Run the initialization when the document is loaded
+document.addEventListener('DOMContentLoaded', initialize); 

assets/static/style.css

@@ -0,0 +1,495 @@
+/* Main App CSS */
+:root {
+  /* Dark theme colors - updated to match image */
+  --bg-primary: #1e1e24;
+  --bg-secondary: #2a2a30;
+  --bg-tertiary: #3a3a42;
+  --bg-card: #2a2a30;
+  --text-primary: #ffffff;
+  --text-secondary: #b0b0b8;
+  --accent-primary: #3f88e2;
+  --accent-secondary: #5e9aeb;
+  --border-color: #383840;
+  --grid-color: #383840;
+  --success-color: #4caf50;
+  --warning-color: #ff9800;
+  --danger-color: #f44336;
+  --random-color: #e2b53f;
+  --equal-weight-color: #4caf50;
+  
+  /* Spacing */
+  --spacing-xs: 4px;
+  --spacing-sm: 8px;
+  --spacing-md: 16px;
+  --spacing-lg: 24px;
+  --spacing-xl: 32px;
+  
+  /* Typography */
+  --font-family: 'Inter', system-ui, -apple-system, sans-serif;
+  --font-size-xs: 12px;
+  --font-size-sm: 14px;
+  --font-size-md: 16px;
+  --font-size-lg: 20px;
+  --font-size-xl: 24px;
+  --font-size-xxl: 32px;
+
+  /* Chart dimensions */
+  --chart-height: 300px;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: var(--font-family);
+  background-color: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.6;
+}
+
+.container {
+  width: 100%;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.header {
+  padding: var(--spacing-md) var(--spacing-lg);
+  background-color: var(--bg-primary);
+  border-bottom: 1px solid var(--border-color);
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.title-container h1 {
+  font-size: var(--font-size-xl);
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.title-container p {
+  font-size: var(--font-size-sm);
+  color: var(--text-secondary);
+}
+
+.main-content {
+  display: flex;
+  flex: 1;
+  overflow: hidden;
+  padding: var(--spacing-lg);
+  gap: var(--spacing-lg);
+  height: calc(100vh - 80px); /* Account for header height */
+}
+
+.left-panel {
+  flex: 3;
+  display: flex;
+  flex-direction: column;
+  overflow-y: auto; /* Add scroll to left panel */
+  gap: var(--spacing-lg);
+  max-height: 100%;
+  padding-right: var(--spacing-sm); /* Add space for scrollbar */
+}
+
+.right-panel {
+  flex: 1;
+  background-color: var(--bg-secondary);
+  border-radius: 8px;
+  overflow-y: auto;
+  max-height: calc(100vh - 120px);
+}
+
+.config-card {
+  background-color: var(--bg-secondary);
+  border-radius: 8px;
+  padding: var(--spacing-md);
+}
+
+.config-title {
+  text-align: center;
+  font-size: var(--font-size-lg);
+  margin-bottom: var(--spacing-md);
+  color: var(--text-primary);
+  font-weight: 500;
+}
+
+.config-grid {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr) auto;
+  grid-gap: var(--spacing-md);
+  align-items: center;
+}
+
+.config-field {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-xs);
+}
+
+.config-label {
+  font-size: var(--font-size-sm);
+  color: var(--text-secondary);
+}
+
+.config-input {
+  background-color: var(--bg-tertiary);
+  border: 1px solid var(--border-color);
+  color: var(--text-primary);
+  padding: var(--spacing-sm);
+  border-radius: 4px;
+  font-size: var(--font-size-sm);
+  outline: none;
+  height: 38px;
+}
+
+.config-input:focus {
+  border-color: var(--accent-primary);
+}
+
+.run-button {
+  background-color: var(--accent-primary);
+  color: white;
+  border: none;
+  padding: var(--spacing-sm) var(--spacing-lg);
+  border-radius: 4px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background-color 0.2s;
+  height: 38px;
+}
+
+.run-button:hover {
+  background-color: var(--accent-secondary);
+}
+
+.graph-container {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-md);
+  overflow: visible;
+}
+
+.chart-card {
+  background-color: var(--bg-secondary);
+  border-radius: 8px;
+  padding: var(--spacing-md);
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-md);
+}
+
+.chart-title {
+  font-size: var(--font-size-md);
+  font-weight: 500;
+  color: var(--text-primary);
+  text-align: center;
+}
+
+.chart-content {
+  position: relative;
+  height: 220px; /* Reduced from 300px */
+  width: 100%;
+}
+
+.stats-row {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  grid-template-rows: repeat(3, auto);
+  gap: var(--spacing-sm);
+  margin-top: var(--spacing-sm);
+}
+
+.stat-card {
+  background-color: var(--bg-secondary);
+  border-radius: 8px;
+  padding: var(--spacing-sm);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+.stat-title {
+  font-size: var(--font-size-xs);
+  color: var(--accent-primary);
+  margin-bottom: var(--spacing-xs);
+  font-weight: 500;
+}
+
+.stat-value {
+  font-size: var(--font-size-md);
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.stat-subtitle {
+  font-size: var(--font-size-xs);
+  color: var(--text-secondary);
+  margin-top: var(--spacing-xs);
+}
+
+/* Ticker Selection Panel */
+.panel-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: var(--spacing-md);
+  border-bottom: 1px solid var(--border-color);
+}
+
+.panel-title {
+  font-size: var(--font-size-md);
+  font-weight: 500;
+}
+
+.ticker-controls {
+  display: flex;
+  gap: var(--spacing-sm);
+}
+
+.ticker-button {
+  background-color: var(--bg-tertiary);
+  border: 1px solid var(--border-color);
+  color: var(--text-secondary);
+  padding: var(--spacing-xs) var(--spacing-sm);
+  border-radius: 4px;
+  font-size: var(--font-size-xs);
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.ticker-button:hover {
+  background-color: var(--accent-primary);
+  color: white;
+}
+
+.stock-list {
+  overflow-y: auto;
+  padding: 0 var(--spacing-md) var(--spacing-md);
+}
+
+.sector-group {
+  margin: var(--spacing-md) 0;
+}
+
+.sector-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: var(--spacing-sm) 0;
+  border-bottom: 1px solid var(--border-color);
+  margin-bottom: var(--spacing-sm);
+}
+
+.sector-controls {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: var(--spacing-sm);
+  padding: 0 var(--spacing-sm);
+}
+
+.sector-name {
+  display: flex;
+  align-items: center;
+  font-size: var(--font-size-sm);
+  font-weight: 500;
+  gap: var(--spacing-sm);
+  cursor: pointer;
+}
+
+.sector-arrow {
+  transition: transform 0.2s;
+}
+
+.sector-arrow.open {
+  transform: rotate(90deg);
+}
+
+.sector-toggle {
+  font-size: var(--font-size-xs);
+  color: var(--accent-primary);
+  background: none;
+  border: none;
+  cursor: pointer;
+}
+
+.ticker-grid {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: var(--spacing-xs) var(--spacing-sm);
+}
+
+.stock-item {
+  display: flex;
+  align-items: center;
+  padding: var(--spacing-xs);
+}
+
+.stock-checkbox {
+  margin-right: var(--spacing-xs);
+  appearance: none;
+  width: 14px;
+  height: 14px;
+  border: 1px solid var(--border-color);
+  border-radius: 3px;
+  background-color: var(--bg-tertiary);
+  cursor: pointer;
+  position: relative;
+}
+
+.stock-checkbox:checked {
+  background-color: var(--accent-primary);
+  border-color: var(--accent-primary);
+}
+
+.stock-checkbox:checked::after {
+  content: "";
+  position: absolute;
+  left: 4px;
+  top: 1px;
+  width: 4px;
+  height: 8px;
+  border: solid white;
+  border-width: 0 2px 2px 0;
+  transform: rotate(45deg);
+}
+
+.stock-ticker {
+  font-size: var(--font-size-xs);
+  cursor: pointer;
+}
+
+.loading-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: rgba(30, 30, 36, 0.8);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 100;
+}
+
+.spinner {
+  width: 40px;
+  height: 40px;
+  border: 3px solid rgba(255, 255, 255, 0.1);
+  border-radius: 50%;
+  border-top-color: var(--accent-primary);
+  animation: spin 1s ease-in-out infinite;
+  margin-bottom: var(--spacing-md);
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.loading-text {
+  font-size: var(--font-size-md);
+  color: var(--text-primary);
+}
+
+/* Toggle switch for sectors */
+.toggle-switch {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-xs);
+}
+
+.toggle-checkbox {
+  height: 0;
+  width: 0;
+  visibility: hidden;
+  position: absolute;
+}
+
+.toggle-label {
+  cursor: pointer;
+  width: 32px;
+  height: 16px;
+  background: var(--bg-tertiary);
+  display: block;
+  border-radius: 100px;
+  position: relative;
+}
+
+.toggle-label:after {
+  content: '';
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 12px;
+  height: 12px;
+  background: var(--text-secondary);
+  border-radius: 50%;
+  transition: 0.3s;
+}
+
+.toggle-checkbox:checked + .toggle-label {
+  background: var(--accent-primary);
+}
+
+.toggle-checkbox:checked + .toggle-label:after {
+  left: calc(100% - 2px);
+  transform: translateX(-100%);
+  background: white;
+}
+
+/* Responsiveness */
+@media (max-width: 1280px) {
+  .main-content {
+    flex-direction: column;
+  }
+  
+  .right-panel {
+    max-height: 300px;
+  }
+  
+  .config-grid {
+    grid-template-columns: 1fr 1fr;
+  }
+  
+  .ticker-grid {
+    grid-template-columns: repeat(3, 1fr);
+  }
+}
+
+@media (max-width: 768px) {
+  .stats-row {
+    grid-template-columns: 1fr;
+  }
+  
+  .ticker-grid {
+    grid-template-columns: repeat(2, 1fr);
+  }
+}
+
+.alpha-controls {
+  margin-top: var(--spacing-md);
+}
+
+.alpha-title {
+  font-size: var(--font-size-sm);
+  margin-bottom: var(--spacing-sm);
+  color: var(--text-primary);
+  font-weight: 500;
+  text-align: center;
+}
+
+.alpha-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: var(--spacing-md);
+} 

benchmarks.py

@@ -0,0 +1,102 @@
+import pandas as pd
+import numpy as np
+import random
+
+# Small epsilon for Sharpe calculation
+eps = 1e-8
+ANNUAL_TRADING_DAYS = 252
+
+def run_equal_weight(data_df: pd.DataFrame) -> pd.Series:
+    """Calculates daily returns for a static equal-weight portfolio.
+
+    Args:
+        data_df (pd.DataFrame): DataFrame with dates as index, ticker returns,
+                                and an 'rf' column.
+
+    Returns:
+        pd.Series: Daily returns of the equal-weight portfolio.
+    """
+    stock_returns = data_df.drop(columns=['rf'], errors='ignore')
+    if stock_returns.empty:
+        return pd.Series(dtype=float, name="EqualWeightReturn")
+    # Calculate the mean return across all stocks for each day
+    daily_returns = stock_returns.mean(axis=1)
+    return daily_returns.rename("EqualWeightReturn")
+
+def run_random_portfolio(
+        data_df: pd.DataFrame,
+        num_stocks: int = 3,
+        rebalance_days: int = 20
+    ) -> pd.Series:
+    """Calculates daily returns for a randomly selected portfolio,
+       rebalanced periodically.
+
+    Args:
+        data_df (pd.DataFrame): DataFrame with dates as index, ticker returns,
+                                and an 'rf' column.
+        num_stocks (int): Number of stocks to randomly select.
+        rebalance_days (int): How often to re-select stocks.
+
+    Returns:
+        pd.Series: Daily returns of the random portfolio.
+    """
+    stock_returns = data_df.drop(columns=['rf'], errors='ignore')
+    if stock_returns.empty or stock_returns.shape[1] < num_stocks:
+        print("Warning: Not enough stocks available for random portfolio.")
+        return pd.Series(dtype=float, name="RandomPortfolioReturn")
+
+    tickers = stock_returns.columns.tolist()
+    portfolio_returns = pd.Series(index=data_df.index, dtype=float)
+    selected_tickers = []
+
+    for i, date in enumerate(data_df.index):
+        # Rebalance check
+        if i % rebalance_days == 0 or not selected_tickers:
+            if len(tickers) >= num_stocks:
+                 selected_tickers = random.sample(tickers, num_stocks)
+            else: # Should not happen based on initial check, but safe
+                 selected_tickers = tickers
+            # print(f"Rebalancing Random Portfolio on {date.date()}: {selected_tickers}")
+
+        # Calculate return for the day using selected tickers
+        daily_returns = stock_returns.loc[date, selected_tickers]
+        portfolio_returns[date] = daily_returns.mean() # Equal weight among selected
+
+    return portfolio_returns.rename("RandomPortfolioReturn")
+
+# --- Performance Metrics --- 
+
+def calculate_cumulative_returns(returns_series: pd.Series) -> pd.Series:
+    """Calculates cumulative returns from a daily returns series."""
+    return (1 + returns_series.fillna(0)).cumprod()
+
+def calculate_performance_metrics(returns_series: pd.Series, rf_series: pd.Series) -> dict:
+    """Calculates annualized Sharpe Ratio and Max Drawdown."""
+    if returns_series.empty or returns_series.isnull().all():
+        return {"Annualized Sharpe Ratio": 0.0, "Max Drawdown": 0.0, "Cumulative Return": 1.0}
+    
+    cumulative_return = (1 + returns_series.fillna(0)).cumprod().iloc[-1]
+    
+    # Align risk-free rate series to the returns series index
+    aligned_rf = rf_series.reindex(returns_series.index).fillna(0)
+    
+    # Calculate Excess Returns
+    excess_returns = returns_series - aligned_rf
+    
+    # Annualized Sharpe Ratio
+    # Use np.sqrt(ANNUAL_TRADING_DAYS) for annualization factor
+    mean_excess_return = excess_returns.mean()
+    std_dev_excess_return = excess_returns.std()
+    sharpe_ratio = (mean_excess_return / (std_dev_excess_return + eps)) * np.sqrt(ANNUAL_TRADING_DAYS)
+    
+    # Max Drawdown
+    cumulative = calculate_cumulative_returns(returns_series)
+    peak = cumulative.expanding(min_periods=1).max()
+    drawdown = (cumulative - peak) / (peak + eps) # Drawdown is negative or zero
+    max_drawdown = abs(drawdown.min()) # Max drawdown is positive
+    
+    return {
+        "Annualized Sharpe Ratio": round(sharpe_ratio, 4),
+        "Max Drawdown": round(max_drawdown, 4),
+        "Cumulative Return": round(cumulative_return, 4)
+    } 

data/risk_free_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6d264a5ebe76a9b04e90f27d60d7cb5877632333acdae4e69c4d1ff43da2d46
+size 74722

data/stock_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba1a04ffe09a116240c3d7bf2dfd1fac2fc817d83727c3d373f89bc23ec5eb2d
+size 14676155

data/tickers_by_sector.json

@@ -0,0 +1,42 @@
+[
+  {
+    "sector": "Technology",
+    "tickers": ["AAPL", "MSFT", "NVDA", "GOOGL", "META", "AVGO", "ORCL", "IBM", "CSCO", "TSM", "ASML", "AMD", "TXN", "INTC", "MU", "QCOM", "LRCX", "NXPI", "ADI"]
+  },
+  {
+    "sector": "Consumer Discretionary",
+    "tickers": ["AMZN", "TSLA", "NKE", "MCD", "SBUX", "YUM", "GM", "F", "RIVN", "NIO", "TTWO", "EA", "GME", "AMC"]
+  },
+  {
+    "sector": "Financials",
+    "tickers": ["JPM", "V", "MA", "GS", "MS", "BAC", "C", "AXP", "SCHW"]
+  },
+  {
+    "sector": "Health Care",
+    "tickers": ["UNH", "JNJ", "LLY", "PFE", "MRNA", "BMY", "GILD", "CVS", "VRTX", "ISRG"]
+  },
+  {
+    "sector": "Consumer Staples",
+    "tickers": ["WMT", "PG", "TGT", "KO", "PEP", "TSN", "CAG", "SYY", "HRL", "MDLZ"]
+  },
+  {
+    "sector": "Energy",
+    "tickers": ["XOM", "CVX", "NEE", "DUK", "SO", "D", "ENB", "SLB", "EOG", "PSX"]
+  },
+  {
+    "sector": "Industrials",
+    "tickers": ["DE", "LMT", "RTX", "BA", "CAT", "GE", "HON", "UPS", "EMR", "NOC", "FDX", "CSX", "UNP", "DAL"]
+  },
+  {
+    "sector": "Real Estate",
+    "tickers": ["PLD", "AMT", "EQIX", "O", "SPG", "VICI", "DLR", "WY", "EQR", "PSA"]
+  },
+  {
+    "sector": "Materials",
+    "tickers": ["ADM", "BG", "CF", "MOS", "FMC"]
+  },
+  {
+    "sector": "Communication Services",
+    "tickers": ["NFLX", "DIS", "PARA", "WBD", "CMCSA", "SPOT", "LYV"]
+  }
+] 

optimization.py

@@ -0,0 +1,347 @@
+import torch
+import pandas as pd
+import numpy as np # Added numpy for potential use
+
+# Small epsilon to avoid division by zero - INCREASED for better stability
+eps = 1e-6
+
+# --- Objective function components ---
+def calculate_sortino(
+        returns: torch.Tensor, # Use torch.Tensor for type hinting
+        min_acceptable_return: torch.Tensor
+    ):
+    """Calculates the Sortino ratio."""
+    if min_acceptable_return is not None:
+        excess_returns = returns - min_acceptable_return
+    else:
+        # If no MAR provided, treat 0 as the target
+        excess_returns = returns
+
+    # Calculate downside deviation only on returns below the target
+    downside_returns = torch.where(excess_returns < 0, excess_returns, torch.tensor(0.0, device=returns.device))
+    downside_deviation = torch.std(downside_returns, dim=0)
+    
+    # More robust division - avoid division by very small numbers
+    downside_deviation = torch.clamp(downside_deviation, min=eps)
+    
+    # Calculate Sortino ratio with better stability
+    sortino = torch.mean(excess_returns, dim=0) / downside_deviation
+    
+    # Clip extreme values to prevent propagation of extreme gradients
+    sortino = torch.clamp(sortino, min=-100.0, max=100.0)
+    
+    return sortino
+
+def calculate_max_drawdown(
+        returns: torch.Tensor
+    ):
+    """Calculates max drawdown for the duration of the returns passed.
+       Max drawdown is defined to be positive, takes the range [0, \\infty).
+    """
+    if returns.numel() == 0:
+        return torch.tensor(0.0, device=returns.device) # Handle empty tensor
+    
+    # Handle NaN values in returns if any
+    clean_returns = torch.nan_to_num(returns, nan=0.0)
+    
+    cum_returns = (clean_returns + 1).cumprod(dim=0)
+    peak = torch.cummax(cum_returns, dim=0).values # Use torch.cummax
+    
+    # Prevent division by zero or very small peaks
+    safe_peak = torch.clamp(peak, min=eps)
+    
+    drawdown = (peak - cum_returns) / safe_peak # Calculate drawdown relative to peak
+    max_drawdown = torch.max(drawdown)
+    
+    # Clip extreme values
+    max_drawdown = torch.clamp(max_drawdown, min=0.0, max=1.0)
+    
+    return max_drawdown
+
+def calculate_turnover(
+        new_weights: torch.Tensor,
+        prev_weights: torch.Tensor
+    ):
+    """Turnover is defined as the sum of absolute differences
+       between new and previous weights, divided by 2.
+       Takes the range [0, \\infty).
+    """
+    # Safe handling of NaN weights
+    new_weights_safe = torch.nan_to_num(new_weights, nan=1.0/new_weights.size(0))
+    prev_weights_safe = torch.nan_to_num(prev_weights, nan=1.0/prev_weights.size(0))
+    
+    turnover = torch.sum(torch.abs(new_weights_safe - prev_weights_safe)) / 2.0
+    
+    # Clip to reasonable values
+    turnover = torch.clamp(turnover, min=0.0, max=1.0)
+    
+    return turnover
+
+def calculate_objective_func(
+        returns: torch.Tensor,
+        risk_free_rate: torch.Tensor,
+        new_weights: torch.Tensor,
+        prev_weights: torch.Tensor,
+        alphas = [1.0, 1.0, 1.0] # Default alpha values (use floats)
+    ):
+    """Calculates the weighted objective function to be MINIMIZED.
+       Note: Sortino is maximized, drawdown and turnover are minimized.
+    """
+    sortino = calculate_sortino(returns, risk_free_rate)
+    max_drawdown = calculate_max_drawdown(returns)
+    turnover = calculate_turnover(new_weights, prev_weights)
+
+    # Apply more conservative scaling to individual components
+    sortino_scaled = torch.clamp(sortino, min=-10.0, max=10.0)
+    max_drawdown_scaled = torch.clamp(max_drawdown, min=0.0, max=1.0)
+    turnover_scaled = torch.clamp(turnover, min=0.0, max=1.0)
+
+    # Objective: Maximize Sortino, Minimize MaxDrawdown, Minimize Turnover
+    # We negate Sortino because the optimizer minimizes the objective.
+    objective = ( -alphas[0] * sortino_scaled +
+                   alphas[1] * max_drawdown_scaled +
+                   alphas[2] * turnover_scaled
+                )
+                
+    # Ensure objective is not NaN
+    if torch.isnan(objective):
+        print("Warning: NaN objective detected, using default value")
+        objective = torch.tensor(0.0, requires_grad=True)
+        
+    return objective
+
+# --- Main OGD Optimization Function ---
+def run_ogd(
+        data_df: pd.DataFrame,
+        window_size: int = 20, # Default hyperparameter
+        learning_rate: float = 0.01, # Default hyperparameter (REDUCED for stability)
+        alphas: list[float] = [1.0, 1.0, 0.1] # Default hyperparameter (reduced turnover weight slightly)
+    ):
+    """Runs the Online Gradient Descent (OGD) portfolio optimization.
+
+    Args:
+        data_df (pd.DataFrame): DataFrame with dates as index, ticker returns as columns,
+                                and a final column named 'rf' for the risk-free rate.
+        window_size (int): Lookback window for objective calculation.
+        learning_rate (float): Learning rate for the SGD optimizer.
+        alphas (list[float]): Weights for [Sortino, MaxDrawdown, Turnover] in the objective.
+
+    Returns:
+        tuple[pd.DataFrame, pd.DataFrame]:
+            - weights_df: DataFrame of daily portfolio weights (dates index, tickers columns).
+            - returns_series: Series of daily portfolio returns (dates index).
+    """
+    if data_df.empty or len(data_df) <= window_size:
+        print("Warning: Dataframe too small for OGD with the given window size.")
+        return pd.DataFrame(), pd.Series(dtype=float)
+
+    # --- Add data validation ---
+    # Check for NaN values in the input data
+    num_nan_values = data_df.isna().sum().sum()
+    if num_nan_values > 0:
+        print(f"WARNING: Input data contains {num_nan_values} NaN values. Filling with 0.")
+        data_df = data_df.fillna(0)
+    
+    # --- Print diagnostic info ---
+    print(f"Data shape: {data_df.shape}")
+    print(f"Sample data (first few rows):")
+    print(data_df.iloc[:3, :5])  # Show first 3 rows, first 5 columns
+    
+    # Check for any columns with all zeros or NaNs
+    zero_cols = (data_df == 0).all()
+    if zero_cols.any():
+        zero_count = zero_cols.sum()
+        print(f"WARNING: {zero_count} columns contain all zeros.")
+
+    # Separate stock returns and risk-free rate
+    returns = data_df.drop(columns=['rf'])
+    rf = data_df['rf']
+    tickers = returns.columns.tolist()
+    num_assets = len(tickers)
+    num_days = len(data_df)
+
+    # Convert to PyTorch tensors with explicit handling of NaN values
+    # Replace NaN values with 0 during tensor conversion
+    returns_tensor = torch.tensor(returns.fillna(0).values, dtype=torch.float32)
+    rf_tensor = torch.tensor(rf.fillna(0).values, dtype=torch.float32)
+    
+    # Check if returns_tensor contains any NaN values (after conversion)
+    if torch.isnan(returns_tensor).any():
+        print("WARNING: returns_tensor contains NaN values after conversion. Replacing with zeros.")
+        returns_tensor = torch.nan_to_num(returns_tensor, nan=0.0)
+
+    # Initialize weights as logits (will be converted to probabilities via softmax)
+    # Starting with zeros gives equal weights after softmax
+    weights = torch.zeros((num_assets,), requires_grad=True)
+
+    # Use Adam optimizer with reduced learning rate
+    optimizer = torch.optim.Adam([weights], lr=learning_rate)
+
+    # Logging structures
+    weights_log = torch.zeros((num_days, num_assets), dtype=torch.float32)
+    portfolio_returns_log = torch.zeros((num_days,), dtype=torch.float32)
+    rolling_portfolio_returns = [] # Store recent portfolio returns for objective calc
+
+    print(f"Starting OGD optimization for {num_days} days, {num_assets} assets...")
+    
+    # Initial weights distribution - equal weights
+    initial_weights = torch.full((num_assets,), 1.0/num_assets)
+    
+    for i in range(num_days):
+        # Check for NaN in weights and reset if needed
+        if torch.isnan(weights).any():
+            print(f"WARNING: NaN detected in weights at day {i}, resetting to uniform weights")
+            with torch.no_grad():
+                weights.copy_(torch.zeros((num_assets,)))
+                
+        # More restrictive clamping for numerical stability
+        clamped_weights = torch.clamp(weights, min=-5, max=5)
+        normalized_weights = torch.nn.functional.softmax(clamped_weights, dim=0)
+        
+        # Verify normalized weights are valid probabilities
+        if torch.isnan(normalized_weights).any() or torch.sum(normalized_weights) < 0.99:
+            print(f"WARNING: Invalid normalized weights at day {i}, using uniform weights")
+            normalized_weights = initial_weights.clone()
+
+        # Get daily asset returns and check for NaN values
+        daily_asset_returns = returns_tensor[i, :]
+        if torch.isnan(daily_asset_returns).any():
+            print(f"WARNING: NaN detected in asset returns at day {i}, replacing with zeros")
+            daily_asset_returns = torch.nan_to_num(daily_asset_returns, nan=0.0)
+        
+        # Calculate portfolio return for the current day
+        daily_portfolio_return = torch.dot(normalized_weights, daily_asset_returns)
+
+        # Check for NaN in portfolio return
+        if torch.isnan(daily_portfolio_return):
+            print(f"WARNING: NaN detected in portfolio return at day {i}, using zero")
+            daily_portfolio_return = torch.tensor(0.0)
+            
+            # Debug information - print sample weights and returns to diagnose the issue
+            if i < 5 or i % 50 == 0:  # Print for first few days and then occasionally
+                print(f"  Debug info for day {i}:")
+                print(f"  Sample weights: {normalized_weights[:5].tolist()}")
+                print(f"  Sample returns: {daily_asset_returns[:5].tolist()}")
+                print(f"  Sum of weights: {torch.sum(normalized_weights).item()}")
+                nan_count = torch.isnan(daily_asset_returns).sum().item()
+                print(f"  NaN count in returns: {nan_count}/{len(daily_asset_returns)}")
+
+        # Log weights and returns (use detach() to prevent tracking history)
+        weights_log[i, :] = normalized_weights.detach()
+        portfolio_returns_log[i] = daily_portfolio_return.detach()
+
+        # Add current return to rolling list for objective calculation
+        # Detach returns when storing to break gradient history
+        rolling_portfolio_returns.append(daily_portfolio_return.detach())
+
+        # --- Objective Calculation and Optimization Step ---
+        # Wait until we have enough data for the lookback window
+        if len(rolling_portfolio_returns) > window_size:
+            rolling_portfolio_returns.pop(0) # Remove oldest return
+
+            # Verify we don't have all zeros in our portfolio returns
+            all_zeros = all(r.item() == 0 for r in rolling_portfolio_returns)
+            if all_zeros:
+                print(f"WARNING: All portfolio returns are zero at day {i}, skipping optimization")
+                continue
+
+            # Prepare tensors for objective function
+            past_portfolio_returns = torch.stack(rolling_portfolio_returns[:-1] + [daily_portfolio_return])
+            
+            # Get corresponding risk-free rates for the window
+            start_idx = max(0, i - window_size + 1)
+            past_rf = rf_tensor[start_idx : i + 1]
+
+            # Get previous day's weights for turnover calculation
+            prev_weights = weights_log[i-1, :] if i > 0 else normalized_weights.detach()
+
+            # Zero out gradients before computation
+            optimizer.zero_grad()
+            
+            try:
+                # Recompute normalized weights for fresh gradient computation
+                clamped_weights = torch.clamp(weights, min=-5, max=5)
+                current_norm_weights = torch.nn.functional.softmax(clamped_weights, dim=0)
+                
+                # Recalculate today's return for gradient computation
+                current_return = torch.dot(current_norm_weights, daily_asset_returns)
+                
+                # Create list with detached historical returns + current gradient-connected return
+                historical_returns = rolling_portfolio_returns[:-1]
+                new_returns_list = historical_returns + [current_return]
+                past_portfolio_returns = torch.stack(new_returns_list)
+                
+                # Calculate objective with robust error handling
+                objective = calculate_objective_func(
+                    past_portfolio_returns,
+                    past_rf,
+                    current_norm_weights,
+                    prev_weights,
+                    alphas
+                )
+                
+                # Check if objective computation produced valid result
+                if not torch.isnan(objective):
+                    # Check objective is not just a default zero
+                    if objective.item() != 0.0 or i % 50 == 0:  # Allow some zeros through for logging
+                        # Compute and apply gradients
+                        objective.backward()
+                        
+                        # --- Enhanced Logging --- 
+                        log_interval = 50
+                        if (i + 1) % log_interval == 0 or num_days - (i + 1) < 5:
+                            print(f"\n--- Step {i+1}/{num_days} Log ---")
+                            print(f"  Objective: {objective.item():.6f}")
+                            
+                            # Log average gradient magnitude rather than all gradients
+                            if weights.grad is not None:
+                                avg_grad = torch.mean(torch.abs(weights.grad)).item()
+                                print(f"  Average Gradient Magnitude: {avg_grad:.6f}")
+                            
+                            # Record some sample weights before update
+                            weights_before = weights.detach().clone()
+                            
+                            # Apply gradient update
+                            optimizer.step()
+                            
+                            # Record weights after update
+                            weights_after = weights.detach().clone()
+                            weight_change = torch.sum(torch.abs(weights_after - weights_before)).item()
+                            print(f"  Weight Change (Sum Abs): {weight_change:.6f}")
+                            
+                            # Display a few normalized weights as a sample
+                            print(f"  Sample Normalized Weights: {[f'{w:.4f}' for w in normalized_weights[:5].tolist()]}")
+                        else:
+                            # Update weights without detailed logging
+                            optimizer.step()
+                        
+                        # Apply gradient clipping after optimizer step
+                        with torch.no_grad():
+                            if weights.grad is not None and torch.isnan(weights.grad).any():
+                                print(f"  WARNING: NaN gradient detected at day {i}, zeroing gradients")
+                                weights.grad.zero_()
+                    else:
+                        print(f"  WARNING: Zero objective at day {i}, skipping gradient update")
+                else:
+                    print(f"  WARNING: NaN objective at day {i}, skipping gradient update")
+                    
+            except Exception as e:
+                print(f"  Optimization error at day {i}: {e}")
+                # Skip this day rather than propagating errors
+
+    print("OGD optimization finished.")
+    
+    # Final check for validity of results
+    if torch.isnan(weights_log).any():
+        print("WARNING: Final weights contain NaN values")
+        weights_log = torch.nan_to_num(weights_log, nan=1.0/num_assets)
+    
+    if torch.isnan(portfolio_returns_log).any():
+        print("WARNING: Final portfolio returns contain NaN values")
+        portfolio_returns_log = torch.nan_to_num(portfolio_returns_log, nan=0.0)
+
+    # Convert logs back to pandas DataFrames/Series with original index
+    weights_df = pd.DataFrame(weights_log.numpy(), index=data_df.index, columns=tickers)
+    returns_series = pd.Series(portfolio_returns_log.numpy(), index=data_df.index, name="PortfolioReturn")
+
+    return weights_df, returns_series 

requirements.txt

@@ -0,0 +1,11 @@
+torch
+pandas
+matplotlib
+yfinance
+numpy
+seaborn
+gradio>=3.50.0
+fastapi>=0.95.0
+uvicorn>=0.22.0
+jinja2>=3.1.2
+python-multipart>=0.0.6 

utils.py

@@ -0,0 +1,119 @@
+import pandas as pd
+import os
+from datetime import datetime # Import datetime
+
+# Define data path relative to this file's location
+DATA_DIR = os.path.join(os.path.dirname(__file__), 'data')
+STOCK_DATA_PATH = os.path.join(DATA_DIR, "stock_data.csv")
+RF_DATA_PATH = os.path.join(DATA_DIR, "risk_free_data.csv")
+TICKERS_PATH = os.path.join(DATA_DIR, "tickers_by_sector.json") # Added for potential future use
+
+def load_data():
+    """Loads stock and risk-free rate data from CSV files.
+       Stock data is pivoted to wide format (date index, ticker columns).
+       Handles duplicate date/ticker entries by averaging returns.
+    """
+    try:
+        # Load stock data (long format)
+        stock_data_long = pd.read_csv(STOCK_DATA_PATH, parse_dates=['date']) # Use lowercase 'date'
+
+        # Check for duplicates before pivoting
+        duplicates = stock_data_long[stock_data_long.duplicated(subset=['date', 'ticker'], keep=False)]
+        if not duplicates.empty:
+            print(f"Warning: Found {len(duplicates)} duplicate date/ticker entries in stock_data.csv.")
+            print("Aggregating returns using 'mean'. First few duplicates:")
+            print(duplicates.head())
+
+        # Pivot to wide format using pivot_table with mean aggregation
+        stock_data_df = stock_data_long.pivot_table(
+            index='date', 
+            columns='ticker', 
+            values='ret', 
+            aggfunc='mean' # Aggregate duplicates by taking the mean return
+        )
+
+        # Load risk-free data
+        # Use lowercase 'date', set as index directly
+        rf_data_df = pd.read_csv(RF_DATA_PATH, parse_dates=['date'], index_col='date')
+
+        print("Data loaded. Stock data pivoted successfully (duplicates averaged).")
+        return stock_data_df, rf_data_df
+    except FileNotFoundError as e:
+        print(f"Error loading data: {e}")
+        print(f"Please ensure '{STOCK_DATA_PATH}' and '{RF_DATA_PATH}' exist.")
+        return None, None
+    except KeyError as e:
+        print(f"Error processing data: Missing expected column - {e}")
+        print("Please ensure CSV files have 'date', 'ticker', 'ret' (for stock) and 'date', 'rf' (for risk-free)." )
+        return None, None
+    except Exception as e: # Catch other potential errors during pivoting etc.
+        print(f"An unexpected error occurred during data loading: {e}")
+        return None, None
+
+# --- Data filtering function (should work with pivoted data) ---
+def filter_data(stock_df, rf_df, start_date_str=None, end_date_str=None, tickers=None):
+    """Filters stock (wide format) and risk-free data based on date range and tickers.
+
+    Args:
+        stock_df (pd.DataFrame): DataFrame with stock returns (Date index, tickers as columns).
+        rf_df (pd.DataFrame): DataFrame with risk-free rates (Date index, 'rf' column).
+        start_date_str (str, optional): Start date in 'YYYY-MM-DD' format. Defaults to None (start of data).
+        end_date_str (str, optional): End date in 'YYYY-MM-DD' format. Defaults to None (end of data).
+        tickers (list, optional): List of ticker symbols to include. Defaults to None (all tickers).
+
+    Returns:
+        pd.DataFrame: Combined DataFrame with filtered stock returns and risk-free rate ('rf' column),
+                      or None if filtering results in an empty DataFrame.
+    """
+    filtered_stock_df = stock_df.copy()
+    filtered_rf_df = rf_df.copy()
+
+    # Convert date strings to datetime objects
+    start_date = pd.to_datetime(start_date_str) if start_date_str else None
+    end_date = pd.to_datetime(end_date_str) if end_date_str else None
+
+    # Filter by date
+    if start_date:
+        filtered_stock_df = filtered_stock_df[filtered_stock_df.index >= start_date]
+        filtered_rf_df = filtered_rf_df[filtered_rf_df.index >= start_date]
+    if end_date:
+        filtered_stock_df = filtered_stock_df[filtered_stock_df.index <= end_date]
+        filtered_rf_df = filtered_rf_df[filtered_rf_df.index <= end_date]
+
+    # Filter by tickers
+    if tickers:
+        # Ensure only requested tickers that exist in the dataframe are selected
+        valid_tickers = [t for t in tickers if t in filtered_stock_df.columns]
+        if not valid_tickers:
+            print(f"Warning: None of the requested tickers {tickers} found in the data.")
+            return None
+        # Select only valid tickers that exist in columns
+        filtered_stock_df = filtered_stock_df[valid_tickers]
+    else:
+        # If no tickers specified, use all available tickers from the wide format
+        valid_tickers = filtered_stock_df.columns.tolist()
+
+    # Combine stock data and risk-free rate
+    combined_df = filtered_stock_df.join(filtered_rf_df, how='inner') # Use inner join to ensure dates match
+
+    # Ensure 'rf' column exists (already correct based on rf_data.csv header)
+    if 'rf' not in combined_df.columns:
+        print("Warning: Risk-free rate column ('rf') not found after join.")
+        # Attempt rename (as fallback, though likely unnecessary now)
+        if 'Daily Treasury Yield Curve Rate' in combined_df.columns:
+            print("Renaming 'Daily Treasury Yield Curve Rate' to 'rf'")
+            combined_df = combined_df.rename(columns={'Daily Treasury Yield Curve Rate': 'rf'})
+        else:
+            print("Could not find 'rf' or alternative name.")
+            return None
+
+    # Reorder columns to have tickers first, then 'rf'
+    # Ensure 'rf' is included if it exists
+    final_columns = valid_tickers + [col for col in ['rf'] if col in combined_df.columns]
+    combined_df = combined_df[final_columns]
+
+    if combined_df.empty:
+        print("Warning: Filtering resulted in an empty DataFrame.")
+        return None
+
+    return combined_df