Predictive Breakout Channels | GainzAlgoAbout the Indicator
The Predictive Breakout Channels indicator is a predictive machine-learning engine designed to map institutional market structure and calculate the statistical probability of impending breakouts. Instead of relying on traditional lagging indicators, the system dynamically anchors itself to major market pivots using a rolling Linear Regression Channel framework.
By evaluating a combination of localized trend correlation, relative strength, institutional volume distribution, and variance metrics, the engine projects real-time target zones while simultaneously calculating a directional probability score directly on the chart the moment a breakout occurs.
Dynamically anchors to institutional pivot structures
Uses a rolling Linear Regression Channel
Evaluates trend correlation, RSI, and variance metrics
Projects real-time ATR-based target zones
Calculates breakout probability scores directly on-chart
Designed to distinguish genuine breakouts from fakeouts
The Core Theory of Breakouts
Markets spend the majority of their time consolidating rather than trending. During these equilibrium phases, liquidity pools accumulate on both sides of the range while volatility compresses beneath the surface.
A breakout represents the structural transition from equilibrium into expansion.
When institutional order flow aggressively consumes localized liquidity, price breaches structural boundaries and volatility rapidly expands outward. The challenge for traders has never been identifying that a breakout occurred — the real challenge is determining whether the move has enough structural backing to sustain itself or whether it is simply a liquidity trap designed to reverse shortly afterward.
The Predictive Breakout Channels engine was specifically designed to address that exact problem.
The Logic Engine — ANOVA & The Power of Variance
To help solve the fakeout problem, this engine incorporates ANOVA, short for Analysis of Variance.
Originally developed by legendary statistician Ronald Fisher, ANOVA has historically served as one of the foundational statistical tools used throughout medical research, behavioral science, and high-level quantitative analysis. Its purpose is to determine whether differences between groups of data are statistically meaningful or simply random noise.
In this indicator, that same statistical framework is adapted directly to price action.
The engine continuously evaluates the structural differences between groups of candle data — including highs, lows, and closes — in real time in order to measure the quality and significance of underlying market expansion.
The Niche Secret — F-Statistic & Volatility Compression
Quantitative modeling revealed a particularly powerful characteristic regarding variance measurements inside the ANOVA engine.
When the raw ANOVA F-Statistic becomes drastically elevated, or when the standardized Z-Score breaches extreme thresholds such as 2 standard deviations, it often signals a state of hyper-compressed market consolidation.
Think of it like winding a mechanical spring tighter and tighter.
As variance compresses to rare statistical extremes, market energy begins building beneath the surface. Eventually that stored pressure releases through aggressive volatility expansion.
This variance surge acts as a leading indicator for impending volatility before the actual breakout even occurs.
However, variance alone cannot determine directional bias. Because of this, the engine layers in additional confirmation modules such as RSI and Trend Correlation Length to help determine whether institutional momentum is favoring bullish or bearish continuation.
Indicator Settings & Customization
The system is fully modular, allowing traders to fine-tune the engine based on their preferred asset class, timeframe, or trading style.
Anchored LinReg Channel Settings: Customize left and right pivot lookbacks alongside standard deviation multipliers to control how the channel dynamically anchors itself to price structure.
ANOVA Confirmation: Fine-tune the lookback period and baseline Z-Score thresholds required for breakout validation.
Feature Filters: Adjust RSI and Trend Correlation baseline lengths to make directional probability scoring more aggressive or more selective.
High Variance Alert Label: Disabled by default. When enabled, the engine plots visual warning labels whenever variance compression reaches statistically elevated levels.
Include HTF Trend Filter: Controls whether breakout signals are filtered using higher timeframe trend conditions.
The Strategic Dilemma — Higher Timeframe Trend Filtering
The indicator includes a dedicated HTF Trend Filter toggle that leverages higher timeframe EMA spreads to determine whether lower timeframe breakout signals align with broader institutional trend conditions.
Choosing whether to enable this filter depends entirely on the type of market environment you prefer trading.
1. HTF Filter ON — Trend Following Regime
Filters out a significant amount of lower timeframe noise
Produces fewer but statistically stronger breakout signals
Aligns entries with broader institutional money flow
Increases overall follow-through probability
However, because the engine becomes heavily biased toward the macro trend, it may intentionally suppress counter-trend reversals or early-stage trend shifts.
2. HTF Filter OFF — Agile / Mean-Reversion Regime
Allows the engine to react dynamically in both directions
Captures sharp intraday reversals more aggressively
Performs well in swinging or range-bound environments
Increases breakout frequency substantially
The tradeoff is naturally higher exposure to lower timeframe noise and shorter average continuation during counter-trend conditions.
How to Trade with the Indicator
When price closes outside the Linear Regression Channel while simultaneously satisfying the statistical validation criteria, the engine prints a breakout entry signal alongside a projected probability score.
At the same time, the system projects 4 distinct ATR-based Target Zones labeled T1 through T4.
Aggressive Traders: May choose to execute immediately on the breakout close while targeting T2 or T3 with structural stops positioned back within the channel.
Conservative Traders: May choose to use the Probability Score as a filter or wait for a localized retest of the broken channel boundary before entering.
The High Variance Play
When the High Variance Alert label appears, traders should avoid impulsively chasing the immediate candle.
Instead, the label should be treated as an early warning that volatility expansion is rapidly approaching.
The preferred approach is to wait for the subsequent confirmed breakout signal, then trade the resulting momentum expansion into the projected target zones.
High variance does not predict direction
It predicts volatility expansion
Directional confirmation comes afterward through breakout validation
Wrapping It Up
The Predictive Breakout Channels indicator bridges quantitative data science with classic market microstructure principles.
By treating volatility as a measurable statistical property rather than a visual guessing game, the engine helps traders identify where the market is coiling, estimate the probability of expansion, and navigate breakout environments using structured statistical confirmation instead of emotion.
Whether used for momentum continuation, volatility expansion, or intraday breakout trading, the system was designed to provide traders with a clearer framework for distinguishing meaningful expansion from market noise. Indicator
KNN Machine Learning Mean Reversion Probability [Dots3Red]█ OVERVIEW
This script applies a K-Nearest Neighbors (KNN) machine learning algorithm to estimate the probability that price will revert to its moving average within a defined number of bars. Rather than predicting momentum direction, it asks a more specific question: how likely is it that this extension snaps back?
The model searches historical bars for situations that looked like the current one — same degree of stretch, same RSI exhaustion profile, same volume behavior — and measures how often those situations ended in a reversion to the basis MA. That proportion becomes the live probability shown on your chart.
█ METHODOLOGY
The indicator follows a supervised machine-learning pipeline with five distinct stages.
1 — Labeling (what we are predicting)
Each historical bar receives a label based on what actually happened next. If price was extended above the basis MA and touched it within the Reversion Window — that bar is labeled a successful reversion. If it did not touch — labeled as no reversion. The same logic applies from below. This is the core distinction from momentum KNN indicators: the target is reversion to fair value , not directional price movement.
2 — Feature engineering (what we measure)
Five features capture how stretched current price conditions are, each Z-score normalized to remove scale bias:
• MA Distance — signed % distance of close from the basis MA. The primary extension signal.
• Bollinger Band position — where price sits within the bands, normalizing extension relative to current volatility.
• RSI deviation — how far RSI has moved from neutral (50). Captures momentum exhaustion.
• Body compression — ratio of candle body to total range. Small bodies near extremes signal hesitation and loss of directional conviction.
• Volume fade — declining volume during an extension is a classic exhaustion signature.
3 — Z-score normalization
All five features are standardized using a rolling mean and standard deviation computed on prior bars only (look-ahead free). This ensures the KNN distance calculation is not biased by features of different scales.
4 — KNN engine
The algorithm scans the historical lookback window for the K most similar past bars, measured by Minkowski Distance across all five features simultaneously. Closer neighbors receive exponentially higher voting weight via a Gaussian Kernel , so the prediction is driven by the most relevant historical analogs — not a simple majority vote.
5 — Dual probability output
Two independent probabilities are maintained and tracked separately:
• P(reversion from above) — for overbought / extended-high setups.
• P(reversion from below) — for oversold / extended-low setups.
They are kept separate because bear-side extensions and bull-side extensions have statistically different behavior — bear moves are typically faster and sharper. A signal fires when the relevant probability crosses the user-defined threshold, and only when price is actually extended (see Extension Gate below).
█ WHAT MAKES THIS DIFFERENT
Most published KNN indicators predict momentum direction — will price go up or down next bar? This indicator predicts something more specific: will price return to its average?
The distinction matters for several reasons:
1 — A high momentum reading can persist for many bars. A stretched reading has a natural gravity pulling it back, and measuring the historical probability of that snap is a more tractable problem than direction forecasting.
2 — The two probability channels are trained on separate populations, accounting for the asymmetry between bull and bear extensions.
3 — The Extension Gate ensures signals only appear when there is actually something to revert from — no signals in flat, choppy, low-volatility conditions.
█ EXTENSION GATE
Even if the KNN model outputs a high reversion probability, no signal appears unless price is beyond Gate Multiplier × ATR from the basis MA. This prevents false signals in low-volatility or ranging conditions where mean reversion setups carry no statistical edge.
█ HOW TO USE
Signal shapes (▲ Rev / ▼ Rev)
Fire when P(reversion) crosses the threshold AND price passes the extension gate. The label at the signal bar shows the exact probability at the moment of firing.
Snap zone fill
When a signal is active, the region between current price and the basis MA is shaded. This is the reversion target zone — where price is statistically expected to return. The fill deactivates automatically once price reverts back through the basis.
Bar colors
• Bright green/red — active probability above the threshold on the current price side.
• Dimmed green/red — probability elevated but below threshold, approaching signal territory.
• No color — neutral or low reversion probability.
Background flash
A faint background confirms the exact bar on which a signal fired.
Recommended workflow
1 — Set the Basis MA to your preferred mean reversion average. EMA 20 is a common starting point for intraday and swing setups.
2 — Tune the Reversion Window to match your typical trade hold time in bars.
3 — Adjust the Extension Gate multiplier to the asset's volatility profile. Crypto typically requires higher values than forex or equities.
4 — Use the Probability Threshold to control signal frequency. 0.65 gives moderate frequency; 0.75 and above is more selective.
5 — Combine with volume analysis or candlestick confirmation at signal bars for additional confluence before entering a position.
█ SETTINGS REFERENCE
KNN Engine
• K Neighbors — how many historical analogs vote. Higher = smoother, slower to react.
• Lookback Window — size of the historical search space in bars.
• Reversion Window — bars within which price must touch the MA to count as a reversion.
• Minkowski p — distance metric exponent. 1 = Manhattan, 2 = Euclidean.
• Gaussian Bandwidth — controls how steeply neighbor weight falls with distance.
• Probability Threshold — minimum confidence required to show a signal.
Feature Settings
• Basis MA type / length — the fair value line all features are measured against.
• Bollinger Band mult — standard deviation multiplier for the BB position feature.
• RSI length — period for the RSI exhaustion feature.
• Volume MA length — baseline for the volume fade feature.
Extension Gate
• Require extension gate — toggle the ATR-based signal filter on/off.
• Gate band multiplier — how many ATRs from basis price must be before signaling.
• Gate ATR length — period for the ATR used in the gate calculation.
█ LIMITATIONS
• KNN is a lazy learner — it does not generalize beyond historical patterns in the lookback window. Strong trending regimes or structural breaks can produce elevated false signals.
• The reversion probability reflects historical frequency, not a guarantee of future behavior.
• On low-bar-count charts (e.g. weekly on newer assets), the lookback window may not contain enough samples to produce stable probability estimates.
• Computation scales with lookback window size. Very large windows may slow chart rendering.
█ DISCLAIMER
This indicator is a decision-support tool, not a trading system. It does not constitute financial advice. Always apply proper risk management and combine with your own analysis.
Algorithm: K-Nearest Neighbors (KNN)
Distance metric: Minkowski Distance
Preprocessing: Z-Score Normalization
Target: Probabilistic Mean Reversion Indicator
Adaptive Trend Intelligence + SMC + RVOL + ML - FloAlgoThis indicator combines an Adaptive SuperTrend with Smart Money Concepts (SMC) market structure, Relative Volume (RVOL) filtering, and an online Machine Learning model to produce high-confidence trend-following signals.
How It Works
Adaptive SuperTrend — A SuperTrend band whose ATR multiplier scales automatically based on the short/long volatility ratio. In quiet markets the band tightens; in expansions it widens. An optional noise filter requires price to hold on the new side for N bars before a flip is accepted, eliminating whipsaws.
SMC Market Structure Engine — Uses a Stochastic Momentum Oscillator to detect overbought/oversold pivots and build an alternating High/Low swing chain. From those swings it tracks Dow-Theory labels (HH, HL, LH, LL), draws a zigzag, plots S/R zones, and detects BOS (Break of Structure) when price closes beyond the previous major swing confirming trend continuation, and CHoCH (Change of Character) when price closes beyond the prior opposing major swing signaling a trend flip. Both events require an established trend direction and fire only against the correct structural level, preventing false signals on internal corrections.
RVOL Filter — Computes directional buy/sell volume from candle structure and ranks it against a rolling percentile. Signals are suppressed unless the directional volume percentile clears a configurable threshold, keeping entries to high-participation moves only.
Online ML Model — A logistic regression model with L2 regularisation trained incrementally on every confirmed SuperTrend flip. It learns 17 features per signal including candle shape, volume, momentum, ATR slope, RSI, Bollinger position, RVOL, and SMC bias, then resolves each trade when the next flip occurs. Probability is displayed in the info table and can gate signals via a minimum confidence threshold.
Visual Elements
SuperTrend line with bull/bear fill
▲ / ▼ signal arrows and labels
BOS / CHoCH labels at structure breaks
HH / HL / LH / LL Dow labels at each pivot
Zigzag lines connecting momentum pivots
S/R zone boxes, colour-coded and fading on break
Info table showing Signal, Trend, ML Confidence, RVOL, Momentum, Volatility, Quality, MS Bias, and last Structure event
Key Settings
ATR Length — lookback for ATR calculation
ATR Multiplier — base band width
Adaptive Multiplier — auto-scales multiplier with volatility ratio
Noise Filter (bars) — bars price must hold before flip is confirmed
RVOL Lookback — rolling window for volume percentile ranking
RVOL Min Percentile % — minimum directional volume percentile to allow a signal
Min ML Probability % — minimum ML model confidence to allow a signal
Stochastic Length — sensitivity of the momentum pivot oscillator
Overbought / Oversold — stochastic zone thresholds for pivot detection
Filter Signals by MS — gate signals to align with SMC trend direction
Max S/R Zones per Side — maximum supply/demand boxes kept on chart
Indicator
Neural Weight Oscillator (Zeiierman)█ Overview
The Neural Weight Oscillator (Zeiierman) is an adaptive multi-factor oscillator that combines structured decision-making with dynamic market learning.
The script analyzes three core market behaviors: Trend, Mean Reversion, and Momentum. Instead of treating these components equally, the oscillator uses the Best-Worst Method (BWM) to determine which market behavior should have the greatest influence under current market conditions.
An adaptive training layer then studies historical market reactions and gradually amplifies the features that have recently produced the strongest directional behavior.
The result is a hybrid oscillator that blends:
Human-defined market logic
Adaptive feature weighting
Multi-factor momentum analysis
Dynamic market learning
Unlike traditional oscillators that rely on static formulas, the Neural Weight Oscillator continuously adjusts its internal structure based on both trader-defined weighting preferences and changing market behavior.
█ How It Works
⚪ Market Structure Engine
The oscillator builds its analysis from three independent behavioral models: Trend, Mean Reversion, and Momentum.
The Trend component measures structural direction by comparing the fast EMA against the slow EMA, then adds the EMA slope to capture acceleration.
trendSpread = (emaFast - emaSlow) / atr
trendSlope = (emaFast - emaFast ) / atr
trendScore = normalize(trendSpread + trendSlope, -2.5, 2.5)
The Mean Reversion component measures stretched conditions using RSI exhaustion and statistical deviation from the market mean.
zScore = dev == 0 ? 0 : (close - basis) / dev
meanScore = (100 - rsi) * 0.5 + normalize(-zScore, -2.5, 2.5) * 0.5
The Momentum component measures directional acceleration using ROC, RSI momentum, and EMA velocity.
rocNorm = normalize(close / close - 1.0, -0.05, 0.05)
momentumScore = rocNorm * 0.45 + rsi * 0.35 + emaMomentum * 0.20
Each component produces its own normalized score before being blended into the final oscillator.
⚪ Best-Worst Method (BWM)
The core weighting system in the oscillator is based on the Best-Worst Method (BWM), a structured decision-making framework that creates balanced weighting relationships among multiple factors.
bestIdx = criterionIndex(bestCriterion)
worstIdx = criterionIndex(worstCriterion)
array.set(bo, bestIdx, 1.0)
array.set(ow, worstIdx, 1.0)
Instead of assigning arbitrary percentages manually, BWM allows the trader to define which market behavior matters most and which matters least. The script then automatically calculates balanced internal weights.
The process begins by selecting:
The “Best” factor → the market behavior trusted most
The “Worst” factor → the market behavior trusted least
relWeight = math.sqrt((aBW / boVal) * owVal)
The oscillator then compares all remaining factors relative to those two extremes and converts those relationships into normalized internal weights.
⚪ How To Think About The BWM Weights
The easiest way to think about BWM is:
“What type of market behavior do I trust most in the current environment?”
Different market conditions naturally favor different behaviors.
In strong directional trends , traders often prioritize Trend because structural continuation becomes the dominant force.
In choppy or range-bound markets , Mean Reversion may become more important because the market repeatedly returns back toward equilibrium.
During aggressive breakout environments , Momentum may deserve the highest weighting because acceleration becomes the primary driver.
The goal is not to find a “perfect” weight configuration, but rather to align the oscillator with the type of behavior currently dominating the market.
⚪ Adaptive Neural Training Layer
The oscillator includes an adaptive learning layer that learns how the market has recently reacted to the model’s internal features.
The script looks back at prior Trend, Mean Reversion, and Momentum feature values, then compares them to the future price reaction.
target = close / close - 1.0
targetDirection = target > 0 ? 1.0 : target < 0 ? -1.0 : 0.0
High-quality samples are ranked by how strong the move was relative to volatility.
sampleScore = math.abs(target) / qualityVol
The model then compares its internal prediction against the actual market direction and adjusts the learned feature weights over time.
pred = twTrend * s.trend + twMean * s.mean + twMomentum * s.momentum + tbias
err = pred - s.target
This allows the oscillator to gradually learn which features are producing the strongest directional behavior.
⚪ Adaptive Feature Amplification
The learned weights are converted into feature amplifiers.
trendAmplifier = 1.0 + learnTrend * blend
meanAmplifier = 1.0 + learnMean * blend
momentumAmplifier = 1.0 + learnMomentum * blend
This allows stronger features to gain more influence, while weaker features receive less influence.
█ How to Use
⚪ Reading the Oscillator
The oscillator operates between 0 and 100.
Values above 50 suggest bullish pressure dominates the market, while values below 50 suggest bearish pressure dominates.
As the oscillator moves farther away from the neutral 50 level, directional imbalance becomes stronger.
Readings above 70 typically indicate strong bullish expansion, while readings below 30 indicate strong bearish pressure. Extreme zones above 80 or below 20 may signal exhaustion conditions where reversals become more likely.
⚪ Using the BWM Weighting System
The BWM system allows traders to align the oscillator with current market behavior by controlling how much influence Trend, Mean Reversion, and Momentum should have inside the model.
Imagine the market is trending strongly upward.
You may believe:
Trend is the dominant market behavior.
Mean Reversion still matters during pullbacks.
Momentum should have the least influence.
In this case, you could choose:
Best = Trend
Worst = Momentum
You then control how strongly Trend dominates the other factors through the comparison inputs.
For example:
Best-to-Others:
Trend = 1
Mean = 3
Mom = 6
Relative-to-Worst:
Trend = 4
Mean = 2
Mom = 1
This tells the oscillator:
Trend is selected as the strongest market behavior.
Momentum is selected as the weakest market behavior.
Trend is 3x more important than Mean Reversion.
Trend is 6x more important than Momentum.
Mean Reversion is 2x more important than Momentum.
The script automatically converts these relationships into balanced internal weights.
As a result, the oscillator becomes more trend-sensitive while reducing the influence of short-term momentum fluctuations and weak counter-trend behavior.
If the market becomes highly rotational or range-bound, traders may instead increase the importance of Mean Reversion so the oscillator becomes more responsive to exhaustion and reversal conditions.
During aggressive breakout environments, increasing Momentum weighting can help the oscillator react faster to acceleration phases.
The weighting system is designed to adapt the oscillator’s personality to different market environments rather than forcing one static interpretation onto every condition.
█ Settings
Fast EMA: controls the responsiveness of the Trend and Momentum calculations.
Slow EMA: controls the structural trend baseline used throughout the oscillator.
Smoothing: controls the smoothness of the final oscillator line.
The Best and Worst: determine how the BWM weighting model prioritizes market behaviors.
Best-to-Others: define how strongly the selected Best factor dominates the remaining components.
Relative-to-Worst: define how much stronger each component is compared to the selected Worst factor.
Use Training: enables the adaptive learning layer.
Influence: controls how strongly the learned model amplifies features.
Line Impact: controls how much the adaptive model can directly influence the oscillator line itself.
-----------------
Disclaimer
The content provided in my scripts, indicators, ideas, algorithms, and systems is for educational and informational purposes only. It does not constitute financial advice, investment recommendations, or a solicitation to buy or sell any financial instruments. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information.
All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.
Indicator
Candle DNA Morphology | AnonycryptousCandle DNA Morphology | Anonycryptous
Description & user manual
Why is this indicator different:
Most candle analysis tools work with names. They look at a candle and call it an engulfing, a hammer, a doji, a shooting star. They compare shape against a fixed template and fire a signal when the match is close enough. The problem is that names are approximations. A hammer in a trending market is not the same as a hammer at a structural level with elevated volume. A name cannot capture that. A fixed template cannot either.
Candle DNA Morphology works differently.
It does not use names. It does not use templates. It compares the current candle to every historical candle within a configurable lookback window and finds the one that is mathematically closest — across up to eight normalized dimensions simultaneously. Body size, wick proportions, body position within the range, relative volume, candle size relative to recent volatility, trend alignment, and structural context. Then it tells you what happened after that historical candle, directly on the chart, with a single marker you can hover.
Other tools that use candle similarity show you statistics. Continuation rates. Reversal percentages. Tables to read and interpret. You still have to decide what the numbers mean and whether they matter right now.
Candle DNA Morphology does not show you statistics. It shows you a signal — the exact historical candle that matched, marked on the chart, with the date, the score, the direction, the R value, the percentage move, and the price move of what followed. No table to interpret. No calculation required. The information is in the hover.
The score tells you how close the match was. The tier tells you how rare it is. The color tells you the direction. Everything else is in the tooltip.
Important notice
Candle DNA Morphology generates signals based on historical pattern similarity and price behavior.
These signals are not financial advice.
They do not predict the future.
They do not guarantee profitability.
The outcome values shown — R, percentage, and price — are historical measurements from the matched candle in the past. They reflect what happened then, on that instrument, at that price level. The market may behave differently now. Similar candles can produce different results. These values are context, not certainty.
All trading decisions are made entirely by the user.
Always manage your own risk. Always apply your own judgment.
1. Overview
Candle DNA Morphology is a candle fingerprint matching indicator built around the mathematical similarity between the current candle and historical ones — and what those historical candles preceded.
What it includes:
- Up to 8-dimensional candle fingerprint matching using Euclidean distance
- Configurable lookback window from 50 to 1000 bars
- Three signal quality tiers: standard, elite, and ultra
- Hoverable triangle markers on signal bars with full match details in the tooltip
- Diamond marker and vertical line on the exact historical matched candle
- Configurable cooldown between signals to prevent clustering
- Signal mode selector: current bar, match bar, or both
- Dynamic score normalization — score stays 0-100 regardless of how many dimensions are active
- Vertical signal line and background glow on qualifying bars
- Live dashboard with score bar, tier, bias, match date, outcome in R / percentage / price, cooldown countdown, active dimensions, and ATR
- All times displayed in the timezone you select in the dashboard settings
- Four alerts: bull match, bear match, elite match (90+), ultra match (95+)
2. How the fingerprint works
Every candle is described by a set of normalized values between 0 and 1. These values capture the shape and context of the candle without using price or time units — which is what makes the engine self-calibrating across instruments and timeframes.
The five core dimensions are always active:
Body ratio. The size of the body relative to the total candle range. A full-body candle scores near 1. A doji scores near 0.
Upper wick. The upper wick as a proportion of the total range. A long upper wick scores high. A candle with no upper wick scores 0.
Lower wick. Same logic for the lower wick.
Body position. Where the body sits within the range — 0 is at the bottom, 1 is at the top. A bullish candle with a close near the high scores near 1. A bearish candle with a close near the low scores near 0.
Relative volume. Volume divided by the 20-bar average, capped at 3x and normalized. A spike at 2x average scores higher than a quiet bar at 0.8x.
Three optional dimensions can be enabled independently:
Atr percentile (dimension 6). How large the current candle is relative to recent volatility. Measures the candle range against the 14-bar ATR, normalized to a 0-2x cap. A large candle matches better with historically large candles.
Trend alignment (dimension 7). How far the close sits above or below EMA 21, normalized to the ATR. A bullish candle well above the EMA matches better with historical bullish candles that were also above the EMA.
Candle context (dimension 8). The relationship between the current candle and the previous one. Inside bars score 0. Outside bars score 1. Normal bars score 0.5. This dimension helps the engine recognize structural setups like inside bar breakouts.
3. Scoring and tiers
Similarity is measured using Euclidean distance — the straight-line distance between two candles in multi-dimensional space. The closer two candles are in this space, the more similar they are.
The maximum possible distance scales automatically with the number of active dimensions, so the score always ranges from 0 to 100 regardless of configuration. A score of 100 would mean a perfect match across all active dimensions. A score of 70 means a strong structural similarity. A score of 95 or above is exceptionally rare.
Three tiers determine how signals are displayed:
Standard (70-89). Green for bull, red for bear. The match is meaningful but not uncommon.
Elite (90-94). Gold marker with a star prefix ★. The match is close enough to be notable. These appear infrequently.
Ultra (95+). Cyan marker with a diamond prefix ◈. A near-identical historical candle was found. Very rare. When one fires, it is worth attention.
4. Understanding the signal
When a signal fires, two things appear on the chart depending on your signal mode setting.
A triangle on the current bar points in the direction the market moved after the historical match — up for a bullish outcome, down for a bearish one. Hovering the triangle with your cursor or S-Pen shows the full match details: the date and time of the historical candle, the score, the tier, the bias, the outcome in R, and the R value.
When a signal fires, two dotted lines and a vertical connector appear on the chart. The first dotted line runs horizontally from the signal bar close — this is the entry reference level, the price from which all R, percentage, and dollar measurements are calculated. The second dotted line shows the target level — where the market would reach if the historical outcome repeats. A vertical connector at the end of the forward window closes the structure. All three lines run exactly as many bars as your forward outcome setting.
The target level is calculated using the current ATR, not the historical ATR from the matched candle. This makes it relevant to the current market conditions. Hovering the target line shows both values — the target using the current ATR and the target using the historical ATR — so you can see how much volatility has changed between then and now. If the current ATR is significantly higher than the historical ATR, the target is further away than it was in the original setup. If it is lower, the target is closer.
A diamond and a vertical line on the historical matched candle shows you exactly which bar was used as the reference. The line runs through the full range of that candle so there is no ambiguity about which bar matched. The color follows the signal tier.
In addition to the dotted lines, the indicator can draw historical projection candles to the right of the signal bar. This feature is off by default and can be enabled in the visuals settings. When enabled, candles appear to the right of the signal bar showing the exact OHLC of the bars that followed the historical matched candle. Each candle has a body and centered wicks, drawn in the tier color of the signal. They scale correctly with chart zoom. A small label above the first candle reads "Historical projection" to make it immediately clear that these are historical bars, not predictions. The number of projection candles follows your forward outcome setting. Body transparency and wick transparency are independently configurable in settings.
The bias shown in the dashboard and the tooltip is the direction the market moved after the matched candle — not a prediction of what will happen now. It is historical context, not a guarantee.
All times shown in this indicator use the timezone you select in the dashboard settings. The default is UTC. Set it to your local timezone — for example UTC+2 for Amsterdam, UTC-4 for New York, UTC+9 for Tokyo — and all match times will display in your local time automatically.
5. Understanding the outcome values
The dashboard and tooltip show three outcome measurements for the historical matched candle. All three describe the same move — the price action in the bars following that historical candle — expressed in different units.
Outcome (R). How far price moved after the matched candle, expressed as a multiple of the ATR at that historical bar. This is the primary measurement. It is instrument-independent and works the same on BTC, SOL, MNQ, or any other asset. A value of +2.4R means price moved 2.4 times the ATR upward in the forward window.
Outcome (%). The same move expressed as a percentage of the close price at the matched candle. This gives a more intuitive sense of the magnitude for traders who think in percentage terms.
Outcome (price). The same move expressed in the currency of the instrument. This is the raw price distance the market covered — for example, $1,075 on Bitcoin or $0.87 on SOL. This value is calculated using the ATR and close price at the historical match bar, not at the current price.
The target line on the chart uses the current ATR rather than the historical ATR. This is intentional — the current ATR reflects how the market is moving right now, making the projected target more relevant to your actual trade. The historical ATR is still shown in the target line tooltip for reference, so you can see whether volatility has expanded or contracted since the original setup occurred. A large difference between the two ATR values means the market is in a different volatility regime than it was at the time of the match.
An important note on the price value: this reflects the historical move at the time and price of the matched candle. If Bitcoin was at 60,000 when the match occurred and is now at 78,000, the same R move produces a larger dollar value today than it did then. The price outcome is historical context — it shows what that candle type led to in dollar terms at that moment, not what the current setup will produce now.
This is not your personal risk-to-reward ratio. The R value gives you the historical move size. Your stop loss placement determines your actual R:R.
6. Bias and cooldown
The bias shown in the dashboard reflects the outcome direction of the current best match. It shows bull when the matched historical candle was followed by an upward move, and bear when it was followed by a downward move.
Bias changes when a new bar closes and the engine finds a different best match with a different historical outcome direction, or when the cooldown expires and a new signal fires pointing in a new direction.
During cooldown, the dashboard shows — wait. The last match date and all three outcome values remain visible. No new signal fires until the cooldown bar count has elapsed. The cooldown countdown shows how many bars remain before the next signal is allowed, or ready when it can fire freely.
Cooldown prevents signal clusters from forming on consecutive bars where the same setup repeats. On faster timeframes with many morphologically similar candles, a cooldown of 15 bars or more is strongly recommended.
7. Self-calibration
All fingerprint dimensions are normalized to values between 0 and 1. Volume is measured relative to its own 20-bar average. Candle size is measured relative to the ATR. Trend alignment is measured in ATR units. There are no fixed price thresholds anywhere in the engine.
This means the indicator adapts automatically to different instruments and timeframes. A BTC candle and an MNQ candle with the same proportional shape, same relative volume, and same relationship to their respective EMAs will produce the same fingerprint score — even though one trades at 78,000 and the other at 20,000.
When switching instruments, only the min match score typically needs a small adjustment. SOL and other volatile assets produce more morphological variation, so a slightly lower score threshold (75-80) often works better. More structured instruments like futures perform well at 85-90.
8. Settings guide
8.1 Match engine
Lookback window (bars). How many historical bars to scan for fingerprint matches. Range: 50-1000. Recommended: 500 on 1m-5m charts, 1000 on 15m and above. A larger window finds better matches but takes longer on lower timeframes.
Min match score (0-100). The minimum similarity score required to fire a signal. 70-79 is standard, 80-89 is strong, 90-94 is elite, 95+ is ultra. Start at 85 and adjust from there.
Cooldown between signals (bars). Minimum bars between signals. On a 5m chart, 15 bars equals 75 minutes. On a 1H chart, 15 bars equals 15 hours. Lower values produce more signals. Higher values enforce a minimum spacing between setups.
Dimension 6 — Atr percentile. Adds candle size context relative to recent volatility. Recommended: on.
Dimension 7 — Trend alignment. Adds EMA 21 directional context. Recommended: on.
Dimension 8 — Candle context. Adds inside/outside bar structural context. Recommended: on.
8.2 Outcome filter
Forward outcome (bars). How many bars after the historical match are used to measure the resulting move. Match this to your typical trade duration. On a 5m chart with 6 bars, the engine looks at 30 minutes of forward price action to determine the outcome direction and magnitude.
Min outcome move (ATR x). The historical match only qualifies if the resulting move exceeded this ATR multiple within the forward window. Filters out matches where the historical candle led to no meaningful move. Recommended: 1.0-2.0.
8.3 Visuals
Signal mode. Current bar only shows only the triangle. Match bar only shows only the diamond and vertical line on the historical candle. Both shows both simultaneously.
Show score on marker. When on, the triangle displays the score as text. When off, the triangle is clean. Hover always shows the full details regardless.
Signal bar background. Subtle glow on the signal bar in the tier color.
Vertical signal line. A faint vertical box through the signal bar. Useful for identifying signal bars when zoomed out.
Timezone. Select your local timezone from the dropdown. All match times in the dashboard and tooltips display in this timezone. Default is UTC. Amsterdam = UTC+2, London = UTC+1 (summer) or UTC, New York = UTC-4 (summer), Tokyo = UTC+9.
8.4 Dashboard
Score bar — visual meter 0-100 in tier color.
Tier — standard, ★ elite (90+), or ◈ ultra (95+).
Bias — ▲ bull or ▼ bear, or — wait during cooldown.
Match date — date and time of the historical matched candle in your selected timezone.
Outcome (R) — price move after the match in ATR multiples with forward bar count.
Outcome (%) — same move as a percentage of the historical close price.
Outcome (price) — same move in currency units at the historical price level.
Lookback — current lookback window setting.
Min score — current minimum score setting.
Cooldown — bars remaining until next signal, or ready.
Dimensions — how many dimensions are active and which ones (ATR, EMA, CTX).
ATR (14) — current ATR value.
9. Recommended starting settings
For 1m-5m scalping:
Lookback 500, min score 85, cooldown 15 bars, forward outcome 3 bars, min outcome move 1.0.
For 15m-1H:
Lookback 1000, min score 88, cooldown 8 bars, forward outcome 6 bars, min outcome move 1.5.
For 4H and above:
Lookback 1000, min score 90, cooldown 5 bars, forward outcome 4 bars, min outcome move 2.0.
10. How to use
Load the indicator and set signal mode to both. This gives you the triangle on the current signal bar and the diamond with border box on the historical matched candle simultaneously.
When a signal fires, hover the triangle with your cursor or S-Pen. Read the match date (UTC), score, bias, and outcome values. Then locate the diamond on the chart — the bordered box marks exactly which candle was matched. Look at what followed it on the chart. That is your reference.
The three outcome values give you the same historical move in three different units. Use whichever is most natural for how you think about size. The R value is instrument-independent. The percentage gives quick context. The price value shows the raw historical distance.
Watch the cooldown counter in the dashboard. When it shows ready, the next qualifying signal will fire without restriction. When it shows a bar count, the engine is waiting before it can fire again.
If you see too many signals, raise the min match score or increase the cooldown. If you see too few, lower the min outcome move or reduce the min score.
Candle DNA Morphology works best as a confluence tool. It tells you what the current candle morphology historically preceded. Your other indicators — levels, sessions, volume, trend — confirm whether the context justifies acting on it.
11. Disclaimer
This indicator is provided for educational and informational purposes only. Nothing in this document constitutes financial advice or any form of recommendation. Trading financial instruments involves substantial risk of loss. Past performance is not indicative of future results. You may lose all of your invested capital.
Anonycryptous accepts no responsibility or liability for any losses incurred as a result of using this indicator.
Indicator
NeuraLib Expansion: Advanced Model LayersNeuraLib_Models is the companion model expansion for NeuraLib .
NeuraLib provides the runtime: tensors, graph execution, datasets, scalers, losses, optimizers, training, inference, and validation tools. NeuraLib_Models builds on that foundation with higher-level neural architectures that are difficult and repetitive to write by hand.
The purpose of this expansion is to keep the main NeuraLib runtime clean, compact, and general, while giving researchers ready-to-use model families for sequence learning, attention, temporal pattern extraction, and Reinforcement Learning workflows.
----------------------------------------------------------------------------------------------------------------
🔷 HOW IT FITS INTO NEURALIB
NeuraLib_Models is built entirely on top of the public NeuraLib API. It does not replace the main runtime and it does not introduce a separate training engine.
After importing NeuraLib_Models, its fluent methods become available directly on NeuraLib `Sequential` models. The expansion alias can remain unused in the layer chain.
//@version=6
indicator("NeuraLib Models Quick Start", overlay = false, calc_bars_count = 600)
import Alien_Algorithms/NeuraLib/1 as nl
import Alien_Algorithms/NeuraLib_Models/1 as models
var nl.Sequential model = nl.sequential("advanced_model")
var float qLong = na
var float qFlat = na
var float qShort = na
if barstate.isfirst
model := model
.input(array.from(8), "sequence")
.temporalConvStack(4, 2, 2, 2, 1, 1, nl.ActivationKind.relu, 0.0, "temporal")
.globalAvgPool1d(3, 2, "pool")
.duelingQHead(4, 3, nl.ActivationKind.relu, "dueling_head")
.build(nl.rng(7))
float ret0 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret1 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret2 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret3 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float atrValue = ta.atr(14)
float atr0 = close == 0.0 ? 0.0 : atrValue / close
float atr1 = close == 0.0 ? 0.0 : atrValue / close
float atr2 = close == 0.0 ? 0.0 : atrValue / close
float atr3 = close == 0.0 ? 0.0 : atrValue / close
bool ready = not na(ret3) and not na(atr3)
if ready
nl.Tensor state = nl.vector(array.from(ret3, atr3, ret2, atr2, ret1, atr1, ret0, atr0), "state_window")
nl.Tensor qValues = model.predict(state)
qLong := qValues.get1d(0)
qFlat := qValues.get1d(1)
qShort := qValues.get1d(2)
plot(qLong, "Q long", color = color.lime, linewidth = 2)
plot(qFlat, "Q flat", color = color.gray)
plot(qShort, "Q short", color = color.red, linewidth = 2)
hline(0.0, "Zero", color = color.new(color.gray, 70))
The model is still a normal NeuraLib model. You still call `.compile()`, `.trainOnBatch()`, `.predict()`, `.evaluate()`, `.getWeightsArray()`, and `.softUpdateFrom()` from the main library.
----------------------------------------------------------------------------------------------------------------
🔷 WHY THIS EXPANSION EXISTS
The main NeuraLib library is the foundation. It exposes a graph engine powerful enough to create custom architectures, but repeatedly building LSTM gates, attention projections, residual blocks, Conv1D stacks, or Transformer paths from raw graph operations would be too verbose for everyday research.
NeuraLib_Models packages those patterns into readable blocks:
Temporal models : Conv1D blocks, temporal convolution stacks, global average pooling, and global max pooling for flattened sequence inputs.
Recurrent models : LSTM and GRU blocks for compact sequence memory.
Attention models : Self-attention, multi-head self-attention, cross-attention, Transformer encoder blocks, Transformer encoder stacks, and Transformer decoder blocks.
Residual models : Residual dense blocks for deeper feedforward paths.
Reinforcement Learning heads : Q-head blocks and dueling Q-heads for action-value style outputs.
Replay utilities : Deterministic Prioritized Experience Replay for reproducible Pine research.
Sequence helpers : Positional encoding for token, sequence, and attention workflows.
----------------------------------------------------------------------------------------------------------------
🔷 PRACTICAL EXAMPLES
🔸 Temporal Conv Model With Dueling Q-Head
This pattern is useful when a flattened sequence contains recent market states and the output represents action values.
//@version=6
indicator("NeuraLib Models Temporal Q Example", overlay = false, calc_bars_count = 600)
import Alien_Algorithms/NeuraLib/1 as nl
import Alien_Algorithms/NeuraLib_Models/1 as models
var nl.Sequential qModel = nl.sequential("temporal_q_model")
var nl.WindowDataset qDataset = nl.windowDataset(8, 3, 400, "q_rows")
var float qDown = na
var float qNeutral = na
var float qUp = na
var float qLoss = na
if barstate.isfirst
nl.CompileConfig cfg = nl.compileConfig()
cfg := cfg
.presetQValues()
.optimizer(nl.adamW(0.001))
.withTrainingGate(true)
qModel := qModel
.input(array.from(8), "state_window")
.temporalConvStack(4, 2, 2, 2, 1, 1, nl.ActivationKind.relu, 0.0, "temporal")
.globalAvgPool1d(3, 2, "pool")
.duelingQHead(4, 3, nl.ActivationKind.relu, "dueling_head")
.compile(cfg)
qDataset := qDataset
.setInputScaler(nl.ScalerKind.zScore)
.setTargetScaler(nl.ScalerKind.none)
float ret0 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret1 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret2 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret3 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret4 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float atrValue = ta.atr(14)
float atr0 = close == 0.0 ? 0.0 : atrValue / close
float atr1 = close == 0.0 ? 0.0 : atrValue / close
float atr2 = close == 0.0 ? 0.0 : atrValue / close
float atr3 = close == 0.0 ? 0.0 : atrValue / close
float atr4 = close == 0.0 ? 0.0 : atrValue / close
bool rowReady = not na(ret4) and not na(atr4)
if rowReady
array features = array.from(ret4, atr4, ret3, atr3, ret2, atr2, ret1, atr1)
float downTarget = math.max(-ret0, 0.0)
float neutralTarget = math.max(0.002 - math.abs(ret0), 0.0)
float upTarget = math.max(ret0, 0.0)
qDataset := qDataset.pushRow(features, array.from(downTarget, neutralTarget, upTarget))
if qDataset.ready(48)
if barstate.islastconfirmedhistory
nl.Batch train = qDataset.trainBatch(12)
qModel := qModel.trainOnBatch(train.inputTensor, train.targetTensor)
qLoss := qModel.trainStats.lastLoss
nl.Tensor liveState = nl.vector(array.from(ret3, atr3, ret2, atr2, ret1, atr1, ret0, atr0), "live_state")
nl.Tensor scaledState = qDataset.scaleInput(liveState)
nl.Tensor qValues = qModel.predict(scaledState)
qDown := qValues.get1d(0)
qNeutral := qValues.get1d(1)
qUp := qValues.get1d(2)
plot(qDown, "Q down", color = color.red, linewidth = 2)
plot(qNeutral, "Q neutral", color = color.gray)
plot(qUp, "Q up", color = color.lime, linewidth = 2)
plot(qLoss, "Training loss", color = color.orange)
hline(0.0, "Zero", color = color.new(color.gray, 70))
Input shape `array.from(8)` represents a flattened 4 step by 2 feature sequence. The temporal stack extracts short sequence structure, pooling compresses the sequence, and the dueling head separates value and advantage paths before producing action scores. The example trains only on the last confirmed historical bar so it remains safe to paste onto long charts.
🔸 Transformer Encoder For Token Rows
Attention models are useful when each row is a token or time step, and each column is a feature dimension.
//@version=6
indicator("NeuraLib Models Transformer Encoder Example", overlay = false, calc_bars_count = 600)
import Alien_Algorithms/NeuraLib/1 as nl
import Alien_Algorithms/NeuraLib_Models/1 as models
var nl.Sequential encoder = nl.sequential("encoder_model")
var float tokenSignal = na
var float tokenContext = na
var float tokenVolatility = na
if barstate.isfirst
encoder := encoder
.input(array.from(4), "tokens")
.multiHeadSelfAttention(4, 2, true, "mha")
.transformerEncoder(4, true, 2, nl.ActivationKind.geluApprox, "encoder", 0.05, 2)
.build(nl.rng(11))
float emaValue = ta.ema(close, 21)
float atrValue = ta.atr(14)
float ret0 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret1 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret2 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float ret3 = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float emaGap0 = emaValue == 0.0 ? 0.0 : close / emaValue - 1.0
float emaGap1 = emaValue == 0.0 ? 0.0 : close / emaValue - 1.0
float emaGap2 = emaValue == 0.0 ? 0.0 : close / emaValue - 1.0
float emaGap3 = emaValue == 0.0 ? 0.0 : close / emaValue - 1.0
float atr0 = close == 0.0 ? 0.0 : atrValue / close
float atr1 = close == 0.0 ? 0.0 : atrValue / close
float atr2 = close == 0.0 ? 0.0 : atrValue / close
float atr3 = close == 0.0 ? 0.0 : atrValue / close
bool ready = not na(ret3) and not na(emaGap3) and not na(atr3)
if ready
nl.Tensor tokens = nl.vector(array.from(
ret3, emaGap3, atr3, -1.0,
ret2, emaGap2, atr2, -0.33,
ret1, emaGap1, atr1, 0.33,
ret0, emaGap0, atr0, 1.0), "tokens").reshape(array.from(4, 4))
nl.Tensor encoded = encoder.predict(tokens)
tokenSignal := encoded.get1d(12)
tokenContext := encoded.get1d(13)
tokenVolatility := encoded.get1d(14)
plot(tokenSignal, "Latest token signal", color = color.aqua, linewidth = 2)
plot(tokenContext, "Latest token context", color = color.purple)
plot(tokenVolatility, "Latest token volatility", color = color.orange)
hline(0.0, "Zero", color = color.new(color.gray, 70))
In this example, each input row has 4 features. `headCount` is 2, so the model dimension is split into two attention heads.
Attention rule: `modelDim` must be divisible by `headCount`, and the current implementation supports up to 8 heads.
🔸 Prioritized Experience Replay
Prioritized Experience Replay stores examples with priorities, then returns reproducible weighted samples. This is especially useful for Reinforcement Learning experiments where high-error transitions should be revisited more often.
//@version=6
indicator("NeuraLib Models PER Example", overlay = false, calc_bars_count = 1200)
import Alien_Algorithms/NeuraLib/1 as nl
import Alien_Algorithms/NeuraLib_Models/1 as models
var models.PrioritizedReplayBuffer replay = models.prioritizedReplayBuffer(4, 2, 300, "replay")
var nl.Sequential replayModel = nl.sequential("replay_q_model")
var float replayLoss = na
var float firstImportanceWeight = na
var float replayRows = na
if barstate.isfirst
nl.CompileConfig cfg = nl.compileConfig()
cfg := cfg
.presetQValues()
.optimizer(nl.adamW(0.001))
.trainEveryCall()
replayModel := replayModel
.input(array.from(4), "state")
.dense(8, nl.ActivationKind.relu, "hidden")
.qHead(2, nl.ActivationKind.linear, "q_values")
.compile(cfg)
float rsiValue = ta.rsi(close, 14)
float emaValue = ta.ema(close, 21)
float atrValue = ta.atr(14)
float atrPct = close == 0.0 ? 0.0 : atrValue / close
float momentum = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float nextReturn = na(close ) ? 0.0 : nl.nextReturnValue(close , close)
bool rowReady = not na(rsiValue ) and not na(emaValue ) and not na(atrPct ) and not na(momentum )
if rowReady
float prevEma = emaValue
float priceVsEma = prevEma == 0.0 ? 0.0 : close / prevEma - 1.0
array stateFeatures = array.from(rsiValue / 100.0, priceVsEma, atrPct , momentum )
array targetValues = array.from(math.max(-nextReturn, 0.0), math.max(nextReturn, 0.0))
float priority = math.abs(nextReturn) + 0.0001
replay := replay.pushExperience(stateFeatures, targetValues, priority)
replayRows := float(replay.size())
if replay.ready(32)
models.PrioritizedReplaySample sample = replay.sampleBatch(32, 0.6, 0.4, 17)
replayModel := replayModel.trainOnBatch(sample.batch.inputTensor, sample.batch.targetTensor)
replayLoss := replayModel.trainStats.lastLoss
firstImportanceWeight := sample.weightArray.size() > 0 ? sample.weightArray.get(0) : na
if sample.indexArray.size() > 0
replay := replay.updatePriority(sample.indexArray.get(0), replayLoss + 0.0001)
plot(replayLoss, "Replay training loss", color = color.orange, linewidth = 2)
plot(firstImportanceWeight, "First sample weight", color = color.aqua)
The returned sample includes:
batch : A normal NeuraLib `Batch` containing sampled inputs and targets.
indexArray : Logical replay indices that can be passed back to `updatePriority()`.
weightArray : Normalized importance weights for custom loss weighting or diagnostics.
sampleRows : Number of sampled rows.
PER sampling is deterministic for a given buffer, `batchSize`, and `seed`. That makes Pine tests and live research easier to reproduce.
----------------------------------------------------------------------------------------------------------------
🔷 MODEL FAMILIES
🔸 Residual Dense Blocks
`residualDense()` adds a feedforward residual block. Residual paths help preserve information through deeper models and reduce the chance that a dense stack destroys useful features too early.
🔸 Conv1D And Temporal Convolution Stacks
`conv1d()` and `temporalConvStack()` operate on flattened sequence inputs. A sequence with `timeSteps = 4` and `featureCount = 2` is represented as 8 input features. These blocks are useful for local temporal structure, short rolling windows, feature rhythm, and compact pattern extraction.
🔸 Global Pooling
`globalAvgPool1d()` and `globalMaxPool1d()` compress flattened sequence outputs into feature-level summaries. Average pooling captures broad sequence behavior, while max pooling emphasizes the strongest activation per feature.
🔸 LSTM And GRU Blocks
`lstm()` and `gru()` provide recurrent sequence memory over flattened time-series inputs. They are useful when the order of recent states matters more than a single snapshot.
🔸 Attention And Transformers
`selfAttention()`, `multiHeadSelfAttention()`, `crossAttention()`, `transformerEncoder()`, `transformerEncoderStack()`, and `transformerDecoder()` bring attention-style modeling into Pine. They are designed for compact token matrices, packed target-memory layouts, and small Transformer-style research models that fit PulseWire limits.
🔸 Q-Heads And Dueling Q-Heads
`qHeadBlock()` creates action-value style outputs. `duelingQHead()` splits the model into value and advantage branches, then recombines them into Q-values. This is useful when you want the model to estimate both the overall state value and the relative value of each action.
🔸 Positional Encoding
`pushPositionalEncoding()` adds sinusoidal position features to a NeuraLib `FeatureBuilder`. This helps attention-style models distinguish where a token or time step sits in a sequence.
----------------------------------------------------------------------------------------------------------------
🔷 FEATURE QUICK REFERENCE
Built on NeuraLib : Uses the main NeuraLib graph, tensor, training, optimizer, dataset, and inference runtime.
Fluent API : Adds methods directly to NeuraLib `Sequential` models after import.
Block factories : Provides standalone `GraphBlock` factories for users who want lower-level composition.
Temporal modeling : Conv1D, temporal convolution stacks, and 1D pooling.
Recurrent modeling : LSTM and GRU sequence blocks.
Attention modeling : Self-attention, multi-head self-attention, cross-attention, encoders, encoder stacks, and decoders.
Reinforcement Learning support : Q-heads, dueling Q-heads, target-model soft updates through NeuraLib, and Prioritized Experience Replay.
Reproducible replay : PER sampling is deterministic for a given seed.
Shape guardrails : Advanced builders validate expected model feature counts and attention head compatibility.
----------------------------------------------------------------------------------------------------------------
🔷 IMPORTANT USAGE NOTES
Import order matters : Import `NeuraLib` first, then `NeuraLib_Models`.
The alias can be unused : The imported expansion registers methods on NeuraLib types, so `.lstm()`, `.gru()`, `.transformerEncoder()`, and similar methods can be called in the model chain.
Keep models compact : Pine Script has execution limits. Start with small hidden sizes, short sequences, and low head counts.
Control chart history : Use `calc_bars_count = 600` in `indicator()` when needed to balance available training history against model size and execution time.
Respect sequence shapes : Conv1D, temporal stacks, LSTM, and GRU methods expect flattened sequence sizes of `timeSteps * featureCount`.
Respect attention shapes : Attention methods expect each input row to have `modelDim` columns. Cross-attention and decoder blocks use packed rows.
Use NeuraLib guardrails : Train/validation splits, scalers, EarlyStopper, training gates, and gradient clipping remain part of the main NeuraLib workflow.
----------------------------------------------------------------------------------------------------------------
🔷 API REFERENCE
🔸 Sequential Methods
residualDense(hiddenUnits, activationKind, dropoutRate, name) : Adds a residual dense block.
duelingQHead(hiddenUnits, actionCount, activationKind, name) : Adds a dueling value/advantage Q-head.
conv1d(timeSteps, featureCount, filters, kernelSize, stride, activationKind, name) : Adds a Conv1D block for flattened sequences.
temporalConvStack(timeSteps, featureCount, filters, kernelSize, layers, stride, activationKind, dropoutRate, name) : Adds stacked temporal Conv1D layers.
globalAvgPool1d(timeSteps, featureCount, name) : Adds global average pooling over a flattened 1D sequence.
globalMaxPool1d(timeSteps, featureCount, name) : Adds global max pooling over a flattened 1D sequence.
lstm(timeSteps, featureCount, units, activationKind, name) : Adds an LSTM scan block.
gru(timeSteps, featureCount, units, activationKind, name) : Adds a GRU scan block.
selfAttention(modelDim, causal, name) : Adds row-wise self-attention.
multiHeadSelfAttention(modelDim, headCount, causal, name) : Adds multi-head self-attention.
crossAttention(queryRows, memoryRows, modelDim, headCount, name) : Adds packed query-memory cross-attention.
transformerEncoder(modelDim, causal, ffMultiplier, activationKind, name, dropoutRate, headCount) : Adds one Transformer encoder block.
transformerEncoderStack(modelDim, layers, causal, ffMultiplier, activationKind, dropoutRate, headCount, name) : Adds repeated Transformer encoder blocks.
transformerDecoder(targetRows, memoryRows, modelDim, headCount, ffMultiplier, activationKind, dropoutRate, name) : Adds a packed target-memory Transformer decoder.
🔸 GraphBlock Factories
qHeadBlock(inputFeatures, actionCount, activationKind, name) : Creates a Q-head block.
duelingQHeadBlock(inputFeatures, hiddenUnits, actionCount, activationKind, name) : Creates a dueling Q-head block.
residualDenseBlock(inputFeatures, hiddenUnits, activationKind, dropoutRate, name) : Creates a residual dense block.
conv1dBlock(timeSteps, featureCount, filters, kernelSize, stride, activationKind, name) : Creates a Conv1D block.
temporalConvStackBlock(timeSteps, featureCount, filters, kernelSize, layers, stride, activationKind, dropoutRate, name) : Creates a temporal convolution stack.
globalAvgPool1dBlock(timeSteps, featureCount, name) and globalMaxPool1dBlock(timeSteps, featureCount, name) : Create pooling blocks.
lstmBlock(timeSteps, featureCount, units, activationKind, name) and gruBlock(timeSteps, featureCount, units, activationKind, name) : Create recurrent blocks.
selfAttentionBlock(modelDim, causal, name) , multiHeadSelfAttentionBlock(modelDim, headCount, causal, name) , and crossAttentionBlock(queryRows, memoryRows, modelDim, headCount, name) : Create attention blocks.
transformerEncoderBlock(modelDim, causal, ffMultiplier, activationKind, name, dropoutRate, headCount) and transformerDecoderBlock(targetRows, memoryRows, modelDim, headCount, ffMultiplier, activationKind, dropoutRate, name) : Create Transformer blocks.
🔸 Prioritized Experience Replay
prioritizedReplayBuffer(featureCount, targetCount, maxRows, name) : Creates a replay buffer.
pushExperience(featureRowArray, targetRowArray, priority) : Adds or overwrites one replay row.
sampleBatch(batchSize, alpha, beta, seed) : Returns a deterministic weighted sample.
updatePriority(index, priority) : Updates a sampled row priority.
toBatch() : Returns all replay rows in chronological order.
ready(minRows) , size() , and clear() : Replay buffer utilities.
🔸 Feature Helpers
pushPositionalEncoding(position, dimensions, maxPeriod, featurePrefix) : Appends sinusoidal positional encoding values to a NeuraLib `FeatureBuilder`.
NeuraLib_Models is for Pine Script developers who want higher-level neural architecture blocks without leaving the NeuraLib runtime. It is built for compact research models inside PulseWire's execution limits, not for oversized GPU-style networks.
All the diagrams in this publication are rendered natively on PulseWire using Pine3D
----------------------------------------------------------------------------------------------------------------
This work is licensed under (CC BY-NC-SA 4.0) , meaning usage is free for non-commercial purposes given that Alien_Algorithms is credited in the description for the underlying software. For commercial use licensing, contact Alien_Algorithms
Library
NeuraLib: A Native AI and Deep Learning RuntimeNeuraLib is a tensor-based, auto-differentiating Machine Learning runtime built natively for Pine Script™.
It brings real Deep Learning mechanisms that power modern Artificial Intelligence systems into PulseWire. Instead of relying on fixed formulas, static regressions, or rigid structures, NeuraLib gives Pine developers a different tool: a compact neural runtime that can learn from the features you feed it, using the architecture you define.
This means users are no longer limited to classical methods like Linear Regression, Logistic Regression, KNN, Naive Bayes, Kalman Filters, or Markov Chains. One can build adaptive architectures perfectly suited for custom indicators, strategies, regime detection, directional prediction, price transforms, and AI-assisted signal generation.
Using NeuraLib, one can build a model, collect market data, normalize it, run predictions, train through backpropagation, track validation behavior, and update weights directly inside PulseWire.
Furthermore, it is not necessary to directly display trained variables. The process can be a part of a larger script functionality, where AI-powered decision making changes how an indicator behaves.
The goal is to make real neural network workflows usable in Pine Script without hiding the important controls, being scalable with evolving market dynamics, and abstracting away the complexity that comes with such software. The provided API is highly modular and intuitive, using chained object-oriented programming for easy readability and use. The backend is engineered with fault-tolerance in mind, providing users with sanity checks and preventing common pitfalls by default.
Think of NeuraLib as a comprehensive machine learning ecosystem, containing:
A Model Builder : Define neural networks with readable chained calls like `.input()`, `.dense()`, and `.dropout()`.
An In-Pine Training Engine : Models calculate losses, backpropagate gradients, update weights, and produce predictions directly on chart data.
Automated Data Pipelines : Built-in datasets handle feature collection, robust scaling (Z-Score, Min-Max), validation holdout splits, and time-series rolling windows.
Finance-Native Loss Functions : Beyond standard error metrics, the engine includes Directional, Quantile, Multi-Horizon Weighted, and Sharpe-style losses tailored for trading.
Practical Training Controls : Layer Normalization, AdamW weight decay, gradient clipping, gradient accumulation, and early stopping are built in to prevent overfitting.
Advanced Optimizers : Train networks using RMSProp, Adam, or AdamW, paired with learning rate schedules like Warmup Cosine and Step Decay.
For newer users, this means you can start with a simple dense model. For advanced users, the same runtime exposes graph operations, custom blocks, tensors, matrix operations, optimizers, schedules, losses, and extension hooks.
In plain terms, a model receives a row of numbers called features, compares its output against a target, measures the error with a loss function, and then adjusts its internal weights to reduce that error next time.
----------------------------------------------------------------------------------------------------------------
🔷 WHAT MAKES IT DIFFERENT
🔸 Parity-tested neural math
NeuraLib’s core operations have been tested against established Machine Learning Runtimes outside of PulseWire (Such as Keras / TensorFlow / PyTorch).
The goal was not to imitate the appearance of Machine Learning, but to reproduce the math that is proven to work. Standard forward passes, gradients, losses, and optimizer behavior were checked for 1:1 algorithmic parity, with negligible differences coming from normal floating-point behavior.
That means the matrix math, backpropagation, and gradient updates running on your chart follow the same underlying logic expected from professional Machine Learning environments.
🔸 Matrix-first computation
NeuraLib uses tensor and matrix abstractions as the foundation of the runtime. Under the hood, it supports the operations needed for neural computation, including matrix multiplication, broadcasting, activation functions, softmax, slicing, concatenation, reductions, normalization, attention scoring, convolution-style operations, and recurrent scan blocks.
🔸 Auto-differentiating graph engine
NeuraLib makes the computational graph a first-class object.
You can use high-level Sequential models, or build custom GraphBlocks from lower-level operations. Once a custom block is connected to a model, the same runtime handles the backward pass. That means your custom architecture can be trained with the same `.trainOnBatch()` workflow as standard layers.
----------------------------------------------------------------------------------------------------------------
🔷 CUSTOM GRAPHS
The Sequential API is the easiest way to start, but NeuraLib is not just a list of built-in layers.
You can create a `GraphBlock`, add operations, set an output node, and plug that block into a model. Once connected, the runtime handles the backward pass and parameter updates.
Useful graph operations include:
Matrix multiplication, transpose, add, subtract, multiply, divide, and scale.
Activation functions and softmax.
Layer Normalization and Dropout.
Causal masking, slicing, concatenation, row reduction, and column reduction.
Global average pooling and global max pooling for 1D sequences.
Attention score and attention apply operations.
Conv1D, LSTM scan, and GRU scan primitives.
This is the foundation that allows companion model libraries to add advanced AI and Machine Learning architectures without changing the main NeuraLib runtime.
----------------------------------------------------------------------------------------------------------------
🔷 BUILT-IN DATA GUARDRAILS
NeuraLib is not only a training mechanism. It also includes guardrails for cleaner research:
Invalid rows are rejected : Dataset rows must match the configured feature and target counts, and rows containing `na` values are not inserted.
Shape checks protect model calls : Forward, training, backward, and evaluation paths validate input and target shapes before running expensive graph code.
Train and validation splits are separated : `trainBatch()` and `validationBatch()` use holdout rows instead of blending all rows into one batch.
Scaler leakage is controlled : Validation batches are scaled from the training-side profile where the dataset split requires it, so validation normalization does not learn from the holdout slice.
Rolling windows respect time order : `RollingDataset` supports target offsets and wrapped ring buffers while preserving chronological reads.
These checks help reduce common data poisoning and data leakage mistakes: wrong row widths, missing values, validation contamination, target-offset leakage, and accidental overtraining across every historical bar.
----------------------------------------------------------------------------------------------------------------
🔷 A FIRST MODEL
The basic API is intentionally readable. This creates a small model with dropout, one hidden layer, Huber loss, AdamW optimization, and MAE tracking.
//@version=6
indicator("NeuraLib Basic Model", overlay = false, calc_bars_count = 600)
import Alien_Algorithms/NeuraLib/1 as nl
var nl.Sequential model = nl.sequential("basic_model")
var float modelOutput = na
if barstate.isfirst
nl.CompileConfig cfg = nl.compileConfig()
cfg := cfg
.optimizer(nl.adamW(0.001))
.loss(nl.LossKind.huber)
.metric(nl.MetricKind.mae)
.withTrainingGate(true)
model := model
.input(array.from(4), "features")
.dropout(0.15)
.dense(8, nl.ActivationKind.relu, "hidden")
.dense(1, nl.ActivationKind.linear, "output")
.compile(cfg)
float rsiValue = ta.rsi(close, 14)
float emaValue = ta.ema(close, 21)
float atrValue = ta.atr(14)
float atrPct = close == 0.0 ? 0.0 : atrValue / close
float momentum = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
bool ready = not na(rsiValue) and not na(emaValue) and not na(atrPct) and not na(momentum)
if ready
float priceVsEma = emaValue == 0.0 ? 0.0 : close / emaValue - 1.0
nl.Tensor inputTensor = nl.vector(array.from(rsiValue, priceVsEma, atrPct, momentum), "features")
nl.Tensor outputTensor = model.predict(inputTensor)
modelOutput := outputTensor.get1d(0)
plot(modelOutput, "Untrained model output", color = color.aqua, linewidth = 2)
hline(0.0, "Zero", color = color.new(color.gray, 70))
The same model can then receive scaled batches from a dataset and train with `.trainOnBatch()`. The plot in this first example is the untrained forward output, included so the block can be pasted directly into an indicator.
----------------------------------------------------------------------------------------------------------------
🔷 A PRACTICAL DATA FLOW
Machine Learning models usually fail when the data pipeline is careless. Price, volume, volatility, and oscillators often live on very different scales. NeuraLib includes dataset and scaling helpers so the common workflow stays explicit:
Build a feature row.
Build a target row.
Push the row into a dataset.
Request a training batch.
Request a validation batch when needed.
Train, evaluate, predict, and inverse-scale targets when appropriate.
//@version=6
indicator("NeuraLib Return Validation Example", overlay = false, calc_bars_count = 600)
import Alien_Algorithms/NeuraLib/1 as nl
var nl.Sequential model = nl.sequential("returns_model")
var nl.WindowDataset dataset = nl.windowDataset(4, 1, 500, "returns_dataset")
var float predictedReturn = na
var float validationLossValue = na
var float trainingLossValue = na
if barstate.isfirst
nl.CompileConfig cfg = nl.compileConfig()
cfg := cfg
.optimizer(nl.adamW(0.003))
.loss(nl.LossKind.huber)
.metric(nl.MetricKind.mae)
.trainEveryCall()
model := model
.input(array.from(4), "features")
.dense(8, nl.ActivationKind.relu, "hidden")
.dropout(0.10, "dropout")
.dense(1, nl.ActivationKind.linear, "next_return")
.compile(cfg)
dataset := dataset
.setInputScaler(nl.ScalerKind.zScore)
.setTargetScaler(nl.ScalerKind.zScore)
float rsiValue = ta.rsi(close, 14)
float emaValue = ta.ema(close, 21)
float atrValue = ta.atr(14)
float atrPct = close == 0.0 ? 0.0 : atrValue / close
float momentum = na(close ) or close == 0.0 ? 0.0 : close / close - 1.0
float realizedReturn = na(close ) ? na : nl.nextReturnValue(close , close)
bool rowReady = not na(rsiValue ) and not na(emaValue ) and not na(atrPct ) and not na(momentum ) and not na(close )
if rowReady
float prevEma = emaValue
float priceVsEma = prevEma == 0.0 ? 0.0 : close / prevEma - 1.0
array features = array.from(
rsiValue ,
priceVsEma,
atrPct ,
momentum )
array target = array.from(nl.nextReturnValue(close , close))
dataset := dataset.pushRow(features, target)
if dataset.ready(64)
nl.Batch train = dataset.trainBatch(16)
nl.Batch validation = dataset.validationBatch(16)
model := model.trainOnBatch(train.inputTensor, train.targetTensor)
trainingLossValue := model.trainStats.lastLoss
nl.LossResult validationLoss = model.evaluate(validation.inputTensor, validation.targetTensor)
validationLossValue := validationLoss.value
bool liveReady = not na(rsiValue) and not na(emaValue) and not na(atrPct) and not na(momentum)
if liveReady
float livePriceVsEma = emaValue == 0.0 ? 0.0 : close / emaValue - 1.0
array liveFeatures = array.from(rsiValue, livePriceVsEma, atrPct, momentum)
nl.Tensor liveInput = nl.vector(liveFeatures, "live_features")
nl.Tensor scaledInput = dataset.scaleInput(liveInput)
nl.Tensor scaledPrediction = model.predict(scaledInput)
nl.Tensor rawPrediction = dataset.inverseScaleTarget(scaledPrediction)
predictedReturn := rawPrediction.get1d(0)
plot(realizedReturn, "Last realized return", color = color.gray)
plot(predictedReturn, "Predicted next return", color = color.aqua, linewidth = 2)
plot(validationLossValue, "Validation loss", color = color.orange)
plot(trainingLossValue, "Training loss", color = color.new(color.blue, 35))
hline(0.0, "Zero", color = color.new(color.gray, 70))
This example trains from completed historical pairs. The feature row comes from the previous bar, and the target is the return from that previous bar to the current bar. That keeps the example easy to inspect and avoids using future information in the feature row. When pasted into an indicator, it plots the last realized return, the model's predicted next return, training loss, and validation loss.
----------------------------------------------------------------------------------------------------------------
🔷 TWO PRACTICAL EXECUTION MODES
Deep Learning in Pine requires careful execution control. NeuraLib supports two main workflows.
🔸 1. Live-edge training
Use this when you want safer execution for larger models.
The dataset can collect rows across the chart, while the expensive training step only runs on the last confirmed historical bar. This helps avoid timeouts while still allowing the model to learn from recent prepared data.
cfg := cfg.withTrainingGate(true)
Use this for:
Larger models
More features
Rolling sequence inputs
Heavier architectures
Safer live-edge updates
🔸 2. Full-history training and inference
Use this when the model is intentionally small.
The model can train and infer across historical bars, which makes it possible to create lightweight adaptive indicators, such as an AI Moving Average that learns from recent local structure instead of using a fixed smoothing formula.
cfg := cfg.trainEveryCall()
Use this for:
Tiny dense models
Small batches
Fast adaptive filters
AI-assisted moving averages
Lightweight feature transforms
For full-history workflows, start small. A shallow model with 4 to 8 hidden units and a batch size of 8 or 16 is usually a better starting point than a deep architecture.
----------------------------------------------------------------------------------------------------------------
🔷 ADVANCED MODEL EXPANSION
NeuraLib is designed to act as the foundation for larger model libraries and community-built extensions.
To demonstrate this, NeuraLib Expansion: Advanced Model Layers is built entirely on top of the public NeuraLib API and is launched in parallel on day one. The expansion library is published as NeuraLib_Models . It extends the runtime with higher-level builders for LSTMs, GRUs, temporal convolution stacks, residual dense blocks, dueling Q-heads for Reinforcement Learning, Transformer-style attention blocks, and Prioritized Experience Replay utilities.
The important part is architectural: advanced models plug into the same runtime. NeuraLib remains the foundation for tensors, graph execution, optimization, training, inference, datasets, and scaling. After importing `NeuraLib_Models`, its fluent methods become available on NeuraLib `Sequential` models, so the expansion alias does not need to be referenced directly in the layer chain.
//@version=6
indicator("NeuraLib Models Extension Demo", overlay = false, calc_bars_count = 600)
import Alien_Algorithms/NeuraLib/1 as nl
import Alien_Algorithms/NeuraLib_Models/1 as models
var nl.Sequential model = nl.sequential("advanced_demo")
if barstate.isfirst
model := model
.input(array.from(8), "sequence")
.temporalConvStack(4, 2, 3, 2, 2, 1, nl.ActivationKind.relu, 0.0, "temporal")
.globalAvgPool1d(2, 3, "pool")
.duelingQHead(4, 2, nl.ActivationKind.relu, "q_head")
.build(nl.rng(7))
----------------------------------------------------------------------------------------------------------------
🔷 FEATURE QUICK REFERENCE
Runtime : Matrix-first auto-differentiating neural graph runtime for Pine Script.
Model API : Chainable `Sequential` builder with `input`, `dense`, `dropout`, `layerNorm`, `activation`, `flatten`, `reshape`, and custom `block` support.
Training : Forward pass, loss calculation, backpropagation, gradient accumulation, optimizer steps, train stats, and history buffers.
Inference : `.predict()` for deterministic inference and `.predictMC()` for dropout-based uncertainty sampling.
Datasets : `WindowDataset` for flat rows and `RollingDataset` for time-series windows.
Scaling : None, Z-Score, Min-Max, Running Z-Score scalers, dataset input scaling, target scaling, and inverse target scaling.
Optimizers : SGD, Momentum, RMSProp, Adam, and AdamW.
Schedulers : Constant, Step Decay, Cosine Decay, and Warmup Cosine.
Activations : Linear, ReLU, Leaky ReLU, ELU, GELU Approx, Sigmoid, Tanh, Softplus, Swish, and Softmax.
Losses : MSE, MAE, Huber, LogCosh, Binary Cross Entropy, Binary Cross Entropy From Logits, Categorical Cross Entropy, Softmax Cross Entropy From Logits, Directional, Quantile, Multi-Horizon Weighted, and Sharpe.
Metrics : MAE, RMSE, Directional Accuracy, Binary Accuracy, Binary Accuracy From Logits, Categorical Accuracy, and Cosine Similarity.
Guardrails : Shape validation, invalid-row rejection, train/validation split helpers, leakage-aware scaler profiles, training gates, gradient clipping, and EarlyStopper.
Advanced expansion : Conv1D, temporal stacks, recurrent blocks, attention, Transformers, dueling Q-heads, positional encodings, and Prioritized Experience Replay.
----------------------------------------------------------------------------------------------------------------
🔷 IMPORTANT CONSIDERATIONS
Start small : Pine Script is not a GPU training environment. Compact models are the right starting point.
Control chart history : Use `calc_bars_count = 600` in `indicator()` when needed to balance available training history against model size and execution time.
Use the training gate : For heavier models, use `.withTrainingGate(true)` so backpropagation runs only at the confirmed historical edge.
Scale your inputs : Raw market features often differ by orders of magnitude. Use dataset scalers unless you have a deliberate reason not to.
Validate separately : Use `trainBatch()` and `validationBatch()` to monitor generalization instead of only watching training loss.
Avoid lookahead : Build feature rows only from information available at the time of the row. Use completed target rows for training.
Treat outputs as research signals : NeuraLib provides model mechanics. Strategy design, risk management, and market assumptions remain the user's responsibility.
----------------------------------------------------------------------------------------------------------------
🔷 API REFERENCE
🔸 Model Setup
sequential(name) : Creates an empty `Sequential` model.
compileConfig() : Creates a model configuration object.
build(rng) : Builds model parameters with a deterministic random stream.
compile(config) : Builds the model when needed and applies the training configuration.
rng(seed, streamId) : Creates a deterministic random stream.
🔸 Sequential Methods
input(dimsArray, name) : Defines the input shape.
dense(units, activation, name) : Adds a fully connected layer.
qHead(actionCount, activation, name) : Adds a Q-value output head.
activation(activationKind, alpha, name) : Adds an activation block.
dropout(rate, name) : Adds dropout regularization.
layerNorm(name) : Adds layer normalization.
flatten(name) and reshape(outputDimsArray, name) : Adjust model shape metadata.
block(graphBlock) : Adds a custom `GraphBlock`.
trainOnBatch(inputTensor, targetTensor) : Runs training when the active gate allows it.
backward(targetTensor) : Accumulates gradients from the last forward pass without stepping.
step() : Applies the optimizer step to accumulated gradients.
predict(inputTensor) : Runs inference.
predictMC(inputTensor, samples) : Runs dropout-enabled Monte Carlo prediction and returns mean and variance.
evaluate(inputTensor, targetTensor) : Calculates loss without updating weights.
fitDataset(dataset) and fitRollingDataset(dataset, targetOffset) : Train through dataset adapters.
getWeightsArray() and setWeightsArray(weightsArray) : Export and import flat model weights.
softUpdateFrom(sourceModel, tau) : Soft-update parameters from another model.
🔸 CompileConfig Methods
optimizer(optimizerState) : Sets the optimizer.
schedule(scheduleState) : Sets the learning-rate schedule.
loss(lossKind) : Sets the training loss.
reduction(reductionKind) : Sets loss reduction behavior.
metric(metricKind) : Adds a metric.
batchSize(size) , epochsPerBar(count) , evalStride(stride) , and historyLength(length) : Store batch and cadence preferences, and set the metric history length.
clipNorm(value) and clipValue(value) : Apply gradient clipping.
gradAccumSteps(steps) : Accumulates gradients before stepping.
withTrainingGate(enabled) : Restricts training to the last confirmed historical bar when enabled.
trainEveryCall() : Allows training whenever `.trainOnBatch()` is called.
presetPriceRegression() , presetReturnRegression() , presetBinaryDirection() , presetBinaryDirectionLogits() , presetQValues() , and presetSharpe() : Apply common loss and metric presets.
🔸 Datasets
windowDataset(featureCount, targetCount, maxRows, name) : Stores flat feature and target rows.
rollingDataset(timeSteps, featureCount, targetCount, maxRows, name) : Stores time-series windows.
pushRow(featureArray, targetArray) : Adds one validated row.
pushBuilderRow(featureBuilder, targetArray) : Adds a row from a `FeatureBuilder`.
pushNextReturnRow(featureBuilder, currentValue, futureValue) : Adds a next-return target.
pushNextDirectionRow(featureBuilder, currentValue, futureValue, threshold, zeroOne) : Adds a direction target.
ready(minRows or minWindows, targetOffset) and size() : Check dataset readiness.
lastBatch(batchSize) : Returns the most recent scaled rows from a `WindowDataset`.
toBatch() : Returns all rows from a `WindowDataset`.
unrollBatch(targetOffset) : Returns all rolling windows from a `RollingDataset`.
trainBatch(validationRows or validationWindows, targetOffset) : Returns the training side of the split.
validationBatch(validationRows or validationWindows, targetOffset) : Returns the validation side of the split.
setInputScaler(kind) , setTargetScaler(kind) , scaleInput(tensor) , scaleTarget(tensor) , and inverseScaleTarget(tensor) : Configure and apply scaling.
clear() : Clears stored rows.
🔸 Tensor, Matrix, and Feature Helpers
scalar(value) , vector(valuesArray) , matrix2d(rows, cols, fillValue) , zeros(shape) , ones(shape) , and full(shape, fillValue) : Create tensors.
shapeFromDims(dimsArray) : Creates a shape.
matrixTensor(tensor) , matrixTensor2d(rows, cols, fillValue) , and matrixTensorFromMatrix(sourceMatrix) : Create matrix tensors.
reshape(dimsArray) , flatten() , row(rowIndex) , get1d(index) , sum() , mean() , variance() , normL2() , argmax() , and dot(other) : Tensor methods.
matmul() , transpose() , add() , subtract() , multiply() , divide() , scale() , activate() , softmax() , sliceRows() , sliceCols() , concatRows() , concatCols() , globalAvgPool1d() , and globalMaxPool1d() : MatrixTensor methods.
featureBuilder(name) , push(value, featureName) , addFeature(value, featureName) , toTensor(tensorName) , toArray() , size() , and clear() : Feature row helpers.
🔸 Scalers, Optimizers, and Schedules
zScoreScaler() , minMaxScaler() , runningZScoreScaler() , and noneScaler() : Standalone scaler states.
fit(tensor) , partialFit(tensor) , transform(tensor) , and inverseTransform(tensor) : Scaler methods.
sgd(learningRate) , momentum(learningRate, momentum) , rmsprop(learningRate, rho, epsilon) , adam(learningRate, beta1, beta2, epsilon) , and adamW(learningRate, beta1, beta2, epsilon, weightDecay) : Optimizers.
constantSchedule(learningRate) , stepDecay(baseLearningRate, decaySteps, gamma) , cosineDecay(baseLearningRate, minLearningRate, decaySteps) , and warmupCosine(baseLearningRate, minLearningRate, warmupSteps, decaySteps) : Schedules.
currentRate(stepCount) : Reads a schedule's learning rate at a step.
paramBank() , append() , zeroGrad() , globalGradNorm() , step(optimizerState) , and softUpdateFrom(sourceBank, tau) : Low-level parameter bank utilities.
🔸 Losses and Metrics
mse() , mae() , huber() , logCosh() , binaryCrossEntropy() , binaryCrossEntropyFromLogits() , categoricalCrossEntropy() , softmaxCrossEntropyFromLogits() , directionalLoss() , quantileLoss() , multiHorizonWeighted() , and sharpeLoss() : Direct loss helpers.
metricValue(metricKind, predictionTensor, targetTensor) : Direct metric helper.
earlyStopper(patience, minDelta) , update(validationLoss) , and reset() : Validation stopping helper.
nextReturnValue(currentValue, futureValue) and nextDirectionValue(currentValue, futureValue, threshold, zeroOne) : Common target helpers.
🔸 GraphBlock Operations
graphBlock(name) : Creates a custom trainable graph block.
input() , param() , constScalar() , constMatrix() , and output() : Define graph inputs, parameters, constants, and output metadata.
matmul() , add() , subtract() , multiply() , divide() , scale() , activate() , softmax() , transpose() , layerNorm() , and dropout() : NeuraLib graph math.
causalMask() , sliceRows() , concatRows() , sliceCols() , concatCols() , reduceRows() , and reduceCols() : Structural graph operations.
globalAvgPool1d() , globalMaxPool1d() , attentionScore() , attentionApply() , conv1d() , scanLstm() , and scanGru() : Sequence and architecture primitives.
🔸 NeuraLib_Models API
prioritizedReplayBuffer(featureCount, targetCount, maxRows, name) : Creates a replay buffer.
pushExperience(featureRowArray, targetRowArray, priority) , sampleBatch(batchSize, alpha, beta, seed) , updatePriority(index, priority) , toBatch() , ready(minRows) , size() , and clear() : Prioritized Experience Replay helpers.
pushPositionalEncoding(position, dimensions, maxPeriod, featurePrefix) : Adds positional encoding values to a `FeatureBuilder`.
residualDense() , duelingQHead() , conv1d() , temporalConvStack() , globalAvgPool1d() , globalMaxPool1d() , lstm() , gru() , selfAttention() , multiHeadSelfAttention() , crossAttention() , transformerEncoder() , transformerEncoderStack() , and transformerDecoder() : NeuraLib_Models `Sequential` methods.
NeuraLib is for Pine Script developers who want to move beyond fixed formulas and experiment with real neural network workflows directly inside PulseWire. It is a research framework, not a guarantee of market performance. Use validation, avoid lookahead, control risk, and keep models small enough for Pine's execution limits.
All the diagrams in this publication are rendered natively on PulseWire using Pine3D
----------------------------------------------------------------------------------------------------------------
This work is licensed under (CC BY-NC-SA 4.0) , meaning usage is free for non-commercial purposes given that Alien_Algorithms is credited in the description for the underlying software. For commercial use licensing, contact Alien_Algorithms
Library
Machine Learning: seMLP Q-Wavelet RL Engine [Jamallo]Author Note: I always get asked: "How can I build a Machine Learning or Artificial Intelligence trading system?" I created the study "Machine Learning: seMLP Q-Wavelet RL Engine" to showcase exactly how it can be done in a beginner-friendly manner. We will break down exactly how this AI thinks in plain English, and then show you exactly how the Pine Script code executes it step-by-step.
Introduction: The Institutional Approach to Algorithmic Trading
Most retail and algorithmic traders spend years searching for the "holy grail" by combining static indicators and hard-coded `IF/THEN` rule sets. They are often unaware that institutional quant desks abandoned those basic, curve-fitted patterns decades ago. Standard algorithmic analysis fails because financial markets are inherently chaotic—a hardcoded strategy that works perfectly in a backtest will systematically break down during a live regime shift.
To acquire a true institutional edge, algorithmic strategies cannot rely on rigid, backwards-looking formulas; they require a system that adapts dynamically in real-time. This script brings that quantitative firepower directly to your chart by constructing a live Self-Teaching AI .
Dynamic Filtering : It uses advanced frequency mathematics (Wavelets) to separate random market noise from true institutional momentum footprints with near-zero lag.
Artificial Brain : It feeds that data into a neural network—a living matrix of artificial "neurons" that continuously analyze and execute decisions.
Self-Correction : Most importantly, it executes Reinforcement Learning. If a trade fails, the AI actively calculates the error and mathematically rewires its own brain, ensuring it constantly evolves to survive changing market conditions.
Ultimately, this serves as a foundational study showing you exactly how to break away from basic scripting and get started in true Quantitative Algorithmic Trading.
1. The Core Architecture Loop
Here is the high-level flow of how the AI thinks on every single candle:
The Invisible "Burn-In" Phase
Because the AI starts with a completely randomized, "empty" brain, it will make terrible decisions on the very first few candles. To prevent it from acting prematurely on live data, the script executes an aggressive Burn-In Phase (e.g., the first 300 bars of the chart). During this period, the indicator is completely invisible. It aggressively executes hundreds of "mock trades" in the background, tracking virtual PnL, taking massive risks, and rapidly rewiring its brain without showing a single signal on your screen. Once the 300 bars are up, the burn-in phase ends. The AI stops acting recklessly and officially enters "Live Trading" mode with a fully trained, highly-intelligent brain.
SECTIONS 2 & 3: Setting Up the Brain
Conceptual Overview
Imagine the brain as a massive team of financial analysts.
We have 16 junior analysts looking at chart data.
They report their findings up to 12 senior analysts.
The seniors report to 6 directors.
The 6 directors send their final opinions to 3 executives representing the 3 possible actions: `BUY, SELL, HOLD`. This is called a 16 → 12 → 6 → 3 network structure.
Before we hand the price data to the junior analysts, we Normalize it (Z-Score). This just means "leveling the playing field" so a massive $500 candle wick doesn't break the analysts' math compared to a tiny $1 movement.
The Code Breakdown
// Section 2: Brain Size Constants
int NI = 16 // 16 Inputs (Junior analysts)
int NH1 = 12 // 12 Hidden layer 1 nodes
int NH2 = 6 // 6 Hidden layer 2 nodes
int NO = 3 // 3 Outputs
// Section 3: Normalization Helper
norm(series float x, simple int win) =>
float mu = ta.sma(x, win)
float sg = ta.stdev(x, win)
float sf = nz(sg) < 1e-10 ? 1.0 : sg
float res = (x - nz(mu, x)) / sf // Levels out the price data
na(res) ? 0.0 : res
SECTIONS 4 & 5: Giving the AI "Memory"
Conceptual Overview
By default, PulseWire indicators suffer from permanent amnesia! Every time a new candle paints, PulseWire completely deletes its short-term memory and forgets what happened on the last candle. If we are building an AI for trading that needs to "learn", it must be able to remember its past mathematical mistakes.
To force PulseWire to remember, we use special variables called `var` to create "Persistent Memory Matrices" where the AI for trading stores its brain's wiring throughout the entire chart history.
The Code Breakdown
// Using 'var' locks the memory so it never resets when a new candle paints
var matrix W1 = matrix.new(NI, NH1, 0.0) // The connections between neurons
var matrix W2 = matrix.new(NH1, NH2, 0.0)
...
var int pos = 0 // The AI remembers its current position: Long (1), Short (-1), or Flat (0)
SECTION 6: Seeing the Market (Wavelets)
Conceptual Overview
If you use a Moving Average, it always "lags" behind the real price. By the time the Moving Average crosses to tell you to buy, the massive breakout has already happened.
To fix this, we teach the AI for trading to see using Haar Wavelets . A Wavelet is a piece of advanced math that splits the price candle with minimal lag into two things:
The Detail (D) : The immediate, rapid volatility chop.
The Smooth (V) : The true underlying smooth momentum. By looking at the detail and momentum completely separately, the AI for trading can react to shifts with minimal lag.
The Code Breakdown
// We take standard features like Open, Close, and Volume:
float f0 = open
float f1 = close...
// We break them into Wavelets using simple math combinations:
float v1_0 = (f0 + nz(f0 , f0)) / 2.0 // Smooth momentum
float d1_0 = (f0 - nz(f0 , f0)) / 2.0 // Instant volatility detail
...
// We pack all 16 traits into the 'feat' array to feed the AI for trading's Brain
feat.set(0, norm(d1_0, i_normWin))
feat.set(14, float(pos)) // Tells the brain its current trade position
feat.set(15, norm(portRet, i_normWin)) // Tells the brain its current open trade return
SECTION 7: How the Brain Thinks (seMLP)
Conceptual Overview
An "MLP" is just a standard Neural Network (a massive web of variables that pass data to each other). The problem is that if you give PulseWire an insanely massive web of math equations, it will crash and throw a compiler timeout error.
So, we use a Self-evolving MLP (seMLP) . The AI pushes the Wavelet data through its network dynamically. To prevent "dead zones" where a neuron just stops firing in a flat market, it uses a formula called LeakyReLU . It basically acts as a gatekeeper that tells the neuron: "If this signal is incredibly weak, shrink it down to 1%, but don't explicitly delete it."
The Code Breakdown
// The data enters Hidden Layer 1 (h1)
array h1 = array.new(NH1, 0.0)
for j = 0 to NH1 - 1
float s = B1.get(j)
// The inner brain loops through all 16 incoming inputs
for i = 0 to NI - 1
s += feat.get(i) * W1.get(i, j)
// LeakyReLU Formula: f(x) = x if x > 0 else 0.01 * x
// If the signal 's' is positive, keep it. If 's' is negative, shrink to 1%
h1.set(j, s > 0 ? s : 0.01 * s)
SECTION 8: Taking Action (Exploration vs Exploitation)
Conceptual Overview
How does the AI actually press the BUY or SELL button? It calculates a "Confidence Score" (called a Q-Value) for all three options— Buy, Sell, and Hold. The highest score wins and executes the trade.
However, during its invisible "Burn-In Period", the AI uses a variable called Epsilon . Think of Epsilon as a dice roll. Sometimes, instead of making the smartest, highest-scoring choice, the AI will randomly pick a completely stupid trade just to "experiment" and see if a hidden market pattern exists! This is conceptually how AI for trading discovers new, out-of-the-box strategies. As training goes on, Epsilon gets smaller, and the AI stops experimenting.
The Code Breakdown
// Calculate Epsilon: Start at a high 50% and slowly decay to 5% over time
float epsilon = bar_index <= i_burnIn ? math.max(0.05, i_epsStart_val * ...)
// Roll the dice. If the random number is less than epsilon, we experiment randomly!
bool explore = math.random(0.0, 1.0) < epsilon
// Find the AI for trading's highest confidence choice: Q(0) = Buy, Q(1) = Sell, Q(2) = Hold
if Q.get(1) > bestQ // If Sell confidence is higher than current best (Buy)...
bestQ := Q.get(1)
bestAct := 1
if Q.get(2) > bestQ // If Hold is even higher...
bestQ := Q.get(2)
bestAct := 2
// Execute the final action
int act = explore ? math.min(int(math.floor(math.random(0.0, 2.999))), 2) : qArg
SECTION 9: Training with Rewards (Reinforcement Learning)
Conceptual Overview
This is the heart of Machine Learning. It functions exactly like training a pet. If the AI makes a winning trade that generates cash, we give it a mathematical "treat" (a positive reward). If the AI loses money, we hit it with a brutal negative reward. Over time, the AI autonomously refines its neural weights exclusively to collect the maximum amount of "treats".
The Code Breakdown
// Calculate how much money the candle moved
float cRet = nz((close - close ) / close , 0.0)
// The Reward (R) is a combination of three factors:
// 1. PnL (rPn) - Did we make raw cash profit?
// 2. Trail (rTn) - Did we efficiently track the trend?
// 3. Lee (rLee) - A shaping bonus for correct directional positioning.
float R = i_alphaT * rTn + i_alphaP * rPn + 0.1 * rLee
SECTION 10: Learning from Mistakes (Backpropagation)
Conceptual Overview
If the AI's trade failed, how does it adjust its internal logic? It uses a process called Backpropagation . It looks at the Reward it just received, realizes it was horribly wrong, and calculates the "Error Margin" (How far off my prediction was I?). It then mathematically rewrites all of the internal connections `(W1, W2, W3)` in reverse, editing them to be slightly smarter for the next candle!
Because updating a massive brain on every single micro-tick causes chaotic glitches, we "Accumulate" the errors in a batch over several candles, and then update the brain smoothly with the batch average.
The Code Breakdown
// Compare the Target Reward vs what the Brain actually Predicted (Temporal Difference Error)
float tgt = R + i_gamma * max_qt
float td = tgt - pOut.get(prevAct)
// Accumulate the backwards gradients over multiple bars so we don't glitch
for j = 0 to NO - 1
gB3_acc.set(j, gB3_acc.get(j) + g3.get(j))
accumCount += 1
// Once 'i_accumSteps' bars have passed, we apply the compiled batch update to 'Rewire' the Brain weights!
if accumCount >= i_accumSteps
for i = 0 to NH2 - 1
for j = 0 to NO - 1
float dw = gW3_acc.get(i, j) * sc
W3.set(i, j, W3.get(i, j) + clr * dw - clr * i_l2 * W3.get(i, j))
SECTION 11: Link Pruning (Making the Brain Faster)
Conceptual Overview
Stage 1: The Initial Brain (Complex & Slow)
Stage 2: The Pruning Decision
Stage 3: The Optimized AI for trading (Sleek & Fast)
As the brain learns, some of the mathematical connections become totally useless. Having a giant Tradingview indicator calculate hundreds of useless math connections will trigger a calculation timeout. At a specific point in training length (defaulting to the end of the 300-bar burn-in period), the script literally pauses and deletes (zeroes out) the weakest neural links. PulseWire skips over calculations containing plain zeroes, making your indicator insanely fast and completely lag-proof.
The Code Breakdown
if bar_index == i_pruneBar and not pruned
// Evaluate every single connection weight...
// Find the bottom weakest percentage (i_prunePct)
float thr = absW.get(pidx)
// Explicitly set the weakest weights to Zero!
for i = 0 to NI - 1
for j = 0 to NH1 - 1
if math.abs(W1.get(i, j)) <= thr
W1.set(i, j, 0.0) // Permanent pruning: weak link removed
Important Disclaimer
This indicator is published strictly for educational and research purposes. It is a conceptual showcase proving that advanced Deep Reinforcement Learning architectures generally reserved for Python/TensorFlow can be natively executed within the PulseWire Pine Script environment. Due to Pine Script's structural time-series limitations—specifically the lack of a random-access historical buffer required for true experience replay—this is NOT intended for practical live trading. For production-grade deployment, it is highly recommended to port this mathematical framework to Python.
References
This indicator's mathematical engine was directly modeled and bridged from the following quantitative research papers:
Lee et al. (2021) — " Learning to trade in financial time series using high-frequency through wavelet transformation and deep reinforcement learning " (Used for the MODWT Wavelet integration & State architecture).
Tsantekidis et al. (2021) — " Price Trailing for Financial Trading using Deep Reinforcement Learning " (Used for the dynamic margin-trailing reward system).
Seow et al. (2021) — " seMLP: Self-evolving Multi-layer Perceptron " (Used for the 16 → 12 → 6 → 3 sparse Neural Network structure and the automatic Link Pruning logic).
Indicator
Reversal Probability & SignalsThis indicator is designed to forecast critical market turning points by predicting the formation of TOPs (Pivot Highs) and BOTTOMs (Pivot Lows).
To achieve this, the script utilizes a simplified K-Nearest Neighbors (KNN) machine learning algorithm built directly within Pine Script. By analyzing a wide spectrum of Commodity Channel Index (CCI) values, it calculates the real-time probability that the current price action will result in a structural Pivot reversal.
How It Works (The Engine)
The script functions as a real-time pattern recognition engine. It operates in three main steps:
Feature Extraction: It concurrently calculates 8 different lengths of the CCI (from very short to long-term periods like 10 to 200). This acts as the feature set of the current market momentum.
Data Collection (Training): Whenever the market makes a significant structural Top or Bottom (based on Pivot points), the script records the specific state of those 8 CCIs at that exact moment. It also collects random "non-target" samples to build a balanced historical database.
KNN Classification (Prediction): On every new bar, the algorithm calculates the mathematical Euclidean distance between the current 8 CCI values and the historically saved samples. It looks at the "K" nearest historical neighbors. If the majority of those closest historical neighbors were market bottoms, the indicator outputs a high "Bottom Probability."
Key Features
Dynamic K-Value Adjustment: To ensure stable and accurate calculations even shortly after applying the indicator (when the historical sample pool is still growing), the "K" value dynamically scales down based on the available data size and automatically adjusts to odd numbers to prevent tie-breaking ambiguity.
Two-Step Smart Signal Logic: To prevent premature entries during strong, ongoing trends, this script uses a dual-threshold confirmation system:
Standby: The probability must first surge above an Upper Threshold (Default: 80%), indicating extreme conditions.
Trigger: The actual signal is only plotted when the probability peaks and subsequently drops below a Lower Threshold (Default: 50%). This confirms that the extreme momentum has broken and the reversal is underway.
Target Selection: Easily switch the engine's focus between predicting a "BOTTOM" or a "TOP" via the settings panel.
Visual Enhancements & Alerts: Includes intuitive dynamic bar coloring (changing based on probability intensity), a clear histogram, distinct signal shapes on the chart, and fully integrated alert conditions for automation.
Settings & Configuration
Prediction Target: Toggle between BOTTOM (Pivot Lows) and TOP (Pivot Highs).
Feature Parameters (CCI): Customize the 8 periods used for momentum extraction. Default settings range from 10 to 200 to capture micro-fluctuations up to macro-trends.
KNN Model Settings: * K-Value: The baseline number of nearest neighbors to compare.
Max Samples: The memory limit for historical data points (higher = more stability, but heavier computation).
Signal Settings: Customize the Upper and Lower thresholds for the two-step signal generation.
How to Trade with It
Select your target: Decide if you are looking for long opportunities (BOTTOM) or short opportunities (TOP).
Watch the Buildup: Observe the histogram or candlestick colors. When the probability goes above 80%, the market is showing conditions highly similar to historical reversals. Do not enter yet.
Wait for the Trigger: Wait for the momentum to break. When the probability drops back below the 50% threshold, a triangle shape will appear on the chart. This is your signal that the reversal pattern is executing.
Disclaimer:
This script uses historical pattern matching and experimental mathematical models. It does not guarantee future results. Please use it in conjunction with broader market context, other technical indicators, and strict risk management. Indicator
SuperTrend Take-Profit Dimensions [AlgoAlpha]🟠 OVERVIEW
A multi-dimensional take-profit aid that scores how typical the current bar looks compared to past SuperTrend pivots, so you can tell when a trend has reached favorable exit conditions.
The indicator runs a standard SuperTrend and records every confirmed zigzag pivot that occurs during a matching-direction run. Tops go into a bull pool , bottoms into a bear pool . Each pivot is stored as a set of readings across several independent axes, such as relative volume , time of day , and price position inside the recent range .
On every bar, the current reading on each axis is compared to that historical pool. A blended score from 0 to 100 tells you how closely the current conditions resemble where past pivots in the same direction have clustered. The idea is to give trend followers a data-backed sense of when to start tightening up, rather than guessing an exit or using a fixed R-multiple.
The three built-in axes were chosen deliberately to be as uncorrelated as possible , each describing a different dimension of market context: volume (relative volume percentile), time (time of day), and price (position in recent range). Correlated inputs would double-count the same information and distort the blended score; picking axes that describe genuinely different aspects of the market means each one contributes independent evidence, and the score reflects how many distinct dimensions are currently in agreement.
🟠 CONCEPTS
SuperTrend — An ATR-based trailing stop that flips between bullish and bearish states. Controls which pool of historical pivots the script reads from.
Pivot pool — A rolling store of confirmed zigzag pivots, split by direction. Bull pool holds pivot highs that printed during bullish SuperTrend runs; bear pool holds pivot lows from bearish runs. Capped at 2000 entries per side .
Context axis — A 0–100 value measured at the pivot bar. The script ships with three built-ins ( relative volume percentile , time of day , position in recent range ) and one optional user-plugged signal.
Axis independence — The three built-in axes cover volume , time , and price respectively, chosen so each describes a structurally different part of the market. Low correlation between axes keeps the blended score from being dominated by any single factor.
Conditional histogram — For each active axis, the script walks its pool and keeps only pivots whose bins on every other active axis match the current bar. The survivors are binned to form a histogram.
Axis score — For one axis, the count of pivots in the current bar's bin divided by the count in the histogram's tallest bin, scaled to 0–100 . 100 means the current context sits in the densest part of past pivots.
Blended favourability score — Arithmetic mean of the active per-axis scores. This is what the gauge and table display.
Density-match scoring — The score measures how common the current context is among past pivots. It is not a forward probability and makes no claim about what happens next.
🟠 FEATURES
Right-side context profiles — Stacked mini histograms render to the right of price, one per active axis.
• Bar heights show how pivots in each axis's conditional pool distribute across bins.
• A dashed vertical line marks the current bar's bin on that axis, so you can see at a glance where today sits against history.
• Bar hue tracks the active SuperTrend direction.
Favourability gauge — A vertical gradient table in the bottom-right showing the blended score, with a chevron marking the current level. Green at the top, red at the bottom.
Favourability breakdown table — A two-column readout of each active axis's individual score out of 100, plus a final row that classifies the blended score as Good , Neutral , or Bad . Position and text size are configurable.
Bar coloring — Bars fade from neutral grey toward the opposing trend colour as the blended score rises toward 100, so the chart itself signals when the context is stretched.
Take-profit markers — Small orange markers print above or below the bar when the blended score hits 100 for the active SuperTrend direction.
Timeframe guard — The time-of-day axis disables automatically on daily and higher timeframes, where the reading has no meaning, and a banner explains this so the blended score stays honest.
Multi-dimensional scoring engine — Four independent axes feed into a single score, each conditioned on all the others.
• Three built-in axes can be toggled on or off individually.
• A fourth axis accepts any plot via source input , provided the series stays within 0–100 on all loaded bars.
• An on-chart warning prints if the custom signal leaves that range, and the axis is ignored until it is corrected.
Deliberately uncorrelated built-in axes — Volume ( relative volume percentile ), time ( time of day ), and price ( position in recent range ) cover three structurally different facets of market context. Keeping the axes independent means each one adds new information to the blend rather than reinforcing the others.
Alert conditions — Six alerts are included: SuperTrend bullish flip, SuperTrend bearish flip, score peak match, and crossovers into the Good , Neutral , and Bad bands.
🟠 HOW TO USE
Add the script to an intraday chart on a liquid instrument and let it run long enough to populate the pools. More history means more stable conditional histograms.
Let SuperTrend define the active regime. The script only scores in the direction of the current trend; bar coloring and take-profit markers respect that regime.
Read the gauge and breakdown table together. The gauge shows the blended level; the table shows which individual axes are pulling it up or down.
Use the right-side profiles as a sanity check. If the dashed current-bin marker is sitting on or near the tallest bar across most axes, the current context closely resembles past pivot contexts in that direction.
Treat high scores as a cue to tighten management, not as reversal signals. A reading of 100 means conditions match where pivots have historically clustered, not that the trend is guaranteed to end.
Adjust the zigzag pivot length to control how strict the pool is. Lower values admit more pivots ( bigger, noisier sample ); higher values keep only firmer pivots ( smaller, cleaner sample ).
Plug your own signal into the custom axis to test whether an existing 0–100 oscillator adds useful conditioning, such as an RSI or a normalised momentum reading. For best results, pick a signal that is not strongly correlated with the three built-ins, so the custom axis adds a new dimension rather than re-stating an existing one.
Enable only the alerts that fit your workflow. The band-crossover alerts fire once per transition , not on every bar inside a band.
🟠 LIMITATIONS
The pool holds every confirmed pivot during a matching-direction run, not only pivots that ended the trend. Intermediate pullbacks sit alongside genuine terminal pivots. Raising the zigzag pivot length filters the pool further if you want a cleaner sample.
On strongly trending symbols the pool is dominated by pullback pivots rather than true terminal exits, because strong trends have many small pullbacks and only one final top or bottom. On choppy symbols the ratio is more balanced. Read the score with this in mind.
The blended score is a density-match measure, not a forward probability . A high reading means today's context is common among past pivots of this direction. It does not predict that the trend is about to end.
The time-of-day axis has no meaning on daily and higher timeframes and is disabled automatically on those timeframes. A warning banner confirms when this is active.
The custom axis requires a source already scaled to 0–100 on every loaded bar. Values outside that range disable the axis and surface a warning. Toggling the custom axis on a live chart starts the range check from the current bar; reload the chart to validate against full loaded history .
Pools are capped at 2000 entries per direction , with the oldest entries dropped first. On very long intraday histories the effective lookback is symbol- and timeframe-dependent.
All scoring uses data up to and including the confirmation bar of each pivot; pivots themselves are detected with the standard zigzag confirmation lag, meaning the scoring population on any given bar reflects pivots confirmed at least zzLen bars earlier.
🟠 CONCLUSION
SuperTrend Take-Profit Dimensions combines a standard SuperTrend with a rolling pool of historical pivot contexts and scores the current bar against that pool across up to four independent axes spanning volume, time, and price. The output is a blended 0–100 favourability reading , a per-axis breakdown, and a set of context profiles that show where past pivots have clustered. It gives trend followers a structured, data-backed way to judge when the current context matches where trends have historically given back profit, without pretending to predict the next bar. Indicator
QuantEdge Momentum ML [PRO]🟦 QuantEdge Momentum ML PRO is a k-Nearest Neighbors driven momentum oscillator built on an adaptive machine-learning core. Unlike RSI, Stochastic, or MACD — which apply the same static formula to every asset — QE-ML PRO learns the dual-horizon RSI fingerprints that have historically led to bullish versus bearish outcomes on the exact instrument being traded, then scores the current bar against the N closest historical matches. The result is a non-parametric, self-calibrating oscillator whose decision boundary is shaped by the asset's own behaviour rather than a hard-coded curve.
The indicator integrates nine independent layers — feature engine, training sampler, k-NN predictor, WMA signal line, stdev-adjusted OB/OS bands, filtered signal dots, gradient channel, theme-adaptive dashboard, and a nine-theme palette — all rendered on a single, clean oscillator panel.
🟦 HOW THE CORE ENGINE WORKS
**Dual-Horizon RSI Feature Vector**
Each bar, the Feature Engine computes two RSI values at different lookback windows and smooths both through a shared trend-length WMA:
- `rsiFast = WMA(RSI(close, FastPeriod), TrendLength)` — reactive short-term momentum
- `rsiSlow = WMA(RSI(close, SlowPeriod), TrendLength)` — structural mid-term momentum
The pair `(rsiSlow, rsiFast)` is a 2-dimensional point in RSI feature space. Every training sample stores one such point along with a ±1 label that records whether price rose or fell since the previous sample. Over time the dataset accumulates a cloud of labelled points that maps which RSI states historically preceded up-moves versus down-moves on this exact asset.
**Training Sampler — Multi-Trigger Collector**
Three collection modes decide when to append a new labelled sample:
| Mode | Trigger | Use Case |
|---|---|---|
| **MA Crossover** | Fast WMA crosses Slow WMA | Clean, sparse samples — classic single-trigger behaviour |
| **Periodic** | Every N bars (user-set) | Fills dataset fast on new / low-history charts |
| **Hybrid** | MA crossover **OR** every N bars | Richest training set — recommended for fresh assets |
Sampling is gated by `barstate.isconfirmed` so the dataset never absorbs unconfirmed values from a flickering live bar.
**k-NN Predictor with Adaptive k**
On every bar, the predictor computes Euclidean distance in the 2D RSI feature space between the live `(rsiSlow, rsiFast)` point and every historical sample:
```
d = sqrt((rsiSlow_now - rsiSlow_hist)² + (rsiFast_now - rsiFast_hist)²)
```
The K closest historical points vote by summing their ±1 labels. The effective K is resolved adaptively using the classical statistical heuristic:
```
kEff = max(3, min(kMax, floor(sqrt(N))))
```
This means early bars — when only a handful of samples exist — use a small K, and the value stabilises as the dataset fills. On a fresh chart you never get a noisy prediction from an undersized neighborhood, and on a mature dataset K automatically scales up for smoother output.
**Bias Correction — Label-Mean Recentering**
Raw k-NN output is biased whenever the label distribution is skewed. On a trending asset, Periodic sampling fills the dataset with mostly +1 (or mostly −1) labels, pushing every prediction off zero. QE-ML PRO subtracts the expected value from the raw sum:
```
prediction = neighborLabelSum − (kEff × meanLabelAcrossDataset)
```
This keeps the mid-level visually centred at zero regardless of how trending the underlying asset has been. The correction is applied on every bar and is what makes the oscillator read cleanly on both sideways and strongly trending markets.
**Minimum Sample Gate**
Until the dataset has reached the user-defined Minimum Training Samples threshold, the predictor outputs exactly zero. This prevents unreliable readings during the warm-up phase on fresh charts.
**FIFO Rotation**
The dataset is hard-capped at Max Dataset Size. Once the cap is reached, the oldest sample is discarded on every new insertion — classical rolling window memory that keeps the k-NN scan bounded and the indicator fast on long histories.
🟦 PREDICTION LINE — FIVE VISUAL STYLES
All five styles are line-based. Only the visual effect differs — the underlying k-NN math is identical across styles.
| Style | Character |
|---|---|
| **Stratum** | Thick adaptive line with zone-based opacity: solid in extreme zones, semi-transparent in the mid zone. Layered intensity aesthetic — default |
| **Neon** | Bright core line with an outer glow halo. Cyberpunk luminous effect, best on dark backgrounds |
| **Resonance** | LRI-style gradient line that fades near the midline and brightens toward the rolling extremes |
| **Pulse** | Adaptive bull/bear color (above midline = bull, below = bear) plus the WMA signal line. The QE-ML PRO classic look |
| **Mono** | Single flat theme-bull line, no gradient, no adaptive coloring. Minimalist single-color silhouette |
🟦 SIGNAL LINE
A WMA of the raw prediction output, used as a crossover trigger line in the MACD convention. Crossovers between the prediction and signal line mark momentum regime changes.
**Two Visual Styles**
| Style | Rendering |
|---|---|
| **Neon** | Bright core line wrapped in a wider semi-transparent glow halo — cyberpunk aesthetic |
| **Flat** | Plain single-color line, no halo, no gradient — minimalist clean look |
🟦 SIGNAL DOTS — FILTERED CROSSOVER MARKERS
A two-layer neon cross-dot renderer fires on every Prediction × Signal crossover that survives the active filter mode. Four progressive filters decide which raw crosses reach the chart:
| Filter Mode | Behaviour | Signal Count |
|---|---|---|
| **All Crosses** | Every cross becomes a dot | Highest — noisy on choppy assets |
| **Zone Only** | Only crosses inside an OB or OS strip | Mean-reversion triggers — strongest reversal setups |
| **Mid Aligned** | Bull dots only above mid, bear dots only below | Trend-following — keeps you on regime side |
| **Strict** | Zone Only + Mid Aligned + extra strength multiplier on mid-zone crosses | Fewest signals, highest conviction — default |
Two additional gates filter out whipsaws:
- **Cooldown (bars)** — minimum spacing between consecutive dots, prevents cluster spam in ranges
- **Min Strength** — minimum `|prediction − signal|` separation at the moment of the cross, drops razor-thin crossovers that close back on themselves
Each dot is a two-layer plot: an outer glow halo with user-adjustable size and opacity, and a bright solid core on top — independently sized and opacity-controlled so users can dial in the exact visual weight they want.
The dot is placed at the actual cross point: bull dots at `min(prediction, signalLine)`, bear dots at `max(prediction, signalLine)`.
🟦 DYNAMIC BANDS — STDEV-ADJUSTED OB / OS ZONES
QE-ML PRO does not use fixed 80 / 20 overbought / oversold levels. Instead, the bands adapt to the actual historical range of the prediction output:
- **Channel Extremes** — rolling highest / lowest of the prediction over a user-configurable lookback
- **Stdev Band** — EMA of rolling standard deviation of the prediction, multiplied by the user's stdev length
- **OB Level** = `rangeHi − stdevBand` (inner boundary of the overbought strip)
- **OS Level** = `rangeLo + stdevBand` (inner boundary of the oversold strip)
The result is a pair of mean-reversion zones that tighten during quiet markets and widen during volatile ones — no manual recalibration needed across assets.
The strips are rendered as gradient fills anchored on the live prediction plot, so they only appear visually while the prediction is actually inside the zone.
🟦 CHANNEL GRADIENT
Two symmetric gradient fills bracket the mid line. The upper fill stretches from `midValue` to `rangeHi`, the lower fill from `midValue` to `rangeLo`. Opacity fades from full intensity at the extremes to fully transparent at the midline — a visual range meter showing how close the prediction is sitting to its historical boundaries.
Colors are pulled from the active Theme. A single opacity slider controls the gradient intensity.
🟦 DASHBOARD — LIVE DATA PANEL
A compact 2-column × 7-row monospace panel drawn on the last bar only (zero historical overhead). Every field updates in real time on the live bar.
| Row | Left | Right |
|---|---|---|
| Header | QE-ML PRO | Regime (▲ BULL / ▼ BEAR / ■ NEUTRAL) |
| Row 1 | Prediction | Raw value + trend arrow vs previous bar |
| Row 2 | Signal | WMA trigger line value |
| Row 3 | Strength | 10-block gauge of `|prediction − signal|` normalised against rolling channel |
| Row 4 | Zone | OB / MID / OS tag |
| Row 5 | Dataset | Sample count / effective k |
| Row 6 | Mode | Active Learning Mode (MA Cross / Periodic / Hybrid) |
**Theme-Aware Auto-Invert**
The panel background scaffolds auto-switch:
- **Tropic / Amber / Pastel / Cyber / Gold / Electric / Candy** → dark panel with bright theme accent text
- **Midnight / Graphite** → light panel with dark theme accent text
This guarantees legibility on every theme without breaking the theme's color identity — because Midnight and Graphite use deep dark bull tones that would drown against a black panel.
**Direction via Glyphs, Not Color**
Both columns share the same full-strength theme tone. Regime direction is conveyed by `▲ ▼ ■` glyphs rather than color shifts, which keeps the panel reading cleanly even on the most minimal themes.
🟦 NINE COLOR THEMES
One theme selector drives every colored component — Prediction line, Signal line, Channel fill, OB / OS strips, Mid-level line, Signal Dots, and Dashboard panel. No per-color manual inputs.
| Theme | Character | Bull | Bear |
|---|---|---|---|
| **Tropic** | Cyan steel + deep orange — electric contrast (default) | Cyan | Deep Orange |
| **Amber** | Warm amber + indigo blue — fire tones | Amber | Red |
| **Pastel** | Sky blue + soft lavender — cool arctic glow | Sky Blue | Lavender |
| **Cyber** | Neon lime + hot crimson — cyber terminal | Neon Green | Crimson |
| **Gold** | Bright gold + scarlet — solar warmth | Yellow Gold | Red |
| **Electric** | Electric aqua + magenta — high-voltage neon | Aqua | Magenta |
| **Candy** | Neon green + hot pink — dark energy pop | Mint Green | Hot Pink |
| **Midnight** | Deep navy + dark crimson — dark depth (auto light dashboard) | Navy Blue | Dark Red |
| **Graphite** | Near-black + silver grey — monochrome minimal (auto light dashboard) | Near Black | Grey |
🟦 ALERT SYSTEM — TEN CONDITIONS
Every alert is gated by its matching "Show X" visibility toggle — if a component is hidden from the chart, its alerts are automatically suppressed. This eliminates the mismatch between visual signals and alert signals that plagues many indicators.
| Alert | Condition | Gated By |
|---|---|---|
| Crossover OB | Prediction crosses above the overbought boundary | Show OB/OS Fill |
| Crossunder OB | Prediction crosses back down through OB | Show OB/OS Fill |
| Crossover OS | Prediction crosses up through oversold boundary | Show OB/OS Fill |
| Crossunder OS | Prediction crosses below the oversold boundary | Show OB/OS Fill |
| Crossover Mid | Prediction crosses above the mid line — bullish regime flip | Show Mid Level |
| Crossunder Mid | Prediction crosses below the mid line — bearish regime flip | Show Mid Level |
| Crossover Signal | Prediction crosses above its WMA signal line (MACD bullish) | Show Signal Line |
| Crossunder Signal | Prediction crosses below its WMA signal line (MACD bearish) | Show Signal Line |
| Bull Signal Dot | A filtered Bull Signal Dot is plotted (uses Filter Mode + Cooldown + Min Strength) | Show Signal Dots |
| Bear Signal Dot | A filtered Bear Signal Dot is plotted (uses Filter Mode + Cooldown + Min Strength) | Show Signal Dots |
🟦 SETTINGS REFERENCE
**Visual**
- Theme — nine cohesive palettes. Default: Tropic
**Machine Learning**
- Neighbors (k) — upper bound on neighbors used by the predictor. Default: 100
- Adaptive k — scales k with dataset size using the `floor(sqrt(N))` heuristic. Default: ON
- Learning Mode — MA Crossover / Periodic / Hybrid. Default: MA Crossover
- Sample Every (bars) — bar interval for the Periodic / Hybrid trigger. Default: 5
- Minimum Training Samples — warm-up gate, predictor outputs zero until reached. Default: 30
- Max Dataset Size — hard FIFO cap. Default: 500 (safe on all timeframes)
**Feature Engine**
- Trend Length — WMA smoothing applied to both RSI features. Default: 20
- RSI Fast Period — first feature dimension. Default: 5
- RSI Slow Period — second feature dimension. Default: 20
- MA Fast Period — fast WMA for the crossover training trigger. Default: 5
- MA Slow Period — slow WMA for the crossover training trigger. Default: 20
**Prediction Line**
- Show Prediction Line — master toggle. Default: ON
- Prediction Style — Stratum / Neon / Resonance / Pulse / Mono. Default: Stratum
- Prediction Width — 1 to 5. Default: 2
**Signal Line**
- Show Signal Line — toggle. Default: ON
- Signal Style — Neon / Flat. Default: Neon
- Signal Period — WMA length of the signal line. Default: 20
- Signal Width — 1 to 5. Default: 1
**Signal Dots**
- Show Signal Dots — toggle. Default: ON
- Filter Mode — All Crosses / Zone Only / Mid Aligned / Strict. Default: Strict
- Cooldown (bars) — minimum spacing between dots. Default: 5
- Min Strength — minimum `|prediction − signal|` at the cross. Default: 0.5
- Core Dot Size — 1 to 8. Default: 3
- Core Dot Opacity — 0 to 100. Default: 100
- Glow Dot Size — 1 to 12. Default: 8
- Glow Dot Opacity — 0 to 100. Default: 30
**Channel Fill**
- Show Channel Fill — toggle. Default: ON
- Channel Opacity — 0 to 100. Default: 25
- Channel Lookback — rolling highest / lowest window. Default: 500
**OB / OS Fill**
- Show OB/OS Fill — toggle. Default: ON
- Zone Stdev Length — stdev window that offsets the OB / OS boundaries inward. Default: 20
**Mid Level**
- Show Mid Level — toggle. Default: ON
- Mid Level Value — Y-value of the reference line. Default: 0
- Mid Level Style — Solid / Dashed / Dotted. Default: Dashed
**Dashboard**
- Show Dashboard — toggle. Default: ON
- Panel Position — six slots (Top/Middle/Bottom × Right/Left). Default: Middle Right
- Panel Text Size — Tiny / Small / Normal / Large. Default: Small
**Alerts**
- Ten opt-in toggles, one per alert condition. All default: ON
🟦 TRADER PRESETS — SETTINGS BY STYLE
QE-ML PRO is volatility-agnostic thanks to the adaptive bands and bias correction, but the reactivity of the predictor scales directly with the feature and sampler parameters. The four presets below are tested starting points you can drop straight into the settings panel — adjust by ±20% to taste.
---
** SCALPER — 1m / 3m / 5m**
High-frequency entries, tight stops, many signals per session. Priority is reaction speed — you want the predictor to flip states within a handful of bars of an actual move.
| Setting | Value |
|---|---|
| Trend Length | 10 |
| RSI Fast Period | 3 |
| RSI Slow Period | 14 |
| MA Fast Period | 3 |
| MA Slow Period | 10 |
| Signal Period | 8 |
| Neighbors (k) | 40 |
| Adaptive k | ON |
| Learning Mode | **Hybrid** |
| Sample Every | 2 |
| Minimum Training Samples | 20 |
| Max Dataset Size | **300** (keeps 1m charts fast) |
| Filter Mode | **All Crosses** or Zone Only |
| Cooldown | 2 |
| Min Strength | 0.3 |
| Channel Lookback | 200 |
| Zone Stdev Length | 10 |
| Prediction Style | Neon or Stratum |
**Why:** Low smoothing (Trend=10) + short RSI pair (3/14) keeps the features razor-sharp. Hybrid learning means you never wait for an MA crossover during quiet 1m sessions. Max Dataset capped at 300 protects you from the PulseWire per-bar calculation limit on long 1m histories.
---
** DAY TRADER — 15m / 30m / 1H**
Balanced reactivity and conviction — the default profile. You want clean crosses without noise spam, and signals that survive the open / close volatility spikes.
| Setting | Value |
|---|---|
| Trend Length | 20 (default) |
| RSI Fast Period | 5 (default) |
| RSI Slow Period | 20 (default) |
| MA Fast Period | 5 (default) |
| MA Slow Period | 20 (default) |
| Signal Period | 20 (default) |
| Neighbors (k) | 100 (default) |
| Adaptive k | ON |
| Learning Mode | **MA Crossover** (default) |
| Minimum Training Samples | 30 (default) |
| Max Dataset Size | 500 (default) |
| Filter Mode | **Strict** (default) |
| Cooldown | 5 (default) |
| Min Strength | 0.5 (default) |
| Channel Lookback | 500 (default) |
| Zone Stdev Length | 20 (default) |
| Prediction Style | Stratum (default) |
**Why:** Every default value was tuned for this range. Strict filter + 5-bar cooldown keeps the dot count honest on a 30m chart. MA Crossover sampling gives you clean sparse data since 15m+ charts already have enough crossover events.
---
** SWING TRADER — 4H / 1D**
Lower signal frequency, higher conviction per signal. You're holding for days or weeks — every dot needs to mean something.
| Setting | Value |
|---|---|
| Trend Length | 30 |
| RSI Fast Period | 7 |
| RSI Slow Period | 30 |
| MA Fast Period | 7 |
| MA Slow Period | 30 |
| Signal Period | 30 |
| Neighbors (k) | 150 |
| Adaptive k | ON |
| Learning Mode | MA Crossover |
| Minimum Training Samples | 50 |
| Max Dataset Size | 800 |
| Filter Mode | **Strict** |
| Cooldown | 10 |
| Min Strength | 0.8 |
| Channel Lookback | 800 |
| Zone Stdev Length | 30 |
| Prediction Style | Stratum or Mono |
**Why:** Longer feature periods mean the predictor only moves on genuine structural shifts. Larger k (150) + bigger dataset (800) gives the k-NN vote a wider base so outliers don't flip the sign. Cooldown of 10 bars on a 4H chart = 40 hours minimum between dots — exactly what a swing trader wants.
---
** POSITION / LONG-TERM — 1D / 1W / 1M**
Macro regime detection. You're looking for the handful of generational setups per year — noise is the enemy.
| Setting | Value |
|---|---|
| Trend Length | 50 |
| RSI Fast Period | 10 |
| RSI Slow Period | 40 |
| MA Fast Period | 10 |
| MA Slow Period | 40 |
| Signal Period | 40 |
| Neighbors (k) | 200 |
| Adaptive k | ON |
| Learning Mode | **Hybrid** |
| Sample Every | 3 |
| Minimum Training Samples | 40 |
| Max Dataset Size | 1000 |
| Filter Mode | **Strict** |
| Cooldown | 15 |
| Min Strength | 1.0 |
| Channel Lookback | 1000 |
| Zone Stdev Length | 40 |
| Prediction Style | Mono or Pulse |
**Why:** Weekly and monthly charts have few crossover events per year — without Hybrid mode the dataset starves. Sample Every = 3 on a weekly chart means one sample every 3 weeks, which is plenty of structural density. Min Strength 1.0 filters out every shallow cross — you only see dots on generational momentum inflections.
---
**Tuning Tip**
If the predictor feels **too reactive** → increase Trend Length and Signal Period by 25%, raise Cooldown.
If the predictor feels **too sluggish** → switch Learning Mode to Hybrid, decrease Min Samples, lower Trend Length.
If the dashboard shows **Dataset N is stuck low** → switch Learning Mode from MA Crossover to Hybrid — crossover events are too rare on your current settings.
If you see **runtime / timeout errors** on long histories → drop Max Dataset Size to 300 and Channel Lookback to 300.
🟦 COMPATIBILITY
Works on all asset classes and all timeframes in PulseWire Pine Script v6.
- **Crypto** — Spot, futures, perpetual contracts
- **Forex** — All pairs
- **Equities** — Stocks, ETFs, indices
- **Commodities** — Metals, energy, agriculture
- **Timeframes** — 1m through Monthly
The k-NN engine learns each asset's own RSI fingerprint distribution, and the stdev-adjusted bands auto-scale to the volatility of that distribution, so the indicator is truly self-calibrating across assets and timeframes — no manual recalibration required.
🟦 TECHNICAL NOTES
- Pine Script v6
- No repainting — training samples are gated by `barstate.isconfirmed` so the dataset never absorbs unconfirmed live-bar values
- Dataset is hard-capped via FIFO rotation; no unbounded memory growth
- Dashboard renders only on `barstate.islast` — zero historical overhead
- All drawing objects are stateless plots (no label / box / line object pools), so `max_*_count` limits cannot be exceeded
- k-NN distance pass is O(N), sort is O(N log N), both bounded by Max Dataset Size
- Default Max Dataset Size of 500 is tuned to stay within PulseWire's per-bar calculation budget on histories up to ~50,000 bars
- Bias correction uses a single extra accumulator pass during the distance sweep — no performance penalty
🟦 DISCLAIMER
This indicator is provided for educational and informational purposes only. It does not constitute financial advice. Past performance does not guarantee future results. The k-NN engine learns from historical patterns, but markets do not guarantee that historical patterns will repeat. Always conduct your own analysis and apply proper risk management. Indicator
Machine Learning Supertrend [Aslan]Hey everyone 👋, This is an indicator I've been working on for a long time. Its not really finished yet, but I think it has huge potential.
It uses a SuperTrend foundation layer with momentum filtering, volume confirmation, and, most importantly, an adaptive engine that continuously adjusts its own parameters based on recent performance. It fires entry arrows on the chart while running a background simulation to score how the current settings are performing — then quietly adjusts itself over time.
Two systems run in parallel: the signal engine that produces the arrows you see, and a background test matrix that opens and closes simulated trades to feed the optimizer. The optimizer adjusts parameters, which produces better signals, which feeds back into better learning.
The Core Concept
At its heart this is a SuperTrend indicator — a volatility band that flips bullish or bearish as price crosses it. Signals fire either when that flip occurs (Reversal mode) or when price pushes to a new extreme within the current trend (Breakout mode).
On top of this, three adaptive learning layers run continuously:
Global Optimizer — rolling window of recent trade results that proposes parameter changes based on win rate, Sortino ratio, and profit factor
Micro-Batch Processor — a faster layer that groups results into mini-batches for quicker adjustments
Regime Grid — a 2D memory map that remembers what settings worked under similar market conditions (trend strength × volatility) and biases proposals accordingly
The Most Important Settings — Start Here
Band Width (Group ②) — Default: 1.4
The single most impactful setting in the entire indicator. Controls how wide the SuperTrend bands are. Lower values (1.0–1.2) create tight bands that flip often, giving more signals but more noise. Higher values (2.0–3.0) only flip on large structural moves, giving fewer but stronger signals. If your chart feels too noisy, raise this first. Higher values result in more trend following signals, while lower ones result in more contrarian signals.
Lookback Window (Group ②) — Default: 30
How many bars back the indicator scans when detecting new highs and lows. Lower values (10–15) react to minor swings and fire frequently. Higher values (50–100) only react to large structural pivots. Tune this alongside Band Width — they work together.
Signal Type (Group ①) — Default: Reversal
Pick one and stick with it. Reversal catches turning points when a trend exhausts. Breakout rides momentum to new extremes.
Reactivity / Master Dial (Group ⑥) — Default: 10
Controls how aggressively the adaptive engine responds to new information. Value of 1 = very conservative, slow to adapt, stays close to your base inputs. Value of 20 = aggressive, adapts quickly and can drift far from base settings. Start at 10 and only raise it if the market you're trading changes character frequently.
Signal Spacing (Group ①) — Default: 10
Minimum bars between any two signals. Prevents clustered rapid-fire entries in choppy zones. Lower on fast timeframes (3–5 on 1-min), higher on daily charts (20–30).
Group-by-Group Reference
① Signal Mode
Signal Type — Reversal catches trend exhaustion flips. Breakout rides momentum to new extremes. Pick one.
Require Fresh Pivot — When on, a signal only fires if price made a genuine new high/low first. Off = more signals, more noise.
Signal Spacing — Minimum bars between signals. Tune per timeframe.
② Volatility Envelope
Lookback Window — Bars scanned for new highs/lows. Lower = more reactive, more signals.
Smoothing Period — ATR calculation period. Lower = faster reaction to volatility, more band flips.
Band Width — ATR multiplier for band width. The most impactful setting in the indicator. Lower = more signals, higher = fewer stronger signals.
Price Basis — Which price source feeds SuperTrend. hlcc4 (default) is smoothest, close is most reactive.
True Range Mode — On = RMA-smoothed ATR (standard). Off = EMA-smoothed, faster but noisier.
③ Momentum Filter
Active — Toggles RSI filtering. Off = more signals but no momentum confirmation.
Length — RSI period. Lower = more volatile RSI, filter triggers more easily.
Hot Zone Memory — How many bars back it checks whether RSI was overbought (for sell confirmation). Higher = more lenient.
Cold Zone Memory — Same concept for oversold / buy confirmation.
RSI Hot/Cold Levels (set in Group ⑬) — Overbought/oversold thresholds. Default 70/30. Wider = more signals, tighter = fewer.
④ Flow Analysis
Sample Depth — Bars averaged to define "normal" volume.
Surge Threshold — Volume must exceed this multiple of average to count as a surge (1.2 = 20% above average).
Require Surge — When on, signals only fire with volume confirmation. Dramatically reduces count but greatly improves quality. Worth enabling.
⑤ Signal Quality
Key Levels Only — Only signals at major structural turning points fire. Fewer signals — suited for swing traders.
Key Level Depth — ATRs the price range must span to qualify as a key level. Only matters when Key Levels Only is on.
⑥ Master Dial
Reactivity (1–20) — The meta-knob for the entire adaptive engine. Controls batch size, adaptation speed, deadband sensitivity, and EMA alpha simultaneously. If you only change one adaptive setting, change this.
Micro-Batch Processing — Enables the faster mini-batch learning layer. On = quicker adaptation.
Live Pressure Sensor — Tracks cumulative up/down-tick volume flow on live bars to bias the optimizer's step size. Only affects live charts.
⑦ Auto-Tune Engine
Enable Auto-Tune — Master switch. Off = fixed parameters forever, just a traditional indicator.
Use Background Test Matrix — Runs the 5×5 simulated trade grid. Must be on for any adaptation to occur.
Lock Envelope to Base — Forces plotted bands to use your original inputs visually even if internal parameters have drifted. The signal engine always uses adapted values regardless.
⑧ Optimizer
Most users don't need to touch these — the defaults work well.
Step Size — Base learning rate. Higher = faster but potentially overshooting adaptation.
History Depth — Rolling window of trades used to compute statistics. Higher = slower but more stable learning.
Win Ceiling / Floor — Win rate thresholds that trigger parameter tightening or loosening.
Momentum Smoothing — EMA blend factor for applying new proposals. Higher = faster-acting changes.
Update Cooldown — Minimum bars between parameter updates. Prevents rapid oscillation.
Deadband Width / Period — Proposed changes must exceed these thresholds before being applied. Filters micro-jitter.
Anchor Revert Interval / Strength — Every N bars, parameters drift back toward your base inputs. Safety mechanism against unbounded drift.
P&L Cap per Trade — Clips outlier trades at this USD value before learning from them. Prevents one giant win/loss from distorting statistics.
⑨ Risk Guard
Max Entries / Session — Stops new signals after this many trades in a day.
Session Loss Limit — Pauses trading if cumulative session P&L drops below this USD amount.
Base Pause After Loss — Bars to wait after a losing trade. Prevents revenge trading.
Streak Limit — Pauses after this many consecutive losses.
Scale Pause by Loss Size — Larger losses trigger proportionally longer pauses.
Enforce on Test Matrix — Applies risk rules to the background simulation too. Usually leave off so the matrix always has fresh data.
⑩ Context Memory (Regime Grid)
Enable Regime Grid — Activates the market-context memory system.
Regime / Volatility Bins — Resolution of the grid on each axis. More bins = finer resolution but slower confidence buildup per cell.
Neighbor Blend Radius — How much adjacent grid cells blend into each other. Higher = smoother but less precise.
Decay Half-Life — How quickly older data in a cell loses weight. Lower = faster forgetting.
Max Grid Influence — How much the regime grid can dominate the global optimizer. 0.65 = up to 65% grid contribution.
⑪ Decay Traces
Short-term fading trade memory that specifically monitors for large adverse moves to tighten stops.
Enable Trace Buffer — Activates short-term memory.
Fade Rate — Energy reduction per bar. Higher = only very recent outcomes matter.
Adverse Move Threshold — MAE in ATR units above which a trade is flagged as a tail event.
Guard Tighten Cap — Maximum stop tightening allowed from tail-event feedback.
⑫ State Snapshot
Restore String — Paste a previously exported snapshot here to reload learned parameters and grid cells across reloads.
Export Now — Toggle on to emit the current learned state as an alert string. Toggle off afterward.
Import on Next Bar — Applies the Restore String on the next confirmed bar.
Risk Management (TP/SL Overlay)
Show TP & SL — Toggles the visual overlay.
TP/SL for — Which signal type drives the levels — Contrarian, AI Supertrend, or Both.
TP 1/2/3 — Take-profit multipliers relative to the stop distance. Set any to 0 to disable that level.
Quick Tuning Guide
Too many noisy signals? Raise Band Width → raise Lookback Window → raise Signal Spacing → enable Require Surge → enable Key Levels Only.
Too few signals? Lower Band Width → lower Lookback Window → lower Signal Spacing → disable Require Surge → disable Key Levels Only → widen RSI Hot/Cold levels.
Want faster adaptation? Raise Reactivity toward 15–18 → lower History Depth → lower Decay Half-Life.
Want more stability? Lower Reactivity toward 3–5 → raise History Depth → raise Anchor Revert Interval.
Starting fresh on a new instrument? Let the indicator run for at least 50–100 bars before evaluating, then use Export Now to save the learned state so it survives a chart reload. Indicator
Naive Bayes DNA Heatmap | GainzAlgoThe Naive Bayes Volume Heatmap is a predictive analytical suite that moves beyond traditional lagging indicators. While a standard RSI or MACD simply tells you where price has been, this system uses Gaussian Machine Learning to determine the statistical probability of where price is going.
By analyzing the Volume of a candle, the internal distribution of volume, delta, and price force, the indicator visualizes market sentiment as a multi-layered heatmap. It allows traders to see whether the current price action is backed by institutional flow or is simply noise.
Core Logic: The Naive Bayes Engine
The brain of the system is a Gaussian Naive Bayes (GNB) classifier. This is a machine learning algorithm that calculates the probability of an event based on prior conditions.
How it Learns
The model continuously "trains" itself on a lookback window (default 500 bars). It analyzes two primary features:
Intensity (Feature 1): Relative Volume (1m mode) or Net Delta (Footprint mode).
Directional Force (Feature 2): The relationship between price spread and volume (1m mode) or POC Distance (Footprint mode).
Here is the self contained function that does the heavy lifting of the probability analysis:
f_naive_bayes(float feat1, float feat2, float target, int len) =>
m1_f1 = ta.sma(target > 0 ? feat1 : na, len), m1_f2 = ta.sma(target > 0 ? feat2 : na, len)
m0_f1 = ta.sma(target <= 0 ? feat1 : na, len), m0_f2 = ta.sma(target <= 0 ? feat2 : na, len)
v1_f1 = math.pow(ta.stdev(target > 0 ? feat1 : na, len), 2), v1_f2 = math.pow(ta.stdev(target > 0 ? feat2 : na, len), 2)
v0_f1 = math.pow(ta.stdev(target <= 0 ? feat1 : na, len), 2), v0_f2 = math.pow(ta.stdev(target <= 0 ? feat2 : na, len), 2)
p1 = nz(ta.sma(target > 0 ? 1.0 : 0.0, len), 0.5)
l1 = f_pdf(feat1, nz(m1_f1), nz(v1_f1)) * f_pdf(feat2, nz(m1_f2), nz(v1_f2)) * p1
l0 = f_pdf(feat1, nz(m0_f1), nz(v0_f1)) * f_pdf(feat2, nz(m0_f2), nz(v0_f2)) * (1.0 - p1)
prob = nz(l1 / (l1 + l0 + 0.000001), 0.5)
This function is the engine of the indicator. It implements a Gaussian Naive Bayes Classifier directly in Pine Script to calculate the real-time probability of a bullish move.
Here is a breakdown of how this code processes market data:
Class Separation (The "M" and "V" Variables)
The function splits historical data into two buckets based on the target (Price Action):
Bucket 1 (Bullish): Data from bars that closed green.
Bucket 0 (Bearish): Data from bars that closed red.
It then calculates the Mean (m) and Variance (v) for each feature within those buckets. This creates two distinct "profiles"—essentially a mathematical fingerprint of what a Bullish bar looks like versus a Bearish one.
Bayesian Inference (The Result)
Finally, it applies Bayes' Theorem to combine these likelihoods with the Prior Probability (p1)—which is simply the historical win rate of green bars over the lookback period.
The final prob is a normalized value between 0 and 1. If the result is 0.85, the model is signaling an 85% statistical probability that the current market conditions align with historical bullish reversals.
The Math
As discussed above, the engine uses the Probability Density Function (PDF) to map these features onto a bell curve. It asks: "In the past, when we saw this specific volume intensity and this specific price force, how often did the next bar close green versus red?"
The result is a Win Probability %. If the probability is >50%, the bias is Bullish; <50% is Bearish.
The Heatmap
The Heatmap is a vertical stack of 20 independent probability layers.
Multi-Horizon Smoothing: Each layer represents a different generation of the Naive Bayes calculation, ranging from ultra-fast (5-bar smoothing) to long-term (100-bar smoothing).
Specialized Features
The Power Index (The White Line)
The Power Index is your Confluence Meter . It scans all 20 layers of the data and counts how many are currently signaling a trend above a 60% threshold.
A spiking Power Index indicates that the trend is synchronizing across all time horizons, a high-probability entry signal.
Footprint Mode vs. 1-Minute Mode
1-Minute Precision: When active, the script uses request.security_lower_tf to deconstruct the current chart bar into 1-minute slices. It finds the "hidden" intent inside the candle that standard indicators miss.
Footprint Analysis: This mode hooks into raw Exchange Order Flow. It calculates Aggressive Buying vs. Aggressive Selling to feed the Naive Bayes engine the most "raw" data possible.
The sidebars: Unique to Footprint mode, these wide neon bars appear to the right of the heatmap.
Real-Time Volume Scaling: The bars grow and shrink based on the current bar's Buy/Sell volume ratio.
Divergence Spotting: If the Heatmap is bright Aqua (Bullish) but the Pink Sell Box is 80% full, you are witnessing Absorption, big players are absorbing the selling, often leading to a massive squeeze.
How to Use the Suite
The Elite Entry
Identify the Bias: Check the NB Probability in the table. You want to see >65% for a high-probability trade.
Confirm the Match: Ensure the heatmap layers are expanding (moving from the dark center toward the bright edges).
Check the Power Index: Wait for the white line to curve upward, confirming momentum is stacking.
The Signal: When the "NB SIGNAL" cell in the table flips to ELITE LONG or ELITE SHORT, the statistical edge is at its peak.
The Elite Exit
Exit when the inner layers of the heatmap turn back to Midnight Charcoal or the opposite color. This indicates that the immediate heartbeat of the trend has faded, even if the longer-term layers are still colored. Indicator
Deep Machine Learning - Artificial Neural Network -⭐ Full-Scale Deep Learning AI on PulseWire ⭐
🌟 Introduction: A Paradigm Shift in Technical Analysis
We are currently living in an unprecedented era of Artificial Intelligence. Large Language Models (LLMs) like Google's Gemini and OpenAI's GPT have fundamentally revolutionized how we process data, generate code, and understand complex non-linear relationships. Inspired by the tremendous analytical power of these modern AI models, this script bridges the gap between advanced data science and retail trading.
🟢 In Simple Terms (For Beginners)
Not a data scientist? Don't worry! Here is what this script does in plain English:
Imagine having a tireless assistant who has studied decades of chart patterns. Instead of you staring at 5 different indicators (like RSI, MACD, and Bollinger Bands) and trying to guess the trend, this AI looks at all of them simultaneously. It learns from its past mistakes, figures out what is actually working right now, and gives you a single, easy-to-read "Bullish" or "Bearish" line. You don't need a PhD in math to use it!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🏫 Educational Deep Dive: Unveiling the "Black Box"
Before diving into the indicator settings, it is essential to understand how a Neural Network (NN) operates. Traditional indicators look at past math to plot a line; Neural Networks learn from past mistakes to forecast a probability.
🧠 The "Sports Team" Analogy (How it works simply)
Think of the Neural Network like a professional sports organization:
The Scouts (Input Layer): They gather raw data from the field (Momentum, Trend, Volume).
The Coaches (Hidden Layers): They sit in the locker room, debate the data, and figure out complex game strategies.
The Manager (Output Layer): Makes the final, definitive decision to "Buy" or "Sell" based on the coaches' advice.
Learning from Mistakes (Backpropagation): When the team loses a game (makes a bad prediction), they review the tape and adjust their strategy for the next game. This AI does exactly this on every single new candle!
🏗️ The Network Architecture (For Advanced Users)
A neural network is inspired by the biological human brain, organized into specific layers. Here is a simplified map of what is happening mathematically inside this script on every single bar:
→weighted sum & activation→
→weighted sum & activation→
💡 DEEP DIVE: Activation Functions (Mapping Non-Linearity)
If a Neural Network only used basic multiplication and addition, it would mathematically collapse into a single, rigid linear regression formula, completely failing to map the chaotic realities of financial markets.
Activation Functions introduce non-linearity, allowing the model to warp its decision boundaries and solve complex, multi-dimensional problems.
📈 ReLU (Rectified Linear Unit): max(0, x) -> Mitigates the "vanishing gradient" problem. It aggressively turns off negative noise, creating sparse, highly efficient activations.
🌊 Tanh (Hyperbolic Tangent): Squashes values into an S-curve between -1 and 1. Being zero-centered, it generally yields faster convergence during gradient descent than Sigmoid.
📉 Sigmoid: Squashes values between 0 and 1. Used for probability estimation, though susceptible to gradient saturation on extreme inputs.
🧠 DEEP DIVE: Optimizers (Navigating the Loss Landscape)
When the AI makes a mistake, Backpropagation uses the Chain Rule of calculus to compute the "Gradient"—the vector pointing toward the steepest increase in error. The Optimizer dictates how to move in the opposite direction to minimize this error.
SGD (Stochastic Gradient Descent): Takes uniform steps down the gradient. Prone to getting stuck in local minima and ravines.
Momentum: Accumulates a moving average of past gradients to accelerate through flat regions and dampen oscillations.
RMSprop: Adapts the learning rate individually by dividing the gradient by a running average of its recent magnitude.
Adam (Adaptive Moment Estimation): The absolute state-of-the-art. It calculates both the 1st moment (mean, like Momentum) and 2nd moment (uncentered variance, like RMSprop) of the gradients. Crucially, it employs Bias Correction to prevent the moments from skewing towards zero early in training, allowing it to navigate the non-convex loss landscapes of financial markets with unmatched precision.
🛡️ DEEP DIVE: Regularization & MC Dropout (Bayesian Approximation)
Overfitting is the fatal flaw of poorly built AI—memorizing the past instead of learning the underlying structure.
L1 Regularization (Lasso): Acts as an algorithmic feature selector. It aggressively pushes the weights of useless, noisy indicators to exactly zero (Sparsity).
L2 Regularization (Ridge): Applies "Weight Decay" by penalizing large weights quadratically. It forces the network to distribute its reliance across all inputs rather than trusting a single dominant feature.
Monte Carlo (MC) Dropout: By randomly turning off nodes during live inference, we aren't just creating noise. Mathematically, this approximates a Gaussian Process, transforming the model into a Bayesian Neural Network. Instead of absolute point estimates, it provides a probabilistic distribution, allowing us to quantify the model's true epistemic uncertainty.
🌀 DEEP DIVE: Kalman Filter Dynamics (Signal vs. Noise)
Financial data is notoriously non-stationary. The script utilizes a 1D Kalman Filter—an algorithm originally designed for aerospace telemetry. It operates on a predict-update cycle. It mathematically balances Process Noise (Q) (the true underlying shift in market trend) and Measurement Noise (R) (the erratic, short-term price fluctuations). By continuously minimizing the error covariance, it extracts the pure signal from the raw Neural Network output without introducing the severe lag inherent in standard moving averages.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚙️ Groundbreaking Features
This indicator is packed with state-of-the-art machine learning techniques previously unseen in native Pine Script:
🎛️ Fully Customizable Architecture: You are the data scientist. Customize hidden layers, nodes per layer, Activation Functions, L1/L2 Regularization penalties, and select from advanced Optimizers to tailor the brain specifically for Crypto, Forex, or Stocks.
🔄 True Online Learning: A model trained on 2021 data will fail in 2024. This network solves that by sampling random historical bars and training itself using Gradient Descent on every single new bar. If the market regime shifts from a bull run to a chop zone, the model re-weights itself dynamically today.
⚖️ Layer Normalization: Financial data is wildly unstable. Layer Norm stabilizes the learning process by standardizing the inputs across the hidden layers, dramatically speeding up convergence and preventing the network from "exploding" mathematically.
🌊 Kalman Filter Smoothing: The raw neural network output is incredibly fast but can be noisy. The output is passed through a mathematically rigorous 1D Kalman Filter, which minimizes error covariance and produces a buttery-smooth, highly actionable Oracle line.
🖥️ Intelligent Dashboard UI: A sleek, dark-themed dashboard displays raw inputs, hidden layer activations (color-coded by activation strength), the final Oracle prediction, and the Uncertainty margin, directly on your chart.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🛠️ Comprehensive Configuration Guide
1️⃣ Engine Configuration (Tuning the Brain)
Optimizer: Leave this on Adam for the best general performance.
Learning Rate (LR): The "step size." If the line is too chaotic, lower the LR. If it adapts too slowly, raise it.
Hidden Layers & Nodes: More is not always better. Giving the network 5 layers and 15 nodes on a 1-minute timeframe will cause it to memorize noise. Start small (e.g., 2 layers, 8 nodes).
2️⃣ Target Configuration (What is the AI predicting?)
Candle: Predicts if the current candle is green or red. (Very noisy, best for scalping).
HTF Candle: Predicts the direction of a predefined Higher Timeframe candle.
Pivot State (Recommended): The AI learns the broader macro market structure by identifying historical Higher Highs (HH) and Lower Lows (LL). This filters out the noise and forces the AI to learn true trend waves.
3️⃣ Signals & Chart Overlays (Actionable Intelligence)
The script goes beyond just an oscillator by providing direct visual cues on your main price chart.
Threshold Crossing Alerts: You define an Alert Threshold (e.g., 0.5 or 1.0 Sigma). When the Oracle line crosses this threshold with conviction, the script triggers a Buy (▲) or Sell (▼) label and can fire native PulseWire alerts.
Smart Label Opacity (MA Alignment): To filter out weak or counter-trend signals, the script utilizes a dual-confirmation system with the Signal MA (nn_ma).
Bright Labels: If a signal triggers and aligns with the Signal MA (e.g., a Buy signal fires while the Oracle is also above its Moving Average), the label is plotted brightly, indicating high momentum and strong trend agreement.
Faint Labels: If a signal triggers but contradicts the Signal MA, the label is plotted faintly (transparently). This acts as a visual warning that the move lacks full momentum backing and might be a riskier, counter-trend setup.
4️⃣ Decoding the AI Dashboard (Visualizing the Brain)
The on-chart Intelligent Dashboard is not just for aesthetics; it literally visualizes the internal thought process of the neural network in real-time.
VECTOR & INPUT (The Senses): This column lists your chosen feature indicators and their current Z-Score normalized values. You can see exactly how strongly the market is pushing each individual metric.
L1, L2... (The Hidden Layers): These columns represent the actual artificial neurons in each hidden layer. The numbers displayed are the post-activation values.
Notice the Colors: The cells are color-coded dynamically based on activation strength. Bright blue/red cells mean those specific neurons are firing strongly, recognizing a pattern. Dark/transparent cells mean those neurons are currently inactive or squashed by the activation function. You are literally watching the AI "think."
ORACLE (The Final Output):
The Score: The aggregated final prediction value (typically clamped between -3.0 and +3.0).
The Phase: A clear text label indicating the current market regime (e.g., "STRONG BUY", "BULLISH", "BEARISH", "STRONG SELL").
Uncertainty (± Margin): The exact numerical value of the Confidence Interval calculated via MC Dropout. A low margin (e.g., ±0.15) means the AI is laser-focused and highly confident. A high margin (e.g., ±0.80) means the AI is mathematically uncertain due to conflicting data.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💡 Advanced Pro-Tips for Real Trading
Reading the Oracle Line:
Values > 0 indicate a Bullish bias (Blue gradient).
Values < 0 indicate a Bearish bias (Red gradient).
Watch the color intensity: A solid, bright line means the AI has strong statistical conviction. Faded, transparent lines mean standard deviation is high and the signal is weak.
Using the CI Box (The Squeeze & Expand Tactic): Look at the transparent box projected into the future.
The Expand (Avoid): When the box is incredibly wide, the AI is telling you the market is chaotic and unpredictable. Protect your capital and stay out.
The Squeeze (Action): When the box gets extremely tight, the AI has high certainty. Look for entries in the direction of the Oracle line.
Wait for the Cross & Check the Smart Labels: Do not execute a trade the millisecond the line turns blue. Trade when it crosses the Alert Threshold. More importantly, look at the brightness of the chart label. Prioritize bright labels where the AI's conviction aligns perfectly with the underlying Signal MA, and be extremely cautious with faint labels.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ Disclaimer
This script is a complex statistical machine learning model designed for educational and deep analytical purposes. Neural Networks are highly dependent on user-defined hyperparameter settings and the specific features fed into them. A poorly tuned model will produce garbage output. Past performance and back-tested training do not guarantee future live market results. Do not use this tool as the sole basis for real-money trading decisions. Always employ strict risk management, position sizing, and use this in confluence with your own price action analysis.
If you appreciate the hundreds of hours of coding and advanced mathematics that went into making this first-of-its-kind Native Pine Script Neural Network a reality, please drop a Boost 🚀, add it to your favorites, and leave a comment below! Let's push the boundaries of what is possible on PulseWire. Indicator
MFE (Market Fractal Entropy)The Market Fractal Entropy (MFE) is a groundbreaking indicator that fully integrates traditional chart analysis with information theory.
Unlike conventional oscillators that merely rely on price smoothing or momentum to measure "overbought" or "oversold" conditions, this script takes a strictly mathematical approach to the market's geometric structure. By quantifying elements such as trendline slopes, distances from trendlines, retracements, and extensions as "information content," you can think of it as a multi-faceted chart analysis compressed into a single oscillator.
▶How to Trade with MFE
Theoretically, a positive MFE value represents the probability (or information content) of a High being formed (i.e., the probability that the current candle's high becomes a Pivot High, PH). Conversely, a negative value represents the probability of a Low being formed (the probability of the current candle's low becoming a Pivot Low, PL).
Therefore, an explosive surge (spike) from the zero-line towards the extreme bands (+90 / -90) strongly suggests that a High or Low is highly likely forming at that exact moment. During a trend, you will often see spikes stopping exactly at the zero line; this indicates an excellent entry opportunity on a retracement.
▶Integrating Traditional Chart Analysis and Information Theory
Traditional chart analysis utilizes tools like trendlines, retracements, and extensions to understand the geometric structure of the market. However, interpreting these tools often relies heavily on the subjective judgment of the trader.
On the other hand, in Claude Shannon's Information Theory, "Self-Information" (or Surprise) mathematically quantifies the amount of information associated with an event. The lower the probability of an event occurring, the higher its surprise or information content.
This script elegantly integrates these two distinct fields. It models the geometric features of past Pivot Highs (PH) and Pivot Lows (PL)—such as the slope of the trend, the depth of the retracement, and the length of the extension—as a probability distribution. It then evaluates the currently forming wave against this historical distribution to calculate its "surprise" (information content). In essence, it objectively and mathematically scores how "rare" or "common" the current geometric structure is, providing a data-driven approach to classical chart patterns.
▶Theoretical & Philosophical Background: Market Geometric Information Theory (MGIT)
I have always believed that the market possesses an orderly geometric structure (such as trendlines, horizontal levels, and chart patterns) and a temporal rhythm in which these structures periodically complete themselves. I hypothesized that market dynamism could be understood as a geometric order within the two-dimensional spacetime of price and time. Furthermore, I believe this order can be quantified by treating it as entropy (information content) within a complex system.
I call this the Market Geometric Information Theory (MGIT). MGIT views financial markets not as simple time-series data, but as a continuous generation and dissipation of wave structures within a multi-dimensional "geometric feature space."
▶The philosophy of MGIT is built upon two core concepts:
Structural Memory: The market is not an amnesiac system. It retains an invisible "probability distribution" of past wave structures, trend angles, and geometric ratios. The market constantly learns from its own history.
Geometric Attractors: In complex systems theory, dynamic systems eventually settle into stable states called Attractors. In financial markets, crowd psychology naturally gravitates toward specific, harmonious wave proportions (like Fibonacci ratios). We define these universally preferred proportions as "Geometric Attractors."
▶What is Market Entropy?
Based on MGIT, the "Market Entropy" in this script is the quantification of the information content (surprise) generated when a PH (Pivot High) or PL (Pivot Low) is formed at the current candle.
It calculates how much the currently forming provisional pivot deviates from the market's "structural memory" (the historical probability distribution). If the calculated surprise is small, it evaluates that the probability of a PH or PL forming is high. Conversely, if the surprise is large, the probability of a PH or PL forming is evaluated as low.
▶The Breakthrough: The Reversal Mechanism
The ultimate edge of this indicator lies in its ability to pinpoint market tops and bottoms through the lens of structural mechanics, rather than simple momentum decay.
In this indicator, entropy is decomposed into a directional metric consisting of positive entropy and negative entropy. When MFE is close to the positive extreme (+100), the market is evaluated as forming a PH. When MFE is close to the negative extreme (-100), the market is evaluated as forming a PL.
▶Key Features of this Script
Four-Quadrant Regime Modeling & Probability Distributions:
The market state is dynamically categorized into four quadrants (Uptrend, Downtrend, Expansion, Contraction) using a Markov-like state model. The geometric features (slopes, retracements) of past PH/PL formations are accumulated as a "probability distribution" for each state. The script then calculates the self-information (surprise) of the current provisional PH or PL by evaluating how "rare" or "unlikely" it is against this historical probability distribution.
Minimum Information Principle:
Evaluates multiple provisional pivot formations and adopts the one with the lowest absolute entropy (least surprise = most likely outcome).
Kalman Filter Option:
Includes a customizable Kalman Filter (Process Noise $Q$ & Measurement Noise $R$) to intelligently smooth out erratic spikes and isolate the true entropy trend.
Dynamic UI & Scaling:
The entropy line dynamically changes color based on the zero-line cross. Since information content is inherently unstable and can easily diverge into massive numbers, it uses Tukey Fences and Tanh soft-clipping to maintain an elegant $-100$ to $+100$ bounded oscillator, greatly improving readability and interpretability. Indicator
Indicator
Indicator
kNN Market Architecture [LuxAlgo]The kNN Market Architecture indicator is a professional-grade market structure framework that utilizes a k-nearest neighbors (kNN) machine learning classifier to validate price pivots across multiple time horizons. By integrating a dynamic detection engine, cumulative volume delta analysis, and a range-based volume profile, this tool provides a multi-layered hierarchical view of price action to identify high-probability reversal and breakout zones.
🔶 USAGE
The indicator identifies and classifies market structure into three distinct layers: Short-Term (ST), Medium-Term (MT), and Long-Term (LT). Unlike traditional pivot indicators that rely on static lookbacks, each point must pass a kNN similarity test based on relative volatility and volume features to be validated and plotted.
🔹 Multi-Scale Bias Analysis
Users can define which structural layer (ST, MT, or LT) dictates the overall market bias. When price is trading above the most recent validated high of the selected term, the candles and dashboard will reflect a bullish bias. Conversely, trading below the recent validated low indicates a bearish bias. This allows for seamless "top-down" analysis within a single chart view.
🔹 The Delta Tank
When a structural level is active (not yet breached), a "Delta Tank" label appears at the price line. This tool tracks the cumulative volume and delta (buying vs. selling pressure) since the level was formed.
A green icon with a high fill percentage indicates aggressive buying defending a support level or attacking resistance.
A red icon suggests selling pressure is mounting, potentially signaling an upcoming Break of Structure (BOS).
The percentage value represents the delta-to-total-volume ratio, providing a metric for the "exhaustion" or "strength" of a specific level.
🔹 Anchor Volume Profile
The indicator includes a dynamic Volume Profile that anchors itself specifically to the current active structural range. This profile calculates volume distribution between the most recent validated High and Low of your chosen Bias Source, allowing you to see exactly where the most "fair value" was traded within the current trading range.
🔶 ADVANTAGES OVER TRADITIONAL METHODS
The kNN Market Architecture offers several significant improvements over standard market structure indicators:
Noise Filtering via Machine Learning: Traditional pivot indicators plot every mathematical high/low within a window. The kNN classifier filters these by comparing the "signature" (volatility and volume) of the current point against historical successful pivots. If a pivot lacks the necessary confidence, it is ignored, leading to much cleaner charts.
Volatility-Adjusted Detection: Most indicators use a fixed lookback (e.g., 10 bars). This script uses a dynamic engine that expands during high volatility and contracts during low volatility, ensuring the structure remains relevant regardless of market speed.
Contextual Volume Data: While standard indicators only show price, this tool layers Volume Delta and Volume Profiles directly onto the structure points, providing the "why" behind price movements.
🔶 DETAILS
🔹 Auto-Adjust Sensitivity
The core of the detection engine is its ability to adapt to changing market conditions. When "Auto-Adjust Sensitivity" is enabled, the script calculates a volatility ratio by comparing the current ATR to its long-term average. During periods of high volatility, the engine automatically expands the detection window. This ensures that the indicator requires more significant price movement to confirm a new structure point, preventing "false positives" during erratic price swings. In low-volatility environments, the window contracts, making the engine more sensitive to subtle structural shifts.
🔹 kNN Validation Engine
For every potential price pivot, the engine analyzes features such as Relative ATR and Relative Volume. It compares these features against a historical database of previous pivots. If the current point does not meet the "Confidence Threshold" (the average score of its k-nearest neighbors), it is discarded.
🔶 SETTINGS
🔹 Dynamic Engine
Structure Sensitivity: Controls the base lookback for pivot detection.
Auto-Adjust Sensitivity: Enables volatility-based scaling of the detection engine.
🔹 kNN Classifier
k-Nearest Neighbors: The number of historical neighbors to compare against the current pivot.
Confidence Threshold: The minimum similarity score required to validate a structure point.
🔹 Visual Hierarchy
ST/MT/LT Toggles: Enables or disables the visibility of Short, Medium, and Long-term structures.
Bias Source: Choose which term (Auto, LT, MT, ST) governs candle coloring and the Volume Profile.
Color Candles by Bias: Toggles the gradient candle coloring based on the current range position.
🔹 Volume Profile
Show Volume Profile: Toggles the structural range-based profile.
Profile Rows: Adjusts the vertical granularity (price bins) of the profile.
Profile Width (%): Controls the horizontal scale of the profile.
Indicator
Cluster Money Flow Index [UAlgo]Cluster Money Flow Index is a zone based MFI structure tool designed to detect repeated Money Flow Index turning points and group them into meaningful reaction areas. Instead of treating every isolated MFI pivot as a standalone event, the script searches for clusters of nearby pivots that occur around similar MFI levels. When enough touches accumulate in the same area, the indicator promotes that region into a live zone.
The main idea is simple. If MFI repeatedly turns down from a similar high region, that area can behave like an overbought supply style zone inside the oscillator. If MFI repeatedly turns up from a similar low region, that area can behave like an oversold demand style zone. By clustering these repeated reactions, the script attempts to map oscillator structure in the same way traders often map support and resistance on price.
What makes this indicator especially useful is that the zones are not static. They can expand when fresh touches appear, they gain visual strength as more reactions accumulate, and they can later be invalidated if MFI decisively breaks beyond them. This creates a much more dynamic view than a simple overbought line, oversold line, or ordinary pivot marker.
The script also includes a smoothed MFI reference, optional center lines, zone labels, a live dashboard, and alert conditions when MFI enters active cluster zones. This makes the indicator useful both for structural oscillator analysis and for workflow monitoring.
In practical use, Cluster Money Flow Index can help highlight repeated MFI rejection areas, repeated MFI support areas, transition zones near the middle range, and regions where oscillator behavior has historically clustered before reversal or pause.
🔹 Features
🔸 Pivot Based MFI Structure Detection
The script detects confirmed MFI pivot highs and pivot lows using user defined left and right pivot settings. This means clusters are built only from confirmed oscillator turning points rather than from every small fluctuation.
🔸 Cluster Logic Instead of Single Pivot Logic
A new pivot does not automatically create a new zone. The script first checks whether that pivot is close enough to an existing valid cluster. If it is, the cluster gains another touch. If it is not, a new cluster is created.
🔸 Adaptive Proximity Threshold
Cluster sensitivity is based on MFI volatility. The script calculates the standard deviation of raw MFI and multiplies it by the user selected proximity multiplier. This makes zone grouping adapt to the current oscillator environment.
🔸 Minimum Touch Confirmation
A cluster is displayed only after it reaches the required minimum number of touches. This helps filter out weak one time reactions and focuses attention on repeated oscillator behavior.
🔸 Optional Zone Expansion
When enabled, the zone can expand with each new retest. If a fresh pivot extends beyond the current cluster boundary, the top or bottom is updated and the center is recalculated. This allows the zone to evolve naturally as more data arrives.
🔸 Dynamic Zone Strength Visualization
Zones become slightly more visible as touch count increases. This gives stronger clusters more visual weight and helps the user quickly distinguish weak from strong oscillator regions.
🔸 Overbought, Oversold, and Mid Context
Zone color is chosen from the zone center. Clusters centered high in the MFI range use the overbought color, clusters centered low use the oversold color, and clusters near the middle range use the mid color.
🔸 Optional Center Line and Labels
Each displayed cluster can include a center line and an information label showing whether the zone is an upper or lower type cluster, its approximate center level, and its total touch count.
🔸 Invalidation Logic
A zone remains valid until MFI breaks clearly beyond it. Upper clusters are invalidated if MFI pushes decisively above the zone. Lower clusters are invalidated if MFI drops decisively below it.
🔸 Dashboard Summary
A built in dashboard can show current MFI state, number of active upper and lower zones, strongest cluster strength, and the nearest upper and lower cluster centers.
🔸 Alert Support
Alerts are provided for:
MFI entering an upper cluster zone,
MFI entering a lower cluster zone,
MFI crossing above 80,
and MFI crossing below 20.
🔹 Calculations
1) Calculating Raw and Smoothed MFI
float rawMFI = ta.mfi(hlc3, mfiLen)
float smoothedMFI = ta.ema(rawMFI, mfiSmooth)
This is the starting point of the indicator.
The script first calculates the standard Money Flow Index from hlc3 using the selected MFI length. Then it applies an EMA smoothing pass to create a softer reference line.
The raw MFI is used for all pivot detection, clustering, invalidation, zone interaction, and alerts. The smoothed MFI is mainly a visual aid that helps the user see the broader oscillator path more clearly.
So the indicator always builds its logic from raw MFI structure while also giving the user a smoother secondary guide.
2) Defining the Cluster Object
type MFICluster
float top
float bottom
float center
bool isOB
int touches
int firstBarTime
int lastTouchTime
int firstBarIdx
bool isValid
bool isDisplayed
box zoneBox
line centerLine
label infoLabel
This object stores the full lifecycle of one MFI cluster zone.
It contains:
the zone top,
the zone bottom,
the center level,
whether the zone came from an upper pivot or lower pivot,
how many touches it has,
when it first formed,
when it was last touched,
whether it is still valid,
whether it has already been drawn,
and its visual objects.
So the script is not just plotting shapes. It is managing structured oscillator zones that have state, memory, and display properties.
3) Calculating the Adaptive Proximity Threshold
float mfiStd = ta.stdev(rawMFI, 50)
float proximity = math.max(2.0, mfiStd * proxMult)
This is the sensitivity engine of the clustering logic.
The script measures the standard deviation of raw MFI over the last fifty bars. It then multiplies that volatility measure by the user selected proximity multiplier. Finally, it enforces a minimum threshold of 2.0.
This means a new pivot is considered close enough to an existing cluster only if it lies within a volatility adjusted distance from the cluster center.
So the zone grouping automatically adapts to how noisy or how compressed the MFI environment currently is.
4) Detecting Confirmed MFI Pivot Highs and Lows
float mfiPH = ta.pivothigh(rawMFI, pivotLeft, pivotRight)
float mfiPL = ta.pivotlow(rawMFI, pivotLeft, pivotRight)
This is the pivot discovery step.
The script finds confirmed pivot highs and pivot lows directly on the raw MFI series. A pivot high becomes an upper type candidate cluster. A pivot low becomes a lower type candidate cluster.
Because the pivots are confirmed using both left and right bars, the script avoids reacting too early to temporary oscillator wiggles.
So all clustering logic is based on confirmed structure rather than live unconfirmed turns.
5) Checking Whether a Pivot Belongs to an Existing Cluster
method checkProximity(MFICluster this, float pivotVal, bool isOB, float threshold) =>
bool result = false
if this.isOB == isOB and this.isValid
if math.abs(pivotVal - this.center) <= threshold
result := true
result
This method decides whether a new pivot should strengthen an existing cluster.
A pivot can only join a cluster if:
the cluster is of the same type,
the cluster is still valid,
and the distance between the pivot value and the cluster center is less than or equal to the current threshold.
This is important because upper pivot highs are never mixed with lower pivot lows, and stale invalidated clusters are ignored.
So this method is the actual grouping filter that turns repeated nearby pivots into one shared zone.
6) Adding a New Touch to a Cluster
method addTouch(MFICluster this, float pivotVal, int pTime, bool shouldExpand) =>
this.touches += 1
this.lastTouchTime := pTime
if shouldExpand
if pivotVal > this.top
this.top := pivotVal
if pivotVal < this.bottom
this.bottom := pivotVal
this.center := (this.top + this.bottom) / 2.0
int(na)
Once a pivot is assigned to a cluster, this method updates the cluster state.
The touch count is incremented and the last touch time is refreshed. If zone expansion is enabled, the script also checks whether the new pivot extends above the current top or below the current bottom. If it does, the cluster boundaries are widened and the center is recalculated.
So clusters do not have to remain frozen. They can evolve as new oscillator reactions appear.
7) Creating a New Cluster When No Match Exists
if not wasClustered
float zoneHalf = math.max(proximity * 0.15, 0.8)
float zTop = pVal + zoneHalf
float zBot = pVal - zoneHalf
MFICluster newCl = MFICluster.new(
top = zTop,
bottom = zBot,
center = pVal,
isOB = isOB,
touches = 1,
firstBarTime = pTime,
lastTouchTime= pTime,
firstBarIdx = pBarIdx,
isValid = true,
isDisplayed = false)
If the new pivot does not belong to any existing valid cluster, the script creates a fresh cluster.
The initial zone width is determined from the current proximity threshold. Specifically, the script takes fifteen percent of that threshold and applies it equally above and below the pivot center, while enforcing a minimum half size of 0.8.
So every new cluster begins as a compact seed zone around one confirmed pivot and can later grow through repeated touches.
8) Minimum Touch Display Rule
if this.touches >= minT
This is the first major visual gate inside the drawing logic.
A cluster is not drawn just because it exists internally. It becomes visible only when its touch count reaches the user selected minimum touches threshold.
This helps reduce noise by hiding weak single touch or low confidence zones until repeated oscillator interaction has been proven.
So display is based on structural repetition, not just first occurrence.
9) Zone Strength and Opacity Calculation
f_calcOpacity(int touches, int baseOp) =>
float strength = math.min((touches - 1) / 8.0, 1.0)
int result = int(baseOp + (strength * 15))
math.min(result, 40)
This function converts touch count into visual intensity.
The script measures strength from the number of touches relative to a capped scale. Then it adds that strength bonus to the base opacity setting, while also imposing an upper limit.
This means zones with more touches appear slightly stronger and easier to notice than weaker zones.
So touch count influences not only logic, but also visual emphasis.
10) Zone Color Selection
f_zoneColor(float center) =>
center >= 70 ? obColor : center <= 30 ? osColor : midColor
This is the color classification rule.
If the cluster center is at or above 70, the zone uses the overbought color.
If the cluster center is at or below 30, the zone uses the oversold color.
Anything in between uses the mid color.
This is important because a cluster may come from an upper or lower pivot, but its actual center still determines how extreme its oscillator location really is.
So the visual color reflects where the cluster sits inside the MFI range.
11) Drawing the Zone Box
this.zoneBox := box.new(
left=this.firstBarTime, top=this.top, right=time, bottom=this.bottom,
border_color=borderCol, border_width=bWidth, bgcolor=fillCol,
xloc=xloc.bar_time)
Once the cluster qualifies for display, the script draws a box from the first touch time to the current bar time, with the cluster’s top and bottom as boundaries.
So the zone is not a single point marker. It becomes a persistent horizontal oscillator region that extends over time.
This makes the MFI structure much easier to interpret as a live area rather than isolated pivot dots.
12) Drawing the Optional Center Line
if drawCenter
this.centerLine := line.new(
x1=this.firstBarTime, y1=this.center, x2=time, y2=this.center,
color=color.new(baseCol, zoneOpacity - 5), style=line.style_dotted,
width=1, xloc=xloc.bar_time)
If enabled, the script also draws a center line through the middle of the cluster.
This gives the user a clean reference for the average reaction level inside the zone, which can be useful when the zone expands and becomes wider over time.
So the center line acts like an equilibrium guide inside the cluster.
13) Drawing the Info Label
string typeStr = this.isOB ? "OB" : "OS"
string lblText = typeStr + " · " + str.tostring(math.round(this.center, 1)) + " | ×" + str.tostring(this.touches)
this.infoLabel := label.new(
x=time, y=this.isOB ? this.top : this.bottom,
text=lblText, textcolor=textCol,
style=label.style_none, size=f_labelSize(lSize),
xloc=xloc.bar_time, textalign=text.align_right)
The label contains three pieces of information:
the cluster type,
the approximate center level,
and the touch count.
This means a user can immediately see whether the zone is an upper or lower cluster, where it is centered, and how strong it is based on repeated reactions.
So the label turns the zone into an interpretable structural object instead of only a colored band.
14) Updating Existing Displayed Zones
box.set_right(this.zoneBox, time)
box.set_bgcolor(this.zoneBox, fillCol)
box.set_border_color(this.zoneBox, borderCol)
box.set_border_width(this.zoneBox, bWidth)
box.set_top(this.zoneBox, this.top)
box.set_bottom(this.zoneBox, this.bottom)
Once a zone is already displayed and still valid, the script updates it on every bar.
It extends the right edge to the latest time, refreshes the fill and border styling, and updates the top and bottom in case the zone expanded after new touches.
So visible zones remain live and adaptive rather than remaining frozen in their original shape.
15) Zone Invalidation Logic
method invalidate(MFICluster this, float mfiVal) =>
bool broken = false
if this.isOB
if mfiVal > this.top + 2
broken := true
else
if mfiVal < this.bottom - 2
broken := true
if broken
this.isValid := false
broken
This method decides when a cluster has failed.
For upper type clusters, invalidation occurs if MFI pushes clearly above the zone top by more than two MFI points.
For lower type clusters, invalidation occurs if MFI falls clearly below the zone bottom by more than two MFI points.
This extra buffer is important because it avoids invalidating zones on tiny marginal touches.
So the script requires a decisive break beyond the zone before it stops treating that cluster as active structure.
16) Visual Handling of Invalidated Zones
else
box.set_bgcolor(this.zoneBox, color.new(baseCol, math.max(zoneOpacity + 20, 95)))
box.set_border_color(this.zoneBox, color.new(baseCol, math.max(zoneOpacity + 20, 95)))
if not na(this.centerLine)
line.set_style(this.centerLine, line.style_dashed)
line.set_color(this.centerLine, color.new(baseCol, 80))
When a cluster becomes invalid, the script does not delete it immediately. Instead, it fades the zone heavily and softens the center line.
This allows the user to keep the historical context of where the zone existed while also clearly seeing that it is no longer considered valid.
So invalidated zones remain on the pane as context, but not as active structure.
17) Detecting Whether MFI Is Inside an Active Cluster
if cl.isValid and cl.touches >= minTouches
if cl.isOB and rawMFI >= cl.bottom and rawMFI <= cl.top + 5
inOBZone := true
if not cl.isOB and rawMFI <= cl.top and rawMFI >= cl.bottom - 5
inOSZone := true
This block checks whether the current raw MFI value has entered a valid displayed cluster zone.
For upper clusters, the script allows a small tolerance above the zone.
For lower clusters, it allows a small tolerance below the zone.
This produces the conditions used by the entry alerts. So the alerts are not tied merely to MFI crossing 80 or 20. They can also trigger when MFI enters historically clustered oscillator reaction areas.
18) Dashboard Metrics
int obZoneCount = 0
int osZoneCount = 0
int strongMax = 0
float nearOB = na
float nearOS = na
if cl.touches > strongMax
strongMax := cl.touches
if cl.touches >= minTouches
if cl.center >= 70
obZoneCount += 1
else if cl.center <= 30
osZoneCount += 1
The dashboard summarizes the live structure.
It counts how many active displayed zones are centered in overbought and oversold territory, finds the highest touch count among all clusters, and tracks the nearest upper and lower cluster centers relative to current MFI.
So the dashboard gives a quick structural overview without requiring the user to visually inspect every zone one by one.
19) MFI State Classification for the Dashboard
string mfiState = rawMFI >= 80 ? "OVERBOUGHT" : rawMFI <= 20 ? "OVERSOLD" : rawMFI >= 50 ? "BULLISH" : "BEARISH"
This line classifies the current oscillator state into four broad conditions.
At or above 80 is treated as overbought.
At or below 20 is treated as oversold.
Between 50 and 80 is treated as bullish.
Between 20 and 50 is treated as bearish.
This gives the dashboard an easy to read directional context in addition to the cluster statistics.
20) Alert Conditions
alertcondition(inOBZone, title="MFI Entered OB Cluster Zone", message="Cluster MFI: Price entered an overbought cluster zone — watch for reversal")
alertcondition(inOSZone, title="MFI Entered OS Cluster Zone", message="Cluster MFI: Price entered an oversold cluster zone — watch for reversal")
alertcondition(ta.crossover(rawMFI, 80), title="MFI Crossed Above 80", message="Cluster MFI: MFI crossed above 80 — overbought territory")
alertcondition(ta.crossunder(rawMFI, 20), title="MFI Crossed Below 20", message="Cluster MFI: MFI crossed below 20 — oversold territory")
The script provides four alert types.
Two alerts are structural cluster alerts:
entering an upper cluster,
and entering a lower cluster.
Two alerts are classic threshold alerts:
crossing above 80,
and crossing below 20.
So the user can monitor both traditional MFI extremes and the more advanced cluster based structure. Indicator
Market Time Cycle (Machine Learning: K-Means Clustering)🕰️Market Time Cycle (Machine Learning: K-Means Clustering)
▶️Overview
The Market Time Cycle Oscillator is a sophisticated predictive analysis tool designed to decode the "temporal DNA" of financial markets. While conventional oscillators (like RSI or Stochastics) measure price momentum and overbought/oversold levels, this indicator focuses on the Time Domain .
It identifies recurring intervals between market pivots to estimate the mathematical probability of the next reversal point.
By leveraging K-Means Clustering, it doesn't just look for a single cycle but identifies multiple dominant frequencies simultaneously, providing a probabilistic "heat map" for future Pivot Highs and Pivot Lows.
▶️Technical Core: The K-Means Advantage
1. From Rigid Cycles to Dynamic Clusters
Traditional cycle analysis (like Fourier Transforms) often struggles with "noise" and the non-stationary nature of market data. Market cycles are rarely fixed; they expand and contract.
This indicator uses K-Means Clustering, an unsupervised machine learning algorithm, to solve this:
Observation: It measures the bar-index distance between historical pivots.
Clustering: Instead of averaging these distances, K-Means groups them into K distinct clusters (centroids).
Result: It can identify, for example, a short-term 20-bar cycle and a mid-term 60-bar cycle existing at the same time, without them cancelling each other out.
2. Gaussian Probability Waves
Once the dominant cycle lengths (centroids) are identified, the engine doesn't just plot a single line at a fixed future date. It recognizes that "history rhymes but doesn't repeat perfectly."
Mathematical Projection: Each cycle is projected forward from the most recent pivots.
Gaussian Distribution: A Normal (Gaussian) distribution curve is applied to each projection. The peak represents the most likely timing, while the "wings" represent the statistical margin of error.
Aggregation: All probability waves are summed to create the final "Total Probability" cloud seen on the oscillator.
▶️The Bipolar Logic: A Dual-Force Perspective
The indicator is split into two halves to provide a clear view of opposing market forces:
Positive Side (Upper Cloud): Summation of probabilities for a Pivot High. When this cloud peaks, the market is entering a "Time Window" where price historically finds a ceiling and begins to move downward.
Negative Side (Lower Cloud): Summation of probabilities for a Pivot Low. A peak here indicates a high statistical likelihood of a market floor and an upward reversal.
▶️Key Features
ML-Driven Adaptability: The engine retrains its K-Means centroids every time a new pivot is confirmed, allowing it to adapt to "Cycle Compression" or "Cycle Expansion" in real-time.
Multi-Layered Analysis: It distinguishes between "Standard" (trend-aligned) and "Inverse" (counter-trend) patterns, capturing the nuances of complex market structures.
Visibility Scaling: The intensity of the clouds dynamically adjusts based on the current price's position within its recent range, highlighting setups that have both time and price confluence.
Optimized Performance: Features a high-speed caching logic that limits heavy ML calculations to pivot confirmation events, ensuring a lag-free experience even on high-frequency charts.
▶️Settings Explained
Pivot Settings (Left/Right): Determines the "strength" of the pivots used for training. Higher values focus on major macro cycles; lower values focus on micro noise.
Number of Clusters (K): How many different "Cycle Identities" the machine should find. Usually, 2 or 3 is optimal for capturing both short and medium terms.
Distribution Width (Sigma): Controls the "Focus." A lower Sigma makes the peaks very sharp (precise timing), while a higher Sigma provides a broader, safer window.Memory Window: The depth of history used to train the K-Means engine.
Disclaimer
Cycle analysis is a study of mathematical probability. While history provides a map, external fundamental shocks ("Black Swans") can break any cycle. Always utilize rigorous risk management. If you find this ML-based approach valuable, please support the script with a like! Indicator
Structural SVM Ranker [LuxAlgo]The Structural SVM Ranker indicator is a market structure tool that utilizes a linear Support Vector Machine (SVM) algorithm to classify and rank structural breaks based on volume, momentum, and price magnitude. By assigning a score from 0 to 100 to every Break of Structure (BOS) and Change of Character (CHoCH), it aims to help traders differentiate between high-conviction structural shifts and low-probability price action.
🔶 USAGE
The indicator identifies key pivot highs and lows to map out the market structure. When price closes beyond these levels, a structural break is identified and assigned a score based on the quality of the move.
BOS (Break of Structure): Represented by solid lines, these indicate a continuation of the current local trend.
CHoCH (Change of Character): Represented by dashed lines, these indicate a potential reversal in the trend direction.
SVM Score: Displayed on labels and the dashboard. A higher score suggests the break occurred with significant relative volume, strong RSI momentum, and a meaningful price distance beyond the pivot level.
Traders can use the SVM score to filter trade quality. For example, a "CHoCH" with a score above 70 indicates a high-conviction reversal backed by volume and momentum, whereas a score below 30 might suggest a "fakeout" or a weak structural shift.
🔶 DETAILS
The core of the script is a linear classification logic inspired by Support Vector Machines. It takes three primary features into account to determine the "strength" of a break:
Relative Volume: Compares current volume to its 20-period average to ensure the break is supported by market participation.
RSI Momentum: Measures the distance of the RSI from its midpoint (50) to confirm trend strength.
Break Distance: Measures how far the price closed beyond the structural level, normalized by the Average True Range (ATR).
These features are multiplied by user-defined weights and then passed through a Sigmoid function to produce a normalized score between 0 and 100.
🔶 SETTINGS
🔹 Market Structure
Pivot Lookback: Determines the number of bars required to confirm a pivot high or low.
Show BOS/CHoCH: Toggles the visibility of structural break lines and labels.
🔹 SVM Ranking Parameters
Relative Volume Weight: Adjusts the influence of volume on the final score.
RSI Momentum Weight: Adjusts the influence of RSI deviation from 50 on the final score.
Break Distance Weight: Adjusts the influence of the price distance beyond the pivot (relative to ATR).
ATR Length: The period used for the ATR normalization of the break distance.
🔹 Dashboard
Dashboard: Toggles the visibility of the real-time ranking table.
Position: Moves the dashboard to different corners of the chart (Top Right, Bottom Right, Bottom Left).
Size: Adjusts the scale of the dashboard text.
Indicator
Hidden Markov Model: Baum-Welch [UAlgo]Hidden Markov Model: Baum-Welch is a regime detection and reversal signaling indicator that applies a 3 state Hidden Markov Model to normalized log returns and continuously adapts its parameters using an online Baum Welch expectation maximization routine. The script is designed to classify the market into three latent regimes, then express that classification as real time probabilities for Bull, Range, and Bear conditions.
The indicator runs in its own pane ( overlay=false ) and outputs:
Probability curves for the three regimes
A dominant regime score scaled to 0 to 1
A regime strip visualization for quick bias reading
Adaptive background coloring based on the dominant regime and confidence
Optional regime shift markers
Optional buy and sell reversal markers driven by strict multi condition logic
The core idea is that price behavior can be modeled as transitions between hidden states that each have their own return distribution. The script fits a Gaussian emission model for each state, estimates state transition probabilities, and updates the posterior probability of each state on every bar. It retrains the full model at fixed intervals, while using a faster one step forward update between retrains for efficiency.
This implementation is not a simple threshold oscillator. It is a full mini HMM engine built in Pine with:
Scaled forward and backward algorithms
Expectation step producing gamma and xi posteriors
Maximization step updating initial distribution, transition matrix, state means, and state variances
Safeguards such as variance floors and transition floors to maintain numerical stability
The output is a regime aware probability system that can be used for bias, context, and reversal confirmation rather than simple entry signals.
Educational tool only. Not financial advice.
🔹 Features
🔸 1) Three State Hidden Markov Model Regime Engine
The model uses three hidden states and continuously estimates the probability of being in each state:
Bull regime
Range regime
Bear regime
This gives a probabilistic regime map rather than a single hard classification.
🔸 2) Baum Welch Training with Scheduled Retraining
The script retrains its parameters using an EM routine at a user defined interval in bars. Each retrain runs a configurable number of EM iterations. Between retrains, the indicator performs a one step forward Bayesian update of the posterior state probabilities.
This structure balances adaptability with performance.
🔸 3) Normalized Log Return Observations
The observation series is a z score normalized log return:
Log returns convert price changes into additive units
An EMA and rolling standard deviation normalize the series to stabilize the HMM fit
This helps the HMM learn regimes based on relative return behavior rather than raw price scale.
🔸 4) Automatic Bull, Range, and Bear Role Assignment
The model learns state means. The script then assigns roles by ranking those learned means:
The state with the lowest mean becomes the Bear state
The state with the highest mean becomes the Bull state
The remaining state is treated as Range
This keeps regime labeling consistent even as the internal state ordering shifts during training.
🔸 5) Probabilities and Dominant Regime Visualization
The script plots:
Bull probability curve
Range probability curve
Bear probability curve
It also plots an area for the dominant probability and a regime strip that makes it easy to see the dominant regime quickly without reading the full curves.
🔸 6) Regime Score Line (Bull minus Bear)
A continuous score is calculated as Bull probability minus Bear probability, then scaled to a 0 to 1 range. This score becomes the main regime momentum signal used for rebound and reversal logic.
🔸 7) Adaptive Background Coloring by Regime and Confidence
The pane background color changes based on the dominant regime. Transparency adapts according to confidence, so strong regime certainty produces a more visible background while low certainty remains subtle.
🔸 8) Strict Signal Filters for Bias and Reversal
The indicator provides bias filters:
Bull bias when Bull probability and confidence exceed thresholds and the dominant regime is Bull
Bear bias when Bear probability and confidence exceed thresholds and the dominant regime is Bear
It also provides reversal style buy and sell signals based on a multi condition framework described in the calculations section.
🔸 9) Reversal Logic Combining Extremes, Rebounds, and Transition Edge
Reversal signals are not generated by a single crossover. The script requires:
An extreme score pivot
An extreme regime probability at that pivot
A rebound trigger through predefined rebound levels
A minimum probability and confidence filter
A transition asymmetry and edge condition that favors switching toward the target regime
A momentum condition requiring Bull probability rising and Bear probability falling for buys, and the inverse for sells
A time window limit so reversals must occur within a limited number of bars after the extreme
This creates a high selectivity reversal engine.
🔸 10) Transition Matrix Insight and Switch Edge Metrics
The script computes predicted transition probabilities toward Bull and Bear using the current posterior and the transition matrix. It also measures transition asymmetry between Bull to Bear and Bear to Bull and uses these values as part of reversal confirmation.
This adds structural information that classic oscillators do not capture.
🔸 11) Anti Duplicate Reversal Signals
Once a pivot extreme has been used to generate a reversal signal, it is marked as consumed so the same pivot cannot repeatedly trigger additional buy or sell signals. This helps avoid signal repetition.
🔸 12) Full Informational Label Output
A live info label prints:
Current regime
Current signal text
Confidence
Bull, Range, Bear probabilities
Log likelihood
Key trigger thresholds
Reversal settings and edge settings
This provides transparency into what the model is currently seeing and why signals are or are not appearing.
🔹 Calculations
1) Observation Series: Normalized Log Returns
The script uses log returns:
logRet = math.log(close / nz(close , close))
Then normalizes them with an EMA mean and rolling standard deviation:
retMean = nz(ta.ema(logRet, normLength), 0.0)
retStd = math.max(nz(ta.stdev(logRet, normLength), 0.0), 1e-6)
obs = (logRet - retMean) / retStd
This creates an observation series with more stable scale properties across time.
2) Rolling Observation Window
The HMM is trained on a rolling window of length windowLen . Only the most recent processRecentBars are processed to control load:
startBar = last_bar_index - processRecentBars
activeRange = bar_index >= (startBar < 0 ? 0 : startBar)
If active, the observation is appended and the oldest one is removed:
if array.size(obsWindow) < windowLen
array.push(obsWindow, obs)
else
array.shift(obsWindow)
array.push(obsWindow, obs)
The model is ready only when the window is full.
3) Model Initialization
The script initializes a 3 state model with:
Uniform initial state probabilities
A transition matrix seeded with high persistence and equal small jump probabilities
State means initialized around zero with a configured separation
State variances initialized to a configured starting value
Key logic:
Stay probability equals initialPersistence
Jump probability equals the remaining probability split across other states
This gives the HMM a stable starting point before training.
4) Emission Model: Gaussian per State
Each state emits observations using a Gaussian density:
math.exp(-0.5 * d * d / varS) / math.sqrt(TWO_PI * varS)
Variance uses a floor:
float varS = math.max(array.get(this.vr, s), varMin)
This prevents variance collapse and numeric instability.
5) Forward Algorithm with Scaling
The script computes the forward probabilities alpha and applies scaling coefficients c to prevent underflow. It then recovers log likelihood from the scaling coefficients:
this.logLik := -sum(log(c ))
This is essential because HMM sequences quickly underflow without scaling.
6) Backward Algorithm with Scaling
The backward probabilities beta are computed using the scaling values from the forward pass, ensuring alpha and beta remain numerically stable across the entire window.
7) Expectation Step: Gamma and Xi
Gamma represents posterior probability of being in state i at time t . Xi represents posterior probability of transitioning from i to j between t and t+1 .
Xi is normalized per time step:
xij = xi_raw / denom
Gamma is computed as the sum of xi across outgoing transitions for each state:
gamma(t, i) = sum_j xi(t, i, j)
8) Maximization Step: Updating Parameters
Initial probabilities update from gamma at time 0:
pi = gamma(0, i)
Transition probabilities update from xi sums divided by gamma sums, with a transition floor and row normalization:
Each transition is clamped to transitionFloor
Each row is normalized to sum to 1
Means update as weighted averages of observations using gamma weights.
Variances update as weighted squared deviation sums with a variance floor.
9) Retraining Schedule and Online Updates
The model retrains when:
It is not initialized yet
Or the bar index matches the retrain interval
shouldRetrain = ready and (not modelInitialized or bar_index % retrainEveryBars == 0)
On retrain, Baum Welch is run for emIterations .
Between retrains, the script performs a one step forward update of the posterior:
hmm.forwardOne(posterior, obs, varianceFloor, posteriorTmp)
This provides continuous posterior updates without full retraining on every bar.
10) Role Mapping to Bull, Range, Bear
The script assigns which internal state corresponds to Bear and Bull by looking at the learned means:
Bear state is the state with the minimum mean
Bull state is the state with the maximum mean
Range is the remaining state index
This mapping updates dynamically as the model learns.
11) Regime Score and Confidence
The regime score is:
score = pBull - pBear
It is then scaled to 0 to 1:
score01 = 0.5 + 0.5 * score
Confidence is:
confidence = max(pBull, pRange, pBear)
This confidence drives background alpha and signal gating.
12) Probability Filters for Bias
Bull filter requires:
Bull probability above bullProbTrigger
Confidence above signalConfidenceMin
Bear filter requires similar conditions for Bear probability.
Bias validity adds the requirement that the dominant regime role matches the direction:
Bull bias requires dominantRole equals 1
Bear bias requires dominantRole equals minus 1
13) Extreme Pivot Logic for Reversal Candidates
The script looks for pivots in the score line:
ta.pivotlow(score01, pivotStrength, 1)
ta.pivothigh(score01, pivotStrength, 1)
It stores the most recent pivot low and pivot high along with the associated Bull or Bear probability at the pivot bar.
A low extreme is valid if:
Score at pivot is below dipScoreLevel
Bear probability at pivot exceeds extremeProbMin
A high extreme is valid if:
Score at pivot is above topScoreLevel
Bull probability at pivot exceeds extremeProbMin
14) Rebound Triggers
After an extreme, the script waits for rebound triggers:
Up rebound:
ta.crossover(score01, reboundUpLevel)
Down rebound:
ta.crossunder(score01, reboundDownLevel)
Rebound must occur within the reversal window bars from the extreme pivot.
15) Transition Edge and Asymmetry Logic
The script computes predicted probabilities of switching toward Bull or Bear using the transition matrix and current posterior. It also computes transition asymmetry between the Bull to Bear and Bear to Bull transitions.
A bullish switch condition requires:
Switch edge greater than hmmEdgeMin
Transition asymmetry favoring Bear to Bull at or above transitionAsymMin
Bull probability greater than Bear probability
A bearish switch condition uses the mirrored logic.
This adds a model based confirmation that a regime switch is plausible, not only that the score bounced.
16) Momentum Confirmation
Bull momentum requires:
Bull probability rising
Bear probability falling
Bear momentum requires the opposite.
These conditions prevent signals when probabilities are flat or conflicting.
17) Final Reversal Signal Construction
Buy reversal requires:
Valid low extreme
Not consumed
Inside reversal window
Rebound up
Bull probability and confidence filter
Bullish HMM switch condition
Bull momentum
Sell reversal requires the mirrored set of conditions.
The sell is suppressed if a buy is simultaneously true so conflicting signals do not print on the same bar.
18) Visualization Output
The script plots:
Probability curves for each regime
A dominant probability area
A thick score line colored by regime
A regime strip column plot
Fills between Bull and Bear curves and between rebound levels
Adaptive background
Optional markers for regime shifts
Reversal markers as glow plus label style plots
The info label consolidates the most important current state and threshold data for transparency. Indicator
Machine Learning PSAR [BOSWaves]Machine Learning PSAR - Adaptive Parabolic Stop and Reverse with K-Means Regime Detection and KNN Signal Validation
Overview
Machine Learning PSAR is a regime-aware trend reversal system that tracks directional price movement through an adaptive Parabolic SAR, where acceleration parameters dynamically adjust based on market regime classification and each reversal signal is validated against historically similar setups using a K-Nearest Neighbors scoring model.
Instead of relying on fixed acceleration factors or unfiltered SAR flips, trend state, parameter scaling, and signal confidence are determined through K-Means flip-frequency clustering, KNN outcome weighting, and Kalman-filtered output smoothing that maintains visual clarity without sacrificing reversal responsiveness.
This creates a SAR system that reflects actual market conditions rather than applying the same parameters regardless of context - tightening in trending environments where acceleration should build quickly, relaxing in choppy conditions where early flips are noise, and scoring every reversal against the historical record so confidence is quantified rather than assumed.
Price is therefore evaluated relative to a SAR that adapts to regime dynamics and historically validated reversal patterns rather than conventional fixed-parameter parabolic logic.
Conceptual Framework
Machine Learning PSAR is founded on the principle that meaningful reversal signals emerge when the SAR acceleration factor is calibrated to current market conditions, and when each flip is cross-referenced against similar historical flips to assess its probability of success.
Traditional PSAR implementations use fixed start, increment, and maximum AF values that ignore whether the market is trending or ranging. This framework replaces static acceleration logic with regime-driven parameter adaptation informed by flip frequency clustering, then layers a KNN validation pass on top to score each signal before it is presented.
Three core principles guide the design:
Acceleration factor behavior should adapt to the detected market regime, becoming more aggressive during trending conditions and more conservative during choppy ones.
Every SAR flip should be scored against historically similar setups so confidence is expressed as a quantified probability rather than a binary signal.
The displayed SAR line should be smooth enough for clean visual interpretation while remaining responsive enough that reversals are never delayed.
This shifts SAR analysis from a fixed-parameter trailing stop into an adaptive, regime-anchored reversal system with integrated signal confidence measurement.
Theoretical Foundation
The indicator combines classical Parabolic SAR logic, K-Means-inspired regime classification, K-Nearest Neighbors outcome scoring, exponential AF smoothing, and Kalman filter output processing.
Flip frequency over a configurable training period provides the feature for regime classification, with centroid distances determining whether the market is trending, neutral, or choppy. KNN validation uses a five-dimensional feature vector at each flip — prior trend duration, bars since last flip, AF at flip, flip frequency, and EP progress — to find the most similar historical flips and weight their outcomes by proximity. The Kalman filter then smooths the final SAR output while snapping to new values instantly on every reversal.
Four internal systems operate in tandem:
Adaptive PSAR Engine : Computes classical parabolic SAR with optional AF smoothing and minimum bars filter to suppress whipsaw flips.
K-Means Regime Classifier : Measures flip frequency relative to its historical range, assigns the current bar to the nearest of three regime centroids, and adjusts AF start, increment, and maximum accordingly.
KNN Signal Validator : On each flip, searches historical flips for the k most similar setups by Euclidean distance, computes an inverse-distance-weighted confidence score, and filters low-confidence signals from high-confidence alerts.
Kalman Smoothing Layer : Applies a recursive Kalman filter to the SAR output for display, balancing smoothness with responsiveness and resetting on every reversal so flips are never visually delayed.
This design allows reversal signals to reflect actual market behavior and historical precedent rather than reacting mechanically to fixed acceleration rules.
How It Works
Machine Learning PSAR evaluates price through a sequence of regime-aware and historically-validated processes:
PSAR Initialization : Classical parabolic SAR begins with base AF start value, tracking EP and advancing the stop in the trend direction.
AF Smoothing : Instead of stepping AF in discrete increments, exponential smoothing ramps it gradually toward the target, producing a more fluid SAR trajectory.
Minimum Bars Filter : Trend must persist for a configurable minimum number of bars before a flip is allowed, preventing immediate whipsaw reversals.
Flip Detection : Price crossing the SAR triggers a raw flip, resetting AF, capturing the new EP, and recording trend duration and context features.
Flip Frequency Measurement : Rolling count of flips over the training period, normalized to its historical range, provides the regime classification feature.
Regime Assignment : Flip frequency is compared against three percentile-anchored centroids; the nearest centroid determines whether the market is choppy, neutral, or trending.
Parameter Adaptation : Regime assignment scales AF start, increment, and maximum — reducing them in choppy conditions to slow the SAR, increasing them in trending conditions to accelerate it.
KNN Feature Construction : At each flip, a five-dimensional vector is built from current context and compared against all historical flips of the same direction within the lookback window.
Neighbor Scoring : The k closest historical flips by Euclidean distance are retrieved; each is weighted by inverse distance and its five-bar forward outcome determines a weighted success rate.
Confidence Assignment : Weighted success rate expressed as a 0–100% confidence score, with flips below the minimum threshold classified as low-confidence.
Kalman Filtering : SAR value is passed through a Kalman filter for display smoothing, with process and measurement noise configurable; filter snaps to new SAR position on every flip.
Confidence Fill : Fill opacity between SAR and price anchor reflects current confidence score — denser fill indicates higher conviction in the active trend.
Together, these elements form a continuously updating reversal framework anchored in regime awareness and historically validated signal quality.
Interpretation
Machine Learning PSAR should be interpreted as a confidence-weighted trend reversal system with regime-adaptive sensitivity:
Bullish State (Blue) : Established when price closes above the SAR after a validated bullish flip, with SAR acting as a dynamic trailing support level below price.
Bearish State (Red) : Established when price closes below the SAR after a validated bearish flip, with SAR acting as a dynamic trailing resistance level above price.
Confidence Fill : Gradient zone between SAR and price reflects KNN confidence — vivid, dense fill indicates high historical precedent for the current flip; faint fill indicates low confidence.
Confidence Score Labels : Percentage label at each flip displays the KNN confidence score. Green (70%+) indicates strong historical backing; orange (50–69%) indicates moderate backing; red (below 50%) indicates low historical support.
Regime Labels : Numbers displayed alongside the SAR indicate current market regime — 3 for trending, 2 for neutral, 1 for choppy — reflecting the K-Means classifier output in real time.
High-Confidence Flips : Flips meeting or exceeding the minimum confidence threshold trigger alerts and represent the primary actionable signals.
Low-Confidence Flips : Flips below the confidence threshold are still displayed but excluded from high-confidence alerts, flagging setups with weak historical precedent.
Regime classification, KNN confidence, and Kalman-smoothed SAR position together outweigh any isolated price movement against the stop.
Signal Logic & Visual Cues
Machine Learning PSAR presents two primary signal categories:
High-Confidence Flip : SAR reversal with KNN score at or above the minimum confidence threshold. These represent setups where historically similar conditions produced successful reversals at a statistically meaningful rate and form the basis for alert-driven systematic monitoring.
Low-Confidence Flip : SAR reversal with KNN score below the minimum confidence threshold. The signal is displayed for awareness but is not included in high-confidence alert conditions, reflecting limited historical precedent.
Regime labels provide continuous market context between flips, allowing real-time awareness of whether the K-Means system is operating in a trending, neutral, or choppy environment. Confidence fill intensity provides a passive, non-disruptive view of trend conviction without requiring active label reading.
Alert generation covers high-confidence bullish and bearish flips, separately triggerable 70%+ confidence signals, and regime transition events for systematic monitoring of market state changes.
Strategy Integration
Machine Learning PSAR fits within adaptive trend-following and signal-quality-filtered reversal approaches:
Confidence-Gated Entries : Enter reversals only on high-confidence flips, using the minimum confidence threshold as a quality gate that filters historically weak setups.
Regime-Aware Sizing : Increase position sizing during trending regime (label 3) where the K-Means system detects low flip frequency and sustained directional conviction.
Choppy Market Avoidance : Reduce or pause activity during choppy regime (label 1) where frequent flips indicate low directional conviction and elevated whipsaw risk.
SAR as Stop Placement : Use the Kalman-smoothed SAR as a trailing stop reference — exit longs when price closes below the bullish SAR, exit shorts when price closes above the bearish SAR.
Confidence Fill Monitoring : Use fill intensity as a passive conviction gauge — fading fill during an active trend may indicate the next flip is likely to be lower confidence.
Multi-Timeframe Regime Alignment : Apply higher-timeframe regime label as a directional filter, entering signals only when the regime aligns across timeframes.
Alert-Based Systematic Monitoring : Configure high-confidence and regime-change alerts for systematic notification without requiring active chart monitoring.
Technical Implementation Details
Core Engine : Classical Parabolic SAR with configurable base AF start, increment, and maximum, optional exponential AF smoothing, and minimum bars flip filter
Regime Model : Flip frequency normalized to training-period range with three percentile-anchored centroids (choppy, neutral, trending) and nearest-centroid assignment
KNN Validator : Five-dimensional feature vector with configurable k and lookback, inverse-distance weighting, and five-bar forward outcome labeling
Smoothing Layer : Kalman filter with configurable process and measurement noise, hard snap to SAR on every flip to preserve reversal timing
Visualization : Dual-plot SAR circles with confidence-opacity fill, percentage confidence labels, every-other-bar regime labels
Signal Logic : High/low confidence classification with configurable minimum threshold, raw flip detection decoupled from display
Performance Profile : Optimized for real-time execution across all timeframes with efficient array-based KNN search and FIFO distance sorting
Optimal Application Parameters
Timeframe Guidance:
1 - 5 min : Scalping with tighter AF values, shorter KNN lookback, and lower minimum confidence threshold
15 - 60 min : Intraday trend following with balanced regime sensitivity and moderate confidence filtering
4H - Daily : Swing and position trading with wider AF maximum, longer training period, and higher confidence threshold
Suggested Baseline Configuration:
Base AF Start : 0.02
Base AF Increment : 0.02
Base AF Maximum : 0.10
Training Data Period : 100
Choppy Regime Percentile : 0.75
Trending Regime Percentile : 0.25
K - Number of Neighbors : 8
Historical Lookback Period : 200
Minimum Confidence Filter : 15%
AF Smoothing Factor : 0.01
Kalman Process Noise : 0.015
Kalman Measurement Noise : 0.5
Minimum Bars Before Flip : 3
These suggested parameters should be used as a baseline; their effectiveness depends on the asset's volatility profile, trending characteristics, and preferred signal frequency, so fine-tuning is expected for optimal performance.
Parameter Calibration Notes
Use the following adjustments to refine behavior without altering the core logic:
Too many flips in ranging markets : Increase Minimum Bars Before Flip to require longer trend duration before a reversal is allowed, or increase Base AF Maximum to widen the SAR distance.
SAR too slow to reverse : Decrease Base AF Start and increase Base AF Increment so the acceleration factor builds more quickly during new trends.
Excessive low-confidence signals : Increase Minimum Confidence Filter to raise the threshold for high-confidence classification, focusing only on the strongest historical precedents.
KNN scores feel unstable : Increase K - Number of Neighbors to average over more historical examples, smoothing out per-flip score variance.
Regime changing too rapidly : Increase Training Data Period to smooth regime classification over a longer flip-frequency history.
Regime too slow to update : Decrease Training Data Period for more responsive regime detection that reacts faster to market character shifts.
SAR line too jumpy visually : Increase Kalman Measurement Noise for more aggressive smoothing, or decrease Kalman Process Noise to make the filter trust its own estimate more.
Kalman lagging reversals : Decrease Kalman Measurement Noise or increase Kalman Process Noise to make the filter more responsive to SAR changes between flips.
AF ramping too abruptly : Decrease AF Smoothing Factor toward 0.01 for a more gradual exponential ramp from start to target AF on each new trend.
Adjustments should be incremental and evaluated across multiple market sessions rather than isolated conditions.
Performance Characteristics
High Effectiveness:
Trending markets with sustained directional conviction where flip frequency remains low and regime classification stabilizes at label 3
Instruments with consistent volatility where ATR-normalized KNN features generalize well across historical flips
Momentum continuation strategies using SAR as a trailing stop with confidence-filtered entries at reversals
Systematic approaches benefiting from quantified signal confidence and regime-based parameter adaptation
Multi-timeframe frameworks where regime labels provide higher-timeframe directional context for lower-timeframe entries
Reduced Effectiveness:
Choppy, range-bound markets with high flip frequency causing frequent low-confidence signals and regime label 1 classification
Extremely thin historical data environments where the KNN lookback contains insufficient comparable flips for reliable scoring
News-driven or gapped markets where discrete price discontinuities bypass SAR logic and invalidate ATR-normalized tension features
Very low volatility instruments where ATR scaling compresses feature vectors and reduces KNN discriminative power
Consolidation phases where mean-reversion dominance causes repeated SAR whipsaws regardless of minimum bars filtering
Integration Guidelines
Confluence : Combine with BOSWaves volume analysis, structure detection, or supply and demand zone identification for multi-factor confirmation
SAR Respect : Honor the trailing SAR as the primary risk boundary — avoid holding positions against the active stop regardless of confidence score
Confidence Awareness : Treat confidence scores as probabilistic context, not certainty — high scores improve odds but do not guarantee outcome
Regime Discipline : Reduce activity during persistent choppy regime classification rather than fighting repeated low-confidence flips
Alert Utilization : Configure high-confidence and regime-change alerts to enable systematic monitoring without requiring active chart observation
Lookback Sufficiency : Ensure sufficient historical bars are loaded for the KNN lookback period before relying on confidence scores, particularly on shorter timeframes
Multi-Timeframe Alignment : Use higher timeframe regime label and trend direction as a filter for lower timeframe flip entries to ensure directional confluence
Disclaimer
Machine Learning PSAR is a professional-grade adaptive reversal and trend-following tool. It uses K-Means regime classification and KNN signal validation to adapt classical Parabolic SAR behavior to current market conditions but does not predict future price movements. Results depend on market conditions, volatility characteristics, parameter selection, and disciplined execution. BOSWaves recommends deploying this indicator within a broader analytical framework that incorporates price structure, volume context, and comprehensive risk management. Indicator
