📌 Fractal Adaptive Moving Average (FRAMA) – Адаптивная скользящая средняя на фрактальной основе🧑‍💻

Суть индикатора:🛠️

FRAMA — это усовершенствованная скользящая средняя, предложенная Джоном Эйлерсом, которая:

- адаптируется к рыночной волатильности,

- становится гладкой во флете и быстрой в тренде,

- основана на оценке фрактальной размерности цены (измерение "неровности").

import ccxt
import pandas as pd
import numpy as np

# Настройки
symbol = "BTC/USDT"
timeframe = "1h"
n = 16  # длина окна FRAMA
w = 5   # размер сегмента внутри окна

exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

def frama(close, n=16, w=5):
    alpha_min = 0.01
    alpha_max = 1.0
    frama = [close[0]]

    for i in range(1, len(close)):
        if i < n:
            frama.append(close[i])
            continue

        hl = close[i - n + 1:i + 1]
        hl1 = close[i - n + 1:i - n//2 + 1]
        hl2 = close[i - n//2 + 1:i + 1]

        n1 = (hl1.max() - hl1.min()) / (n // 2)
        n2 = (hl2.max() - hl2.min()) / (n // 2)
        n3 = (hl.max() - hl.min()) / n

        if n1 > 0 and n2 > 0 and n3 > 0:
            D = (np.log(n1 + n2) - np.log(n3)) / np.log(2)
            alpha = np.exp(-4.6 * (D - 1))
            alpha = min(max(alpha, alpha_min), alpha_max)
        else:
            alpha = alpha_min

        frama_val = alpha * close[i] + (1 - alpha) * frama[-1]
        frama.append(frama_val)

    return pd.Series(frama, index=close.index)

# Применение
df["frama"] = frama(df["close"])

# Вывод последних значений
print(df[["ts", "close", "frama"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Order Book Depth Shift Detector – Реакция на сдвиг в плотности стакана🧑‍💻

Суть стратегии:🚀

Стакан заявок (Order Book) отражает текущие уровни спроса и предложения.
Depth Shift Detector отслеживает внезапные изменения в плотности ордеров — например:

- Появление/исчезновение крупных стен (bid/ask walls)

- Смещение объёмов ближе/дальше от текущей цены

- Неожиданное перевешивание стороны (ask >> bid или наоборот)

Зачем отслеживать:💸

- Это может быть сигналом к движению цены в сторону "разгрузки"

- Крупные лимитные ордера влияют на ликвидность и исполнение

- В High Frequency Trading и скальпинге — ключевая информация

import ccxt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 20
poll_interval = 3  # секунд

def get_depth_snapshot():
    ob = exchange.fetch_order_book(symbol, limit=depth_limit)
    bids = {round(price, 2): size for price, size in ob['bids']}
    asks = {round(price, 2): size for price, size in ob['asks']}
    return bids, asks

prev_bids, prev_asks = get_depth_snapshot()

while True:
    time.sleep(poll_interval)
    bids, asks = get_depth_snapshot()

    for price in bids:
        prev_size = prev_bids.get(price, 0)
        curr_size = bids[price]
        if curr_size > prev_size * 2 and curr_size > 10:
            print(f"🔵 Увеличение BID на {price}: {prev_size:.2f} → {curr_size:.2f}")
        elif curr_size < prev_size * 0.5 and prev_size > 10:
            print(f"⚠️ Снятие BID на {price}: {prev_size:.2f} → {curr_size:.2f}")

    for price in asks:
        prev_size = prev_asks.get(price, 0)
        curr_size = asks[price]
        if curr_size > prev_size * 2 and curr_size > 10:
            print(f"🔴 Увеличение ASK на {price}: {prev_size:.2f} → {curr_size:.2f}")
        elif curr_size < prev_size * 0.5 and prev_size > 10:
            print(f"⚠️ Снятие ASK на {price}: {prev_size:.2f} → {curr_size:.2f}")

    prev_bids, prev_asks = bids, asks

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌 Hull Moving Average Crossover – Cтратегия пересечения HMA🧑‍💻

Суть индикатора:🚀

Hull Moving Average (HMA) — это гладкая и быстро реагирующая скользящая средняя, разработанная Аланом Халлом.
Она снижает запаздывание обычных MA (например, EMA) и при этом остаётся плавной.

Пересечение двух HMA с разными периодами может использоваться как сигнал к входу или выходу.

Сигналы стратегии:🛠️

- Buy: HMA_fast пересекает HMA_slow снизу вверх

- Sell: HMA_fast пересекает HMA_slow сверху вниз

import ccxt
import pandas as pd
import numpy as np

def wma(series, period):
    weights = np.arange(1, period + 1)
    return series.rolling(period).apply(lambda prices: np.dot(prices, weights)/weights.sum(), raw=True)

def hma(series, period):
    half = int(period / 2)
    sqrt_p = int(np.sqrt(period))

    wma_half = wma(series, half)
    wma_full = wma(series, period)
    raw = 2 * wma_half - wma_full
    return wma(raw, sqrt_p)

# Данные с Binance
exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "1h"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# HMA
df["hma_fast"] = hma(df["close"], 14)
df["hma_slow"] = hma(df["close"], 55)

# Сигналы пересечения
df["signal"] = 0
df.loc[(df["hma_fast"] > df["hma_slow"]) & (df["hma_fast"].shift() <= df["hma_slow"].shift()), "signal"] = 1  # BUY
df.loc[(df["hma_fast"] < df["hma_slow"]) & (df["hma_fast"].shift() >= df["hma_slow"].shift()), "signal"] = -1  # SELL

# Вывод последних сигналов
print(df[["ts", "close", "hma_fast", "hma_slow", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Adaptive Stop-Loss Adjuster – Автоматическая адаптация стоп-лосса🧑‍💻

Суть идеи:🛠️

Adaptive Stop-Loss Adjuster — инструмент, который динамически перемещает стоп-лосс в зависимости от:

- волатильности (ATR)

- текущей прибыли

- тренда (EMA, FRAMA и др.)

- времени в сделке

- структуры рынка (локальные минимумы/максимумы)

Цель: 💸 максимизировать удержание прибыли и минимизировать убытки, не выходя слишком рано.

import ccxt
import pandas as pd
import talib

# Настройки
symbol = "BTC/USDT"
timeframe = "1h"
exchange = ccxt.binance()
risk_multiplier = 2.0
entry_price = 27000
position_type = "long"  # или "short"

# Данные
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=100)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)

# Последние значения
atr = df["atr"].iloc[-1]
current_price = df["close"].iloc[-1]

# Начальный стоп
if position_type == "long":
    stop = entry_price - risk_multiplier * atr
    new_stop = max(stop, current_price - risk_multiplier * atr)
else:
    stop = entry_price + risk_multiplier * atr
    new_stop = min(stop, current_price + risk_multiplier * atr)

print(f"ATR: {atr:.2f}")
print(f"Начальный стоп: {stop:.2f}")
print(f"Адаптивный стоп: {new_stop:.2f}")

#инструмент

📌 Подпишись  Crypto Python❗️

📌 Chande Momentum Oscillator Strategy – Фильтрация силы движения🧑‍💻

Суть индикатора:🛠️

Chande Momentum Oscillator (CMO) — осциллятор, разработанный Тушаром Чандом, отражает силу направленного движения цены.
Он похож на RSI, но:

- Использует абсолютные значения приростов и спадов

- Колеблется от −100 до +100

- Быстро реагирует на смену импульса

Типовые сигналы:💸

- CMO > +50 → сильный восходящий импульс (возможность входа в лонг)

- CMO < −50 → сильный нисходящий импульс (шорт или избегать лонга)

- CMO между −20 и +20 → флет / слабое движение

- Пересечения нуля → смена направления

import ccxt
import pandas as pd
import talib

# Настройки
exchange = ccxt.binance()
symbol = "BTC/USDT"
timeframe = "1h"
limit = 200

# Получение данных
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт CMO
df["cmo"] = talib.CMO(df["close"], timeperiod=14)

# Сигналы
df["signal"] = 0
df.loc[df["cmo"] > 50, "signal"] = 1   # Buy
df.loc[df["cmo"] < -50, "signal"] = -1  # Sell

# Вывод последних значений
print(df[["ts", "close", "cmo", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Volume Profile Range Reversion – Возврат к зоне наибольшей ликвидности (Value Area)🧑‍💻

Суть стратегии:🛠️

Volume Profile отображает, где за определённый период было проторговано наибольшее количество объёма по ценам.
Зона с наибольшей активностью (называемая POC — Point of Control) часто выступает как магнит для цены, особенно в отсутствии тренда.

Стратегия Range Reversion предполагает:🛠️

- Если цена отклонилась от POC, вероятен возврат

- Вход осуществляется на возврат к зоне ликвидности

- Часто используется внутри дня и в боковике

import ccxt
import pandas as pd
import numpy as np

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="15m", limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Построение volume profile (по ценам close)
bins = np.linspace(df["close"].min(), df["close"].max(), 50)
df["price_bin"] = pd.cut(df["close"], bins)
vp = df.groupby("price_bin")["volume"].sum()
poc_bin = vp.idxmax()
poc_center = poc_bin.mid

# Сигнал: если цена >1% выше или ниже POC — ждать возврат
last_price = df["close"].iloc[-1]
distance = (last_price - poc_center) / poc_center * 100

print(f"POC (центр зоны): {poc_center:.2f}")
print(f"Последняя цена:  {last_price:.2f}")
print(f"Отклонение от POC: {distance:.2f}%")

if abs(distance) > 1:
    print("⚠️ Цена далеко от зоны объёма — возможно возвращение к POC (вход против движения)")
else:
    print("Цена вблизи ликвидности — сигналов нет")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌 ETF vs Futures Arbitrage – Арбитраж между ETF и фьючерсами🧑‍💻

Суть стратегии:🚀

ETF (биржевые фонды) отражают стоимость базового актива (например, BTC через $BITO, ETH через $ETHE), но торгуются на фондовом рынке,
в то время как фьючерсы — на срочном.

В силу разных механизмов ценообразования, между ними может возникать временной дисбаланс, который можно использовать для арбитража.

Риски и особенности:🛠️

- ETF может не совпадать 1:1 с базовым активом

- Комиссии и издержки по шорту (в ETF особенно)

- Требуется доступ к фондовому и фьючерсному рынку одновременно

-Задержки в исполнении или отклонения ликвидности

# Предположим, вы получаете цены из двух источников:
etf_price = 84.00     # цена BITO
futures_price = 84500 # цена BTC фьючерса

# Переводим ETF в "BTC-эквивалент"
btc_per_etf = 0.001   # условно 1 ETF = 0.001 BTC (зависит от структуры фонда)
etf_price_btc = etf_price / btc_per_etf

spread_pct = (etf_price_btc - futures_price) / futures_price * 100

print(f"BITO в BTC: ${etf_price_btc:.2f}")
print(f"BTC Futures: ${futures_price:.2f}")
print(f"Спред: {spread_pct:.2f}%")

if abs(spread_pct) > 1.0:
    print("⚠️ Возможность арбитража между ETF и фьючерсом")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Order Flow Delta Spike Strategy – Стратегия по резким всплескам дельты ордеров🧑‍💻

Суть стратегии:🚀

Delta ордеров — это разница между рыночными ордерами на покупку и продажу за определённый интервал времени.

Delta Spike Strategy строится на обнаружении резких всплесков этой дельты, которые могут свидетельствовать о:

- агрессивных входах крупного игрока,

- начале импульсного движения,

- либо ложном вбросе ликвидности (фейковый импульс).

Ключевые сигналы:💸

- Резкий положительный спайк дельты → сигнал на лонг

-Резкий отрицательный спайк → сигнал на шорт

Подтверждение можно получать от:🧨

- увеличенного объёма

- свечной формации (например, пробой)

- давления из стакана

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
limit = 500

# Получение тиковых сделок
trades = exchange.fetch_trades(symbol, limit=limit)
df = pd.DataFrame(trades)

# Определяем сторону сделки: True = buy, False = sell
df["side"] = df["side"].apply(lambda x: 1 if x == 'buy' else -1)
df["delta"] = df["amount"] * df["side"]

# Агрегируем дельту по минутам
df["ts"] = pd.to_datetime(df["timestamp"], unit="ms")
df.set_index("ts", inplace=True)
delta_per_min = df["delta"].resample("1min").sum()

# Выявляем спайки дельты
z_score = (delta_per_min - delta_per_min.rolling(20).mean()) / delta_per_min.rolling(20).std()
signals = z_score[abs(z_score) > 2]  # только резкие всплески

print(signals.tail())

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Meta-Learning for Strategy Selection – Выбор стратегии под текущий режим рынка с помощью мета-обучения🧑‍💻

Суть идеи:🚀

Meta-learning (мета-обучение) — это подход, при котором модель обучается выбирать или адаптировать другую модель/стратегию в зависимости от контекста.

В трейдинге это используется для:🛠️

- автоматического выбора наиболее эффективной стратегии

- подстраивания под текущий рыночный режим (тренд, флет, высокая волатильность и т.д.)

- повышения устойчивости и адаптивности системы

Как это работает:💸

1. Собирается пул стратегий:

2. Собираются фичи текущего рынка:

3. Модель-маршрутизатор (meta-model):

Обучается по истории, какая стратегия работает в каких условиях

Выдаёт предсказание, какую стратегию применять сейчас

import pandas as pd
from sklearn.ensemble import RandomForestClassifier

# Допустим, у нас есть:
# - данные о рынке (X)
# - и лучшая стратегия, которая дала максимальный профит (y)

# X — фичи рынка
# y — лучшая стратегия (0 = trend, 1 = mean-reversion, 2 = breakout)
df = pd.read_csv("market_regime_features.csv")
X = df[["atr", "volatility", "trend_strength", "rsi", "slope_ema"]]
y = df["best_strategy"]

# Обучение meta-модели
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X, y)

# Текущие рыночные условия
current = pd.DataFrame([{
    "atr": 120,
    "volatility": 0.018,
    "trend_strength": 0.7,
    "rsi": 65,
    "slope_ema": 0.04
}])

# Предсказание
strategy_id = clf.predict(current)[0]
strategies = ["trend", "mean-reversion", "breakout"]
print(f"Рекомендуемая стратегия: {strategies[strategy_id]}")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Liquidity Heatmap Generator – Генератор тепловой карты ликвидности по ценовым уровням🧑‍💻

Суть инструмента:🛠️

Liquidity Heatmap визуализирует, где в стакане сконцентрирована ликвидность — крупные лимитные заявки на покупку и продажу.

Это позволяет:💸

- Видеть уровни поддержки/сопротивления,

- Предугадывать реакцию цены на крупные кластеры ликвидности,

- Использовать визуально для входов, выходов или фильтра сигналов.

import ccxt
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 100
interval_sec = 2
snapshots = []

print("Сбор snapshot данных стакана...")

for _ in range(30):  # ~1 минута
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    bids = {round(price): amount for price, amount in depth["bids"]}
    asks = {round(price): amount for price, amount in depth["asks"]}
    
    combined = bids.copy()
    combined.update(asks)
    snapshots.append(combined)
    
    time.sleep(interval_sec)

# Объединяем данные
all_prices = sorted(set().union(*[snap.keys() for snap in snapshots]))
heatmap_data = []

for snap in snapshots:
    row = []
    for price in all_prices:
        row.append(snap.get(price, 0))
    heatmap_data.append(row)

heatmap = np.array(heatmap_data).T  # строки — цены, столбцы — время

# Построение тепловой карты
plt.figure(figsize=(12, 6))
plt.imshow(heatmap, aspect="auto", cmap="hot", origin="lower")
plt.yticks(ticks=np.arange(len(all_prices))[::10], labels=all_prices[::10])
plt.xlabel("Время (шаги)")
plt.ylabel("Цена")
plt.title("Тепловая карта ликвидности BTC/USDT")
plt.colorbar(label="Объём")
plt.tight_layout()
plt.show()

#инструмент

📌 Подпишись  Crypto Python❗️

📌SuperTrend Indicator Strategy – Следование за трендом с динамическим уровнем🧑‍💻

Суть индикатора:🛠️

SuperTrend — трендовый индикатор, который строится на основе:

- ATR (среднего истинного диапазона) — измеряет волатильность,

- цены закрытия — для направления сигнала.

Он рисует динамический уровень поддержки/сопротивления, который перерисовывается при смене тренда.

Используется для:🧨

- входа в направлении тренда,
- удержания позиции,
- выставления трейлинг-стопа.

Сигналы:💸

- Цена пересекает SuperTrend снизу вверх → сигнал на покупку

- Цена пересекает SuperTrend сверху вниз → сигнал на продажу

import ccxt
import pandas as pd
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры SuperTrend
atr_period = 10
multiplier = 3.0

# Расчёт ATR
atr = ta.volatility.AverageTrueRange(high=df["high"], low=df["low"], close=df["close"], window=atr_period).average_true_range()
hl2 = (df["high"] + df["low"]) / 2
df["upperband"] = hl2 + (multiplier * atr)
df["lowerband"] = hl2 - (multiplier * atr)

# Логика SuperTrend
supertrend = []
direction = []
for i in range(len(df)):
    if i == 0:
        supertrend.append(df["upperband"][i])
        direction.append(1)
    else:
        if df["close"][i] > supertrend[i-1]:
            supertrend.append(df["lowerband"][i])
            direction.append(1)
        elif df["close"][i] < supertrend[i-1]:
            supertrend.append(df["upperband"][i])
            direction.append(-1)
        else:
            supertrend.append(supertrend[i-1])
            direction.append(direction[i-1])

df["supertrend"] = supertrend
df["trend"] = direction

# Сигналы
df["signal"] = 0
df.loc[(df["trend"] == 1) & (df["trend"].shift(1) == -1), "signal"] = 1   # Покупка
df.loc[(df["trend"] == -1) & (df["trend"].shift(1) == 1), "signal"] = -1  # Продажа

# Вывод последних сигналов
print(df[["ts", "close", "supertrend", "trend", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Schaff Trend Cycle Strategy – Быстрые сигналы на основе MACD и рыночных циклов🧑‍💻

Суть индикатора:🛠️

Schaff Trend Cycle (STC) — это модифицированная версия MACD, разработанная Дугом Шаффом, которая сочетает:

- трендовые свойства MACD,

- фильтрацию через цикличность рынка (с помощью двойного применения стохастика).

В результате получается более быстрый и точный индикатор, чем MACD, с меньшим запаздыванием.

Основные сигналы STC:💸

- STC поднимается выше 25 или 50 → сигнал на покупку

- STC опускается ниже 75 или 50 → сигнал на продажу

- Также используются пересечения порогов и дивергенции как подтверждение

import ccxt
import pandas as pd
import numpy as np
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Шаг 1: MACD
macd_line = ta.trend.macd(df["close"], window_slow=26, window_fast=12)
macd_signal = ta.trend.macd_signal(df["close"], window_slow=26, window_fast=12, window_sign=9)
macd_hist = macd_line - macd_signal

# Шаг 2: Стохастик от MACD
lowest = macd_hist.rolling(window=10).min()
highest = macd_hist.rolling(window=10).max()
stoch = 100 * (macd_hist - lowest) / (highest - lowest + 1e-9)

# Шаг 3: Стохастик от стохастика (фильтр циклов)
stc = stoch.rolling(window=3).mean()

df["stc"] = stc

# Генерация сигналов
df["signal"] = 0
df.loc[(df["stc"] > 25) & (df["stc"].shift() <= 25), "signal"] = 1  # Buy
df.loc[(df["stc"] < 75) & (df["stc"].shift() >= 75), "signal"] = -1 # Sell

# Вывод последних сигналов
print(df[["ts", "close", "stc", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Ensemble Voting Classifier Strategy – Cтратегия на основе голосования моделей (ансамбль)🧑‍💻

Суть идеи:🛠️

Ensemble Voting Classifier — это метод, при котором несколько моделей машинного обучения (или правил/индикаторов) дают свои прогнозы, а итоговый сигнал формируется на основе голосования:

Majority voting — большинство голосов

Weighted voting — взвешенные по точности/достоверности

Soft voting — усреднение вероятностей (если модели дают вероятности)

Преимущества ансамбля:💸

- Уменьшает переобучение отдельных моделей

- Повышает устойчивость к шуму

- Позволяет объединять разные типы моделей (логика, ML, индикаторы)

Пример: 🧨

3 модели → голос за покупку или продажу

1. XGBoost, обученный на RSI/MACD/Bollinger

2. RandomForest, обученный на объёме и свечах

3. Rule-based, если close > EMA200 and RSI < 30 → лонг

import pandas as pd
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Данные
df = pd.read_csv("features_signals.csv")  # Должны быть признаки и метка
X = df[["rsi", "macd", "volume", "sma_diff", "atr"]]
y = df["signal"]  # 1 = buy, -1 = sell, 0 = hold

# Разделение
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Масштабирование
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Модели
model1 = LogisticRegression()
model2 = RandomForestClassifier(n_estimators=100)
model3 = SVC(probability=True)

# Ансамбль голосования
ensemble = VotingClassifier(
    estimators=[("lr", model1), ("rf", model2), ("svc", model3)],
    voting="soft"  # можно "hard"
)

# Обучение
ensemble.fit(X_train, y_train)

# Прогноз
pred = ensemble.predict(X_test)
print("Прогнозы:", pred[-10:])

#инструмент

📌 Подпишись  Crypto Python❗️

📌Order Flow Visualizer – Визуализация входящих ордеров и их направления🧑‍💻

Суть идеи:🛠️

Order Flow Visualizer — это инструмент для отображения потока сделок (tape reading) в реальном времени:

- Показывает направление сделок: покупки против продаж,

- Визуализирует скорость, объём и агрессивность ордеров,

Помогает распознавать💸 импульсы, спайки ликвидности, активности "умных денег".

import websocket
import json
import pandas as pd
import matplotlib.pyplot as plt

# Сбор данных через WebSocket Binance
socket = "wss://stream.binance.com:9443/ws/btcusdt@aggTrade"

trades = []

def on_message(ws, message):
    data = json.loads(message)
    price = float(data["p"])
    qty = float(data["q"])
    side = "buy" if data["m"] == False else "sell"  # buyer maker = False => buy
    trades.append({"price": price, "qty": qty, "side": side})
    
    if len(trades) >= 200:
        ws.close()

def on_open(ws):
    print("Соединение открыто")

def on_close(ws):
    print("Соединение закрыто")
    df = pd.DataFrame(trades)
    # Визуализация
    plt.figure(figsize=(12, 6))
    colors = df["side"].map({"buy": "green", "sell": "red"})
    plt.scatter(df.index, df["price"], s=df["qty"]*10, c=colors, alpha=0.6)
    plt.title("Order Flow - BTC/USDT")
    plt.xlabel("Сделка")
    plt.ylabel("Цена")
    plt.show()

# Запуск WebSocket
ws = websocket.WebSocketApp(socket, on_message=on_message, on_open=on_open, on_close=on_close)
ws.run_forever()

#инструмент

📌 Подпишись  Crypto Python❗️

📌Statistical Arbitrage with Cointegration – Парный трейдинг на основе коинтеграции🧑‍💻

Суть стратегии:🛠️

Коинтеграция — это статистическая связь между двумя временными рядами, где их разность (спред) остаётся стационарной, даже если сами ряды нестационарны.
Statistical Arbitrage (StatArb) на коинтеграции предполагает:

- Найти пару активов, где есть долгосрочная устойчивая связь,

- Торговать на расхождении спреда от его среднего значения,

- Шортить актив, который ушёл выше, и лонговать актив, который остался ниже.

Идеальный случай для парного трейдинга:💸

- Активы движутся вместе долгосрочно, но краткосрочно могут расходиться

- Спред между ними возвращается к своему среднему (mean-reversion)

Как определить коинтеграцию:🧨

- Тесты: Engle-Granger, Johansen Test

- Статистика: p-value < 0.05 → есть коинтеграция

- Построение регрессии спреда между двумя активами

import ccxt
import pandas as pd
import statsmodels.api as sm
from statsmodels.tsa.stattools import coint

# Получение данных
exchange = ccxt.binance()
symbol1 = "ETH/USDT"
symbol2 = "ETC/USDT"
tf = "1h"
limit = 500

ohlcv1 = exchange.fetch_ohlcv(symbol1, timeframe=tf, limit=limit)
ohlcv2 = exchange.fetch_ohlcv(symbol2, timeframe=tf, limit=limit)

df1 = pd.DataFrame(ohlcv1, columns=["ts", "open", "high", "low", "close", "volume"])
df2 = pd.DataFrame(ohlcv2, columns=["ts", "open", "high", "low", "close", "volume"])

# Синхронизация по времени
df1["ts"] = pd.to_datetime(df1["ts"], unit="ms")
df2["ts"] = pd.to_datetime(df2["ts"], unit="ms")
merged = pd.merge(df1[["ts", "close"]], df2[["ts", "close"]], on="ts", suffixes=('_eth', '_etc'))

# Тест коинтеграции
score, pvalue, _ = coint(merged["close_eth"], merged["close_etc"])
print(f"p-value коинтеграции: {pvalue:.5f}")

if pvalue < 0.05:
    print("✅ Пары коинтегрированы, можно строить стратегию!")

    # Построение спреда через регрессию
    model = sm.OLS(merged["close_eth"], sm.add_constant(merged["close_etc"])).fit()
    merged["spread"] = merged["close_eth"] - (model.params[1] * merged["close_etc"] + model.params[0])

    # Нормализация спреда (Z-скор)
    merged["z_score"] = (merged["spread"] - merged["spread"].mean()) / merged["spread"].std()

    # Генерация сигналов
    merged["signal"] = 0
    merged.loc[merged["z_score"] > 1, "signal"] = -1  # Short ETH / Long ETC
    merged.loc[merged["z_score"] < -1, "signal"] = 1  # Long ETH / Short ETC

    print(merged[["ts", "close_eth", "close_etc", "spread", "z_score", "signal"]].tail(10))
else:
    print("❌ Нет стабильной коинтеграции, пары не подходят.")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Execution Slippage Tracker – Фильтрация сигналов при высоком проскальзывании🧑‍💻

Суть инструмента:🛠️

Execution Slippage Tracker отслеживает разницу между ожидаемой и фактической ценой исполнения сделки.

Цель — избежать открытия сделок, если проскальзывание превышает допустимый порог и ухудшает риск-прибыль.

Как использовать на практике:💸

- Автоматически фильтровать трейдинг-сигналы

- Работать только с ликвидными инструментами

- Применять разную допустимую величину slippage для разных стратегий

- Блокировать ордера при неожиданных "провалах" ликвидности

import ccxt

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
desired_amount = 0.1  # количество BTC, которое хотим купить
expected_price = 27000  # ожидаемая цена входа
max_slippage_pct = 0.2  # максимальное допустимое проскальзывание в %

# Получение стакана
order_book = exchange.fetch_order_book(symbol, limit=20)

# Расчёт средней цены для покупки desired_amount
remaining = desired_amount
total_cost = 0

for price, volume in order_book['asks']:
    if volume >= remaining:
        total_cost += price * remaining
        break
    else:
        total_cost += price * volume
        remaining -= volume

avg_execution_price = total_cost / desired_amount

# Расчёт проскальзывания
slippage = (avg_execution_price - expected_price) / expected_price * 100

print(f"Ожидаемая цена: {expected_price}")
print(f"Фактическая средняя цена: {avg_execution_price:.2f}")
print(f"Проскальзывание: {slippage:.3f}%")

# Проверка
if slippage > max_slippage_pct:
    print("❌ Слишком высокое проскальзывание! Сделку пропустить.")
else:
    print("✅ Проскальзывание в пределах нормы. Сделку можно выполнять.")

#инструмент

📌 Подпишись  Crypto Python❗️

📌 Наш канал на YouTube 🧑‍💻

📌Synthetic Short Strategy – Создание шорта через два актива (long A, short B)🧑‍💻

Суть стратегии:🛠️

Synthetic Short — это техника, при которой трейдер имитирует короткую позицию, открывая лонг на одном активе и одновременно шорт на другом, вместо прямой продажи в шорт.

Используется когда:🧨

- Прямой шорт дорог или недоступен (например, нет маржи или фьючерсов),

- Требуется создать нейтральную или направленную позицию,

- Нужно использовать рыночно-нейтральные стратегии или парный трейдинг.

Когда Synthetic Short эффективен:💸

- Между активами существует стабильная корреляция

- Есть ожидание расхождения в скоростях роста/падения

- При торговле деривативами с низким свопом или через спотовые пары

Риски Synthetic Short:🧨

- Если обе позиции идут в неправильную сторону одновременно, убытки удваиваются

- Требуется правильная балансировка размера позиций (особенно, если волатильность активов разная)

import ccxt
import pandas as pd

# Получение данных
exchange = ccxt.binance()
symbol_a = "ETH/USDT"
symbol_b = "BTC/USDT"
limit = 300
tf = "1h"

ohlcv_a = exchange.fetch_ohlcv(symbol_a, timeframe=tf, limit=limit)
ohlcv_b = exchange.fetch_ohlcv(symbol_b, timeframe=tf, limit=limit)

df_a = pd.DataFrame(ohlcv_a, columns=["ts", "open", "high", "low", "close", "volume"])
df_b = pd.DataFrame(ohlcv_b, columns=["ts", "open", "high", "low", "close", "volume"])
df_a["ts"] = pd.to_datetime(df_a["ts"], unit="ms")
df_b["ts"] = pd.to_datetime(df_b["ts"], unit="ms")

# Объединение данных
df = pd.merge(df_a[["ts", "close"]], df_b[["ts", "close"]], on="ts", suffixes=('_a', '_b'))

# Расчёт спреда (A - B)
df["spread"] = df["close_a"] - df["close_b"]

# Логика: рост спреда → профит
df["spread_change"] = df["spread"].diff()

print(df[["ts", "close_a", "close_b", "spread", "spread_change"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Trade Journal Analyzer – Разбор истории трейдов с выводом статистики🧑‍💻

Суть инструмента:🛠️

Trade Journal Analyzer позволяет анализировать историю сделок, чтобы:

- Видеть реальные показатели эффективности,

- Находить сильные и слабые стороны стратегии,

- Улучшать риск-менеджмент и правила входа/выхода.

Что обычно анализируют:💸

- Количество сделок

- Winrate (процент прибыльных сделок)

- Средний профит/убыток

- Profit Factor (отношение общей прибыли к убыткам)

- Максимальная просадка (drawdown)

- Средний риск-ревард (R:R)

- Среднее время удержания сделки

import pandas as pd

# Загрузка журнала
df = pd.read_csv("trades_journal.csv")  # ваши данные

# Базовые расчёты
total_trades = len(df)
wins = df[df["PnL"] > 0]
losses = df[df["PnL"] <= 0]
winrate = len(wins) / total_trades * 100

avg_win = wins["PnL"].mean()
avg_loss = losses["PnL"].mean()
profit_factor = wins["PnL"].sum() / abs(losses["PnL"].sum())
gross_profit = wins["PnL"].sum()
gross_loss = losses["PnL"].sum()

# Максимальная просадка (кумулятивный PnL)
df["cum_pnl"] = df["PnL"].cumsum()
drawdown = df["cum_pnl"] - df["cum_pnl"].cummax()
max_drawdown = drawdown.min()

# Вывод отчёта
print(f"Общее количество сделок: {total_trades}")
print(f"Winrate: {winrate:.2f}%")
print(f"Средний профит: {avg_win:.2f} $")
print(f"Средний убыток: {avg_loss:.2f} $")
print(f"Profit Factor: {profit_factor:.2f}")
print(f"Валовая прибыль: {gross_profit:.2f} $")
print(f"Валовый убыток: {gross_loss:.2f} $")
print(f"Максимальная просадка: {max_drawdown:.2f} $")

#инструмент

📌 Подпишись  Crypto Python❗️

📌Queue Position Tactic – Выставление лимитного ордера для ранней позиции в очереди🧑‍💻

Суть идеи:🛠️

На биржах с приоритетом по времени (FIFO — First In, First Out), крайне важно занять как можно более высокую позицию в очереди лимитных ордеров:

Чем выше в очереди → тем быстрее исполнение при подходе цены,

Тем меньше шанс, что ордер "перепрыгнут" другими лимитками,

Тем выше вероятность избежать проскальзывания и комиссий.

Основные принципы Queue Tactic:

- Выставить лимитный ордер раньше других по желаемой цене,

- Обновлять лимитку, если впереди появляются новые крупные ордера,

- Избегать постоянной перезаявки, чтобы не терять свою очередь.

import ccxt
import time

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
side = "buy"  # или "sell"
limit_price = 27000  # желаемая цена
order_size = 0.01  # в BTC
depth_limit = 5

# Функция получения лучшего уровня
def get_best_price_volume(side):
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    if side == "buy":
        price, volume = depth['bids'][0]
    else:
        price, volume = depth['asks'][0]
    return price, volume

# Текущий статус
best_price, best_volume = get_best_price_volume(side)
print(f"Лучший {side.upper()} уровень: {best_price} | Объём: {best_volume}")

# Псевдологика отправки ордера
# order_id = exchange.create_limit_buy_order(symbol, order_size, limit_price)

# Циклический контроль
while True:
    time.sleep(2)
    current_price, current_volume = get_best_price_volume(side)

    if side == "buy" and current_price < limit_price:
        print("⚡ Появился более выгодный bid! Обновляем ордер...")
        # exchange.cancel_order(order_id, symbol)
        # order_id = exchange.create_limit_buy_order(symbol, order_size, current_price)
        limit_price = current_price

    elif side == "sell" and current_price > limit_price:
        print("⚡ Появился более высокий ask! Обновляем ордер...")
        # exchange.cancel_order(order_id, symbol)
        # order_id = exchange.create_limit_sell_order(symbol, order_size, current_price)
        limit_price = current_price

    else:
        print(f"Позиция в очереди удерживается на {current_price}.")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️