In partnership with
If you work in fintech or finance, you already have too many tabs open and not enough time.
Fintech Takes is the free newsletter senior leaders actually read. Each week, we break down the trends, deals, and regulatory moves shaping the industry — and explain why they matter — in plain English.
No filler, no PR spin, and no “insights” you already saw on LinkedIn eight times this week. Just clear analysis and the occasional bad joke to make it go down easier.
Get context you can actually use. Subscribe free and see what’s coming before everyone else.
🔔 Flash Launch Alert: AlgoEdge Colab Vault – Your 2026 Trading Edge! 🔔
The $79 book gives you ideas on paper.
This gives you 20 ready-to-run money machines in Google Colab.
I've turned my 20 must-have, battle-tested Python strategies into fully executable Google Colab notebooks – ready to run in your browser with one click.
One-click notebooks • Real-time data • Bias-free backtests • Interactive charts • OOS tests • CSV exports • Pro metrics
Test on any ticker instantly (SPY, BTC, PLTR, TSLA, etc.).
Launch Deal (ends Feb 28, 2026):
$129 one-time (save $40 – regular $169 after)
Lifetime access + free 2026 updates.
Inside the Vault (20 powerhouses):
Bias-Free Cubic Poly Trend
3-State HMM Volatility Filter
MACD-RSI Momentum
Bollinger Squeeze Breakout
Supertrend ATR Rider
Ichimoku Cloud
VWAP Scalper
Donchian Breakout
Keltner Reversion
RSI Divergence
MA Ribbon Filter
Kalman Adaptive Trend
ARIMA-GARCH Vol Forecast
LSTM Predictor
Random Forest Regime Classifier
Pairs Cointegration
Monte Carlo Simulator
FinBERT Sentiment
Straddle IV Crush
Fibonacci Retracement
👇 Grab It Before Price Jumps 👇
Buy Now – $129
P.S. Run code today → test live tomorrow → outperform the book readers.
Reply “VAULT” for direct link or questions.
Premium Members – Your Full Notebook Is Ready
The complete Google Colab notebook from today’s article (with live data, full Hidden Markov Model, interactive charts, statistics, and one-click CSV export) is waiting for you.
Preview of what you’ll get:
Inside:
Automatic PLTR (or any ticker) daily data download from 2021 → today via free yfinance
Full polynomial regression demo (degrees 1–4) with R², MAE, RMSE, MAPE metrics & beautiful comparison plots
Bias-free expanding-window cubic (deg=3) regression – no lookahead bias, real walk-forward style
Clear trading signals: long when price > cubic fit and slope > 0, with entry/exit markers
Interactive-style plots: price + trend filter + green/red signals + in-position highlights
Complete backtest vs Buy & Hold: daily/ cumulative returns, 0.1% transaction costs applied
Detailed performance metrics: Total Return, CAGR, Ann. Volatility, Sharpe (rf=0), Max Drawdown
Trade statistics: number of trades, win rate, average trade return
Realistic Out-of-Sample (OOS) test on last ~10% of data + separate metrics & chart
Bonus: change one line to test any symbol (e.g. TSLA, BTC-USD, AAPL, GLD) or adjust degree/window/costs
Free readers – you already got the full breakdown and visuals in the article. Paid members – you get the actual tool.
Not upgraded yet? Fix that in 10 seconds here👇
Google Collab Notebook With Full Code Is Available In the End Of The Article Behind The Paywall 👇 (For Paid Subs Only)
Most indicators track direction or volatility, but not both. Certainly, they almost never show you where price is clustering inside swings.
The methodology presented here fills that gap and aim to visualize trend direction in real-time.
We visualize adaptive ATR bands, real-time momentum shifts, and live price clustering.
The aim is to spot transitions as they form, and understand where price truly spends its time.
The approach combines multi-band ATR envelopes, percentile-based momentum scoring, and contextual price histograms.
The complete Python notebook for the analysis is provided below.
1. Layering Trend, Volatility, and Momentum
The visualization is built from three layers: trend, volatility, and momentum. Each show a different structural property of the market.
The sequence of the process: (i) extracting market structure by combining rolling averages, (ii) ATR-based volatility bands, (iii) percentile-normalized momentum scoring, (iv) regime segmentation, and (v) price clustering.
What investment is rudimentary for billionaires but ‘revolutionary’ for 70,571+ investors entering 2026?
Imagine this. You open your phone to an alert. It says, “you spent $236,000,000 more this month than you did last month.”
If you were the top bidder at Sotheby’s fall auctions, it could be reality.
Sounds crazy, right? But when the ultra-wealthy spend staggering amounts on blue-chip art, it’s not just for decoration.
The scarcity of these treasured artworks has helped drive their prices, in exceptional cases, to thin-air heights, without moving in lockstep with other asset classes.
The contemporary and post war segments have even outpaced the S&P 500 overall since 1995.*
Now, over 70,000 people have invested $1.2 billion+ across 500 iconic artworks featuring Banksy, Basquiat, Picasso, and more.
How? You don’t need Medici money to invest in multimillion dollar artworks with Masterworks.
Thousands of members have gotten annualized net returns like 14.6%, 17.6%, and 17.8% from 26 sales to date.
*Based on Masterworks data. Past performance is not indicative of future returns. Important Reg A disclosures: masterworks.com/cd
Step 1: Compute the Rolling Mean (Trend Baseline)
The rolling mean provides the directional reference.
N is the lookback window (e.g. 50 bars).
The rolling mean defines the baseline trend and achor all subsequent calculations to the prevailing market direction.
Step 2: Calculate Rolling ATR and Multi-Band Deviation Channels
Volatility is quantified by the rolling Average True Range:
True Range at time t:
ATR over window M:
Multi-band channels:
For each multiplier k (e.g. k=1,2,3):
These bands define the volatility context for each price level at every time step.
Step 3: Calculate Momentum (Directional Change in Trend)
Momentum is measured as the change in the rolling mean over a short interval:
where nnn is a small lookback (e.g., 5 bars).
This difference captures the speed and direction of the trend baseline.
Step 4: Normalize Momentum Using Rolling Percentile
To standardize momentum, divide by the rolling 100th percentile (max value) of Δavg over a window W:
Clip Scoret to [−1,1] for stability.
This produces a momentum oscillator sensitive to recent history, robust to changes in volatility.
Step 5: Trend Regime Determination (Trend State Flagging)
A trend regime is identified using percentile-based thresholds:
Uptrend: If Scoret>UP_THRESHOLD and trend flag is off, the regime flips to “on” (uptrend).
Down/Exit: If Scoret<DOWN_THRESHOLD and trend flag is on, the regime flips to “off” (trend exit).
Trend state: At each time step, track the binary regime state (on/off) and its current start index.
This structure segments the price series into adaptive trend regimes based on recent normalized momentum.
Will Your Retirement Income Last?
A successful retirement can depend on having a clear plan. Fisher Investments’ The Definitive Guide to Retirement Income can help you calculate your future costs and structure your portfolio to meet your needs. Get the insights you need to help build a durable income strategy for the long term.
Step 6: Price Clustering (Histogram Within Regime)
For the current regime window (from regime start index to present), bin all closing prices:
Split the full price range in the regime into B bins.
Count the frequency of closes in each bin:
where 1binj is the indicator function for bin j.
This histogram highlights zones of high price concentration (support, resistance) within each detected trend.
Step 7: Visual Assembly
Upper Panel: Price with rolling mean and multi-band ATR envelopes; trend state marked by color changes and regime-flip markers.
Middle Panel: Percentile-normalized momentum oscillator, with regime thresholds.
Lower Panel: Histogram of price clustering for the active regime, overlaid with ATR bands for contextual reference.
The usefulness of this Combination
Rolling mean anchors the trend, providing structure and smoothing noise.
ATR bands contextualize volatility and dynamically show when price exceeds normal ranges, key for breakout or reversion trades.
Percentile momentum detects regime shifts early and adapt to changing volatility and market conditions.
Regime segmentation allows for analysis within market context, not arbitrary windowing.
Price clustering shows zones of market activity, support, resistance, and congestion, within the structural boundaries of each trend.
2. Python Implementation
2.1 Imports and Parameter Setup
Import all core libraries. Set parameters for symbol, time range, and analytical windows.
Each parameter is annotated so you know how to tune responsiveness and sensitivity.
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.collections import LineCollection
# ── PARAMETERS ───
TICKER = "BTC-USD"
PERIOD = "180d"
INTERVAL = "1h"
SMA_LEN = 50 # Rolling mean window length. Higher = smoother trend, slower to react. Lower = more responsive, but noisier.
ATR_LEN = 200 # ATR calculation window. Higher = more stable bands, slower to adapt. Lower = bands respond quicker, can be more volatile.
MULTS = [1, 2, 3] # ATR multipliers for deviation bands. Increase values for wider bands (fewer extremes flagged), decrease for tighter bands (more sensitivity).
BINS = 50 # Number of price histogram bins. Higher = more detailed clustering, can look noisy. Lower = smoother, less granular distribution.
PERCENTILE_WINDOW = 500 # Window for percentile normalization. Higher = smoother momentum normalization, less sensitive to recent spikes. Lower = reacts faster to new momentum extremes.
UP_THRESHOLD = 0.5 # Momentum score threshold for uptrend regime. Increase = stricter trend confirmation. Decrease = easier to trigger an uptrend.
DOWN_THRESHOLD = -0.5 # Momentum score threshold for ending uptrend. Increase (closer to 0) = earlier exits. Decrease (more negative) = trends persist longer.
COLOR_PRICE = "gray" # Plot color for raw price.
COLOR_SMA_UP = np.array([0, 1, 0]) # SMA line color during uptrend (green).
COLOR_SMA_DOWN = np.array([1, 0, 0]) # SMA line color during downtrend (red).
COLOR_FLIP_UP = "green" # Marker color for uptrend regime flip.
COLOR_FLIP_DOWN = "red" # Marker color for downtrend regime flip.2.2 Data Download and Preprocessing
Download OHLCV data using yfinance. Columns are standardized and rows with missing data are dropped.
def download_ohlc(ticker, period, interval):
df = yf.download(
ticker,
period=period,
interval=interval,
auto_adjust=True,
progress=False
)
# flatten MultiIndex if present
if isinstance(df.columns, pd.MultiIndex):
df.columns = df.columns.get_level_values(0)
df.columns = df.columns.map(str.title)
df.dropna(subset=["Open", "High", "Low", "Close"], inplace=True)
return df
# 1) Fetch data
df = download_ohlc(TICKER, PERIOD, INTERVAL)2.3 Trend and Volatility Calculation
Calculate the rolling mean as the trend baseline and compute ATR for volatility.
# 2) Compute SMA & ATR
df["avg"] = df["Close"].rolling(SMA_LEN).mean()
df["prev_close"] = df["Close"].shift(1)
tr = pd.concat([
df["High"] - df["Low"],
(df["High"] - df["prev_close"]).abs(),
(df["Low"] - df["prev_close"]).abs()
], axis=1).max(axis=1)
df["atr"] = tr.rolling(ATR_LEN).mean()Then build symmetric deviation bands.
# 3) Build deviation bands
for m in MULTS:
df[f"up{m}"] = df["avg"] + m * df["atr"]
df[f"dn{m}"] = df["avg"] - m * df["atr"]2.4 Momentum and Regime Detection
Measure momentum as the change in rolling mean over a short window.
Normalize by recent percentile, then flag trend regimes with threshold crossings.
# 4) Compute avg_col (momentum metric)
df["avg_diff"] = df["avg"] - df["avg"].shift(5)
df["p100"] = df["avg_diff"].rolling(
PERCENTILE_WINDOW,
min_periods=1
).quantile(1.0)
df["avg_col"] = (df["avg_diff"] / df["p100"]).fillna(0).clip(-1, 1)
# 5) Trend flags and start index
trend, starts, start_i = False, [], []
si = 0
for i, v in enumerate(df["avg_col"]):
if v > UP_THRESHOLD and not trend:
trend, si = True, i
elif v < DOWN_THRESHOLD and trend:
trend, si = False, i
starts.append(trend)
start_i.append(si)
df["trend"] = starts
df["start_i"] = start_i
# capture last row for labeling bands
last = df.iloc[-1]2.5 Price Clustering: Regime Histogram
For the active trend regime, segment all closes and bin them for a price clustering histogram.
# 6) Build histogram for current trend period
hist_start = int(last["start_i"])
hist_df = df.iloc[hist_start:]
# dynamic y-range based on ±3 bands
min_p = hist_df[f"dn{MULTS[-1]}"].min()
max_p = hist_df[f"up{MULTS[-1]}"].max()
step = (max_p - min_p) / BINS if BINS else 1
hist = np.zeros(BINS, int)
if step > 0:
for price in hist_df["Close"]:
idx = int((price - min_p) / step)
if 0 <= idx < BINS:
hist[idx] += 1
maxh = hist.max() or 1
barcols = [plt.get_cmap("bwr")(h / maxh) for h in hist]
ys = min_p + (np.arange(BINS) + 0.5) * step2.6 Plot Construction
Build a multi-panel visualization:
Price with deviation bands and color-coded regimes
Momentum oscillator pane
Horizontal histogram for price clustering
# ── PLOT ────
fig, (ax_price, ax_osc, ax_hist) = plt.subplots(
3, 1,
figsize=(14, 10),
dpi=100,
gridspec_kw={"height_ratios": [4, 1, 2], "hspace": 0.15}
)
# 1) Price pane
plt.style.use("dark_background")
ax_price.plot(df.index, df["Close"], color=COLOR_PRICE, linewidth=1)
# SMA gradient
t = (df["avg_col"].clip(-0.3, 0.3) / 0.3 + 1) / 2
cols = [COLOR_SMA_DOWN * (1 - v) + COLOR_SMA_UP * v for v in t]
x = mdates.date2num(df.index)
pts = np.array([x, df["avg"]]).T.reshape(-1, 1, 2)
segs = np.concatenate([pts[:-1], pts[1:]], axis=1)
ax_price.add_collection(LineCollection(segs, colors=cols[:-1], linewidth=3))
# flip markers
flips = df[df["trend"] ^ df["trend"].shift(1).fillna(False)]
for idx, row in flips.iterrows():
c = COLOR_FLIP_UP if row["trend"] else COLOR_FLIP_DOWN
s = np.clip((abs(row["avg_col"]) - UP_THRESHOLD) / (1 - UP_THRESHOLD), 0, 1)
ax_price.axvline(idx, color=c, alpha=0.3 + 0.7*s, linestyle="--", linewidth=1)
ax_price.scatter(idx, row["avg"], s=30, color=c, zorder=5)
ax_price.set_title(f"{TICKER} · Deviation Trend Profile", color="white")
# 2) Oscillator pane
ax_osc.plot(df.index, df["avg_col"], color="white", linewidth=1)
ax_osc.hlines([UP_THRESHOLD, DOWN_THRESHOLD],
df.index[0], df.index[-1],
color="gray", linestyle="--", linewidth=1)
ax_osc.set_ylabel("avg_col")
ax_osc.set_ylim(-1, 1)
# 3) Histogram pane (horizontal bars)
ax_hist.barh(ys, hist, height=step*0.9, color=barcols, edgecolor="black")
ax_hist.set_xlabel("Count")
ax_hist.set_ylabel("Price")
ax_hist.set_xlim(0, maxh*1.1)
ax_hist.set_ylim(min_p - step, max_p + step)
# draw and label the ATR bands on the histogram
for m in MULTS:
up = last[f"up{m}"]
dn = last[f"dn{m}"]
ax_hist.axhline(up, color="white", linestyle="--", linewidth=1)
ax_hist.text(maxh*1.02, up, f"+{m}", va="center", color="white")
ax_hist.axhline(dn, color="white", linestyle="--", linewidth=1)
ax_hist.text(maxh*1.02, dn, f"-{m}", va="center", color="white")
# styling
for ax in (ax_price, ax_osc, ax_hist):
ax.tick_params(colors="white", labelcolor="white")
for spine in ax.spines.values():
spine.set_color("white")
fig.subplots_adjust(left=0.06, right=0.96, top=0.93, bottom=0.06)
plt.show()
3. Interpretation
The top panel shows the BTC-USD price with the trend signal overlaid. Green sections on the moving average mark active uptrends.
Red marks neutral or downtrending phases. Dashed vertical lines flag regime shifts. Green for trend starts, red for exits, yellow for rapid flips.
In the middle panel, the oscillator tracks momentum. When it rises above 0.5, an uptrend begins. When it drops below –0.5, the trend ends.
At the bottom, horizontal bars map out where price clusters within the active regime.
Stronger colors show heavier trading activity at those levels. ATR bands bracket these clusters to show how far price moves before volatility becomes extreme.
For BTC in particular, the histogram shows strong clustering between $105,000 and $107,000.
This shows that most trading during the current regime has occurred in this upper range.
This signals a consolidation zone and potential support if price pulls back.
4. Limitations and Extensions
This methodology adapts to trend and volatility, but it does not predict future moves.
Whipsaws increase when market regimes shift quickly, especially in choppy or news-driven environments.
Parameter sensitivity matters: overly tight bands or thresholds can trigger false regimes, while loose settings may lag true shifts.
The approach uses only price action. Volume, order flow, or external indicators are not included. Short lookback windows can amplify noise; long ones may miss short-term rotations.
The histogram shows where price has clustered in the current regime only. but it does not capture historical support or resistance outside that window.
Extensions are straightforward. You can add volume-weighted clustering to expose high-liquidity zones.
For deeper context, overlay other features like open interest, funding rates, or macro indicators.
Final Thoughts
Markets d gather, scatter, and rest in places which can be made visible.
The methodology presentend here is just one method of doing so which can be fine-tuned further.
Subscribe to our premium content to read the rest.
Become a paying subscriber to get access to this post and other subscriber-only content.
Upgrade