# abdallah abdelkarim
# In the world of finance, managing asset allocation is a crucial aspect of investment strategy.
# As market conditions change, it’s essential to rebalance portfolios to maintain desired risk and return
# profiles. Dynamic portfolio rebalancing involves adjusting the weights of assets in a portfolio based
# on predefined rules or algorithms.
# In this tutorial, we will explore how to implement dynamic portfolio rebalancing using Python.
# We will download real financial data using the yfinance library, analyze the data and create a dynamic
# rebalancing strategy based on historical performance. We will leverage object-oriented programming concepts
# to build a rob ust and flexible portfolio management system.
import yfinance as yf
import numpy as np
import [Link] as plt
import pandas as pd
#. Downloading Financial Data
# To demonstrate dynamic portfolio rebalancing, we need historical financial data for multiple assets.
# We will download data for three diverse assets: Tesla (TSLA), Amazon (AMZN) and Bitcoin (BTC-USD).
#We will fetch data until the end of February 2024 to analyze the performance over a substantial period.
assets = ['TSLA', 'AMZN', 'BTC-USD']
data = [Link](assets, start='2020-01-01', end='2024-03-14')['Adj Close']
[*********************100%%**********************] 3 of 3 completed
# Visualizing Asset Prices
# Let’s visualize the historical prices of the selected assets to understand their performance over time.
# We will plot the adjusted close prices on a single graph for easy comparison.
[Link](figsize=(14, 7))
for asset in assets:
[Link]([Link], data[asset], label=asset)
[Link]('Historical Asset Prices')
[Link]('Date')
[Link]('Price (USD)')
[Link]()
[Link](True)
[Link]()
# The plot above shows the historical prices of Tesla, Amazon and Bitcoin from January 2020 to mars 2024.
# We can observe the price trends and volatility of each asset over the period.
# Calculating Returns and Volatility
# To optimize our portfolio, we need to analyze the historical returns and volatility of each asset.
# We will calculate the daily returns and volatility of the assets to understand their performance
# characteristics.
returns = data.pct_change()
mean_returns = [Link]()
cov_matrix = [Link]()
# Annualized returns and covariance matrix
annual_returns = mean_returns * 252
annual_covariance = cov_matrix * 252
# The pct_change() function calculates the daily percentage change in asset prices. We then compute the mean
# daily returns, covariance matrix, annualized returns and annualized covariance matrix for our analysis.
# Efficient Frontier and Portfolio Optimization
# The efficient frontier represents a set of optimal portfolios that offer the highest expected return
# for a given level of risk. We will use the Markowitz Portfolio Optimization technique to find the optimal
# asset allocation that maximizes returns while minimizing risk.
class Portfolio:
def __init__(self, returns, cov_matrix):
[Link] = returns
self.cov_matrix = cov_matrix
def generate_random_portfolios(self, num_portfolios):
results = [Link]((3, num_portfolios))
weights_record = []
for i in range(num_portfolios):
weights = [Link](3)
weights /= [Link](weights)
weights_record.append(weights)
portfolio_return = [Link]([Link] * weights) * 252
portfolio_std_dev = [Link]([Link](weights.T, [Link](self.cov_matrix, weights))) * [Link](252)
results[0, i] = portfolio_return
results[1, i] = portfolio_std_dev
results[2, i] = portfolio_return / portfolio_std_dev
return results, weights_record
portfolio = Portfolio(annual_returns, annual_covariance)
num_portfolios = 10000
results, weights = portfolio.generate_random_portfolios(num_portfolios)
[Link](figsize=(14, 7))
[Link](results[1, :], results[0, :], c=results[2, :], cmap='viridis')
[Link]('Efficient Frontier')
[Link]('Volatility')
[Link]('Return')
[Link](label='Sharpe Ratio')
[Link]()
# The plot above illustrates the efficient frontier, showing the trade-off between risk (volatility) and return.
# Each point represents a randomly generated portfolio with different asset allocations. The color represents
# the Sharpe Ratio, a measure of risk-adjusted return.
# Dynamic Portfolio Rebalancing Strategy
# Now that we have explored the efficient frontier, we can implement a dynamic portfolio rebalancing strategy
# based on historical performance. We will rebalance the portfolio quarterly based on the optimal asset
# allocation derived from the efficient frontier.
class RebalancingStrategy:
def __init__(self, assets, returns, cov_matrix):
[Link] = assets
[Link] = returns
self.cov_matrix = cov_matrix
def get_optimal_weights(self):
portfolio = Portfolio([Link], self.cov_matrix)
num_portfolios = 10000
results, weights = portfolio.generate_random_portfolios(num_portfolios)
max_sharpe_idx = [Link](results[2])
optimal_weights = weights[max_sharpe_idx]
return optimal_weights
def rebalance_portfolio(self):
optimal_weights = self.get_optimal_weights()
current_prices = [Link][-1]
portfolio_value = 1000000
asset_values = {asset: portfolio_value * weight for asset, weight in zip([Link], optimal_weights)}
shares_to_buy = {asset: asset_values[asset] / price for asset, price in current_prices.items()}
return shares_to_buy
strategy = RebalancingStrategy(assets, annual_returns, annual_covariance)
shares_to_buy = strategy.rebalance_portfolio()
print(shares_to_buy)
{'AMZN': 3346.4735318485086, 'BTC-USD': 5.583767541066703, 'TSLA': 6.286088778837214}
# In the RebalancingStrategy class, we calculate the optimal asset allocation based on the efficient frontier
# and rebalance the portfolio accordingly. The shares_to_buy dictionary provides the number of shares to buy
# for each asset to achieve the optimal allocation.
# Conclusion
# In this tutorial, we have explored the concept of dynamic portfolio rebalancing using Python.
# By leveraging historical financial data and portfolio optimization techniques, we can create a robust asset
# allocation strategy that adapts to changing market conditions.
# We implemented a dynamic rebalancing strategy based on the efficient frontier, optimizing the portfolio
# for risk-adjusted returns. By rebalancing the portfolio quarterly, we can maintain the desired asset
# allocation and maximize returns while managing risk effectively.
# Dynamic portfolio rebalancing is a powerful tool for investors looking to optimize their investment
# portfolios and achieve their financial goals. By combining Python programming with financial analysis
# techniques, we can make informed decisions and enhance our investment strategies.
# Remember, the key to successful portfolio management lies in continuous monitoring, analysis and adaptation.
# Stay informed, stay agile and let Python be your guide in navigating the complex world of asset allocation
# and investment management.
Loading [MathJax]/jax/output/CommonHTML/fonts/TeX/[Link]