Cross-Asset Correlation Analysis with Ollama: Complete Guide to Stocks, Bonds, and Crypto Integration

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pull the required model
ollama pull llama3.1

# requirements.txt
ollama==0.1.9
pandas==2.0.3
numpy==1.24.3
yfinance==0.2.18
matplotlib==3.7.1
seaborn==0.12.2
scipy==1.11.1
plotly==5.15.0

pip install -r requirements.txt

import ollama
import pandas as pd
import numpy as np
import yfinance as yf
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta

class CrossAssetAnalyzer:
    def __init__(self):
        self.client = ollama.Client()
        self.data = {}
        self.correlations = {}
    
    def analyze_with_ollama(self, prompt, data_context=""):
        """Use Ollama for financial analysis insights"""
        full_prompt = f"""
        {prompt}
        
        Data Context: {data_context}
        
        Provide specific, actionable insights for portfolio management.
        Focus on practical implications for asset allocation.
        """
        
        response = self.client.chat(
            model='llama3.1',
            messages=[{'role': 'user', 'content': full_prompt}]
        )
        
        return response['message']['content']

def collect_stock_data(self, symbols, period="2y"):
    """Collect stock price data using yfinance"""
    stock_data = {}
    
    for symbol in symbols:
        try:
            ticker = yf.Ticker(symbol)
            data = ticker.history(period=period)
            stock_data[symbol] = data['Close']
            print(f"✓ Collected data for {symbol}")
        except Exception as e:
            print(f"✗ Error collecting {symbol}: {e}")
    
    return pd.DataFrame(stock_data)

def collect_bond_data(self, bond_symbols, period="2y"):
    """Collect bond ETF and treasury data"""
    bond_data = {}
    
    # Common bond ETFs for cross-asset analysis
    default_bonds = {
        'TLT': 'Long-term Treasury',
        'IEF': 'Intermediate Treasury', 
        'LQD': 'Corporate Bonds',
        'HYG': 'High Yield Bonds',
        'TIP': 'TIPS'
    }
    
    symbols = bond_symbols or list(default_bonds.keys())
    
    for symbol in symbols:
        try:
            ticker = yf.Ticker(symbol)
            data = ticker.history(period=period)
            bond_data[symbol] = data['Close']
            print(f"✓ Collected bond data for {symbol}")
        except Exception as e:
            print(f"✗ Error collecting {symbol}: {e}")
    
    return pd.DataFrame(bond_data)

def collect_crypto_data(self, crypto_symbols, period="2y"):
    """Collect cryptocurrency price data"""
    crypto_data = {}
    
    # Add -USD suffix for Yahoo Finance crypto symbols
    formatted_symbols = [f"{symbol}-USD" for symbol in crypto_symbols]
    
    for original, formatted in zip(crypto_symbols, formatted_symbols):
        try:
            ticker = yf.Ticker(formatted)
            data = ticker.history(period=period)
            crypto_data[original] = data['Close']
            print(f"✓ Collected crypto data for {original}")
        except Exception as e:
            print(f"✗ Error collecting {original}: {e}")
    
    return pd.DataFrame(crypto_data)

def calculate_correlations(self, stock_data, bond_data, crypto_data):
    """Calculate comprehensive cross-asset correlations"""
    
    # Combine all asset data
    all_data = pd.concat([stock_data, bond_data, crypto_data], axis=1)
    
    # Calculate returns for correlation analysis
    returns = all_data.pct_change().dropna()
    
    # Calculate correlation matrix
    correlation_matrix = returns.corr()
    
    # Store results
    self.correlations['full_matrix'] = correlation_matrix
    self.correlations['returns'] = returns
    
    return correlation_matrix

def analyze_cross_asset_relationships(self):
    """Identify key cross-asset relationships"""
    corr_matrix = self.correlations['full_matrix']
    
    # Extract cross-asset correlations (non-diagonal elements)
    cross_correlations = []
    
    assets = corr_matrix.columns
    for i, asset1 in enumerate(assets):
        for j, asset2 in enumerate(assets):
            if i < j:  # Avoid duplicates
                correlation = corr_matrix.loc[asset1, asset2]
                cross_correlations.append({
                    'Asset1': asset1,
                    'Asset2': asset2,
                    'Correlation': correlation,
                    'Strength': self._correlation_strength(correlation)
                })
    
    return pd.DataFrame(cross_correlations).sort_values('Correlation', key=abs, ascending=False)

def _correlation_strength(self, correlation):
    """Classify correlation strength"""
    abs_corr = abs(correlation)
    if abs_corr >= 0.8:
        return 'Very Strong'
    elif abs_corr >= 0.6:
        return 'Strong'
    elif abs_corr >= 0.4:
        return 'Moderate'
    elif abs_corr >= 0.2:
        return 'Weak'
    else:
        return 'Very Weak'

def calculate_rolling_correlations(self, window=60):
    """Calculate rolling correlations to track relationship changes"""
    returns = self.correlations['returns']
    rolling_correlations = {}
    
    # Calculate rolling correlations for key asset pairs
    asset_pairs = [
        ('SPY', 'TLT'),  # Stocks vs Long-term Bonds
        ('SPY', 'BTC'),  # Stocks vs Bitcoin
        ('TLT', 'BTC'),  # Bonds vs Bitcoin
        ('SPY', 'GLD'),  # Stocks vs Gold
    ]
    
    for asset1, asset2 in asset_pairs:
        if asset1 in returns.columns and asset2 in returns.columns:
            rolling_corr = returns[asset1].rolling(window).corr(returns[asset2])
            rolling_correlations[f"{asset1}_vs_{asset2}"] = rolling_corr
    
    return pd.DataFrame(rolling_correlations)

def create_correlation_heatmap(self, save_path=None):
    """Create an enhanced correlation heatmap"""
    corr_matrix = self.correlations['full_matrix']
    
    # Create figure with custom size
    plt.figure(figsize=(12, 10))
    
    # Create heatmap with custom styling
    sns.heatmap(corr_matrix, 
                annot=True, 
                cmap='RdBu_r', 
                center=0,
                square=True,
                cbar_kws={'label': 'Correlation Coefficient'},
                fmt='.3f',
                linewidths=0.5)
    
    plt.title('Cross-Asset Correlation Matrix', fontsize=16, fontweight='bold')
    plt.xlabel('Assets', fontsize=12)
    plt.ylabel('Assets', fontsize=12)
    plt.tight_layout()
    
    if save_path:
        plt.savefig(save_path, dpi=300, bbox_inches='tight')
    
    plt.show()

def plot_rolling_correlations(self, save_path=None):
    """Plot rolling correlation trends over time"""
    rolling_corr = self.calculate_rolling_correlations()
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 10))
    axes = axes.flatten()
    
    for i, (pair, data) in enumerate(rolling_corr.items()):
        if i < 4:  # Limit to 4 subplots
            axes[i].plot(data.index, data.values, linewidth=2)
            axes[i].set_title(f'Rolling Correlation: {pair.replace("_vs_", " vs ")}')
            axes[i].set_ylabel('Correlation')
            axes[i].grid(True, alpha=0.3)
            axes[i].axhline(y=0, color='black', linestyle='--', alpha=0.5)
            
            # Add correlation strength bands
            axes[i].axhspan(0.6, 1.0, alpha=0.1, color='red', label='Strong Positive')
            axes[i].axhspan(-1.0, -0.6, alpha=0.1, color='blue', label='Strong Negative')
    
    plt.tight_layout()
    
    if save_path:
        plt.savefig(save_path, dpi=300, bbox_inches='tight')
    
    plt.show()

# Initialize the analyzer
analyzer = CrossAssetAnalyzer()

# Define asset universes
stocks = ['SPY', 'QQQ', 'IWM', 'EFA', 'EEM']  # Broad market ETFs
bonds = ['TLT', 'IEF', 'LQD', 'HYG', 'TIP']   # Bond ETFs
crypto = ['BTC', 'ETH', 'ADA', 'SOL']          # Major cryptocurrencies

# Collect data
print("Collecting market data...")
stock_data = analyzer.collect_stock_data(stocks)
bond_data = analyzer.collect_bond_data(bonds)
crypto_data = analyzer.collect_crypto_data(crypto)

# Calculate correlations
print("\nCalculating cross-asset correlations...")
correlation_matrix = analyzer.calculate_correlations(stock_data, bond_data, crypto_data)

# Analyze relationships
cross_asset_relationships = analyzer.analyze_cross_asset_relationships()
print("\nTop 10 Cross-Asset Relationships:")
print(cross_asset_relationships.head(10))

# Generate AI insights
market_context = f"""
Recent correlation analysis shows:
- Highest correlation: {cross_asset_relationships.iloc[0]['Asset1']} vs {cross_asset_relationships.iloc[0]['Asset2']} ({cross_asset_relationships.iloc[0]['Correlation']:.3f})
- Lowest correlation: {cross_asset_relationships.iloc[-1]['Asset1']} vs {cross_asset_relationships.iloc[-1]['Asset2']} ({cross_asset_relationships.iloc[-1]['Correlation']:.3f})
"""

ai_insights = analyzer.analyze_with_ollama(
    "Analyze these cross-asset correlations and provide portfolio diversification recommendations.",
    market_context
)

print("\n" + "="*50)
print("AI-POWERED INSIGHTS:")
print("="*50)
print(ai_insights)

def identify_correlation_regimes(self, threshold=0.5):
    """Identify periods of high/low correlation"""
    rolling_corr = self.calculate_rolling_correlations()
    
    regimes = {}
    for pair, correlations in rolling_corr.items():
        high_corr_periods = correlations[correlations.abs() > threshold]
        low_corr_periods = correlations[correlations.abs() <= threshold]
        
        regimes[pair] = {
            'high_correlation_periods': len(high_corr_periods),
            'low_correlation_periods': len(low_corr_periods),
            'avg_high_correlation': high_corr_periods.mean() if len(high_corr_periods) > 0 else 0,
            'avg_low_correlation': low_corr_periods.mean() if len(low_corr_periods) > 0 else 0
        }
    
    return regimes

from scipy import stats

def test_correlation_significance(self, alpha=0.05):
    """Test statistical significance of correlations"""
    returns = self.correlations['returns']
    n = len(returns)
    
    significant_correlations = []
    
    for i, asset1 in enumerate(returns.columns):
        for j, asset2 in enumerate(returns.columns):
            if i < j:
                corr = returns[asset1].corr(returns[asset2])
                
                # Calculate t-statistic
                t_stat = corr * np.sqrt((n - 2) / (1 - corr**2))
                p_value = 2 * (1 - stats.t.cdf(abs(t_stat), n - 2))
                
                if p_value < alpha:
                    significant_correlations.append({
                        'Asset1': asset1,
                        'Asset2': asset2,
                        'Correlation': corr,
                        'p_value': p_value,
                        'Significant': True
                    })
    
    return pd.DataFrame(significant_correlations)

def optimize_portfolio_allocation(self, risk_tolerance='moderate'):
    """Optimize portfolio allocation based on correlation analysis"""
    corr_matrix = self.correlations['full_matrix']
    returns = self.correlations['returns']
    
    # Calculate expected returns and volatility
    expected_returns = returns.mean() * 252  # Annualize
    volatility = returns.std() * np.sqrt(252)  # Annualize
    
    # Risk tolerance settings
    risk_settings = {
        'conservative': {'max_correlation': 0.3, 'max_volatility': 0.15},
        'moderate': {'max_correlation': 0.5, 'max_volatility': 0.20},
        'aggressive': {'max_correlation': 0.7, 'max_volatility': 0.30}
    }
    
    settings = risk_settings.get(risk_tolerance, risk_settings['moderate'])
    
    # Select assets based on correlation and volatility constraints
    selected_assets = []
    
    for asset in returns.columns:
        if volatility[asset] <= settings['max_volatility']:
            # Check correlation with already selected assets
            if not selected_assets:
                selected_assets.append(asset)
            else:
                max_corr = max([abs(corr_matrix.loc[asset, selected]) 
                              for selected in selected_assets])
                if max_corr <= settings['max_correlation']:
                    selected_assets.append(asset)
    
    # Equal weight allocation for simplicity
    allocation = {asset: 1.0/len(selected_assets) for asset in selected_assets}
    
    return {
        'allocation': allocation,
        'selected_assets': selected_assets,
        'expected_return': sum([allocation[asset] * expected_returns[asset] 
                              for asset in selected_assets]),
        'portfolio_volatility': self._calculate_portfolio_volatility(
            selected_assets, allocation, corr_matrix, volatility)
    }

def _calculate_portfolio_volatility(self, assets, weights, corr_matrix, volatility):
    """Calculate portfolio volatility using correlation matrix"""
    portfolio_var = 0
    
    for i, asset1 in enumerate(assets):
        for j, asset2 in enumerate(assets):
            portfolio_var += (weights[asset1] * weights[asset2] * 
                            volatility[asset1] * volatility[asset2] * 
                            corr_matrix.loc[asset1, asset2])
    
    return np.sqrt(portfolio_var)

def analyze_market_events_2024(self):
    """Analyze correlation changes during 2024 market events"""
    
    # Define key market events
    events = {
        '2024-01-15': 'AI Boom Peak',
        '2024-03-20': 'Fed Policy Shift',
        '2024-06-15': 'Crypto ETF Approval',
        '2024-09-10': 'Election Volatility',
        '2024-11-05': 'Post-Election Rally'
    }
    
    rolling_corr = self.calculate_rolling_correlations(window=30)
    
    event_analysis = {}
    
    for date, event in events.items():
        event_date = pd.to_datetime(date)
        
        # Get correlations around event date
        if event_date in rolling_corr.index:
            event_correlations = rolling_corr.loc[event_date]
            
            # Compare with previous month
            prev_month = event_date - pd.Timedelta(days=30)
            if prev_month in rolling_corr.index:
                prev_correlations = rolling_corr.loc[prev_month]
                correlation_change = event_correlations - prev_correlations
                
                event_analysis[event] = {
                    'date': date,
                    'correlations': event_correlations.to_dict(),
                    'changes': correlation_change.to_dict()
                }
    
    return event_analysis

def validate_data_quality(self):
    """Validate data quality for correlation analysis"""
    returns = self.correlations['returns']
    
    quality_report = {
        'missing_data': returns.isnull().sum(),
        'outliers': self._detect_outliers(returns),
        'data_sufficiency': len(returns) >= 252,  # At least 1 year of data
        'correlation_stability': self._test_correlation_stability()
    }
    
    return quality_report

def _detect_outliers(self, returns, threshold=3):
    """Detect outliers using z-score method"""
    outliers = {}
    
    for asset in returns.columns:
        z_scores = np.abs(stats.zscore(returns[asset].dropna()))
        outliers[asset] = (z_scores > threshold).sum()
    
    return outliers

def _test_correlation_stability(self):
    """Test correlation stability over time"""
    returns = self.correlations['returns']
    
    # Split data into two periods
    midpoint = len(returns) // 2
    first_half = returns.iloc[:midpoint]
    second_half = returns.iloc[midpoint:]
    
    corr1 = first_half.corr()
    corr2 = second_half.corr()
    
    # Calculate stability metric
    stability = np.corrcoef(corr1.values.flatten(), corr2.values.flatten())[0, 1]
    
    return stability

def optimize_analysis_performance(self):
    """Optimize correlation analysis for large datasets"""
    
    # Use efficient data structures
    returns = self.correlations['returns'].astype('float32')
    
    # Parallel processing for large correlation matrices
    from multiprocessing import Pool
    import functools
    
    def calculate_pairwise_correlation(asset_pair):
        asset1, asset2 = asset_pair
        return returns[asset1].corr(returns[asset2])
    
    # Generate all asset pairs
    assets = returns.columns
    asset_pairs = [(asset1, asset2) for i, asset1 in enumerate(assets) 
                   for j, asset2 in enumerate(assets) if i < j]
    
    # Calculate correlations in parallel
    with Pool() as pool:
        correlations = pool.map(calculate_pairwise_correlation, asset_pairs)
    
    # Reconstruct correlation matrix
    correlation_dict = dict(zip(asset_pairs, correlations))
    
    return correlation_dict

from flask import Flask, jsonify, request
import json

app = Flask(__name__)
analyzer = CrossAssetAnalyzer()

@app.route('/analyze_correlations', methods=['POST'])
def analyze_correlations_api():
    """API endpoint for correlation analysis"""
    
    data = request.json
    stocks = data.get('stocks', ['SPY', 'QQQ'])
    bonds = data.get('bonds', ['TLT', 'IEF'])
    crypto = data.get('crypto', ['BTC', 'ETH'])
    
    try:
        # Collect data
        stock_data = analyzer.collect_stock_data(stocks)
        bond_data = analyzer.collect_bond_data(bonds)
        crypto_data = analyzer.collect_crypto_data(crypto)
        
        # Calculate correlations
        correlation_matrix = analyzer.calculate_correlations(
            stock_data, bond_data, crypto_data)
        
        # Get insights
        relationships = analyzer.analyze_cross_asset_relationships()
        
        return jsonify({
            'success': True,
            'correlation_matrix': correlation_matrix.to_dict(),
            'top_relationships': relationships.head(10).to_dict('records'),
            'analysis_date': datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

if __name__ == '__main__':
    app.run(debug=True)

def generate_automated_report(self):
    """Generate automated correlation analysis report"""
    
    # Collect fresh data
    self.refresh_data()
    
    # Calculate current correlations
    current_correlations = self.analyze_cross_asset_relationships()
    
    # Generate AI insights
    ai_insights = self.analyze_with_ollama(
        "Provide a comprehensive analysis of current cross-asset correlations and portfolio implications.",
        f"Current market correlations: {current_correlations.head(5).to_string()}"
    )
    
    # Create report
    report = {
        'report_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
        'executive_summary': ai_insights,
        'correlation_analysis': current_correlations.to_dict('records'),
        'portfolio_recommendations': self.optimize_portfolio_allocation(),
        'risk_metrics': self.calculate_risk_metrics()
    }
    
    # Save report
    report_filename = f"correlation_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    with open(report_filename, 'w') as f:
        json.dump(report, f, indent=2, default=str)
    
    return report