Diversification Analysis using Ollama: Correlation and Beta Calculation Guide

# Install Ollama (if not already installed)
curl -fsSL https://ollama.ai/install.sh | sh

# Pull the required model for financial analysis
ollama pull llama3.2

# Install Python dependencies
pip install pandas numpy requests matplotlib seaborn

import ollama
import pandas as pd
import numpy as np
import requests
from datetime import datetime, timedelta

# Configure Ollama client
client = ollama.Client()

# Test connection
response = client.chat(model='llama3.2', messages=[
    {'role': 'user', 'content': 'Hello, can you help with financial analysis?'}
])
print(response['message']['content'])

def fetch_stock_data(symbol, days=365):
    """
    Fetch historical stock data for analysis
    Replace with your preferred data source (Alpha Vantage, Yahoo Finance, etc.)
    """
    # Example using a mock data generator for demonstration
    dates = pd.date_range(end=datetime.now(), periods=days)
    
    # Simulate realistic stock price movements
    np.random.seed(42)  # For reproducible results
    returns = np.random.normal(0.001, 0.02, days)  # Daily returns
    prices = [100]  # Starting price
    
    for return_val in returns[1:]:
        prices.append(prices[-1] * (1 + return_val))
    
    return pd.DataFrame({
        'date': dates,
        'close': prices,
        'symbol': symbol
    })

# Collect data for portfolio analysis
symbols = ['AAPL', 'GOOGL', 'MSFT', 'SPY']  # Individual stocks + market index
portfolio_data = {}

for symbol in symbols:
    portfolio_data[symbol] = fetch_stock_data(symbol)
    print(f"Collected {len(portfolio_data[symbol])} days of data for {symbol}")

def prepare_returns_data(portfolio_data):
    """
    Convert price data to returns for correlation and beta analysis
    """
    returns_data = pd.DataFrame()
    
    for symbol, data in portfolio_data.items():
        # Calculate daily returns
        data['returns'] = data['close'].pct_change()
        returns_data[symbol] = data['returns']
    
    # Remove first row (NaN values from pct_change)
    returns_data = returns_data.dropna()
    
    return returns_data

returns_df = prepare_returns_data(portfolio_data)
print("Returns data shape:", returns_df.shape)
print("\nFirst 5 rows:")
print(returns_df.head())

def calculate_correlation_matrix(returns_df):
    """
    Calculate correlation matrix for portfolio assets
    """
    correlation_matrix = returns_df.corr()
    return correlation_matrix

# Calculate correlations
corr_matrix = calculate_correlation_matrix(returns_df)
print("Correlation Matrix:")
print(corr_matrix.round(3))

def analyze_correlations_with_ollama(correlation_matrix):
    """
    Use Ollama to interpret correlation patterns
    """
    # Convert correlation matrix to string for AI analysis
    corr_text = correlation_matrix.to_string()
    
    prompt = f"""
    Analyze this correlation matrix for a portfolio:
    
    {corr_text}
    
    Please provide:
    1. Key correlation insights
    2. Diversification effectiveness
    3. Risk concentration areas
    4. Recommendations for improvement
    
    Focus on practical insights for portfolio management.
    """
    
    response = client.chat(model='llama3.2', messages=[
        {'role': 'user', 'content': prompt}
    ])
    
    return response['message']['content']

# Get AI insights on correlations
correlation_analysis = analyze_correlations_with_ollama(corr_matrix)
print("AI Correlation Analysis:")
print(correlation_analysis)

def calculate_rolling_correlations(returns_df, window=30):
    """
    Calculate rolling correlations to identify changing relationships
    """
    rolling_corr = {}
    reference_asset = 'SPY'  # Use market index as reference
    
    for column in returns_df.columns:
        if column != reference_asset:
            rolling_corr[f"{column}_vs_{reference_asset}"] = (
                returns_df[column].rolling(window=window)
                .corr(returns_df[reference_asset])
            )
    
    return pd.DataFrame(rolling_corr)

# Calculate 30-day rolling correlations
rolling_corr_df = calculate_rolling_correlations(returns_df)
print("Rolling Correlations (last 5 observations):")
print(rolling_corr_df.tail())

def calculate_beta(asset_returns, market_returns):
    """
    Calculate beta coefficient for a single asset
    Beta = Covariance(asset, market) / Variance(market)
    """
    # Remove any NaN values
    valid_data = pd.DataFrame({
        'asset': asset_returns,
        'market': market_returns
    }).dropna()
    
    # Calculate covariance and variance
    covariance = np.cov(valid_data['asset'], valid_data['market'])[0, 1]
    market_variance = np.var(valid_data['market'])
    
    beta = covariance / market_variance
    
    return beta

# Calculate beta for each stock vs market (SPY)
market_returns = returns_df['SPY']
betas = {}

for symbol in returns_df.columns:
    if symbol != 'SPY':
        betas[symbol] = calculate_beta(returns_df[symbol], market_returns)

print("Beta Coefficients:")
for symbol, beta in betas.items():
    print(f"{symbol}: {beta:.3f}")

def calculate_portfolio_beta(individual_betas, weights):
    """
    Calculate overall portfolio beta
    Portfolio Beta = Sum(Weight_i * Beta_i)
    """
    portfolio_beta = sum(weight * individual_betas[symbol] 
                        for symbol, weight in weights.items() 
                        if symbol in individual_betas)
    return portfolio_beta

# Define portfolio weights (equal weight for simplicity)
equal_weights = {symbol: 1/len(betas) for symbol in betas.keys()}

portfolio_beta = calculate_portfolio_beta(betas, equal_weights)
print(f"\nPortfolio Beta (equal weights): {portfolio_beta:.3f}")

def interpret_beta_with_ollama(betas, portfolio_beta):
    """
    Use Ollama to interpret beta values and portfolio risk
    """
    beta_summary = "\n".join([f"{symbol}: {beta:.3f}" for symbol, beta in betas.items()])
    
    prompt = f"""
    Analyze these beta coefficients for investment decision-making:
    
    Individual Stock Betas:
    {beta_summary}
    
    Portfolio Beta: {portfolio_beta:.3f}
    
    Please explain:
    1. What these beta values mean for risk
    2. How the portfolio compares to market risk
    3. Specific recommendations for risk management
    4. Which stocks add/reduce portfolio volatility
    
    Provide actionable insights for portfolio optimization.
    """
    
    response = client.chat(model='llama3.2', messages=[
        {'role': 'user', 'content': prompt}
    ])
    
    return response['message']['content']

beta_analysis = interpret_beta_with_ollama(betas, portfolio_beta)
print("AI Beta Analysis:")
print(beta_analysis)

def calculate_risk_contributions(returns_df, weights):
    """
    Calculate each asset's contribution to portfolio risk
    """
    # Calculate portfolio returns
    weighted_returns = returns_df.multiply(pd.Series(weights), axis=1)
    portfolio_returns = weighted_returns.sum(axis=1)
    portfolio_std = portfolio_returns.std()
    
    risk_contributions = {}
    
    for symbol in returns_df.columns:
        if symbol in weights:
            # Calculate marginal contribution to risk
            asset_portfolio_corr = returns_df[symbol].corr(portfolio_returns)
            asset_std = returns_df[symbol].std()
            weight = weights[symbol]
            
            marginal_risk = (weight * asset_std * asset_portfolio_corr) / portfolio_std
            risk_contributions[symbol] = marginal_risk
    
    return risk_contributions

# Calculate risk contributions
risk_contrib = calculate_risk_contributions(returns_df, equal_weights)
print("Risk Contributions:")
for symbol, contribution in risk_contrib.items():
    print(f"{symbol}: {contribution:.1%}")

def generate_diversification_recommendations(corr_matrix, betas, risk_contrib):
    """
    Use Ollama to generate specific diversification recommendations
    """
    # Prepare comprehensive analysis data
    analysis_data = {
        'correlations': corr_matrix.to_dict(),
        'betas': betas,
        'risk_contributions': risk_contrib
    }
    
    prompt = f"""
    Based on this comprehensive portfolio analysis, provide specific diversification recommendations:
    
    Correlation Data: {corr_matrix.to_string()}
    Beta Values: {betas}
    Risk Contributions: {risk_contrib}
    
    Please provide:
    1. Specific assets to add/remove
    2. Optimal weight adjustments
    3. Alternative asset classes to consider
    4. Timeline for implementing changes
    5. Expected impact on portfolio risk
    
    Make recommendations actionable and specific.
    """
    
    response = client.chat(model='llama3.2', messages=[
        {'role': 'user', 'content': prompt}
    ])
    
    return response['message']['content']

recommendations = generate_diversification_recommendations(corr_matrix, betas, risk_contrib)
print("Diversification Recommendations:")
print(recommendations)

import matplotlib.pyplot as plt
import seaborn as sns

def create_correlation_heatmap(correlation_matrix):
    """
    Create a correlation heatmap for visual analysis
    """
    plt.figure(figsize=(10, 8))
    sns.heatmap(correlation_matrix, 
                annot=True, 
                cmap='RdYlBu_r', 
                center=0,
                square=True,
                fmt='.3f')
    plt.title('Portfolio Correlation Matrix')
    plt.tight_layout()
    plt.savefig('correlation_heatmap.png', dpi=300, bbox_inches='tight')
    plt.show()

def create_beta_visualization(betas):
    """
    Create beta coefficient visualization
    """
    symbols = list(betas.keys())
    beta_values = list(betas.values())
    
    plt.figure(figsize=(10, 6))
    bars = plt.bar(symbols, beta_values, color=['red' if b > 1 else 'green' for b in beta_values])
    plt.axhline(y=1, color='black', linestyle='--', alpha=0.7, label='Market Beta = 1')
    plt.xlabel('Assets')
    plt.ylabel('Beta Coefficient')
    plt.title('Beta Coefficients vs Market')
    plt.legend()
    
    # Add value labels on bars
    for bar, value in zip(bars, beta_values):
        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
                f'{value:.3f}', ha='center', va='bottom')
    
    plt.tight_layout()
    plt.savefig('beta_visualization.png', dpi=300, bbox_inches='tight')
    plt.show()

# Generate visualizations
create_correlation_heatmap(corr_matrix)
create_beta_visualization(betas)

def setup_automated_analysis():
    """
    Create automated diversification monitoring system
    """
    automation_code = """
    # Schedule daily analysis
    import schedule
    import time
    
    def daily_diversification_check():
        # Fetch latest data
        current_data = fetch_portfolio_data()
        
        # Calculate metrics
        correlations = calculate_correlation_matrix(current_data)
        current_betas = calculate_portfolio_betas(current_data)
        
        # Check for significant changes
        if correlation_change_detected(correlations) or beta_change_detected(current_betas):
            send_alert_notification()
        
        # Generate updated report
        create_daily_report(correlations, current_betas)
    
    # Schedule analysis
    schedule.every().day.at("09:00").do(daily_diversification_check)
    
    while True:
        schedule.run_pending()
        time.sleep(3600)  # Check every hour
    """
    
    return automation_code

print("Automation Setup Code:")
print(setup_automated_analysis())

def benchmark_diversification_effectiveness():
    """
    Compare portfolio performance against diversification benchmarks
    """
    benchmark_prompt = f"""
    Evaluate this portfolio's diversification effectiveness:
    
    Current Metrics:
    - Average correlation: {corr_matrix.values[np.triu_indices_from(corr_matrix.values, 1)].mean():.3f}
    - Portfolio beta: {portfolio_beta:.3f}
    - Number of assets: {len(betas)}
    
    Compare against:
    1. Target correlation < 0.3
    2. Target beta 0.8-1.2
    3. Minimum 8-10 assets for retail portfolios
    
    Provide a diversification score (1-10) and improvement priorities.
    """
    
    response = client.chat(model='llama3.2', messages=[
        {'role': 'user', 'content': benchmark_prompt}
    ])
    
    return response['message']['content']

diversification_score = benchmark_diversification_effectiveness()
print("Diversification Effectiveness Score:")
print(diversification_score)

def validate_portfolio_data(returns_df):
    """
    Validate data quality for reliable analysis
    """
    issues = []
    
    # Check for missing data
    missing_pct = returns_df.isnull().sum() / len(returns_df) * 100
    for symbol, pct in missing_pct.items():
        if pct > 5:  # More than 5% missing
            issues.append(f"{symbol}: {pct:.1f}% missing data")
    
    # Check for extreme outliers
    for symbol in returns_df.columns:
        q99 = returns_df[symbol].quantile(0.99)
        q1 = returns_df[symbol].quantile(0.01)
        outliers = ((returns_df[symbol] > q99) | (returns_df[symbol] < q1)).sum()
        if outliers > len(returns_df) * 0.02:  # More than 2% outliers
            issues.append(f"{symbol}: {outliers} potential outliers detected")
    
    return issues

data_issues = validate_portfolio_data(returns_df)
if data_issues:
    print("Data Quality Issues:")
    for issue in data_issues:
        print(f"- {issue}")
else:
    print("Data quality validation passed!")

def detect_correlation_regimes(returns_df, window=60):
    """
    Detect periods of changing correlation patterns
    """
    regime_analysis = f"""
    Based on rolling {window}-day correlations, identify:
    1. Periods of high correlation (crisis periods)
    2. Periods of low correlation (normal diversification)
    3. Correlation breakpoints and regime changes
    4. Implications for portfolio rebalancing timing
    
    Current rolling correlation data:
    {rolling_corr_df.describe().to_string()}
    """
    
    response = client.chat(model='llama3.2', messages=[
        {'role': 'user', 'content': regime_analysis}
    ])
    
    return response['message']['content']

regime_insights = detect_correlation_regimes(returns_df)
print("Correlation Regime Analysis:")
print(regime_insights)

def export_to_excel(correlation_matrix, betas, recommendations):
    """
    Export analysis results to Excel for traditional workflows
    """
    with pd.ExcelWriter('diversification_analysis.xlsx', engine='openpyxl') as writer:
        # Correlation matrix
        correlation_matrix.to_excel(writer, sheet_name='Correlations')
        
        # Beta values
        beta_df = pd.DataFrame(list(betas.items()), columns=['Symbol', 'Beta'])
        beta_df.to_excel(writer, sheet_name='Beta_Coefficients', index=False)
        
        # Recommendations (convert to DataFrame)
        recommendations_df = pd.DataFrame([recommendations], columns=['AI_Recommendations'])
        recommendations_df.to_excel(writer, sheet_name='Recommendations', index=False)
    
    print("Analysis exported to 'diversification_analysis.xlsx'")

# Export results
export_to_excel(corr_matrix, betas, recommendations)

def create_api_endpoint():
    """
    Example API endpoint for diversification analysis
    """
    api_example = """
    from flask import Flask, request, jsonify
    
    app = Flask(__name__)
    
    @app.route('/analyze_diversification', methods=['POST'])
    def analyze_diversification():
        try:
            # Get portfolio data from request
            portfolio_symbols = request.json.get('symbols', [])
            
            # Perform analysis
            data = fetch_portfolio_data(portfolio_symbols)
            correlations = calculate_correlation_matrix(data)
            betas = calculate_portfolio_betas(data)
            
            # Get AI insights
            insights = analyze_with_ollama(correlations, betas)
            
            return jsonify({
                'status': 'success',
                'correlations': correlations.to_dict(),
                'betas': betas,
                'ai_insights': insights
            })
            
        except Exception as e:
            return jsonify({'status': 'error', 'message': str(e)})
    
    if __name__ == '__main__':
        app.run(debug=True)
    """
    
    return api_example

print("API Integration Example:")
print(create_api_endpoint())