Section 1.1: What Is the Sharpe Ratio?

The Sharpe Ratio, also known as the Sharpe Index, is a metric used to evaluate the performance of an investment, including a portfolio. Introduced by William Sharpe in 1966, this ratio calculates the difference between portfolio returns and the risk-free rate, normalized by the portfolio's volatility. The risk-free return represents a theoretical gain with minimal risk, often reflected by government bonds. This ratio allows investors to understand the excess return relative to each unit of volatility, with a higher Sharpe Ratio indicating better returns for lower risk. For this discussion, we will assume the risk-free rate is zero.

SharpeRatio = frac{R_p - R_e}{SD_p}

Where:

• (R_p) = Portfolio return
• (R_e) = Risk-free return
• (SD_p) = Portfolio standard deviation

Section 1.2: Understanding the Efficient Frontier

Later in this article, we will generate thousands of portfolios to identify the most optimal stock weights. Initially, we will assign equal weights to each stock. This leads us to a concept known as the Efficient Frontier, which was introduced by Harry Markowitz in 1952. The Efficient Frontier visually represents the set of portfolios that provide the highest returns for a given level of risk.

The curve of the Efficient Frontier illustrates the advantages of diversification and the trade-off between risk and reward. Investors with higher risk tolerance may gravitate toward the right side of the curve, while conservative investors will likely prefer the left side, where risk is minimized. Portfolios that lie on the frontier are deemed efficient, while those above or below the curve are not optimal due to their inferior return-risk balance. Our goal is to create an Efficient Frontier chart and determine the optimal stock weight combinations.

Section 1.3: Exploratory Data Analysis (EDA)

We will download and analyze data from February 2022 to February 2023.

First, let's load the necessary libraries:

import numpy as np

import pandas as pd

import warnings

import matplotlib.pyplot as plt

import seaborn as sns

from datetime import date

from nsepy import get_history as gh

Next, we will set our initial investment parameters. We plan to invest in five banking stocks: Axis Bank, HDFC Bank, ICICI Bank, Kotak Bank, and SBI, allocating 20% to each stock.

initial_investment = 100000

start_date = date(2022, 2, 2)

end_date = date(2023, 2, 2)

stocksymbols = ['AXISBANK', 'HDFCBANK', 'ICICIBANK', 'KOTAKBANK', 'SBIN']

weights = np.array([0.2, 0.2, 0.2, 0.2, 0.2])

Section 1.4: Calculating Daily Returns

Now, we will compute the daily returns for our selected stocks.

def load_stock_data(start_date, end_date, investment: int, ticker: str):

df = pd.DataFrame()

for i in range(len(ticker)):

data = gh(symbol=ticker[i], start=start_date, end=end_date)[['Symbol', 'Close']]

data.rename(columns={'Close': data['Symbol'][0]}, inplace=True)

data.drop(['Symbol'], axis=1, inplace=True)

df = df.join(data) if not df.empty else data

return df

df_stockPrice = load_stock_data(start_date, end_date, initial_investment, stocksymbols)

df_returns = df_stockPrice.pct_change().dropna()

Visualizing Stock Price Trends

Source: Author | Price Trends of all the Stocks

Source: Author | Cumulative Trends of all the Stocks

Source: Author | Histogram of Returns of Stocks

Section 1.5: Sharpe Ratio Calculation

Now, we will compute the weighted returns and summarize them.

df_returns['Portfolio'] = (weights * df_returns.values).sum(axis=1)

# Average daily return

average_return = df_returns['Portfolio'].mean()

# Standard deviation of the portfolio

portfolio_std = df_returns['Portfolio'].std()

# Sharpe ratio

sharpe_ratio = average_return / portfolio_std

Section 1.6: Finding Portfolio Balance

After establishing equal weights, we will create numerous portfolios with different weight distributions, ensuring their total equals one. We will compute the portfolio returns, risks, weights, and Sharpe ratios in each iteration.

def sim_portfolio(weights):

port_mean = (weights * df_returns.values).sum(axis=1) * 252 # Annualized mean

port_sd = np.sqrt(weights.T.dot(df_returns.cov() * 252).dot(weights))

mc_sim_sr = (port_mean.mean() / port_sd)

return mc_sim_sr

Refer to the complete code on GitHub.

After 25,000 iterations, we will summarize the results, focusing on maximizing the Sharpe ratio.

Visualizing Risk vs. Return

Source: Author | Return vs. Volatility vs. Sharpe Ratio

Section 2.1: Closing Thoughts

We explored various methods for optimizing a portfolio, focusing on the application of the Sharpe ratio and the Efficient Frontier to create an ideal investment strategy. The Sharpe ratio is a valuable tool for comparing similar portfolios due to its straightforward interpretability.

I hope you found this article informative and insightful. For further reading, consider my previous works on Risk Management, Portfolio Construction, and Fundamental Analysis in Python.

Disclaimer: This blog is for educational purposes and should not be considered professional financial advice.

References

• Investopedia
• Unsplash
• Subscribe to DDIntel Here.
• Follow us on LinkedIn, Twitter, YouTube, and Facebook.