Backtesting the NVIDIA Scalping Strategy with SPY Benchmark & VaR Simulations

Image design template by Agit Akbulut via Canva.

In this post, the focus is on 1Y backtesting the NVIDIA (NASDAQ: NVDA) scalping algo-trading strategy as compared to the buy-hold strategy and the SPY ETF benchmark. In addition, we’ll quantify the potential risk of loss by running stochastic simulations for computing the Value-at-Risk (VaR).
Challenge 1: What To Do Now As NVDA Forms A Base; Is NVDA A Buy Now? Those who still hold NVDA may be asking themselves, what is an exit strategy as NVDA struggles to get past the 900 level?
Challenge 2: NVDA, the tech behemoth, definitely tempts as a day trading option, but let’s be real — you’ll want to find stocks that are easy to buy and sell (that’s called liquidity), don’t burn you with high transaction fees, swing enough in price to make things interesting (hello, volatility), and have enough people trading them to ensure there’s always a buyer or seller when you need one.
Solution Part 1: Scalping is a day trading technique where an investor buys and sells an individual stock multiple times throughout the same day. Scalpers seek to profit from small market movements, taking advantage of a ticker tape that never stands still.
Solution Part 2: VaR serves as a tool to quantify investment risks by providing estimates of maximum potential losses given a certain level of confidence in making predictions about stock returns within a specific timeframe.
Let’s begin with basic settings and imports:

import os
os.chdir('YOURPATH')    # Set working directory
os. getcwd()

# IMPORTING PACKAGES

import requests
import pandas as pd
import matplotlib.pyplot as plt
from termcolor import colored as cl
import numpy as np
import math

Reading Input Stock Data

Getting the NVDA historical data since 2023–1–1

plt.style.use('fivethirtyeight')
plt.rcParams['figure.figsize'] = (20, 10)
myticker='NVDA'
mydate='2023-1-1'
def get_historical_data(symbol, start_date):
    api_key = 'YOUR API KEY'
    api_url = f'https://api.twelvedata.com/time_series?symbol={symbol}&interval=1day&outputsize=5000&apikey={api_key}'
    raw_df = requests.get(api_url).json()
    df = pd.DataFrame(raw_df['values']).iloc[::-1].set_index('datetime').astype(float)
    df = df[df.index >= start_date]
    df.index = pd.to_datetime(df.index)
    return df

nvd= get_historical_data(myticker, mydate)
nvd.tail()

           open      high      low       close     volume
datetime     
2024-04-08 887.00000 888.29999 867.32001 871.33002 28322000.0
2024-04-09 874.41998 876.34998 830.21997 853.53998 50354700.0
2024-04-10 839.26001 874.00000 837.09003 870.39001 43192900.0
2024-04-11 874.20001 907.39001 869.26001 906.15997 43163700.0
2024-04-12 896.98999 901.75000 875.29999 881.85999 42488900.0

Calculating Trade Earnings

Calculating the intraday open-close % price change

# CALCULATING % CHANGE

nvd['pclose_open_pc'] = np.nan

for i in range(1, len(nvd)):
    diff, avg = (nvd.close[i-1] - nvd.open[i]) , (nvd.close[i-1] + nvd.open[i])/2
    pct_change = (diff / avg)*100
    nvd['pclose_open_pc'][i] = pct_change
    
nvd = nvd[nvd.pclose_open_pc > 1]

nvd.tail()

           open      high      low       close     volume     pclose_open_pc
datetime      
2024-03-19 867.00000 905.44000 850.09998 893.97998 67217100.0 2.003938
2024-04-02 884.47998 900.94000 876.20001 894.52002 43306400.0 2.141929
2024-04-03 884.84003 903.73999 884.00000 889.64001 37006700.0 1.088030
2024-04-10 839.26001 874.00000 837.09003 870.39001 43192900.0 1.687142
2024-04-12 896.98999 901.75000 875.29999 881.85999 42488900.0 1.017107

Extracting the intraday stock data, defining the entering/exiting position, and calculating the day trade earnings by investing $10k

investment = 10000
equity = investment
earning = 0

earnings_record = []

for i in range(len(nvd)):
    
    # EXTRACTING INTRADAY DATA
    date = str(nvd.index[i])[:10]
    # ENTERING POSITION
    open_p = nvd.iloc[i].open
    no_of_shares = math.floor(equity/open_p)
    equity -= (no_of_shares * open_p)

    # EXITING POSITION
    nvd['p_change'] = np.nan
    
    for i in range(len(nvd)):
        diff, avg = (nvd.close[i] - open_p), (nvd.close[i] + open_p)/2
        pct_change = (diff / avg)*100
        nvd['p_change'][i] = pct_change
    nvd = nvd.dropna()
    greater_1 = nvd[nvd.p_change > 1]
    
    if len(greater_1) > 0:
        sell_price = greater_1.iloc[0].close
        equity += (no_of_shares * sell_price)
    else:
        sell_price = nvd.iloc[-1].close
        equity += (no_of_shares * sell_price)
    
    # CALCULATING TRADE EARNINGS
    investment += earning
    earning = round(equity-investment, 2)
    earnings_record.append(earning)
    
    if earning > 0:
        print(cl('PROFIT:', color = 'green', attrs = ['bold']), f'Earning on {date}: ${earning}; Bought ', cl(f'{no_of_shares}', attrs = ['bold']), 'stocks at ', cl(f'${open_p}', attrs = ['bold']), 'and Sold at ', cl(f'${sell_price}', attrs = ['bold']))
    else:
        print(cl('LOSS:', color = 'red', attrs = ['bold']), f'Loss on {date}: ${earning}; Bought ', cl(f'{no_of_shares}', attrs = ['bold']), 'stocks at ', cl(f'${open_p}', attrs = ['bold']), 'and Sold at ', cl(f'${sell_price}', attrs = ['bold']))

PROFIT: Earning on 2023-10-06: $345.18; Bought  22 stocks at  $441.92999 and Sold at  $457.62
PROFIT: Earning on 2023-10-09: $211.6; Bought  23 stocks at  $448.42001 and Sold at  $457.62
PROFIT: Earning on 2023-10-17: $405.26; Bought  23 stocks at  $440.0 and Sold at  $457.62
PROFIT: Earning on 2023-10-18: $792.75; Bought  25 stocks at  $425.91 and Sold at  $457.62
PROFIT: Earning on 2023-10-31: $1540.48; Bought  29 stocks at  $404.5 and Sold at  $457.62
PROFIT: Earning on 2023-12-04: $442.4; Bought  28 stocks at  $460.76999 and Sold at  $476.57001
PROFIT: Earning on 2023-12-12: $467.19; Bought  29 stocks at  $460.45999 and Sold at  $476.57001
PROFIT: Earning on 2023-12-19: $3249.96; Bought  28 stocks at  $494.23999 and Sold at  $610.31
PROFIT: Earning on 2024-01-03: $762.84; Bought  36 stocks at  $474.85001 and Sold at  $496.04001
PROFIT: Earning on 2024-01-26: $3238.72; Bought  29 stocks at  $609.59998 and Sold at  $721.28003
PROFIT: Earning on 2024-01-31: $3633.92; Bought  34 stocks at  $614.40002 and Sold at  $721.28003
PROFIT: Earning on 2024-02-13: $604.8; Bought  35 stocks at  $704.0 and Sold at  $721.28003
PROFIT: Earning on 2024-02-21: $1525.15; Bought  37 stocks at  $680.06 and Sold at  $721.28003
PROFIT: Earning on 2024-02-28: $2853.89; Bought  35 stocks at  $776.20001 and Sold at  $857.73999
PROFIT: Earning on 2024-03-11: $515.11; Bought  34 stocks at  $864.28998 and Sold at  $879.44
LOSS: Loss on 2024-03-14: $-472.95; Bought  34 stocks at  $895.77002 and Sold at  $881.85999
PROFIT: Earning on 2024-03-15: $344.76; Bought  34 stocks at  $869.29999 and Sold at  $879.44
PROFIT: Earning on 2024-03-19: $435.4; Bought  35 stocks at  $867.0 and Sold at  $879.44
PROFIT: Earning on 2024-04-02: $323.0; Bought  34 stocks at  $884.47998 and Sold at  $893.97998
PROFIT: Earning on 2024-04-03: $319.9; Bought  35 stocks at  $884.84003 and Sold at  $893.97998
PROFIT: Earning on 2024-04-10: $683.76; Bought  37 stocks at  $839.26001 and Sold at  $857.73999
LOSS: Loss on 2024-04-12: $-529.55; Bought  35 stocks at  $896.98999 and Sold at  $881.85999

Backtesting Results

Let’s look at the NVDA backtesting results

# STRATEGY RETURNS

print(cl(f'NVDA BACKTESTING RESULTS:', attrs = ['bold']))
print(' ')

strategy_earning = round(equity - 10000, 2)
roi = round(strategy_earning / 10000 * 100, 2)

print(cl(f'EARNING: ${strategy_earning} ; ROI: {roi}%', attrs = ['bold']))

NVDA BACKTESTING RESULTS:
 
EARNING: $21693.57 ; ROI: 216.94%

Creating the earning dataframe for plotting purposes

earnings_df = pd.DataFrame(columns = ['date', 'earning'])
earnings_df.date = nvd.index
earnings_df.earning = earnings_record

earnings_df.tail()
date          earning
17 2024-03-19 435.40
18 2024-04-02 323.00
19 2024-04-03 319.90
20 2024-04-10 683.76
21 2024-04-12 -529.55

Plotting Scalping Returns

Plotting the Earnings Distribution and Strategy Cumulative Returns

plt.figure(figsize=(10,6))


max_loss = earnings_df.earning.min()
max_profit = earnings_df.earning.max()

no_of_wins = len(earnings_df.iloc[np.where(earnings_df.earning > 0)[0]])
no_of_losses = len(earnings_df.iloc[np.where(earnings_df.earning < 0)[0]])
no_of_trades = no_of_wins+no_of_losses
win_rate = (no_of_wins/(no_of_wins + no_of_losses))*100

plt.style.use('ggplot')

earnings_df.earning.hist()
plt.title('Earnings Distribution')
plt.xticks(fontsize=14, rotation=0)
plt.yticks(fontsize=14, rotation=0)

plt.show()

plt.figure(figsize=(10,6))

earnings_df = earnings_df.set_index('date')

earnings_df.earning.cumsum().plot()
plt.title('Strategy Cumulative Returns')
plt.xticks(fontsize=14, rotation=0)
plt.yticks(fontsize=14, rotation=0)
plt.show()

Printing the key fintech metrics

print(cl('MAX LOSS:', color = 'red', attrs = ['bold']), f'${max_loss};', 
      cl('MAX PROFIT:', color = 'green', attrs = ['bold']), f'{max_profit};', 
      cl('TOTAL TRADES:', attrs = ['bold']), f'{no_of_trades};',
      cl('WIN RATE:', attrs = ['bold']), f'{round(win_rate)}%;',
      cl('AVG. TRADES/MONTH:', attrs = ['bold']), f'{round(no_of_trades/120)};',
      cl('AVG. EARNING/MONTH:', attrs = ['bold']), f'${round(strategy_earning/120)}'
     )

MAX LOSS: $-529.55; MAX PROFIT: 3633.92; TOTAL TRADES: 22; WIN RATE: 91%; AVG. TRADES/MONTH: 0; AVG. EARNING/MONTH: $181

Buy-Hold Strategy Returns

Calculating the buy-hold ROI

#BUY and HOLD
nvd_roi = round(list(nvd['close'].pct_change().cumsum())[-1],4)*100
print(cl(f'BUY/HOLD STRATEGY ROI: {round(nvd_roi,2)}%', attrs = ['bold']))

BUY/HOLD STRATEGY ROI: 73.25%

SPY Benchmark Returns

Calculating the SPY ETF benchmark ROI

import math
myamount=10000
profit_percentage=roi
def get_benchmark(start_date, investment_value):
    spy = get_historical_data('SPY', start_date)['close']
    benchmark = pd.DataFrame(np.diff(spy)).rename(columns = {0:'benchmark_returns'})
    
    investment_value = investment_value
    number_of_stocks = math.floor(investment_value/spy[-1])
    benchmark_investment_ret = []
    
    for i in range(len(benchmark['benchmark_returns'])):
        returns = number_of_stocks*benchmark['benchmark_returns'][i]
        benchmark_investment_ret.append(returns)

    benchmark_investment_ret_df = pd.DataFrame(benchmark_investment_ret).rename(columns = {0:'investment_returns'})
    return benchmark_investment_ret_df

benchmark = get_benchmark(mydate, myamount)

investment_value = myamount
total_benchmark_investment_ret = round(sum(benchmark['investment_returns']), 2)
benchmark_profit_percentage = math.floor((total_benchmark_investment_ret/investment_value)*100)
print(cl('Benchmark profit by investing $10k : {}'.format(total_benchmark_investment_ret), attrs = ['bold']))
print(cl('Benchmark Profit percentage : {}%'.format(benchmark_profit_percentage), attrs = ['bold']))
print(cl('Scalping Strategy profit is {}% higher than the Benchmark Profit'.format(profit_percentage - benchmark_profit_percentage), attrs = ['bold']))

Benchmark profit by investing $10k : 1587.26
Benchmark Profit percentage : 15%
Scalping Strategy profit is 201.94% higher than the Benchmark Profit

VaR Random Simulations

Using the close price to calculate the mean return and volatility

prices = nvd['close']
returns =prices.pct_change().dropna()
volatility = returns.std()
mean_return = returns.mean()
volatility
0.08559207027897263
mean_return
0.0348814533103655

Using the last price as the initial price

initial_price =prices.iloc[-1]

Defining the parameters for prices simulation

initial_price =prices.iloc[-1]  # Use the last price as the initial price
num_simulations = 400  # Number of simulations
confidence_level = 0.95  # Confidence level for VaR estimation
duration = 260

Running the random simulations and calculating VaR

price_paths = np.zeros((num_simulations,duration))

for i in range(num_simulations):
    price_paths[i, 0] = initial_price

    for day in range(1, duration):
        drift = mean_return * (1 / duration)
        shock = volatility * np.random.randn() * np.sqrt(1 / duration)
        price_paths[i, day] = price_paths[i, day - 1] * (1 + drift + shock)

# Calculate daily returns for each simulation
returns = (price_paths[:, 1:] - price_paths[:, :-1]) / price_paths[:, :-1]

# Calculate the portfolio value at the end of 2023
portfolio_value = 10000  # Example portfolio value
portfolio_returns = portfolio_value * returns

# Calculate the VaR
sorted_portfolio_returns = np.sort(portfolio_returns)
var_index = int(num_simulations * (1 - confidence_level))
var = -sorted_portfolio_returns[var_index]

Plotting slices of the portfolio returns 2D array

print(portfolio_returns.shape)
(400, 259)

port1=portfolio_returns[:,0]
x = np.arange(0, 400)
y=port1
# plotting
plt.figure(figsize=(10,6))
plt.title("Portfolio Returns") 
plt.xlabel("Simulation Number") 
plt.ylabel("Returns") 
plt.plot(x, y, color ="red") 
plt.show()

Portfolio Returns vs Simulation Number: Time Slot 1

# Creating plot
plt.figure(figsize=(4,6))
plt.boxplot(port1)
plt.ylabel("Returns")  
# show plot
plt.show()

port1=portfolio_returns[:,250]
x = np.arange(0, 400)
y=port1
# plotting
plt.figure(figsize=(10,6))
plt.title("Portfolio Returns") 
plt.xlabel("Simulation Number") 
plt.ylabel("Returns") 
plt.plot(x, y, color ="red") 
plt.show()

Portfolio Returns vs Simulation Number: Time Slot 249

# Creating plot
plt.figure(figsize=(4,6))
plt.boxplot(port1)
plt.ylabel("Returns")  
# show plot
plt.show()

port11=portfolio_returns[0,:]
x = np.arange(0, 259)
y=port11
# plotting
plt.figure(figsize=(10,6))
plt.title("Simulation Returns") 
plt.xlabel("Duration") 
plt.ylabel("Returns") 
plt.plot(x, y, color ="blue") 
plt.show()

# Creating plot
plt.figure(figsize=(4,6))
plt.boxplot(port11)
plt.ylabel("Returns")   
# show plot
plt.show()

port11=portfolio_returns[300,:]
x = np.arange(0, 259)
y=port11
# plotting
plt.figure(figsize=(10,6))
plt.title("Simulation Returns") 
plt.xlabel("Duration") 
plt.ylabel("Returns") 
plt.plot(x, y, color ="blue") 
plt.show()

# Creating plot
plt.figure(figsize=(4,6))
plt.boxplot(port11)
plt.ylabel("Returns")    
# show plot
plt.show()

Plotting VaR: Returns vs Duration

x = np.arange(0, 259)
y=var
# plotting
plt.figure(figsize=(10,6))
plt.title("VaR") 
plt.xlabel("Duration") 
plt.ylabel("Returns") 
plt.plot(x, y, color ="blue") 
plt.show()

Box plots Returns vs Simulation Slots 1–5

data_1 = portfolio_returns[1,:]
data_2 = portfolio_returns[101,:]
data_3 = portfolio_returns[201,:]
data_4 = portfolio_returns[301,:]
data_5 = portfolio_returns[399,:]
data = [data_1, data_2, data_3, data_4,data_5]
plt.figure(figsize=(8,6))
plt.boxplot(data)

plt.xlabel("Simulation Slot") 
plt.ylabel("Returns") 
# show plot
plt.show()

Box plots Returns vs Simulation Slots 1–5

Customized box plots Returns vs Simulation Slots 1–5

data = [data_1, data_2, data_3, data_4, data_5]
 
fig = plt.figure(figsize =(10, 7))
ax = fig.add_subplot(111)
 
# Creating axes instance
bp = ax.boxplot(data, patch_artist = True,
                notch ='True', vert = 0)
 
colors = ['#0000FF', '#00FF00', 
          '#FFFF00', '#FF00FF','#00FFFF']
 
for patch, color in zip(bp['boxes'], colors):
    patch.set_facecolor(color)
 
# changing color and linewidth of
# whiskers
for whisker in bp['whiskers']:
    whisker.set(color ='#8B008B',
                linewidth = 1.5,
                linestyle =":")
 
# changing color and linewidth of
# caps
for cap in bp['caps']:
    cap.set(color ='#8B008B',
            linewidth = 2)
 
# changing color and linewidth of
# medians
for median in bp['medians']:
    median.set(color ='red',
               linewidth = 3)
 
# changing style of fliers
for flier in bp['fliers']:
    flier.set(marker ='D',
              color ='#e7298a',
              alpha = 0.5)
     
# x-axis labels
ax.set_yticklabels(['1', '100', 
                    '200', '300','400'])
 
# Adding title 
plt.title("VaR Monte Carlo Simulation",fontsize=18)
plt.xlabel("Returns",fontsize=16)
plt.ylabel("Simulation Slot",fontsize=16)
 
# Removing top axes and right axes
# ticks
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
     
# show plot
plt.show()

Customized box plots Returns vs Simulation Slots 1–5

Conclusions

The NVDA 2023–24 backtesting results by investing $10k are as follows: EARNING: $21693.57 ; ROI: 216.94%

MAX LOSS: $-529.55; MAX PROFIT: 3633.92; TOTAL TRADES: 22; WIN RATE: 91%; AVG. TRADES/MONTH: 0; AVG. EARNING/MONTH: $181

BUY/HOLD STRATEGY ROI: 73.25%

Benchmark profit by investing $10k : 1587.26
Benchmark Profit percentage : 15%
Scalping Strategy profit is 201.94% higher than the Benchmark Profit

The estimated volatility is 0.085 and mean return is 0.035.
We have shown that NVDA scalping can be a profitable trading approach with a 91% win rate but requires careful risk management, algo-trading backtesting and benchmarking.

Backtesting the NVIDIA Scalping Strategy with SPY Benchmark & VaR Simulations

Reading Input Stock Data

Calculating Trade Earnings

Backtesting Results

Plotting Scalping Returns

Buy-Hold Strategy Returns

SPY Benchmark Returns

VaR Random Simulations

Conclusions

References

Explore More

Contacts