📌Volatility Stop Reversal – Переворот позиции при пробое волатильностного стоп-уровня🧑‍💻

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

Volatility Stop Reversal (VSR) — это торговая тактика, при которой:

Позиция переворачивается, если цена пробивает волатильностный стоп-уровень,

Уровень рассчитывается на основе ATR (Average True Range) или других индикаторов,

Такой подход позволяет следовать за трендом, автоматически меняя сторону позиции при смене направления.

Механика стратегии:💸

1. Вход по тренду (например, вверх).

2. Уровень стопа:

для лонга: stop = high - k × ATR,

для шорта: stop = low + k × ATR.

3. Если цена пересекает этот уровень → позиция закрывается и открывается в противоположную сторону.

4. Новый стоп пересчитывается — и цикл повторяется.

import ccxt
import pandas as pd
import ta

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

# Параметры
atr_period = 14
atr_multiplier = 2.0

# Расчёт ATR
df["atr"] = ta.volatility.AverageTrueRange(df["high"], df["low"], df["close"], window=atr_period).average_true_range()

# Инициализация
df["position"] = 0
df["stop"] = None

# Логика VSR
for i in range(1, len(df)):
    atr = df["atr"].iloc[i]
    close = df["close"].iloc[i]
    prev_pos = df["position"].iloc[i - 1]

    if prev_pos == 0:
        # Первая инициализация — допустим, открываем лонг
        df.loc[i, "position"] = 1
        df.loc[i, "stop"] = df["high"].iloc[i] - atr_multiplier * atr
    elif prev_pos == 1:
        stop = df["stop"].iloc[i - 1]
        if close < stop:
            df.loc[i, "position"] = -1  # Переворот в шорт
            df.loc[i, "stop"] = df["low"].iloc[i] + atr_multiplier * atr
        else:
            df.loc[i, "position"] = 1
            df.loc[i, "stop"] = max(stop, df["high"].iloc[i] - atr_multiplier * atr)
    elif prev_pos == -1:
        stop = df["stop"].iloc[i - 1]
        if close > stop:
            df.loc[i, "position"] = 1  # Переворот в лонг
            df.loc[i, "stop"] = df["high"].iloc[i] - atr_multiplier * atr
        else:
            df.loc[i, "position"] = -1
            df.loc[i, "stop"] = min(stop, df["low"].iloc[i] + atr_multiplier * atr)

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

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

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

📌VWAP Imbalance Entry – Вход при смещении торгов к одной стороне от VWAP🧑‍💻

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

VWAP (Volume Weighted Average Price) — это средневзвешенная цена сделки по объёму.
Она часто выступает как балансная точка между покупателями и продавцами.
Когда цена и объёмы сильно сдвинуты на одну сторону от VWAP, это может сигнализировать о:

- доминировании одной стороны (покупатели или продавцы),

- готовности к импульсу или продолжению движения,

- потенциальном входе в позицию по направлению дисбаланса.

Принцип стратегии:💸

1. Вычисляем VWAP за сессию или торговый период

2. Анализируем, где проходит основной объём сделок — выше или ниже VWAP

3. Если 70%+ объёма идёт выше VWAP → лонговое смещение

4. Если 70%+ ниже VWAP → шортовое смещение

5. Вход по направлению дисбаланса (в сторону, где сосредоточен объём)

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
limit = 200
tf = "1m"

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

# Расчёт VWAP вручную
df["tp"] = (df["high"] + df["low"] + df["close"]) / 3
df["vwap_num"] = df["tp"] * df["volume"]
df["cum_vol"] = df["volume"].cumsum()
df["cum_vwap"] = df["vwap_num"].cumsum()
df["vwap"] = df["cum_vwap"] / df["cum_vol"]

# Определим, где прошёл объём — выше или ниже VWAP
df["side"] = df["close"] > df["vwap"]
above_vol = df[df["side"] == True]["volume"].sum()
below_vol = df[df["side"] == False]["volume"].sum()
total_vol = df["volume"].sum()

above_pct = above_vol / total_vol * 100
below_pct = below_vol / total_vol * 100

print(f"Объём выше VWAP: {above_pct:.1f}% | ниже VWAP: {below_pct:.1f}%")

# Генерация сигнала
if above_pct > 70:
    print("⚡ Объём сконцентрирован выше VWAP → сигнал на ЛОНГ")
elif below_pct > 70:
    print("⚡ Объём сконцентрирован ниже VWAP → сигнал на ШОРТ")
else:
    print("Нет чёткого дисбаланса по VWAP")

#индикатор

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

📌Trend Strength Delta Strategy – Вход при резком изменении силы тренда🧑‍💻

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

Trend Strength Delta — это стратегия, основанная на отслеживании изменения силы тренда во времени.
Сигналы генерируются, когда дельта силы тренда (например, по ADX, CCI, MACD или собственному индикатору)
резко возрастает или снижается, указывая на:

- Начало нового импульса,

- Усиление/ослабление тренда,

- Переход из флетовой фазы в направленную.

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

- Фильтр по направлению тренда — использовать +DI и -DI (из ADX)

- Торговать импульсы при резком росте силы

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

- Можно сочетать с EMA или MACD для подтверждения направления

import ccxt
import pandas as pd
import ta

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

# Расчёт ADX
adx_indicator = ta.trend.ADXIndicator(high=df["high"], low=df["low"], close=df["close"], window=14)
df["adx"] = adx_indicator.adx()

# Дельта ADX
df["adx_delta"] = df["adx"].diff(periods=3)

# Порог дельты
threshold = 10

# Генерация сигнала
df["signal"] = 0
df.loc[df["adx_delta"] > threshold, "signal"] = 1   # Вход в лонг
df.loc[df["adx_delta"] < -threshold, "signal"] = -1  # Вход в шорт

# Вывод
print(df[["ts", "close", "adx", "adx_delta", "signal"]].tail(10))

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

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

📌Graph Neural Networks for Market Prediction – GNN для анализа взаимосвязанных активов🧑‍💻

Суть подхода:🛠️

Graph Neural Networks (GNN) применяются для анализа взаимосвязанных временных рядов, где каждый актив — это узел графа, а связи между активами — рёбра, отражающие:

- корреляцию,

- коинтеграцию,

- потоки капитала,

- или даже семантические связи (например, BTC ↔ ETH ↔ DeFi).

GNN позволяют моделировать структуру рынка как целое, а не каждый актив в отдельности, улучшая прогноз за счёт учёта коллективного поведения.

import torch
from torch_geometric.data import Data
import numpy as np

# 5 активов, 4 признака на каждый
x = torch.tensor([
    [0.2, 0.3, 0.8, 1.2],  # BTC
    [0.1, 0.4, 0.6, 0.9],  # ETH
    [0.3, 0.2, 0.7, 1.1],  # BNB
    [0.5, 0.1, 0.5, 0.7],  # SOL
    [0.4, 0.2, 0.4, 0.6],  # XRP
], dtype=torch.float)

# Связи: пары индексов узлов (например, BTC ↔ ETH)
edge_index = torch.tensor([
    [0, 1, 1, 2, 2, 3, 3, 4],  # from
    [1, 0, 2, 1, 3, 2, 4, 3],  # to
], dtype=torch.long)

data = Data(x=x, edge_index=edge_index)

print(data)

#инструмент

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

📌Transformer-Based Time Series Forecasting – Прогнозирование временных рядов с помощью трансформеров🧑‍💻

Суть подхода:🛠️

Модели Transformer, изначально созданные для обработки текста, адаптированы для временных рядов, потому что умеют:

- Учитывать долгосрочные зависимости в данных,

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

- Быть параллельными (в отличие от RNN/LSTM),

- Использовать self-attention для фокусировки на ключевых точках в истории.

Зачем использовать трансформеры в трейдинге:💸

- Прогнозирование цены, дельты, объёма, тренда и других параметров

- Моделирование зависимости между разными активами/индикаторами

- Предсказание следующих свечей или направления движения

import torch
import torch.nn as nn

class TimeSeriesTransformer(nn.Module):
    def __init__(self, input_size, d_model=64, nhead=4, num_layers=2, output_size=1):
        super().__init__()
        self.embedding = nn.Linear(input_size, d_model)
        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        self.fc = nn.Linear(d_model, output_size)

    def forward(self, x):
        x = self.embedding(x)  # [batch, seq_len, d_model]
        x = self.transformer(x)
        return self.fc(x[:, -1])  # прогноз по последнему элементу

#инструмент

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

📌Cycle-Based Bollinger Entry – Вход по фазе рыночного цикла внутри полос Боллинджера🧑‍💻

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

Cycle-Based Bollinger Entry сочетает:

Боллинджер-канал (Bollinger Bands) — для определения границ волатильности,

Циклическую фазу — чтобы понимать, где в колебательном цикле находится цена (вверх, пик, вниз, дно),

Цель — вход внутри полос Боллинджера, с учётом фазы:💸

На дне → лонг от нижней полосы

На вершине → шорт от верхней полосы

import ccxt
import pandas as pd

# Загрузка данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры полос Боллинджера
period = 20
k = 2

# Средняя и стандартное отклонение
df["ma"] = df["close"].rolling(period).mean()
df["std"] = df["close"].rolling(period).std()

# Полосы
df["upper"] = df["ma"] + k * df["std"]
df["lower"] = df["ma"] - k * df["std"]

# Z-score — аналог фазы (отклонение от центра)
df["zscore"] = (df["close"] - df["ma"]) / df["std"]

# Сигналы по фазе и положению
df["signal"] = 0
df.loc[(df["zscore"] < -1.5), "signal"] = 1   # Лонг у нижней полосы
df.loc[(df["zscore"] > 1.5), "signal"] = -1   # Шорт у верхней полосы

# Вывод
print(df[["ts", "close", "zscore", "signal"]].tail(10))

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

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

📌Iceberg Detector Strategy – Выявление айсберг-ордеров и вход в сторону крупного игрока🧑‍💻

Цель стратегии:🛠️

Выявить такие айсберг-ордера через повторяющееся появление объёма на одном уровне, и войти в направлении “умных денег”, стоящих за этим уровнем.

Признаки айсберг-ордера:🛠️

- Видимая заявка в стакане съедается частично или полностью → и снова появляется,

- На одном ценовом уровне происходит много рыночных сделок, но цена не двигается,

- Объём на уровне не уменьшается, несмотря на агрессию,

- Скорость восстановления лимитки выше обычной.

Стратегия входа:💸

Если выявлен айсберг на bid → вход в лонг,

Если выявлен айсберг на ask → вход в шорт,

Цель — следовать за крупным участником, который удерживает уровень,

Стоп — за ценой айсберга, тейк — по импульсу или ближайшему сопротивлению.

import ccxt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 10
check_interval = 2  # в секундах

previous_book = exchange.fetch_order_book(symbol, limit=depth_limit)
track_price = previous_book['bids'][0][0]
track_volume = previous_book['bids'][0][1]
reappear_count = 0

print(f"Отслеживаем BID на {track_price:.2f} с объёмом {track_volume:.2f}")

while True:
    time.sleep(check_interval)
    order_book = exchange.fetch_order_book(symbol, limit=depth_limit)
    bids = {price: vol for price, vol in order_book["bids"]}

    # Проверка на возврат объёма на том же уровне
    if track_price in bids:
        new_volume = bids[track_price]
        if new_volume >= track_volume * 0.9:
            reappear_count += 1
            print(f"Объём на {track_price:.2f} восстановлен ({reappear_count} раз)")
        else:
            reappear_count = 0
    else:
        reappear_count = 0

    # Если айсберг подтвердился несколько раз — сигнал
    if reappear_count >= 3:
        print(f"✅ Айсберг-заявка подтверждена на {track_price:.2f} → сигнал на ЛОНГ")
        break

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

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

📌Trend Rotation Strategy – Ротация активов по силе текущего тренда🧑‍💻

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

Trend Rotation — это метод динамического распределения капитала между активами на основе сравнения силы их текущего тренда.

Идея проста:🚀

> держать активы с сильным трендом,
избавляться от слабых,
и периодически пересматривать портфель (например, раз в день/неделю).

Пример стратегии:💸

1. Берём 10 активов (BTC, ETH, SOL, BNB, APT, XRP...)

2. Расчёт ADX для каждого актива

3. Отбираем топ-3 с самым высоким ADX

4. Входим в них равными долями

5. Пересмотр каждую неделю

import ccxt
import pandas as pd
import ta

exchange = ccxt.binance()
symbols = ["BTC/USDT", "ETH/USDT", "BNB/USDT", "SOL/USDT", "XRP/USDT"]
timeframe = "1h"
limit = 200

results = []

for symbol in symbols:
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    adx = ta.trend.ADXIndicator(df["high"], df["low"], df["close"]).adx()
    last_adx = adx.iloc[-1]
    results.append((symbol, last_adx))

# Сортировка по силе тренда
ranked = sorted(results, key=lambda x: x[1], reverse=True)

# Вывод
print("Топ активов по силе тренда (ADX):")
for s, a in ranked:
    print(f"{s}: {a:.2f}")

# Выбор топ-3
selected = ranked[:3]
print("\nПортфель: ", [s for s, _ in selected])

#инструмент

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

📌Funding Premium vs Spot Arbitrage – Арбитраж на расхождении цены фьючерса и спота🧑‍💻

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

Funding Premium Arbitrage основан на разнице между:

- Ценой спотового актива (например, BTC/USDT на споте)

и ценой бессрочного фьючерса (perpetual futures),

- а также периодическим funding rate, который платится между long/short сторонами.

Цель — зарабатывать на дисбалансе, удерживая две противоположные позиции:

Long спот + Short фьючерс, или наоборот,

При этом не подвержен риску движения цены, т.к. позиции хеджированы.

Когда работает:💸

- Фьючерс торгуется с премией к споту + положительный funding rate
→ Шорт фьючерс, лонг спот → получаешь funding и арбитраж от схождения цены.

- Фьючерс торгуется со скидкой + отрицательный funding rate
→ Лонг фьючерс, шорт спот (или через заемный актив) → аналогичная логика.

Риски:❗

- Funding rate может измениться

- Плечо на фьючерсе может привести к ликвидации (если не хеджируешь правильно)

- Зависимость от ликвидности и комиссий

- Нужно маржинальное обеспечение на обе стороны

import ccxt

exchange = ccxt.binance()

# Получаем цены
spot_ticker = exchange.fetch_ticker("BTC/USDT")
future_ticker = exchange.fetch_ticker("BTC/USDT:USDT")  # Perpetual

# Funding rate
funding = exchange.fetch_funding_rate("BTC/USDT:USDT")
funding_rate = funding["fundingRate"]

# Расчёт спреда
spot_price = spot_ticker["last"]
future_price = future_ticker["last"]
spread = future_price - spot_price
spread_pct = (spread / spot_price) * 100

print(f"Спот: {spot_price}, Фьючерс: {future_price}")
print(f"Спред: {spread:.2f} USDT ({spread_pct:.2f}%)")
print(f"Funding rate: {funding_rate:.5f} (на 8 ч)")

# Условие для входа
if spread_pct > 0.5 and funding_rate > 0.0002:
    print("✅ Вход в арбитраж: лонг спот + шорт фьючерс")

#арбитраж

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

📌CCI Breakout Strategy – Вход при выходе CCI из зоны ±100🧑‍💻

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

CCI (Commodity Channel Index) — осциллятор, измеряющий отклонение цены от её средней.
Значения в диапазоне ±100 считаются нормой, выход за пределы — сигнал силы.

Принцип стратегии:💸

Buy, когда CCI выходит выше +100 → сигнал восходящего импульса

Sell, когда CCI уходит ниже -100 → сигнал нисходящего импульса

import ccxt
import pandas as pd
import ta

# Данные с Binance
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")

# CCI
cci = ta.trend.CCIIndicator(high=df["high"], low=df["low"], close=df["close"], window=20)
df["cci"] = cci.cci()

# Сигналы
df["signal"] = 0
df.loc[(df["cci"].shift(1) < 100) & (df["cci"] > 100), "signal"] = 1    # Вход в ЛОНГ
df.loc[(df["cci"].shift(1) > -100) & (df["cci"] < -100), "signal"] = -1  # Вход в ШОРТ

# Вывод
print(df[["ts", "close", "cci", "signal"]].tail(10))

#индикатор

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

📌Onchain News-Driven Trade Trigger – Сделка по триггеру событий из ончейн-агрегаторов (Smart Money)🧑‍💻

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

Это подход, при котором вход в рынок осуществляется не по графику или индикатору, а при обнаружении ключевых событий в ончейн-данных.

Фокус на активности "умных денег" (Smart Money) — это:💸

- крупные кошельки,

- фонды,

- биржи,

- DeFi-протоколы,

- известные инвесторы.

Типы ончейн-триггеров:🚀

- Перевод большого объёма на биржу - Возможен дамп (шорт)

- Перевод с биржи в холодный кошелёк - Потенциальный рост (лонг)

- Активация старого кошелька - Неопределённость / волатильность

- Покупка токена через DEX (Smart Money) - Сигнал на покупку

- Вложение в пул DeFi (Curve, Aave, и т.д.) - Рост интереса к токену

from telethon import TelegramClient, events

api_id = YOUR_API_ID
api_hash = "YOUR_API_HASH"
client = TelegramClient("arkham_alerts", api_id, api_hash)

@client.on(events.NewMessage(chats='ArkhamIntelAlerts'))
async def handler(event):
    msg = event.message.message
    if "Binance" in msg and "ETH" in msg and "transferred" in msg:
        print("⚠️ Поток ETH на Binance — возможный дамп!")

client.start()
client.run_until_disconnected()

#инструмент

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

📌Candle Pattern Machine Learner – Автообучение модели на свечных паттернах🧑‍💻

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

Вместо ручного определения свечных моделей (поглощение, доджи, молот и т.д.), стратегия строится на автоматическом обучении модели (CNN, XGBoost, LSTM и др.), чтобы:

- Распознать скрытые закономерности в свечах,

- Предсказывать направление следующей свечи, или

- Классифицировать паттерны по вероятности роста/падения.

import xgboost as xgb
import pandas as pd

# Предположим, у вас есть DataFrame df с OHLCV
df["body"] = df["close"] - df["open"]
df["upper_wick"] = df["high"] - df[["close", "open"]].max(axis=1)
df["lower_wick"] = df[["close", "open"]].min(axis=1) - df["low"]
df["range"] = df["high"] - df["low"]
df["body_ratio"] = df["body"] / df["range"]

# Цель: растёт ли следующая свеча
df["target"] = (df["close"].shift(-1) > df["close"]).astype(int)
df.dropna(inplace=True)

# Обучение
features = ["body", "upper_wick", "lower_wick", "body_ratio"]
X = df[features]
y = df["target"]

model = xgb.XGBClassifier()
model.fit(X, y)

# Предсказание
df["predicted"] = model.predict(X)

#инструмент

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

📌Exchange Inflow Spike Strategy – Продажа при всплеске входов на биржи🧑‍💻

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

Когда крупные держатели или инвесторы переводят активы на биржу, это часто предшествует продаже. Особенно если это:

- Smart Money

- Долгосрочные холдеры

- Или крупные адреса (киты)

Стратегия реагирует на всплеск входящих переводов (inflows) на централизованные биржи (CEX) — это может сигнализировать о грядущем давлении продаж.

import requests

API_KEY = "your_cryptoquant_api_key"
symbol = "btc"

r = requests.get(
    f"https://api.cryptoquant.com/v1/bitcoin/exchange-flows/inflow?exchange=binance",
    headers={"x-api-key": API_KEY}
)
data = r.json()
latest_inflow = data['result'][-1]['value']
avg_inflow = sum([d['value'] for d in data['result'][-24:]]) / 24

if latest_inflow > avg_inflow * 2:
    print(f"⚠️ Всплеск входов BTC на Binance! {latest_inflow} BTC (среднее {avg_inflow:.0f}) — сигнал на продажу.")

#инструмент

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

📌Speed-of-Move Detector – Стратегия по скорости и ускорению ценового движения🧑‍💻

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

Speed-of-Move Detector (детектор скорости движения цены) реагирует на внезапные импульсы — участки, где:

- Цена быстро проходит значительное расстояние за короткое время,

- Часто указывает на начало импульса, пробой уровня, или манипуляцию.

- Основана на производных: скорость (первое изменение), ускорение (второе изменение) цены.

Пример применения:💸

- Buy, если ускорение резко положительное (вверх) + объём растёт

- Sell, если ускорение резко отрицательное (вниз)

import ccxt
import pandas as pd

# Загрузка данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, timeframe="1m", limit=300),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Скорость (на основе закрытий)
N = 3
df["velocity"] = df["close"] - df["close"].shift(N)

# Ускорение — изменение скорости
df["acceleration"] = df["velocity"] - df["velocity"].shift(N)

# Стандартное отклонение для фильтра
threshold = df["acceleration"].rolling(50).std()
df["signal"] = 0
df.loc[df["acceleration"] > threshold * 2, "signal"] = 1    # импульс вверх
df.loc[df["acceleration"] < -threshold * 2, "signal"] = -1  # импульс вниз

# Вывод
print(df[["ts", "close", "velocity", "acceleration", "signal"]].tail(10))

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

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

📌Slope of MA as Filter – Фильтрация сигналов по наклону скользящей средней🧑‍💻

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

Скользящая средняя (MA) сама по себе показывает направление тренда,
но угол наклона MA (градиент) даёт информацию о силе этого тренда.

Фильтрация по наклону MA позволяет:🚀

- Исключать сделки во флэте,

- Входить только по направлению устойчивого движения,

- Повышать точность сигналов любой стратегии (пересечения, пробои, свечные паттерны и т.д.).

Как рассчитать наклон MA:🛠️

MA(t) — значение скользящей на текущей свече
MA(t - N) — значение MA N свечей назад

slope = (MA(t) - MA(t-N)) / N

Это приближённый градиент/угол наклона.

Можно интерпретировать:💸

slope > 0 — восходящий тренд

slope < 0 — нисходящий

abs(slope) мал — рынок во флэте

import ccxt
import pandas as pd
import ta

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

# EMA и её наклон
period = 50
df["ema"] = ta.trend.ema_indicator(df["close"], window=period).ema_indicator()

# Расчёт наклона (на 5 свечей назад)
df["ema_slope"] = (df["ema"] - df["ema"].shift(5)) / 5

# Фильтр: считаем тренд сильным, если slope > 10 (например, в $)
df["trend_filter"] = 0
df.loc[df["ema_slope"] > 10, "trend_filter"] = 1   # Uptrend
df.loc[df["ema_slope"] < -10, "trend_filter"] = -1  # Downtrend

# Вывод
print(df[["ts", "close", "ema", "ema_slope", "trend_filter"]].tail(10))

#индикатор

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

📌Micro-Breakout Zone Entry – Стратегия входа после мини-консолидации🧑‍💻

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

Micro-Breakout Zone Entry — это стратегия, ориентированная на вход после кратковременной консолидации (узкого диапазона).

Основная идея:❗

> Цена замирает в узком диапазоне (часто перед новостью, крупным ордером или ликвидностью),

затем быстро пробивает его вверх или вниз → точка входа.

Характерные признаки micro-консолидации:🧨

- Последние 3–10 свечей с малыми телами,

- Диапазон high-low очень узкий (например, < 1% от средней волатильности),

- Часто — горизонтальное движение у границ VWAP/EMA,

- После фазы расширения/импульса → "сжатие пружины".

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

Вход по направлению пробоя сразу после закрытия свечи

Стоп — за границей зоны консолидации

Тейк — по фиксированному R:R или ближайшему уровню/объёму

import ccxt
import pandas as pd

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

# Параметры
lookback = 5  # свечей
threshold_pct = 0.005  # 0.5%

# Диапазон зоны консолидации
df["range"] = df["high"].rolling(lookback).max() - df["low"].rolling(lookback).min()
df["avg_price"] = df["close"].rolling(lookback).mean()
df["range_pct"] = df["range"] / df["avg_price"]

# Флаг зоны — если диапазон меньше порога
df["is_microzone"] = df["range_pct"] < threshold_pct

# Сигналы пробоя
df["signal"] = 0
for i in range(lookback, len(df)):
    if df["is_microzone"].iloc[i - 1]:
        if df["close"].iloc[i] > df["high"].iloc[i - lookback:i].max():
            df.loc[i, "signal"] = 1  # breakout вверх
        elif df["close"].iloc[i] < df["low"].iloc[i - lookback:i].min():
            df.loc[i, "signal"] = -1  # breakout вниз

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

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

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

📌Implied Volatility Spread Arbitrage – Арбитраж на расхождении реализованной и ожидаемой волатильности🧑‍💻

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

Эта стратегия основана на сравнении двух типов волатильности:

1. Implied Volatility (IV) — ожидаемая волатильность, заложенная в цену опциона.

2. Realized Volatility (RV) — реализованная историческая волатильность актива за N дней.

Идея:💸

Если IV сильно выше RV → опционы переоценены → выгодно продавать волатильность (short straddle, short options).

Если RV выше IV → опционы недооценены → выгодно покупать волатильность (long straddle, long options).

Примеры инструментов:💸

- Опционы на BTC, ETH на Deribit

- Опционы на акции или индексы через брокеров (например, Interactive Brokers, TastyTrade)

- Volatility tokens (например, ETHV, BTCV) на DeFi или централизованных платформах

import ccxt, numpy as np, pandas as pd

# Получение исторических данных
exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv("BTC/USDT", timeframe="1d", limit=60)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])

# Расчёт реализованной волатильности за 30 дней
returns = df["close"].pct_change()
rv = returns.rolling(window=30).std() * np.sqrt(365)
rv_value = rv.iloc[-1]

# Получение IV через сторонние источники (примерно, вручную)
iv_value = 0.75  # Пример: 75% implied volatility

print(f"Realized Volatility: {rv_value:.2%}")
print(f"Implied Volatility:  {iv_value:.2%}")

if iv_value > rv_value * 1.5:
    print("IV >> RV → опционы переоценены → стратегия: продажа волатильности")
elif rv_value > iv_value * 1.2:
    print("RV >> IV → опционы недооценены → стратегия: покупка волатильности")
else:
    print("Волатильности сбалансированы → без действия")

#арбитраж

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

📌Cross-Timeframe Pattern Confirmator – Вход при совпадении паттернов на нескольких таймфреймах🧑‍💻

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

Cross-Timeframe Pattern Confirmator — это метод, при котором сигнал на вход формируется только тогда, когда свечный паттерн (или другой сигнал) совпадает сразу на нескольких таймфреймах, например:

- Младший ТФ (5m / 15m): даёт быстрый вход,

- Старший ТФ (1h / 4h / 1d): подтверждает направление и фильтрует шум.

import ccxt
import pandas as pd

exchange = ccxt.binance()

# Получаем данные для двух ТФ
def get_df(symbol, tf):
    data = exchange.fetch_ohlcv(symbol, tf, limit=100)
    df = pd.DataFrame(data, columns=["ts", "open", "high", "low", "close", "volume"])
    df["ts"] = pd.to_datetime(df["ts"], unit="ms")
    return df

df_5m = get_df("BTC/USDT", "5m")
df_1h = get_df("BTC/USDT", "1h")

# Пример: паттерн "бычье поглощение"
def bullish_engulfing(df):
    prev = df.iloc[-2]
    curr = df.iloc[-1]
    return (curr["close"] > curr["open"] and
            prev["close"] < prev["open"] and
            curr["close"] > prev["open"] and
            curr["open"] < prev["close"])

# Проверяем паттерн на обоих ТФ
pattern_5m = bullish_engulfing(df_5m)
pattern_1h = bullish_engulfing(df_1h)

if pattern_5m and pattern_1h:
    print("✅ Быстрое и старшее бычье поглощение — сигнал на ЛОНГ")
else:
    print("Нет совпадения паттернов — сигнал игнорируется")

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

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

📌Liquidity Migration Detector – Отслеживание миграции ликвидности с актива или биржи🧑‍💻

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

Liquidity Migration — это явление, когда ликвидность (объёмы, глубина стакана, активность маркетмейкеров) перетекает:

- с одного актива на другой (например, из BTC в ETH, или из SOL в мемкойны),

- с одной биржи на другую (например, с Binance на OKX),

- или между деривативами и спотом.

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

Уход ликвидности → риск резких движений, спредов, проскальзывания

Приток ликвидности → повышенная интересность для торговли и сигнал к ротации капитала

Может быть прекурсором трендового движения

import ccxt

exchange = ccxt.binance()

symbols = ["BTC/USDT", "ETH/USDT", "SOL/USDT", "DOGE/USDT"]
result = []

for symbol in symbols:
    ticker = exchange.fetch_ticker(symbol)
    orderbook = exchange.fetch_order_book(symbol, limit=20)
    depth = sum([v for _, v in orderbook["bids"]]) + sum([v for _, v in orderbook["asks"]])
    
    result.append({
        "symbol": symbol,
        "24h_volume": ticker["quoteVolume"],
        "orderbook_depth": depth
    })

# Сортировка по ликвидности
sorted_data = sorted(result, key=lambda x: x["24h_volume"], reverse=True)

print("Текущая ликвидность по активам:")
for r in sorted_data:
    print(f"{r['symbol']}: объем = {r['24h_volume']:.2f}, стакан = {r['orderbook_depth']:.2f}")

#инструмент

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

📌Session Overlap Strategy – Торговля на стыке торговых сессий (Азия, Европа, США) 🧑‍💻

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

Между основными торговыми сессиями (Азия → Европа → США) происходят стыки активности, на которых:

- Объём и волатильность резко увеличиваются,

- Происходит пробой диапазонов предыдущей сессии,

- Растёт вероятность импульсных движений или разворотов.

Цель стратегии💸 — входить в направлении пробоя или ловить отскок от границ диапазона предыдущей сессии на моменте их пересечения.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "15m", limit=96),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df.set_index("ts", inplace=True)

# Определим азиатскую сессию (00:00–08:00 UTC)
asian_session = df.between_time("00:00", "08:00")
asia_high = asian_session["high"].max()
asia_low = asian_session["low"].min()

# Сигнал в начале Европы (например, 07:15–08:30)
europe_open = df.between_time("07:15", "08:30")
latest_price = europe_open["close"].iloc[-1]

if latest_price > asia_high:
    print("⚡ Пробой вверх диапазона Азии → сигнал на ЛОНГ")
elif latest_price < asia_low:
    print("⚡ Пробой вниз диапазона Азии → сигнал на ШОРТ")
else:
    print("Цена внутри азиатского диапазона – без сигнала")

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

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

📌Autoencoder Anomaly Detection – Выявление рыночных аномалий через автоэнкодер🧑‍💻

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

Автоэнкодер — это тип нейросети, обучающийся восстанавливать входные данные.

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

Применение в трейдинге:💸

- Выявление всплесков/скачков, нехарактерных движений, фейков, манипуляций

- Используется для фильтрации фейковых сигналов или входа в момент выхода за “норму”

import pandas as pd
import numpy as np
from keras.models import Model
from keras.layers import Input, Dense

# Данные
df = pd.read_csv("market_data.csv")  # Предположим, у вас есть OHLCV
features = ["close", "volume", "rsi", "ema", "atr"]
X = df[features].dropna()
X_scaled = (X - X.mean()) / X.std()

# Архитектура автоэнкодера
input_dim = X_scaled.shape[1]
input_layer = Input(shape=(input_dim,))
encoded = Dense(8, activation="relu")(input_layer)
decoded = Dense(input_dim, activation="linear")(encoded)

autoencoder = Model(input_layer, decoded)
autoencoder.compile(optimizer="adam", loss="mse")

# Обучение
autoencoder.fit(X_scaled, X_scaled, epochs=50, batch_size=32, shuffle=True, verbose=0)

# Вычисляем ошибку восстановления
recon = autoencoder.predict(X_scaled)
mse = np.mean((X_scaled - recon) ** 2, axis=1)
df["recon_error"] = mse

# Порог (например, 99-й перцентиль)
threshold = np.percentile(mse, 99)
df["anomaly"] = df["recon_error"] > threshold

print(df[["close", "recon_error", "anomaly"]].tail(10))

#инструмент

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