Probabilistic ICT Order Blocks [3D]

indicator("Probabilistic ICT Order Blocks [3D] | GainzAlgo", overlay=true, max_bars_back = 1500, max_boxes_count=500, max_lines_count=500, max_labels_count=500)

import GainzAlgo/Arbor_Gradient_Boosting_GainzAlgo/1 as arbor

string ICT_GRP = "ICT Order Block Settings"
int swing_length = input.int(5, "Swing Detection Length", minval=2, group=ICT_GRP)
int max_blocks   = input.int(4, "Max Displayed Blocks (Per Type)", minval=1, maxval=10, group=ICT_GRP)
bool delete_on_break = input.bool(true, "Delete OB on Full Invalidation", tooltip="Removes a block the moment price closes fully through it (loss). Frees up space so new blocks don't overlap stale ones.", group=ICT_GRP)

string AI_GRP  = "Arbor AI Engine"
int train_len   = input.int(200, "Machine Learning Training Lookback", minval=50, group=AI_GRP)
int retrain_f   = input.int(30, "Retrain Frequency (Bars)", minval=10, group=AI_GRP)

string VIS_GRP = "3D Rendering Visuals"
color bull_clr = input.color(#00e5ff, "Bullish OB Color", group=VIS_GRP)
color bear_clr = input.color(#ff1744, "Bearish OB Color", group=VIS_GRP)
int depth_shift = input.int(2, "3D Depth Shift (Bars)", minval=1, maxval=5, group=VIS_GRP)
int tick_shift  = input.int(3, "3D Depth Shift (Ticks)", minval=1, group=VIS_GRP)

string DASH_GRP = "Win Rate Dashboard"
bool show_dashboard = input.bool(true, "Show Dashboard", group=DASH_GRP)
string dash_pos = input.string("Top Right", "Position", options=["Top Right", "Top Left", "Bottom Right", "Bottom Left"], group=DASH_GRP)
string dash_size = input.string("Normal", "Text Size", options=["Small", "Normal", "Large"], group=DASH_GRP)
bool show_retest_signals = input.bool(true, "Show Win/Loss Markers on Chart", group=DASH_GRP)

float f1 = ta.rsi(close, 14)
float f2 = ta.mfi(hlc3, 14)
float f3 = ta.atr(14) / (close + 1e-6) * 100
float f4 = nz(volume) > 0 ? (volume - ta.sma(volume, 20)) / (ta.stdev(volume, 20) + 1e-6) : 0.0

bool features_ready = not (na(f1) or na(f2) or na(f3) or na(f4))

var arbor.GBM4 model = na
var float current_prob = 0.5
bool dynamic_retrain = bar_index % retrain_f == 0 and bar_index > train_len and features_ready and barstate.isconfirmed

if dynamic_retrain
    array<float> a1 = array.new<float>()
    array<float> a2 = array.new<float>()
    array<float> a3 = array.new<float>()
    array<float> a4 = array.new<float>()
    array<float> target = array.new<float>()

    for i = train_len to 5
        if not (na(f1[i]) or na(f2[i]) or na(f3[i]) or na(f4[i]))
            array.push(a1, f1[i])
            array.push(a2, f2[i])
            array.push(a3, f3[i])
            array.push(a4, f4[i])
            array.push(target, close[i-5] > close[i] ? 1.0 : 0.0)

    if array.size(target) >= 30
        model := arbor.gbm4_fit(a1, a2, a3, a4, target, n_rounds=15, lr=0.3, is_classifier=true, seed=42)

if not na(model) and features_ready
    current_prob := arbor.gbm4_predict(model, f1, f2, f3, f4)

var array<float> bull_ob_top    = array.new<float>()
var array<float> bull_ob_bot    = array.new<float>()
var array<int>   bull_ob_x      = array.new<int>()
var array<float> bull_ob_pr     = array.new<float>()
var array<bool>  bull_ob_tested = array.new<bool>()

var array<float> bear_ob_top    = array.new<float>()
var array<float> bear_ob_bot    = array.new<float>()
var array<int>   bear_ob_x      = array.new<int>()
var array<float> bear_ob_pr     = array.new<float>()
var array<bool>  bear_ob_tested = array.new<bool>()

var int bull_wins = 0
var int bull_losses = 0
var int bear_wins = 0
var int bear_losses = 0

bool bull_win_signal = false
bool bull_loss_signal = false
bool bear_win_signal = false
bool bear_loss_signal = false

f_is_overlapping(array<float> tops, array<float> bots, float new_top, float new_bot) =>
    bool result = false
    if array.size(tops) > 0
        for i = 0 to array.size(tops) - 1
            float et = array.get(tops, i)
            float eb = array.get(bots, i)
            if new_top >= eb and new_bot <= et
                result := true
                break
    result

float high_lh = ta.highest(high, swing_length)
float low_ll  = ta.lowest(low, swing_length)

bool mss_bull = ta.crossover(close, high_lh[1])
bool mss_bear = ta.crossunder(close, low_ll[1])

if barstate.isconfirmed
    if array.size(bull_ob_top) > 0
        for i = array.size(bull_ob_top) - 1 to 0
            float top = array.get(bull_ob_top, i)
            float bot = array.get(bull_ob_bot, i)
            bool tested = array.get(bull_ob_tested, i)

            if not tested and low <= top
                array.set(bull_ob_tested, i, true)
                tested := true

            bool resolved = false
            if tested and close > top
                bull_wins += 1
                bull_win_signal := true
                resolved := true
            else if close < bot
                bull_losses += 1
                bull_loss_signal := true
                resolved := true

            if resolved and delete_on_break
                array.remove(bull_ob_top, i)
                array.remove(bull_ob_bot, i)
                array.remove(bull_ob_x, i)
                array.remove(bull_ob_pr, i)
                array.remove(bull_ob_tested, i)

    if array.size(bear_ob_top) > 0
        for i = array.size(bear_ob_top) - 1 to 0
            float top = array.get(bear_ob_top, i)
            float bot = array.get(bear_ob_bot, i)
            bool tested = array.get(bear_ob_tested, i)

            if not tested and high >= bot
                array.set(bear_ob_tested, i, true)
                tested := true

            bool resolved = false
            if tested and close < bot
                bear_wins += 1
                bear_win_signal := true
                resolved := true
            else if close > top
                bear_losses += 1
                bear_loss_signal := true
                resolved := true

            if resolved and delete_on_break
                array.remove(bear_ob_top, i)
                array.remove(bear_ob_bot, i)
                array.remove(bear_ob_x, i)
                array.remove(bear_ob_pr, i)
                array.remove(bear_ob_tested, i)

if mss_bull
    int lowest_idx = 1
    for i = 1 to swing_length * 2
        if close[i] < open[i] and low[i] < low[lowest_idx]
            lowest_idx := i

    float new_top = high[lowest_idx]
    float new_bot = low[lowest_idx]

    bool overlap = f_is_overlapping(bull_ob_top, bull_ob_bot, new_top, new_bot) or
                   f_is_overlapping(bear_ob_top, bear_ob_bot, new_top, new_bot)

    if not overlap
        array.unshift(bull_ob_top, new_top)
        array.unshift(bull_ob_bot, new_bot)
        array.unshift(bull_ob_x, bar_index - lowest_idx)
        array.unshift(bull_ob_pr, current_prob)
        array.unshift(bull_ob_tested, false)

Показано первые 50% кода (символов: 10525)