📌 Auto-Trailing Profit – Перемещение тейк-профита при росте цены🧑‍💻

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

Auto-Trailing Profit — это автоматическое перемещение тейк-профита вверх, когда цена растёт, чтобы:

Зафиксировать прибыль, если тренд развернётся,

И максимизировать выход, если тренд продолжается.💸

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

import ccxt
import time

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
POSITION_SIZE = 0.01  # BTC
TRAIL_START = 100.0  # начальная прибыль (в $)
TRAIL_STEP = 50.0    # шаг подтягивания (в $)

def get_price():
    return EXCHANGE.fetch_ticker(PAIR)['last']

def trailing_tp_manager(entry_price):
    max_profit = 0
    tp_price = entry_price + TRAIL_START

    while True:
        price = get_price()
        profit = (price - entry_price) * POSITION_SIZE

        print(f"\nТекущая цена: {price:.2f} | Профит: ${profit:.2f} | Текущий TP: {tp_price:.2f}")

        if profit > max_profit:
            max_profit = profit

        # Перемещаем тейк-профит вверх при достижении следующего шага
        new_tp_price = entry_price + ((int((max_profit - TRAIL_START) / TRAIL_STEP) + 1) * TRAIL_STEP) / POSITION_SIZE
        if new_tp_price > tp_price:
            tp_price = new_tp_price
            print(f"🔄 TP обновлён: {tp_price:.2f}")

        # Эмуляция: цена опустилась ниже TP → фиксация
        if price <= tp_price:
            print(f"✅ Цена достигла TP: {tp_price:.2f} → фиксация прибыли")
            break

        time.sleep(10)

# Пример входа
if __name__ == "__main__":
    entry = get_price()
    print(f"📈 Вход по {entry:.2f}, старт трейлинг TP...")
    trailing_tp_manager(entry)

#ордер

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

📌 PCA Strategy Reducer – Сокращение количества сигналов через анализ главных компонент (PCA)🧑‍💻

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

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

избыточными (повторяющимися),

шумными (противоречивыми),

слабо значимыми.

PCA (Principal Component Analysis) позволяет:
→ сжать индикаторы до нескольких основных факторов,
→ уменьшить количество сигналов,
→ улучшить точность входа и устойчивость модели.

Применение:

Преобразовать 5–10 индикаторов (RSI, MACD, ATR, Bollinger Width, Momentum...)

Сократить до 2–3 главных компонент

Строить сигналы на основе этих компонент (например, PCA_1 > порога)

import ccxt
import pandas as pd
import numpy as np
import talib
from sklearn.decomposition import PCA

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK = 100
N_COMPONENTS = 2

def fetch_data():
    ohlcv = EXCHANGE.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    return df

def calculate_indicators(df):
    df["rsi"] = talib.RSI(df["close"], timeperiod=14)
    df["macd"], _, _ = talib.MACD(df["close"])
    df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)
    df["momentum"] = talib.MOM(df["close"], timeperiod=10)
    df["boll_width"] = talib.BBANDS(df["close"])[1] - talib.BBANDS(df["close"])[2]
    df.dropna(inplace=True)
    return df

def apply_pca(df):
    features = df[["rsi", "macd", "atr", "momentum", "boll_width"]]
    pca = PCA(n_components=N_COMPONENTS)
    components = pca.fit_transform(features)
    df["pca_1"] = components[:, 0]
    df["pca_2"] = components[:, 1]
    return df, pca.explained_variance_ratio_

def signal_from_pca(df):
    last_pca = df.iloc[-1][["pca_1", "pca_2"]]
    print(f"\nPCA-1: {last_pca['pca_1']:.2f} | PCA-2: {last_pca['pca_2']:.2f}")

    if last_pca["pca_1"] > 1.0:
        print("📈 Сигнал на покупку (основной компонент указывает на силу)")
    elif last_pca["pca_1"] < -1.0:
        print("📉 Сигнал на продажу")
    else:
        print("⏳ Нет сигнала — нейтральное состояние")

if __name__ == "__main__":
    df = fetch_data()
    df = calculate_indicators(df)
    df, variance = apply_pca(df)
    print(f"Объяснённая дисперсия компонент: {variance}")
    signal_from_pca(df)

#индикатор

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

📌 Volatility Regime Classifier – Переключение стратегий по типу рынка🧑‍💻

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

Рынок постоянно меняет состояние:

Трендовый (высокая волатильность, направленное движение)

Флэт (низкая волатильность, боковое движение)

Volatility Regime Classifier — это инструмент, который:🚀

1. Определяет текущее состояние рынка (режим),

2. Автоматически включает подходящую стратегию (например, трендовую или флетовую).

import ccxt
import pandas as pd
import talib
import time

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK = 100
ATR_PERIOD = 14
TREND_THRESHOLD = 200  # условный порог волатильности (в USD)

def fetch_data():
    ohlcv = EXCHANGE.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    return df

def classify_volatility_regime(df):
    atr = talib.ATR(df["high"], df["low"], df["close"], timeperiod=ATR_PERIOD)
    last_atr = atr.iloc[-1]

    print(f"\nТекущий ATR: {last_atr:.2f} USD")

    if last_atr > TREND_THRESHOLD:
        print("📈 Режим: ТРЕНД → активируем трендовую стратегию (например, MA crossover)")
    else:
        print("🔄 Режим: ФЛЭТ → активируем стратегию на возврат (например, Bollinger Reversion)")

if __name__ == "__main__":
    while True:
        df = fetch_data()
        classify_volatility_regime(df)
        time.sleep(60 * 5)

#индикатор

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

📌 Dynamic Entry Splitter – Адаптивное разбиение позиции по условиям рынка🧑‍💻

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

Вместо того чтобы входить в рынок одним большим ордером, позиция разбивается на несколько частей, которые исполняются в зависимости от:

- текущей ликвидности,
- глубины стакана,
- волатильности,
- объёма,
- или других рыночных условий.

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

→ уменьшить проскальзывание,
→ войти более точно,
→ скрыть крупный вход от других участников (анти-HFT подход).

import ccxt
import time
import random

# Настройки
EXCHANGE = ccxt.binance({
    # "apiKey": "YOUR_API_KEY",
    # "secret": "YOUR_SECRET",
    "enableRateLimit": True
})

PAIR = "BTC/USDT"
TOTAL_AMOUNT = 1.0  # BTC
MIN_PART = 0.05     # минимальная доля
MAX_PART = 0.2      # максимальная доля
SPREAD_THRESHOLD = 20  # в USD
DEPTH = 10
CHECK_INTERVAL = 10  # сек

def get_order_book():
    book = EXCHANGE.fetch_order_book(PAIR, limit=DEPTH)
    best_bid = book['bids'][0][0]
    best_ask = book['asks'][0][0]
    spread = best_ask - best_bid
    return best_bid, best_ask, spread

def adaptive_entry():
    remaining = TOTAL_AMOUNT
    print(f"Начинаем адаптивный вход на сумму {TOTAL_AMOUNT} BTC...\n")
    while remaining > 0:
        bid, ask, spread = get_order_book()
        mid = (bid + ask) / 2

        print(f"Цена BID: {bid:.2f}, ASK: {ask:.2f}, Спред: {spread:.2f}")

        if spread <= SPREAD_THRESHOLD:
            size = min(random.uniform(MIN_PART, MAX_PART), remaining)
            price = bid  # вход лимитом по BID
            print(f"📥 Размещаем ордер на {size:.4f} BTC по {price:.2f}")
            # order = EXCHANGE.create_limit_buy_order(PAIR, size, price)  # для реальной торговли
            remaining -= size
        else:
            print("⏳ Спред широкий, ждём улучшения...")

        print(f"Осталось: {remaining:.4f} BTC\n")
        time.sleep(CHECK_INTERVAL)

if __name__ == "__main__":
    adaptive_entry()

#ордер

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

📌 Price Delay Arbitrage – Арбитраж при задержке обновления цен между биржами🧑‍💻

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

На разных биржах котировки одного и того же актива могут обновляться с задержкой.
Если:

Биржа A уже отреагировала на движение,

А Биржа B ещё нет,
→ Можно войти на медленной бирже, пока цена не догнала.💸

Это форма low-latency арбитража, похожая на front-running, но без необходимости HFT.

import ccxt
import time

# Настройки
SYMBOL = "BTC/USDT"
THRESHOLD = 0.4  # % расхождения
INTERVAL = 1  # сек

# Биржи
fast = ccxt.binance()
slow = ccxt.kucoin()

def get_price(exchange):
    try:
        ticker = exchange.fetch_ticker(SYMBOL)
        return ticker['last'], ticker['datetime']
    except:
        return None, None

def check_price_delay_arbitrage():
    price_fast, time_fast = get_price(fast)
    price_slow, time_slow = get_price(slow)

    if not price_fast or not price_slow:
        return

    spread = price_fast - price_slow
    spread_pct = spread / price_fast * 100

    print(f"\nFast: {price_fast:.2f} ({time_fast}) | Slow: {price_slow:.2f} ({time_slow}) | Spread: {spread_pct:.2f}%")

    if abs(spread_pct) >= THRESHOLD:
        direction = "BUY slow / SELL fast" if spread > 0 else "BUY fast / SELL slow"
        print(f"⚡ Возможность арбитража! Направление: {direction}")

if __name__ == "__main__":
    while True:
        check_price_delay_arbitrage()
        time.sleep(INTERVAL)

#арбитраж

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

📌 LSTM Trend Predictor – Прогноз движения цены с помощью LSTM🧑‍💻

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

LSTM (Long Short-Term Memory) — тип рекуррентной нейросети, которая хорошо справляется с временными рядами, в том числе с финансовыми данными.
Модель обучается на исторических свечах и пытается предсказать направление (или цену) на следующий шаг.

Пример задачи:💻

Вход: последовательность из 50 последних цен

Цель: предсказать цену/тренд на следующую свечу

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

- определения тренда (вверх/вниз),

- генерации сигналов для стратегии,

- фильтрации других индикаторов.

import ccxt
import pandas as pd
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from sklearn.preprocessing import MinMaxScaler

# Параметры
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK = 500
WINDOW_SIZE = 50

# Получение данных
exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])

# Подготовка данных
scaler = MinMaxScaler()
scaled_close = scaler.fit_transform(df[['close']])

X, y = [], []
for i in range(WINDOW_SIZE, len(scaled_close)):
    X.append(scaled_close[i-WINDOW_SIZE:i])
    y.append(scaled_close[i])
X, y = np.array(X), np.array(y)

# Модель LSTM
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(X.shape[1], 1)))
model.add(Dropout(0.2))
model.add(LSTM(50))
model.add(Dropout(0.2))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# Обучение
model.fit(X, y, epochs=10, batch_size=32)

# Прогноз следующей цены
last_seq = scaled_close[-WINDOW_SIZE:]
last_seq = last_seq.reshape((1, WINDOW_SIZE, 1))
predicted = model.predict(last_seq)
predicted_price = scaler.inverse_transform(predicted)

print(f"📈 Прогноз следующей цены: {predicted_price[0][0]:.2f} USDT")

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

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

📌 Adaptive Stop Loss Manager – Управление стоп-лоссом в зависимости от волатильности🧑‍💻

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

Вместо фиксированного стоп-лосса, его размер адаптируется под текущую волатильность рынка, чтобы:

- избежать раннего выбивания,

- учитывать динамику рынка,

- уменьшить ложные срабатывания в "шумном" движении.

Принцип работы:💸

1. Расчёт волатильности (например, через ATR, StdDev или процент отклонения).

2. Установка стоп-лосса на X × волатильность ниже цены входа (для лонга) или выше (для шорта).

3. Возможность перемещения стопа при росте позиции (опционально — трейлинг).

import ccxt
import pandas as pd
import talib

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
ATR_PERIOD = 14
ATR_MULTIPLIER = 1.5  # множитель на волатильность
LOOKBACK = 100

def fetch_data():
    ohlcv = EXCHANGE.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    return df

def calculate_stop_loss(entry_price, side="long"):
    df = fetch_data()
    atr = talib.ATR(df["high"], df["low"], df["close"], timeperiod=ATR_PERIOD).iloc[-1]

    if side == "long":
        stop_loss = entry_price - (atr * ATR_MULTIPLIER)
    elif side == "short":
        stop_loss = entry_price + (atr * ATR_MULTIPLIER)
    else:
        raise ValueError("Сторона сделки должна быть 'long' или 'short'")

    print(f"\nATR: {atr:.2f} | Entry: {entry_price:.2f} | Stop-Loss: {stop_loss:.2f}")
    return stop_loss

# Пример вызова
if __name__ == "__main__":
    entry = 30000.0  # примерная цена входа
    calculate_stop_loss(entry_price=entry, side="long")

#ордер

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

📌Market Microstructure Scanner – Анализ микродвижений в стакане (order book)🧑‍💻

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

Market Microstructure — это анализ поведения участников в стакане и потоке ордеров для выявления:

- скрытых покупок/продаж,

- спуфинга (spoofing),

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

- импульсных дисбалансов.

import ccxt
import time

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
DEPTH = 20
THRESHOLD = 30  # BTC – крупная заявка
INTERVAL = 2  # сек

def scan_microstructure():
    prev_bids, prev_asks = None, None

    while True:
        book = EXCHANGE.fetch_order_book(PAIR, limit=DEPTH)
        bids = {price: volume for price, volume in book['bids']}
        asks = {price: volume for price, volume in book['asks']}

        print("\n--- Скан стакана ---")
        # Отслеживаем крупные заявки
        for side, data in [("BID", bids), ("ASK", asks)]:
            for price, volume in data.items():
                if volume >= THRESHOLD:
                    print(f"🧱 {side}: {volume:.2f} BTC на {price:.2f}")

        # Отслеживаем исчезновение крупных заявок (спуфинг)
        if prev_bids:
            disappeared = [
                price for price in prev_bids
                if prev_bids[price] >= THRESHOLD and price not in bids
            ]
            for price in disappeared:
                print(f"❗ Крупный BID исчез: {price}")

        if prev_asks:
            disappeared = [
                price for price in prev_asks
                if prev_asks[price] >= THRESHOLD and price not in asks
            ]
            for price in disappeared:
                print(f"❗ Крупный ASK исчез: {price}")

        prev_bids, prev_asks = bids, asks
        time.sleep(INTERVAL)

if __name__ == "__main__":
    scan_microstructure()

#ордер

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

📌Position Reversal Trigger – Переворот позиции при пробое уровня🧑‍💻

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

Если цена пробивает ключевой уровень (поддержки/сопротивления), текущая позиция:

Закрывается,

И тут же открывается в противоположную сторону.

Это позволяет моментально реагировать на изменение рыночной структуры, особенно при:

- ложных пробоях,

- переломах тренда,

- волатильных импульсах.

import ccxt
import time

# Настройки
EXCHANGE = ccxt.binance({
    # 'apiKey': 'your_api_key',
    # 'secret': 'your_api_secret',
    'enableRateLimit': True
})

PAIR = "BTC/USDT"
LEVEL = 30000.0  # ключевой уровень
POSITION = None  # текущая позиция: None, 'long', 'short'
AMOUNT = 0.01
INTERVAL = 10  # секунд

def get_price():
    return EXCHANGE.fetch_ticker(PAIR)['last']

def open_position(direction, amount, price):
    print(f"🚀 Открываем {direction.upper()} по {price}")
    # Пример: отправка рыночного ордера
    # if direction == "long":
    #     EXCHANGE.create_market_buy_order(PAIR, amount)
    # else:
    #     EXCHANGE.create_market_sell_order(PAIR, amount)

def close_position(current_price):
    print(f"❌ Закрытие позиции по {current_price}")
    # Здесь должна быть логика закрытия ордера (обратная операция)

def manage_position(price):
    global POSITION

    if POSITION == "long" and price < LEVEL:
        close_position(price)
        open_position("short", AMOUNT, price)
        POSITION = "short"

    elif POSITION == "short" and price > LEVEL:
        close_position(price)
        open_position("long", AMOUNT, price)
        POSITION = "long"

    elif POSITION is None:
        # Начальная позиция по текущему тренду
        if price > LEVEL:
            open_position("long", AMOUNT, price)
            POSITION = "long"
        elif price < LEVEL:
            open_position("short", AMOUNT, price)
            POSITION = "short"

if __name__ == "__main__":
    print(f"🎯 Запущен переворот по уровню {LEVEL}")
    while True:
        price = get_price()
        print(f"Цена: {price:.2f} | Позиция: {POSITION}")
        manage_position(price)
        time.sleep(INTERVAL)

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

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

📌Anomaly Detection Alert Bot – Обнаружение аномального поведения цены или объёма 🧑‍💻

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

Бот отслеживает внезапные и нетипичные изменения на рынке:

- всплески объёма,

- резкие ценовые движения,

-высокую волатильность,

→ и выдает сигналы/уведомления при обнаружении аномалий 🧨

Типы аномалий:🌐

1. Ценовые импульсы: резкое движение за 1 свечу

2. Всплеск объёма: объём > X × среднего

3. Отклонение от скользящего среднего (цены или объёма)

4. Волатильность выше нормы (по ATR/StdDev)

import ccxt
import pandas as pd
import time

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
TIMEFRAME = "5m"
LOOKBACK = 100
VOLUME_THRESHOLD = 2.5  # раз выше среднего
PRICE_JUMP_PCT = 1.0    # в % за свечу
CHECK_INTERVAL = 60  # сек

def fetch_data():
    ohlcv = EXCHANGE.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    return df

def detect_anomalies(df):
    last = df.iloc[-1]
    prev = df.iloc[-2]
    
    # Аномалия по объёму
    avg_volume = df['volume'][:-1].mean()
    volume_spike = last['volume'] > avg_volume * VOLUME_THRESHOLD
    
    # Аномалия по цене
    price_change_pct = abs(last['close'] - prev['close']) / prev['close'] * 100
    price_spike = price_change_pct >= PRICE_JUMP_PCT

    print(f"\nЦена: {last['close']:.2f} | Объём: {last['volume']:.2f} | Δ%: {price_change_pct:.2f}")

    if volume_spike:
        print(f"⚠️ Всплеск объёма: {last['volume']:.2f} > {avg_volume:.2f}")
    if price_spike:
        direction = "вверх" if last['close'] > prev['close'] else "вниз"
        print(f"⚡ Резкое движение {direction}: {price_change_pct:.2f}% за свечу")
    if not volume_spike and not price_spike:
        print("✅ Аномалий не обнаружено.")

# Основной цикл
if __name__ == "__main__":
    while True:
        df = fetch_data()
        detect_anomalies(df)
        time.sleep(CHECK_INTERVAL)

#индикатор

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

📌Kill Switch Bot – Автоматическое закрытие всех позиций при достижении лимита риска🧑‍💻

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

Kill Switch Bot — это защитный механизм, который:

Постоянно отслеживает PnL (прибыль/убыток) по всем позициям.

И при достижении заданного максимального убытка (например, −5%) или долларового лимита (например, −$500):

→ автоматически закрывает все открытые позиции

→ Можно использовать как антислив защиту или "паник-кнопку" в алгоритмах.

import ccxt
import time

# Настройки
MAX_DRAWDOWN_USD = -300  # максимальный убыток в долларах
CHECK_INTERVAL = 30  # сек

# Инициализация Binance Futures
exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET_KEY',
    'enableRateLimit': True,
    'options': {'defaultType': 'future'}
})

def fetch_total_unrealized_pnl():
    balance = exchange.fapiPrivate_get_account()
    total_pnl = 0
    for pos in balance['positions']:
        upnl = float(pos['unrealizedProfit'])
        total_pnl += upnl
    return total_pnl

def close_all_positions():
    positions = exchange.fapiPrivate_get_positionrisk()
    for pos in positions:
        symbol = pos['symbol']
        amt = float(pos['positionAmt'])
        if amt == 0:
            continue
        side = 'SELL' if amt > 0 else 'BUY'
        print(f"⚠️ Закрытие позиции {symbol}: {side} {abs(amt)}")
        try:
            exchange.create_order(
                symbol=symbol,
                type='MARKET',
                side=side,
                amount=abs(amt),
                params={'reduceOnly': True}
            )
        except Exception as e:
            print(f"Ошибка закрытия {symbol}: {e}")

def run_kill_switch():
    while True:
        pnl = fetch_total_unrealized_pnl()
        print(f"\n🔍 Текущий общий PnL: {pnl:.2f} USDT")
        if pnl <= MAX_DRAWDOWN_USD:
            print(f"🛑 Убыток превышен ({pnl:.2f} USDT) — запускаем Kill Switch!")
            close_all_positions()
            break
        time.sleep(CHECK_INTERVAL)

if __name__ == "__main__":
    run_kill_switch()

#ордер

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

📌XGBoost Classifier Strategy – Обучение модели на индикаторах (сигналы Buy/Sell)🧑‍💻

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

Используем технические индикаторы как признаки (features) и обучаем XGBoost-классификатор, который:

- анализирует исторические данные,

- учится предсказывать сигналы: покупка / продажа / держать,

- может применяться в алготрейдинге и сигнальных ботах.

import ccxt
import pandas as pd
import numpy as np
import talib
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Параметры
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK = 500

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

# Технические индикаторы
df["rsi"] = talib.RSI(df["close"], timeperiod=14)
df["macd"], _, _ = talib.MACD(df["close"])
df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)
df["mom"] = talib.MOM(df["close"], timeperiod=10)
df.dropna(inplace=True)

# Целевая переменная: рост цены через N свечей
N = 3
df["future_return"] = df["close"].shift(-N) - df["close"]
df["target"] = (df["future_return"] > 0).astype(int)
df.dropna(inplace=True)

# Обучающая выборка
features = ["rsi", "macd", "atr", "mom"]
X = df[features]
y = df["target"]

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

# Модель
model = xgb.XGBClassifier(n_estimators=100, max_depth=3, use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train)

# Прогноз
preds = model.predict(X_test)
print(classification_report(y_test, preds))

# Последний сигнал
last_features = X.iloc[[-1]]
signal = model.predict(last_features)[0]
print(f"\n📈 Текущий сигнал: {'BUY' if signal == 1 else 'SELL'}")

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

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

📌Order Layering Strategy – Построение лестницы лимитных ордеров🧑‍💻

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

Order Layering — это тактика размещения нескольких лимитных ордеров на разных ценовых уровнях, чтобы:

- войти в позицию частями по более выгодной цене,

- разместить ликвидность в стакане,

- избежать проскальзывания,

- или обмануть других участников рынка

import ccxt
import time

# Настройки
exchange = ccxt.binance({
    # 'apiKey': 'YOUR_API_KEY',
    # 'secret': 'YOUR_SECRET',
    'enableRateLimit': True
})

PAIR = "BTC/USDT"
TOTAL_AMOUNT = 0.1  # BTC
LAYERS = 5
START_PRICE = 79500
PRICE_STEP = 100
ORDER_SIDE = 'buy'  # или 'sell'

def build_order_ladder():
    amount_per_order = TOTAL_AMOUNT / LAYERS

    for i in range(LAYERS):
        price = START_PRICE - i * PRICE_STEP if ORDER_SIDE == 'buy' else START_PRICE + i * PRICE_STEP
        print(f"📥 Размещение лимитного ордера: {ORDER_SIDE.upper()} {amount_per_order:.4f} BTC по {price:.2f}")
        
        # exchange.create_limit_buy_order(PAIR, amount_per_order, price)  # активировать при торговле

        time.sleep(1)  # небольшая пауза между ордерами

if __name__ == "__main__":
    build_order_ladder()

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

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

📌Front-Run Detector – Обнаружение активности, похожей на фронтран🧑‍💻

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

Фронтран (front-running) — это стратегия, при которой участник рынка опережает крупную сделку, зная о ней заранее (или замечая её подготовку в стакане/мемпуле).

Front-Run Detector пытается выявить:

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

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

- Быстрые серии ордеров перед резким движением

Примеры признаков фронтрана:🛠️

1. Резкое добавление крупной заявки на Bid/Ask, которая исчезает перед импульсом

2. Секундные всплески мелких ордеров в одну сторону → затем резкое движение

3. Появление ликвидности "приманки", за которой идёт настоящая крупная сделка

4. Разгон объёма до того, как произойдёт прорыв уровня

import ccxt
import time

# Настройки
exchange = ccxt.binance()
PAIR = "BTC/USDT"
DEPTH = 20
LARGE_ORDER_SIZE = 30  # BTC
INTERVAL = 2  # секунд

prev_bids, prev_asks = {}, {}

def fetch_order_book():
    ob = exchange.fetch_order_book(PAIR, limit=DEPTH)
    bids = {price: size for price, size in ob['bids']}
    asks = {price: size for price, size in ob['asks']}
    return bids, asks

def detect_front_run(prev, current, side):
    suspicious = []
    for price in current:
        if current[price] >= LARGE_ORDER_SIZE:
            if price not in prev or prev[price] < LARGE_ORDER_SIZE:
                suspicious.append(price)
    return suspicious

def run_detector():
    global prev_bids, prev_asks

    while True:
        bids, asks = fetch_order_book()

        new_large_bids = detect_front_run(prev_bids, bids, "BID")
        new_large_asks = detect_front_run(prev_asks, asks, "ASK")

        for price in new_large_bids:
            print(f"⚠️ Появился крупный BID: {price} → возможный фронтран")
        for price in new_large_asks:
            print(f"⚠️ Появился крупный ASK: {price} → возможный фронтран")

        prev_bids, prev_asks = bids, asks
        time.sleep(INTERVAL)

if __name__ == "__main__":
    run_detector()

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

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

📌Clustering Market Regimes – Определение рыночных фаз через кластеризацию🧑‍💻

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

Вместо ручного деления рынка на "тренд" и "флэт", используется кластеризация (машинное обучение без учителя), чтобы:

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

- Присвоить каждому участку графика кластер (режим),

- Переключать стратегию в зависимости от текущего кластера рынка.

Признаки, используемые для кластеризации:🛠️

- Возвратность (доходность за окно)

- Волатильность (ATR / std)

- Объём

- Размеры свечей

- Трендовые индикаторы (RSI, MACD, ADX)

import ccxt
import pandas as pd
import numpy as np
import talib
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Параметры
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK = 500
N_CLUSTERS = 3

# Получение данных
exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["returns"] = df["close"].pct_change()
df["volatility"] = df["returns"].rolling(window=10).std()
df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)
df["rsi"] = talib.RSI(df["close"], timeperiod=14)
df.dropna(inplace=True)

# Фичи для кластеризации
features = df[["returns", "volatility", "atr", "rsi"]]
features = features.fillna(0)

# Кластеризация
kmeans = KMeans(n_clusters=N_CLUSTERS, random_state=42)
df["regime"] = kmeans.fit_predict(features)

# Визуализация
plt.figure(figsize=(12, 5))
for regime in range(N_CLUSTERS):
    plt.plot(df[df["regime"] == regime]["close"], label=f"Regime {regime}")
plt.legend()
plt.title("Режимы рынка, определённые кластеризацией")
plt.xlabel("Время")
plt.ylabel("Цена")
plt.show()

#индикатор

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

📌Reversal Pattern Detector – Обнаружение разворотных паттернов🧑‍💻

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

Разворотные паттерны графического анализа указывают на возможное окончание текущего тренда и начало.

Пример на Python – Обнаружение двойного дна👇👇👇

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

# Настройки
exchange = ccxt.binance()
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK = 300
DISTANCE = 5  # интервал между минимумами

def fetch_data():
    ohlcv = exchange.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    df["ts"] = pd.to_datetime(df["ts"], unit="ms")
    return df

def detect_double_bottom(df):
    lows = df["low"].values
    idx_min = argrelextrema(lows, np.less, order=DISTANCE)[0]

    for i in range(len(idx_min) - 1):
        i1, i2 = idx_min[i], idx_min[i+1]
        price1, price2 = lows[i1], lows[i2]
        diff = abs(price1 - price2)

        # Условия: два минимума на ~одном уровне, между ними — максимум
        if diff / price1 < 0.01:
            middle_idx = (i1 + i2) // 2
            middle_high = df["high"].iloc[middle_idx]
            if middle_high > price1 * 1.02:
                print(f"\n✅ Найден паттерн Двойное Дно на свечах {i1} и {i2}")
                print(f"Минимумы: {price1:.2f}, {price2:.2f} | Потенциал пробоя: {middle_high:.2f}")

if __name__ == "__main__":
    df = fetch_data()
    detect_double_bottom(df)

#патерн

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

📌Dark Pool Activity Scanner – Анализ скрытых транзакций на рынке🧑‍💻

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

Dark Pools — это внебиржевые площадки, где крупные участники совершают сделки без раскрытия информации в стакане.
Хотя в криптовалютах нет формальных "даркпулов", их активность можно оценивать косвенно — через:

Признаки скрытых транзакций:🛠️

1. Внезапные крупные объёмы без изменений в стакане

2. Необъяснимые всплески объёма на слабом движении цены

3. Резкие движения цены без предварительного давления в стакане

4. Скачки крупных сделок (анализ ленты сделок / trade stream)

5. Необычные дисбалансы в дельте объёмов

6. Низкая волатильность + высокий объём = поглощение ликвидности

import ccxt
import pandas as pd
import time

# Настройки
exchange = ccxt.binance()
PAIR = "BTC/USDT"
TIMEFRAME = "1m"
VOLUME_MULTIPLIER = 3.0  # объем выше среднего в X раз
PRICE_CHANGE_THRESHOLD = 0.1  # % за минуту
LOOKBACK = 100

def fetch_data():
    ohlcv = exchange.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    df["ts"] = pd.to_datetime(df["ts"], unit="ms")
    df["return"] = df["close"].pct_change() * 100
    return df.dropna()

def detect_dark_pool_behavior(df):
    avg_volume = df["volume"][:-1].mean()
    last = df.iloc[-1]
    volume_spike = last["volume"] > avg_volume * VOLUME_MULTIPLIER
    low_price_move = abs(last["return"]) < PRICE_CHANGE_THRESHOLD

    print(f"\nВремя: {last['ts']} | Объём: {last['volume']:.2f} | Δ%: {last['return']:.2f}")

    if volume_spike and low_price_move:
        print("⚠️ Подозрение на скрытую крупную сделку (высокий объём без движения цены)")

if __name__ == "__main__":
    while True:
        df = fetch_data()
        detect_dark_pool_behavior(df)
        time.sleep(60)

#индикатор

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

📌Genetic Strategy Generator – Генерация торговых стратегий с помощью генетических алгоритмов🧑‍💻

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

- Генетический алгоритм (GA) используется для поиска оптимальных правил входа/выхода в рынок, основываясь на:

- технических индикаторах,

- логических операторах (AND, OR, >, <),

- целевой функции (например, максимизация доходности или Sharpe Ratio).

Такой подход имитирует естественный отбор:
→ лучшие "особи" (стратегии) выживают и улучшаются из поколения в поколение.

Что делает Genetic Strategy Generator:🛠️

1. Генерирует случайные стратегии из набора правил и индикаторов

2. Применяет их к историческим данным

3. Оценивает результат (fitness) — прибыль, стабильность, drawdown

4. Оставляет лучшие стратегии и мутирует их

5. Повторяет до достижения лучших результатов

Пример Python-структуры: стратегия на базе RSI и MACD

import numpy as np
import pandas as pd
import talib
import ccxt
import random

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

def fetch_data():
    ohlcv = exchange.fetch_ohlcv(PAIR, timeframe=TIMEFRAME, limit=LOOKBACK)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    df["rsi"] = talib.RSI(df["close"], timeperiod=14)
    macd, signal, _ = talib.MACD(df["close"])
    df["macd"] = macd
    df["signal"] = signal
    df.dropna(inplace=True)
    return df

# Генерация случайной стратегии
def generate_strategy():
    return {
        "rsi_threshold": random.randint(20, 80),
        "macd_relation": random.choice([">", "<"])
    }

# Применение стратегии
def apply_strategy(df, strategy):
    signals = []
    for i in range(len(df)):
        rsi = df["rsi"].iloc[i]
        macd = df["macd"].iloc[i]
        signal = df["signal"].iloc[i]

        cond1 = rsi < strategy["rsi_threshold"]
        cond2 = (macd > signal) if strategy["macd_relation"] == ">" else (macd < signal)

        if cond1 and cond2:
            signals.append(1)  # BUY
        else:
            signals.append(0)  # NO ACTION
    df["signal"] = signals
    return df

# Подсчёт PnL (доходности)
def evaluate(df):
    df["returns"] = df["close"].pct_change().fillna(0)
    df["strategy_return"] = df["returns"] * df["signal"].shift(1)
    total_return = (df["strategy_return"] + 1).prod() - 1
    return total_return

# Генетический цикл
def genetic_optimizer(pop_size=20, generations=10):
    population = [generate_strategy() for _ in range(pop_size)]
    df = fetch_data()

    for gen in range(generations):
        scores = []
        for strat in population:
            test_df = apply_strategy(df.copy(), strat)
            score = evaluate(test_df)
            scores.append((score, strat))

        scores.sort(reverse=True, key=lambda x: x[0])
        print(f"🧬 Поколение {gen}: лучшая доходность = {scores[0][0]:.2%}")

        # Отбор + мутация
        best = [x[1] for x in scores[:pop_size // 2]]
        new_generation = []
        for s in best:
            new = s.copy()
            if random.random() < 0.5:
                new["rsi_threshold"] += random.randint(-5, 5)
                new["rsi_threshold"] = max(10, min(new["rsi_threshold"], 90))
            if random.random() < 0.3:
                new["macd_relation"] = ">" if s["macd_relation"] == "<" else "<"
            new_generation.append(new)
        population = best + new_generation

    return scores[0][1]

if __name__ == "__main__":
    best_strategy = genetic_optimizer()
    print(f"\n🏆 Лучшая стратегия: {best_strategy}")

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

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

📌Reinforcement Learning Agent – Стратегия на основе самообучающегося агента🧑‍💻

Суть подхода:🚀

Reinforcement Learning (RL) — обучение агента принимать оптимальные решения путём взаимодействия со средой и получения награды за результат.
В контексте трейдинга агент:

Наблюдает состояние рынка (индикаторы, цены, объёмы),

Принимает действия: купить, продать, удерживать,

Получает награду (например, PnL),

Обучается максимизировать общую прибыль.

import gym
import numpy as np
import pandas as pd
import ccxt
import ta
from gym import spaces
from stable_baselines3 import PPO

# Создаём кастомную среду
class TradingEnv(gym.Env):
    def __init__(self, df):
        super().__init__()
        self.df = df.reset_index(drop=True)
        self.current_step = 0
        self.start_balance = 10000
        self.balance = self.start_balance
        self.position = 0  # 0: нет, 1: лонг
        self.entry_price = 0

        self.action_space = spaces.Discrete(3)  # hold, buy, sell
        self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape=(4,), dtype=np.float32)

    def _get_obs(self):
        row = self.df.iloc[self.current_step]
        return np.array([row['close'], row['rsi'], row['macd'], self.position], dtype=np.float32)

    def _get_reward(self, price):
        if self.position == 1:
            return price - self.entry_price
        return 0

    def step(self, action):
        done = False
        price = self.df.iloc[self.current_step]['close']

        reward = 0
        if action == 1 and self.position == 0:  # BUY
            self.position = 1
            self.entry_price = price
        elif action == 2 and self.position == 1:  # SELL
            reward = price - self.entry_price
            self.balance += reward
            self.position = 0

        self.current_step += 1
        if self.current_step >= len(self.df) - 1:
            done = True

        obs = self._get_obs()
        return obs, reward, done, {}

    def reset(self):
        self.current_step = 0
        self.balance = self.start_balance
        self.position = 0
        self.entry_price = 0
        return self._get_obs()

# Подготовка данных
def fetch_data():
    exchange = ccxt.binance()
    ohlcv = exchange.fetch_ohlcv("BTC/USDT", timeframe="1h", limit=500)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    df["rsi"] = ta.momentum.RSIIndicator(df["close"]).rsi()
    macd = ta.trend.MACD(df["close"])
    df["macd"] = macd.macd()
    return df.dropna()

# Обучение агента
df = fetch_data()
env = TradingEnv(df)
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=10000)

# Тестирование агента
obs = env.reset()
done = False
while not done:
    action, _ = model.predict(obs)
    obs, reward, done, _ = env.step(action)
    print(f"Action: {action}, Reward: {reward:.2f}")

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

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

📌AutoFeature Engine for Strategies – Автоматическая генерация признаков для оптимизации торговых правил🧑‍💻

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

AutoFeature Engine — это компонент, который:

- создаёт множество технических признаков (features) на основе OHLCV-данных,

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

- используется в связке с машинным обучением или генерацией правил (в том числе для XGBoost, RL, GA и т.д.).

Типы автоматически создаваемых признаков:🛠️

1. Технические индикаторы: RSI, MACD, ATR, Bollinger, EMA и др.

2. Статистические признаки: скользящее среднее, std, z-score, rate of change

3. Комбинированные признаки: кроссы, отклонения, сигнальные уровни

4. Целевые признаки (label): будущий доход / направление движения

import ccxt
import pandas as pd
import ta  # pip install ta
import numpy as np

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

# Генерация признаков
def generate_features(df):
    df["return_1h"] = df["close"].pct_change()
    df["sma_10"] = ta.trend.sma_indicator(df["close"], window=10)
    df["sma_50"] = ta.trend.sma_indicator(df["close"], window=50)
    df["rsi"] = ta.momentum.RSIIndicator(df["close"]).rsi()
    macd = ta.trend.MACD(df["close"])
    df["macd"] = macd.macd()
    df["macd_signal"] = macd.macd_signal()
    df["bollinger_h"] = ta.volatility.BollingerBands(df["close"]).bollinger_hband()
    df["bollinger_l"] = ta.volatility.BollingerBands(df["close"]).bollinger_lband()
    df["atr"] = ta.volatility.AverageTrueRange(df["high"], df["low"], df["close"]).average_true_range()
    df["roc"] = ta.momentum.ROCIndicator(df["close"]).roc()
    df["zscore"] = (df["close"] - df["close"].rolling(20).mean()) / df["close"].rolling(20).std()
    return df.dropna()

# Целевая переменная (напр. рост цены через 3 часа)
def generate_target(df, forward=3):
    df["future_return"] = df["close"].shift(-forward) / df["close"] - 1
    df["target"] = (df["future_return"] > 0).astype(int)  # 1 - BUY, 0 - SELL
    return df.dropna()

# Основной процесс
df = generate_features(df)
df = generate_target(df)

print("✅ Сгенерированы признаки:")
print(df[["return_1h", "sma_10", "sma_50", "rsi", "macd", "zscore", "target"]].tail())

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

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