in the second part of AI stock predictions we will take a look at the second set of files which actually performs comprehensive Monte Carlo simulations now these files process and produce detailed data for different types of simulations let's take a look at that first this uh file eventually will

produce trading simulations and we'll see how they do that uh including with play money investment strategies for example when we had given it uh 20 days of prior data it ran the simulation for so many times and starting with an initial bankroll of 1,000 it was able

to reach uh $1,100 here it also ran the same simulation for 60 days and still returned a positive and also for 3 days past data still produced a positive which is a bit uh surprising but before we get deeper let's see how this works

so we have a data set for a particular stock price in this case Apple stock uh which includes the Open high low close and volume for each day starting from November 2023 since we are using GPT we made sure that all the data is after its

knowledge cut off date so it doesn't have any information so essentially what we're going to do with the simulations is we give it a prior range of data in this case just the closing price to start with this date range can be for example 3 day 10 days 3 days this

is really totally up to you and we pick a date range from this uh this range of data that we have up until recently uh and we pick a point and then we predict the next day we pick another point and predict the next day the simulation aspect of it actually does

This automatically, and it just picks different, automatically picks different parts from this data set and tries to predict the next day's price. So when we do that enough times, we accumulate data and we actually save it to, uh, detailed simulation results, trading simulation results, performance analysis with, uh

statistical data and also trading simulation analysis. So if you look at the performance report, we write the model number, that model name that we used for the simulation, uh, how many predictions we have made for each simulation because this is a Monte Carlo simulation after all, here in this case, 200, and we've run

this for 150 times, and we received an overall score based on direction accuracy, mean absolute error, for example, uh, and the uh, confidence range for, for example, direction accuracy with 3-day using 3-day historical data was from 48% to 57%. So it's leaning on the

positive side, which means this simulation was able to predict the direction of movement more often directly than not, which is surprising to me. And the trading simulation report actually, uh, put play money, pretends to bet or invest $1,000 each time and runs these trades

for example, if you take a look at the trade statistics, it was able to do 128 trades, there was 71 winning trades and 57 losing trades. The win rate was 55%, average win was 9.99, essentially it led up to the final

bankroll being 1100, so that is not actually significant across 12, I mean 128 trades I suppose, but it's 11% return. But before we continue, I do want to say this is not financial advice, this is built for research purposes only and

each one of these scripts will print that in the beginning as a disclaimer you should always uh do your own research and consult with a licensed financial advisor now um if you wanted to find the first part of this yeah you can find the first part of this video at

the description or search for it at my YouTube video I'll put a link to it but all these files will be available at my Patreon if you want to download it uh and the link for that will be in the description by becoming a patron you'll

also have access to 350 plus other interesting projects and the lowered projects so essentially let's if you review it one last time uh we uh go through four files we do increasing the complexity of simulations picking date ranges initially and running this picking different date ranges these are the predictions for

example if you were to if you were to look at this in this Sim if you were to leave it just like this done we are making four predictions in this particular simulation the Monte Carlo aspect of it is actually that we run this again and again as many times as we

like so here in this case we are making four predictions for three separate runs and we accumulate the results and save it so this is pretty useful if you wanted to experiment and see what works uh in if you look at the first file this is just to predict the ranges as you can

see we have data ranges the test 3 days 10 days and 30 days we want to make 30 predictions per range and we also have performance weights Direction accuracy if it has 40% weight mean absolute error has 30% and whether the prediction was

within 1% of the actual price is 30% um rate. You can change these, but in the second one, we introduced simulations to enhance this. Monte Carlo simulation, so now we can taste test as many ranges. You can also specify a particular model and run this uh simulation across

these data ranges, making this many predictions and run this uh 10 times. This script will run it 10 times. You can also specify your model uh and prior files which will also be included with this, such as get price range. You can specify a stock ticker and

it'll download uh the necessary information which you can use. Now, the third file actually does this with simulated money investments. Here, you can specify the bankroll and the trade amount for each trade, and the final one actually adds an additional complexity where you can enter additional data

points. If you look at our database, it has uh opening price, high price, low, close, and the volume values. But most of our simulations only take a look at the closing price. But this final file, you can actually specify any number of combinations of close, open, high, low, or

volume, so you will also test that. This is also a Monte Carlo simulation which you can run as many times as you like. Again, this is not financial advice and is meant for research purposes. Each file comes with a detailed description of what it does, and we will be reviewing

the code actually shortly, but essentially uh this is just to get an idea if you want to test different strategies and see how powerful LMS are in this aspect. Now, as far as the complexity of the code, the final code that runs tests different data ranges uh

across with different data points is about a thousand lines of code. I will actually get my AI code explainer to explain this, uh, so I think it'll be easier. But most of the code is actually uh related to generating the report and writing the report

properly. Uh, so that takes up quite a lot of space and also using Yahoo Finance, the dealing with date ranges is a bit, was a bit difficult. But if you quickly look, this is a Monte Carlo stock price prediction analysis using AI. The original file tests multiple historical

data ranges, parallel processes them, generates detailed performance metrics and visualizations, implements direction accuracy and error analysis, produces comprehensive reports and plots. The second one introduces uh Monte Carlo stock price prediction simulation with multiple data ranges. So you can actually here run multiple simulations. So this is what it

introduces, you can run this same simulation multiple times. The third one introduces uh play data training simulation and also a comprehensive report about that. And the fourth file introduces different data points, as we have talked about. Okay, so now I'll uh let go

ahead and let my AI code reviewer review this code. It's quite complex, but it's actually the original, the actual logic of it is not so complex, uh, as you will see. And the AI code reviewer is also available at my Patreon

for download for at Architect level. You can find the link for that in the description as well. And also if you are enjoying my content, you can find more of it at my website and my YouTube channel. My website is eivedolive.com. In this

website you can search and browse through all my projects, over 400 of them. And if you do become a patron, you have a convenient mod download link which takes you to my Patreon where you can actually download the project files for each one of these projects. As a patron, you'll

also gain access to my THX cursor course which has 19 chapters of full with cursor, uh, over 28, sorry, 28 chapters over 19 hours of content. The first two chapters are free. Uh, I think my patrons find this very useful. Now let's just go

ahead and review the code for the final file where we perform multi simulation with Monte Carlo with different data points. This segment sets the stage for the entire simulation program. It begins by importing essential libraries which range from data handling, pandas, numpy, and visualization, matplotlib, to async

handling, asyncio, and API interactions, openAI. Think of it as stocking up your coding toolbox before diving into the DIY project. Then it establishes various constants that define the parameters of the Monte Carlo simulation. These include settings for how many simulations to run, JSON file

configurations for results and weights for performance metrics, ensuring that when your AI makes grand predictions it follows some rules of engagement. The segment also addresses a very important aspect, disclaimer and user acceptance. Since the AI driven predictions can sound promising, a disclaimer message is displayed to

remind users about the risks of financial trading and the potential limitations of AI models in this domain. This guardrail is in place to prevent users from treating AI predictions as financial gospel. Overall, this section lays down the ground rules and prepares the environment for conducting the

simulations and analyses that follow this snippet introduce the star of the trading simulation show, the Trade Simulator class. It's like the financial analyst you wish you had during your last stock pick misadventure. The Trade Simulator is responsible for executing mock trades based on the

predictions, tracking profit and loss because who doesn't love keeping score, and generating performance reports. The `score_init` method sets up the initial bankroll and creates data structures to hold trade records and balance history. Think of it as setting up your initial piggy bank before you start throwing imaginary

money around. The `simulate_trade` method calculates the profit or loss based on predicted stock price movements and records each trade's details. Every time your AI predicts a positive move, this method decides if it's the right time to invest. Finally, the `generate_trade_report` method summarizes the trading

performance, providing insights like win rates and Returns on Investment (ROI). It's like getting a financial report card after each simulation run without the heartbreak of seeing your real money dwindle. Overall, this class is crucial for the script as it brings the stock market predictions to life by simulating

trades, allowing you to evaluate how well the predictive model performs in a mock trading environment. Here's where the predictive magic, or so we hope, happens. The `get_prediction` function is an async function designed to extract stock price predictions from the GPT-4 model. It's like

asking your clever friend, except it's an AI, about tomorrow's stock price movements but with a strict rule to answer in a specific format. The function constructs a well-formatted prompt using historical data points like close and open prices, which are sent to GPT-4 aiming to receive a neat prediction.

wrapped in prediction tags, it's crucial that GPT-4 sticks to these tags. Otherwise, parsing becomes like dealing with an indecipherable stock pick mumbled at a noisy party. This function also ensures predictions are reasonable by comparing the predicted price to the last known price, flagging anything that

looks like a wild guess. Imagine predicting the Dow would jump 50% overnight. Using a semaphore ensures that only a set number of predictions can run concurrently, preventing overload on the API server. It's like politely queuing for your ice cream instead of mob

overrunning the vendor. Now that we have our prediction mechanism, 'make predictions' steps in as the orchestrator. Its role is to manage the hustle and bustle of multiple prediction tasks, ensuring everything runs smoothly in parallel, akin to a Broadway stage manager. This async function cycles

through potential prediction points in the stock data, applying historical data for prediction, and orchestrates multiple calls to get predictions. It hands each task a semaphore, the backstage pass to the API, to ensure an orderly procession. Crucially, this function also integrates with our trade simulator, processing

predictions into simulated trades. You could say each prediction is like casting a spell: it either works and you gain, or it backfires and you learn. The results are tallied, including the crucial information needed to assess how predictions fared against real outcomes. And trades are tracked in a neatly

structured result package. This function thus stands as a key piece in enabling the simulator to evaluate prediction accuracy and hypothetical trading success across multiple scenarios. In the world of stock simulation, it's not all about making predictions, they need to be analyzed and reported. That's where the 'generate'

report function struts onto the stage turning raw prediction data into a polished summary of performance. This function collates the predictions, calculates key error and accuracy metrics like the mean absolute error and directional accuracy, and provides a breakdown of results. Think of it as the teacher grading a particularly

math-heavy test, except here the questions are stock price predictions and the stakes are your hypothetical gains and losses. Each prediction's authenticity is cross-verified with actual stock movements to determine if the prediction's directional hunch was correct: positive prediction direction matched with real upward stock movement,

gold star; negative direction followed by a stock fall, another gold star. Finally, the function synthesizes all this data into a coherent textual report, crowning the multi-day simulation journey with insights that guide future predictive explorations. In many ways, this report is as close as you get to receiving your

stock prediction driver's license, full of constructive feedback to navigate the market's unpredictable highways. The calculate performance metrics function is our analytical tool, breaking down the performance of a set of predictions into comprehensible metrics. If predictions were book reports, this function would be the rubric against which they're graded.

This utility calculates several error metrics such as the mean error (ME), mean absolute error (MAE), and root mean square error (RMSE), offering a quantitative assessment of prediction precision. It also checks if predicted and actual price directions aligned, contributing to a directional accuracy percentage – arguably the MVP in assessing a prediction

model's reliability. These metrics allow for grounding predictions in quantifiable measures, providing a solid basis for evaluating the model's overall effectiveness and for benchmarking against other simulation runs. If predicting stocks were like shooting arrows, then this function tells us how

Often our model hit the bullseye or barely grazed the outer rim in steps. The test data range function is designed to evaluate how our predictive model performs over a specified historical data period. Consider it as embarking on a research expedition to uncover secrets

hidden within time sequences of stock data. For each data range, this function launches the prediction tasks leveraging the make predictions function for handling hefty workloads in parallel. Once the predictions are in hand, performance metrics are calculated to measure how the simulation fares in this particular

context. By focusing on specific data ranges, this function allows a fine-grained evaluation of how well the model predicts, not just in general, but based on varying lengths of historical data. It's akin to checking different weather forecasts over multiple timelines to decide if flimsy umbrellas or rugged

raincoats are in order. In essence, test data range ensures the simulation doesn't just guess at stocks haphazardly, but reflects carefully on what diverse historical data lengths mean for prediction accuracy. Here we dive into packaging our findings. The serialized results and generate performance report

functions handle the transformation of raw simulation data into structured summaries and reports. The serialized results function extracts vital metrics from simulation results, readying them for storage in lightweight, efficient JSON format. Picture this as a kind of Marie Kondo tidying, only key metrics that spark joy are serialized for

posterity and further analysis. Then comes the generate performance report, a function that assembles a detailed report based on simulation outcomes, tracing the journey from prediction to hypothetical wealth or its potential absence by synthesizing metrics with weights and calculating overall scores. This function ranks simulations by their

perceived performance. If your predictions were a sports league, this function would be the commentator announcing the ranking with detail and flare. Crucially, this report includes insights on trading performance and ROI, ensuring that both your stock picking acumen and trading hustle are properly

accounted for. It's comprehensive and insightful, about as glamorous as stock prediction analysis can get without an accompanying slideshow. Our simulation efforts culminate in the aggregate simulation results function, which combines results from multiple runs into a comprehensive, concise overview. Think of it as baking all the

individual pie slices into a grand finale cheesecake. This function aggregates performance metrics across different data ranges, averaging out the variations to discern consistent patterns and anomalies. It relies heavily on storing directional accuracy, error metrics, and scores derived using predefined weights,

giving each metric its due importance in the grand scheme. By generating averages, standard deviations, and confidence intervals, this function enables us to not only see how our prediction model performs on isolated runs but gain an understanding of how stable these performances are over various conditions. To borrow from finance, once

more aggregation like this is like weighing one's entire investment portfolio and assessing risk diversification based on trends and metrics that cut through the single run noise. This function is crucial for delivering those insights and making the case that this model's predictions are

worth considering or improving. In practical applications, our statistical magic moment in the limelight—that's the generate statistical report function, which crafts a meticulous narrative from the aggregated results of multiple simulation endeavors. This function synthesizes how simulations pan out over various data

ranges compiling mean metrics, standard deviations, and confidence intervals. You could say it's the analytic crescendo where everything from prediction precision to performance consistency is harmonized into a comprehensive report. It ranks these metrics meticulously, guiding end users through the intricate performance landscape navigated by this

AI-driven simulator. If predictions are wandering thoughts, then this report provides the map, spotlighting each significant point of interest with empirical coordinates. Metrics into how the simulation truly performed. Finally, it logs the results to preserve them for future introspection and decision-making because in the stock world and beyond

insight isn't just knowledge, it's value, and this report embodies just that. Now that we've seen parts of the simulation process, the 'Run Single Simulation' function brings it all together. Picture it as pressing launch on the simulation rocket. It coordinates the execution of the entire test routine for a given run

for each data range that needs testing, tasks are assembled to analyze predictions concurrently using asyncio. Do gather this multitasking capacity is essential given the lemonade stand, I can concurrency limit on API usage we set up earlier. Following this, the 'Print Trading Summary' function offers a postmortem on the simulation

detailing trading outcomes in all tested scenarios. It's where predictions meet their reckoning and the trading strategy's efficacy is publicly flaunted or lambasted. It summarizes the wins, losses, and key financial indicators akin to a postgame wrap-up where winners are

lauded and highlights or lowlights are replayed. By pairing these two functions, the program efficiently executes individual simulations and then communicates the wealth or woe that could have resulted had these trades been real. Welcome to the grand orchestration, the main function. This is the script's central

Operations Command, where all roads of logic, prediction, and analysis converge to form a coherent simulation. The main begins by setting the stage for Monte Carlo simulations, detailing configuration specifics and setting up the environment, fetching stock data, initializing semaphore limits. It spools up the necessary async tasks, tucking

them under its wing before firing them off concurrently with async sh. Gather to simulate each run. Post simulation, the program aggregates results, averages crucial metrics, and formulates comprehensive reports. This phase isn't just about number crunching; it's where insights are

synthesized and mapped out. Finally, it handles the detailed logging of results and their respective insights, from trading outcomes and performance assessments to statistical reports. It's like the end credits of a movie, providing clarity and closure on all goals achieved and narrative threads

explored. When run, the main function ensures all our different snippets interlock smoothly, achieving the script's overall aim to simulate potential stock trading scenarios and analyze their outcomes with a touch of AI foresight. Whether you're banking on this AI-driven adventure for serious

insight or just a glimpse into predictive models, this function holds the key. I would like to take a moment to talk about the benefits of becoming a patron. Some of you may know in the last year and a half I've spent 3,000 hours

over 300 uh projects. As a patron, you will have access to all the code files so you can get inspiration and iterate quickly. Another benefit is that you'll have access to all my courses and my most recent and most proud one, the THX Master Class, teaching how I, what I've

learned on how to code fast and efficiently. All the Streamlit course and the FastAPI course in my Patreon, I also have TI in which you can connect with me one-on-one. Check those out as well. I've now listen to me, I've been trying to

Toad and you know like I like toading the fact that I can code and make things happen, but how do I do it? I mean, fast with AI. I heard about it, it's easy, so um I came across Talon X cursor course

and that's great, you know, it just made everything super silky smooth, it just it just worked. I'm I'm telling you, uh THX, you're coding

LLM Stock predictions Monte Carlo simulator Python script

I have spent over 3000 hours learning and coding over 300 projects and share everything I have learned in these YouTube videos. I hope you will find them useful :)
search all echohive videos: https://www.echohive.live/
You can download the souce code to all my projects by becoming a Patron
