📌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❗️

📌Cross-Exchange Funding Rate Arbitrage – Арбитраж на разнице ставок финансирования между биржами🧑‍💻

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

Funding Rate Arbitrage использует то, что разные биржи назначают разные ставки финансирования (funding rate) на бессрочные фьючерсы (perpetual contracts).

Цель стратегии — открыть противоположные позиции на двух биржах и зарабатывать на разнице funding rate, при этом:

- Сохраняется рыночный нейтралитет (цена не важна),

- Основная прибыль идёт от разницы в выплатах между биржами.💸

import ccxt

binance = ccxt.binance()
bybit = ccxt.bybit()

symbol = "BTC/USDT:USDT"

binance_funding = binance.fetch_funding_rate(symbol)["fundingRate"]
bybit_funding = bybit.fetch_funding_rate(symbol)["fundingRate"]

spread = binance_funding - bybit_funding

print(f"Binance funding: {binance_funding:.5f}")
print(f"Bybit funding:   {bybit_funding:.5f}")
print(f"Разница (спред): {spread:.5f}")

if abs(spread) > 0.0003:  # 0.03%
    if spread > 0:
        print("✅ Лонг на Binance, шорт на Bybit — положительное арбитражное плечо")
    else:
        print("✅ Лонг на Bybit, шорт на Binance — положительное арбитражное плечо")
else:
    print("Разница мала — арбитраж невыгоден")

#арбитраж

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

📌Day of Week Bias Strategy – Торговля по дневной сезонности🧑‍💻

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

Day of Week Bias (или сезонность по дням недели) — это стратегия, основанная на том, что в исторических данных может прослеживаться предсказуемое поведение рынка в определённые дни недели.

Например:💸

- BTC часто падал по понедельникам,

- Альткоины показывали рост по пятницам,

- Минимумы чаще формировались по вторникам и четвергам.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1d", limit=365)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df["day"] = df["ts"].dt.day_name()
df["return"] = df["close"].pct_change()

# Группируем по дням недели
stats = df.groupby("day")["return"].agg(["mean", "std", "count"])
stats["sharpe"] = stats["mean"] / stats["std"]

# Сортируем по средней доходности
stats = stats.sort_values(by="mean", ascending=False)
print(stats)

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

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

📌DeFi Gas Spike Strategy – Стратегия на основе всплеска комиссии в сети (Gas) как сигнал к панике или ажиотажу🧑‍💻

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

Комиссия (Gas price) в DeFi-сетях, таких как Ethereum, Arbitrum, BSC, Polygon, — это высокочувствительный индикатор поведения толпы.
Резкое увеличение цены газа (Gas Spike) указывает на:

- ажиотаж — массовое FOMO, запуск новых токенов, NFT, memecoins,

- панику — массовый выход из протоколов, скам, взломы, ликвидации.

Идея стратегии:💸

> Реагировать на всплески газа как на опережающий сигнал рыночной турбулентности:
или входить (при FOMO), или шортить (при панике).

import requests

def get_gas_price():
    url = "https://api.etherscan.io/api"
    params = {
        "module": "gastracker",
        "action": "gasoracle",
        "apikey": "YOUR_ETHERSCAN_API_KEY"
    }
    r = requests.get(url, params=params)
    data = r.json()
    return int(data["result"]["FastGasPrice"])

# Пример сигнала
gas = get_gas_price()
if gas > 100:
    print(f"⚠️ Высокий GAS: {gas} Gwei — возможна паника или ажиотаж")
elif gas < 40:
    print(f"GAS нормальный: {gas} Gwei")

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

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

📌Reinforcement Learning with Risk Constraints – Обучение с подкреплением с ограничением по риску🧑‍💻

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

Это стратегия, в которой агент обучается на основе Reinforcement Learning (RL) принимать торговые решения, учитывая не только прибыль, но и ограничения по риску:

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

- Волатильность позиции (Stdev)

- Value at Risk (VaR)

- Ограничение на потери за эпизод/день

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

Где это применимо:🚀

- Алготрейдинг с лимитами по просадке

- Криптофонды с ограничением на daily VaR

- Автоуправление позицией с учётом волатильности

- Агент для стратегии с мягким контролем риска

Пример среды(псевдо-код)💻

class TradingEnvWithRisk(gym.Env):
    def __init__(self):
        ...
        self.max_drawdown = 0.2  # ограничение
        self.volatility_limit = 0.05
        ...

    def step(self, action):
        ...
        pnl = self.calc_profit()
        risk = self.calc_volatility()  # или drawdown, VaR, CVaR
        penalty = self.lambda_ * max(0, risk - self.volatility_limit)
        reward = pnl - penalty
        ...
        return obs, reward, done, info

#инструмент

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

📌Bayesian Optimization for Hyperparameters – Автонастройка стратегий и ML-моделей🧑‍💻

Суть метода:🛠️

Байесовская оптимизация (Bayesian Optimization) — это метод поиска наилучших гиперпараметров для стратегии или модели,
при котором:

- Строится вероятностная модель зависимости гиперпараметры → результат (обычно Gaussian Process),

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

Метод быстрее и умнее, чем перебор (Grid Search) или случайный поиск (Random Search).

Где применяется в трейдинге:💸

- Оптимизация параметров стратегии (например: RSI период, TP/SL, ATR множитель)

- Настройка моделей ML (например: XGBoost: learning_rate, max_depth, n_estimators)

- Комбинирование индикаторов и фильтров

- Поиск оптимальных весов в портфеле

import optuna

def objective(trial):
    rsi_period = trial.suggest_int("rsi_period", 5, 30)
    tp = trial.suggest_float("take_profit", 0.01, 0.1)
    sl = trial.suggest_float("stop_loss", 0.01, 0.1)

    score = backtest_strategy(rsi_period, tp, sl)  # вернуть, например, Sharpe Ratio
    return score

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50)

print("Лучшие параметры:", study.best_params)

#инструмент

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

📌Deep Q-Networks for Execution – Оптимизация исполнения сделок с помощью DQN🧑‍💻

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

Deep Q-Network (DQN) — это метод обучения с подкреплением, где агент обучается максимизировать ожидаемую награду, выбирая действия (дискретные) на основе текущего состояния.

В контексте оптимизации исполнения ордеров, DQN обучается решать задачу:💸

> Когда и как исполнять ордер (market/limit/split), чтобы минимизировать издержки (slippage, impact) и максимизировать итоговый результат.

import torch
import torch.nn as nn

class DQN(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(DQN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 128), nn.ReLU(),
            nn.Linear(128, 128), nn.ReLU(),
            nn.Linear(128, output_dim)
        )

    def forward(self, x):
        return self.net(x)

#инструмент

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

📌High-Frequency Entry Strategy – Стратегия с большим количеством входов в позиции🧑‍💻

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

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

Принцип входа:💸

- Используются частые сигналы от осцилляторов и краткосрочных условий волатильности

- Вход при чётком импульсе на малом ТФ

- Выход через фиксированный TP/SL или по времени

- Можно выполнять 20+ входов в сутки

Используемые индикаторы:🚀

- RSI (период 5): краткосрочная перекупленность/перепроданность

- ATR: фильтрация по волатильности

- EMA 21 / EMA 50: подтверждение направления

- Volume Spike (объём выше среднего) — дополнительный триггер

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

exchange = ccxt.binance()
symbol = "BTC/USDT"
timeframe = "5m"

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")

# Индикаторы
df["rsi"] = ta.momentum.RSIIndicator(df["close"], window=5).rsi()
df["ema21"] = ta.trend.EMAIndicator(df["close"], window=21).ema_indicator()
df["ema50"] = ta.trend.EMAIndicator(df["close"], window=50).ema_indicator()
df["atr"] = ta.volatility.AverageTrueRange(df["high"], df["low"], df["close"], window=14).average_true_range()
df["volume_mean"] = df["volume"].rolling(20).mean()

# Сигналы
df["signal"] = 0

# Лонг-сигнал
df.loc[
    (df["rsi"] < 30) &
    (df["close"] > df["ema21"]) &
    (df["volume"] > df["volume_mean"]) &
    (df["atr"] > df["atr"].rolling(20).mean()),
    "signal"
] = 1

# Шорт-сигнал
df.loc[
    (df["rsi"] > 70) &
    (df["close"] < df["ema21"]) &
    (df["volume"] > df["volume_mean"]) &
    (df["atr"] > df["atr"].rolling(20).mean()),
    "signal"
] = -1

# Последние сигналы
signals = df[df["signal"] != 0][["ts", "close", "signal"]].tail(10)
print(signals)

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

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

📌Variational Autoencoders for Regime Clustering – Выявление рыночных фаз через вариационные автоэнкодеры🧑‍💻

Суть метода:🛠️

Variational Autoencoder (VAE) — это вероятностная нейросетевая модель, которая обучается сжимать данные в компактное латентное пространство,
а затем восстанавливать их с минимальной потерей информации.

Идея для трейдинга:💸

> Пропустить рыночные данные (например, свечи + индикаторы) через VAE,
Изучить распределение в латентном пространстве,
Затем кластеризовать его (например, через KMeans) и определить рыночные фазы:

- Флэт

- Тренд вверх

- Тренд вниз

- Волатильный переходный режим

Спекулятивный всплеск

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from tensorflow.keras import layers, Model

# Данные: окна по 30 свечей (OHLC)
X = np.load("windows_30.npy")  # форма (N, 30, 4)
X = X.reshape((X.shape[0], -1))  # flatten
X = StandardScaler().fit_transform(X)

# VAE: encoder
input_dim = X.shape[1]
inputs = layers.Input(shape=(input_dim,))
h = layers.Dense(64, activation="relu")(inputs)
z_mean = layers.Dense(8)(h)
z_logvar = layers.Dense(8)(h)

# Sampling
def sample(args):
    z_mean, z_logvar = args
    eps = np.random.normal(size=z_mean.shape)
    return z_mean + np.exp(0.5 * z_logvar) * eps

z = layers.Lambda(sample)([z_mean, z_logvar])

# Decoder
decoder_h = layers.Dense(64, activation="relu")(z)
outputs = layers.Dense(input_dim)(decoder_h)

vae = Model(inputs, outputs)
vae.compile(optimizer="adam", loss="mse")
vae.fit(X, X, epochs=50, batch_size=64, verbose=0)

# Получение латентных векторов
encoder = Model(inputs, z_mean)
Z = encoder.predict(X)

# Кластеризация в режимы
kmeans = KMeans(n_clusters=4).fit(Z)
regimes = kmeans.labels_

# Теперь можно сопоставить фазу рынку
df = pd.DataFrame({"regime": regimes})
print(df["regime"].value_counts())

#инструмент

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