How to Calculate Beta from Scratch using Python

Beta is one of the most widely used metrics in the investment world, especially for those who follow the Capital Asset Pricing Model (CAPM). But what exactly is beta, and how can you calculate it yourself? Let’s break it down!

In this post, we’ll explain what beta is, why it’s important, how to calculate it, and even show you a simple Python code to calculate the beta of your favorite asset.

What is Beta?

Beta measures how much an asset’s price moves relative to a different asset, usually a benchmark index that represents the overall market like SP&500 or Nasdaq. In simple terms, it shows how sensitive an asset is to changes in the market.

How Does Beta Work?

• Beta = 1: The asset moves similarly to the market. If the market goes up by 1%, the asset is likely to go up by 1% as well.
• Beta > 1: The asset is more volatile than the market. If the market goes up by 1%, the asset might go up more than 1%.
• Beta < 1: The asset is less volatile than the market. If the market goes up by 1%, the asset is likely to go up less than 1%.
• Negative Beta: The asset tends to move in the opposite direction of the market. If the market goes up, the asset might go down.

These characteristics make beta an excellent tool for investors who want to understand the risk of an asset relative to the market.

Why is Beta Important?

Beta is important because:

• It helps evaluate risk: Understanding how an asset behaves in relation to the market helps you assess whether it fits your risk tolerance.
• It aids in diversification: By understanding the beta of different assets, you can choose a portfolio that balances risk more effectively.
• It is used in pricing models: The Capital Asset Pricing Model (CAPM), one of the most widely used asset pricing models, relies on beta to calculate expected returns.

For example, if you have a high-risk tolerance, you might prefer assets with a beta greater than 1, as they offer greater potential for returns (and losses!). On the other hand, if you’re more risk-averse, a lower beta might be better suited to your portfolio.

How is Beta Calculated?

To calculate the beta of an asset, you need two main pieces of information:

1. The asset’s returns: These are the percentage changes in the asset’s price over time.
2. The market’s returns: These are the percentage changes in the market index (e.g., S&P 500, Nasdaq Composite, or any other market index) over the same period.

The formula to calculate beta is:

β = Covariance(Asset Returns,Market Returns) / Variance(Market Returns)

In plain English:

• Covariance measures how the asset’s returns move in relation to the market’s returns.
• Variance measures how much the market’s returns fluctuate from their average.

Code Example: Calculate Beta in Python

Below is an example of how to calculate beta using the yfinance library to download the historical data and numpy to perform the calculations.

import yfinance as yf
import numpy as np
from datetime import datetime, timedelta

def calculate_beta(return_stock, return_index):
    """
    Calculates the beta of an asset relative to a market index.
    
    Parameters:
    - return_stock: The historical returns of the asset
    - return_index: The historical returns of the market index
    
    Returns:
    - The beta of the asset relative to the market index
    """
    
    # Calculate covariance between the asset returns and the market returns
    covariance = np.cov(return_stock, return_index)[0, 1]
    
    # Calculate the variance of the market returns
    variance_index = np.var(return_index)
    
    # Calculate beta
    beta = covariance / variance_index
    
    return beta

stock_name = 'NVDA'  # Example asset: Apple
market_index = '^IXIC'  # Nasdaq Composite index

# Download historical data (last 5 years)
end_date = datetime.today().date()  # today
start_date = end_date - timedelta(days=1*365)  # 5 years ago
data = yf.download([stock_name, market_index], start=start_date, end=end_date)

# Extract adjusted close prices
stock_prices = data['Close'][stock_name]
market_prices = data['Close'][market_index]

# Calculate daily returns (percent change)
stock_returns = stock_prices.pct_change().dropna()
market_returns = market_prices.pct_change().dropna()

# Calculate beta
beta = calculate_beta(stock_returns, market_returns)

print(f"The beta of {stock_name} relative to {market_index} is: {beta:.4f}")

Explanation of the Code

1. Data Download: The yfinance library is used to download historical price data for both the asset and the market index.
2. Calculate Returns: The .pct_change() function calculates the percentage change in price from day to day, giving us the daily returns.
3. Covariance and Variance: Using numpy, we calculate the covariance between the asset’s returns and the market’s returns, and the variance of the market’s returns.
4. Beta: The beta is simply the ratio of covariance to variance.

Code results

These are the results we found for some different assets comparing the last 5 years of the asset with Nasdaq

- The beta of NVDA relative to ^IXIC is: 2.2372
- The beta of MSFT relative to ^IXIC is: 0.8590
- The beta of NVDA relative to ^GSPC is: 2.7887 (S&P 500)
- The beta of MSFT relative to ^GSPC is: 1.1609 (S&P 500)

It is interesting to note how some assets vary in comparison to market indexes. The relationship between individual assets and broader market indexes, like the S&P 500 or Nasdaq Composite, can provide valuable insights into how an asset behaves in different market conditions.

In some cases, the indexes are actually composed of the same assets you’re analyzing. For example, the S&P 500 is made up of 500 of the largest companies in the U.S., and when an individual stock in the S&P 500 moves, it can affect the index itself. In these cases, when one of the assets moves, the index is, in fact, moving too — making it especially interesting to track their performance side by side.

Anyway, that was it for this post!

Let me know what you want to see in the next posts in the comments.