开始

Machinelearning

XAUUSD ML Supertrend [MatsukazeAlgo]🇬🇧 ENGLISH A Gold-optimized version of the Machine Learning Supertrend. The original engine — SuperTrend foundation with three adaptive learning layers (Global Optimizer, Micro-Batch Processor, and Regime Grid) — is preserved. Four Gold-specific layers are added: session filtering, DXY bias, psychological level TP boost, and a Session-Aware Regime Grid that replaces trend-strength axes with Asia / London / NY session identifiers. Concepts Machine Learning SuperTrend — The original indicator fires entry signals when a volatility band flips direction (Reversal mode) or when price pushes to a new extreme within a trend (Breakout mode). What makes it adaptive is the background simulation: every signal opens a simulated trade, and the results continuously feed three learning systems that adjust the underlying parameters. The longer it runs, the more the engine reflects the current market's character. Three Adaptive Layers — The Global Optimizer monitors rolling win rate, Sortino ratio, and profit factor to propose parameter changes. The Micro-Batch Processor groups results into mini-batches for faster short-term adjustments. The Regime Grid is a 2D memory map that remembers what settings worked under similar conditions (trend strength × volatility) and biases proposals accordingly. These three layers run in parallel, reinforcing each other. Session-Aware Regime Grid — On Gold, the relevant "conditions" are not just trend strength and volatility — they are which session is active. Asia builds range. London breaks it. NY follows through or reverses. This version replaces the volatility axis of the Regime Grid with a session axis (Asia = 0.15, London = 0.5, NY = 0.85). The ML engine now learns optimal parameters per session rather than per generic market regime. Asia settings become distinct from London settings over time. DXY Bias — Gold and the US Dollar Index move inversely. When DXY is weakening (below its EMA), bullish signals are permitted. When DXY is strengthening, bearish signals are permitted. Signals that fight the macro Gold/Dollar relationship are filtered out before they reach the chart. Psychological Level TP Boost — Gold respects $50 and $100 round numbers as institutional order clusters. When an entry signal occurs near one of these levels, the simulated trade target is extended by a configurable ATR bonus. This tells the adaptive engine that psychological level entries have more room, producing more accurate learning near round numbers. How It Works 1. SuperTrend bands are calculated using the configured lookback, smoothing, and band width. 2. Signals fire in Reversal mode (band flip with trend exhaustion) or Breakout mode (new extreme within trend). 3. Session filter blocks signals during excluded sessions. Asia is excluded by default. 4. DXY filter blocks signals that oppose the Dollar trend. 5. Each signal opens a background simulated trade. Outcome is scored and fed to the three adaptive layers. 6. Session-aware Regime Grid maps performance by session, not just volatility × trend strength. 7. Psych level entries get extended TP in simulation, improving learning accuracy near round numbers. 8. Dashboard shows current session, DXY state, signal mode, and live performance metrics. Gold-Specific Features Session Filter — Individual toggles for Asia / London / NY. Asia is OFF by default. Gold's Asia session is dominated by thin liquidity and stop runs that produce unreliable signals. London and NY carry institutional volume. DXY Bias — Bullish signals only when DXY is below its EMA. Bearish signals only when DXY is above it. Configurable EMA period. Psychological Level TP Boost — When entry is within the configured proximity of a $25, $50, or $100 round number, the simulated TP is extended by the configured ATR bonus. The ML engine learns that these entries have more follow-through, adjusting parameters accordingly. Session-Aware Regime Grid — Replaces trend-strength as the X-axis with session identity. The engine builds separate parameter memory for Asia, London, and NY. Over time, it discovers that Asia requires different band widths than London. Dashboard — Shows current session, DXY state, signal mode, active parameters, and simulated win rates per session. Disabled by default. Session Background — Optional coloured background per session (Asia=rose, London=teal, NY=sky). OFF by default. Alerts All original alert types are preserved: Long Signal, Short Signal. These fire only for session-allowed, DXY-confirmed signals. Input Reference Gold Settings — Session Filter: master toggle with individual Asia/London/NY toggles. DXY Bias: enable/disable with DXY symbol and trend EMA period. Psych Level TP Boost: enable/disable with interval ($25/$50/$100), proximity ($), and ATR bonus multiplier. Session-Aware Regime Grid: toggle to use session as Regime Grid X-axis. Dashboard: show/hide. Session Background: show/hide. Signal Mode (①) — Signal Type (Reversal/Breakout), Require Fresh Pivot, Signal Spacing. Volatility Envelope (②) — Lookback Window, Smoothing Period, Band Width (most impactful setting), Price Basis, True Range Mode. Momentum Filter (③) — RSI length and hot/cold zone memory. Flow Analysis (④) — Volume sample depth and surge threshold. Adaptive Engine (⑤–⑥) — Learning rate, batch size, Regime Grid resolution, Reactivity / Master Dial. Conclusion XAUUSD ML Supertrend adds Gold's three-session structure to one of the most powerful adaptive trend indicators on TradingView. The machine learning engine no longer treats Asia, London, and NY the same — it learns them separately. DXY alignment removes signals that fight the macro Gold/Dollar relationship. Psychological level awareness improves simulation accuracy near the round numbers that Gold consistently respects. The original engine by Zimord is preserved in full. The Gold additions layer on top without touching the core learning architecture. --- Based on Machine Learning Supertrend by Zimord . This version adds session filtering (Asia/London/NY), DXY bias filter, psychological level TP boost, session-aware Regime Grid, and MatsukazeAlgo session palette. --- 🇯🇵 日本語 Machine Learning Supertrendのゴールド最適化版です。オリジナルエンジン（SuperTrend基盤 + グローバルオプティマイザー、マイクロバッチプロセッサー、レジームグリッドの3層学習）を完全保持。セッションフィルター、DXYバイアス、心理的価格帯TP延長、セッション対応レジームグリッドの4つのゴールド専用レイヤーを追加。 コンセプト 機械学習スーパートレンド — オリジナルはボラティリティバンドの反転（Reversalモード）または新高値/安値（Breakoutモード）でシグナルを発火。バックグラウンドシミュレーションが全シグナルをトレースし、3つの学習システムに結果を供給して継続的にパラメータを調整。稼働時間が長いほど、現在の市場特性を反映した設定になる。 3つの適応レイヤー — グローバルオプティマイザーがローリング勝率・ソルティノ比率・プロフィットファクターを監視。マイクロバッチプロセッサーが結果をミニバッチに分類して素早い短期調整を実施。レジームグリッドが類似条件下で効果的だった設定を記憶してプロポーザルにバイアスをかける。 セッション対応レジームグリッド — ゴールドで重要な「条件」はトレンド強度とボラティリティだけでない。どのセッションが動いているかが決定的。東京はレンジ形成、ロンドンはブレイク、NYは継続または反転。このバージョンではレジームグリッドのX軸をボラティリティからセッション（Asia=0.15、London=0.5、NY=0.85）に置き換え。MLエンジンが汎用的な市場レジームではなくセッションごとに最適パラメータを学習。 DXYバイアス — ゴールドとドル指数は逆相関。DXYがEMAを下回る時のみ強気シグナルを許可。マクロなゴールド/ドル関係に逆らうシグナルをフィルター。 心理的価格帯TP延長 — ゴールドは$50/$100のラウンドナンバーを機関投資家の注文クラスターとしてリスペクト。シグナルがこれらの価格帯付近で発生した場合、シミュレーションTPをATRボーナス分延長。適応エンジンが心理的価格帯エントリーの余地を正確に学習。 ゴールド専用機能 セッションフィルター — Asia/London/NYの個別トグル。Asiaはデフォルトでオフ。薄商いと流動性スイープが多いアジアを除外することで、信頼性の高いシグナルのみを許可。 DXYバイアス — DXYがEMA以下の場合のみ強気シグナル、EMA以上の場合のみ弱気シグナル。設定可能なEMA期間。 心理的価格帯TP延長 — $25/$50/$100のラウンドナンバー付近のエントリーでシミュレーションTPをATRボーナス分延長。MLエンジンの学習精度を向上。 セッション対応レジームグリッド — ボラティリティ軸をセッション識別子に置き換え。エンジンがAsia、London、NYそれぞれのパラメータ記憶を構築。 ダッシュボード — 現在セッション、DXY状態、シグナルモード、アクティブパラメータ、セッション別シミュレーション勝率を表示。 入力パラメータ ゴールド設定 — セッションフィルター（Asia/London/NY個別トグル）、DXYバイアス（シンボル + EMA期間）、心理的価格帯TP延長（間隔/近接距離/ATRボーナス）、セッション対応レジームグリッド、ダッシュボード、セッション背景。 シグナルモード（①） — シグナルタイプ（Reversal/Breakout）、Fresh Pivot必須、シグナル間隔。 ボラティリティエンベロープ（②） — ルックバック、スムージング期間、バンド幅（最重要設定）、価格ベース、True Rangeモード。 モメンタムフィルター（③） — RSI長さ、ホット/コールドゾーンメモリ。 フロー分析（④） — ボリュームサンプル深さ、サージ閾値。 適応エンジン（⑤–⑥） — 学習率、バッチサイズ、レジームグリッド解像度、Reactivity / Master Dial。 まとめ XAUUSD ML Supertrendは、TradingViewで最も強力な適応型トレンドインジケーターの一つにゴールドの3セッション構造を追加します。機械学習エンジンが東京、ロンドン、NYを同一視せず、それぞれ個別に学習します。DXYアライメントがマクロなゴールド/ドル関係に逆らうシグナルを除去。心理的価格帯の認識がゴールドが一貫してリスペクトするラウンドナンバー付近のシミュレーション精度を向上させます。 Zimordによるオリジナルエンジンは完全保持。ゴールドの追加機能はコア学習アーキテクチャに触れることなくレイヤーとして追加されています。 --- Based on Machine Learning Supertrend by Zimord . セッションフィルター（Asia/London/NY）、DXYバイアスフィルター、心理的価格帯TP延長、セッション対応レジームグリッド、MatsukazeAlgoセッションパレットを追加。
Pine Script®指标
由MatsukazeAlgo提供
2
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.
Pine Script®指标
由Zeiierman提供
9
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.
Pine Script®指标
由Anonycryptous提供
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 TradingView 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 TradingView's execution limits, not for oversized GPU-style networks. All the diagrams in this publication are rendered natively on TradingView 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
Pine Script®库
由Alien_Algorithms提供
1
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 TradingView. 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 TradingView. 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 TradingView (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 TradingView. 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 TradingView 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
Pine Script®库
由Alien_Algorithms提供
6
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, TradingView indicators suffer from permanent amnesia! Every time a new candle paints, TradingView 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 TradingView 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 TradingView 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. TradingView 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 TradingView 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).
Pine Script®指标
由Jamallo22提供
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.
Pine Script®指标
由SatohK提供
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.
Pine Script®指标
由AlgoAlpha提供
10
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 TradingView 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 TradingView 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 TradingView'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.
Pine Script®指标
由a_jabbaroff提供
26
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.
Pine Script®指标
由Zimord提供
59
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.
Pine Script®指标
由GainzAlgo提供
222
Deep Machine Learning - Artificial Neural Network -⭐ Full-Scale Deep Learning AI on TradingView ⭐ 🌟 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 TradingView 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 TradingView.
Pine Script®指标
由SatohK提供
5
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.
Pine Script®指标
由SatohK提供
3
KNN Supertrend Horizon [LuxAlgo]The KNN Supertrend Horizon indicator is a machine learning tool that combines K-Nearest Neighbors (KNN) classification with Supertrend logic to identify high-probability trend directions and price rejection zones. 🔶 USAGE The indicator provides a comprehensive view of market trends by filtering traditional Supertrend calculations through a machine learning engine. It is designed to help traders stay on the right side of the trend while identifying potential exhaustion points through visual "Rejection Orbs." 🔹 Trend Identification The core trend logic is driven by the KNN engine, which analyzes RSI and volatility (ATR) features over a lookback window to determine the most likely trend direction. When the ML confidence aligns with the Supertrend, the indicator displays a colored horizon at the top or bottom of the chart. 🔹 3D Rejection Orbs Specialized rejection signals appear when price interacts with the Supertrend level and forms a significant wick. The size of the orb is dynamically adjusted based on relative volume. A label attached to the orb displays the exact volume of the rejection candle. These orbs serve as potential entry or exit signals where price is "bouncing" off the trend baseline. 🔹 Confidence Visualization The script features "Liquid Smooth" gradient candle coloring. The intensity of the candle colors shifts based on the ML engine's confidence level. Brighter, more vibrant colors indicate a high-conviction trend, while muted colors suggest the trend may be weakening or entering a sideways phase. 🔶 DETAILS The KNN engine functions by searching for historical similarities in price behavior. By comparing the current RSI and ATR-based volatility to the past N bars (Search Window), it finds the K closest matches (Neighbors) to predict the current trend state. A confidence buffer is applied to this probability to filter out market noise and prevent rapid signal flipping. 🔶 SETTINGS 🔹 Machine Learning Settings K-Neighbors: The number of historical neighbors the algorithm looks for to determine the trend direction. Search Window: The lookback period (in bars) used to find similar historical patterns. 🔹 Supertrend Settings ATR Length: The period used for the Average True Range calculation. Factor: The multiplier applied to the ATR to set the distance of the Supertrend line. 🔹 Noise Filter Settings Smooth Price Input: Enables HMA smoothing on the price source used for ML features. ML Confidence Buffer (%): The percentage threshold above/below 50% required to trigger a trend change. 🔹 Rejection Signal Settings Show 3D Rejection Orbs: Toggles the visibility of the volume-based rejection bubbles. Min Wick-to-Body Multiplier: The required ratio of wick length to body size to qualify as a rejection. Min Bubble Gap: The minimum number of bars required between consecutive rejection signals. 🔹 Visual & Dashboard Settings Liquid Smoothness: Controls the EMA smoothing applied to the ML confidence for visual gradients. Vibrancy: Increases the color intensity of the gradient candles and horizons. Show Dashboard: Toggles the real-time statistics table containing trend direction, ML confidence, and relative volatility.
Pine Script®指标
由LuxAlgo提供
7
Support & Resistance KDESupport & Resistance KDE (Kernel Density Estimation) ▶️Overview This indicator identifies high-significance support and resistance (S/R) levels using Kernel Density Estimation (KDE), a sophisticated statistical method for finding price clusters. By employing a linear kernel approach where the width is determined by the candlestick range, this tool provides a more robust estimation of S/R levels compared to simply marking discrete pivot points. It visualizes statistically significant "price walls" that represent real supply and demand zones by accounting for the price action's volatility at each historical turning point. ▶️Key Features Statistical S/R Identification: Uses Pivot Highs and Lows as sample data for KDE to automatically extract price levels with high historical significance. KDE Distribution Profile: Displays a density profile on the right side of the chart, allowing you to instantly see where the strongest price clusters are located. Dynamic Zone Display: Levels are displayed as "Zones" rather than thin lines, based on ATR. This helps account for market noise and provides a more realistic view of price reaction areas. Peak Filtering: Identifies local maxima in density and uses an ATR-based minimum distance filter to merge overlapping levels and keep the chart clean. ▶️How It Works (Logic) The script processes data through the following steps to ensure a robust statistical analysis: Data Collection: Extracts all Pivot Highs and Lows within the defined Lookback Period, alongside the price range (High - Low) of the candle where the pivot occurred. Density Calculation (Linear Kernel): Instead of treating each pivot as a single, infinitesimal price point, the script applies a Linear (Triangular) Kernel to each pivot. The width of this kernel is defined by the candle's range at that specific time. Mechanism: Each pivot contributes its "weight" to a price range rather than a single value. This accounts for the volatility and uncertainty present at the moment the pivot was formed, leading to a much more reliable estimation of where "true" support or resistance lies compared to raw price data. Peak Detection: Scans the entire price range within the lookback period to find local maxima (peaks) in the cumulative density distribution. Ranking and Filtering: Ranks these peaks by density and filters them based on the user-defined "Min Distance (ATR Multiplier)" to display only the top N most significant levels. ▶️Inputs --- Calculation Settings --- Lookback Period: The number of bars to analyze. Pivot Left/Right Strength: The period used to detect pivot points. Increasing these values will capture more macro-level structures. Number of Top Levels: The maximum number of S/R levels to display. Min Distance Between Levels: Minimum vertical distance between levels (ATR multiplier) to prevent clutter. KDE Resolution: The granularity of the price scan for density calculation. --- Display Settings --- Show KDE Distribution: Toggles the visibility of the density profile on the right. Zone Display Width: The vertical thickness of the S/R zones (ATR multiplier). ▶️Trading Use Cases Take Profit / Stop Loss Targets: Use Level 1 (the highest density peak) as a high-probability target for exits. Breakout Confirmation: Watch for strong candle closes outside of high-density zones as a signal of a potential trend shift. Identifying Range Boundaries: Use the boundaries of the KDE profile to define the upper and lower limits of a consolidation phase. Disclaimer: This script is provided for educational and analytical purposes only and does not constitute financial advice.
Pine Script®指标
由SatohK提供
1
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.
Pine Script®指标
由LuxAlgo提供
9
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.
Pine Script®指标
由UAlgo提供
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!
Pine Script®指标
由SatohK提供
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.
Pine Script®指标
由LuxAlgo提供
14
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.
Pine Script®指标
由UAlgo提供
2
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.
Pine Script®指标
由BOSWaves提供
2
KNN Trend Forecaster [UAlgo]KNN Trend Forecaster is a chart overlay forecasting tool that uses a K Nearest Neighbors style similarity engine to estimate the next directional bias and project a probabilistic price path. It converts the current market state into a compact feature vector, compares it to a rolling memory of historical states, and computes an expected forward change as a weighted consensus of the most similar past observations. The indicator is built for decision support rather than signal chasing. It provides a projected path, a volatility aware tunnel around that path, and optional ghost structures that visualize how the forecast could evolve bar by bar. A minimal UI panel summarizes the current projection and sentiment, while the plot color adapts to bullish, bearish, or neutral expectation. This script is most effective when treated as a contextual layer. It can help align trade selection with the dominant statistical bias implied by recent conditions, while still leaving execution to your own confirmation rules. 🔹 Features 1) KNN Similarity Forecasting Engine The core model is a K Nearest Neighbors approach. For each bar, the script builds a three dimensional feature set from momentum, volatility, and relative strength. It then measures the distance between the current feature set and each stored historical feature set. The closest K neighbors are selected, and their realized forward returns are combined into a single prediction. Model Sensitivity controls K. Lower values behave more reactive and can change bias quickly. Higher values behave more stable and tend to smooth the projection. 2) Feature Design Focused On Trading Context The feature set is intentionally practical: RSI captures directional pressure and mean reversion tendencies ROC captures normalized momentum ATR captures normalized volatility regime Normalization ensures that ROC and ATR values are scaled into comparable ranges so the distance metric remains balanced and does not get dominated by raw magnitude differences. 3) Rolling Memory With Outcome Labels The script builds a training memory in real time. On each confirmed bar, it stores the features from ten bars ago and labels them with the percentage change over the next ten bars. This creates a consistent supervised learning target: Feature snapshot at time t Outcome equals return from time t to t plus ten bars Memory is capped to a fixed size to keep performance stable. 4) Weighted Neighbor Voting For Robust Predictions Rather than using a simple average of neighbor outcomes, the script assigns higher weight to closer neighbors. Weight is the inverse of distance, which prioritizes highly similar historical states and reduces the influence of weaker matches. This helps stabilize results when the market is transitioning and the feature landscape becomes noisier. 5) Forecast Path With Adaptive Step Decay Once a prediction is produced, the script generates a forward path for a user selected Forecast Horizon. The step applied to the path decays with the square root of the forecast index, which makes the projection more confident near the present and more conservative further out. The result is a smooth curve rather than an aggressive linear extrapolation. 6) Multi Layer Volatility Tunnel A tunnel can be drawn around the projected path. Its width scales with ATR and expands over the forecast horizon using a square root growth profile. Tunnel Volatility controls how wide the envelope becomes. This provides a practical view of expected dispersion around the forecast rather than a single deterministic line. 7) Ghost Structures For Bar To Bar Projection Framing Optional ghost boxes are printed for each forward step. Each box visualizes the projected candle body from the current projected close to the next projected close. The ghost color adapts to whether the step is rising or falling, making momentum and path rhythm easier to read. 8) Neon Glow Path And Target Tag When enabled, the path is rendered twice using polylines: A wider glow stroke for visual depth A thinner main stroke for precision A target label is placed at the end of the horizon, showing the model predicted change in percent. 9) Projection Basis And Dashboard A 21 period EMA is plotted as a reference basis, colored by the current prediction bias. A compact table displays the projection value and a sentiment label that classifies the forecast into bullish, bearish, or neutral ranges. 🔹 Calculations 1) Feature Construction The model uses three features built from common market analytics. RSI uses standard 14 period RSI: float f_rsi = ta.rsi(close, 14) ROC and ATR are normalized into a 0 to 100 style range using rolling min max scaling: normalize(float src, int len) => float mn = ta.lowest(src, len) float mx = ta.highest(src, len) (src - mn) / (math.max(mx - mn, 0.000001)) * 100 float f_roc = normalize(ta.roc(close, 10), 100) float f_atr = normalize(ta.atr(14), 100) The current feature vector: FeatureSet current_f = FeatureSet.new(f_rsi, f_roc, f_atr) 2) Training Memory And Outcome Labeling On each confirmed bar, the script stores the feature snapshot from ten bars earlier and labels it with the forward ten bar return. Outcome in percent: float outcome = (close - close ) / close * 100 Training point created from the past feature snapshot: memory.push(TrainingPoint.new(FeatureSet.new(f_rsi , f_roc , f_atr ), outcome)) Memory is limited for stability: if memory.size() > 1000 memory.shift() 3) Distance Metric Between Feature Vectors Similarity is computed using Euclidean distance in three dimensions: method distance(FeatureSet v1, FeatureSet v2) => math.sqrt(math.pow(v1.f1 - v2.f1, 2) + math.pow(v1.f2 - v2.f2, 2) + math.pow(v1.f3 - v2.f3, 2)) Smaller distance means greater similarity. 4) Neighbor Selection And Weighted Prediction The script computes distances from the current state to each stored training point and gathers the outcomes. It then selects the closest K entries by repeatedly taking the minimum distance. Each neighbor is weighted by inverse distance: float w = 1.0 / math.max(td.get(idx), 0.0001) twc += tc.get(idx) * w ws += w pred := twc / ws This produces pred, a percentage change estimate inferred from the most similar historical contexts. 5) Signal Color Classification The display color adapts to the sign and magnitude of the prediction. Small values map to a neutral tone, stronger positive values map to bullish tone, and stronger negative values map to bearish tone. color sig_col = pred > 0.005 ? THEME_UP : pred < -0.005 ? THEME_DN : THEME_MID 6) Forecast Path Generation Path construction begins from the current close. A base step is derived from the prediction and then decayed across the horizon. Base step: float step = (pred / 10.0) * 0.01 Forward projection with square root decay: float next_c = cur_c * (1 + step * (1.0 / math.sqrt(i))) This produces a smooth forecast curve where early steps carry more weight than later steps. 7) Volatility Tunnel Width Model The tunnel uses ATR as the volatility anchor and expands across the horizon: Outer width: float v_outer = (atr * expansion * 0.3 * math.sqrt(i)) Inner width is half of the outer width: float v_inner = v_outer * 0.5 Upper and lower bounds are then computed around the projected close: float h_out = next_c + v_outer float l_out = next_c - v_outer float h_in = next_c + v_inner float l_in = next_c - v_inner 8) Ghost Structures For each forecast step, a box is drawn between the current projected close and the next projected close. Its color reflects whether the path step is rising or falling. color g_col = next_c >= cur_c ? color.new(THEME_UP, 40) : color.new(THEME_DN, 40) box b = box.new(x1, math.max(cur_c, next_c), x2, math.min(cur_c, next_c), border_color=color.new(g_col, 20), bgcolor=g_col, border_width=1) 9) Path Rendering And Target Tag When glow is enabled, the script renders a thick glow polyline and a thinner main polyline over the same projected points. A label is placed at the final horizon index showing the predicted percent change. path_glow := polyline.new(pts, curved=true, line_color=color.new(sig_col, 70), line_width=8) path_main := polyline.new(pts, curved=true, line_color=sig_col, line_width=2) target_tag := label.new(bar_index + forecast_len, cur_c, "TARGET: " + str.tostring(pred, "#.##") + "%") 10) UI Summary And Basis Plot A 21 period EMA is plotted and colored by the current bias. A table panel prints the projection value and a sentiment classification: Bullish when pred is above 0.01 Bearish when pred is below minus 0.01 Neutral otherwise This gives an at a glance readout that matches the on chart color theme.
Pine Script®指标
由UAlgo提供
1
Anchored Clusters Volume Profile [LuxAlgo]The Anchored Clusters Volume Profile indicator utilizes K-Means clustering to categorize historical price action into distinct groups within a user-defined range and generates individual volume profiles for each detected cluster. This tool provides a unique perspective on volume distribution by isolating price behaviors based on proximity rather than strictly chronological order. 🔶 USAGE The indicator identifies "clusters" of price activity within a selected range defined by a starting and ending date. Each cluster is assigned a unique color and its own horizontal volume profile, allowing traders to see where liquidity is most concentrated within specific price regimes. 🔹 Identifying Institutional Zones Traders can use the Point of Control (POC) of high-volume clusters to identify significant institutional interest. Because the K-Means algorithm groups price action by density rather than time, a cluster's POC often represents a "fair value" level where significant exchange occurred. These dashed POC lines frequently act as robust support or resistance levels when price returns to them in the future. 🔹 Market Regime Detection By observing the vertical distribution and overlap of clusters, traders can identify market phases. Overlapping clusters with high volume often indicate accumulation or distribution phases (sideways markets), whereas distinct, vertically separated clusters with lower volume gaps between them suggest a trending environment. A shift from multiple overlapping clusters to a new, isolated cluster can signal a breakout or the start of a new trend. 🔹 Precision Entry & Exits Cluster boundaries and POC lines provide concrete levels for trade management. An entry can be sought when price retests a high-volume cluster POC, while stops can be placed outside the total price range of that specific cluster (the area covered by its volume profile). Conversely, targets can be set at the POC of the next major cluster above or below current price action. 🔹 Volume Conviction The tool provides specific volume metrics that allow traders to gauge conviction. By comparing the "Total" volume label of one cluster against another, a trader can determine which price regime had more participation. A breakout into a price zone with a high-volume cluster suggests stronger conviction and a higher probability of the level holding compared to a zone with low total volume. 🔶 DETAILS Unlike traditional anchored volume profiles that provide a single histogram, this script employs a K-Means clustering algorithm to segment the range. This process involves: Identifying the specific range of bars between the user-selected Start Time and End Time . Initializing "centroids" across the price range of that period. Iteratively assigning each price bar to the nearest centroid based on the HLC2 (median) price. Recalculating centroids based on the volume-weighted average price of the assigned bars. Finalizing assignments after the specified number of iterations to ensure stable clusters. By separating price action into these clusters, the tool helps identify high-interest zones that might be obscured by a single, traditional Volume Profile. 🔶 SETTINGS 🔹 Anchor Settings Start Time / End Time : Sets the beginning and end of the analysis range. These use the "Confirm" feature, allowing you to select the range directly on the chart after adding the indicator or changing settings. Range Highlight : Adjusts the color and transparency of the background shading that identifies the analyzed range. 🔹 Clustering Settings Number of Clusters : Sets how many distinct price groups the algorithm should attempt to find (2 to 10). K-Means Iterations : Controls the number of times the algorithm refines the cluster centers. Higher values can lead to more stable results. 🔹 Volume Profile Settings Rows per Cluster VP : Defines the vertical resolution (number of bins) for each individual cluster's profile. Max VP Width (Bars) : Sets the maximum horizontal length of the volume profile histograms. VP Offset : Adjusts the horizontal spacing between the current bar and the start of the volume profiles. Highlight Price Dots : Toggles the visibility of the colored dots on the price action to identify cluster assignments. Dot Size : Adjusts the size of the cluster assignment dots on the chart, ranging from tiny to huge.
Pine Script®指标
由LuxAlgo提供
4