Machine Learning for Trading - Stocks - Shares - Python - AI - Deep Learning Course Algorithmic

The computation of various statistics on time series data is introduced. Global statistics such as mean, median, and standard deviation for each stock in a DataFrame are demonstrated using built-in Pandas functions. The distinction between mean and median is reiterated. Rolling statistics are then introduced as a dynamic measure over a moving window of time (e.g., 20-day rolling mean). The `pd.rolling_mean()` function is used, and the visualization of rolling mean on a price chart is shown, highlighting its smoothing and lagging properties. Bollinger Bands (rolling mean +/- two standard deviations) are presented as a technical indicator for identifying significant price excursions.

Daily returns, a fundamental metric in financial analysis, are explained. The formula (Today's Price / Yesterday's Price - 1) is given, emphasizing vectorized computation over loops. Python implementation for calculating daily returns using slicing (Today's Data / Yesterday's Data - 1) and Pandas' `df.shift()` function is demonstrated. The normalization effect of daily returns for comparing different stocks is illustrated. Cumulative returns are then introduced as the total return from a starting point (Today's Price / Initial Price - 1). The visual similarity between cumulative returns and normalized price charts is noted.

The challenges of missing data in historical financial time series are discussed, dispelling the myth of pristine data. Common scenarios leading to missing data (e.g., delisted companies, new listings, thinly traded stocks) are illustrated with examples. The concept of `NaN` (Not a Number) for missing values in Pandas is introduced. The strategy for handling missing data is explained: 'fill forward' to propagate the last known value, followed by 'fill backward' to populate initial missing values. The rationale behind this sequence (to avoid looking into the future) is highlighted. Pandas' `.fillna()` function with `method='ffill'` and `method='bfill'` is demonstrated.

Histograms are introduced as a way to visualize the distribution of daily returns, representing the frequency of different return values. The typical bell-curve shape of stock daily return distributions is discussed. Key statistical measures derived from histograms, such as mean, standard deviation, and kurtosis, are covered. Kurtosis, specifically, describes the 'tails' of the distribution, with positive kurtosis indicating 'fat tails' (more extreme events) and negative indicating 'skinny tails'. Plotting multiple stock histograms to compare their volatility and return characteristics is demonstrated. Scatter plots are then introduced to visualize the relationship between the daily returns of two stocks (e.g., a stock versus the S&P 500 market). Linear regression is used to fit a line to the scatter plot, and the concepts of Beta (slope, market reactivity) and Alpha (y-intercept, excess return) are explained. The difference between slope and correlation is emphasized, with correlation measuring how tightly points fit the line.

The lesson shifts to computing statistics for investment portfolios. A portfolio is defined as an allocation of funds to a set of stocks, typically summed to 1.0. A step-by-step process for calculating the total value of a portfolio over time is detailed: normalize prices by the first day, multiply by allocations, multiply by initial investment, and sum across assets. Key portfolio performance statistics are introduced: cumulative return, average daily return, standard deviation of daily return (risk), and Sharpe Ratio. The Sharpe Ratio is explained as a risk-adjusted return metric, taking into account the risk-free rate of return and volatility. The mathematical formula for Sharpe Ratio is broken down, emphasizing the annualization factor (square root of trading days per year, e.g., 252 for daily data). The importance of comparing daily returns for consistent Sharpe Ratio calculations is highlighted.

Optimizers are introduced as algorithms capable of finding minimum values for functions, fitting parameterized models to data, and refining stock allocations in portfolios. The three key steps to use an optimizer are: define a function to minimize, provide an initial guess, and call the optimizer. A simple parabolic function `f(x) = (x - 1.5)^2 + 0.5` is used as an example to demonstrate how an optimizer (using `scipy.optimize.minimize`) iteratively finds the minimum by 'marching downhill'. The concept of convex functions, which guarantee a single global minimum, is explained. It is shown that optimizers can work in multiple dimensions, not just single-variable functions.

This section illustrates how optimizers can build parameterized models from data, using linear regression as an example. The task is reframed as minimizing the 'error' between the model's predictions and actual data points (e.g., using squared error). The optimizer finds the coefficients (parameters) of the line that minimize this error. The process is demonstrated in Python code, showing how to define a custom error function and use `scipy.optimize.minimize` to find the best-fit line to noisy data. The applicability of this approach to more complex polynomial functions for fitting data is also briefly shown.

Portfolio optimization is framed as finding an asset allocation that maximizes performance (e.g., Sharpe Ratio) given a set of assets and a time period. The problem is formulated for a minimizer by seeking to minimize the negative Sharpe Ratio. The components of the problem are: `x` represents the allocations to each stock, and the function to minimize is `-SharpeRatio(allocations)`. Two crucial aspects for effective optimization are introduced: bounds (constraining allocations between 0 and 1) and constraints (ensuring allocations sum to 1.0). These are essential for obtaining meaningful and realistic portfolio allocations.

Different types of investment funds are introduced: Exchange Traded Funds (ETFs), Mutual Funds, and Hedge Funds. Their characteristics such as tradability, transparency, and liquidity are compared. ETFs are highly liquid and transparent, traded like stocks. Mutual funds are less liquid (traded end-of-day) and less transparent (quarterly disclosures). Hedge funds are least transparent, with long lock-up periods and private agreements. The concept of 'Assets Under Management' (AUM) is defined. Manager compensation structures are detailed: ETFs and mutual funds typically use expense ratios (percentage of AUM), while hedge funds often follow a '2 and 20' model (2% of AUM + 20% of profits). The incentives of each compensation model regarding risk-taking and AUM accumulation are discussed.

Key types of hedge fund investors (individuals, institutions, funds of funds) and their motivations for investing (track record, compelling strategy, portfolio fit) are explored. Fund goals are categorized into 'beating a benchmark' (relative return) or 'absolute return' (positive return no matter what). Metrics for measuring fund performance are reviewed, including cumulative return, volatility (standard deviation of daily returns), and Sharpe Ratio (risk-adjusted return). The importance of choosing an appropriate benchmark aligned with the fund's expertise is emphasized. The computational infrastructure within a typical hedge fund is outlined, from live portfolio trading algorithms interacting with the market to portfolio optimizers driven by forecasts, and forecasting algorithms based on machine learning and proprietary data.

The mechanics of how stock orders are processed and executed are explained. Essential components of a stock order (Buy/Sell, Symbol, Shares, Limit/Market Price) are detailed. The concept of an 'order book' at stock exchanges, listing bids (buy orders) and asks (sell orders) at various prices, is introduced. How market orders execute by taking the best available price from the order book is demonstrated through examples. The impact of selling/buying pressure on stock prices based on the order book's liquidity is discussed. The flow of an order from a retail investor through a broker to an exchange, and the role of internal brokerage matching and 'dark pools' in executing orders off-exchange, are explained. The majority of retail orders are routed internally or through dark pools to save on exchange fees. Two hedge fund exploitation strategies—'order book exploit' (latency arbitrage) and 'geographic arbitrage'—leveraging micro-second speed advantages are presented.

The mechanism of 'selling short' is explained. This involves borrowing shares of a stock, selling them, and then buying them back later (hopefully at a lower price) to return to the lender. The process allows investors to profit from a stock's decline. A detailed example illustrates borrowing shares, selling them, profiting from a price drop by buying back at a lower price, and returning the shares. The risks involved (unlimited loss potential if the stock price rises) are highlighted. It's noted that the broker facilitates all these complex transactions, shielding the individual trader from direct interaction with lenders or other buyers/sellers.

The importance of company valuation in stock trading is discussed, as it helps identify opportunities where the market price deviates from the 'true value'. Three primary methods for estimating company value are presented: Intrinsic Value (based on future dividends, discounted by a risk-adjusted rate), Book Value (assets minus liabilities and intangibles), and Market Capitalization (current stock price multiplied by outstanding shares). The concept of 'present value' of future cash flows, discounted by an interest rate (or 'discount rate' for risky assets), is central to intrinsic value calculation. An example demonstrates how a higher discount rate (for riskier assets) yields a lower present value for future cash flows. The practical application of comparing market price to intrinsic/book value for trading decisions (e.g., buying if market price is below book value) is illustrated. The rarity of a stock trading significantly below book value due to the threat of predatory acquisitions is explained.

The Capital Asset Pricing Model (CAPM), a foundational financial concept, is introduced. CAPM states that a stock's return is primarily influenced by the market's return, adjusted by its 'Beta' (market sensitivity), plus an 'Alpha' (residual return). Beta is the slope of a stock's daily returns versus market returns on a scatter plot, while Alpha is the y-intercept. CAPM asserts that Alpha is random with an expected value of zero, implying that one cannot consistently 'beat the market' through stock picking. The implications for passive versus active investing are discussed: if CAPM is true, passive investing (buying market index) is optimal. The model can be extended to portfolios, where portfolio Beta is the weighted sum of individual stock Betas. The Arbitrage Pricing Theory (APT) is briefly mentioned as an extension of CAPM, suggesting multiple Betas for different market factors/sectors.

This section explains how hedge funds, assuming they possess 'actionable information' (forecast alpha), can leverage the CAPM. The focus is on constructing 'long-short' portfolios to minimize market risk. By taking long positions in stocks predicted to have positive alpha and short positions in stocks predicted to have negative alpha, a fund can create a market-neutral portfolio (Beta = 0). This means the portfolio's performance is desensitized to overall market movements, allowing the fund to profit primarily from its ability to predict individual stock alphas. A detailed example illustrates calculating optimal weights for two stocks (one long, one short) to achieve a portfolio Beta of zero, thereby isolating the Alpha component.

Technical analysis, which focuses solely on historical price and volume data to predict future movements, is introduced as an alternative to fundamental analysis. Key characteristics of technical analysis, such as its reliance on 'indicators' (heuristics derived from price/volume), are discussed. Three common technical indicators are explained: Momentum (rate of price change), Simple Moving Average (SMA) (smoothed average price over a period), and Bollinger Bands (SMA +/- standard deviations, used to identify volatility-adjusted price extremes). Trading strategies based on these indicators, such as buying/selling when prices cross SMA or Bollinger Bands, are outlined. The concept of 'normalization' of indicator values to standardize their range (-1 to +1) for machine learning models is also covered.

The process of aggregating raw 'tick' data (individual successful transactions) into higher-level timeframes like minute-by-minute or daily Open, High, Low, Close (OHLC) and Volume data is explained. The advantages of using daily data for this course (less data, easier to process) are highlighted. Two common market anomalies, stock splits and dividends, which cause sudden, artificial price drops in raw historical data, are discussed. The concept of 'Adjusted Close' price is introduced as a solution to account for these events retrospectively, providing a continuous and accurate representation of true returns over time. The importance of using 'adjusted close' for backtesting is emphasized to avoid false trading signals. Finally, the 'survivor bias' in historical stock data (using current index constituents to backtest in the past) and the need for 'survivor bias-free' data for realistic backtesting are explained.

The Efficient Markets Hypothesis (EMH) is introduced, proposing that current stock prices reflect all available information, making it impossible to consistently 'beat the market'. Three forms of EMH are described: Weak Form (future prices cannot be predicted from past prices; refutes technical analysis), Semi-Strong Form (prices adjust immediately to new public information; refutes fundamental analysis), and Strong Form (prices reflect all information, public and private; refutes even insider trading). Evidence for and against each form is discussed, with the presence of successful hedge funds suggesting that the Strong Form might not be entirely true. An example of the price-to-earnings (P/E) ratio consistently predicting future returns across decades is presented as a challenge to the Semi-Strong form.

Richard Grinold's 'Fundamental Law of Active Portfolio Management' is presented: Performance = Skill x SquareRoot(Breadth). This law quantifies how a manager's performance (Information Ratio) is related to their predictive ability (Information Coefficient) and the number of independent investment opportunities (Breadth). The concepts of Information Ratio (Sharpe Ratio of excess returns), Information Coefficient (correlation of manager forecasts to actual returns), and Breadth (number of trading opportunities per year) are defined. The implications are explored, showing that performance can be improved either by enhancing skill or increasing breadth, although increasing breadth yields diminishing returns (square root factor). The theory is applied to compare the investment styles of Warren Buffett (high skill, low breadth) and Renaissance Technologies (lower skill per trade, very high breadth).

Mean-Variance Optimization (MVO), or portfolio optimization, is introduced as a method to allocate funds across a set of stocks to minimize risk for a given target return. Risk is defined as the standard deviation (volatility) of daily returns. The importance of 'covariance' between assets (how their daily returns move together) is highlighted as discovered by Harry Markowitz (Nobel Prize winner). By combining anti-correlated assets, it's possible to achieve portfolios with lower risk than any individual asset. The inputs for an MVO optimizer (expected return, volatility, and covariance matrix for each stock, plus a target return) and its output (optimal asset weights) are described. The concept of the 'efficient frontier' (a curve representing portfolios that offer the highest return for a given risk or lowest risk for a given return) is explained.

Machine learning is introduced as a data-centric approach to building predictive models for financial markets. A 'model' is defined as a system that takes observations (X, e.g., stock features) and produces a prediction (Y, e.g., future price). The machine learning process involves training a model using historical data (X-Y pairs) and then using the trained model for real-time predictions. The specific focus is on 'supervised regression learning': 'regression' for numerical predictions, 'supervised' because the model learns from labeled X-Y pairs, and 'learning' implies training with data. Examples of relevant features (X) and target predictions (Y) for stock trading are provided.

Various supervised regression learning algorithms are mentioned, including Linear Regression (parametric, learns parameters and discards data) and K-Nearest Neighbor (KNN) (non-parametric, instance-based, retains data). The application of these algorithms in a real-world financial forecasting system (QuantDesk) is demonstrated, showing how features are processed to generate future price predictions, along with confidence scores and backtest scores. The process of 'backtesting' is explained as a method to evaluate model accuracy by simulating trading strategies on historical data. This involves rolling back time, training the model on past data, making predictions for a future period, and evaluating portfolio performance. The general structure of the machine learning problem for the course project is outlined: train on 2009 data, test on 2010-2011 data, and compare performance metrics.

The differences between parametric (e.g., linear regression, polynomial regression) and non-parametric (e.g., K-Nearest Neighbor, kernel regression) models are revisited. Parametric models derive a fixed set of parameters from data and discard the data, being space-efficient but slow to update. Non-parametric models retain all training data and query it directly, being flexible for complex patterns but requiring more storage and potentially slower queries. Choosing between them depends on whether an underlying mathematical form is known or needs to be learned from data ('bias' vs. 'unbiased' models). The importance of out-of-sample testing (training on one dataset, testing on another unseen dataset) to avoid over-optimistic results is emphasized. The API (Application Programming Interface) design for implementing these learning algorithms (constructor, train, query methods) is outlined.

Methods for evaluating the performance of machine learning algorithms are discussed. Root Mean Squared (RMS) Error is introduced as a standard metric to quantify the difference between predicted and actual values. The crucial distinction between 'in-sample error' (measured on training data) and 'out-of-sample error' (measured on unseen test data) is emphasized, with out-of-sample error typically being higher. 'Roll-forward cross-validation' is presented as a method for robust out-of-sample testing in time-series data, preventing 'peeking into the future'. The relationship between predicted and actual values can also be visualized using scatter plots and quantified using 'correlation'. Finally, 'overfitting' is formally defined as the phenomenon where a model performs well on training data but poorly on unseen data. Its behavior in both K-Nearest Neighbor (KNN) and polynomial regression models is analyzed, illustrating how model complexity (e.g., high polynomial degree or low K in KNN) can lead to overfitting.

Ensemble learning, a technique to combine multiple 'weak' learners into a single 'strong' learner, is introduced. The Netflix Prize winning algorithm, which used an ensemble, highlights its effectiveness. An ensemble involves training multiple models (which can be different algorithms or same algorithm with different data) and combining their predictions (e.g., by averaging for regression). Ensembles often lead to lower error and reduced overfitting due to the reduction of individual model biases. 'Bagging' (Bootstrap Aggregating) is explained as an ensemble method where multiple models are trained on different subsets of the original data, sampled randomly with replacement. 'Boosting' (e.g., AdaBoost) is introduced as a variation of bagging that focuses more on learning from misclassified/poorly predicted instances in subsequent training iterations to improve overall performance. The advantages of using these meta-algorithms for improved model robustness are emphasized.

Reinforcement Learning (RL) is introduced as an alternative to regression for trading decisions. RL focuses on learning a 'policy' (rules for action) rather than making direct predictions. The core RL framework involves an 'agent' (robot/trader) interacting with an 'environment' (market). The agent perceives the environment's 'state' (S), performs an 'action' (A), and receives a 'reward' (R). This leads to a new state (S'). The goal of the RL agent is to find a policy that maximizes cumulative future rewards. The trading problem is mapped to RL: actions are buy/sell/do nothing, states include market features and current holdings, and rewards are trade returns. The concept of a 'Markov Decision Problem' (MDP), the mathematical framework for RL, is introduced, defined by states (S), actions (A), transition function (T), and reward function (R). Different optimization goals for cumulative reward (infinite horizon, finite horizon, discounted reward) are discussed.

Q-learning, a model-free RL algorithm, is explained. It learns a 'Q-table' that stores the expected future discounted reward for taking a specific action (A) in a given state (S). The policy derived from the Q-table is to choose the action with the maximum Q-value for the current state. The core of Q-learning is its update rule: the new Q-value for a (state, action) pair is a weighted average of the old Q-value and a new 'best estimate'. This new estimate includes the immediate reward (R) plus the discounted maximum future Q-value from the resulting state (S'). Key parameters are 'alpha' (learning rate) and 'gamma' (discount factor for future rewards). Exploration (e.g., using random actions with decaying probability) is vital during training to discover optimal policies. The challenge of representing a continuous state space as a discrete integer for the Q-table is addressed using 'discretization' (dividing continuous values into discrete bins).

Dyna-Q, an algorithm by Rich Sutton, is introduced as a method to accelerate Q-learning. Traditional Q-learning is 'model-free', learning directly from real-world interactions which can be expensive (e.g., requiring real trades). Dyna-Q augments Q-learning by integrating 'model-based' components. After each real-world interaction, Dyna-Q builds/updates internal models of the environment's transition (T) and reward (R) functions. It then uses these internal models to 'hallucinate' many additional experiences (e.g., hundreds of simulated interactions) and updates the Q-table based on these imagined experiences. This 'hallucination' process is computationally cheap, allowing for more rapid Q-table convergence. The details of how T and R models are updated (e.g., using a count-based approach for T and an averaging approach for R) are explained.

An interview with Tammer Kamel, founder of Quandl, discusses the Quandl platform's role in providing historical financial data for quantitative analysis. He explains how Quandl fits into a hedge fund's workflow by providing high-quality data through various APIs, primarily focusing on daily updated historical data rather than live feeds. Kamel describes Quandl's cloud-based infrastructure, leveraging Amazon Web Services and a NoSQL database for scalability, with a Ruby on Rails backend. The importance of meticulous time-stamping and data validation to prevent 'look-ahead bias' in analysis is highlighted. He notes that direct relationships between data consumers and publishers on Quandl's platform help mitigate data quality issues. Additionally, Kamel shares insights and lessons learned from his experience advising and managing hedge funds in the 1990s, including strategies like yield curve arbitrage and statistical arbitrage. He discusses the 'evaporation of alpha' in today's markets due to increased participation and lower volatility, contrasting it with the 'golden age' of quant finance. For aspiring quants, he advises seeking new information sources and combining multiple theoretically sound, empirically testable, and simple factors for robust strategies, while cautioning against overfitting and overly complex models.

Professor Tucker Balch and graduate student Dave introduce the course, focusing on applying machine learning to financial markets. The course is divided into three mini-courses: manipulating financial data in Python, computational investing, and learning algorithms for trading. The goal is to equip students to join a trading system development team, emphasizing that this course is a starting point, not an endorsement of immediate automatic trading. Required textbooks include 'Python for Finance' by Hilpisch, 'What Hedge Funds Really Do' by Balch and Romero, and 'Machine Learning' by Mitchell.

This section introduces manipulating financial data in Python. Python is chosen for its strong scientific libraries, active maintenance, and computational speed (especially with matrix notation). The course uses 'Python for Finance' as a reference. The primary data source will be CSV files, which are simple text files with comma-separated values. Expected fields in stock data CSVs include date/time and price. Detailed explanation of stock data fields (open, high, low, close, volume, adjusted close) is provided, highlighting the importance of 'adjusted close' for accurate historical analysis due to stock splits and dividends.

The section introduces Pandas DataFrames as a powerful tool for financial data manipulation. DataFrames are structured with symbols (stocks) as columns and dates as rows. The concept of 'NaN' (Not a Number) values for missing data (e.g., when a company wasn't publicly traded) is explained. Dave provides a hands-on demonstration of reading CSV files into DataFrames using `pd.read_csv()`, viewing top/bottom rows with `df.head()` and `df.tail()`, and slicing data by index. Examples of calculating max closing values and mean volume for stocks are shown.

Plotting financial data with Pandas and Matplotlib is demonstrated. The `matplotlib.pyplot` library is imported for plotting. Simple plotting of adjusted close prices is shown using `df[column_name].plot()`. The importance of adding labels and titles to plots for clarity is emphasized through examples using `plt.title()`, `ax.set_xlabel()`, and `ax.set_ylabel()`. The power of Pandas to plot multiple series simultaneously and automatically generate legends is highlighted.

This part focuses on building DataFrames with multiple stock data, addressing issues like date range selection, indexing rows by dates, aligning dates across different stocks, and handling reverse-ordered data from sources like Yahoo Finance. The process involves creating an empty DataFrame with desired dates, then iteratively joining individual stock data (e.g., SPY, IBM, GOOG, GLD) using Pandas' `join` function. The concept of inner join to only include dates present in all datasets (e.g., exclude weekend dates where no trading occurred) is explained. The need to specify `index_col` and `parse_dates` when reading CSVs to correctly handle dates as indices is demonstrated.

Advanced DataFrame slicing techniques are covered. Three main ways to slice a DataFrame are discussed: row slicing (selecting specific date ranges for all columns), column slicing (selecting specific stock symbols for all dates), and combined row and column slicing (selecting specific date ranges for specific symbols). The `.ix` selector is introduced as a robust method for combined slicing. These slicing capabilities are crucial for focusing on subsets of data for analysis, such as comparing multiple stocks over a specific period.

The concept of normalizing stock prices to facilitate comparison across stocks with different price levels is explained. Normalization involves dividing all prices by their initial value (e.g., the price on the first day), so all stocks start at 1.0. This allows for an 'apples-to-apples' comparison of relative performance. The efficiency of using vectorized operations in Pandas/NumPy for normalization is highlighted over traditional for-loops.

NumPy, a high-performance numerical library, is introduced as the backbone of Pandas. It provides fast operations through underlying C and Fortran code. The core data structure in NumPy is the N-dimensional array (nd-array). Accessing elements and slicing nd-arrays using various indexing techniques (e.g., `[:, 3]`, `-1`, ranges `start:end:step`) is explained in detail. Creating NumPy arrays from Python lists, tuples, or using functions like `np.empty()`, `np.ones()`, `np.zeros()`, and random number generation functions (`np.random.rand()`, `np.random.normal()`, `np.random.randint()`) is demonstrated.

Key NumPy array attributes like `shape` (dimensions), `size` (total elements), and `dtype` (data type of elements) are explained. Essential mathematical operations on nd-arrays are covered, including summation (`.sum()`), minimum (`.min()`), maximum (`.max()`), and mean (`.mean()`). The concept of `axis` (0 for columns, 1 for rows) for performing operations along specific dimensions is crucial. The speed advantage of NumPy vectorized operations over Python loops for large datasets is empirically demonstrated and emphasized.

This segment delves into advanced indexing, including boolean arrays for filtering elements (e.g., selecting values less than the mean) and assigning values to subsets of arrays. Element-wise arithmetic operations (addition, subtraction, multiplication, division) between arrays and scalars, or between two arrays, are thoroughly explained. The distinction between element-wise multiplication and matrix multiplication (`.dot()` function for the latter) is clarified. Best practices for handling data types (e.g., ensuring float division) are also discussed.