wisebucks.ai/monteCarlo7Day.py

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

#Mote Carlo for 7 days

#start_price (initial stock price),
# days (number of simulation days),
# mu (average daily return of the stock),
# sigma (standard deviation of the stock’s daily returns)

#TO-DO for the next year: compare from previous year to next year
#change the value from one day to one month
#take data for all S&P 500

# uses yfinance library to get the stocks for analysis based on user inputs
start_date = input("Enter the start date (YYYY-MM-DD): ")
end_date = input("Enter the end date (YYYY-MM-DD): ")
stock_symbol = input("Enter stock ticker symbol (e.g., GOOGL): ")
prev_days = int(input("Enter the number of previous days you want to predict with in each simulation: "))
num_simulations = int(input("Enter the number of simulations you want in Monte simulation: "))

# Retrieve historical data for the specified stock and user-defined dates
data = yf.download(stock_symbol, start=start_date, end=end_date)
days = len(data) # Number of days in the data
dt = 1 / days  # Time interval

# Random seed for reproducibility
np.random.seed(42)
actual_price = data['Close'].iloc[-1]

def monte_carlo(start_price, days, mu, sigma):
    price = np.zeros(days + 7)  # Initializes price with zeros
    print(len(price))
    price[0] = start_price

    for x in range(1, days + 9):
        total_shock = 0
        for i in range(prev_days): #was initally for days
            total_shock += np.random.normal(loc=mu, scale=sigma)  # Accumulate shocks from previous days
        shock = total_shock / prev_days  # Average shock from previous days
        drift = mu * dt  # Expected change in price based on the average daily return

        # computed by applying the drift and shock components to the previous day’s price and stores that in the price array
        price[x] = price[x - 1] + (price[x - 1] * (drift + shock))

    return price #compare all these prices curve and get accuracies for all of these prices

#new accuracy method
def accur(start_date, end_date, days, mu, sigma, start_price, prev_days):
    price = np.zeros(days)  # initializes prices with 0
    price[0] = start_price
    accuracies = []

    print('hello')

def accuracies(start_price, days, mu, sigma, prev_days):
    dt = 1 / days
    price = np.zeros(days)
    price[0] = start_price
    accuracies = []

    for x in range(1, days):
        total_shock = 0
        for day in range(days):
            total_shock += np.random.normal(loc=mu, scale=sigma)
        shock = total_shock / days
        drift = mu * dt

        price[x] = price[x - 1] + (price[x - 1] * (drift + shock))

        predicted_price = price[x]
        accuracy = (1 - abs(actual_price - predicted_price) / actual_price) * 100
        accuracies.append(accuracy)

    return accuracies

#accuracies to be plotted
# def accuracies(start_price, days, mu, sigma, prev_days):
#     price = np.zeros(days)  # initializes prices with 0
#     price[0] = start_price
#     accuracies = []
#
#     for x in range(1, days):
#         total_shock = 0
#         for day in range(prev_days):
#             total_shock += np.random.normal(loc=mu, scale=sigma)  # Accumulate shocks from previous days
#         shock = total_shock / prev_days  # Average shock from previous days
#         drift = mu * dt  # Expected change in price based on the average daily return
#
#         # computed by applying the drift and shock components to the previous day’s price and stores that in the price array
#         price[x] = price[x - 1] + (price[x - 1] * (drift + shock))
#
#         # Calculate accuracy for the current day and store it
#         predicted_price = price[x]
#         actual_price = data['Close'].iloc[x]  # Actual price for the current day
#         accuracy = (1 - abs(actual_price - predicted_price) / actual_price) * 100
#         accuracies.append(accuracy)
#
#     return accuracies

# Perform x amount of Monte Carlo simulations for the specified stock
sim = np.zeros(num_simulations)
plt.figure(figsize=(15, 8))

# need 7 different arrays, one for each of the days within the week for predicting the price for X stock
sim1 = np.zeros(num_simulations)
sim2 = np.zeros(num_simulations)
sim3 = np.zeros(num_simulations)
sim4 = np.zeros(num_simulations)
sim5 = np.zeros(num_simulations)
sim6 = np.zeros(num_simulations)
sim7 = np.zeros(num_simulations)

for i in range(num_simulations):
    start_price = data['Adj Close'].iloc[0] #retrieves the adjusted closing prices of all the stocks in your datase
    # and indexes into the 'Adj Close' column to select the specific stock symbole
    mu = data['Adj Close'].pct_change().mean() #mean of daily percentage values entire year
    sigma = data['Adj Close'].pct_change().std()   #standard deviation of daily percentage values
    result = monte_carlo(start_price, days, mu, sigma)

    sim[i] = result[days-1]  # final price is stored #TODO instead need to store final  7 day price here

    sim1[i] = result[(days + 1) - 1]
    sim2[i] = result[(days + 2) - 1]
    sim3[i] = result[(days + 3) - 1]
    sim4[i] = result[(days + 4) - 1]
    sim5[i] = result[(days + 5) - 1]
    sim6[i] = result[(days + 6) - 1]
    sim7[i] = result[(days + 7) - 1]

    plt.plot(result)

# for i in range (days, days + 8):
#     result = monte_


day_1_predicted_price = np.median(np.sort(sim1))
day_2_predicted_price = np.median(np.sort(sim2))
day_3_predicted_price = np.median(np.sort(sim3))
day_4_predicted_price = np.median(np.sort(sim4))
day_5_predicted_price = np.median(np.sort(sim5))
day_6_predicted_price = np.median(np.sort(sim6))
day_7_predicted_price = np.median(np.sort(sim7))

plt.xlabel('Days')
plt.ylabel('Price')
plt.title(f'7 Day Price Prediction of GOOGL')

predicted_prices = [day_1_predicted_price, day_2_predicted_price, day_3_predicted_price,
                    day_4_predicted_price, day_5_predicted_price, day_6_predicted_price, day_7_predicted_price]

plt.plot(range(1, 8), predicted_prices, marker='o', label='Predicted Prices')

# Adding legend
plt.legend()

# Show the plot
plt.show()

#---------------------------------------------------------------------------------------------------------------------

#prints out predicted price for next day and accuracy of that value compared to actual data
predicted_price = np.median(np.sort(sim))
print("Predicted price for the next day after " + end_date + f" is ${predicted_price:.2f}")
accuracy = (1- abs(actual_price - predicted_price) / actual_price) * 100
print("Accuracy: {:.2f}%".format(accuracy))

# sets axes and title for Graph #1
plt.xlabel('Days')
plt.ylabel('Price')
plt.title(f'Monte Carlo Simulation for {stock_symbol}')

# Perform Monte Carlo simulation to get accuracies for each day
accuracies_per_day = accuracies(data['Close'].iloc[0], days, data['Close'].pct_change().mean(),
                                  data['Close'].pct_change().std(), prev_days)

# Plotting accuracies for each day
plt.figure(figsize=(12, 6))
plt.plot(data.index[1:], accuracies_per_day, color='b', linewidth=1)
plt.xlabel('Date')
plt.ylabel('Accuracy (Decimal)')
plt.title(f'Accuracy of {stock_symbol} Predictions from {start_date} to {end_date}')
plt.xticks(rotation=45)
plt.tight_layout()

# Plot histogram
plt.figure(figsize=(10, 7))  #generates a histogram plot using the data from the sim array.
    # the sim array contains the simulated final prices of each of the stocks
plt.hist(sim, bins=100)
plt.figtext(0.6, 0.7, "Mean: {:.2f}\nStd: {:.2f}\nStart Price: {:.2f}".format(sim.mean(), sim.std(), start_price))
# adds text annotations to the figure at specific coordinates. It displays the mean, standard deviation, and start price of the simulated prices
plt.title(f'Histogram for Monte Carlo Simulations of {stock_symbol}')
plt.xlabel('Price')
plt.ylabel('Frequency')


#write next graph here

# Initialize lists to store accuracies and predicted prices
accuracies_list = []
predicted_prices_list = []

arr = []

# Iterate through the range from -30 to 30 days
# Think about price your predicting, if oprice goes up as well, otherwise consider a failure.
# where the error builds o
# if you make current predicition to next day
# quantize our final score
# need an alogiirhtm to combine all the tests
# if it is  anegative prediction, you do minus
# quantizing --> if predicting score is more (that way you factor + (predicited)/(actual)
# if you get a 60% movement accuracy better than S&P 500
for prev_days in range(-30, 30):  #-30, 30 Predict whether it goes up or down
    shifted_start_date = pd.to_datetime(start_date) + pd.DateOffset(days=prev_days)
    shifted_end_date = pd.to_datetime(end_date) + pd.DateOffset(days=prev_days)

    days = len(data)
    dt = 1 / days

    start_price = data['Close'].iloc[0]
    mu = data['Close'].pct_change().mean()
    sigma = data['Close'].pct_change().std()

    accuracy_values = accuracies(start_price, days, mu, sigma, prev_days)
    arr.extend(accuracy_values)

    mean_accuracy = np.mean(arr)
    accuracies_list.append(mean_accuracy)
    predicted_prices_list.append(prev_days)


plt.figure(figsize=(10, 6))
plt.plot(predicted_prices_list, accuracies_list, marker='o', linestyle='-', color='b')
plt.xlabel('Days Shifted')
plt.ylabel('Accuracy (%)')
plt.title('Accuracy of Predictions vs. Days Shifted')
plt.grid(True)

plt.show()