I'll help you organize this crypto prediction system into a more modular structure with separate files. Here's the improved version: # تنظیمات اولیه BINANCE_API_KEY = "your_api_key" # جایگزین کنید BINANCE_SECRET = "your_api_secret" # جایگزین کنید CRYPTOPANIC_API_KEY = "your_api_key" # جایگزین کنید SYMBOLS = ['BTCUSDT', 'ETHUSDT'] # ارزهای مورد تحلیل MODEL_UPDATE_INTERVAL = 3600 # به‌روزرسانی مدل هر 1 ساعت DATA_FETCH_INTERVAL = 60 # جمع‌آوری داده هر 1 دقیقه import sqlite3 from datetime import datetime import logging def init_db(): try: conn = sqlite3.connect('crypto_signals.db') c = conn.cursor() c.execute('''CREATE TABLE IF NOT EXISTS market_data ( id INTEGER PRIMARY KEY AUTOINCREMENT, symbol TEXT, price REAL, volume REAL, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)''') c.execute('''CREATE TABLE IF NOT EXISTS sentiment_data ( id INTEGER PRIMARY KEY AUTOINCREMENT, source TEXT, score REAL, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)''') c.execute('''CREATE TABLE IF NOT EXISTS predictions ( id INTEGER PRIMARY KEY AUTOINCREMENT, symbol TEXT, actual_price REAL, prophet_pred REAL, lstm_pred REAL, ensemble_pred REAL, signal INTEGER, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)''') c.execute('''CREATE TABLE IF NOT EXISTS alerts ( id INTEGER PRIMARY KEY AUTOINCREMENT, type TEXT, message TEXT, severity INTEGER, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)''') conn.commit() conn.close() logging.info("پایگاه داده با موفقیت راه‌اندازی شد") except Exception as e: logging.error(f"خطا در راه‌اندازی پایگاه داده: {str(e)}") raise def save_market_data(data): try: conn = sqlite3.connect('crypto_signals.db') cursor = conn.cursor() cursor.execute( "INSERT INTO market_data (symbol, price, volume, timestamp) VALUES (?, ?, ?, ?)", (data['symbol'], data['price'], data['volume'], datetime.utcnow()) ) conn.commit() conn.close() except Exception as e: logging.error(f"خطا در ذخیره داده بازار: {str(e)}") def save_sentiment(score): try: conn = sqlite3.connect('crypto_signals.db') cursor = conn.cursor() cursor.execute( "INSERT INTO sentiment_data (source, score, timestamp) VALUES (?, ?, ?)", ('CryptoPanic', score, datetime.utcnow()) ) conn.commit() conn.close() except Exception as e: logging.error(f"خطا در ذخیره احساسات: {str(e)}") def log_alert(message, alert_type, severity=1): try: conn = sqlite3.connect('crypto_signals.db') cursor = conn.cursor() cursor.execute( "INSERT INTO alerts (type, message, severity, timestamp) VALUES (?, ?, ?, ?)", (alert_type, message, severity, datetime.utcnow()) ) conn.commit() conn.close() logging.warning(f"هشدار: {message}") except Exception as e: logging.error(f"خطا در ثبت هشدار: {str(e)}") import numpy as np import pandas as pd import requests from binance.client import Client from transformers import pipeline from datetime import datetime, timedelta from config import * from database import log_alert, save_market_data, save_sentiment class DataCollector: def __init__(self): self.binance_client = Client(BINANCE_API_KEY, BINANCE_SECRET) self.sentiment_analyzer = pipeline( "sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english" ) def fetch_binance_data(self, symbol): try: ticker = self.binance_client.get_symbol_ticker(symbol=symbol) klines = self.binance_client.get_historical_klines( symbol, Client.KLINE_INTERVAL_1HOUR, "1 hour ago UTC" ) return { 'price': float(ticker['price']), 'volume': float(klines[0][5]), 'symbol': symbol } except Exception as e: log_alert(f"خطا در دریافت داده از بایننس: {str(e)}", "API Error", 3) return None def fetch_news_sentiment(self): try: url = f"https://cryptopanic.com/api/v1/posts/?auth_token={CRYPTOPANIC_API_KEY}¤cies=BTC,ETH" response = requests.get(url, timeout=15).json() scores = [] for news in response['results'][:10]: result = self.sentiment_analyzer(news['title'])[0] score = result['score'] if result['label'] == 'POSITIVE' else 1 - result['score'] scores.append(score) return np.mean(scores) if scores else 0.5 except Exception as e: log_alert(f"خطا در تحلیل احساسات: {str(e)}", "API Error", 2) return 0.5 def get_historical_data(self, symbol, days=30): try: end_date = datetime.utcnow() start_date = end_date - timedelta(days=days) klines = self.binance_client.get_historical_klines( symbol, Client.KLINE_INTERVAL_1HOUR, start_date.strftime("%d %b %Y %H:%M:%S"), end_date.strftime("%d %b %Y %H:%M:%S") ) data = [{ 'timestamp': pd.to_datetime(k[0], unit='ms'), 'close': float(k[4]), 'volume': float(k[5]) } for k in klines] return pd.DataFrame(data) except Exception as e: log_alert(f"خطا در دریافت داده تاریخی: {str(e)}", "API Error", 3) return pd.DataFrame() import numpy as np import pandas as pd import tensorflow as tf from prophet import Prophet from sklearn.preprocessing import MinMaxScaler from datetime import datetime from data_collector import DataCollector from database import log_alert class PredictionModels: def __init__(self, symbol): self.symbol = symbol self.prophet_model = None self.lstm_model = None self.scaler = MinMaxScaler(feature_range=(0, 1)) self.data_collector = DataCollector() self.load_or_train_models() def load_or_train_models(self): try: self.prophet_model = self.load_prophet_model() self.lstm_model = self.load_lstm_model() if not self.prophet_model or not self.lstm_model: self.train_models() except Exception as e: log_alert(f"خطا در بارگذاری مدل: {str(e)}", "Model Error", 3) self.train_models() def train_models(self): try: historical_data = self.data_collector.get_historical_data(self.symbol, days=60) if historical_data.empty: log_alert("داده تاریخی برای آموزش مدل یافت نشد", "Data Error", 3) return self.train_prophet(historical_data) self.train_lstm(historical_data) self.save_lstm_model() except Exception as e: log_alert(f"خطا در آموزش مدل: {str(e)}", "Model Error", 4) def train_prophet(self, df): try: prophet_df = df[['timestamp', 'close']].rename(columns={'timestamp': 'ds', 'close': 'y'}) self.prophet_model = Prophet(daily_seasonality=True, weekly_seasonality=True) self.prophet_model.fit(prophet_df) except Exception as e: log_alert(f"خطا در آموزش Prophet: {str(e)}", "Model Error", 3) def train_lstm(self, df): try: dataset = df['close'].values.reshape(-1, 1) scaled_data = self.scaler.fit_transform(dataset) look_back = 60 X, y = [], [] for i in range(look_back, len(scaled_data)): X.append(scaled_data[i-look_back:i, 0]) y.append(scaled_data[i, 0]) X, y = np.array(X), np.array(y) X = np.reshape(X, (X.shape[0], X.shape[1], 1)) self.lstm_model = tf.keras.Sequential([ tf.keras.layers.LSTM(64, return_sequences=True, input_shape=(X.shape[1], 1)), tf.keras.layers.Dropout(0.3), tf.keras.layers.LSTM(32), tf.keras.layers.Dense(1) ]) self.lstm_model.compile(optimizer='adam', loss='mse') self.lstm_model.fit(X, y, epochs=20, batch_size=32, verbose=0) except Exception as e: log_alert(f"خطا در آموزش LSTM: {str(e)}", "Model Error", 3) def predict(self, current_price, volume, sentiment): try: future = self.prophet_model.make_future_dataframe(periods=1, freq='H') forecast = self.prophet_model.predict(future) prophet_pred = forecast['yhat'].iloc[-1] conn = sqlite3.connect('crypto_signals.db') query = f"SELECT price FROM market_data WHERE symbol = '{self.symbol}' ORDER BY timestamp DESC LIMIT 60" last_prices = pd.read_sql_query(query, conn)['price'].values conn.close() if len(last_prices) < 60: last_prices = np.pad(last_prices, (60 - len(last_prices), 0), mode='constant', constant_values=current_price) scaled_data = self.scaler.transform(last_prices.reshape(-1, 1)) X_test = np.array([scaled_data[-60:]]) lstm_pred = self.lstm_model.predict(X_test, verbose=0) lstm_pred = self.scaler.inverse_transform(lstm_pred)[0][0] weights = [0.45, 0.45, 0.1] ensemble_pred = (prophet_pred * weights[0] + lstm_pred * weights[1] + (current_price * (1 + (sentiment - 0.5) / 10) * weights[2])) return prophet_pred, lstm_pred, ensemble_pred except Exception as e: log_alert(f"خطا در پیش‌بینی: {str(e)}", "Prediction Error", 3) return current_price, current_price, current_price def save_lstm_model(self): try: self.lstm_model.save(f"lstm_model_{self.symbol}.h5") except Exception as e: log_alert(f"خطا در ذخیره مدل LSTM: {str(e)}", "Model Error", 2) def load_prophet_model(self): return None def load_lstm_model(self): try: return tf.keras.models.load_model(f"lstm_model_{self.symbol}.h5") except: return None class SignalGenerator: @staticmethod def generate_signal(current_price, predictions, sentiment): prophet_pred, lstm_pred, ensemble_pred = predictions prophet_dev = abs(prophet_pred - current_price) / current_price lstm_dev = abs(lstm_pred - current_price) / current_price if ensemble_pred > current_price * 1.03 and sentiment > 0.6: return 2 elif ensemble_pred > current_price * 1.015 and sentiment > 0.5: return 1 elif ensemble_pred < current_price * 0.97 and sentiment < 0.4: return -2 elif ensemble_pred < current_price * 0.985 and sentiment < 0.5: return -1 elif prophet_dev > 0.05 or lstm_dev > 0.05: return 3 else: return 0 import streamlit as st import pandas as pd import sqlite3 import threading from config import SYMBOLS from database import init_db class CryptoDashboard: def __init__(self): st.set_page_config(page_title="سیستم پیش‌بینی ارز دیجیتال", layout="wide", page_icon="📈") def run(self): st.title("📈 سیستم پیش‌بینی بازار ارزهای دیجیتال") tab1, tab2 = st.tabs(["وضعیت بازار", "پیش‌بینی‌ها"]) with tab1: self.show_market_status() with tab2: self.show_predictions() if 'system_started' not in st.session_state: init_db() st.session_state.system_started = True def show_market_status(self): st.subheader("وضعیت لحظه‌ای بازار") try: conn = sqlite3.connect('crypto_signals.db') for symbol in SYMBOLS: df = pd.read_sql( f"SELECT price, timestamp FROM market_data WHERE symbol = '{symbol}' ORDER BY timestamp DESC LIMIT 1", conn ) if not df.empty: st.metric(f"قیمت {symbol}", f"${df['price'].iloc[0]:,.2f}") conn.close() except Exception as e: st.error(f"خطا در نمایش وضعیت بازار: {str(e)}") def show_predictions(self): st.subheader("پیش‌بینی‌ها و سیگنال‌ها") try: conn = sqlite3.connect('crypto_signals.db') for symbol in SYMBOLS: df = pd.read_sql( f"SELECT * FROM predictions WHERE symbol = '{symbol}' ORDER BY timestamp DESC LIMIT 1", conn ) if not df.empty: signal = df['signal'].iloc[0] signal_text = {2: "خرید قوی", 1: "خرید", 0: "نگه‌داری", -1: "فروش", -2: "فروش قوی", 3: "هشدار نوسان"}[signal] st.write(f"{symbol}: {signal_text} - قیمت پیش‌بینی‌شده: ${df['ensemble_pred'].iloc[0]:,.2f}") conn.close() except Exception as e: st.error(f"خطا در نمایش پیش‌بینی‌ها: {str(e)}") import time import logging from config import * from database import init_db, save_prediction, log_alert from data_collector import DataCollector from prediction_models import PredictionModels from signal_generator import SignalGenerator # تنظیم لاگ‌گذاری برای دیباگ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') class CryptoPredictionSystem: def __init__(self): self.data_collector = DataCollector() self.signal_generator = SignalGenerator() self.symbol_models = {symbol: PredictionModels(symbol) for symbol in SYMBOLS} self.last_update = time.time() def start(self): init_db() while True: for symbol in SYMBOLS: self.process_symbol(symbol) time.sleep(DATA_FETCH_INTERVAL) def process_symbol(self, symbol): try: data = self.data_collector.fetch_binance_data(symbol) if not data: return save_market_data(data) sentiment = self.data_collector.fetch_news_sentiment() save_sentiment(sentiment) if time.time() - self.last_update > MODEL_UPDATE_INTERVAL: self.symbol_models[symbol] = PredictionModels(symbol) self.last_update = time.time() logging.info(f"مدل‌ها برای {symbol} به‌روزرسانی شدند") predictions = self.symbol_models[symbol].predict(data['price'], data['volume'], sentiment) signal = self.signal_generator.generate_signal(data['price'], predictions, sentiment) self.save_prediction(symbol, data['price'], predictions, signal) self.check_alerts(symbol, data['price'], sentiment, predictions) except Exception as e: log_alert(f"خطا در پردازش {symbol}: {str(e)}", "Processing Error", 4) def save_prediction(self, symbol, price, predictions, signal): try: prophet_pred, lstm_pred, ensemble_pred = predictions conn = sqlite3.connect('crypto_signals.db') cursor = conn.cursor() cursor.execute( """INSERT INTO predictions (symbol, actual_price, prophet_pred, lstm_pred, ensemble_pred, signal, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?)""", (symbol, price, prophet_pred, lstm_pred, ensemble_pred, signal, datetime.utcnow()) ) conn.commit() conn.close() except Exception as e: log_alert(f"خطا در ذخیره پیش‌بینی: {str(e)}", "Database Error", 2) def check_alerts(self, symbol, price, sentiment, predictions): prophet_pred, lstm_pred, ensemble_pred = predictions price_dev = abs(ensemble_pred - price) / price if price_dev > 0.07: log_alert( f"نوسان شدید پیش‌بینی شده برای {symbol}: {price_dev*100:.2f}%", "Volatility Alert", 2 ) if sentiment < 0.3: log_alert( f"احساسات منفی شدید بازار: {sentiment:.2f}", "Sentiment Alert", 1 ) if __name__ == "__main__": try: dashboard = CryptoDashboard() dashboard.run() except Exception as e: logging.error(f"خطا در اجرای سیستم: {str(e)}")