# Forget gate — decides what fraction of the previous cell state to discard
f_t = sigma( W_f . [h_(t-1), x_t] + b_f )

# Input gate — decides what new information gets stored
i_t = sigma( W_i . [h_(t-1), x_t] + b_i )

# Candidate values for updating the cell state
C~_t = tanh( W_C . [h_(t-1), x_t] + b_C )

# Cell state update: combine old memory (scaled by forget gate) with new candidate
C_t = f_t * C_(t-1) + i_t * C~_t

# Output gate — decides what fraction of memory is exposed as output
o_t = sigma( W_o . [h_(t-1), x_t] + b_o )

# Final hidden state passed to the next layer or output
h_t = o_t * tanh(C_t)

import numpy as np
import tensorflow as tf
from tensorflow.keras import Sequential, Input
from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization
from sklearn.preprocessing import MinMaxScaler

# ── Stacked Bi-directional LSTM architecture for trend classification ──
def build_lstm_model(seq_len=60, n_features=11, n_classes=3):
    model = Sequential([
        Input(shape=(seq_len, n_features)),
        # First LSTM layer — returns full sequence for the second layer
        LSTM(128, return_sequences=True),
        BatchNormalization(),
        Dropout(0.25),

        # Second LSTM layer — collapses sequence to a single context vector
        LSTM(64, return_sequences=False),
        BatchNormalization(),
        Dropout(0.20),

        # Projection head before classifier
        Dense(32, activation='relu'),
        # Output: 3-class softmax — class 0=Down, 1=Neutral, 2=Up
        Dense(n_classes, activation='softmax')
    ])
    model.compile(
        # learning_rate=1e-3 with cosine decay recommended for long runs
        optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

# ── Feature engineering: OHLCV + 6 technical indicators → [Batch, 60, 11] ──
def make_sequences(df, seq_len=60):
    # Per-feature MinMax scaling applied on training split only (avoid leakage)
    scaler = MinMaxScaler()
    scaled = scaler.fit_transform(df[[
        'open', 'high', 'low', 'close', 'volume',  # OHLCV
        'rsi_14', 'atr_14', 'ema_20', 'ema_50',      # momentum / volatility
        'bb_upper', 'bb_lower'                        # Bollinger Band channels
    ]])
    X, y = [], []
    for i in range(seq_len, len(scaled)):
        X.append(scaled[i-seq_len:i])  # sliding window → shape [60, 11]
        y.append(get_label(df, i))     # forward-label: 0=Down, 1=Neutral, 2=Up
    return np.array(X), np.array(y), scaler

# ── Real-time inference server: receives OHLCV from MT5 EA via ZeroMQ REP ──
import zmq

def signal_server(model, scaler, threshold=0.62):
    ctx = zmq.Context()
    sock = ctx.socket(zmq.REP)
    sock.bind("tcp://*:5555")
    while True:
        data = sock.recv_json()          # receive last 60 candles from MT5 EA
        X = prepare_input(data, scaler)  # scale + reshape → [1, 60, 11]
        probs = model.predict(X, verbose=0)[0]  # [p_down, p_neutral, p_up]
        # Only emit a directional signal when confidence exceeds threshold
        signal = "BUY"  if probs[2] > threshold else \
                 "SELL" if probs[0] > threshold else "HOLD"
        sock.send_json({"signal": signal, "confidence": float(probs.max()),
                        "probs": probs.tolist()})

# ── Training run + Out-of-Sample evaluation ──
from sklearn.metrics import classification_report, accuracy_score

X, y, scaler = make_sequences(df, seq_len=60)

# Time-ordered split — NEVER shuffle time series data (causes lookahead leakage)
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

model = build_lstm_model(seq_len=60, n_features=11, n_classes=3)
history = model.fit(
    X_train, y_train,
    validation_split=0.15,
    epochs=50,
    batch_size=32,
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=8, restore_best_weights=True)],
    verbose=1
)

# Out-of-sample prediction: probabilities per class → [Down, Neutral, Up]
probs = model.predict(X_test)
y_pred = probs.argmax(axis=1)

print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=['Down', 'Neutral', 'Up']))

# Single latest-window inference (what signal_server() does per tick)
latest_probs = model.predict(X_test[-1:])[0]
print(f"Latest signal -> Down={latest_probs[0]:.2f}  Neutral={latest_probs[1]:.2f}  Up={latest_probs[2]:.2f}")

# Update gate — how much of the previous state to keep (merges roles of f_t and i_t)
z_t = sigma( W_z . [h_(t-1), x_t] )

# Reset gate — how much of the previous memory to ignore
r_t = sigma( W_r . [h_(t-1), x_t] )

# Candidate state, with the reset gate applied to previous memory
h~_t = tanh( W . [r_t * h_(t-1), x_t] )

# Final hidden state — linear interpolation between old memory and new candidate
h_t = (1 - z_t) * h_(t-1) + z_t * h~_t

import pandas as pd
import tensorflow as tf
from tensorflow.keras.layers import GRU, Dense, Dropout, BatchNormalization
from tensorflow.keras import Sequential, Input

# ── GRU architecture — 2-gate design, 15-25% faster to train than LSTM ──
def build_gru_model(seq_len=60, n_features=11, n_classes=3):
    model = Sequential([
        Input(shape=(seq_len, n_features)),
        # Reset Gate + Update Gate fused — fewer params than LSTM's 3 gates
        GRU(128, return_sequences=True),
        BatchNormalization(),
        Dropout(0.25),

        # Final GRU layer outputs a single hidden state h_T
        GRU(64, return_sequences=False),
        BatchNormalization(),
        Dropout(0.20),

        Dense(32, activation='relu'),
        # 3-class softmax: 0=Down, 1=Neutral, 2=Up
        Dense(n_classes, activation='softmax')
    ])
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

# ── Adaptive daily retraining — fine-tunes existing weights on fresh data ──
def daily_retrain_job(model_path, new_data_path):
    df = pd.read_csv(new_data_path)
    # make_sequences(): same feature pipeline as the LSTM model (11 features, window=60)
    X, y, scaler = make_sequences(df, seq_len=60)
    model = tf.keras.models.load_model(model_path)
    # Short fine-tune (5 epochs) avoids catastrophic forgetting
    model.fit(X, y, epochs=5, batch_size=32, verbose=0)
    model.save(model_path)  # overwrite checkpoint with updated weights

# ── Training run + Out-of-Sample evaluation ──
from sklearn.metrics import classification_report, accuracy_score

X, y, scaler = make_sequences(df, seq_len=60)
split = int(len(X) * 0.8)  # time-ordered split — no shuffling for time series
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

model = build_gru_model(seq_len=60, n_features=11, n_classes=3)
model.fit(
    X_train, y_train,
    validation_split=0.15,
    epochs=50,
    batch_size=32,
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=8, restore_best_weights=True)],
    verbose=1
)
model.save("gru_model.h5")  # checkpoint used by daily_retrain_job()

y_pred = model.predict(X_test).argmax(axis=1)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=['Down', 'Neutral', 'Up']))

# Latest-candle inference (single sample, what a live EA would call each tick)
latest_probs = model.predict(X_test[-1:])[0]
signal = ['SELL', 'HOLD', 'BUY'][latest_probs.argmax()]
print(f"Latest signal: {signal}  (confidence={latest_probs.max():.2%})")

# First hidden layer: linear combination of inputs + ReLU non-linearity
a1 = ReLU( W1 . x + b1 )

# Output layer: projection into class space
z2 = W2 . a1 + b2

# Map output to a probability distribution over classes (Sell/Hold/Buy)
y_hat = softmax(z2) = exp(z2_i) / sum_j exp(z2_j)

# Cross-Entropy loss used to optimize weights via Backpropagation
Loss = - sum_i y_i * log(y_hat_i)

import numpy as np
import tensorflow as tf
import onnxruntime as ort
import tf2onnx
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization, Input
from tensorflow.keras import Sequential, Model

# ── MLP for tabular signal classification — no sequence dimension needed ──
def build_mlp_model(n_features=30, n_classes=3):
    model = Sequential([
        Input(shape=(n_features,)),
        # Wide first layer: captures non-linear interactions between indicators
        Dense(128, activation='relu'),
        BatchNormalization(),
        Dropout(0.3),

        # Narrower second layer: feature compression
        Dense(64, activation='relu'),
        BatchNormalization(),
        Dropout(0.3),

        # Output: Buy=2, Sell=0, Hold=1 (sparse integer labels)
        Dense(n_classes, activation='softmax')
    ])
    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

# ── Export to ONNX for sub-0.5ms inference inside EA via onnxruntime ──
def export_to_onnx(keras_model, output_path="mlp_signal.onnx"):
    spec = (tf.TensorSpec((None, keras_model.input_shape[-1]),
                          tf.float32, name="features"),)
    tf2onnx.convert.from_keras(keras_model, input_signature=spec,
                                output_path=output_path)

# ── ONNX inference: load once, reuse session for every tick ──
def predict_onnx(session, features: np.ndarray) -> str:
    # features shape: [1, n_features], dtype float32
    inp = {session.get_inputs()[0].name: features.astype('float32')}
    probs = session.run(None, inp)[0][0]   # [p_sell, p_hold, p_buy]
    return ["SELL", "HOLD", "BUY"][probs.argmax()]

# ── Training run + Out-of-Sample evaluation ──
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score

# Tabular features (no time dimension) — indicators computed per row
X = feature_df[feature_columns].values   # shape: [n_samples, 30]
y = feature_df['label'].values           # 0=Sell, 1=Hold, 2=Buy

# shuffle=False keeps the test set as the most recent time window
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, shuffle=False
)

model = build_mlp_model(n_features=X.shape[1], n_classes=3)
model.fit(
    X_train, y_train,
    validation_split=0.15,
    epochs=40,
    batch_size=64,
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=6, restore_best_weights=True)],
    verbose=1
)

y_pred = model.predict(X_test).argmax(axis=1)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=['Sell', 'Hold', 'Buy']))

# Export + single-sample ONNX inference (production path used in the EA)
export_to_onnx(model, "mlp_signal.onnx")
session = ort.InferenceSession("mlp_signal.onnx")
print("Live signal:", predict_onnx(session, X_test[-1:]))

# Gini impurity — used to pick the best split at each tree node
Gini(t) = 1 - sum_c ( p_c )^2      # p_c = fraction of class-c samples in node t

# Impurity reduction from a split — the tree picks the split that maximizes this
Delta_Gini = Gini(parent) - ( n_L/n * Gini(L) + n_R/n * Gini(R) )

# Each tree trains on a Bootstrap sample with a random feature subset (m ~ sqrt(p))
D_b = Bootstrap(D),   features_b = RandomSubset(features, m)

# Final prediction: majority vote across B independent trees
y_hat = mode( T_1(x), T_2(x), ..., T_B(x) )

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import TimeSeriesSplit
import matplotlib.pyplot as plt

# ── Conservative hyperparameters tuned for noisy financial tabular data ──
model = RandomForestClassifier(
    n_estimators=300,        # 300 trees: accuracy plateaus beyond ~400
    max_depth=10,            # shallow depth prevents memorising tick noise
    min_samples_leaf=20,    # at least 20 samples per leaf — key overfitting guard
    max_features='sqrt',    # random feature subsetting ensures tree diversity
    class_weight='balanced', # compensates for imbalanced Up/Neutral/Down classes
    n_jobs=-1,              # parallel training across all CPU cores
    random_state=42
)

# ── Purged Walk-Forward Validation — critical: no future leakage in splits ──
tscv = TimeSeriesSplit(n_splits=5, gap=5)  # gap=5 avoids look-ahead bias
oos_scores = []
for fold, (train_idx, test_idx) in enumerate(tscv.split(X), 1):
    model.fit(X[train_idx], y[train_idx])
    score = model.score(X[test_idx], y[test_idx])
    oos_scores.append(score)
    print(f"Fold {fold} OOS Accuracy: {score:.2%}")
print(f"Mean OOS Accuracy: {np.mean(oos_scores):.2%} ± {np.std(oos_scores):.2%}")

# ── Feature Importance — reveals which indicators drive prediction ──
importances = sorted(
    zip(feature_names, model.feature_importances_),
    key=lambda x: x[1], reverse=True
)
for name, score in importances[:10]:
    print(f"  {name:<20} {score:.4f}")

# ── Final model fit + holdout evaluation + single-sample prediction ──
from sklearn.metrics import classification_report, accuracy_score

# Fit on the full Walk-Forward training window, then evaluate on the final holdout
train_idx, test_idx = list(tscv.split(X))[-1]  # most recent fold = closest to live data
model.fit(X[train_idx], y[train_idx])
y_pred = model.predict(X[test_idx])

print(f"Holdout Accuracy: {accuracy_score(y[test_idx], y_pred):.4f}")
print(classification_report(y[test_idx], y_pred, target_names=['Down', 'Neutral', 'Up']))

# Prediction with class probabilities for the newest available candle
latest_probs = model.predict_proba(X[-1:])[0]
signal = ['Down', 'Neutral', 'Up'][latest_probs.argmax()]
print(f"Latest signal: {signal}  (confidence={latest_probs.max():.2%})")

# Overall objective: prediction loss + model-complexity penalty
Obj = sum_i l(y_i, y_hat_i) + sum_k Omega(f_k)

# Regularization term — penalizes number of leaves (T) and leaf-weight magnitude (w)
Omega(f) = gamma * T + (1/2) * lambda * ||w||^2

# Second-order Taylor approximation of the loss around the current prediction
l(y, y_hat + f) ~= l(y, y_hat) + g*f + (1/2)*h*f^2      # g,h = first and second derivatives

# Split gain — the criterion used to choose the best split at each boosting step
Gain = (1/2) * [ G_L^2/(H_L+lambda) + G_R^2/(H_R+lambda) - (G_L+G_R)^2/(H_L+H_R+lambda) ] - gamma

import xgboost as xgb
import optuna
from sklearn.model_selection import TimeSeriesSplit
import numpy as np

# ── Optuna objective: Walk-Forward CV inside each trial prevents leakage ──
def objective(trial):
    params = {
        'max_depth':     trial.suggest_int('max_depth', 4, 6),
        'learning_rate': trial.suggest_float('learning_rate', 1e-2, 0.1, log=True),
        'n_estimators':  trial.suggest_int('n_estimators', 500, 2000),
        'subsample':     trial.suggest_float('subsample', 0.7, 0.9),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.6, 0.9),
        'reg_lambda':    trial.suggest_float('reg_lambda', 1, 10), # L2 regularisation
        'objective': 'multi:softprob', 'num_class': 3,
        'eval_metric': 'mlogloss', 'n_jobs': -1,
    }
    # TimeSeriesSplit ensures no look-ahead bias across folds
    tscv = TimeSeriesSplit(n_splits=4, gap=5)
    oos_scores = []
    for tr, te in tscv.split(X):
        m = xgb.XGBClassifier(**params)
        m.fit(X[tr], y[tr], eval_set=[(X[te], y[te])],
              early_stopping_rounds=30, verbose=False)
        oos_scores.append(m.score(X[te], y[te]))
    return np.mean(oos_scores)

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100, show_progress_bar=True)

# ── Serve best model via FastAPI — EA calls POST /predict per tick ──
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
best_model = xgb.XGBClassifier(**study.best_params)
best_model.fit(X, y)

class Features(BaseModel):
    values: list[float]

@app.post("/predict")
def predict(req: Features):
    probs = best_model.predict_proba([req.values])[0]
    return {"signal": ["SELL", "HOLD", "BUY"][probs.argmax()],
            "confidence": float(probs.max())}

# ── Holdout evaluation of the Optuna-tuned model + single-sample prediction ──
from sklearn.metrics import classification_report, accuracy_score
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

final_model = xgb.XGBClassifier(**study.best_params)
final_model.fit(X_train, y_train)

y_pred = final_model.predict(X_test)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=['Sell', 'Hold', 'Buy']))

# Single-sample probability prediction — same call used inside the /predict endpoint
probs = final_model.predict_proba(X_test[-1:])[0]
print(f"Latest signal: {['SELL','HOLD','BUY'][probs.argmax()]}  (confidence={probs.max():.2%})")

# Fama-French style factor model: excess return as a linear combination of risk factors
r_i - r_f = alpha_i + beta_1*MKT + beta_2*SMB + beta_3*HML + epsilon_i

# Ridge coefficient estimate with an L2 penalty to control multicollinearity between factors
beta_hat = argmin_beta  ||y - X*beta||^2 + lambda * ||beta||^2

# Information Coefficient — rank correlation between predicted and actual returns
IC = corr( rank(y_hat), rank(y) )

import pandas as pd
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.preprocessing import RobustScaler
import alphalens as al

# ── Build composite alpha factor from three orthogonal signal families ──
def build_factor_score(df: pd.DataFrame) -> pd.DataFrame:
    # Momentum: 20-day price return — buy recent winners
    df['momentum']   = df['close'].pct_change(20)
    # Volatility: normalised ATR — penalise high-noise assets
    df['volatility']  = df['atr_14'] / df['close']
    # Value: inverse P/E → lower P/E is more attractive
    df['value']       = -df['pe_ratio']

    # Cross-sectionally scale each factor (RobustScaler handles outliers)
    scaler = RobustScaler()
    factors = scaler.fit_transform(df[['momentum', 'volatility', 'value']])

    # Ridge regression learns optimal factor weights from realised forward returns
    model = Ridge(alpha=1.0)
    model.fit(factors, df['forward_return'])
    df['factor_score'] = model.predict(factors)
    return df

# ── Evaluate with Alphalens — IC > 0.05 signals a statistically useful factor ──
factor_data = al.utils.get_clean_factor_and_forward_returns(
    factor=df['factor_score'],
    prices=price_data,
    periods=(1, 5, 10)   # 1-day, 5-day, 10-day forward return horizons
)
ic = al.performance.factor_information_coefficient(factor_data)
print(f"Mean IC: {ic.mean():.3f}   IR: {(ic.mean()/ic.std()):.2f}")

# ── Train/test split + regression evaluation + latest cross-sectional prediction ──
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

X = factors  # scaled [momentum, volatility, value] matrix built above
y = df['forward_return'].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

model = Ridge(alpha=1.0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"Test MSE: {mean_squared_error(y_test, y_pred):.6f}")
print(f"Test R^2: {r2_score(y_test, y_pred):.4f}")

# Latest cross-section: rank assets by predicted forward return (long top decile)
latest_scores = model.predict(X[-len(symbols):])
ranked = sorted(zip(symbols, latest_scores), key=lambda x: x[1], reverse=True)
print("Top ranked assets:", ranked[:5])

# Scaled Dot-Product Attention
Attention(Q, K, V) = softmax( Q * K^T / sqrt(d_k) ) * V

# Combine multiple parallel attention heads to learn different relationships at once
MultiHead(Q,K,V) = Concat(head_1, ..., head_h) * W_O ,   head_i = Attention(Q*W_i^Q, K*W_i^K, V*W_i^V)

# Pinball (Quantile) loss for probabilistic P10/P50/P90 forecasting
L_q(y, y_hat) = max( q*(y - y_hat), (q-1)*(y - y_hat) )

import pytorch_lightning as pl
from pytorch_forecasting import TemporalFusionTransformer, TimeSeriesDataSet
from pytorch_forecasting.metrics import QuantileLoss

# ── Multi-source TimeSeriesDataSet ──
# known_reals: features available at prediction time (e.g. calendar, macro)
# unknown_reals: features only observed up to the encoder window
training = TimeSeriesDataSet(
    df,
    time_idx="time_idx",
    target="close",
    group_ids=["symbol"],               # one group per trading instrument
    max_encoder_length=60,              # 60-candle lookback window
    max_prediction_length=10,           # forecast 10 steps ahead simultaneously
    time_varying_known_reals=[          # available during the decoder phase
        "rsi", "atr", "sentiment_score",
        "hour_of_day", "day_of_week"    # session / seasonality signals
    ],
    time_varying_unknown_reals=[        # observed only in the encoder
        "close", "volume", "spread"
    ],
    static_categoricals=["asset_class"], # FX, Crypto, Equity — handled by VSN
    target_normalizer="softplus",       # ensures non-negative price targets
)

# ── Build TFT with Quantile Loss for probabilistic forecasting ──
# quantiles=[0.1, 0.5, 0.9] → P10/P50/P90 confidence bands per candle
tft = TemporalFusionTransformer.from_dataset(
    training,
    hidden_size=64,
    attention_head_size=4,              # Multi-Head Self-Attention heads
    dropout=0.2,
    hidden_continuous_size=16,
    loss=QuantileLoss(quantiles=[0.1, 0.5, 0.9]),
    log_interval=10,
    learning_rate=3e-3,
)

# ── Train with early stopping to prevent overfitting ──
trainer = pl.Trainer(max_epochs=30, gradient_clip_val=0.1,
                     accelerator="gpu", devices=1)
trainer.fit(tft, train_dataloaders=train_loader, val_dataloaders=val_loader)

# ── Probabilistic prediction: returns P10/P50/P90 bands for 10 candles ──
raw_predictions = tft.predict(val_loader, mode="raw", return_x=True)
p10, p50, p90 = raw_predictions.output.prediction.unbind(dim=-1)

# ── Evaluate probabilistic forecasts + single-series prediction ──
from pytorch_forecasting.metrics import QuantileLoss

# Quantile loss on the validation set — lower is better; compares P10/P50/P90 to actuals
val_loss = trainer.validate(tft, dataloaders=val_loader)[0]
print(f"Validation Quantile Loss: {val_loss['val_loss']:.4f}")

# Point forecast accuracy using the P50 (median) quantile as the prediction
actuals = torch.cat([y[0] for x, y in iter(val_loader)])
mae = (p50 - actuals).abs().mean()
print(f"MAE (P50 vs actual close): {mae:.5f}")

# Forecast the next 10 candles for a single symbol from the latest known window
new_prediction = tft.predict(new_raw_data, mode="quantiles",
                              trainer_kwargs=dict(accelerator="cpu"))
p10, p50, p90 = new_prediction[0].unbind(dim=-1)
print(f"Next-candle forecast: P10={p10[0]:.5f}  P50={p50[0]:.5f}  P90={p90[0]:.5f}")

# Raw attention score for each time step relative to the context vector
e_t = v^T * tanh( W_h * h_t + b )

# Normalize scores into a probability distribution over all time steps (60 candles)
alpha_t = exp(e_t) / sum_j exp(e_j)

# Final context vector: weighted average of all hidden states based on importance
context = sum_t alpha_t * h_t

import tensorflow as tf
from tensorflow.keras.layers import LSTM, Dense, Dropout, Layer, Input
from tensorflow.keras import Model

# ── Custom Temporal Attention layer — additive (Bahdanau-style) ──
# Computes a scalar alignment score for each time step, then softmax-normalises
class TemporalAttention(Layer):
    def __init__(self, units=64, **kwargs):
        super().__init__(**kwargs)
        self.W = Dense(units)   # projects LSTM hidden states
        self.V = Dense(1)      # collapses to a single scalar score

    def call(self, lstm_outputs, return_weights=False):
        # lstm_outputs shape: [batch, T, units]
        scores = self.V(tf.nn.tanh(self.W(lstm_outputs)))  # [batch, T, 1]
        weights = tf.nn.softmax(scores, axis=1)            # attention distribution over time
        # Weighted sum: high-weight time steps contribute more to prediction
        context = tf.reduce_sum(weights * lstm_outputs, axis=1)  # [batch, units]
        if return_weights:
            return context, weights  # weights → Attention Heatmap visualisation
        return context

# ── Build LSTM + Temporal Attention model using Functional API ──
inp = Input(shape=(60, 11))             # [Batch, 60 candles, 11 features]
x = LSTM(128, return_sequences=True)(inp)  # full sequence → all hidden states h_1 … h_60
x = Dropout(0.25)(x)
context = TemporalAttention(64)(x)         # squeeze sequence → context vector
x = Dropout(0.2)(context)
x = Dense(32, activation='relu')(x)
out = Dense(3, activation='softmax')(x)  # Up / Neutral / Down

model = Model(inp, out)
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# ── Training run + evaluation + attention-weight inspection ──
from sklearn.metrics import classification_report, accuracy_score

X, y, scaler = make_sequences(df, seq_len=60)
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

model.fit(
    X_train, y_train,
    validation_split=0.15,
    epochs=50,
    batch_size=32,
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=8, restore_best_weights=True)],
    verbose=1
)

y_pred = model.predict(X_test).argmax(axis=1)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=['Down', 'Neutral', 'Up']))

# Extract per-candle attention weights for the latest window — powers the Heatmap UI
attention_layer = TemporalAttention(64)
context, weights = attention_layer(model.layers[1](X_test[-1:]), return_weights=True)
top_candles = weights[0, :, 0].numpy().argsort()[-5:][::-1]
print("Most influential candles (index from window start):", top_candles)

# 2D convolution operation over the candlestick image with filter K
S(i,j) = sum_m sum_n  I(i+m, j+n) * K(m,n)

# Non-linearity applied after convolution
A(i,j) = ReLU( S(i,j) + b )

# Max pooling to reduce dimensionality and add robustness to small shifts
P(i,j) = max( A(2i:2i+1, 2j:2j+1) )

import numpy as np
from tensorflow.keras.layers import (Conv2D, MaxPooling2D, GlobalAveragePooling2D,
                                            Dense, Dropout, BatchNormalization, Input)
from tensorflow.keras import Sequential
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# ── Convert a 20-candle OHLCV window into a 2D candlestick image ──
# Output shape: [20, 64, 3] → time steps × price-channels × RGB
def ohlcv_to_image(df_slice, img_h=64):
    n = len(df_slice)
    img = np.zeros((n, img_h, 3), dtype=np.float32)
    lo, hi = df_slice['low'].min(), df_slice['high'].max()
    def norm(v): return int((v - lo) / (hi - lo + 1e-9) * (img_h - 1))
    for i, (_, row) in enumerate(df_slice.iterrows()):
        # Candle body: green for bullish, red for bearish
        color = [0, 1, 0] if row.close >= row.open else [1, 0, 0]
        y0, y1 = norm(min(row.open, row.close)), norm(max(row.open, row.close))
        img[i, y0:y1+1, :] = color
        # Wicks: grey channel
        img[i, norm(row.low):norm(row.high)+1, :] = [0.5, 0.5, 0.5]
    return img

# ── CNN architecture for chart pattern classification (50+ pattern classes) ──
model = Sequential([
    Input(shape=(20, 64, 3)),
    # Block 1: low-level edge and line detection
    Conv2D(32, (3, 3), activation='relu', padding='same'),
    BatchNormalization(),
    MaxPooling2D((2, 2)),
    # Block 2: composite pattern detection (Head&Shoulders, Double Top, etc.)
    Conv2D(64, (3, 3), activation='relu', padding='same'),
    BatchNormalization(),
    MaxPooling2D((2, 2)),
    Conv2D(128, (3, 3), activation='relu', padding='same'),
    BatchNormalization(),
    # Global pooling collapses spatial dims → fixed-length descriptor
    GlobalAveragePooling2D(),
    Dense(128, activation='relu'),
    Dropout(0.4),
    # 50+ pattern classes — use categorical_crossentropy with one-hot labels
    Dense(50, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy',
              metrics=['accuracy'])

# ── Image dataset generation + training + evaluation ──
from sklearn.metrics import classification_report, accuracy_score
import numpy as np

# Build image dataset from labelled 20-candle windows
X_img = np.array([ohlcv_to_image(df.iloc[i:i+20]) for i in start_indices])
y_img = np.array(pattern_labels)  # integer-encoded, one of 50 pattern classes

split = int(len(X_img) * 0.8)
X_train, X_test = X_img[:split], X_img[split:]
y_train, y_test = y_img[:split], y_img[split:]

datagen = ImageDataGenerator(horizontal_flip=False, brightness_range=[0.9, 1.1])
model.fit(
    datagen.flow(X_train, tf.keras.utils.to_categorical(y_train, 50), batch_size=32),
    validation_data=(X_test, tf.keras.utils.to_categorical(y_test, 50)),
    epochs=40,
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=6, restore_best_weights=True)]
)

y_pred = model.predict(X_test).argmax(axis=1)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred))

# Classify the most recent 20-candle chart image
latest_img = ohlcv_to_image(df.tail(20))[np.newaxis, ...]
pred_class = model.predict(latest_img).argmax()
print(f"Detected pattern class: {pattern_names[pred_class]}")

# Standard DQN target — suffers from optimistic overestimation bias in value estimates
y_DQN = r + gamma * max_a  Q(s', a; theta_target)

# Double DQN target — action selected by the online network, evaluated by the target network (reduces bias)
y_DDQN = r + gamma * Q( s', argmax_a Q(s', a; theta_online); theta_target )

# Loss function — mean squared Temporal Difference (TD) error
L(theta) = E[ ( y_DDQN - Q(s, a; theta_online) )^2 ]

import gym
import numpy as np
import tensorflow as tf
from collections import deque
import random

# ── Custom Gym environment — simulates order execution on historical OHLCV ──
class TradingEnv(gym.Env):
    def __init__(self, df, window=60):
        super().__init__()
        self.df = df
        self.window = window
        self.action_space = gym.spaces.Discrete(3)   # 0=Sell, 1=Hold, 2=Buy
        # State: last `window` candles × n_features
        self.observation_space = gym.spaces.Box(
            low=-np.inf, high=np.inf,
            shape=(window, df.shape[1]), dtype=np.float32)

    def step(self, action):
        prev_sharpe = self._calc_sharpe()
        self._execute_order(action)
        self.current_step += 1
        # Reward: incremental Sharpe Ratio — penalises both loss and excess risk
        reward = self._calc_sharpe() - prev_sharpe
        done = self.current_step >= len(self.df) - 1
        return self._get_obs(), reward, done, {}

# ── Experience Replay Buffer (capacity: 50 k transitions) ──
memory = deque(maxlen=50_000)

# ── DDQN training step: decouples action selection from value estimation ──
def train_step(online_net, target_net, gamma=0.99, batch_size=64):
    if len(memory) < batch_size:
        return
    batch = random.sample(memory, batch_size)
    states, actions, rewards, next_states, dones = map(np.array, zip(*batch))

    # Double DQN: online net picks the best next action, target net evaluates it
    best_actions = online_net(next_states).numpy().argmax(axis=1)
    next_q = target_net(next_states).numpy()
    targets = rewards + gamma * next_q[np.arange(batch_size), best_actions] * (~dones)

    # Bellman update — only update Q-values for taken actions
    with tf.GradientTape() as tape:
        q_pred = online_net(states)
        q_taken = tf.reduce_sum(q_pred * tf.one_hot(actions, 3), axis=1)
        loss = tf.reduce_mean(tf.square(targets - q_taken))   # MSE (Huber also works)
    online_net.optimizer.minimize(loss, online_net.trainable_weights, tape=tape)

# ── Sync target network every 500 steps to stabilise training ──
if step % 500 == 0:
    target_net.set_weights(online_net.get_weights())

# ── Full training loop over episodes + trained-policy inference ──
online_net = build_q_network(input_shape=(60, n_features), n_actions=3)
target_net = build_q_network(input_shape=(60, n_features), n_actions=3)
target_net.set_weights(online_net.get_weights())

env = TradingEnv(train_df, window=60)
epsilon, epsilon_min, epsilon_decay = 1.0, 0.05, 0.995

for episode in range(500):
    state, done, ep_reward = env.reset(), False, 0
    while not done:
        # Epsilon-greedy exploration — decays toward pure exploitation over training
        if np.random.rand() < epsilon:
            action = env.action_space.sample()
        else:
            action = int(online_net(state[np.newaxis]).numpy().argmax())

        next_state, reward, done, _ = env.step(action)
        memory.append((state, action, reward, next_state, done))
        train_step(online_net, target_net)
        state, ep_reward = next_state, ep_reward + reward

    epsilon = max(epsilon_min, epsilon * epsilon_decay)
    if episode % 500 == 0:
        target_net.set_weights(online_net.get_weights())
    if episode % 50 == 0:
        print(f"Episode {episode}  reward={ep_reward:.3f}  epsilon={epsilon:.3f}")

# ── Evaluate the trained policy on unseen data (epsilon=0 → fully greedy) ──
test_env = TradingEnv(test_df, window=60)
state, done, total_reward = test_env.reset(), False, 0
while not done:
    action = int(online_net(state[np.newaxis]).numpy().argmax())
    state, reward, done, _ = test_env.step(action)
    total_reward += reward
print(f"Out-of-sample cumulative reward (Sharpe-based): {total_reward:.3f}")

# Reconstruction loss — the autoencoder must be able to reconstruct the original data from latent space
L_R = E[ || X - Decoder(Encoder(X)) ||^2 ]

# Supervised loss — the next-step prediction in latent space must match the real data dynamics
L_S = E[ || h_t - g(h_(t-1), z_t) ||^2 ]

# Adversarial loss — the discriminator must tell real from synthetic, the generator must fool it
L_U = E[ log D(H) ] + E[ log(1 - D(H_hat)) ]

import numpy as np
from ydata_synthetic.synthesizers.timeseries import TimeGAN

# ── TimeGAN hyperparameters — tune noise_dim and hidden_dim for your dataset ──
gan_args = {
    'batch_size': 128,
    'lr': 5e-4,          # lower LR stabilises adversarial training
    'noise_dim': 32,     # latent space dimension for the generator
    'seq_len': 60,       # must match encoder window of downstream model
    'n_features': 5,    # OHLCV — extend to 11 to include indicators
}

# gamma: weight of supervised (reconstruction) loss vs adversarial loss
synth = TimeGAN(model_parameters=gan_args, hidden_dim=24,
                seq_len=60, n_seq=5, gamma=1)

# Increase train_steps to 20 k–50 k if mode collapse appears
synth.train(real_data, train_steps=10_000)

# ── Sample synthetic sequences for downstream data augmentation ──
synthetic_data = synth.sample(n_samples=1_000)  # shape: [1000, 60, 5]

# ── TSTR evaluation: Train on Synthetic, Test on Real ──
# A high TSTR accuracy proves the synthetic data captures real market dynamics
model_synth = train_lstm(synthetic_data)
tstr_acc, _ = model_synth.evaluate(real_test_X, real_test_y, verbose=0)
print(f"TSTR Accuracy (synthetic→real): {tstr_acc:.2%}")

# ── Discriminative Score — the standard quality metric for synthetic time series ──
# Train a classifier to distinguish real vs synthetic sequences.
# Score near 0.5 = indistinguishable (ideal); near 1.0 = poor-quality synthetic data.
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

real_flat = real_data.reshape(len(real_data), -1)
synth_flat = synthetic_data.reshape(len(synthetic_data), -1)

X_disc = np.vstack([real_flat, synth_flat])
y_disc = np.concatenate([np.ones(len(real_flat)), np.zeros(len(synth_flat))])
X_train, X_test, y_train, y_test = train_test_split(X_disc, y_disc, test_size=0.3, random_state=42)

clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)
disc_score = accuracy_score(y_test, clf.predict(X_test))
print(f"Discriminative Score: {disc_score:.3f}  (0.5 = ideal, indistinguishable from real)")

# ── TSTR classification example — train an LSTM purely on synthetic sequences ──
X_synth, y_synth = label_sequences(synthetic_data)   # forward-return based labels
model_synth = build_lstm_model(seq_len=60, n_features=5, n_classes=3)
model_synth.fit(X_synth, y_synth, epochs=30, batch_size=32, verbose=0)
tstr_acc = model_synth.evaluate(real_test_X, real_test_y, verbose=0)[1]
print(f"TSTR Accuracy (trained on synthetic, tested on real): {tstr_acc:.2%}")

# Compress the input into a lower-dimensional latent space (bottleneck)
z = Encoder(x) ,   dim(z) << dim(x)

# Reconstruct the input from the compressed representation
x_hat = Decoder(z)

# Reconstruction error — the main criterion used for anomaly scoring
L = || x - x_hat ||^2 = || x - Decoder(Encoder(x)) ||^2

import tensorflow as tf
from tensorflow.keras.layers import Dense, Input, Dropout
from tensorflow.keras.models import Model
from sklearn.cluster import KMeans

# ── Bottleneck Autoencoder for non-linear factor extraction ──
# Encoder compresses 40 market features into a 2D latent embedding
inp   = Input(shape=(40,))
x     = Dense(32, activation='relu')(inp)
x     = Dropout(0.1)(x)
x     = Dense(16, activation='relu')(x)
# 2D latent space → directly visualisable as a scatter plot
latent = Dense(2, activation='linear', name='latent')(x)

# Decoder reconstructs the original feature vector from the latent code
x     = Dense(16, activation='relu')(latent)
x     = Dense(32, activation='relu')(x)
output = Dense(40, activation='linear')(x)  # MSE loss → minimise reconstruction error

autoencoder = Model(inp, output)
encoder     = Model(inp, latent)            # inference-time encoder only

autoencoder.compile(optimizer='adam', loss='mse')
autoencoder.fit(X_train, X_train, epochs=100, batch_size=64, verbose=0)

# ── Cluster latent codes into market regimes via K-Means ──
latent_features = encoder.predict(X_train, verbose=0)
kmeans  = KMeans(n_clusters=3, random_state=42, n_init=10)
regimes = kmeans.fit_predict(latent_features)
# cluster labels: 0=Trending, 1=Ranging, 2=High Volatility

# ── Reconstruction-error evaluation + anomaly / new-regime prediction ──
import numpy as np

recon = autoencoder.predict(X_test, verbose=0)
recon_error = np.mean(np.square(X_test - recon), axis=1)
print(f"Mean reconstruction error (test set): {recon_error.mean():.5f}")

# Anomaly threshold: 95th percentile of training reconstruction error
train_recon = autoencoder.predict(X_train, verbose=0)
train_error = np.mean(np.square(X_train - train_recon), axis=1)
threshold = np.percentile(train_error, 95)

# Predict on the newest market sample
latest = X_test[-1:]
latest_error = np.mean(np.square(latest - autoencoder.predict(latest, verbose=0)))
is_anomaly = latest_error > threshold
latest_regime = kmeans.predict(encoder.predict(latest, verbose=0))[0]

print(f"Latest sample: regime={['Trending','Ranging','High Volatility'][latest_regime]}, "
      f"anomaly={is_anomaly} (error={latest_error:.5f}, threshold={threshold:.5f})")

# Convert the correlation matrix into a valid metric distance for hierarchical clustering
d(i,j) = sqrt( 0.5 * (1 - rho(i,j)) )

# Cluster variance using inverse-variance weights within the cluster
V_c = w_c^T * Sigma_c * w_c ,   w_c = diag(Sigma_c)^-1 / sum(diag(Sigma_c)^-1)

# Recursive weight allocation between two sub-clusters at each binary split (Recursive Bisection)
alpha = 1 - V_1 / (V_1 + V_2) ,   w_1 *= alpha ,   w_2 *= (1 - alpha)

import pandas as pd
import numpy as np
from pypfopt import HRPOpt, expected_returns, risk_models

# ── Build daily return matrix for multi-asset portfolio ──
# Supports any mix: Forex, Gold, Crypto, Equity indices
returns = pd.DataFrame({
    'XAUUSD': gold_prices.pct_change(),
    'XAGUSD': silver_prices.pct_change(),
    'EURUSD': eurusd_prices.pct_change(),
    'GBPUSD': gbpusd_prices.pct_change(),
    'BTCUSD': btc_prices.pct_change(),
}).dropna()

# ── Run HRP: no covariance matrix inversion needed ──
# Step 1: hierarchical clustering on correlation distance matrix
# Step 2: recursive bisection to assign inverse-variance weights per cluster
hrp = HRPOpt(returns)
weights = hrp.optimize(linkage_method='ward')   # ward linkage reduces within-cluster variance

hrp.clean_weights()
print("Portfolio Allocation:", weights)
# e.g. {'XAUUSD': 0.31, 'XAGUSD': 0.19, 'EURUSD': 0.28, 'GBPUSD': 0.13, 'BTCUSD': 0.09}

# ── Evaluate expected risk-adjusted performance ──
perf = hrp.portfolio_performance(verbose=True)
# returns: (expected_annual_return, annual_volatility, Sharpe_ratio)

# ── Monthly rebalancing check — reallocate when weights drift > 5% ──
current_weights = get_current_portfolio_weights()
drift = {k: abs(current_weights[k] - weights[k]) for k in weights}
if max(drift.values()) > 0.05:
    rebalance_to_target(weights)  # sends orders to MT5/cTrader API

# ── Out-of-sample backtest: HRP allocation vs naive Equal-Weight benchmark ──
from pypfopt import HRPOpt

split = int(len(returns) * 0.7)
train_ret, test_ret = returns.iloc[:split], returns.iloc[split:]

hrp = HRPOpt(train_ret)
hrp_weights = hrp.optimize(linkage_method='ward')

equal_weights = {k: 1 / len(hrp_weights) for k in hrp_weights}

def portfolio_return(weights, ret_df):
    w = np.array([weights[c] for c in ret_df.columns])
    return (ret_df.values @ w)

hrp_pnl = portfolio_return(hrp_weights, test_ret)
eq_pnl = portfolio_return(equal_weights, test_ret)

hrp_sharpe = hrp_pnl.mean() / hrp_pnl.std() * np.sqrt(252)
eq_sharpe = eq_pnl.mean() / eq_pnl.std() * np.sqrt(252)

print(f"HRP Out-of-Sample Sharpe:          {hrp_sharpe:.2f}")
print(f"Equal-Weight Out-of-Sample Sharpe: {eq_sharpe:.2f}")
print(f"HRP Max Drawdown: {(1 - (1 + hrp_pnl).cumprod() / (1 + hrp_pnl).cumprod().cummax()).max():.2%}")

# Simple average across N independent base models
y_hat = (1/N) * sum_i( y_hat_i )

# Bates & Granger (1969) inverse-variance weighting — lower-error models get higher weight
w_i = sigma_i^-2 / sum_j( sigma_j^-2 ) ,   y_hat = sum_i( w_i * y_hat_i )

# Stacking (Wolpert, 1992) — a meta-learner g() learns the optimal non-linear combination
y_hat = g( y_hat_1, y_hat_2, ..., y_hat_N ; theta )

# Regime-gated mixture of experts — weight each model by the probability of its matching regime
y_hat = sum_r( P(regime=r | x) * y_hat_r(x) )

import numpy as np
from sklearn.model_selection import TimeSeriesSplit, cross_val_predict
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score, classification_report

# ── Base models: intentionally diverse algorithms (low error correlation) ──
base_models = {
    'rf': RandomForestClassifier(n_estimators=300, max_depth=8, random_state=42),
    'xgb': XGBClassifier(n_estimators=300, max_depth=4, learning_rate=0.05),
    'lstm_probs': None,  # pre-computed LSTM probabilities, see make_sequences() on the LSTM page
}

tscv = TimeSeriesSplit(n_splits=5)  # time-ordered folds — never shuffle financial time series

# ── Critical: generate OUT-OF-FOLD predictions for the meta-learner ──
# Using in-sample predictions here would leak information and make the
# meta-learner look far more accurate than it will be live (see Common Mistakes)
oof_rf  = cross_val_predict(base_models['rf'],  X, y, cv=tscv, method='predict_proba')[:, 1]
oof_xgb = cross_val_predict(base_models['xgb'], X, y, cv=tscv, method='predict_proba')[:, 1]
oof_lstm = lstm_oof_probs  # from a separate walk-forward LSTM training loop

# ── Meta-learner: a simple Logistic Regression stacks the three OOF prediction columns ──
meta_X = np.column_stack([oof_rf, oof_xgb, oof_lstm])
meta_model = LogisticRegression()
meta_model.fit(meta_X, y)

print("Learned ensemble weights:", dict(zip(['rf', 'xgb', 'lstm'], meta_model.coef_[0])))

# ── Fit final base models on ALL training data, then combine via the meta-learner ──
base_models['rf'].fit(X_train, y_train)
base_models['xgb'].fit(X_train, y_train)

test_meta_X = np.column_stack([
    base_models['rf'].predict_proba(X_test)[:, 1],
    base_models['xgb'].predict_proba(X_test)[:, 1],
    lstm_test_probs,
])
y_pred = meta_model.predict(test_meta_X)

print(f"Ensemble Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=['Down', 'Up']))

# ── Bates & Granger (1969) inverse-variance weighted average, computed from validation error ──
from sklearn.metrics import mean_squared_error

val_errors = {
    'rf':  mean_squared_error(y_val, rf_val_pred),
    'xgb': mean_squared_error(y_val, xgb_val_pred),
    'lstm': mean_squared_error(y_val, lstm_val_pred),
}
inv_var = {k: 1 / v for k, v in val_errors.items()}
total = sum(inv_var.values())
weights = {k: v / total for k, v in inv_var.items()}
print("Bates-Granger weights:", weights)

ensemble_test_pred = (
    weights['rf']   * rf_test_pred +
    weights['xgb']  * xgb_test_pred +
    weights['lstm'] * lstm_test_pred
)

# ── Compare ensemble MSE against each individual model AND the naive equal-weight average ──
naive_avg_pred = (rf_test_pred + xgb_test_pred + lstm_test_pred) / 3

results = {
    'RF alone':            mean_squared_error(y_test, rf_test_pred),
    'XGBoost alone':       mean_squared_error(y_test, xgb_test_pred),
    'LSTM alone':          mean_squared_error(y_test, lstm_test_pred),
    'Equal-weight ensemble': mean_squared_error(y_test, naive_avg_pred),
    'Bates-Granger ensemble': mean_squared_error(y_test, ensemble_test_pred),
}
for name, mse in sorted(results.items(), key=lambda x: x[1]):
    print(f"{name:24s} MSE = {mse:.6f}")

// Volatility-adjusted position sizing based on ATR
#include 
CTrade trade;

input double RiskPercent = 1.0;      // risk per trade, % of balance
input int    AtrPeriod   = 14;
int atrHandle;

int OnInit() {
   atrHandle = iATR(_Symbol, _Period, AtrPeriod);
   if(atrHandle == INVALID_HANDLE) return(INIT_FAILED);
   return(INIT_SUCCEEDED);
}

double CalculateLotSize(double stopLossPoints) {
   double atr[];
   CopyBuffer(atrHandle, 0, 0, 1, atr);
   double riskAmount  = AccountInfoDouble(ACCOUNT_BALANCE) * RiskPercent / 100.0;
   double tickValue   = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double lot = riskAmount / (stopLossPoints * tickValue);
   return NormalizeDouble(lot, 2);
}

void OnTick() {
   static datetime lastBar = 0;
   datetime currentBar = iTime(_Symbol, _Period, 0);
   if(currentBar == lastBar) return;   // process once per new candle, not every tick
   lastBar = currentBar;

   double atr[];
   CopyBuffer(atrHandle, 0, 0, 1, atr);
   double slPoints = atr[0] / _Point * 1.5;
   double lot = CalculateLotSize(slPoints);

   // CTrade handles requote retry, slippage and price normalization internally
   trade.Buy(lot, _Symbol, 0, SymbolInfoDouble(_Symbol, SYMBOL_BID) - slPoints * _Point);
}

using cAlgo.API;
using cAlgo.API.Indicators;

[Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class AtrRiskBot : Robot
{
    [Parameter("Risk %", DefaultValue = 1.0)]
    public double RiskPercent { get; set; }

    private AverageTrueRange atr;

    protected override void OnStart()
    {
        atr = Indicators.AverageTrueRange(14, MovingAverageType.Simple);
    }

    protected override void OnBar()
    {
        // Volatility-adjusted position size, mirrors the MQL5 ATR pattern
        double slPips = atr.Result.LastValue / Symbol.PipSize * 1.5;
        double riskAmount = Account.Balance * RiskPercent / 100;
        double volume = Symbol.NormalizeVolumeInUnits(riskAmount / (slPips * Symbol.PipValue));

        if (Positions.Count == 0)
        {
            // ExecuteMarketOrder returns a TradeResult with slippage/fill details
            var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, volume,
                                              "AtrRiskBot", slPips, null);
            if (!result.IsSuccessful)
                Print("Order failed: {0}", result.Error);
        }
    }
}

//@version=6
strategy("ATR Risk Strategy", overlay = true, initial_capital = 10000)

riskPercent = input.float(1.0, "Risk %", minval = 0.1)
atrLen      = input.int(14, "ATR Length")

atrVal = ta.atr(atrLen)
emaFast = ta.ema(close, 20)
emaSlow = ta.ema(close, 50)

// v6: boolean values are always strictly true/false, never na
longCondition = ta.crossover(emaFast, emaSlow)

if longCondition
    stopDistance = atrVal * 1.5
    riskAmount   = strategy.equity * riskPercent / 100
    qty = riskAmount / stopDistance
    strategy.entry("Long", strategy.long, qty = qty)
    strategy.exit("Exit", "Long", stop = close - stopDistance)

// v6: new log.* functions for real debugging instead of plotting hacks
if barstate.islast
    log.info("ATR: {0}, Fast EMA: {1}, Slow EMA: {2}", atrVal, emaFast, emaSlow)

plot(emaFast, color = color.orange)
plot(emaSlow, color = color.blue)
alertcondition(longCondition, title = "Long Signal", message = "Buy {{ticker}} at {{close}}")

import MetaTrader5 as mt5
import pandas as pd

# Official library talks directly to the terminal — no ZMQ bridge required
if not mt5.initialize():
    print("MT5 initialize failed:", mt5.last_error())
    quit()

symbol = "EURUSD"
account_info = mt5.account_info()
balance = account_info.balance

# ATR-based position sizing, same risk model used in the MQL5/cAlgo pages
rates = mt5.copy_rates_from_pos(symbol, mt5.TIMEFRAME_H1, 0, 15)
df = pd.DataFrame(rates)
atr = (df['high'] - df['low']).rolling(14).mean().iloc[-1]

risk_percent = 1.0
point = mt5.symbol_info(symbol).point
sl_points = atr / point * 1.5
tick_value = mt5.symbol_info(symbol).trade_tick_value
lot = round((balance * risk_percent / 100) / (sl_points * tick_value), 2)

price = mt5.symbol_info_tick(symbol).ask
request = {
    "action":    mt5.TRADE_ACTION_DEAL,
    "symbol":    symbol,
    "volume":    lot,
    "type":      mt5.ORDER_TYPE_BUY,
    "price":     price,
    "sl":        price - sl_points * point,
    "deviation": 10,
    "magic":     123456,
    "type_filling": mt5.ORDER_FILLING_IOC,
}
result = mt5.order_send(request)
if result.retcode != mt5.TRADE_RETCODE_DONE:
    print(f"Order failed, retcode={result.retcode}")

mt5.shutdown()