LLM-Powered Black-Litterman Portfolio Optimization

An advanced portfolio optimization system that leverages Large Language Models (LLMs) to analyze multi-source financial data and generate investment views for Black-Litterman portfolio optimization.

---

Documentation Index

---

Overview

This system combines:

• Multi-Source Data Analysis: Political news, FOMC minutes, research reports, Bloomberg headlines
• LLM-Powered Views Generation: Finance-Llama-8B generates structured investment views from unstructured data
• Black-Litterman Optimization: Risk-aware portfolio construction with confidence-weighted views
• Quarterly Rebalancing: Systematic portfolio updates with transaction cost modeling
• Comprehensive Backtesting: Performance analysis with statistical significance testing

Architecture

System Workflow

The complete system workflow is visualized in the following diagrams:

High-Level Overview (output/workflow_diagram.png):

• Shows the complete data flow from inputs through processing to outputs
• Includes hyperparameter optimization loop
• Color-coded by component type (inputs, processes, outputs)

Detailed Component View (output/workflow_diagram_detailed.png):

• Component-level process flow with sub-processes
• Shows internal processing details for each major step
• Includes method calls and data transformations

For more information about generating and customizing these diagrams, see WORKFLOW_DIAGRAM_README.md.

Reference: See RESULTS_SUMMARY.md for detailed performance analysis and backtesting results.

Text Flow

Data Sources → Data Pipeline → LLM Analysis → Views Matrix → Black-Litterman → Portfolio → Backtesting → Reports

Components

1. Data Pipeline (data/)

   • loader.py: Load all data sources (news, FOMC, research, stock prices)
   • formatter.py: Format data for LLM consumption
   • stock_processor.py: Process stock data for optimization

2. LLM Analysis (llm/)

   • analyzer.py: Main LLM interface (Finance-Llama-8B model)
   • prompts.py: System and user prompts optimized for Llama instruction format
   • views_parser.py: Parse and validate LLM output with robust JSON extraction

3. Optimization (optimization/)

   • portfolio_optimizer.py: Portfolio optimization wrapper
   • views_converter.py: Convert LLM views to P, Q, Ω matrices
   • Uses existing BlackLitterman/BlackLitterman.py implementation

4. Backtesting (backtesting/)

   • backtester.py: Simulate portfolio performance
   • metrics.py: Calculate performance metrics
   • visualization.py: Generate charts

5. Reporting (reports/)

   • report_generator.py: Create comprehensive reports

Installation

# Install dependencies
pip install -r requirements.txt

# For local LLM (Finance-Llama-8B)
pip install transformers torch accelerate

LLM Model

This system uses Finance-Llama-8B (tarun7r/Finance-Llama-8B), a Llama-based model fine-tuned for financial analysis:

The model generates structured investment views with expected returns, confidence levels, and reasoning for each sector ETF.

Reference: See HYPERPARAMETER_GUIDE.md for temperature tuning and other LLM parameter optimization.

Usage

Quick Start

Run the complete pipeline with default settings (simulated LLM):

python main.py

Advanced Usage

# Use Finance-Llama-8B local model (default)
python main.py --llm-type finance-llama

# Use simulated mode (fallback, for testing)
python main.py --llm-type simulated

# Process specific quarters
python main.py --quarters Q1_2024 Q2_2024 Q3_2024

# Skip chart generation
python main.py --skip-charts

LLM Options

1. finance-llama (default): tarun7r/Finance-Llama-8B local model

   • Local Llama-based model, no API required
   • Requires transformers and torch packages
   • Runs locally (GPU recommended, but works on CPU)
   • Financial domain-specific fine-tuned Llama 8B
   • Model downloads automatically on first use (~16GB)
   • Better instruction-following for structured JSON output

2. simulated: Rule-based views generation (fallback only)

   • Used automatically if Finance-Llama fails to load
   • Fast and deterministic
   • Good for testing/debugging

Data Sources

The system uses your existing collected data:

• Political News: political_news_data/ (GDELT articles) — See README_political_news.md for collection details
• FOMC Minutes: Finance and Investments Group Final Project/FOMC data/
• Investment Research: Finance and Investments Group Final Project/Investor Research/
• Bloomberg Headlines: Finance and Investments Group Final Project/Bloomberg Headlines/
• Stock Data: Finance and Investments Group Final Project/Stock Data.xlsx

Target ETFs

• XLK - Technology Select Sector SPDR
• XLY - Consumer Discretionary Select Sector SPDR
• ITA - iShares U.S. Aerospace & Defense ETF
• XLE - Energy Select Sector SPDR
• XLV - Health Care Select Sector SPDR
• XLF - Financial Select Sector SPDR

Output

After running the pipeline, find results in:

• output/portfolios/: Quarterly portfolio allocations (JSON)
• output/views/: LLM-generated investment views (JSON)
• output/charts/: Performance visualizations (PNG)
• output/reports/: Full analysis report (TXT, JSON)
• output/workflow_diagram.png: System workflow diagram (high-level)
• output/workflow_diagram_detailed.png: Detailed component workflow diagram

Reference: See RESULTS_SUMMARY.md for a detailed analysis of the backtesting results, performance metrics, and quarterly breakdowns.

Key Files

Configuration

• config.yaml: System configuration parameters
• requirements.txt: Python dependencies

Main Pipeline

• main.py: End-to-end execution pipeline

Existing BlackLitterman

• BlackLitterman/BlackLitterman.py: Core optimization model (existing)

Methodology

1. Data Loading

For each quarter, the system loads:

• Political news articles related to each sector (GDELT)
• FOMC meeting minutes for monetary policy signals
• Quarterly investment research reports (PDF analysis)
• Bloomberg headlines for market sentiment
• Historical stock prices for covariance calculation (configurable lookback period)

Data Quality Checks:

• Validates minimum data points required (default: 60 days)
• Handles missing values with forward/backward fill
• Checks for ticker coverage completeness

2. LLM Analysis

The LLM analyzes all data sources using a structured framework and generates calibrated investment views:

Analysis Framework:

• Multi-Source Integration: Synthesizes signals from FOMC, research, news, and technical indicators
• Confidence Calibration: Uses calibrated confidence levels (0-100) that reflect actual uncertainty
• View Types: Supports both absolute views (expected returns) and relative views (outperformance)

View Generation:

{
  "quarter": "Q1_2024",
  "views": [
    {
      "type": "absolute",
      "ticker": "XLK",
      "expected_return": 0.03,
      "confidence": 75,
      "reasoning": "Strong AI momentum, favorable Fed policy..."
    },
    {
      "type": "relative",
      "ticker1": "XLK",
      "ticker2": "XLY",
      "expected_outperformance": 0.05,
      "confidence": 80,
      "reasoning": "Technology expected to outperform consumer discretionary..."
    }
  ]
}

Confidence Calibration Principles:

• 90-100: Very high confidence (multiple aligned sources, low uncertainty)
• 70-89: High confidence (2-3 consistent sources, moderate uncertainty)
• 50-69: Moderate confidence (mixed signals, higher uncertainty)
• 30-49: Low confidence (limited/conflicting data)
• 0-29: Very low confidence (minimal data, high uncertainty)

3. Views Matrix Construction

Convert LLM views to Black-Litterman matrices with improved uncertainty modeling:

• P Matrix: View specification matrix

  • Absolute views: P[i, ticker_idx] = 1.0
  • Relative views: P[i, ticker1_idx] = 1.0, P[i, ticker2_idx] = -1.0

• Q Vector: Expected returns/outperformance vector

  • Absolute views: Expected return for ticker
  • Relative views: Expected outperformance (ticker1 - ticker2)

• Ω Matrix: View uncertainty matrix (diagonal)

  • Improved Mapping: Uses exponential function for confidence-to-uncertainty conversion
  • Formula: uncertainty = base_variance * exp(-4.6 * confidence/100)
  • Ensures high confidence views have exponentially lower uncertainty
  • Bounded between 0.0001 and 2×base_variance for numerical stability

4. Black-Litterman Optimization

Combine market equilibrium with LLM views:

Prior Distribution:

• Implied equilibrium returns from market weights (equal-weight default)
• Covariance matrix from historical returns (configurable lookback)

Posterior Distribution:

• Combines prior with LLM views using Bayesian updating
• Views weighted by confidence (via Ω matrix)
• Hyperparameters: risk_aversion, tau_for_covariance, tau_omega, relative_confidence

Optimization:

• Objective: Maximize Sharpe ratio
• Constraints: Portfolio weights sum to 1.0
• Bounds: Configurable (long-only or long-short)
• Solver: SLSQP with convergence checks

Validation:

• Checks for NaN/Inf in posterior returns and covariance
• Validates optimization convergence
• Falls back to equal weights if optimization fails

5. Backtesting

Simulate quarterly rebalancing with realistic transaction costs:

Simulation Process:

• Start with initial capital
• Apply optimized weights each quarter
• Calculate actual returns using historical data
• Transaction Costs: Applied based on portfolio turnover
  • Default: 10 bps (0.1%) transaction cost
  • Default: 5 bps (0.05%) slippage cost
  • Total cost = turnover × (transaction_cost + slippage)
• Compare to equal-weight benchmark

Rebalancing Logic:

• Quarterly rebalancing at quarter boundaries
• Tracks portfolio value over time
• Records transaction costs per quarter
• Maintains full history for analysis

6. Performance Analysis

Calculate comprehensive metrics with statistical significance testing:

Return Metrics:

• Total return, annualized return (CAGR)
• Quarterly returns breakdown
• Win rate (percentage of positive quarters)

Risk Metrics:

• Volatility (annualized)
• Maximum drawdown
• Value at Risk (VaR) at 95% confidence
• Conditional VaR (CVaR/Expected Shortfall) at 95%

Risk-Adjusted Metrics:

• Sharpe ratio (excess return / volatility)
• Sortino ratio (downside deviation)
• Calmar ratio (return / max drawdown)
• Information ratio (active return / tracking error)

Statistical Significance:

• T-tests: Tests if strategy outperformance is statistically significant
  • One-sample t-test on active returns
  • Paired t-test comparing strategy vs benchmark
• Sharpe Ratio Test: Jobson-Korkie test for Sharpe ratio difference
  • Tests if strategy Sharpe ratio is significantly higher than benchmark
• Confidence Intervals: 95% confidence intervals for mean active return
• Significance Flags: Indicates significance at 95% and 99% levels

Turnover Analysis:

• Average portfolio turnover per quarter
• Tracks rebalancing frequency and magnitude

Performance Metrics

The system calculates:

• Return Metrics: Total return, annualized return, quarterly returns
• Risk Metrics: Volatility, VaR, CVaR, maximum drawdown
• Risk-Adjusted: Sharpe ratio, Sortino ratio, Calmar ratio
• Relative: Information ratio, outperformance vs benchmark
• Trading: Average turnover per quarter

Reference: See RESULTS_SUMMARY.md for actual performance results showing +47.3% total return vs +32.4% benchmark over 7 quarters.

Visualizations

Generated charts include:

• Cumulative returns (strategy vs benchmark)
• Quarterly returns comparison
• Portfolio allocation heatmap
• Drawdown over time
• Risk-return scatter plot

Customization

Adjust Black-Litterman Parameters

Edit config.yaml:

black_litterman:
  risk_aversion: 2.5      # Higher = more conservative
  tau_for_covariance: 0.025  # Prior uncertainty
  tau_omega: 0.05         # Views uncertainty

Change LLM Prompts

Edit llm/prompts.py to customize:

• System prompt (analyst persona)
• User prompt template (data formatting)

Modify Optimization Constraints

Edit optimization/portfolio_optimizer.py:

• Adjust weight bounds
• Add sector constraints
• Modify objective function

Hyperparameter Optimization

Run hyperparameter optimization to find best settings:

# Random search (recommended)
python hyperparameter_optimization.py --method random --n-trials 20

# Grid search
python hyperparameter_optimization.py --method grid --max-combinations 50

Results are saved to output/hyperparameter_optimization/ with:

• JSON files with all results and analysis
• Automatic visualization generation

Reference: See HYPERPARAMETER_GUIDE.md for the complete guide including temperature tuning (0.3-0.9 range), Black-Litterman parameter optimization, Bayesian and Optuna ML-based optimization methods, and best practices.

Visualize Optimization Results

Generate graphs and analysis from optimization results:

# Visualize latest results
python hyperparameter_visualization.py

# Visualize specific results
python hyperparameter_visualization.py --results-file path/to/results.json --analysis-file path/to/analysis.json

Creates visualizations including:

• Hyperparameter importance analysis
• Parameter vs metric relationships
• Correlation heatmaps
• Metric distributions
• 2D hyperparameter spaces
• Pareto frontier (risk vs return)
• Top configurations comparison

Project Structure

project/
├── main.py                          # Main execution pipeline
├── config.yaml                      # System configuration (hyperparameters, paths, etc.)
├── config.yaml.backup               # Backup configuration
├── config_loader.py                 # Configuration loader with defaults
├── requirements.txt                 # Python dependencies
├── README.md                        # This file
│
├── Core Modules/
│   │
│   ├── data/                        # Data loading and processing
│   │   ├── __init__.py
│   │   ├── loader.py                # Multi-source data loader (news, FOMC, research, stocks)
│   │   ├── formatter.py             # Format data for LLM consumption
│   │   └── stock_processor.py       # Process stock prices and calculate returns
│   │
│   ├── llm/                         # LLM-powered analysis
│   │   ├── __init__.py
│   │   ├── analyzer.py              # LLM interface (supports multiple models)
│   │   ├── prompts.py               # System and user prompt templates
│   │   └── views_parser.py          # Parse and validate LLM-generated views
│   │
│   ├── optimization/                # Portfolio optimization
│   │   ├── __init__.py
│   │   ├── portfolio_optimizer.py   # Black-Litterman optimization wrapper
│   │   └── views_converter.py       # Convert LLM views to P, Q, Ω matrices
│   │
│   ├── backtesting/                 # Performance analysis and simulation
│   │   ├── __init__.py
│   │   ├── backtester.py            # Simulate portfolio performance over time
│   │   ├── metrics.py               # Calculate performance metrics (Sharpe, Sortino, etc.)
│   │   └── visualization.py        # Generate performance charts
│   │
│   ├── reports/                     # Report generation
│   │   ├── __init__.py
│   │   └── report_generator.py      # Generate comprehensive analysis reports
│   │
│   └── BlackLitterman/              # Existing Black-Litterman implementation
│       ├── BlackLitterman.py       # Core optimization algorithm
│       ├── BlackLittermanData.csv  # Sample data
│       └── main.py                  # BL standalone example
│
├── Analysis & Optimization/
│   ├── hyperparameter_optimization.py    # Grid/random/ML-based hyperparameter search
│   ├── hyperparameter_visualization.py   # Visualize optimization results
│   ├── update_config_from_optimization.py # Update config with optimal params
│   └── HYPERPARAMETER_GUIDE.md           # Guide for hyperparameter tuning
│
├── Utilities & Scripts/
│   ├── collect_multiple_quarters.py      # Batch data collection utility
│   ├── political_news_collector.py       # GDELT news collection script
│   ├── workflow_diagram.py               # Generate workflow diagrams
│   ├── test.py                          # Test scripts
│   └── llm.py                           # Legacy LLM script (if exists)
│
├── Documentation/
│   ├── RESULTS_SUMMARY.md               # Performance results and analysis
│   ├── HYPERPARAMETER_GUIDE.md          # Complete hyperparameter optimization guide
│   ├── PROJECT_PRESENTATION_SUMMARY.md  # Comprehensive presentation summary
│   ├── README_political_news.md          # Political news data documentation
│   └── WORKFLOW_DIAGRAM_README.md        # Workflow diagram generation guide
│
├── Data Sources/
│   └── Finance and Investments Group Final Project/
│       ├── Bloomberg Headlines/          # Bloomberg sector headlines
│       ├── FOMC data/                    # Federal Reserve meeting minutes (PDFs)
│       ├── Investor Research/           # Quarterly research reports (PDFs)
│       ├── political_news_data/         # GDELT political news (CSV/JSON)
│       └── Stock Data.xlsx              # Historical stock prices
│
├── Notebooks/                            # Jupyter notebooks for exploration
│   ├── Data_exploration.ipynb           # Data exploration and analysis
│   └── gdelt.ipynb                      # GDELT data analysis
│
└── output/                               # Generated results (created at runtime)
    ├── portfolios/                       # Quarterly portfolio allocations (JSON)
    ├── views/                            # LLM-generated investment views (JSON)
    ├── charts/                           # Performance visualizations (PNG)
    │   ├── cumulative_returns.png
    │   ├── quarterly_returns.png
    │   ├── allocation_heatmap.png
    │   ├── drawdown.png
    │   └── risk_return.png
    ├── reports/                          # Comprehensive analysis reports
    │   ├── full_report.txt
    │   └── full_report.json
    ├── hyperparameter_optimization/      # Hyperparameter search results
    │   ├── results_*.json                # Raw optimization results
    │   ├── analysis_*.json               # Statistical analysis
    │   └── visualizations/               # Optimization visualizations
    ├── workflow_diagram.png              # High-level workflow diagram
    └── workflow_diagram_detailed.png     # Detailed component diagram

Key File Descriptions

Core Pipeline:

• main.py: Orchestrates the complete pipeline from data loading through backtesting
• config.yaml: Centralized configuration for all system parameters
• config_loader.py: Handles configuration loading with sensible defaults

Data Processing:

• data/loader.py: Loads and integrates multiple data sources (news, FOMC, research, stocks)
• data/formatter.py: Formats unstructured data for LLM analysis
• data/stock_processor.py: Processes historical prices and calculates returns/covariance

LLM Integration:

• llm/analyzer.py: Main interface to Finance-Llama-8B model with caching
• llm/prompts.py: Llama instruction-format prompts optimized for JSON output
• llm/views_parser.py: Robust JSON extraction with fallback parsing

Optimization:

• optimization/portfolio_optimizer.py: Wraps Black-Litterman with constraints and objectives
• optimization/views_converter.py: Converts LLM views to mathematical matrices

Analysis:

• backtesting/backtester.py: Simulates portfolio performance with quarterly rebalancing
• backtesting/metrics.py: Calculates comprehensive performance metrics
• backtesting/visualization.py: Generates publication-quality charts
• reports/report_generator.py: Creates detailed analysis reports

Hyperparameter Optimization:

• hyperparameter_optimization.py: Systematic search for optimal parameters
• hyperparameter_visualization.py: Visualizes optimization results and parameter importance

Analysis & Research

Reference: For a complete research-ready summary, see PROJECT_PRESENTATION_SUMMARY.md, which includes methodology, results, and innovation highlights.

Conducting Comprehensive Analysis

This system provides multiple layers of analysis for rigorous research:

1. Baseline Performance Analysis

Start with the standard pipeline to establish baseline performance:

python main.py

This generates:

• Performance Metrics: Total return, Sharpe ratio, maximum drawdown, VaR
• Quarterly Breakdown: Performance by quarter to identify patterns
• Allocation History: How portfolio weights evolved over time
• Benchmark Comparison: Strategy vs equal-weight benchmark

Key Files to Review:

• output/reports/full_report.txt: Comprehensive text report
• output/reports/full_report.json: Structured data for further analysis
• output/charts/: Visual performance analysis

2. Hyperparameter Sensitivity Analysis

Understand how parameters affect performance:

# Run random search to explore parameter space
python hyperparameter_optimization.py --method random --n-trials 50

# Visualize results
python hyperparameter_visualization.py

Analysis Questions:

• Which parameters have the most impact on Sharpe ratio?
• Is there a trade-off between return and risk?
• Are optimal parameters stable across different time periods?
• What's the sensitivity to risk aversion parameter?

Output Files:

• output/hyperparameter_optimization/results_*.json: Raw results
• output/hyperparameter_optimization/analysis_*.json: Statistical analysis
• output/hyperparameter_optimization/visualizations/: Parameter importance plots

3. LLM Views Analysis

Examine the quality and consistency of LLM-generated views:

# Review generated views
cat output/views/Q1_2024_views.json

Analysis Dimensions:

• Consistency: Do views align with actual market movements?
• Confidence Calibration: Are high-confidence views more accurate?
• Sector Coverage: Are all sectors receiving adequate analysis?
• Reasoning Quality: Do explanations make financial sense?

Files:

• output/views/*.json: LLM-generated views with reasoning
• output/llm_responses/: Raw LLM responses (if enabled in config)

4. Data Source Contribution Analysis

Understand which data sources drive decisions:

Method:

1. Run pipeline with different data source combinations
2. Compare resulting views and allocations
3. Measure contribution of each source (news, FOMC, research, Bloomberg)

Implementation:

• Modify data/loader.py to selectively load sources
• Compare views generated with/without each source
• Analyze correlation between data source signals and performance

Reference: See README_political_news.md for details on GDELT political news collection and integration.

5. Temporal Analysis

Examine performance across different market regimes:

Questions:

• How did the strategy perform in Q1 2024 vs Q3 2024?
• Were there specific quarters with exceptional performance?
• Did the strategy adapt well to changing market conditions?
• What was the impact of major events (FOMC decisions, etc.)?

Tools:

• output/charts/quarterly_returns.png: Quarter-by-quarter comparison
• output/reports/full_report.txt: Quarterly breakdown section
• Custom analysis using backtesting/metrics.py functions

6. Risk-Return Analysis

Deep dive into risk characteristics:

Metrics to Analyze:

• Volatility: How stable are returns?
• Drawdowns: Maximum and average drawdown periods
• Tail Risk: VaR and CVaR at different confidence levels
• Risk-Adjusted Returns: Sharpe, Sortino, Calmar ratios

Visualizations:

• output/charts/risk_return.png: Risk-return scatter
• output/charts/drawdown.png: Drawdown over time
• Custom analysis using backtesting/metrics.py

7. Portfolio Composition Analysis

Understand allocation patterns:

Questions:

• Which sectors received consistent overweight/underweight?
• How did allocations change over time?
• Were there any extreme positions (very high/low weights)?
• Did allocations align with LLM views?

Files:

• output/portfolios/*.json: Quarterly allocations
• output/charts/allocation_heatmap.png: Visual allocation history

8. Robustness Testing

Test the stability of results:

Tests:

• Parameter Robustness: Vary parameters within reasonable ranges
• Data Robustness: Test with different lookback periods
• Model Robustness: Compare Finance-Llama vs simulated mode
• Constraint Robustness: Test long-only vs long-short strategies

Implementation:

# Test different lookback periods
# Edit config.yaml: data.lookback_days
python main.py

# Test long-only vs long-short
python main.py --long-only
python main.py --allow-shorts

# Compare LLM vs simulated
python main.py --llm-type finance-llama
python main.py --llm-type simulated

9. Comparative Analysis

Compare against alternative approaches:

Baselines:

• Equal-weight portfolio (already included)
• Market-cap weighted
• Risk-parity
• Traditional Black-Litterman (without LLM views)

Implementation:

• Modify backtesting/backtester.py to add alternative strategies
• Compare metrics side-by-side

10. Statistical Significance Testing

Validate that results are statistically meaningful:

Tests:

• T-tests: Compare strategy returns vs benchmark
• Bootstrap Analysis: Confidence intervals for metrics
• Monte Carlo Simulation: Distribution of outcomes
• Out-of-Sample Testing: Walk-forward validation

Tools:

• Use backtesting/metrics.py as foundation
• Extend with statistical libraries (scipy, statsmodels)

Analysis Workflow Recommendations

1. Start Broad: Run full pipeline, review comprehensive report
2. Identify Patterns: Look for interesting trends in charts
3. Deep Dive: Focus on specific aspects (e.g., Q2 2024 performance)
4. Hypothesis Testing: Form hypotheses, test with parameter variations
5. Validate: Cross-check findings across multiple metrics
6. Document: Record insights and methodology in analysis notes

Research Questions to Explore

• LLM Effectiveness: Do LLM-generated views add value over market equilibrium?
• Data Source Value: Which data sources contribute most to performance?
• Parameter Sensitivity: How sensitive is performance to hyperparameters?
• Market Regime Adaptation: Does the strategy adapt to different market conditions?
• View Quality: Are high-confidence views more accurate?
• Sector Analysis: Which sectors benefit most from LLM analysis?

Extending Analysis

The modular structure allows easy extension:

• Custom Metrics: Add to backtesting/metrics.py
• Custom Visualizations: Extend backtesting/visualization.py
• Custom Reports: Modify reports/report_generator.py
• Alternative Strategies: Add to backtesting/backtester.py
• Data Sources: Extend data/loader.py with new sources

Academic Use

This system was developed for MGT 6078 (Georgia Tech). Key features for academic analysis:

1. Novel Approach: Application of Finance-Llama-8B to Black-Litterman optimization
2. Reproducible: All code and data sources documented
3. Comprehensive: Full pipeline from data loading to backtested results
4. Benchmarked: Rigorous comparison to equal-weight baseline with statistical tests
5. Transparent: Clear methodology, hyperparameters, and limitations discussed
6. Modular: Easy to extend with new data sources, models, or strategies

Reference: See PROJECT_PRESENTATION_SUMMARY.md for a comprehensive project summary suitable for presentations, including executive summary, research questions, detailed system architecture, methodology, data source integration strategies, and technical implementation details.

Limitations

• LLM quality depends on model and prompts (Finance-Llama-8B used)
• Historical backtest (not forward-looking)
• Transaction costs partially modeled (10bps transaction + 5bps slippage)
• Limited to 7 quarters of data (Q1 2024 - Q3 2025)
• Assumes quarterly rebalancing optimal
• Requires ~16GB RAM/VRAM for Finance-Llama-8B model

Future Enhancements

• Real-time data integration via streaming APIs
• Alternative view formulations (relative views already supported)
• Enhanced transaction cost modeling with market impact
• Bayesian/Optuna hyperparameter optimization (already implemented)
• Ensemble of multiple LLMs for view consensus
• Sentiment analysis integration with FinBERT
• Factor models for risk decomposition
• Walk-forward validation for out-of-sample testing

License

Academic/Educational use for MGT 6078 course project.

Code Quality & Improvements

For guidance on improving code quality, testing, and best practices:

• Testing: Run pytest after installing dev dependencies (pip install -r requirements-dev.txt)
• Code Formatting: Use black . to format code, isort . to sort imports
• Linting: Use flake8 . to check code quality

Related Documentation

Contact & Resources

For questions about the system, refer to:

GitHub Repository: Elijah3756/MGT6078