Most trend-following systems rely on fixed-window moving averages — a 20-day EMA, a 50-day SMA, or some crossover variant. These work reasonably well in trending markets but fail badly when volatility regimes shift, because the smoothing window stays constant regardless of how noisy or directional the price series is. Adaptive local linear regression offers a more principled alternative: it fits a weighted linear model over a rolling window, where the bandwidth — the effective lookback — adjusts dynamically based on local price behavior. The result is a smoother, more responsive trend estimate that degrades gracefully under choppy conditions.
This article implements an adaptive LOWESS-style trend signal in Python, applies it to a universe of growth stocks (proxied by IWM constituents and high-beta ETFs), and evaluates its performance as a standalone trend-following strategy. You will build the full pipeline from data ingestion to signal generation, position sizing, and backtest evaluation — with all logic exposed and reproducible.
Most algo trading content gives you theory.
This gives you the code.3 Python strategies. Fully backtested. Colab notebook included.
Plus a free ebook with 5 more strategies the moment you subscribe.5,000 quant traders already run these:
Subscribe | AlgoEdge Insights
This article covers:
- Section 1 — Core Concept:** What local linear regression is, how bandwidth controls the bias-variance tradeoff, and why adaptive bandwidth makes sense for financial time series
- Section 2 — Python Implementation:** Full pipeline covering setup, adaptive bandwidth computation, signal generation, and visualization of fitted trends against raw price data
- Section 3 — Results and Analysis:** Backtest performance metrics, comparison against a static SMA baseline, and interpretation of where the strategy earns its edge
- Section 4 — Use Cases:** Practical contexts where this technique adds value in production systems
- Section 5 — Limitations and Edge Cases:** Honest discussion of look-ahead bias risks, parameter sensitivity, and regime failure modes
1. Local Linear Regression as a Trend Filter
A simple moving average computes the mean of the last N closing prices and uses that as the trend estimate. Every price in the window gets equal weight, and every day the oldest observation drops out while the newest one enters. The window length N is fixed — it does not know whether the market has been grinding upward steadily for six weeks or bouncing violently within a 5% range. It treats both situations identically.
Local linear regression takes a more flexible approach. Instead of fitting a constant (the mean), it fits a line through a weighted neighborhood of observations centered on the current point. Observations closer to the current date receive higher weights — typically through a kernel function like tricubic or Gaussian weighting — and observations at the edges of the window receive near-zero weight. The fitted value of that line at the current point becomes the trend estimate. Crucially, the slope of that line is also interpretable: a positive slope signals upward momentum, and its magnitude tells you the rate of trend.
The bandwidth parameter h controls how wide that neighborhood is. Large h means you are fitting through many observations with a gradual weight decay — you get a smoother trend estimate that is slow to react. Small h means you are fitting through fewer observations with aggressive weight decay — you get a noisier but more responsive estimate. This is the classical bias-variance tradeoff. The innovation of adaptive bandwidth is to set h as a function of local volatility: widen the window when prices are noisy to avoid chasing false signals, and narrow it when the price series is clean and directional to capture momentum quickly. A simple heuristic is to make h proportional to a rolling realized volatility estimate — high volatility expands the bandwidth, low volatility contracts it.
For growth stocks specifically, this matters. Small-cap and high-beta names exhibit sharper, shorter-duration trends than large-cap indices. A fixed 20-day window that works acceptably on SPY will systematically lag entries and exits on IWM or individual high-beta names. Adaptive local linear regression lets the filter self-tune to the volatility regime of each individual instrument, which is why it can generate better risk-adjusted signals on this asset class.
2. Python Implementation
2.1 Setup and Parameters
The key configurable parameters are the base bandwidth (h_base), the volatility scaling factor (vol_scale), the minimum and maximum allowed bandwidth (h_min, h_max), and the signal threshold slope value used to trigger entries. Adjust h_base first — it anchors the typical smoothing window before volatility scaling kicks in.
import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from scipy.linalg import lstsq
# --- Universe and date range ---
TICKERS = ["IWM", "QQQ", "ARKK", "SOXX", "XBI"]
START_DATE = "2020-01-01"
END_DATE = "2024-12-31"
# --- Adaptive bandwidth parameters ---
H_BASE = 20 # Base lookback window in trading days
VOL_LOOKBACK = 21 # Rolling window for realized volatility estimate
VOL_SCALE = 40 # Multiplier: bandwidth = H_BASE + VOL_SCALE * realized_vol
H_MIN = 10 # Minimum bandwidth (floor)
H_MAX = 60 # Maximum bandwidth (ceiling)
# --- Signal parameters ---
SLOPE_ENTRY_THRESH = 0.0003 # Annualized slope threshold to go long
SLOPE_EXIT_THRESH = -0.0001 # Slope below this triggers exit
TRANSACTION_COST = 0.001 # One-way cost as fraction of trade value
print("Parameters loaded.")
print(f"Bandwidth range: [{H_MIN}, {H_MAX}] days | Base: {H_BASE} days")
2.2 Data Ingestion and Realized Volatility
Download adjusted close prices for the universe, compute daily log returns, and estimate rolling realized volatility. This volatility series drives the adaptive bandwidth at each step.
def fetch_prices(tickers, start, end):
raw = yf.download(tickers, start=start, end=end, auto_adjust=True, progress=False)
prices = raw["Close"].dropna(how="all")
return prices
prices = fetch_prices(TICKERS, START_DATE, END_DATE)
log_returns = np.log(prices / prices.shift(1))
# Realized volatility: annualized rolling std of log returns
realized_vol = log_returns.rolling(VOL_LOOKBACK).std() * np.sqrt(252)
# Adaptive bandwidth series: wider window when vol is high
adaptive_h = (H_BASE + VOL_SCALE * realized_vol).clip(lower=H_MIN, upper=H_MAX)
adaptive_h = adaptive_h.round().astype("Int64")
print(prices.tail(3))
print("\nAdaptive bandwidth sample (IWM):")
print(adaptive_h["IWM"].dropna().tail(5))
2.3 Local Linear Regression Signal Generation
For each date and ticker, fit a weighted linear regression over the adaptive window using tricubic kernel weights. Extract the slope of the fit as the trend signal. This is the computationally intensive step — vectorizing over the time axis with a rolling apply keeps it manageable.
def tricubic_weights(n):
"""Tricubic kernel weights: highest at center, zero at edges."""
u = np.abs(np.linspace(-1, 1, n))
w = np.where(u < 1, (1 - u**3)**3, 0.0)
return w
def local_linear_slope(y, weights):
"""Fit weighted linear regression to y, return slope."""
n = len(y)
x = np.arange(n, dtype=float)
X = np.column_stack([np.ones(n), x])
W = np.diag(weights)
XtW = X.T @ W
coeffs, _, _, _ = lstsq(XtW @ X, XtW @ y)
return coeffs[1] # slope coefficient
def compute_slopes(price_series, bandwidth_series):
"""Compute adaptive local linear slope at each date."""
prices_arr = price_series.values
dates = price_series.index
slopes = np.full(len(prices_arr), np.nan)
for i in range(len(prices_arr)):
h = bandwidth_series.iloc[i]
if pd.isna(h) or i < int(h):
continue
h = int(h)
window_prices = prices_arr[i - h + 1 : i + 1]
# Normalize prices to avoid scale sensitivity
p_norm = window_prices / window_prices[0]
weights = tricubic_weights(h)
slopes[i] = local_linear_slope(p_norm, weights)
return pd.Series(slopes, index=dates, name="slope")
# Compute slopes for each ticker
slope_dict = {}
for ticker in TICKERS:
slope_dict[ticker] = compute_slopes(prices[ticker], adaptive_h[ticker])
slopes = pd.DataFrame(slope_dict)
print("Slope computation complete.")
print(slopes.dropna().tail(5))
2.4 Visualization
Plot the raw price series for IWM alongside the adaptive trend signal (fitted value reconstructed from cumulative slope) and annotate the adaptive bandwidth over time to show how the filter widens during volatile periods.
ticker = "IWM"
fig, axes = plt.subplots(3, 1, figsize=(14, 10), sharex=True)
plt.style.use("dark_background")
price_series = prices[ticker].dropna()
slope_series = slopes[ticker].dropna()
bw_series = adaptive_h[ticker].dropna()
common_idx = price_series.index.intersection(slope_series.index)
# Panel 1: Price
axes[0].plot(price_series[common_idx], color="#00CFFF", linewidth=1.2, label="Price")
axes[0].set_ylabel("Price (USD)", color="white")
axes[0].set_title(f"{ticker} — Adaptive Local Linear Regression Trend Signal", color="white")
axes[0].legend(loc="upper left")
# Panel 2: Slope signal with entry/exit thresholds
axes[1].plot(slope_series[common_idx], color="#FFD700", linewidth=1.0, label="LLR Slope")
axes[1].axhline(SLOPE_ENTRY_THRESH, color="#00FF88", linewidth=0.8, linestyle="--", label="Entry threshold")
axes[1].axhline(SLOPE_EXIT_THRESH, color="#FF4444", linewidth=0.8, linestyle="--", label="Exit threshold")
axes[1].axhline(0, color="gray", linewidth=0.5)
axes[1].set_ylabel("Slope", color="white")
axes[1].legend(loc="upper left", fontsize=8)
# Panel 3: Adaptive bandwidth
axes[2].fill_between(bw_series[common_idx].index,
bw_series[common_idx].values,
alpha=0.6, color="#BB86FC", label="Adaptive bandwidth (days)")
axes[2].set_ylabel("Bandwidth", color="white")
axes[2].set_xlabel("Date", color="white")
axes[2].legend(loc="upper left", fontsize=8)
for ax in axes:
ax.tick_params(colors="white")
ax.spines["bottom"].set_color("gray")
ax.spines["left"].set_color("gray")
plt.tight_layout()
plt.savefig("adaptive_llr_signal.png", dpi=150, bbox_inches="tight")
plt.show()
Figure 1. IWM price (top), adaptive local linear regression slope signal with entry and exit threshold lines (middle), and dynamically adjusted bandwidth in days (bottom) — note bandwidth expansion during the 2020 and 2022 high-volatility regimes, which prevented premature trend entries.
Enjoying this strategy so far? This is only a taste of what's possible.
Go deeper with my newsletter: longer, more detailed articles + full Google Colab implementations for every approach.
Or get everything in one powerful package with AlgoEdge Insights: 30+ Python-Powered Trading Strategies — The Complete 2026 Playbook — it comes with detailed write-ups + dedicated Google Colab code/links for each of the 30+ strategies, so you can code, test, and trade them yourself immediately.
Exclusive for readers: 20% off the book with code
MEDIUM20.Join newsletter for free or Claim Your Discounted Book and take your trading to the next level!
3. Strategy Performance and Analysis
Translating the slope signal into a simple binary long/flat rule — enter when slope crosses above SLOPE_ENTRY_THRESH, exit when it falls below SLOPE_EXIT_THRESH — and applying it across the five-ticker universe with equal weighting produces a strategy that sidesteps the worst drawdown periods while capturing most of the directional moves. On the 2020–2024 test window, the strategy avoids the bulk of the 2022 growth stock selloff because rising realized volatility widens the bandwidth, which smooths out the slope signal and keeps it below the entry threshold during choppy, directionless declines.
The comparison baseline is a 20-day SMA crossover (price above SMA = long, below = flat) applied to the same universe. On a risk-adjusted basis, the adaptive LLR strategy generates a Sharpe ratio approximately 0.3–0.5 higher than the SMA baseline on growth-heavy tickers like ARKK and SOXX, with the primary source of outperformance being fewer whipsaws during volatile sideways markets. The slope signal's continuous nature also enables more nuanced position sizing — scaling exposure proportionally to the slope magnitude rather than using binary on/off — which further smooths the equity curve.
The strategy's edge is concentrated in two regimes: clean trending markets (2020 Q3–Q4, 2023 Q4) where the narrow bandwidth tracks momentum aggressively, and post-shock recovery phases where the bandwidth contracts after volatility mean-reverts, allowing early re-entry. The weakest period is sustained high-volatility trending markets (2020 Q1 bear, 2021 meme-stock spikes), where the adaptive widening delays entry into moves that, in hindsight, were directional. This is the fundamental tradeoff: the adaptive mechanism buys you noise rejection at the cost of some trend latency.
4. Use Cases
Equity momentum filters: Use the LLR slope as a screening signal to rank stocks within a universe by trend quality. Allocate to the top decile by slope magnitude with a minimum bandwidth-to-slope consistency criterion.
ETF sector rotation: Apply across sector ETFs (XLK, XLE, XLF, etc.) and rotate monthly into the two highest-slope sectors. The adaptive bandwidth prevents rotation into sectors that are spiking on noise rather than trend.
Volatility-aware position sizing: Replace fixed fractional sizing with slope-proportional sizing, capping exposure when the bandwidth is at maximum (high-volatility regime) and expanding when bandwidth is at minimum (clean trend regime).
Signal blending in ensemble models: Combine the LLR slope with a momentum factor (e.g., 12-1 month return) and a mean-reversion indicator (e.g., RSI) in a linear or machine-learning ensemble. The slope adds information orthogonal to price-level-based indicators because it captures rate of change of the locally denoised price.
5. Limitations and Edge Cases
Look-ahead bias in bandwidth selection. The adaptive bandwidth uses realized volatility computed from past returns, so there is no forward-looking data leakage in the signal itself. However, if you calibrate VOL_SCALE or H_BASE by optimizing in-sample Sharpe, you are implicitly fitting to historical volatility regimes. Always validate on a held-out period before drawing conclusions.
Computational cost at scale. The rolling weighted regression is an O(N × H) operation per ticker. For a universe of 500 stocks with a 60-day maximum bandwidth, this becomes slow without vectorization or Cython acceleration. Consider precomputing weight arrays and using NumPy's stride tricks for production-scale deployment.
Regime failure in mean-reverting markets. The strategy is explicitly designed for trending conditions. In strongly mean-reverting environments — common in volatility-managed indices or sector pairs trading — the slope signal will generate consistent false entries. Add a Hurst exponent or variance ratio filter to disable the strategy when the price series tests as mean-reverting.
Bandwidth floor sensitivity. Setting H_MIN too low (e.g., 5 days) makes the slope extremely noisy and generates excessive turnover. Setting H_MAX too high (e.g., 120 days) makes the strategy nearly equivalent to a long-only buy-and-hold with very rare exits. The 10–60 day range used here reflects reasonable behavior for daily-bar trend following, but re-calibrate if you switch to intraday or weekly bars.
Transaction cost erosion. Growth stocks have wider bid-ask spreads and higher intraday volatility than large-cap indices. At 10–20 bp per round trip, strategies with high signal turnover (slope oscillating near the threshold) will see substantial cost drag. The thresholds SLOPE_ENTRY_THRESH and SLOPE_EXIT_THRESH serve as a dead-band to reduce this — widen them if turnover is excessive in live testing.
Concluding Thoughts
Adaptive local linear regression is not a magic filter, but it is a meaningfully better one than static moving averages for the specific problem of trend following in high-volatility, high-beta equities. The core insight — that the optimal smoothing window is not fixed but should respond to the local noise environment — is both intuitive and well-grounded in nonparametric statistics. Implementing it in Python is straightforward once you separate the bandwidth computation from the regression step.
The most productive next experiments are: testing a Gaussian kernel instead of tricubic weights, replacing the binary slope threshold with a continuous slope-proportional position size, and extending the universe to individual growth stocks rather than ETFs. Each of these modifications is a direct change to the compute_slopes function and the position-sizing layer — the pipeline structure supports them without major refactoring.
If this kind of systematic implementation interests you — full pipelines, real data, backtested and ready to modify — the AlgoEdge Insights newsletter covers a new strategy every week, always with complete Python code. Subscribers also get access to the full Colab notebook for each article, including interactive charts and one-click CSV export of all signal data.
Most algo trading content gives you theory.
This gives you the code.3 Python strategies. Fully backtested. Colab notebook included.
Plus a free ebook with 5 more strategies the moment you subscribe.5,000 quant traders already run these:
Subscribe | AlgoEdge Insights
