Portfolio optimization across multiple factors - Dividends, Returns, Volatility, CVaR, and more

				
					import yfinance as yf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from pypfopt import risk_models, expected_returns
import json

# Function to download adjusted close prices for given tickers
def download_data(tickers, start, end):
    return yf.download(tickers, start=start, end=end)['Adj Close']

# Function to calculate returns, mean returns, and covariance matrix
def calculate_metrics(data):
    returns = data.pct_change().dropna()  # Calculate daily returns
    mean_returns = expected_returns.mean_historical_return(data)  # Calculate mean returns
    cov_matrix = risk_models.sample_cov(data)  # Calculate covariance matrix
    return returns, mean_returns, cov_matrix

# Function to get dividend yields for given tickers
def get_dividend_yields(tickers):
    dividend_yields = {}
    for ticker in tickers:
        stock = yf.Ticker(ticker)
        info = stock.info
        # Get dividend yield or set to 0 if not available
        dividend_yield = info.get('dividendYield') or info.get('trailingAnnualDividendYield', 0)
        if dividend_yield is None:
            dividend_yield = 0
        dividend_yields[ticker] = dividend_yield
    return pd.Series(dividend_yields)

# Function to calculate portfolio beta
def portfolio_beta(weights, returns, benchmark_returns):
    aligned_returns, aligned_benchmark = returns.align(benchmark_returns, join='inner', axis=0)
    cov_matrix = np.cov(aligned_returns.T, aligned_benchmark)
    beta = cov_matrix[:-1, -1] / np.var(aligned_benchmark)
    return np.sum(weights * beta)

# Function to calculate Sortino ratio
def sortino_ratio(weights, returns, risk_free_rate=0.01):
    portfolio_return = np.dot(weights, returns.mean())
    downside_returns = np.minimum(returns - risk_free_rate, 0)
    downside_deviation = np.sqrt(np.mean(downside_returns ** 2))
    return (portfolio_return - risk_free_rate) / downside_deviation

# Function to calculate Upside Potential Ratio
def upside_potential_ratio(weights, returns, risk_free_rate=0.01):
    portfolio_return = np.dot(weights, returns.mean())
    upside_returns = np.maximum(returns - risk_free_rate, 0)
    downside_returns = np.minimum(returns - risk_free_rate, 0)
    downside_deviation = np.sqrt(np.mean(downside_returns ** 2))
    upside_potential = np.mean(upside_returns)
    return upside_potential / downside_deviation

# Multi-objective function for portfolio optimization
def multi_objective_function(weights, mean_returns, cov_matrix, dividend_yields, benchmark_returns, risk_free_rate=0.01):
    obj_value = 0  # Initialize the objective value to 0
    if maximize_return:
        # If we want to maximize return, subtract the weighted sum of mean returns from the objective value
        obj_value -= np.dot(weights, mean_returns)  # Maximize return
    if minimize_risk:
        # If we want to minimize risk, add the portfolio volatility (standard deviation) to the objective value
        obj_value += np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))  # Minimize risk
    if maximize_sharpe:
        # If we want to maximize the Sharpe ratio, calculate it and subtract from the objective value
        portfolio_return = np.dot(weights, mean_returns)  # Expected portfolio return
        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))  # Portfolio volatility
        sharpe_ratio = (portfolio_return - risk_free_rate) / portfolio_volatility  # Sharpe ratio calculation
        obj_value -= sharpe_ratio  # Maximize Sharpe ratio
    if maximize_diversification:
        # If we want to maximize diversification, calculate the diversification ratio and subtract it from the objective value
        w_vol = np.dot(weights.T, np.sqrt(np.diag(cov_matrix)))  # Weighted volatilities of individual assets
        p_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))  # Portfolio volatility
        diversification_ratio = w_vol / p_vol  # Diversification ratio calculation
        obj_value -= diversification_ratio  # Maximize diversification
    if minimize_cvar:
        # If we want to minimize Conditional Value at Risk (CVaR), calculate it and add to the objective value
        cvar = np.percentile(np.dot(returns.values, weights), 5)  # CVaR calculation
        obj_value += cvar  # Minimize CVaR
    if minimize_transaction_costs:
        # If we want to minimize transaction costs, calculate them and add to the objective value
        prev_weights = np.ones(len(weights)) / len(weights)  # Assume equal weights previously
        transaction_costs = np.sum(np.abs(weights - prev_weights)) * 0.001  # Assume 0.1% cost for transactions
        obj_value += transaction_costs  # Minimize transaction costs
    if maximize_dividend_yield:
        # If we want to maximize dividend yield, subtract the weighted sum of dividend yields from the objective value
        obj_value -= np.dot(weights, dividend_yields)  # Maximize dividend yield
    if maximize_sortino:
        # If we want to maximize the Sortino ratio, calculate it and subtract from the objective value
        obj_value -= sortino_ratio(weights, returns, risk_free_rate)  # Maximize Sortino ratio
    if maximize_upside_potential:
        # If we want to maximize the Upside Potential Ratio, calculate it and subtract from the objective value
        obj_value -= upside_potential_ratio(weights, returns, risk_free_rate)  # Maximize Upside Potential Ratio
    if minimize_beta:
        # If we want to minimize beta, calculate it and add to the objective value
        obj_value += portfolio_beta(weights, returns, benchmark_returns)  # Minimize Beta
    return obj_value  # Return the final objective value


# Function to optimize portfolio based on given metrics
def optimize_portfolio(mean_returns, cov_matrix, dividend_yields, benchmark_returns):
    num_assets = len(mean_returns)
    init_guess = num_assets * [1. / num_assets,]  # Initial guess for weights
    constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1}, {'type': 'ineq', 'fun': lambda x: x})  # Constraints
    bounds = [(0, 1) for _ in range(num_assets)]  # Bounds for weights
    result = minimize(multi_objective_function, init_guess, args=(mean_returns, cov_matrix, dividend_yields, benchmark_returns),
                      method='SLSQP', bounds=bounds, constraints=constraints)
    return result.x

# Function to calculate cumulative returns
def calculate_cumulative_returns(returns, weights):
    portfolio_returns = returns.dot(weights)
    return (1 + portfolio_returns).cumprod()

# Function to plot cumulative returns
def plot_results(portfolio_cumulative, sp500_cumulative, equal_weighted_cumulative):
    plt.figure(figsize=(10, 6))
    plt.plot(portfolio_cumulative, label='Multi-Objective Optimization Portfolio')
    plt.plot(sp500_cumulative, label='S&P 500')
    plt.plot(equal_weighted_cumulative, label='Equal Weighted Portfolio')
    plt.xlabel('Date')
    plt.ylabel('Cumulative Returns')
    plt.title('Cumulative Returns Over Time')
    plt.legend()
    plt.show()

# Function to rebalance portfolio periodically
def rebalance_portfolio(data, tickers, rebalance_period):
    rebalanced_weights = []
    dates = pd.date_range(start=data.index[0], end=data.index[-1], freq=f'{rebalance_period}M')
    for date in dates:
        if date in data.index:
            subset_data = data[:date]  # Data up to the current date
            returns, mean_returns, cov_matrix = calculate_metrics(subset_data)
            benchmark_returns = benchmark_data[:date].pct_change().dropna()
            dividend_yields = get_dividend_yields(tickers)
            weights = optimize_portfolio(mean_returns, cov_matrix, dividend_yields, benchmark_returns)
            rebalanced_weights.append((date, weights))
    return rebalanced_weights