📌 Наш канал на 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❗️

📌Cycle Phase Strategy (Hilbert Transform) – Вход по фазе рыночного цикла🧑‍💻

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

Cycle Phase Strategy использует Гильберт-преобразование (Hilbert Transform) для определения фазы рыночного цикла:

Понимание, находится ли рынок в начале роста, на вершине, в падении или в основании.

Это позволяет точнее ловить развороты или поддерживать тренды.

Как работает Hilbert Transform в трейдинге:

- Преобразует временной ряд цен в аналитический сигнал (комплексная форма),

- Выделяет моментальную амплитуду и фазу движения,

Фаза цикла меняется от 0 до 360°:

0° → начало роста,

90° → вершина,

180° → начало падения,

270° → основание рынка.

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

- Фаза около 0° или 360° → покупка (рост начинается)

- Фаза около 180° → продажа (падение начинается)

- Можно использовать фазовые переходы через ±45° для более точного входа/выхода.

import ccxt
import pandas as pd
import numpy as np
import scipy.signal

# Получение данных
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")

# Расчёт Hilbert Transform для цен закрытия
analytic_signal = scipy.signal.hilbert(df["close"])
instantaneous_phase = np.angle(analytic_signal, deg=True)  # В градусах
df["phase"] = (instantaneous_phase + 360) % 360  # Приведение к 0–360°

# Генерация сигналов
df["signal"] = 0
df.loc[(df["phase"] < 45) | (df["phase"] > 315), "signal"] = 1    # Buy
df.loc[(df["phase"] > 135) & (df["phase"] < 225), "signal"] = -1  # Sell

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

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

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

📌Sweep Detection Strategy – Вход после выявления "свипа" крупных лимиток🧑‍💻

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

Sweep (свип) — это событие, когда огромный объём рыночных ордеров быстро сметает крупные лимитные заявки в стакане на определённой цене.

Такой всплеск ликвидации уровней часто сигнализирует о:

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

- Проломе поддержки или сопротивления,

- Важной инициативе покупателей или продавцов.

Что такое свип в стакане:🛠️

- Был крупный лимитный объём на ценовом уровне.

- Появился мощный рыночный ордер (market buy или market sell).

- Лимитки быстро исчезли → цена пошла в их сторону (или против них).

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

- Buy: после свипа крупных sell-лимиток (ask sweep).

- Sell: после свипа крупных buy-лимиток (bid sweep).

- Подтверждение: объём, дельта, ускорение в ленте сделок.

import ccxt
import time

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 10
sweep_volume_threshold = 50  # например, 50 BTC
poll_interval = 2  # сек

def fetch_order_book():
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    return depth['bids'], depth['asks']

prev_bids, prev_asks = fetch_order_book()

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

    # Проверка на исчезновение крупных заявок
    for (prev_price, prev_volume), (new_price, new_volume) in zip(prev_bids, bids):
        if prev_volume > sweep_volume_threshold and new_volume < prev_volume * 0.5:
            print(f"⚡ Свип BID на {prev_price}: {prev_volume:.2f} -> {new_volume:.2f} BTC")

    for (prev_price, prev_volume), (new_price, new_volume) in zip(prev_asks, asks):
        if prev_volume > sweep_volume_threshold and new_volume < prev_volume * 0.5:
            print(f"⚡ Свип ASK на {prev_price}: {prev_volume:.2f} -> {new_volume:.2f} BTC")

    prev_bids, prev_asks = bids, asks

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

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

📌Hidden Liquidity Revealer – Стратегия по выявлению скрытых заявок🧑‍💻

Суть идеи:🛠️

Hidden liquidity — это лимитные ордера, которые не видны в стакане или выглядят маленькими, но на самом деле:

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

- Или они постоянно восстанавливаются ("айсберги").

Стратегия "подсветки" — это способ обнаружить такие скрытые уровни, чтобы:💸

- Не попасть в ловушку при пробоях,

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

- Использовать эти зоны для точного входа или выхода.

Как можно выявить скрытую ликвидность:🚀

1. Необычная устойчивость цены на уровне без видимой поддержки в стакане.

2. Повторное появление заявок после частичного съедения.

3. Замедление рыночного исполнения при небольших видимых ордерах.

4. Анализ ленты сделок — большое количество исполнений по одному уровню без перемещения цены.

import ccxt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 5
check_interval = 2  # секунды

def get_top_levels():
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    best_bid = depth["bids"][0]  # [цена, объём]
    best_ask = depth["asks"][0]
    return best_bid, best_ask

# Инициализация
previous_bid, previous_ask = get_top_levels()

while True:
    time.sleep(check_interval)
    current_bid, current_ask = get_top_levels()

    # Проверка на "регенерацию" объёма
    if abs(current_bid[0] - previous_bid[0]) < 1e-3 and current_bid[1] > previous_bid[1]:
        print(f"🟢 Обнаружено пополнение BID на {current_bid[0]}: {current_bid[1]:.2f} BTC")

    if abs(current_ask[0] - previous_ask[0]) < 1e-3 and current_ask[1] > previous_ask[1]:
        print(f"🔴 Обнаружено пополнение ASK на {current_ask[0]}: {current_ask[1]:.2f} BTC")

    previous_bid, previous_ask = current_bid, current_ask

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

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

📌Triangular Arbitrage Bot — Арбитраж между тройкой валют на одной бирже🧑‍💻

Что такое треугольный арбитраж?🛠️

Это стратегия, при которой ты:

1. Обмениваешь валюту A на валюту B,

2. Обмениваешь валюту B на валюту C,

3. Обмениваешь валюту C обратно на валюту A.

Цель:💸

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

Что нужно учитывать:🧨

- Комиссии биржи (обычно 0.075–0.1% за каждую операцию),

- Ликвидность на уровнях цен (объём в стакане),

- Время исполнения — сделки должны быть очень быстрыми,

- Минимальные лоты и требования к ордерам.

import ccxt

exchange = ccxt.binance()

symbols = ["BTC/USDT", "ETH/BTC", "ETH/USDT"]
tickers = exchange.fetch_tickers(symbols)

btc_usdt_ask = tickers["BTC/USDT"]["ask"]  # купить BTC
eth_btc_ask = tickers["ETH/BTC"]["ask"]    # купить ETH за BTC
eth_usdt_bid = tickers["ETH/USDT"]["bid"]   # продать ETH за USDT

initial_usdt = 1000

btc_amount = initial_usdt / btc_usdt_ask
eth_amount = btc_amount / eth_btc_ask
final_usdt = eth_amount * eth_usdt_bid

profit = final_usdt - initial_usdt
profit_pct = profit / initial_usdt * 100

print(f"Старт: {initial_usdt} USDT → Конец: {final_usdt:.2f} USDT")
print(f"Профит: {profit:.2f} USDT ({profit_pct:.2f}%)")

#арбитраж

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

📌Google Trends Impact Strategy – Стратегия на основе роста поисковых запросов🧑‍💻

Суть идеи:🛠️

Google Trends Impact Strategy основывается на том, что:

- Всплеск интереса в поиске по названию актива (например, Bitcoin, Ethereum)

- Часто предшествует росту волатильности, импульсам, или даже ценовому тренду.

Идея💸 — использовать резкое увеличение частоты запросов как сигнал к входу в рынок или повышению бдительности.

from pytrends.request import TrendReq
import pandas as pd

pytrends = TrendReq()

# Ключевое слово
kw = "Bitcoin"

# Получаем данные за последние 30 дней
pytrends.build_payload([kw], cat=0, timeframe='now 30-d', geo='', gprop='')
data = pytrends.interest_over_time()

# Проверяем последний прирост
data['change'] = data[kw].pct_change() * 100
latest = data.iloc[-1]

print(f"Актуальный интерес к '{kw}': {latest[kw]}")
print(f"Суточное изменение: {latest['change']:.2f}%")

# Сигнал
if latest['change'] > 30:
    print("⚡ Всплеск интереса! Возможен рост активности на рынке.")
else:
    print("Нет значимого роста поисковой активности.")

#инструмент

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

📌ADX Reversion on Low Trend Regime – Стратегия возврата к среднему при слабом тренде🧑‍💻

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

Индикатор ADX (Average Directional Index) измеряет силу тренда, не его направление.

Если ADX низкий (обычно < 20–25), рынок во флете или в фазе консолидации.

В такие периоды хорошо работает стратегия возврата к среднему (mean reversion).

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

Основные компоненты:💸

1. Фильтр по ADX:

- ADX < 20 → рынок во флете

Разрешаем вход только при низкой трендовости❗

2. Отклонение цены от средней (например, EMA):

Цена выше EMA + X% → Sell

Цена ниже EMA − X% → Buy

import ccxt
import pandas as pd
import talib as ta

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

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

# EMA и ADX
df["ema"] = ta.trend.ema_indicator(df["close"], window=50).ema_indicator()
adx = ta.trend.adx(df["high"], df["low"], df["close"], window=14)
df["adx"] = adx

# Сигналы: если цена далеко от EMA при слабом тренде
threshold = 0.01  # 1%
df["signal"] = 0

# Buy при отклонении вниз и слабом тренде
df.loc[
    (df["adx"] < 20) & 
    (df["close"] < df["ema"] * (1 - threshold)), 
    "signal"
] = 1

# Sell при отклонении вверх и слабом тренде
df.loc[
    (df["adx"] < 20) & 
    (df["close"] > df["ema"] * (1 + threshold)), 
    "signal"
] = -1

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

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

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

📌Liquidity Vacuum Entry – Вход в сделку при возникновении “вакуумов” ликвидности🧑‍💻

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

Liquidity Vacuum — это участок рынка, где почти отсутствуют лимитные ордера в стакане на определённом ценовом диапазоне.
Если цена входит в такую зону, она часто проскальзывает быстро, пока не встретит новую ликвидность.

Стратегия Liquidity Vacuum Entry:💸

- Находит “пустые зоны” в стакане,

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

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

import ccxt

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth = exchange.fetch_order_book(symbol, limit=50)

# Задаём порог пустоты
vacuum_threshold = 1.0  # минимальный объём в BTC
gap_threshold = 2.0     # минимальное ценовое расстояние между уровнями

# Анализ BID-стороны
last_price = depth['bids'][0][0]
vacuum_zones = []

for i in range(len(depth['bids']) - 1):
    price1, vol1 = depth['bids'][i]
    price2, vol2 = depth['bids'][i + 1]

    if vol1 < vacuum_threshold and vol2 < vacuum_threshold:
        price_gap = abs(price1 - price2)
        if price_gap > gap_threshold:
            vacuum_zones.append((price2, price1))

print("Обнаружены BID-вакуумы:")
for low, high in vacuum_zones:
    print(f"Между {low:.2f} – {high:.2f}")

# Аналогично можно анализировать и ASK-сторону

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

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

📌Dynamic Trend Channel Strategy – Скользящий канал на основе отклонений от EMA🧑‍💻

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

Dynamic Trend Channel — это адаптивный канал, строящийся вокруг скользящей средней (обычно EMA), с границами, определёнными на основе:

- волатильности (например, ATR),

- или процентного отклонения от EMA.

Цель — определить динамический коридор, в пределах которого цена колеблется, и торговать:

- от границ к центру (mean reversion) во флэте,

- по направлению пробоя — в тренде.

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

Вход в лонг, если цена касается нижней границы, и тренд восходящий

Вход в шорт, если цена касается верхней границы, и тренд нисходящий

Выход — в центре канала (EMA) или фиксированный тейк/стоп

import ccxt
import pandas as pd
import ta

# Получение данных
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")

# Параметры канала
ema_period = 50
atr_period = 14
atr_mult = 1.5

# EMA и ATR
df["ema"] = ta.trend.ema_indicator(df["close"], window=ema_period).ema_indicator()
df["atr"] = ta.volatility.AverageTrueRange(df["high"], df["low"], df["close"], window=atr_period).average_true_range()

# Границы канала
df["upper"] = df["ema"] + atr_mult * df["atr"]
df["lower"] = df["ema"] - atr_mult * df["atr"]

# Сигналы
df["signal"] = 0
df.loc[df["close"] < df["lower"], "signal"] = 1   # Покупка
df.loc[df["close"] > df["upper"], "signal"] = -1  # Продажа

print(df[["ts", "close", "lower", "ema", "upper", "signal"]].tail(10))

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

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

📌Fisher Transform Trend Filter – фильтрация фейковых движений с помощью индикатора Фишера🧑‍💻

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

Fisher Transform — это осциллятор, который преобразует ценовое движение в нормальное распределение, делая развороты и тренды более чёткими и симметричными.

Применяется как тренд-фильтр или точка разворота, особенно для:💸

- Фильтрации ложных импульсов,

- Подтверждения сигнала входа,

- Точечного выхода из позиции.

Преимущества Fisher Transform:💸

- Улавливает экстремумы с меньшим запаздыванием, чем RSI

- Хорошо работает в связке с другими трендовыми индикаторами (EMA, ADX)

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

import ccxt
import pandas as pd
import numpy as np

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

# Настройки Fisher
period = 10
hl2 = (df["high"] + df["low"]) / 2
min_low = hl2.rolling(window=period).min()
max_high = hl2.rolling(window=period).max()

# Нормализация
value = 2 * ((hl2 - min_low) / (max_high - min_low + 1e-9) - 0.5)
value = value.clip(-0.999, 0.999)

# Расчёт Fisher Transform
fisher = 0.5 * np.log((1 + value) / (1 - value))
df["fisher"] = fisher.rolling(2).mean()

# Сигналы
df["signal"] = 0
df.loc[(df["fisher"] > 0) & (df["fisher"].shift(1) < 0), "signal"] = 1   # Лонг
df.loc[(df["fisher"] < 0) & (df["fisher"].shift(1) > 0), "signal"] = -1  # Шорт

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

#индикатор

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

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