Machine Learning Techniques for Trading › Supervised Learning Algorithms

Let's examine the supervised learning algorithms most commonly employed in quantitative finance, building from simple linear models to more complex ensemble methods and neural networks.

Linear regression, which we covered extensively in Part III's chapter on regression analysis, remains a foundational tool. The intuition behind linear regression is straightforward: we assume that the target variable can be expressed as a weighted sum of the input features, plus some random noise that captures everything our model cannot explain. This assumption, while restrictive, proves remarkably useful in many financial applications where relationships between variables are approximately linear over relevant ranges.

For predicting continuous targets like returns, we model:

$$y = \beta_0 + \beta_1 x_1 + \beta_2 x_2 + \cdots + \beta_p x_p + \epsilon$$

where:

• $y$: dependent variable (target)
• $\beta_0$: y-intercept
• $\beta_i$: regression coefficient for feature $i$
• $x_i$: independent variable (feature) $i$
• $p$: total number of features
• $\epsilon$: error term (residual)

To understand what this formula truly represents, consider each coefficient $\beta_i$ as quantifying the expected change in the target variable when feature $x_i$ increases by one unit, holding all other features constant. The intercept $\beta_0$ captures the baseline prediction when all features equal zero. The error term $\epsilon$ acknowledges that our linear model cannot perfectly explain every observation; it represents the inherent randomness in financial markets and the influence of factors we have not included.

Despite its simplicity, linear regression offers important advantages: interpretability, computational efficiency, and well-understood statistical properties. Its coefficients tell us exactly how each feature influences the prediction. When a portfolio manager asks why the model is bullish on a particular stock, we can point to specific features and their associated weights, and gives a clear narrative that connects inputs to outputs.

For binary classification tasks, such as predicting whether returns will be positive or negative, we need a different approach. The challenge is that linear regression produces unbounded outputs, yet we need probabilities that fall between zero and one. Logistic regression solves this elegantly by wrapping the linear combination inside a special transformation called the logistic (or sigmoid) function. Logistic regression models the probability of the positive class:

$$P(y = 1 | \mathbf{x}) = \frac{1}{1 + e^{-(\beta_0 + \boldsymbol{\beta}^T \mathbf{x})}}$$

where:

• $P(y = 1 | \mathbf{x})$: probability of the positive class given features $\mathbf{x}$
• $\beta_0 + \boldsymbol{\beta}^T \mathbf{x}$: the log-odds (linear combination) of the features
• $\beta_0$: bias term
• $\boldsymbol{\beta}$: vector of weights
• $\mathbf{x}$: vector of input features

The logistic function converts a linear score into a probability. Inside the exponential, we still have our familiar linear combination of features. However, the logistic function squashes this linear combination into the $(0, 1)$ interval, giving us probability estimates rather than unbounded predictions. When the linear combination is large and positive, the probability approaches 1; when it is large and negative, the probability approaches 0; and when the linear combination equals zero, the probability equals exactly 0.5.

The coefficients reveal the relationship between features and targets. Momentum shows a positive relationship with returns (as expected from our data generation), while the mean reversion signal has a negative coefficient, consistent with the contrarian nature of mean reversion strategies.

Key ParametersLink Copied

• fit_intercept: Whether to calculate the intercept (bias) term. In finance, this represents the alpha or base probability.
• C: Inverse of regularization strength for logistic regression (default 1.0). Smaller values specify stronger regularization to prevent overfitting.
• penalty: The norm used in the penalization (e.g., 'l2').

Decision trees partition the feature space through a sequence of binary splits, creating a hierarchical structure that naturally captures nonlinear relationships and feature interactions. The fundamental idea is intuitive: at each step, the algorithm asks a yes-or-no question about one of the features (such as "Is momentum greater than 0.5?"), and based on the answer, it routes the observation down one of two branches. This process continues recursively until the observations reach terminal nodes, called leaves, where the final prediction is made.

At each internal node, the tree selects a feature and threshold that best separates the data according to some criterion. For classification tasks, this criterion is typically Gini impurity while for regression tasks, mean squared error is commonly used. This approach automatically discovers which features matter most and identifies the thresholds that create the most informative splits.

The tree-building process recursively finds the optimal split at each node by evaluating all possible features and thresholds, selecting the combination that most reduces the weighted impurity of the resulting child nodes:

$$\text{Best Split} = \arg\min_{j, t} \left[ \frac{n_L}{n} \cdot \text{Impurity}(L) + \frac{n_R}{n} \cdot \text{Impurity}(R) \right]$$

where:

• $j$: feature index selected for the split
• $t$: threshold value for feature $j$
• $L, R$: left and right child nodes
• $n_L, n_R$: number of samples in the left and right child nodes
• $n$: total number of samples in the current node
• $\text{Impurity}(\cdot)$: function measuring node impurity (e.g., Gini)

This formula captures the essence of the splitting decision. We weight each child node's impurity by the proportion of samples it receives, so we prioritize splits that create large, pure groups rather than small pockets of purity. The algorithm searches over all features $j$ and all possible thresholds $t$ to find the combination that minimizes this weighted impurity.

Random forests often perform well with relatively little hyperparameter tuning. They handle mixed feature types, provide probability estimates through voting, and offer feature importance measures. Their main limitations are computational cost (training many trees) and reduced interpretability compared to single trees.

Key ParametersLink Copied

• n_estimators: The number of trees in the forest. More trees increase stability but also computational cost.
• max_depth: The maximum depth of each tree.
• max_features: The number of features to consider when looking for the best split.

While random forests build trees independently and average their predictions, gradient boosting takes a fundamentally different approach by building trees sequentially, with each tree correcting the errors of the previous ensemble. The conceptual difference is significant: random forests reduce variance through averaging, while gradient boosting reduces bias through iterative refinement.

The method works by fitting each new tree to the negative gradient of the loss function. To understand this intuitively, think of the gradient as pointing in the direction of steepest ascent. By moving in the opposite direction (the negative gradient), we descend toward lower loss values. In the case of squared error loss, this negative gradient equals the residuals, the differences between actual values and current predictions. In essence, each new tree learns to predict the mistakes of the ensemble so far.

For regression with squared error loss, the algorithm proceeds in steps:

1. Initialize with the mean value:

$$F_0(\mathbf{x}) = \bar{y}$$

where:

• $F_0(\mathbf{x})$: initial prediction (mean value)
• $\bar{y}$: mean of the target values
• $\mathbf{x}$: input feature vector

Starting with the mean is a natural choice because, in the absence of any other information, the mean minimizes squared error. This provides a sensible baseline from which the algorithm can begin its iterative improvement.

1. Iterate for $m = 1, 2, \ldots, M$:

   First, compute the pseudo-residuals, which represent the errors not yet explained by the current ensemble:

$$r_i^{(m)} = y_i - F_{m-1}(\mathbf{x}_i)$$

where:

• $r_i^{(m)}$: pseudo-residual for sample $i$, representing the unexplained part of the target
• $y_i$: target value for sample $i$
• $F_{m-1}(\mathbf{x}_i)$ or $F_{m-1}(\mathbf{x})$: prediction from the previous iteration (the baseline we are improving)
• $\mathbf{x}_i$: feature vector for sample $i$

These pseudo-residuals tell us how much each observation's actual value differs from our current prediction. A large positive residual means we are underestimating; a large negative residual means we are overestimating. The next tree will focus on learning these patterns.

Next, fit a weak learner (tree) $h_m(\mathbf{x})$ to these residuals. This tree learns to predict where the current ensemble is making mistakes.

Finally, update the ensemble prediction by adding the new tree's contribution:

$$F_m(\mathbf{x}) = F_{m-1}(\mathbf{x}) + \nu \cdot h_m(\mathbf{x})$$

where:

• $F_m(\mathbf{x})$: ensemble prediction after iteration $m$
• $F_{m-1}(\mathbf{x})$: prediction from the previous iteration
• $\nu$: learning rate parameter (scales the contribution of each tree to prevent overfitting)
• $h_m(\mathbf{x})$: weak learner (tree) fitted to the pseudo-residuals
• $\mathbf{x}$: input feature vector

The learning rate $\nu$ (typically 0.01 to 0.1) controls how much each tree contributes. This parameter represents a deliberate choice to learn slowly: rather than fully correcting all residuals at once, we make small, incremental adjustments. This regularization technique, known as shrinkage, helps prevent overfitting. Smaller values require more trees but generally achieve better performance by allowing for finer-grained corrections. Modern implementations like XGBoost and LightGBM add sophisticated optimizations including regularization, efficient handling of sparse data, and parallel processing.

Neural networks model complex nonlinear relationships through layers of interconnected nodes. The fundamental building block is the artificial neuron, which computes a weighted sum of its inputs, adds a bias term, and passes the result through a nonlinear activation function. By stacking many such neurons in layers and connecting them together, neural networks can approximate arbitrarily complex functions.

The architecture of a neural network determines its capacity to learn. A feedforward neural network with one hidden layer computes:

$$\hat{y} = g_2\left( \mathbf{W}_2 g_1(\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1) + \mathbf{b}_2 \right)$$

where:

• $\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1$: linear transformation of the input
• $g_1(\dots)$: activation of the hidden layer, creating nonlinear features
• $\mathbf{W}_1, \mathbf{W}_2$: weight matrices for the hidden and output layers
• $\mathbf{b}_1, \mathbf{b}_2$: bias vectors
• $g_1, g_2$: activation functions (e.g., ReLU, sigmoid)
• $\hat{y}$: network output (prediction)
• $\mathbf{x}$: input feature vector

To understand this formula, trace the flow of information from input to output. The input vector $\mathbf{x}$ first undergoes a linear transformation by the weight matrix $\mathbf{W}_1$, which projects it into a higher-dimensional space, and bias $\mathbf{b}_1$ shifts this projection. The activation function $g_1$ then introduces nonlinearity, allowing the network to learn complex patterns that linear models cannot capture. This transformed representation passes through another linear transformation ($\mathbf{W}_2$, $\mathbf{b}_2$) and final activation $g_2$ to produce the output.

The hidden layer activation, typically ReLU defined as $g(z) = \max(0, z)$, introduces nonlinearity. Without these nonlinear activations, stacking multiple layers would be equivalent to a single linear transformation, no matter how many layers we added. The output activation depends on the task: sigmoid for binary classification (squashing outputs to probabilities), linear for regression (allowing unbounded predictions).

Training proceeds by backpropagation, a systematic application of the chain rule to compute gradients of the loss function with respect to all weights. These gradients indicate how to adjust each weight to reduce the prediction error. Optimization algorithms like stochastic gradient descent, Adam, or RMSprop then update the weights iteratively, gradually improving the network's predictions.