Script

Script with a web panel for predicting the price of ETH

Описание скрипта ultra_scalper_pro_

Loading...

fixed.py

ultra_scalper_pro_

Loading...

fixed.py

— это комплексный скрипт для автоматического скальпинга криптовалюты Ethereum (ETH) на бирже Binance. Он использует машинное обучение (нейронные сети на основе трансформеров), технические индикаторы (RSI, MACD, Bollinger Bands) и анализ ордербука (стакана заказов) для прогнозирования краткосрочного движения цены ETH/USDT и генерации сигналов на покупку или продажу. скрипт включает в себя веб-интерфейс на Streamlit для визуального отслеживания текущей цены, прогнозов, сигналов и состояния ордербука.
Как работает скрипт

1. Получение данных:
   
   • Цена: Текущая цена ETH/USDT получается через REST API Binance.
   • Исторические данные (Klines): Скрипт скачивает исторические данные (цены, объемы) для трех таймфреймов: 1 час (1h), 5 минут (5m), 1 минута (1m).
   • Ордербук: Состояние стакана заказов (цены и объемы заявок на покупку и продажу) обновляется в реальном времени через WebSocket-соединение с Binance.
2. Вычисление индикаторов:
   
   • Для каждого таймфрейма (1h, 5m, 1m) вычисляются следующие технические индикаторы: RSI, MACD (линия MACD и сигнал), линии Боллинджера (верхняя, нижняя, положение цены относительно полос), скользящее среднее объема, соотношение текущего объема к среднему.
   • Эти индикаторы, вместе с ценой и объемом, формируют набор признаков (features), который используется для обучения и предсказания.
3. Обучение и предсказание с помощью нейронной сети (Transformer):
   
   • Для каждого таймфрейма создается и обучается отдельная нейронная сеть на основе архитектуры Transformer.
   • Сеть обучается на последовательностях исторических данных (TIMESTEP_H, TIMESTEP_5M, TIMESTEP_1M — количество предыдущих свечей, используемых для анализа).
   • Сеть анализирует последние TIMESTEP_X свечей (вместе с индикаторами) и пытается предсказать цену следующей свечи.
4. Анализ ордербука:
   
   • Рассчитывается общий дисбаланс между объемами заявок на покупку и продажу в стакане (imbalance). Это может указывать на потенциальное давление продавцов или покупателей.
5. Генерация сигналов:
   
   • Скрипт сравнивает текущую цену с прогнозами сети для каждого таймфрейма.
   • Если прогнозируемое изменение цены превышает заданный порог (например, 0.3% для 1 мин, 0.8% для 5 мин, 1.5% для 1 ч), генерируется сигнал.
   • Сигнал (BUY/SELL) с указанием таймфрейма, силы сигнала и прогнозируемой цены отправляется в Telegram-чат (через Telegram Bot API) и сопровождается звуковым уведомлением.
6. Веб-интерфейс (Streamlit):
   
   • При запуске скрипта запускается веб-сервер Streamlit.
   • Веб-панель отображает:
     
     • Текущую цену ETH.
     • Прогнозы цены и процентное изменение для 1 мин, 5 мин и 1 ч.
     • Простые графики, показывающие разницу между текущей ценой и прогнозом для каждого таймфрейма.
     • Топ 10 цен и объемов из ордербука (покупки/продажи).
     • Текущий дисбаланс ордербука.

Как запустить скрипт

1. Установите зависимости:Убедитесь, что у вас установлен Python 3.8+ и pip. Затем установите все необходимые библиотеки:
2. pip install requests pandas numpy scikit-learn tensorflow ta python-telegram-bot websocket-client streamlit matplotlib pygame scipy

   Python

   pip install requests pandas numpy scikit-learn tensorflow ta python-telegram-bot websocket-client streamlit matplotlib pygame scipy

1. Настройте Telegram (необязательно, но рекомендуется):
   
   • Создайте Telegram-бота через @BotFather и получите TELEGRAM_TOKEN.
   • Найдите свой TELEGRAM_CHAT_ID (например, отправьте сообщение боту, а затем запросите
     

     Loading...

     api.telegram.org
     <TOKEN>/getUpdates).
   • Замените значения TELEGRAM_TOKEN и TELEGRAM_CHAT_ID в начале скрипта на свои.
2. Запустите скрипт:Выполните команду в терминале:
3. Откройте веб-интерфейс:После запуска откройте браузер и перейдите по адресу
   

   Loading...

   localhost
   .
   
   • Нажмите кнопку "ЗАПУСТИТЬ СКАЛЬПИНГ" на веб-странице, чтобы начать работу алгоритма.
   • Теперь вы можете наблюдать за текущими данными, прогнозами и ордербуком в реальном времени на веб-панели. Сигналы будут приходить в Telegram и сопровождаться звуками.

# ultra_scalper_pro_fixed.py
import requests
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense, Dropout, LayerNormalization
from ta.momentum import RSIIndicator
from ta.trend import MACD
from ta.volatility import BollingerBands
from telegram import Bot
import asyncio
import websocket
import json
import threading
from datetime import datetime
import streamlit as st
import matplotlib.pyplot as plt
import time
import os
import pygame
from scipy.io.wavfile import write

# === ОТКЛЮЧАЕМ **** ===
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
tf.get_logger().setLevel('ERROR')

# === НАСТРОЙКИ ===
TELEGRAM_TOKEN = "1457088547:AAGt3I5ua04qTXsSJsIgPIpoYjhqC7gNflc"
TELEGRAM_CHAT_ID = "1305348616"
PAST_HOURS = 168
TIMESTEP_H = 48
TIMESTEP_5M = 36
TIMESTEP_1M = 60
ORDERBOOK_DEPTH = 500
bot = Bot(token=TELEGRAM_TOKEN)

# === ЗВУК ===
pygame.mixer.init()
BUY_SOUND = "buy_alert.wav"
SELL_SOUND = "sell_alert.wav"

def create_sound():
if not os.path.exists(BUY_SOUND):
fs = 44100
t = np.linspace(0, 0.5, int(fs*0.5))
wave = np.sin(2*np.pi*1000*t) * np.exp(-t*5)
write(BUY_SOUND, fs, (wave * 32767).astype(np.int16))
if not os.path.exists(SELL_SOUND):
fs = 44100
t = np.linspace(0, 0.5, int(fs*0.5))
wave = np.sin(2*np.pi*600*t) * np.exp(-t*5)
write(SELL_SOUND, fs, (wave * 32767).astype(np.int16))

create_sound()

# === ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
orderbook = {"bids": [], "asks": []}
lock = threading.Lock()
last_signal_time = 0
model_h = model_5m = model_1m = None
scaler_h = scaler_5m = scaler_1m = None
features_h = features_5m = features_1m = None
last_price = 3161.0 # ТЕКУЩАЯ ЦЕНА ИЗ ТВОЕГО СКРИНА
pred_1h = pred_5m = pred_1m = last_price
last_imbalance = 0.0

# === ПОЛУЧИТЬ ТЕКУЩУЮ ЦЕНУ ===
def get_current_price():
try:
url = "https://api.binance.com/api/v3/ticker/price"
resp = requests.get(url, params={'symbol': 'ETHUSDT'}, timeout=5).json()
return float(resp['price'])
except:
return last_price

# === REST ОРДЕРБУК ===
def fetch_orderbook_rest():
try:
url = "https://api.binance.com/api/v3/depth"
params = {'symbol': 'ETHUSDT', 'limit': ORDERBOOK_DEPTH}
resp = requests.get(url, params=params, timeout=10).json()
if 'bids' in resp and 'asks' in resp:
with lock:
orderbook['bids'] = [(float(p), float(q)) for p, q in resp['bids']]
orderbook['asks'] = [(float(p), float(q)) for p, q in resp['asks']]
return True
except:
pass
return False

# === WebSocket ===
def on_message(ws, message):
try:
data = json.loads(message)
if 'bids' in data and 'asks' in data:
with lock:
orderbook['bids'] = [(float(p), float(q)) for p, q in data['bids'][:ORDERBOOK_DEPTH]]
orderbook['asks'] = [(float(p), float(q)) for p, q in data['asks'][:ORDERBOOK_DEPTH]]
except:
pass

def on_open(ws):
ws.send(json.dumps({
"method": "SUBSCRIBE",
"params": [f"ethusdt@depth{ORDERBOOK_DEPTH}@100ms"],
"id": 1
}))

# === KLINE ===
def fetch_binance(interval, limit):
try:
url = "https://api.binance.com/api/v3/klines"
params = {'symbol': 'ETHUSDT', 'interval': interval, 'limit': limit}
resp = requests.get(url, params=params, timeout=10).json()
df = pd.DataFrame(resp, columns=[
'open_time', 'open', 'high', 'low', 'close', 'volume',
'close_time', 'quote_volume', 'trades', 'taker_buy_base', 'taker_buy_quote', 'ignore'
])
df['price'] = pd.to_numeric(df['close'])
df['volume'] = pd.to_numeric(df['volume'])
return df[['price', 'volume']].dropna()
except:
return pd.DataFrame()

# === ИНДИКАТОРЫ ===
def add_indicators(df):
if len(df) < 50:
return df
df = df.copy()
df['rsi'] = RSIIndicator(df['price'], window=14).rsi()
macd = MACD(df['price'])
df['macd'] = macd.macd()
df['macd_signal'] = macd.macd_signal()
bb = BollingerBands(df['price'])
df['bb_upper'] = bb.bollinger_hband()
df['bb_lower'] = bb.bollinger_lband()
df['bb_position'] = (df['price'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'] + 1e-8)
df['volume_ma'] = df['volume'].rolling(20).mean()
df['volume_ratio'] = df['volume'] / (df['volume_ma'] + 1e-8)
return df.dropna()

# === TRANSFORMER ===
def build_transformer(input_shape):
inputs = Input(shape=input_shape)
x = tf.keras.layers.MultiHeadAttention(num_heads=4, key_dim=input_shape[-1])(inputs, inputs)
x = Dropout(0.2)(x)
x = LayerNormalization()(inputs + x)
ffn = Dense(128, activation='relu')(x)
ffn = Dense(input_shape[-1])(ffn)
x = LayerNormalization()(x + ffn)
x = Dense(64, activation='relu')(x)
x = Dense(1)(x)
model = Model(inputs, x)
model.compile(optimizer='adam', loss='mse')
return model

# === ОРДЕРБУК ===
def get_orderbook():
with lock:
bids = orderbook['bids'][:20]
asks = orderbook['asks'][:20]
if len(bids) < 5:
fetch_orderbook_rest()
with lock:
bids = orderbook['bids'][:20]
asks = orderbook['asks'][:20]
total_bid = sum(q for p, q in orderbook['bids'])
total_ask = sum(q for p, q in orderbook['asks'])
imbalance = (total_bid - total_ask) / (total_bid + total_ask + 1e-8) if (total_bid + total_ask) > 0 else 0
return bids, asks, imbalance

# === ЗВУК ===
def play_sound(action):
try:
sound_file = BUY_SOUND if action == "BUY" else SELL_SOUND
pygame.mixer.music.load(sound_file)
pygame.mixer.music.play()
except:
pass

# === АЛЕРТ ===
async def send_alert(change, timeframe, curr, pred):
global last_signal_time
if time.time() - last_signal_time < 60:
return
action = "BUY" if change > 0 else "SELL"
strength = "СВЕРХСИЛЬНЫЙ" if abs(change) > 0.03 else "СИЛЬНЫЙ"

msg = (f"**{action} ETH — {strength} СИГНАЛ ({timeframe})**\n"
f"AI: `{change:+.2%}` → `${curr:.0f}` → **`${pred:.0f}`**\n"
f"Время: `{datetime.now().strftime('%H:%M:%S')}`")

try:
await bot.send_message(chat_id=TELEGRAM_CHAT_ID, text=msg, parse_mode='Markdown')
play_sound(action)
last_signal_time = time.time()
except:
pass

# === ОСНОВНОЙ ЦИКЛ ===
async def run_ai():
global model_h, model_5m, model_1m, scaler_h, scaler_5m, scaler_1m
global features_h, features_5m, features_1m, last_price, pred_1h, pred_5m, pred_1m, last_imbalance

# WebSocket
ws = websocket.WebSocketApp("wss://stream.binance.com:9443/ws", on_open=on_open, on_message=on_message)
wst = threading.Thread(target=ws.run_forever, daemon=True)
wst.start()
fetch_orderbook_rest()
await asyncio.sleep(3)

while True:
try:
current_price = get_current_price()
if current_price > 0:
last_price = current_price

# 1. ЧАСОВОЙ
df_h = fetch_binance('1h', PAST_HOURS)
if len(df_h) >= TIMESTEP_H + 1:
df_h = add_indicators(df_h)
if not df_h.empty and features_h is None:
features_h = df_h.columns.tolist()
scaler_h = MinMaxScaler()
model_h = build_transformer((TIMESTEP_H, len(features_h)))
if not df_h.empty:
scaled = scaler_h.fit_transform(df_h.values)
X = np.array([scaled[i:i+TIMESTEP_H] for i in range(len(scaled) - TIMESTEP_H)])
y = scaled[TIMESTEP_H:, features_h.index('price')]
if len(X) > 0 and np.random.rand() < 0.1:
model_h.fit(X, y, epochs=1, batch_size=8, verbose=0)
last_seq = scaled[-TIMESTEP_H:].reshape(1, TIMESTEP_H, len(features_h))
pred_scaled = model_h.predict(last_seq, verbose=0)[0, 0]
dummy = np.zeros((1, len(features_h)))
dummy[0, features_h.index('price')] = pred_scaled
pred_1h = scaler_h.inverse_transform(dummy)[0, features_h.index('price')]
else:
pred_1h = last_price * 1.02

# 2. 5-МИНУТНЫЙ
df_5m = fetch_binance('5m', TIMESTEP_5M + 10)
if len(df_5m) >= TIMESTEP_5M + 1:
df_5m = add_indicators(df_5m)
if not df_5m.empty and features_5m is None:
features_5m = df_5m.columns.tolist()
scaler_5m = MinMaxScaler()
model_5m = build_transformer((TIMESTEP_5M, len(features_5m)))
if not df_5m.empty:
scaled = scaler_5m.fit_transform(df_5m.values)
last_seq = scaled[-TIMESTEP_5M:].reshape(1, TIMESTEP_5M, len(features_5m))
pred_scaled = model_5m.predict(last_seq, verbose=0)[0, 0]
dummy = np.zeros((1, len(features_5m)))
dummy[0, features_5m.index('price')] = pred_scaled
pred_5m = scaler_5m.inverse_transform(dummy)[0, features_5m.index('price')]
else:
pred_5m = last_price * 1.003

# 3. 1-МИНУТНЫЙ
df_1m = fetch_binance('1m', TIMESTEP_1M + 5)
if len(df_1m) >= TIMESTEP_1M + 1:
df_1m = add_indicators(df_1m)
if not df_1m.empty and features_1m is None:
features_1m = df_1m.columns.tolist()
scaler_1m = MinMaxScaler()
model_1m = build_transformer((TIMESTEP_1M, len(features_1m)))
if not df_1m.empty:
scaled = scaler_1m.fit_transform(df_1m.values)
last_seq = scaled[-TIMESTEP_1M:].reshape(1, TIMESTEP_1M, len(features_1m))
pred_scaled = model_1m.predict(last_seq, verbose=0)[0, 0]
dummy = np.zeros((1, len(features_1m)))
dummy[0, features_1m.index('price')] = pred_scaled
pred_1m = scaler_1m.inverse_transform(dummy)[0, features_1m.index('price')]
else:
pred_1m = last_price * 1.001

# ИМБАЛАНС
_, _, imbalance = get_orderbook()
last_imbalance = imbalance

# СИГНАЛЫ
change_1h = (pred_1h - last_price) / last_price if last_price > 0 else 0
change_5m = (pred_5m - last_price) / last_price if last_price > 0 else 0
change_1m = (pred_1m - last_price) / last_price if last_price > 0 else 0

if abs(change_1m) > 0.003:
await send_alert(change_1m, "1 МИН", last_price, pred_1m)
if abs(change_5m) > 0.008:
await send_alert(change_5m, "5 МИН", last_price, pred_5m)
if abs(change_1h) > 0.015:
await send_alert(change_1h, "1 ЧАС", last_price, pred_1h)

await asyncio.sleep(30)
except:
await asyncio.sleep(30)

# === WEB-ПАНЕЛЬ ===
def main():
st.set_page_config(page_title="ULTRA SCALPER PRO", layout="wide")
st.title("ULTRA SCALPER PRO — СКАЛЬПИНГ + 1М/5М/1Ч")

if 'running' not in st.session_state:
st.session_state.running = False

if not st.session_state.running:
if st.button("ЗАПУСТИТЬ СКАЛЬПИНГ"):
st.session_state.running = True
loop = asyncio.new_event_loop()
threading.Thread(target=loop.run_forever, daemon=True).start()
asyncio.run_coroutine_threadsafe(run_ai(), loop)
st.success("СКАЛЬПИНГ ЗАПУЩЕН! Цена обновляется...")

if st.session_state.running:
placeholder = st.empty()
chart_placeholder = st.empty()
orderbook_placeholder = st.empty()

while st.session_state.running:
with placeholder.container():
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Цена ETH", f"${last_price:.0f}")
with col2:
change = (pred_1m - last_price) / last_price if last_price > 0 else 0
st.metric("1 МИН", f"{change:+.2%}", f"${pred_1m:.0f}")
with col3:
change = (pred_5m - last_price) / last_price if last_price > 0 else 0
st.metric("5 МИН", f"{change:+.2%}", f"${pred_5m:.0f}")
with col4:
change = (pred_1h - last_price) / last_price if last_price > 0 else 0
st.metric("1 ЧАС", f"{change:+.2%}", f"${pred_1h:.0f}")

with chart_placeholder.container():
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 4))
for ax, target, label in [
(ax1, pred_1m, "1 МИН"),
(ax2, pred_5m, "5 МИН"),
(ax3, pred_1h, "1 ЧАС")
]:
ax.plot([0, 1], [last_price, target], 'go--', linewidth=2)
ax.set_title(label, fontweight='bold')
ax.set_xticks([0, 1])
ax.set_xticklabels(['Сейчас', 'Прогноз'])
ax.set_ylim(last_price * 0.95, last_price * 1.05)
ax.grid(True, alpha=0.3)
st.pyplot(fig)
plt.close(fig)

with orderbook_placeholder.container():
bids, asks, imbalance = get_orderbook()
st.write(f"### Ордербук | Имбаланс: `{imbalance:+.1%}`")
colb, cola = st.columns(2)
with colb:
st.write("**Покупки**")
for p, q in bids[:10]:
st.write(f"`${p:.1f}` → `{q:.1f}` ETH")
with cola:
st.write("**Продажи**")
for p, q in asks[:10]:
st.write(f"`${p:.1f}` → `{q:.1f}` ETH")

time.sleep(5)

if __name__ == "__main__":
main()

Python

# ultra_scalper_pro_fixed.py

import requests

import pandas as pd

import numpy as np

from sklearn.preprocessing import MinMaxScaler

import tensorflow as tf

from tensorflow.keras.models import Model

from tensorflow.keras.layers import Input, Dense, Dropout, LayerNormalization

from ta.momentum import RSIIndicator

from ta.trend import MACD

from ta.volatility import BollingerBands

from telegram import Bot

import asyncio

import websocket

import json

import threading

from datetime import datetime

import streamlit as st

import matplotlib.pyplot as plt

import time

import os

import pygame

from scipy.io.wavfile import write



# === ОТКЛЮЧАЕМ **** ===

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

tf.get_logger().setLevel('ERROR')



# === НАСТРОЙКИ ===

TELEGRAM_TOKEN = "1457088547:AAGt3I5ua04qTXsSJsIgPIpoYjhqC7gNflc"

TELEGRAM_CHAT_ID = "1305348616"

PAST_HOURS = 168

TIMESTEP_H = 48

TIMESTEP_5M = 36

TIMESTEP_1M = 60

ORDERBOOK_DEPTH = 500

bot = Bot(token=TELEGRAM_TOKEN)



# === ЗВУК ===

pygame.mixer.init()

BUY_SOUND = "buy_alert.wav"

SELL_SOUND = "sell_alert.wav"



def create_sound():

    if not os.path.exists(BUY_SOUND):

        fs = 44100

        t = np.linspace(0, 0.5, int(fs*0.5))

        wave = np.sin(2*np.pi*1000*t) * np.exp(-t*5)

        write(BUY_SOUND, fs, (wave * 32767).astype(np.int16))

    if not os.path.exists(SELL_SOUND):

        fs = 44100

        t = np.linspace(0, 0.5, int(fs*0.5))

        wave = np.sin(2*np.pi*600*t) * np.exp(-t*5)

        write(SELL_SOUND, fs, (wave * 32767).astype(np.int16))



create_sound()



# === ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ===

orderbook = {"bids": [], "asks": []}

lock = threading.Lock()

last_signal_time = 0

model_h = model_5m = model_1m = None

scaler_h = scaler_5m = scaler_1m = None

features_h = features_5m = features_1m = None

last_price = 3161.0  # ТЕКУЩАЯ ЦЕНА ИЗ ТВОЕГО СКРИНА

pred_1h = pred_5m = pred_1m = last_price

last_imbalance = 0.0



# === ПОЛУЧИТЬ ТЕКУЩУЮ ЦЕНУ ===

def get_current_price():

    try:

        url = "https://api.binance.com/api/v3/ticker/price"

        resp = requests.get(url, params={'symbol': 'ETHUSDT'}, timeout=5).json()

        return float(resp['price'])

    except:

        return last_price



# === REST ОРДЕРБУК ===

def fetch_orderbook_rest():

    try:

        url = "https://api.binance.com/api/v3/depth"

        params = {'symbol': 'ETHUSDT', 'limit': ORDERBOOK_DEPTH}

        resp = requests.get(url, params=params, timeout=10).json()

        if 'bids' in resp and 'asks' in resp:

            with lock:

                orderbook['bids'] = [(float(p), float(q)) for p, q in resp['bids']]

                orderbook['asks'] = [(float(p), float(q)) for p, q in resp['asks']]

            return True

    except:

        pass

    return False



# === WebSocket ===

def on_message(ws, message):

    try:

        data = json.loads(message)

        if 'bids' in data and 'asks' in data:

            with lock:

                orderbook['bids'] = [(float(p), float(q)) for p, q in data['bids'][:ORDERBOOK_DEPTH]]

                orderbook['asks'] = [(float(p), float(q)) for p, q in data['asks'][:ORDERBOOK_DEPTH]]

    except:

        pass



def on_open(ws):

    ws.send(json.dumps({

        "method": "SUBSCRIBE",

        "params": [f"ethusdt@depth{ORDERBOOK_DEPTH}@100ms"],

        "id": 1

    }))



# === KLINE ===

def fetch_binance(interval, limit):

    try:

        url = "https://api.binance.com/api/v3/klines"

        params = {'symbol': 'ETHUSDT', 'interval': interval, 'limit': limit}

        resp = requests.get(url, params=params, timeout=10).json()

        df = pd.DataFrame(resp, columns=[

            'open_time', 'open', 'high', 'low', 'close', 'volume',

            'close_time', 'quote_volume', 'trades', 'taker_buy_base', 'taker_buy_quote', 'ignore'

        ])

        df['price'] = pd.to_numeric(df['close'])

        df['volume'] = pd.to_numeric(df['volume'])

        return df[['price', 'volume']].dropna()

    except:

        return pd.DataFrame()



# === ИНДИКАТОРЫ ===

def add_indicators(df):

    if len(df) < 50:

        return df

    df = df.copy()

    df['rsi'] = RSIIndicator(df['price'], window=14).rsi()

    macd = MACD(df['price'])

    df['macd'] = macd.macd()

    df['macd_signal'] = macd.macd_signal()

    bb = BollingerBands(df['price'])

    df['bb_upper'] = bb.bollinger_hband()

    df['bb_lower'] = bb.bollinger_lband()

    df['bb_position'] = (df['price'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'] + 1e-8)

    df['volume_ma'] = df['volume'].rolling(20).mean()

    df['volume_ratio'] = df['volume'] / (df['volume_ma'] + 1e-8)

    return df.dropna()



# === TRANSFORMER ===

def build_transformer(input_shape):

    inputs = Input(shape=input_shape)

    x = tf.keras.layers.MultiHeadAttention(num_heads=4, key_dim=input_shape[-1])(inputs, inputs)

    x = Dropout(0.2)(x)

    x = LayerNormalization()(inputs + x)

    ffn = Dense(128, activation='relu')(x)

    ffn = Dense(input_shape[-1])(ffn)

    x = LayerNormalization()(x + ffn)

    x = Dense(64, activation='relu')(x)

    x = Dense(1)(x)

    model = Model(inputs, x)

    model.compile(optimizer='adam', loss='mse')

    return model



# === ОРДЕРБУК ===

def get_orderbook():

    with lock:

        bids = orderbook['bids'][:20]

        asks = orderbook['asks'][:20]

    if len(bids) < 5:

        fetch_orderbook_rest()

        with lock:

            bids = orderbook['bids'][:20]

            asks = orderbook['asks'][:20]

    total_bid = sum(q for p, q in orderbook['bids'])

    total_ask = sum(q for p, q in orderbook['asks'])

    imbalance = (total_bid - total_ask) / (total_bid + total_ask + 1e-8) if (total_bid + total_ask) > 0 else 0

    return bids, asks, imbalance



# === ЗВУК ===

def play_sound(action):

    try:

        sound_file = BUY_SOUND if action == "BUY" else SELL_SOUND

        pygame.mixer.music.load(sound_file)

        pygame.mixer.music.play()

    except:

        pass



# === АЛЕРТ ===

async def send_alert(change, timeframe, curr, pred):

    global last_signal_time

    if time.time() - last_signal_time < 60:

        return

    action = "BUY" if change > 0 else "SELL"

    strength = "СВЕРХСИЛЬНЫЙ" if abs(change) > 0.03 else "СИЛЬНЫЙ"

    

    msg = (f"**{action} ETH — {strength} СИГНАЛ ({timeframe})**\n"

           f"AI: `{change:+.2%}` → `${curr:.0f}` → **`${pred:.0f}`**\n"

           f"Время: `{datetime.now().strftime('%H:%M:%S')}`")

    

    try:

        await bot.send_message(chat_id=TELEGRAM_CHAT_ID, text=msg, parse_mode='Markdown')

        play_sound(action)

        last_signal_time = time.time()

    except:

        pass



# === ОСНОВНОЙ ЦИКЛ ===

async def run_ai():

    global model_h, model_5m, model_1m, scaler_h, scaler_5m, scaler_1m

    global features_h, features_5m, features_1m, last_price, pred_1h, pred_5m, pred_1m, last_imbalance



    # WebSocket

    ws = websocket.WebSocketApp("wss://stream.binance.com:9443/ws", on_open=on_open, on_message=on_message)

    wst = threading.Thread(target=ws.run_forever, daemon=True)

    wst.start()

    fetch_orderbook_rest()

    await asyncio.sleep(3)



    while True:

        try:

            current_price = get_current_price()

            if current_price > 0:

                last_price = current_price



            # 1. ЧАСОВОЙ

            df_h = fetch_binance('1h', PAST_HOURS)

            if len(df_h) >= TIMESTEP_H + 1:

                df_h = add_indicators(df_h)

                if not df_h.empty and features_h is None:

                    features_h = df_h.columns.tolist()

                    scaler_h = MinMaxScaler()

                    model_h = build_transformer((TIMESTEP_H, len(features_h)))

                if not df_h.empty:

                    scaled = scaler_h.fit_transform(df_h.values)

                    X = np.array([scaled[i:i+TIMESTEP_H] for i in range(len(scaled) - TIMESTEP_H)])

                    y = scaled[TIMESTEP_H:, features_h.index('price')]

                    if len(X) > 0 and np.random.rand() < 0.1:

                        model_h.fit(X, y, epochs=1, batch_size=8, verbose=0)

                    last_seq = scaled[-TIMESTEP_H:].reshape(1, TIMESTEP_H, len(features_h))

                    pred_scaled = model_h.predict(last_seq, verbose=0)[0, 0]

                    dummy = np.zeros((1, len(features_h)))

                    dummy[0, features_h.index('price')] = pred_scaled

                    pred_1h = scaler_h.inverse_transform(dummy)[0, features_h.index('price')]

                else:

                    pred_1h = last_price * 1.02



            # 2. 5-МИНУТНЫЙ

            df_5m = fetch_binance('5m', TIMESTEP_5M + 10)

            if len(df_5m) >= TIMESTEP_5M + 1:

                df_5m = add_indicators(df_5m)

                if not df_5m.empty and features_5m is None:

                    features_5m = df_5m.columns.tolist()

                    scaler_5m = MinMaxScaler()

                    model_5m = build_transformer((TIMESTEP_5M, len(features_5m)))

                if not df_5m.empty:

                    scaled = scaler_5m.fit_transform(df_5m.values)

                    last_seq = scaled[-TIMESTEP_5M:].reshape(1, TIMESTEP_5M, len(features_5m))

                    pred_scaled = model_5m.predict(last_seq, verbose=0)[0, 0]

                    dummy = np.zeros((1, len(features_5m)))

                    dummy[0, features_5m.index('price')] = pred_scaled

                    pred_5m = scaler_5m.inverse_transform(dummy)[0, features_5m.index('price')]

                else:

                    pred_5m = last_price * 1.003



            # 3. 1-МИНУТНЫЙ

            df_1m = fetch_binance('1m', TIMESTEP_1M + 5)

            if len(df_1m) >= TIMESTEP_1M + 1:

                df_1m = add_indicators(df_1m)

                if not df_1m.empty and features_1m is None:

                    features_1m = df_1m.columns.tolist()

                    scaler_1m = MinMaxScaler()

                    model_1m = build_transformer((TIMESTEP_1M, len(features_1m)))

                if not df_1m.empty:

                    scaled = scaler_1m.fit_transform(df_1m.values)

                    last_seq = scaled[-TIMESTEP_1M:].reshape(1, TIMESTEP_1M, len(features_1m))

                    pred_scaled = model_1m.predict(last_seq, verbose=0)[0, 0]

                    dummy = np.zeros((1, len(features_1m)))

                    dummy[0, features_1m.index('price')] = pred_scaled

                    pred_1m = scaler_1m.inverse_transform(dummy)[0, features_1m.index('price')]

                else:

                    pred_1m = last_price * 1.001



            # ИМБАЛАНС

            _, _, imbalance = get_orderbook()

            last_imbalance = imbalance



            # СИГНАЛЫ

            change_1h = (pred_1h - last_price) / last_price if last_price > 0 else 0

            change_5m = (pred_5m - last_price) / last_price if last_price > 0 else 0

            change_1m = (pred_1m - last_price) / last_price if last_price > 0 else 0



            if abs(change_1m) > 0.003:

                await send_alert(change_1m, "1 МИН", last_price, pred_1m)

            if abs(change_5m) > 0.008:

                await send_alert(change_5m, "5 МИН", last_price, pred_5m)

            if abs(change_1h) > 0.015:

                await send_alert(change_1h, "1 ЧАС", last_price, pred_1h)



            await asyncio.sleep(30)

        except:

            await asyncio.sleep(30)



# === WEB-ПАНЕЛЬ ===

def main():

    st.set_page_config(page_title="ULTRA SCALPER PRO", layout="wide")

    st.title("ULTRA SCALPER PRO — СКАЛЬПИНГ + 1М/5М/1Ч")



    if 'running' not in st.session_state:

        st.session_state.running = False



    if not st.session_state.running:

        if st.button("ЗАПУСТИТЬ СКАЛЬПИНГ"):

            st.session_state.running = True

            loop = asyncio.new_event_loop()

            threading.Thread(target=loop.run_forever, daemon=True).start()

            asyncio.run_coroutine_threadsafe(run_ai(), loop)

            st.success("СКАЛЬПИНГ ЗАПУЩЕН! Цена обновляется...")



    if st.session_state.running:

        placeholder = st.empty()

        chart_placeholder = st.empty()

        orderbook_placeholder = st.empty()



        while st.session_state.running:

            with placeholder.container():

                col1, col2, col3, col4 = st.columns(4)

                with col1:

                    st.metric("Цена ETH", f"${last_price:.0f}")

                with col2:

                    change = (pred_1m - last_price) / last_price if last_price > 0 else 0

                    st.metric("1 МИН", f"{change:+.2%}", f"${pred_1m:.0f}")

                with col3:

                    change = (pred_5m - last_price) / last_price if last_price > 0 else 0

                    st.metric("5 МИН", f"{change:+.2%}", f"${pred_5m:.0f}")

                with col4:

                    change = (pred_1h - last_price) / last_price if last_price > 0 else 0

                    st.metric("1 ЧАС", f"{change:+.2%}", f"${pred_1h:.0f}")



            with chart_placeholder.container():

                fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 4))

                for ax, target, label in [

                    (ax1, pred_1m, "1 МИН"),

                    (ax2, pred_5m, "5 МИН"),

                    (ax3, pred_1h, "1 ЧАС")

                ]:

                    ax.plot([0, 1], [last_price, target], 'go--', linewidth=2)

                    ax.set_title(label, fontweight='bold')

                    ax.set_xticks([0, 1])

                    ax.set_xticklabels(['Сейчас', 'Прогноз'])

                    ax.set_ylim(last_price * 0.95, last_price * 1.05)

                    ax.grid(True, alpha=0.3)

                st.pyplot(fig)

                plt.close(fig)



            with orderbook_placeholder.container():

                bids, asks, imbalance = get_orderbook()

                st.write(f"### Ордербук | Имбаланс: `{imbalance:+.1%}`")

                colb, cola = st.columns(2)

                with colb:

                    st.write("**Покупки**")

                    for p, q in bids[:10]:

                        st.write(f"`${p:.1f}` → `{q:.1f}` ETH")

                with cola:

                    st.write("**Продажи**")

                    for p, q in asks[:10]:

                        st.write(f"`${p:.1f}` → `{q:.1f}` ETH")



            time.sleep(5)



if __name__ == "__main__":

    main()

Для запуска скрипта используйте комманду

python -m streamlit run Ваше названия скрипта

Python

python -m streamlit run Ваше названия скрипта