Time-Aware Regression for Detecting and Segmenting Structured Trend Shifts

Linear regressions can reveal much more than a single best-fit line. When anchored to time and applied in segments, they can expose how market trends evolve structurally.

We show a method to model price action using time-anchored linear regressions. It segments the price series based on calendar logic (e.g weekly, monthly) and fits a separate regression to each slice.

Both static and rolling modes are supported. In static mode, the data is divided into fixed windows. In rolling mode, the regression updates bar-by-bar, anchored to a periodic reset.

You’ll also see how to visualize these segments with slope-based coloring and confidence bands derived from residual volatility.

This article is structured as follows:

Time-Anchored Linear Regression
Building Regression Segments
Plotting Results
Discussion — Benefits & Limitations

End-to-end implementation Google notebook provided below.

1. A Structural Approach to Trend Detection

Traditional trendlines oversimplify market behavior. They assume a single trend across the entire price history. But markets evolve, sometimes gradually, sometimes abruptly. A single regression line can’t capture that complexity.

Time-anchored linear regression solves this by segmenting the price series into smaller, calendar-based intervals. Each segment receives its own linear model. These regressions adapt to local structure, revealing short-term directional changes and trend persistence.

Here’s how it works.

Segmenting the Price Series by Time

The first step is to divide the data based on time-based anchors — daily, weekly, or monthly. Each segment contains a slice of price data that corresponds to a fixed calendar period. This avoids lookahead bias and aligns with how traders think in terms of weeks, months, or quarters.

For each segment, we fit a simple linear regression:

Where:

y is the price
x is the index position (e.g. bar number)
m is the slope (trend strength and direction)
b is the intercept

The slope m indicates whether the local trend is rising or falling. The steeper the slope, the stronger the trend.

To assess the fit quality, we calculate the residual standard deviation:

This gives us a way to define upper and lower bands:

Where k is a user-defined multiplier. These bands visualize uncertainty. A wider band signals more variability within the trend.

Static vs. Rolling Regression Modes

There are two core modes implemented here:

Static Regression
Each time segment is treated independently. Once a window closes (e.g. end of the week), the regression is calculated and fixed.
Rolling Regression
The regression updates continuously from a reset point. As new bars arrive, the line evolves. Anchors reset periodically (e.g. every Monday) to allow the regression to shift over time without anchoring to the full window.

2. Python Implementation

Everything here is self-contained , just copy the code and run it. You can adjust behavior using a few intuitive parameters.

2.1 Modeling Settings

All configuration is centralized in a single block. You can modify the ticker symbol, date range, regression mode (“Static” or “Rolling”), anchor type, resolution, and styling options.

ANCHOR_TYPE sets where regressions begin.

"First Bar" starts one long regression from the dataset’s beginning.
"Periodic" restarts regressions at each time window (e.g., weekly, monthly).

MULT controls band width by scaling the regression’s residual standard deviation.

Higher MULT = wider bands, more noise tolerance.
Lower MULT = tighter bands, more sensitivity to outliers.

				
					import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime

plt.style.use("dark_background")

# USER PARAMETERS
TICKER = "ASML.AS"           # Stock symbol to fetch data from Yahoo Finance
START_DATE = "2023-01-01"    # Start date of historical data
END_DATE   = "2025-06-01"    # End date of historical data

# --- Main Logic Mode ---
METHOD = "Rolling"           # "Static" => regression per fixed window. "Rolling" => regression updates bar-by-bar

# --- Anchor Logic ---
ANCHOR_TYPE = "Periodic"     # "First Bar" => anchor from start. "Periodic" => reset based on time
ANCHOR_RES  = "weekly"       # Defines how frequently the anchor resets ("daily", "weekly", "monthly", etc.)

# --- Price Column ---
SOURCE_COL = "Close"         # Which column to use for regression (e.g., "Close", "Adj Close")

# --- Band Settings ---
MULT = 1.0                   # Multiplier for standard deviation bands (higher = wider bands)
SHOW_BANDS = True            # If True, draw upper/lower deviation bands around regression line

# --- Color Config ---
BICOLOR    = True            # If True, use separate colors based on slope sign (up/down)
MONO_COLOR = "#FF5D00"       # If not bicolor, this color will be used for all lines
COL_A = "#089981"            # Slope >= 0 color
COL_B = "#F23645"            # Slope < 0 color

# --- Visual Enhancements ---
GRADIENT = True              # If True, fill area between regression line and bands with a soft gradient
SHOW_DASHBOARD = True        # If True, print summary stats of each regression segment to console

2.2 Load and Clean Price Data

We download daily price data for the selected ticker via Yfinance and clean it. The closing price is standardized as the main reference:

The date index is also converted to a NumPy array for easier positional indexing later.

				
					# Step 1: Data Download & Preprocessing
# Download daily price data and clean it up.
df = yf.download(TICKER, start=START_DATE, end=END_DATE, interval="1d")
if df.empty:
    print("No data returned for the given ticker/date range.")
    exit(1)

# Flatten MultiIndex columns if present
if isinstance(df.columns, pd.MultiIndex):
    df.columns = df.columns.map("_".join)

# Check if the SOURCE_COL exists; if not, try to find a column starting with it.
if SOURCE_COL not in df.columns:
    found = False
    for col in df.columns:
        if col.startswith(SOURCE_COL):
            df["Close"] = df[col]
            found = True
            print(f"Column '{col}' found. Renaming it to 'Close'.")
            break
    if not found:
        print(f"Column '{SOURCE_COL}' not found. Available columns: {df.columns}")
        exit(1)
else:
    df["Close"] = df[SOURCE_COL]

df.dropna(inplace=True)
if df.empty:
    print("Data is empty after cleaning. Exiting.")
    exit(1)

# Standardize columns for ease of use
df["Price"] = df["Close"]
df["Time"]  = df.index
# Convert date index to a NumPy array for positional indexing later.
dates = df.index.to_numpy()

2.3 Segment Price Series by Time

The price series is segmented and a linear regression is fitted on each segment. Two modes previously discussed are supported:

Static Mode: The data is split into fixed segments (e.g., weekly)
Rolling Mode: The regression line is updated continuously from a reset anchor point

Modeling Price Structure with Time-Anchored Linear Regressions

Time-Aware Regression for Detecting and Segmenting Structured Trend Shifts