Random Forest AI - RSI MACD Confluence [Dots3Red]█ RANDOM FOREST AI — RSI MACD CONFLUENCE
This script combines 15 simple, independent decision rules ("trees") into one weighted verdict. Each tree looks at a different combination of RSI, MACD, ATR, volume, DMI, and price-vs-moving-average conditions and casts one vote: bullish, bearish, or neutral. What makes this different from simply averaging several indicators is that every tree's historical accuracy is tracked continuously, and that accuracy becomes the tree's voting weight — a rule that has actually been right more often on this specific chart counts for more than one that hasn't.
█ WHY THIS APPROACH
A single indicator like RSI applies the same fixed rule forever: "below 30 means buy," regardless of whether that rule has been working lately on the instrument you're watching. It has no way to notice that its own signal has become less reliable in a strong trend, or more reliable during a ranging period.
This script addresses that by running many small, simple rules in parallel and grading each one against what actually happened afterward. A rule's influence on the final verdict rises when it's been accurate and falls when it hasn't — without requiring the trader to manually decide which indicator to trust in current conditions.
This is a simplified, Pine-native ensemble. A literal machine-learning Random Forest trains via recursive data-splitting across bootstrap-sampled datasets, which isn't something Pine Script's execution model supports. What's implemented here captures the core idea in a form that runs natively on every bar: multiple diverse, simple voters, weighted by empirical track record rather than by a fixed formula.
█ HOW IT WORKS
1. Base features
Six indicators are computed every bar and feed into the trees:
• RSI (configurable length)
• MACD histogram
• ATR ratio — current ATR relative to a 50-bar baseline (volatility context)
• Volume ratio — current volume relative to its moving average
• DI difference — +DI minus -DI from the DMI system (directional pressure)
• Price vs. moving average — distance from a trend MA, expressed in ATR units
2. The 15 trees
Each tree is a short, explicit rule combining two or three of the base features. They are deliberately varied in character:
• Some are trend-following (DI direction, MACD momentum, full trend confluence combining three features at once)
• Some are contrarian / mean-reversion (an extreme price extension combined with an extreme RSI reading votes for a pullback, not a continuation)
• Some are volatility-filtered (an RSI extreme only counts when the ATR ratio shows calm conditions, on the reasoning that overbought/oversold readings are less reliable during high volatility)
• Some require multi-indicator confluence before voting at all (MACD direction agreeing with volume expansion, or RSI agreeing with MACD)
Any single tree by itself is simplistic. The value comes from having 15 of them looking at the situation from different angles simultaneously.
3. Historical grading and weighting
Every tree's vote from a configurable number of bars ago ("Outcome Window") is compared against what price actually did between then and now. If the tree voted bullish and price rose, that's a correct call; if it voted bullish and price fell, that's incorrect. A running hit/total count is kept per tree.
Each tree's weight is its accuracy rate (hits ÷ total) once it has accumulated a minimum number of graded votes. Before that minimum is reached, a tree counts at a neutral 0.5 weight so early, unproven trees don't disproportionately swing the verdict.
4. The forest verdict
Bullish and bearish contributions are summed across all 15 trees, weighted by each tree's current accuracy, then expressed as a percentage split (e.g. 73% bullish / 27% bearish). The overall verdict — BULLISH, BEARISH, or NEUTRAL — is determined by configurable thresholds (default: 60% for bullish, below 40% bullish-share for bearish).
5. RSI confluence
Separately from its role inside the 15 trees, RSI's classic overbought/oversold state is checked against the forest's overall verdict. If RSI is oversold and the forest is bullish, that's flagged as "AGREE." If RSI is oversold but the forest is bearish, that's flagged as "CONFLICT." This gives a second, independent read using the indicator most traders already know, alongside the ensemble's own conclusion.
█ SIGNAL MARKERS AND SPACING
A marker appears only when three conditions line up at once: the forest's weighted verdict crosses its threshold, RSI's classic overbought/oversold state independently agrees with that direction, and the bar has fully closed. Markers never appear on a still-forming bar — the script waits for bar confirmation so a marker never appears and then vanishes as the live bar changes.
Each marker is drawn in two parts: a small triangle at the bar, and a text block showing three values — the weighted percentage that triggered it, the word AGREE confirming RSI's independent agreement, and how many of the 15 trees were actively voting (non-neutral) at that moment. A reading of "73% / AGREE / 9/15 trees" carries different weight than "61% / AGREE / 4/15 trees," even though both pass the threshold — the first reflects broad participation across the ensemble, the second a thin majority among few active voters.
Two mechanisms prevent marker clutter on intraday timeframes:
• One marker per episode — when the verdict enters a bullish or bearish state, only the first qualifying signal of that run is marked. The verdict flickering around the threshold (61% → 59% → 62%) does not produce repeated markers; the internal latch resets only when the verdict genuinely changes state.
• Signal Cooldown — a configurable minimum number of bars between same-side markers, which absorbs the remaining case where a brief state change resets the latch and the condition re-triggers shortly after. On a 5-minute chart, a cooldown of 30 bars means at least 2.5 hours between same-direction markers.
Both mechanisms apply per direction — a bearish marker shortly after a bullish one is never suppressed, because an ensemble flip is meaningful information rather than clutter.
█ READING THE CHART
Bar coloring tints candles by the current verdict — cyan for bullish, magenta for bearish, slate for neutral.
Dashboard (top-right by default) shows the current verdict, the bull/bear percentage split with a progress bar, how many trees are actively voting, RSI's state and its agreement with the verdict, and a breakdown of five representative trees showing each one's live weight and how many samples that weight is based on.
█ SETTINGS
Feature Settings — lengths for RSI, MACD, ATR baseline, volume MA, DMI, and the trend MA used by the price-vs-MA feature.
Ensemble Settings
• Outcome Window (bars) — how far ahead each vote is checked against actual price movement
• Min Samples Before Weighting — how many graded votes a tree needs before its real accuracy replaces the neutral 0.5 default
• Bullish / Bearish Threshold % — where the weighted percentage split has to cross before the verdict label changes
Visualization
• Color Bars by Verdict — toggle candle tinting
• Show Confluence Markers — toggle the triangle markers
• Signal Cooldown (bars) — minimum bars between same-side markers; raise this on lower timeframes if markers feel too frequent
Dashboard — toggle the table, choose its position, toggle the per-tree accuracy breakdown.
█ EXAMPLE
Suppose the dashboard shows: Verdict BULLISH, 73% / 27%, 9/15 trees active, RSI at 28 (OVERSOLD), Agreement: AGREE. This means the weighted vote across all 15 trees currently favors upside by roughly 3-to-1, nine of the trees have a non-neutral opinion right now, and the classic RSI reading independently supports the same bullish read. If the per-tree breakdown shows "Calm-Market RSI" at 78% (n=45) while "RSI Extremes" sits at 52% (n=45), that's telling you the version of the RSI rule that only fires during low volatility has actually been considerably more reliable on this chart than the raw, unfiltered version — information a plain RSI plot could never surface on its own.
█ NOTES
Weights start neutral and only become meaningful once each tree has accumulated enough graded votes (set by "Min Samples Before Weighting"). On a fresh chart or a newly added timeframe, expect the dashboard's percentages to be less informative until that history builds up. The ensemble adapts continuously — a tree's weight can and will drift as market conditions change and its track record evolves.
On intraday timeframes, tune the Signal Cooldown to the chart's pace. The default suits higher timeframes; 5-minute and 15-minute charts generally benefit from a larger value.
█ DISCLAIMER
This is an analytical and visualization tool. It does not generate trade signals and does not constitute financial advice. Historical accuracy of any individual rule or the ensemble as a whole does not guarantee future performance. Indicator
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
Liquidity Maxing [JOAT]Liquidity Maxing - Institutional Liquidity Matrix
Introduction
Liquidity Maxing is an open-source strategy for PulseWire built around institutional market structure concepts. It identifies structural shifts, evaluates trades through multi-factor confluence, and implements layered risk controls.
The strategy is designed for swing trading on 4-hour timeframes, focusing on how institutional order flow manifests in price action through structure breaks, inducements, and liquidity sweeps.
Core Functionality
Liquidity Maxing performs three primary functions:
Tracks market structure to identify when control shifts between buyers and sellers
Scores potential trades using an eight-factor confluence system
Manages position sizing and risk exposure dynamically based on volatility and user-defined limits
The goal is selective trading when multiple conditions align, rather than frequent entries.
Market Structure Engine
The structure engine tracks three key events:
Break of Structure (BOS): Price pushes beyond a prior pivot in the direction of trend
Change of Character (CHoCH): Control flips from bullish to bearish or vice versa
Inducement Sweeps (IDM): Market briefly runs stops against trend before moving in the real direction
The structure module continuously updates strong highs and lows, labeling structural shifts visually. IDM markers are optional and disabled by default to maintain chart clarity.
The trade engine requires valid structure alignment before considering entries. No structure, no trade.
Eight-Factor Confluence System
Instead of relying on a single indicator, Liquidity Maxing uses an eight-factor scoring system:
Structure alignment with current trend
RSI within healthy bands (different ranges for up and down trends)
MACD momentum agreement with direction
Volume above adaptive baseline
Price relative to main trend EMA
Session and weekend filter (configurable)
Volatility expansion/contraction via ATR shifts
Higher-timeframe EMA confirmation
Each factor contributes one point to the confluence score. The default minimum confluence threshold is 6 out of 8, but you can adjust this from 1-8 based on your preference for trade frequency versus selectivity.
Only when structure and confluence agree does the strategy proceed to risk evaluation.
Dynamic Risk Management
Risk controls are implemented in multiple layers:
ATR-based stops and targets with configurable risk-to-reward ratio (default 2:1)
Volatility-adjusted position sizing to maintain consistent risk per trade as ranges expand or compress
Daily and weekly risk budgets that halt new entries once thresholds are reached
Correlation cooldown to prevent clustered trades in the same direction
Global circuit breaker with maximum drawdown limit and emergency kill switch
If any guardrail is breached, the strategy will not open new positions. The dashboard clearly displays risk state for transparency.
Market Presets
The strategy includes configuration presets optimized for different market types:
Crypto (BTC/ETH): RSI bands 70/30, volume multiplier 1.2, enhanced ATR scaling
Forex Majors: RSI bands 75/25, volume multiplier 1.5
Indices (SPY/QQQ): RSI bands 70/30, volume multiplier 1.3
Custom: Default values for user customization
For crypto assets, the strategy automatically applies ATR volatility scaling to account for higher volatility characteristics.
Monitoring and Dashboards
The strategy includes optional monitoring layers:
Risk Operations Dashboard (top-right):
Trend state
Confluence score
ATR value
Current position size percentage
Global drawdown
Daily and weekly risk consumption
Correlation guard state
Alert mode status
Performance Console (top-left):
Net profit
Current equity
Win rate percentage
Average trade value
Sharpe-style ratio (rolling 50-bar window)
Profit factor
Open trade count
Optional risk tint on chart background provides visual indication of "safe to trade" versus "halted" state.
All visualization elements can be toggled on/off from the inputs for clean chart viewing or full telemetry during parameter tuning.
Alerts and Automation
The strategy supports alert integration with two formats:
Standard alerts: Human-readable messages for long, short, and risk-halt conditions
Webhook format: JSON-formatted payloads ready for external execution systems (optional)
Alert messages are predictable and unambiguous, suitable for manual review or automated forwarding to execution engines.
Built-in Validation Suite
The strategy includes an optional validation layer that can be enabled from inputs. It checks:
Internal consistency of structure and confluence metrics
Sanity and ordering of risk parameters
Position sizing compliance with user-defined floors and caps
This validation is optional and not required for trading, but provides transparency into system operation during development or troubleshooting.
Strategy Parameters
Market Presets:
Configuration Preset: Choose between Crypto (BTC/ETH), Forex Majors, Indices (SPY/QQQ), or Custom
Market Structure Architecture:
Pivot Length: Default 5 bars
Filter by Inducement (IDM): Default enabled
Visualize Structure: Default enabled
Structure Lookback: Default 50 bars
Risk & Capital Preservation:
Risk:Reward Ratio: Default 2.0
ATR Period: Default 14
ATR Multiplier (Stop): Default 2.0
Max Drawdown Circuit Breaker: Default 10%
Risk per Trade (% Equity): Default 1.5%
Daily Risk Limit: Default 6%
Weekly Risk Limit: Default 12%
Min Position Size (% Equity): Default 0.25%
Max Position Size (% Equity): Default 5%
Correlation Cooldown (bars): Default 3
Emergency Kill Switch: Default disabled
Signal Confluence:
RSI Length: Default 14
Trend EMA: Default 200
HTF Confirmation TF: Default Daily
Allow Weekend Trading: Default enabled
Minimum Confluence Score (0-8): Default 6
Backtesting Considerations
When backtesting this strategy, consider the following:
Commission: Default 0.05% (adjustable in strategy settings)
Initial Capital: Default $100,000 (adjustable)
Position Sizing: Uses percentage of equity (default 2% per trade)
Timeframe: Optimized for 4-hour charts, though can be tested on other timeframes
Results will vary significantly based on:
Market conditions and volatility regimes
Parameter settings, especially confluence threshold
Risk limit configuration
Symbol characteristics (crypto vs forex vs equities)
Past performance does not guarantee future results. Win rate, profit factor, and other metrics should be evaluated in context of drawdown periods, trade frequency, and market conditions.
How to Use This Strategy
This is a framework that requires understanding and parameter tuning, not a one-size-fits-all solution.
Recommended workflow:
Start on 4-hour timeframe with default parameters and appropriate market preset
Run backtests and study performance console metrics: focus on drawdown behavior, win rate, profit factor, and trade frequency
Adjust confluence threshold to match your risk appetite—higher thresholds mean fewer but more selective trades
Set realistic daily and weekly risk budgets appropriate for your account size and risk tolerance
Consider ATR multiplier adjustments based on market volatility characteristics
Only connect alerts or automation after thorough testing and parameter validation
Treat this as a risk framework with an integrated entry engine, not merely an entry signal generator. The risk controls are as important as the trade signals.
Strategy Limitations
Designed for swing trading timeframes; may not perform optimally on very short timeframes
Requires sufficient market structure to identify pivots; may struggle in choppy or low-volatility environments
Crypto markets require different parameter tuning than traditional markets
Risk limits may prevent entries during favorable setups if daily/weekly budgets are exhausted
Correlation cooldown may delay entries that would otherwise be valid
Backtesting results depend on data quality and may not reflect live trading with slippage
Design Philosophy
Many indicators tell you when price crossed a moving average or RSI left oversold. This strategy addresses questions institutional traders ask:
Who is in control of the market right now?
Is this move structurally significant or just noise?
Do I want to add more risk given what I've already done today/week?
If I'm wrong, exactly how painful can this be?
The strategy provides disciplined, repeatable answers to these questions through systematic structure analysis, confluence filtering, and multi-layer risk management.
Technical Implementation
The strategy uses Pine Script v6 with:
Custom types for structure, confluence, and risk state management
Functional programming approach for reusable calculations
State management through persistent variables
Optional visual elements that can be toggled independently
The code is open-source and can be modified to suit individual needs. All important logic is visible in the source code.
Disclaimer
This script is provided for educational and informational purposes only. It is not intended as financial, investment, trading, or any other type of advice or recommendation. Trading involves substantial risk of loss and is not suitable for all investors. Past performance, whether real or indicated by historical tests of strategies, is not indicative of future results.
No representation is being made that any account will or is likely to achieve profits or losses similar to those shown. In fact, there are frequently sharp differences between backtested results and actual results subsequently achieved by any particular trading strategy.
The user should be aware of the risks involved in trading and should trade only with risk capital. The authors and publishers of this script are not responsible for any losses or damages, including without limitation, any loss of profit, which may arise directly or indirectly from use of or reliance on this script.
This strategy uses technical analysis methods and indicators that are not guaranteed to be accurate or profitable. Market conditions change, and strategies that worked in the past may not work in the future. Users should thoroughly test any strategy in a paper trading environment before risking real capital.
Commission and slippage settings in backtests may not accurately reflect live trading conditions. Real trading results will vary based on execution quality, market liquidity, and other factors not captured in backtesting.
The user assumes full responsibility for all trading decisions made using this script. Always consult with a qualified financial advisor before making investment decisions.
Enjoy - officialjackofalltrades Strategy
FVG Maxing - Fair Value Gaps, Equilibrium, and Candle Patterns
What this script does
This open-source indicator highlights 3-candle fair value gaps (FVGs) on the active chart timeframe, draws their midpoint ("equilibrium") line, tracks when each gap is mitigated, and optionally marks simple candle patterns (engulfing and doji) for confluence. It is intended as an educational tool to study how price interacts with imbalances.
3-candle bullish and bearish FVG zones drawn as forward-extending boxes.
Equilibrium line at 50% of each gap.
Different styling for mitigated vs unmitigated gaps.
Compact statistics panel showing how many gaps are currently active and filled.
Optional overlays for bullish/bearish engulfing patterns and doji candles.
1. FVG logic (3-candle gaps)
The script focuses on a strict 3-candle definition of a fair value gap:
Three consecutive candles with the same body direction.
The wick of candle 3 is separated from the wick of candle 1 (no overlap).
A bullish gap is created when price moves up fast enough to leave a gap between candle 1 and 3. A bearish gap is the mirror case to the downside.
In Pine, the core detection looks like this:
// Three candles with the same body direction
bull_seq = close > open and close > open and close > open
bear_seq = close < open and close < open and close < open
// Wick gap between candle 1 and candle 3
bull_gap = bull_seq and low > high
bear_gap = bear_seq and high < low
// Final FVG flags
is_bull_fvg = bull_gap
is_bear_fvg = bear_gap
For each detected FVG:
Bullish FVG range: from high up to low (gap below current price).
Bearish FVG range: from low down to high (gap above current price).
Each zone is stored in a custom FVGData structure so it can be updated when price later trades back inside it.
2. Equilibrium line (0.5 of the gap)
Every FVG box gets an optional equilibrium line plotted at the midpoint between its top and bottom:
eq_level = (top + bottom) / 2.0
right_index = extend_boxes ? bar_index + extend_length_bars : bar_index
bx = box.new(bar_index - 2, top, right_index, bottom)
eq_ln = line.new(bar_index - 2, eq_level, right_index, eq_level)
line.set_style(eq_ln, line.style_dashed)
line.set_color(eq_ln, eq_color)
You can use this line as a neutral “fair value” reference inside the zone, or as a simple way to think in terms of premium/discount within each gap.
3. Mitigation rules and styling
Each FVG stays active until price trades back into the gap:
Bullish FVG is considered mitigated when the low touches or moves below the top of the gap.
Bearish FVG is considered mitigated when the high touches or moves above the bottom of the gap.
When that happens, the script:
Marks the internal FVGData entry as mitigated.
Softens the box fill and border colors.
Optionally updates the label text from "BULL EQ / BEAR EQ" to "BULL FILLED / BEAR FILLED".
Can hide mitigated zones almost completely if you only want to see unfilled imbalances.
This allows you to distinguish between current areas of interest and zones that have already been traded through.
4. Candle pattern overlays (engulfing and doji)
For additional confluence, the script can mark simple candle patterns on top of the FVG view:
Bullish engulfing — current candle body fully wraps the previous bearish body and is larger in size.
Bearish engulfing — current candle body fully wraps the previous bullish body and is larger in size.
Doji — candles where the real body is small relative to the full range (high–low).
The detection is based on basic body and range geometry:
curr_body = math.abs(close - open)
prev_body = math.abs(close - open )
curr_range = high - low
body_ratio = curr_range > 0 ? curr_body / curr_range : 1.0
bull_engulfing = close > open and close < open and open <= close and close >= open and curr_body > prev_body
bear_engulfing = close < open and close > open and open >= close and close <= open and curr_body > prev_body
is_doji = curr_range > 0 and body_ratio <= doji_body_ratio
On the chart, they appear as:
Small triangle markers below bullish engulfing candles.
Small triangle markers above bearish engulfing candles.
Small circles above doji candles.
All three overlays are optional and can be turned on or off and recolored in the CANDLE PATTERNS group of inputs.
5. Inputs overview
The script organizes settings into clear groups:
DISPLAY SETTINGS : Show bullish/bearish FVGs, show/hide mitigated zones, box extension length, box border width, and maximum number of boxes.
EQUILIBRIUM : Toggle equilibrium lines, color, and line width.
LABELS : Enable labels, choose whether to label unmitigated and/or mitigated zones, and select label size.
BULLISH COLORS / BEARISH COLORS : Separate fill and border colors for bullish and bearish gaps.
MITIGATED STYLE : Opacity used when a gap is marked as mitigated.
STATISTICS : Toggle the on-chart FVG statistics panel.
CANDLE PATTERNS : Show engulfing patterns, show dojis, colors, and the body-to-range threshold that defines a doji.
6. Statistics panel
An optional table in the corner of the chart summarizes the current state of all tracked gaps:
Total number of FVGs still being tracked.
Number of bullish vs bearish FVGs.
Number of unfilled vs mitigated FVGs.
Simple fill rate: percentage of tracked FVGs that have been marked as mitigated.
This can help you study how a particular market tends to treat gaps over time.
7. How you might use it (examples)
These are usage ideas only, not recommendations:
Study how often your symbol mitigates gaps and where inside the zone price tends to react.
Use higher-timeframe context and then refine entries near the equilibrium line on your trading timeframe.
Combine FVG zones with basic candle patterns (engulfing/doji) as an extra visual anchor, if that fits your process.
Hope you enjoy, give your feedback in the comments!
- officialjackofalltrades
Indicator
Indicator
Machine Learning Support and Resistance [AlgoAlpha]🚀 Elevate Your Trading with Machine Learning Dynamic Support and Resistance!
The Machine Learning Dynamic Support and Resistance by AlgoAlpha leverages advanced machine learning techniques to identify dynamic support and resistance levels on your chart. This tool is designed to help traders spot key price levels where the market might reverse or stall, enhancing your trading strategy with precise, data-driven insights.
Key Features:
🎯 Dynamic Levels: Continuously adjusts support and resistance levels based on real-time price data using a K-means clustering algorithm.
🧠 Machine Learning: Utilizes clustering methods to optimize the identification of significant price zones.
⏳ Configurable Lookback Periods: Customize the training length and confirmation length for better adaptability to different market conditions.
🎨 Visual Clarity: Clearly distinguish bullish and bearish zones with customizable color schemes.
📉 Trailing and Fixed Levels: Option to display both trailing and fixed support/resistance levels for comprehensive analysis.
🚮 Auto-Cleaning: Automatically removes outdated levels after a specified number of bars to keep your chart clean and relevant.
Quick Guide to Using the Machine Learning Dynamic Support and Resistance Indicator
Maximize your trading with this powerful indicator by following these streamlined steps! 🚀✨
🛠 Add the Indicator: Add the indicator to favorites by pressing the star icon. Customize settings like clustering training length, confirmation length, and whether to show trailing or fixed levels to fit your trading style.
📊 Market Analysis: Monitor the dynamic levels to identify potential reversal points. Use these levels to inform entry and exit points, or to set stop losses.
How It Works
This indicator employs a K-means clustering algorithm to dynamically identify key price levels based on the historical price data within a specified lookback window. It starts by initializing three centroids based on the highest, lowest, and an average between the highest and lowest price over the lookback period. The algorithm then iterates through the price data to cluster the prices around these centroids, dynamically adjusting them until they stabilize, representing potential support and resistance levels. These levels are further confirmed based on a separate confirmation length parameter to identify "fixed" levels, which are then drawn as horizontal lines on the chart. The script continuously updates these levels as new data comes in, while also removing older levels to keep the chart clean and relevant, offering traders a clear and adaptive view of market structure. Indicator
Correlation Clusters [LuxAlgo]The Correlation Clusters is a machine learning tool that allows traders to group sets of tickers with a similar correlation coefficient to a user-set reference ticker.
The tool calculates the correlation coefficients between 10 user-set tickers and a user-set reference ticker, with the possibility of forming up to 10 clusters.
🔶 USAGE
Applying clustering methods to correlation analysis allows traders to quickly identify which set of tickers are correlated with a reference ticker, rather than having to look at them one by one or using a more tedious approach such as correlation matrices.
Tickers belonging to a cluster may also be more likely to have a higher mutual correlation. The image above shows the detailed parts of the Correlation Clusters tool.
The correlation coefficient between two assets allows traders to see how these assets behave in relation to each other. It can take values between +1.0 and -1.0 with the following meaning
Value near +1.0: Both assets behave in a similar way, moving up or down at the same time
Value close to 0.0: No correlation, both assets behave independently
Value near -1.0: Both assets have opposite behavior when one moves up the other moves down, and vice versa
There is a wide range of trading strategies that make use of correlation coefficients between assets, some examples are:
Pair Trading: Traders may wish to take advantage of divergences in the price movements of highly positively correlated assets; even highly positively correlated assets do not always move in the same direction; when assets with a correlation close to +1.0 diverge in their behavior, traders may see this as an opportunity to buy one and sell the other in the expectation that the assets will return to the likely same price behavior.
Sector rotation: Traders may want to favor some sectors that are expected to perform in the next cycle, tracking the correlation between different sectors and between the sector and the overall market.
Diversification: Traders can aim to have a diversified portfolio of uncorrelated assets. From a risk management perspective, it is useful to know the correlation between the assets in your portfolio, if you hold equal positions in positively correlated assets, your risk is tilted in the same direction, so if the assets move against you, your risk is doubled. You can avoid this increased risk by choosing uncorrelated assets so that they move independently.
Hedging: Traders may want to hedge positions with correlated assets, from a hedging perspective, if you are long an asset, you can hedge going long a negatively correlated asset or going short a positively correlated asset.
Grouping different assets with similar behavior can be very helpful to traders to avoid over-exposure to those assets, traders may have multiple long positions on different assets as a way of minimizing overall risk when in reality if those assets are part of the same cluster traders are maximizing their risk by taking positions on assets with the same behavior.
As a rule of thumb, a trader can minimize risk via diversification by taking positions on assets with no correlations, the proposed tool can effectively show a set of uncorrelated candidates from the reference ticker if one or more clusters centroids are located near 0.
🔶 DETAILS
K-means clustering is a popular machine-learning algorithm that finds observations in a data set that are similar to each other and places them in a group.
The process starts by randomly assigning each data point to an initial group and calculating the centroid for each. A centroid is the center of the group. K-means clustering forms the groups in such a way that the variances between the data points and the centroid of the cluster are minimized.
It's an unsupervised method because it starts without labels and then forms and labels groups itself.
🔹 Execution Window
In the image above we can see how different execution windows provide different correlation coefficients, informing traders of the different behavior of the same assets over different time periods.
Users can filter the data used to calculate correlations by number of bars, by time, or not at all, using all available data. For example, if the chart timeframe is 15m, traders may want to know how different assets behave over the last 7 days (one week), or for an hourly chart set an execution window of one month, or one year for a daily chart. The default setting is to use data from the last 50 bars.
🔹 Clusters
On this graph, we can see different clusters for the same data. The clusters are identified by different colors and the dotted lines show the centroids of each cluster.
Traders can select up to 10 clusters, however, do note that selecting 10 clusters can lead to only 4 or 5 returned clusters, this is caused by the machine learning algorithm not detecting any more data points deviating from already detected clusters.
Traders can fine-tune the algorithm by changing the 'Cluster Threshold' and 'Max Iterations' settings, but if you are not familiar with them we advise you not to change these settings, the defaults can work fine for the application of this tool.
🔹 Correlations
Different correlations mean different behaviors respecting the same asset, as we can see in the chart above.
All correlations are found against the same asset, traders can use the chart ticker or manually set one of their choices from the settings panel. Then they can select the 10 tickers to be used to find the correlation coefficients, which can be useful to analyze how different types of assets behave against the same asset.
🔶 SETTINGS
Execution Window Mode: Choose how the tool collects data, filter data by number of bars, time, or no filtering at all, using all available data.
Execute on Last X Bars: Number of bars for data collection when the 'Bars' execution window mode is active.
Execute on Last: Time window for data collection when the `Time` execution window mode is active. These are full periods, so `Day` means the last 24 hours, `Week` means the last 7 days, and so on.
🔹 Clusters
Number of Clusters: Number of clusters to detect up to 10. Only clusters with data points are displayed.
Cluster Threshold: Number used to compare a new centroid within the same cluster. The lower the number, the more accurate the centroid will be.
Max Iterations: Maximum number of calculations to detect a cluster. A high value may lead to a timeout runtime error (loop takes too long).
🔹 Ticker of Reference
Use Chart Ticker as Reference: Enable/disable the use of the current chart ticker to get the correlation against all other tickers selected by the user.
Custom Ticker: Custom ticker to get the correlation against all the other tickers selected by the user.
🔹 Correlation Tickers
Select the 10 tickers for which you wish to obtain the correlation against the reference ticker.
🔹 Style
Text Size: Select the size of the text to be displayed.
Display Size: Select the size of the correlation chart to be displayed, up to 500 bars.
Box Height: Select the height of the boxes to be displayed. A high height will cause overlapping if the boxes are close together.
Clusters Colors: Choose a custom colour for each cluster.
Indicator
Machine Learning Adaptive SuperTrend [AlgoAlpha]📈🤖 Machine Learning Adaptive SuperTrend - Take Your Trading to the Next Level! 🚀✨
Introducing the Machine Learning Adaptive SuperTrend , an advanced trading indicator designed to adapt to market volatility dynamically using machine learning techniques. This indicator employs k-means clustering to categorize market volatility into high, medium, and low levels, enhancing the traditional SuperTrend strategy. Perfect for traders who want an edge in identifying trend shifts and market conditions.
What is K-Means Clustering and How It Works
K-means clustering is a machine learning algorithm that partitions data into distinct groups based on similarity. In this indicator, the algorithm analyzes ATR (Average True Range) values to classify volatility into three clusters: high, medium, and low. The algorithm iterates to optimize the centroids of these clusters, ensuring accurate volatility classification.
Key Features
🎨 Customizable Appearance: Adjust colors for bullish and bearish trends.
🔧 Flexible Settings: Configure ATR length, SuperTrend factor, and initial volatility guesses.
📊 Volatility Classification: Uses k-means clustering to adapt to market conditions.
📈 Dynamic SuperTrend Calculation: Applies the classified volatility level to the SuperTrend calculation.
🔔 Alerts: Set alerts for trend shifts and volatility changes.
📋 Data Table Display: View cluster details and current volatility on the chart.
Quick Guide to Using the Machine Learning Adaptive SuperTrend Indicator
🛠 Add the Indicator: Add the indicator to favorites by pressing the star icon. Customize settings like ATR length, SuperTrend factor, and volatility percentiles to fit your trading style.
📊 Market Analysis: Observe the color changes and SuperTrend line for trend reversals. Use the data table to monitor volatility clusters.
🔔 Alerts: Enable notifications for trend shifts and volatility changes to seize trading opportunities without constant chart monitoring.
How It Works
The indicator begins by calculating the ATR values over a specified training period to assess market volatility. Initial guesses for high, medium, and low volatility percentiles are inputted. The k-means clustering algorithm then iterates to classify the ATR values into three clusters. This classification helps in determining the appropriate volatility level to apply to the SuperTrend calculation. As the market evolves, the indicator dynamically adjusts, providing real-time trend and volatility insights. The indicator also incorporates a data table displaying cluster centroids, sizes, and the current volatility level, aiding traders in making informed decisions.
Add the Machine Learning Adaptive SuperTrend to your PulseWire charts today and experience a smarter way to trade! 🌟📊 Indicator
AI SuperTrend x Pivot Percentile - Strategy [PresentTrading]█ Introduction and How it is Different
The AI SuperTrend x Pivot Percentile strategy is a sophisticated trading approach that integrates AI-driven analysis with traditional technical indicators. Combining the AI SuperTrend with the Pivot Percentile strategy highlights several key advantages:
1. Enhanced Accuracy in Trend Prediction: The AI SuperTrend utilizes K-Nearest Neighbors (KNN) algorithm for trend prediction, improving accuracy by considering historical data patterns. This is complemented by the Pivot Percentile analysis which provides additional context on trend strength.
2. Comprehensive Market Analysis: The integration offers a multi-faceted approach to market analysis, combining AI insights with traditional technical indicators. This dual approach captures a broader range of market dynamics.
BTC 6H L/S Performance
Local
█ Strategy: How it Works - Detailed Explanation
🔶 AI-Enhanced SuperTrend Indicators
1. SuperTrend Calculation:
- The SuperTrend indicator is calculated using a moving average and the Average True Range (ATR). The basic formula is:
- Upper Band = Moving Average + (Multiplier × ATR)
- Lower Band = Moving Average - (Multiplier × ATR)
- The moving average type (SMA, EMA, WMA, RMA, VWMA) and the length of the moving average and ATR are adjustable parameters.
- The direction of the trend is determined based on the position of the closing price in relation to these bands.
2. AI Integration with K-Nearest Neighbors (KNN):
- The KNN algorithm is applied to predict trend direction. It uses historical price data and SuperTrend values to classify the current trend as bullish or bearish.
- The algorithm calculates the 'distance' between the current data point and historical points. The 'k' nearest data points (neighbors) are identified based on this distance.
- A weighted average of these neighbors' trends (bullish or bearish) is calculated to predict the current trend.
For more please check: Multi-TF AI SuperTrend with ADX - Strategy
🔶 Pivot Percentile Analysis
1. Percentile Calculation:
- This involves calculating the percentile ranks for high and low prices over a set of predefined lengths.
- The percentile function is typically defined as:
- Percentile = Value at (P/100) × (N + 1)th position
- Where P is the desired percentile, and N is the number of data points.
2. Trend Strength Evaluation:
- The calculated percentiles for highs and lows are used to determine the strength of bullish and bearish trends.
- For instance, a high percentile rank in the high prices may indicate a strong bullish trend, and vice versa for bearish trends.
For more please check: Pivot Percentile Trend - Strategy
🔶 Strategy Integration
1. Combining SuperTrend and Pivot Percentile:
- The strategy synthesizes the insights from both AI-enhanced SuperTrend and Pivot Percentile analysis.
- It compares the trend direction indicated by the SuperTrend with the strength of the trend as suggested by the Pivot Percentile analysis.
2. Signal Generation:
- A trading signal is generated when both the AI-enhanced SuperTrend and the Pivot Percentile analysis agree on the trend direction.
- For instance, a bullish signal is generated when both the SuperTrend is bullish, and the Pivot Percentile analysis shows strength in bullish trends.
🔶 Risk Management and Filters
- ADX and DMI Filter: The strategy uses the Average Directional Index (ADX) and the Directional Movement Index (DMI) as filters to assess the trend's strength and direction.
- Dynamic Trailing Stop Loss: Based on the SuperTrend indicator, the strategy dynamically adjusts stop-loss levels to manage risk effectively.
This strategy stands out for its ability to combine real-time AI analysis with established technical indicators, offering traders a nuanced and responsive tool for navigating complex market conditions. The equations and algorithms involved are pivotal in accurately identifying market trends and potential trade opportunities.
█ Usage
To effectively use this strategy, traders should:
1. Understand the AI and Pivot Percentile Indicators: A clear grasp of how these indicators work will enable traders to make informed decisions.
2. Interpret the Signals Accurately: The strategy provides bullish, bearish, and neutral signals. Traders should align these signals with their market analysis and trading goals.
3. Monitor Market Conditions: Given that this strategy is sensitive to market dynamics, continuous monitoring is crucial for timely decision-making.
4. Adjust Settings as Needed: Traders should feel free to tweak the input parameters to suit their trading preferences and to respond to changing market conditions.
█Default Settings and Their Impact on Performance
1. Trading Direction (Default: "Both")
Effect: Determines whether the strategy will take long positions, short positions, or both. Adjusting this setting can align the strategy with the trader's market outlook or risk preference.
2. AI Settings (Neighbors: 3, Data Points: 24)
Neighbors: The number of nearest neighbors in the KNN algorithm. A higher number might smooth out noise but could miss subtle, recent changes. A lower number makes the model more sensitive to recent data but may increase noise.
Data Points: Defines the amount of historical data considered. More data points provide a broader context but may dilute recent trends' impact.
3. SuperTrend Settings (Length: 10, Factor: 3.0, MA Source: "WMA")
Length: Affects the sensitivity of the SuperTrend indicator. A longer length results in a smoother, less sensitive indicator, ideal for long-term trends.
Factor: Determines the bandwidth of the SuperTrend. A higher factor creates wider bands, capturing larger price movements but potentially missing short-term signals.
MA Source: The type of moving average used (e.g., WMA - Weighted Moving Average). Different MA types can affect the trend indicator's responsiveness and smoothness.
4. AI Trend Prediction Settings (Price Trend: 10, Prediction Trend: 80)
Price Trend and Prediction Trend Lengths: These settings define the lengths of weighted moving averages for price and SuperTrend, impacting the responsiveness and smoothness of the AI's trend predictions.
5. Pivot Percentile Settings (Length: 10)
Length: Influences the calculation of pivot percentiles. A shorter length makes the percentile more responsive to recent price changes, while a longer length offers a broader view of price trends.
6. ADX and DMI Settings (ADX Length: 14, Time Frame: 'D')
ADX Length: Defines the period for the Average Directional Index calculation. A longer period results in a smoother ADX line.
Time Frame: Sets the time frame for the ADX and DMI calculations, affecting the sensitivity to market changes.
7. Commission, Slippage, and Initial Capital
These settings relate to transaction costs and initial investment, directly impacting net profitability and strategy feasibility. Strategy
Multi-TF AI SuperTrend with ADX - Strategy [PresentTrading]
## █ Introduction and How it is Different
The trading strategy in question is an enhanced version of the SuperTrend indicator, combined with AI elements and an ADX filter. It's a multi-timeframe strategy that incorporates two SuperTrends from different timeframes and utilizes a k-nearest neighbors (KNN) algorithm for trend prediction. It's different from traditional SuperTrend indicators because of its AI-based predictive capabilities and the addition of the ADX filter for trend strength.
BTC 8hr Performance
ETH 8hr Performance
## █ Strategy, How it Works: Detailed Explanation (Revised)
### Multi-Timeframe Approach
The strategy leverages the power of multiple timeframes by incorporating two SuperTrend indicators, each calculated on a different timeframe. This multi-timeframe approach provides a holistic view of the market's trend. For example, a 8-hour timeframe might capture the medium-term trend, while a daily timeframe could capture the longer-term trend. When both SuperTrends align, the strategy confirms a more robust trend.
### K-Nearest Neighbors (KNN)
The KNN algorithm is used to classify the direction of the trend based on historical SuperTrend values. It uses weighted voting of the 'k' nearest data points. For each point, it looks at its 'k' closest neighbors and takes a weighted average of their labels to predict the current label. The KNN algorithm is applied separately to each timeframe's SuperTrend data.
### SuperTrend Indicators
Two SuperTrend indicators are used, each from a different timeframe. They are calculated using different moving averages and ATR lengths as per user settings. The SuperTrend values are then smoothed to make them suitable for KNN-based prediction.
### ADX and DMI Filters
The ADX filter is used to eliminate weak trends. Only when the ADX is above 20 and the directional movement index (DMI) confirms the trend direction, does the strategy signal a buy or sell.
### Combining Elements
A trade signal is generated only when both SuperTrends and the ADX filter confirm the trend direction. This multi-timeframe, multi-indicator approach reduces false positives and increases the robustness of the strategy.
By considering multiple timeframes and using machine learning for trend classification, the strategy aims to provide more accurate and reliable trade signals.
BTC 8hr Performance (Zoom-in)
## █ Trade Direction
The strategy allows users to specify the trade direction as 'Long', 'Short', or 'Both'. This is useful for traders who have a specific market bias. For instance, in a bullish market, one might choose to only take 'Long' trades.
## █ Usage
Parameters: Adjust the number of neighbors, data points, and moving averages according to the asset and market conditions.
Trade Direction: Choose your preferred trading direction based on your market outlook.
ADX Filter: Optionally, enable the ADX filter to avoid trading in a sideways market.
Risk Management: Use the trailing stop-loss feature to manage risks.
## █ Default Settings
Neighbors (K): 3
Data points for KNN: 12
SuperTrend Length: 10 and 5 for the two different SuperTrends
ATR Multiplier: 3.0 for both
ADX Length: 21
ADX Time Frame: 240
Default trading direction: Both
By customizing these settings, traders can tailor the strategy to fit various trading styles and assets. Strategy
Machine Learning: Gaussian Process Regression [LuxAlgo]We provide an implementation of the Gaussian Process Regression (GPR), a popular machine-learning method capable of estimating underlying trends in prices as well as forecasting them.
While this implementation is adapted to real-time usage, do remember that forecasting trends in the market is challenging, do not use this tool as a standalone for your trading decisions.
🔶 USAGE
The main goal of our implementation of GPR is to forecast trends. The method is applied to a subset of the most recent prices, with the Training Window determining the size of this subset.
Two user settings controlling the trend estimate are available, Smooth and Sigma . Smooth determines the smoothness of our estimate, with higher values returning smoother results suitable for longer-term trend estimates.
Sigma controls the amplitude of the forecast, with values closer to 0 returning results with a higher amplitude. Do note that due to the calculation of the method, lower values of sigma can return errors with higher values of the training window.
🔹 Updating Mechanisms
The script includes three methods to update a forecast. By default a forecast will not update for new bars (Lock Forecast).
The forecast can be re-estimated once the price reaches the end of the forecasting window when using the "Update Once Reached" method.
Finally "Continuously Update" will update the whole forecast on any new bar.
🔹 Estimating Trends
Gaussian Process Regression can be used to estimate past underlying local trends in the price, allowing for a noise-free interpretation of trends.
This can be useful for performing descriptive analysis, such as highlighting patterns more easily.
🔶 SETTINGS
Training Window: Number of most recent price observations used to fit the model
Forecasting Length: Forecasting horizon, determines how many bars in the future are forecasted.
Smooth: Controls the degree of smoothness of the model fit.
Sigma: Noise variance. Controls the amplitude of the forecast, lower values will make it more sensitive to outliers.
Update: Determines when the forecast is updated, by default the forecast is not updated for new bars.
Indicator
Double AI Super Trend Trading - Strategy [PresentTrading]█ Introduction and How It is Different
The Double AI Super Trend Trading Strategy is a cutting-edge approach that leverages the power of not one, but two AI algorithms, in tandem with the SuperTrend technical indicator. The strategy aims to provide traders with enhanced precision in market entry and exit points. It is designed to adapt to market conditions dynamically, offering the flexibility to trade in both bullish and bearish markets.
*The KNN part is mainly referred from @Zeiierman.
BTCUSD 8hr performance
ETHUSD 8hr performance
█ Strategy, How It Works: Detailed Explanation
1. SuperTrend Calculation
The SuperTrend is a popular indicator that captures market trends through a combination of the Volume-Weighted Moving Average (VWMA) and the Average True Range (ATR). This strategy utilizes two sets of SuperTrend calculations with varying lengths and factors to capture both short-term and long-term market trends.
2. KNN Algorithm
The strategy employs k-Nearest Neighbors (KNN) algorithms, which are supervised machine learning models. Two sets of KNN algorithms are used, each focused on different lengths of historical data and number of neighbors. The KNN algorithms classify the current SuperTrend data point as bullish or bearish based on the weighted sum of the labels of the k closest historical data points.
3. Signal Generation
Based on the KNN classifications and the SuperTrend indicator, the strategy generates signals for the start of a new trend and the continuation of an existing trend.
4. Trading Logic
The strategy uses these signals to enter long or short positions. It also incorporates dynamic trailing stops for exit conditions.
Local picture
█ Trade Direction
The strategy allows traders to specify their trading direction: long, short, or both. This enables the strategy to be versatile and adapt to various market conditions.
█ Usage
ToolTips: Comprehensive tooltips are provided for each parameter to guide the user through the customization process.
Inputs: Traders can customize numerous parameters including the number of neighbors in KNN, ATR multiplier, and types of moving averages.
Plotting: The strategy also provides visual cues on the chart to indicate bullish or bearish trends.
Order Execution: Based on the generated signals, the strategy will execute buy or sell orders automatically.
█ Default Settings
The default settings are configured to offer a balanced approach suitable for most scenarios:
Initial Capital: $10,000
Default Quantity Type: 10% of equity
Commission: 0.1%
Slippage: 1
Currency: USD
These settings can be modified to suit various trading styles and asset classes.
Strategy
AI SuperTrend - Strategy [presentTrading]
█ Introduction and How it is Different
The AI Supertrend Strategy is a unique hybrid approach that employs both traditional technical indicators and machine learning techniques. Unlike standard strategies that rely solely on traditional indicators or mathematical models, this strategy integrates the power of k-Nearest Neighbors (KNN), a machine learning algorithm, with the tried-and-true SuperTrend indicator. This blend aims to provide traders with more accurate, responsive, and context-aware trading signals.
*The KNN part is mainly referred from @Zeiierman.
BTCUSD 8hr performance
ETHUSD 8hr performance
█ Strategy, How it Works: Detailed Explanation
SuperTrend Calculation
Volume-Weighted Moving Average (VWMA): A VWMA of the close price is calculated based on the user-defined length (len). This serves as the central line around which the upper and lower bands are calculated.
Average True Range (ATR): ATR is calculated over a period defined by len. It measures the market's volatility.
Upper and Lower Bands: The upper band is calculated as VWMA + (factor * ATR) and the lower band as VWMA - (factor * ATR). The factor is a user-defined multiplier that decides how wide the bands should be.
KNN Algorithm
Data Collection: An array (data) is populated with recent n SuperTrend values. Corresponding labels (labels) are determined by whether the weighted moving average price (price) is greater than the weighted moving average of the SuperTrend (sT).
Distance Calculation: The absolute distance between each data point and the current SuperTrend value is calculated.
Sorting & Weighting: The distances are sorted in ascending order, and the closest k points are selected. Each point is weighted by the inverse of its distance to the current point.
Classification: A weighted sum of the labels of the k closest points is calculated. If the sum is closer to 1, the trend is predicted as bullish; if closer to 0, bearish.
Signal Generation
Start of Trend: A new bullish trend (Start_TrendUp) is considered to have started if the current trend color is bullish and the previous was not bullish. Similarly for bearish trends (Start_TrendDn).
Trend Continuation: A bullish trend (TrendUp) is considered to be continuing if the direction is negative and the KNN prediction is 1. Similarly for bearish trends (TrendDn).
Trading Logic
Long Condition: If Start_TrendUp or TrendUp is true, a long position is entered.
Short Condition: If Start_TrendDn or TrendDn is true, a short position is entered.
Exit Condition: Dynamic trailing stops are used for exits. If the trend does not continue as indicated by the KNN prediction and SuperTrend direction, an exit signal is generated.
The synergy between SuperTrend and KNN aims to filter out noise and produce more reliable trading signals. While SuperTrend provides a broad sense of the market direction, KNN refines this by predicting short-term price movements, leading to a more nuanced trading strategy.
Local picture
█ Trade Direction
The strategy allows traders to choose between taking only long positions, only short positions, or both. This is particularly useful for adapting to different market conditions.
█ Usage
ToolTips: Explains what each parameter does and how to adjust them.
Inputs: Customize values like the number of neighbors in KNN, ATR multiplier, and moving average type.
Plotting: Visual cues on the chart to indicate bullish or bearish trends.
Order Execution: Based on the generated signals, the strategy will execute buy/sell orders.
█ Default Settings
The default settings are selected to provide a balanced approach, but they can be modified for different trading styles and asset classes.
Initial Capital: $10,000
Default Quantity Type: 10% of equity
Commission: 0.1%
Slippage: 1
Currency: USD
By combining both machine learning and traditional technical analysis, this strategy offers a sophisticated and adaptive trading solution. Strategy
FunctionNNLayerLibrary "FunctionNNLayer"
Generalized Neural Network Layer method.
function(inputs, weights, n_nodes, activation_function, bias, alpha, scale) Generalized Layer.
Parameters:
inputs : float array, input values.
weights : float array, weight values.
n_nodes : int, number of nodes in layer.
activation_function : string, default='sigmoid', name of the activation function used.
bias : float, default=1.0, bias to pass into activation function.
alpha : float, default=na, if required to pass into activation function.
scale : float, default=na, if required to pass into activation function.
Returns: float Library
FunctionNNPerceptronLibrary "FunctionNNPerceptron"
Perceptron Function for Neural networks.
function(inputs, weights, bias, activation_function, alpha, scale) generalized perceptron node for Neural Networks.
Parameters:
inputs : float array, the inputs of the perceptron.
weights : float array, the weights for inputs.
bias : float, default=1.0, the default bias of the perceptron.
activation_function : string, default='sigmoid', activation function applied to the output.
alpha : float, default=na, if required for activation.
scale : float, default=na, if required for activation.
@outputs float Library
MLActivationFunctionsLibrary "MLActivationFunctions"
Activation functions for Neural networks.
binary_step(value) Basic threshold output classifier to activate/deactivate neuron.
Parameters:
value : float, value to process.
Returns: float
linear(value) Input is the same as output.
Parameters:
value : float, value to process.
Returns: float
sigmoid(value) Sigmoid or logistic function.
Parameters:
value : float, value to process.
Returns: float
sigmoid_derivative(value) Derivative of sigmoid function.
Parameters:
value : float, value to process.
Returns: float
tanh(value) Hyperbolic tangent function.
Parameters:
value : float, value to process.
Returns: float
tanh_derivative(value) Hyperbolic tangent function derivative.
Parameters:
value : float, value to process.
Returns: float
relu(value) Rectified linear unit (RELU) function.
Parameters:
value : float, value to process.
Returns: float
relu_derivative(value) RELU function derivative.
Parameters:
value : float, value to process.
Returns: float
leaky_relu(value) Leaky RELU function.
Parameters:
value : float, value to process.
Returns: float
leaky_relu_derivative(value) Leaky RELU function derivative.
Parameters:
value : float, value to process.
Returns: float
relu6(value) RELU-6 function.
Parameters:
value : float, value to process.
Returns: float
softmax(value) Softmax function.
Parameters:
value : float array, values to process.
Returns: float
softplus(value) Softplus function.
Parameters:
value : float, value to process.
Returns: float
softsign(value) Softsign function.
Parameters:
value : float, value to process.
Returns: float
elu(value, alpha) Exponential Linear Unit (ELU) function.
Parameters:
value : float, value to process.
alpha : float, default=1.0, predefined constant, controls the value to which an ELU saturates for negative net inputs. .
Returns: float
selu(value, alpha, scale) Scaled Exponential Linear Unit (SELU) function.
Parameters:
value : float, value to process.
alpha : float, default=1.67326324, predefined constant, controls the value to which an SELU saturates for negative net inputs. .
scale : float, default=1.05070098, predefined constant.
Returns: float
exponential(value) Pointer to math.exp() function.
Parameters:
value : float, value to process.
Returns: float
function(name, value, alpha, scale) Activation function.
Parameters:
name : string, name of activation function.
value : float, value to process.
alpha : float, default=na, if required.
scale : float, default=na, if required.
Returns: float
derivative(name, value, alpha, scale) Derivative Activation function.
Parameters:
name : string, name of activation function.
value : float, value to process.
alpha : float, default=na, if required.
scale : float, default=na, if required.
Returns: float Library
Library
Machine Learning / Longs [Experimental]Hello Traders/Programmers,
For long time I thought that if it's possible to make a script that has own memory and criterias in Pine. it would learn and find patterns as images according to given criterias. after we have arrays of strings, lines, labels I tried and made this experimental script. The script works only for Long positions.
Now lets look at how it works:
On each candle it creates an image of last 8 candles. before the image is created it finds highest/lowest levels of 8 candles, and creates a string with the lengths 64 (8 * 8). and for each square, it checks if it contains wick, green or red body, green or red body with wicks. see the following picture:
Each square gets the value:
0: nothing in it
1: only wick in it
2: only red body in it
3. only green body in it
4: red body and wick in it
5: green body and wick in it
And then it checks if price went up equal or higher than user-defined profit. if yes then it adds the image to the memory/array. and I call this part as Learning Part.
what I mean by image is:
if there is 1 or more element in the memory, it creates image for current 8 candles and checks the memory if there is a similar images. If the image has similarity higher than user-defined similarty level then if show the label "Matched" and similarity rate and the image in the memory. if it find any with the similarity rate is equal/greater than user-defined level then it stop searching more.
As an example matched image:
and then price increased and you got the profit :)
Options:
Period: if there is possible profit higher than user-defined minimum profit in that period, it checks the images from 2. to X. bars.
Min Profit: you need to set the minimum expected profit accordingly. for example in 1m chart don't enter %10 as min profit :)
Similarity Rate: as told above, you can set minimum similarity rate, higher similarity rate means better results but if you set higher rates, number of images will decrease. set it wisely :)
Max Memory Size: you can set number of images (that gives the profit equal/higher than you set) to be saved that in memory
Change Bar Color: optionally it can change bar colors if current image is found in the memory
Current version of the script doesn't check if the price reach the minimum profit target, so no statistics.
This is completely experimental work and I made it for fun. No one or no script can predict the future. and you should not try to predict the future.
P.S. it starts searching on last bar, it doesn't check historical bars. if you want you should check it in replay mode :)
if you get calculation time out error then hide/unhide the script. ;)
Enjoy!
Indicator
Indicator
Indicator
ANN MACD BTC v2.0 This script is the 2nd version of the BTC Deep Learning (ANN) system.
Created with the following indicators and tools:
RSI
MACD
MOM
Bollinger Bands
Guppy Exponential Moving Averages:
(3,5,8,10,12,15,30,35,40,45,50,60)
Note: I was inspired by the CM Guppy Ema script.
Thank you very much to dear wroclai for his great help.
He has been a big help in the deep learning series.
That's why the licenses in this series are for both of us.
I'm sharing these series and thats the first. Stay tuned and regards!
Note : Alerts added. Indicator
