Pricing American Options using Machine Learning Algorithms

Risk neutral pricing is a fundamental concept in financial mathematics used to evaluate the fair value of derivatives contracts, such as options, in a manner that accounts for risk without introducing arbitrage opportunities [4]. This approach relies on the assumption that investors are indifferent to risk when pricing financial assets, allowing for a simplified valuation framework [4].

Considering a model economy with risky assets $n_{S}$, risk-free assets $\beta$, and risky assets $S_{i}$. An equation for a differential is followed by the risk-free asset $\beta$:

where the risk-free interest rate is denoted by $r(t)$. The stochastic differential equation governing the hazardous assets $S_{i}$ in the real-world measure $P$ is as follows:

where $dW^{P}_{i}$ is a $n_{S}$-dimensional standard Brownian motion, $\sigma_{i}(t)$ represents the asset’s volatility, and $\mu_{i}(t)$ represents the asset-dependent drift term [5].

The price $V(S(t_{0}),t_{0})$ of a European type contract in a complete market is determined by the expected value of the future price $V(S(t_{1}),t_{1})$ in relation to the risk-neutral measure $Q$ [4], given as follows:

The equation (3) ensures that there are no arbitrage opportunities in the market. The measure $Q$ is unique under the assumption of an arbitrage-free market. In the risk-neutral measure $Q$, all the drift terms of the risky assets $S_{i}$ are given by the risk-free interest rate $r(t)$:

where $\sigma_{i}$ is the asset’s volatility, and $W^{Q}_{i}(t)$ is a standard Brownian motion in the $Q$ measure. The relationship between the Brownian motions $W^{Q}_{i}(t)$ and $W^{P}_{i}(t)$ is given by:

where $\nu_{i}(t)$ satisfies $\mu(t)=r(t)+\sigma_{i}\nu_{i}(t)$. Notably, the volatilities $\sigma_{i}$ remain the same under this change of measure, allowing for the estimation of $\sigma_{i}$ from real-world observations of the asset price processes $S_{i}$.

It is instantly evident from combining the differential equations for the risky and risk-free assets that the ratio $\frac{S_{i}}{\beta}$ is a drift-free process [6]:

Risk-neutral pricing provides a powerful and wide framework for valuing financial derivatives, offering simplicity and tractability in complex market environments. By incorporating the principles of risk neutrality, financial analysts can derive fair prices for derivatives contracts, facilitating informed investment decisions and risk management strategies.

A European option is a form of options agreement where execution is restricted solely to its expiry date [7]. This means that investors cannot exercise the option prematurely regardless of any fluctuations in the price of the underlying security such as a stock. The execution of the call or put option is only permitted on the date of the option’s maturity. At time $t$, the cost of a European option is provided by

where $h(S,T)$ is the payoff of the option at maturity, e.g.,

with $K$ the strike of the option.

Options with an extra right for the contract holder are known as American options. Anytime prior to or on the day of expiration, the option may be exercised. Due to this additional right, an American choice may be worth more than a European option. The European option will always have a higher payoff if it is exercised before it expires, so the American option can never be worth less than the European option. However, in certain situations, the extra right to exercise it early may allow for a higher payoff [7].

An American option holder may exercise their right to do so at any time up until and including maturity, unlike holders of European options. Because of this qualitative difference, in the American context as compared to the European case, the option holder has more rights. An American option’s pricing must be at least equal to that of a comparable European option.

An American option holder must continually check the price of the underlying asset throughout the option’s lifetime and determine if the option’s price exceeds the instant payout they would get if they exercised the option at this particular moment. It can be shown that the price $V(S,t)$ of an American option is provided by

where the ideal stopping time supremum is attained $\tau^{*}$

For the first time, the option’s price is below what the holder would receive if they exercised it at this particular moment.

In the work [8], Monte Carlo simulation is introduced into the financial domain and Monte Carlo techniques are used to price structured goods. These techniques provide an effective approximation of the option price, especially for multidimensional issues like derivatives with numerous underlying assets. European options in particular benefit from this, but American options can also be priced rather effectively. The following is the fundamental notion underlying the Monte Carlo Simulations technique for an option with payoff $h$. The price of the derivative is determined by explicitly computing the expected value of the discounted payoff, as it is in equation (7), using these paths to create a (large) sample of random processes of the equation (4) for the underlying stochastic processes.

Solving the following system of coupled stochastic differential equations is necessary in order to simulate the paths of the underlying assets.

where $r(t)$ is the deterministic interest rate and $\mathbf{W}$ is a $n$-dimensional $Q$-Brownian motion with correlation matrix $\rho_{ij}$.

This can be accomplished most conveniently with the Euler-Maruyama approach. [8] has a thorough introduction. For a time mesh $t_{j}=t_{0}+jdt$, $j=1,\ldots,\text{nstep}$, step size $dt$, essentially, simulating random pathways means computing

where $Z_{j}(t)$ are independent standard normal random variables, and $B_{ij}$ is derived from the Cholesky decomposition of the correlation matrix $\rho_{ij}$.

With a European option, the Black-Scholes model may precisely sample the end-point of the pathways, which is the sole point that matters for the payout and doesn’t require Euler-Maruyama time-stepping. We can calculate the value of the payout at maturity for each path after generating an ensemble of random values for the underlying assets’ value at maturity, $S^{j}_{i}(T)$. The current option price can be obtained by averaging the discounted payoffs of all simulated paths, as illustrated in Figure 1. The standard deviation can be used to calculate the degree of price uncertainty.

To price an American option using Monte Carlo simulation for $n$ underlying assets, a backward iteration algorithm is employed. The Least Squares Monte Carlo (LSM) algorithm is a method for pricing options by simulating potential future paths of the underlying asset’s price and recursively working backward through time. It begins by generating random paths for the asset’s price and setting the option’s payoff at maturity based on the payoff function. Then, starting at maturity, it discounts future payoffs, performs regression analysis to estimate continuation values, and compares them to immediate exercise values to determine whether to exercise the option. This process iterates backward through time until the present. At the final time step, option values are discounted back to the present, and the option price is computed by averaging over all paths. LSM is particularly effective for pricing American-style options due to its ability to account for early exercise opportunities through regression analysis, making it a versatile and accurate approach for pricing complex derivatives.

Expand the continuation value $c(\mathbf{S})$ (as a function of the underlying asset price) at each time step $t_{i}$ in terms of a function basis $\psi_{j}$. Be aware that it costs a lot of money to compute an option’s continuation value. Consequently, using a least squares regression to approximate the continuation value at each time across all pathways,

where the expansion coefficients $\beta_{k}$ are obtained by a least squares fit to the (discounted) values of the option at the next time step:

where $B_{\psi\psi}$, $BV_{\psi}$ at time step $t_{i}$ are given by

and the expectation is over the ensemble of paths.

Unlike when the price is chosen to replicate the early exercise decision

for all paths $j$ where $h(S_{j}(t_{i}))>e^{-\int_{t_{i}}^{t_{i+1}}r(s)ds}V_{j}(t_{i+1})$ in step 6b in Figure 2, in some papers like [10] assume that the non exercised value is the continuation value

Its disadvantage is that the sampling error is compounded by the difference between $c$ and $h$,

where

• •

  $t_{i}$: Represents each time step in the option pricing process.

• •

  $c(\mathbf{x},t_{i})$: The continuation value of the option at time $t_{i}$, where $\mathbf{x}$ denotes the underlying asset price.

• •

  $h$: The payoff function of the option.

• •

  $V(S(t_{i}+1))$: The value of the option at the next time step $t_{i+1}$ given the asset price $S(t_{i}+1)$.

• •

  $\psi_{j}$: A function basis used for expansion.

• •

  $\beta_{k}$: Expansion coefficients obtained through a least squares fit.

• •

  $n_{\text{order}}$: The order of the expansion.

• •

  $B_{\psi\psi}$: The matrix of expectations of the product of basis functions.

• •

  $BV_{\psi}$: The vector of expectations of the product of the option value and basis functions.

Figure 2 shows the American option pricing and detailing algorithm of the Longstaff-Schwartz method for using least squares regression in step 6 to calculate the continuation value c. The solution of equation (14) to obtain equation (13) is explained in detail in steps 6a and 6b in the purple boxes [11].

This section details how various machine learning models can be integrated into the Least Squares Monte Carlo (LSM) algorithm to enhance the pricing of American options. The machine learning models discussed include XGBoost, LightGBM, logistic regression, k-nearest neighbors (kNN), decision tree, and random forest.

In the LSM algorithm in Figure (2) for pricing American options, machine learning models are primarily involved in Step 6a, where the continuation value is estimated through regression. Traditionally, this step uses linear regression to estimate the relationship between the current state variables and the future payoffs. However, integrating machine learning models such as XGBoost, LightGBM, logistic regression, k-nearest neighbors (kNN), decision trees, and random forests can significantly enhance this process. These models are trained on the simulated paths and their corresponding discounted payoffs $V_{j}(t_{i+1})$, allowing them to capture complex, non-linear relationships in the data. By doing so, they can provide more accurate predictions of the continuation value $c_{j}$ for each path $j$. For example, XGBoost and LightGBM are gradient-boosting models that can handle large datasets with intricate interactions, while decision trees and random forests can model non-linear relationships effectively.

Once the machine learning model is trained, it replaces the traditional linear regression formula $B_{VV}\beta=B_{Vy}$ used to calculate the regression coefficients $\beta$. In this enhanced approach, the model predicts the continuation value $c_{j}$ for each path based on the state variables $S_{j}(t_{i})$. These predicted continuation values are then used to determine whether to exercise the option or to continue holding it (Step 7). If the payoff from exercising the option is greater than the predicted continuation value, the option is exercised; otherwise, it is not. By leveraging machine learning models in this critical step, the LSM algorithm can achieve more accurate and robust option pricing, as these models can generalize better to complex and high-dimensional state spaces than traditional linear regression.

Inspired by the architecture and operation of the human brain, neural networks (NNs) are a fundamental idea in machine learning. NNs are fundamentally made up of linked nodes arranged in layers. Data is received by input layers, information is processed by hidden levels, and output layers generate output. The capacity of NNs to learn from data and modify internal parameters (weights) during training to maximize performance is what gives them their strength [12].

RNNs are a specific type of NN made to work with sequential data. They provide the idea of memory, which allows the network to remember data from earlier inputs. For jobs like pricing American options, where historical prices and market conditions might affect future decisions, this memory is essential [12].

Detailed working principals of Recurrent Neural Networks (RNNs) are presented as follows:

• •

  Sequential Methodology: RNNs, in contrast to conventional neural networks, are made to handle data sequences. They accomplish this by sequentially accepting inputs one at a time.

• •

  Repeated Relationships: An RNN’s recurrent connections are its primary characteristic. The network can maintain some sort of "memory" thanks to these links. The RNN processes the current input and a "hidden state" from the previous phase at each step in a sequence. Information gleaned from earlier inputs is contained in this hidden state.

• •

  Secret State: At every time step $t$, the hidden state $h_{t}$ is updated using the prior hidden state $h_{t-1}$ as well as the new input $x_{t}$. In mathematics, this is commonly expressed as:

  $$h_{t}=\phi(W_{hx}x_{t}+W_{hh}h_{t-1}+b_{h}),$$

  where $\phi$ is a non-linear activation function, $W_{hx}$ and $W_{hh}$ are weight matrices, and $b_{h}$ is a bias vector.

• •

  Compared Weights: All time steps in an RNN use the same weights, or parameters. This increases the efficiency of the model and lowers the number of parameters since the same weights are applied to each input in the sequence.

In the realm of Recurrent Neural Networks, Long Short-Term Memory (LSTM) networks are an advanced evolution designed to overcome the drawbacks of conventional RNNs, especially when addressing long-term dependencies [13]. Therefore, the detailed processes throughout Long Short-Term Memory are explained as follows:

• •

  Higher Level Memory Management: The LSTM unit, a sophisticated memory cell, is the distinguishing characteristic of LSTM. This unit’s distinct structure, which consists of several gates, allows it to retain information for lengthy periods of time.

• •

  Gating System: Three different kinds of gates are included in LSTMs, and each is essential to the network’s memory management.

  • $\star$

    Input Gate: Shows which values from the input should be used to modify the memory. Mathematically, the input gate $i_{t}$ is defined as:

    $$i_{t}=\sigma(W_{ix}x_{t}+W_{ih}h_{t-1}+b_{i}),$$

    where $\sigma$ is the sigmoid activation function, and $W_{ix}$, $W_{ih}$, and $b_{i}$ are the weights and biases for the input gate.

  • $\star$

    Forget Gate: Decides what portions of the existing memory should be discarded. The forget gate $f_{t}$ is given by:

    $$f_{t}=\sigma(W_{fx}x_{t}+W_{fh}h_{t-1}+b_{f}),$$

    where $W_{fx}$, $W_{fh}$, and $b_{f}$ are the weights and biases for the forget gate.

  • $\star$

    Output Gate: Controls the output flow of the memory content to the next layer in the network. The output gate $o_{t}$ is represented as:

    $$o_{t}=\sigma(W_{ox}x_{t}+W_{oh}h_{t-1}+b_{o}),$$

    where $W_{ox}$, $W_{oh}$, and $b_{o}$ are the weights and biases for the output gate.

• •

  Cell State: The cell state $C_{t}$, which functions as a kind of conveyor belt running straight down the length of the network chain, is the fundamental component of LSTM. It guarantees that the network efficiently stores and retrieves significant long-term information while permitting information to flow essentially unaltered. The following updates the cell state:

  $$C_{t}=f_{t}*C_{t-1}+i_{t}*\tilde{C}_{t},$$

  where $\tilde{C}_{t}$ is the candidate cell state, calculated as:

  $$\tilde{C}_{t}=\tanh(W_{cx}x_{t}+W_{ch}h_{t-1}+b_{c}),$$

  and $\tanh$ is the hyperbolic tangent activation function [13].

GRUs are a cutting-edge variant of recurrent neural networks that aim to enhance and streamline LSTM architecture. They provide a more efficient method of managing sequential data, and they work especially well in situations where long-term dependencies are essential [14]. Therefore, the detailed processes throughout the Gated Recurrent Unit are explained as follows:

• •

  Architecture Simplified: In terms of processing resources, the GRU is more efficient because to its simpler structure than the LSTM. Its lower gate count accounts for this efficiency.

• •

  Two gates are used by GRUs:

  • $\star$

    Update Gate: The degree to which data from the previous state should be transferred to the present state is determined by this gate. It combines the forget and input gates that are present in LSTMs. We define the update gate $z_{t}$ as follows:

    $$z_{t}=\sigma(W_{zx}x_{t}+W_{zh}h_{t-1}+b_{z}),$$

    where $W_{zx}$, $W_{zh}$, and $b_{z}$ are the weights and biases for the update gate.

  • $\star$

    Reset Gate: It basically lets the model select how much of the past is useful for the current prediction by deciding how much of the past to ignore. Given is the reset gate $r_{t}$:

    $$r_{t}=\sigma(W_{rx}x_{t}+W_{rh}h_{t-1}+b_{r}),$$

    where $W_{rx}$, $W_{rh}$, and $b_{r}$ are the weights and biases for the reset gate.

• •

  No Separate State for Cells: There is no distinct cell state in GRUs, in contrast to LSTMs. In doing so, they streamline the information flow and facilitate modeling and training by merging the cell state and concealed state into a single structure. The hidden state $h_{t}$ in a GRU is updated as follows:

  $$h_{t}=(1-z_{t})*h_{t-1}+z_{t}*\tilde{h}_{t},$$

  where $\tilde{h}_{t}$ is the candidate hidden state, calculated as:

  $$\tilde{h}_{t}=\tanh(W_{hx}x_{t}+r_{t}*(W_{hh}h_{t-1})+b_{h}).$$

The data source used in this experimental investigation is a collection of historical data on all symbols in the U.S equities markets from January to June 2013 (https://optiondata.org).

The given dataset provides detailed information on options contracts, encompassing various attributes crucial for options trading analysis. Bellow are explanations of each column:

• •

  Contract: A unique identifier for each options contract, likely containing information about the underlying asset, expiration date, type (call or put), and strike price.

• •

  Underlying: Indicates the underlying asset associated with the options contract.

• •

  Expiration: The expiration date of the options contract.

• •

  Type: Specifies whether the option is a call or a put.

• •

  Strike: The strike price of the options contract.

• •

  Style: Refers to the style of the options contract (e.g., American or European).

• •

  Bid: The bid price of the options contract, representing the highest price a buyer is willing to pay.

• •

  Bid Size: The size of the bid, indicating the quantity of contracts being bid for.

• •

  Ask: The ask price of the options contract, representing the lowest price a seller is willing to accept.

• •

  Ask Size: The size of the ask, indicating the quantity of contracts being offered.

• •

  Volume: The trading volume of the options contract.

• •

  Open Interest: The total number of outstanding options contracts.

• •

  Quote Date: The date when the quote for the options contract was made.

• •

  Delta: Delta measures the rate of change of the option’s price in response to changes in the price of the underlying asset.

• •

  Gamma: Gamma measures the rate of change in delta in response to changes in the price of the underlying asset.

• •

  Theta: Theta measures the rate of decline in the value of the option over time.

• •

  Vega: Vega measures the sensitivity of the option’s price to changes in implied volatility.

• •

  Implied Volatility: Implied volatility is the market’s estimate of the future volatility of the underlying asset, as implied by the options prices.

In the analysis of our dataset, we focused on the numerical features to understand the relationships between them. To achieve this, we computed the correlation matrix, which quantifies the linear relationships between pairs of numerical variables. We visualized this correlation matrix using a heatmap, a powerful tool for identifying patterns and correlations within the data. The heatmap, annotated for clarity, uses a ’coolwarm’ color palette to indicate the strength and direction of the correlations, with positive correlations shown in warm tones and negative correlations in cool tones. This visual representation helps in quickly identifying strong correlations, both positive and negative, among the numerical features, thereby providing insights that can guide further analysis and decision-making processes. The heatmap underscores the importance of certain variables and their interdependencies, which can be critical for predictive modeling and other statistical analyses.

The results presented in Table 1 and 2 offer valuable insights into the performance of LSM with machine learning algorithms in pricing American options.

To see the model performance we used the numerical example presented in work [15]. In this numerical example, Table 1 and 2 report a range of numerical values for different parameter choices for different machine learning models. Throughout, we use $K=100$, $r=0.04$, $T=1$, and take the same volatilities of both assets to be 0.2 or 0.4, with 10,000 paths and one basis function.

In Table 1 and 2, we can observe the influence of volatility ($\sigma$) and time to maturity ($T$) on option prices.

• •

  Volatility ($\sigma$): Higher volatility generally leads to higher option prices across all models. For instance, when $S(0)=80$ and $T=1$, the KNN price increases from 24.37 (when $\sigma=0.2$) to 30.87 (when $\sigma=0.4$). The standard errors tend to increase with higher volatility, reflecting the increased uncertainty and complexity in pricing under these conditions.

• •

  Time to Maturity ($T$): Longer maturities also result in higher option prices. For example, with $S(0)=80$ and $\sigma=0.2$, the KNN price increases from 24.37 (when $T=1$) to 25.36 (when $T=2$). The standard errors typically increase with longer maturities, indicating greater variability in the predictions as the time horizon extends.

Figure 4 provides a visual comparison of the fit of the six approaches. Each model here uses 5 basis functions (polynomials up to degree 5). The x-axis shows the simulated stock price at a step in time and the y-axis shows the discounted option value from the next step. Figure 4, we can see that polynomial fits for the following machine learning applied to LSM; KNN, Decision Tree, XGBoost, LightGBM, Logistic Regression, and Random Forest. Some of these methods provide a better visual fit for example here we can see that Logistic Regression provides a better visual fit.

Here let’s compare the pricing of an example American put option with the following details: $S_{0}=100$, $K=100$, $T=1.0$, $r=0.02$, and $\sigma=0.4$ Monte Carlo simulation was performed with 25 time intervals and 10000 paths. Table 3 shows the results.

From Table 3, we can see computational times reveal that simpler models like Decision Trees and Logistic Regression are the quickest, with times of 2.033 and 2.133 seconds respectively, indicating their suitability for scenarios requiring rapid computations. KNN also performs moderately well at 2.593 seconds. In contrast, ensemble methods such as Random Forest take significantly longer, with a computational time of 167.095 seconds, reflecting their higher complexity and resource demands. Gradient boosting methods, XGBoost and LightGBM, offer a balance between speed and performance, with times of 6.689 and 5.506 seconds respectively, making them efficient yet powerful options. This highlights a trade-off between computational efficiency and model complexity, guiding the choice of method based on specific needs for speed versus predictive accuracy.

Below we are going to see the performance of various machine learning models used within the Long staff-Schwartz Method (LSM) framework for pricing American options. The models evaluated are K-Nearest Neighbors (KNN), Decision Tree, XGBoost, LightGBM, Logistic Regression, and Random Forest. Each model is analyzed based on the estimated option price, standard error, execution time, and classification performance metrics (confusion matrix, precision, recall, F1-score, and ROC AUC). Table 4 presents the results of six different models evaluated using several performance indicators for the in-time sample. These metrics include accuracy, AUC, PR-AUC, precision, recall, and F1-score. Among the six models evaluated, Logistic Regression has the highest scores across all metrics, achieving an accuracy score of 0.9995, an AUC score of 1.0000, a PR-AUC score of 1.0000, a precision score of 0.9990, a recall score of 1.0000, and an F1-score of 0.9995. This indicates that Logistic Regression is highly effective in pricing American options within the in-time sample, showing exceptional performance without apparent overfitting or class imbalance issues.

LightGBM follows Logistic Regression to have better performance with an AUC score of 0.8640. However, its accuracy score of 0.5078 and PR-AUC score of 0.5078, along with a precision score of 0.4870 and a perfect recall score of 1.0000, indicate a trade-off between precision and recall. This suggests that while LightGBM is good at identifying positive cases, it may produce more false positives compared to Logistic Regression. XGBoost provides robust performance with an AUC score of 0.8416 and a PR-AUC score of 0.8425. It has an accuracy score of 0.5078 and a precision score of 0.5078, coupled with a perfect recall score of 1.0000. The lower precision score compared to its recall indicates a higher likelihood of false positives, but its overall high AUC and PR-AUC scores reflect strong model reliability. Decision Tree offers a balanced performance with an accuracy score of 0.5599, an AUC score of 0.6041, and a PR-AUC score of 0.5813. It has a precision score of 0.5370 and a recall score of 0.9663, leading to an F1-score of 0.6904. This suggests that Decision Tree captures most positive cases effectively, although it has lower discriminative power compared to LightGBM and XGBoost. Random Forest shows moderate performance with an accuracy score of 0.5111, an AUC score of 0.6332, and a PR-AUC score of 0.6174. Its precision score of 0.5095 and recall score of 1.0000 lead to an F1-score of 0.6750. Like the Decision Tree, Random Forest provides balanced but lower overall performance compared to the boosting models. KNN also provides moderate performance with an accuracy score of 0.5101, an AUC score of 0.6677, and a PR-AUC score of 0.6588. It has a precision score of 0.5090 and a recall score of 1.0000, resulting in an F1-score of 0.6746. KNN’s performance is similar to Random Forest, with high recall and moderate precision, making it suitable for simpler use cases. Overall, while Logistic Regression is the top performer across all metrics, other models like LightGBM and XGBoost also demonstrate effectiveness, particularly in terms of AUC and PR-AUC, highlighting their robustness in pricing American options.

Figure 6 shows the ROC-AUC curve which is depicting the ability of each model to distinguish between positive and negative samples. From the curve, it is evident that:

• •

  Logistic Regression has the highest AUC score of 1.00, indicating perfect discriminatory ability.

• •

  LightGBM follows with an AUC score of 0.86.

• •

  XGBoost has an AUC score of 0.84.

• •

  KNN and Random Forest have moderate AUC scores of 0.67 and 0.63, respectively.

• •

  The Decision Tree model has the lowest AUC score of 0.60.

An AUC score above 0.8 generally indicates a good model, and hence, Logistic Regression, LightGBM, and XGBoost are considered better performers in distinguishing between classes.

Figure 6 shows the Precision-Recall (PR) curve which provides insights into the trade-off between Precision and Recall for each model. The PR-AUC scores are as follows:

• •

  Logistic Regression again leads with a perfect PR-AUC score of 1.00.

• •

  LightGBM has a PR-AUC score of 0.86.

• •

  XGBoost follows closely with a PR-AUC score of 0.83.

• •

  KNN, Random Forest, and Decision Tree have lower PR-AUC scores of 0.64, 0.61, and 0.58, respectively.

The higher the PR-AUC score, the better the model is at balancing precision and recall, particularly useful for imbalanced datasets.

The confusion matrices in Figure 7 provide a detailed breakdown of True Positives (TP), True Negatives (TN), False Positives (FP), and False Negatives (FN) for each model. From these matrices:

• •

  Logistic Regression achieves nearly perfect classification with minimal misclassifications.

• •

  LightGBM and XGBoost show a good balance with high TP and TN counts.

• •

  Decision Tree and Random Forest exhibit more misclassifications compared to the top performers.

• •

  KNN shows the highest number of misclassifications, indicating it may not be as effective for this task.

Overall, Logistic Regression emerges as the top-performing model across most metrics, making it highly suitable for pricing American options. LightGBM and XGBoost also demonstrate strong performance, while KNN and Decision Tree are less effective.

The dataset containing various features related to financial options was loaded and split into features (X) and the target variable (y), representing bid prices. A train-validation split of 80-20 was employed to partition the dataset into training and validation sets.

Using TensorFlow’s Keras API, LSTM and GRU models were constructed with four hidden fully connected layers, each comprising 200 neurons, followed by an output layer with a single neuron for bid price prediction. Rectified Linear Unit (ReLU) activation functions were applied in all layers. The mean squared error (MSE) loss function was chosen to quantify prediction errors. Both models were optimized using the Adam optimizer with a learning rate of 0.001.

The models underwent training for 200 epochs with a batch size of 64. During training, validation set performance was monitored to prevent over fitting. Evaluation of the models was conducted using the mean squared error (MSE) metric on the validation set to assess predictive accuracy which are summarised in Table 5.

From the training and validation loss Figure 9 and 9, it is evident that both the GRU and LSTM models demonstrate significant reductions in loss over the training epochs. The GRU model shows more stability with fewer spikes in the validation loss compared to the LSTM model, which has a noticeable spike around the 35th epoch.

The GRU model’s validation loss fluctuates less and maintains a relatively lower loss towards the end of the training, suggesting better generalization and stability. On the other hand, the LSTM model, while initially reducing loss effectively, exhibits more variability and occasional higher spikes, indicating potential overfitting or sensitivity to certain epochs.

Looking at the error metrics provided in Table 6, the GRU model outperforms the LSTM model across all evaluated metrics. The GRU model achieves a lower Mean Absolute Error (MAE) of 0.49075 compared to 0.5919 for the LSTM model.

Similarly, the Mean Squared Error (MSE) and Root Mean Squared Error (RMSE) are significantly lower for the GRU model, with values of 0.84277 and 0.9180 respectively, as opposed to the LSTM model’s 1.7017 and 1.3045. This indicates that the GRU model not only fits the training data better but also predicts more accurately on the test data, making it a more reliable choice for this specific application. Additionally, the training time per epoch is shorter for the GRU model (6ms/step) compared to the LSTM model (7ms/step), indicating a more efficient training process. Therefore, the GRU model demonstrates superior performance in terms of both stability and predictive accuracy, making it a preferable choice over the LSTM model.