привет!
import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix

# Загрузка и подготовка данных
df = pd.read_csv('BTCUSDT_M5_220301_241210.csv')
df.timestamp = pd.to_datetime(df.timestamp)
df.columns = ['date', 'time', 'timestamp', 'open', 'high', 'low', 'close', 'volume']
df.set_index('timestamp', inplace=True)
df = df.iloc[-200_000:]

window1 = 5
window2 = 50
df['price_avg'] = (df['open'] + df['close']) / 2
df['sma1'] = df['price_avg'].rolling(window=window1).mean()
df['upper_band1'] = df['high'].rolling(window=window1).mean() + (2 * df['high'].rolling(window=window1).std())
df['lower_band1'] = df['low'].rolling(window=window1).mean() - (2 * df['low'].rolling(window=window1).std())
df['sma2'] = df['price_avg'].rolling(window=window2).mean()
df['upper_band2'] = df['high'].rolling(window=window2).mean() + (2 * df['high'].rolling(window=window2).std())
df['lower_band2'] = df['low'].rolling(window=window2).mean() - (2 * df['low'].rolling(window=window2).std())

# Создание лагов
lags = 15
for lag in range(1, lags + 1):
    df[f'body_avg_lag_{lag}'] = (df['price_avg'] / df['price_avg'].shift(lag)) - 1
    df[f'sma1_lag_{lag}'] = (df['sma1'] / df['sma1'].shift(lag)) - 1
    df[f'sma2_lag_{lag}'] = (df['sma2'] / df['sma2'].shift(lag)) - 1
    df[f'upper_band1_lag_{lag}'] = (df['upper_band1'] / df['upper_band1'].shift(lag)) - 1
    df[f'upper_band2_lag_{lag}'] = (df['upper_band2'] / df['upper_band2'].shift(lag)) - 1
    df[f'lower_band1_lag_{lag}'] = (df['lower_band1'] / df['lower_band1'].shift(lag)) - 1
    df[f'lower_band2_lag_{lag}'] = (df['lower_band2'] / df['lower_band2'].shift(lag)) - 1

# Определяем переменные
lag_columns = [col for col in df.columns if 'lag_' in col]
Q = 5

# Категоризация лагов
for col in lag_columns:
    df[f'{col}_cat'] = pd.qcut(df[col], q=Q, labels=False) / Q
cat_columns = [col for col in df.columns if 'cat' in col]
# Определение целей
shift_lag = window1 * 1
shift_lag_sma2 = window2 * 1
df['target'] = (df['sma1'].shift(-shift_lag) > df['sma1']).astype(int)
df['target_sma2'] = (df['sma2'].shift(-shift_lag_sma2) > df['sma2']).astype(int)
y_column = 'target'
y_column_sma2 = 'target_sma2'

# Удаляем строки с NaN в любой из целевых переменных
df = df.dropna()

# Разделяем данные на тренировочную и тестовую выборки
test_size = 0.1
n_test = int(len(df) * test_size)
df_train = df.iloc[:-n_test]
df_test = df.iloc[-n_test:]

# Определяем X и y для первой модели
X_train_lags = df_train[lag_columns]
y_train = df_train[y_column]

X_test_lags = df_test[lag_columns]
y_test = df_test[y_column]

X_train_cats = df_train[cat_columns]
X_test_cats = df_test[cat_columns]

# Классификаторы
log_reg_lags = LogisticRegression()
log_reg_cats = LogisticRegression()
log_reg_lags_sma2 = LogisticRegression()
log_reg_cats_sma2 = LogisticRegression()

# Обучение на лаговых данных для sma1
log_reg_lags.fit(X_train_lags, y_train)

# Обучение на лаговых данных для sma2
y_train_sma2 = df_train[y_column_sma2]  # Получаем метки для второй целевой переменной
log_reg_lags_sma2.fit(X_train_lags, y_train_sma2)

# Обучение на категориальных данных для sma1
log_reg_cats.fit(X_train_cats, y_train)

# Обучение на категориальных данных для sma2
log_reg_cats_sma2.fit(X_train_cats, y_train_sma2)

# Прогнозируем на тестовой выборке и получаем вероятности
probs_lags = log_reg_lags.predict_proba(X_test_lags)[:, 1]  # Вероятности положительного класса для sma1
probs_cats = log_reg_cats.predict_proba(X_test_cats)[:, 1]  # Вероятности для категориальных данных для sma1

# Предсказания для второй модели
probs_lags_sma2 = log_reg_lags_sma2.predict_proba(X_test_lags)[:, 1]  # Вероятности положительного класса для sma2
probs_cats_sma2 = log_reg_cats_sma2.predict_proba(X_test_cats)[:, 1]  # Вероятности для категориальных данных для sma2

# Блендинг предсказаний
final_probs = (probs_lags + probs_cats) / 2  # усредняем вероятности для первой модели
final_probs_sma2 = (probs_lags_sma2 + probs_cats_sma2) / 2  # усредняем для второй модели

# Торговый алгоритм
position = 0  # 0 - нет позиции, 1 - открытая позиция
trades = []
profit = 0.0

# Проходим по предсказаниям
for i in range(len(final_probs)):
    # Условия на открытие позиции
    if position == 0 and final_probs[i] > 0.55 and final_probs_sma2[i] > 0.55:
        position = 1
        entry_price = df_test['close'].iloc[i]  # Запоминаем цену входа
        trades.append(('BUY', df_test.index[i], entry_price))

    # Условия на закрытие позиции
    if position == 1 and (final_probs[i] <= 0.55 or final_probs_sma2[i] <= 0.55):
        position = 0
        exit_price = df_test['close'].iloc[i]  # Запоминаем цену выхода
        trades.append(('SELL', df_test.index[i], exit_price))
        # Подсчет прибыли по сделке
        profit += exit_price - entry_price if exit_price > entry_price else 0

# Вывод результатов
print("Сделки:")
for trade in trades:
    print(trade)

print(f"Общая прибыль: {profit:.2f}")

# Оценка результатов для первой модели
final_predictions = (final_probs > 0.55).astype(int)  # Преобразуем в бинарные предсказания при пороге 0.55
print("\nОценка на первой модели:")
print(classification_report(y_test, final_predictions))
print(confusion_matrix(y_test, final_predictions))

давай сюда добавим запись динамики депозита после закрытия каждой сделки, для анализа