ML Bot for Crypto Trading: Strategy Development with LightGBM and LSTM

import pandas as pd import numpy as np from ta import trend, momentum, volatility class FeatureEngineer: def generate_features(self, df: pd.DataFrame) -> pd.DataFrame: """df contains: open, high, low, close, volume""" features = pd.DataFrame(index=df.index) # === Technical indicators === # Trend features['ema_9'] = trend.EMAIndicator(df.close, 9).ema_indicator() features['ema_21'] = trend.EMAIndicator(df.close, 21).ema_indicator() features['macd'] = trend.MACD(df.close).macd() features['macd_signal'] = trend.MACD(df.close).macd_signal() features['adx'] = trend.ADXIndicator(df.high, df.low, df.close).adx() # Momentum features['rsi_14'] = momentum.RSIIndicator(df.close, 14).rsi() features['stoch_k'] = momentum.StochasticOscillator(df.high, df.low, df.close).stoch() features['cci'] = momentum.CCIIndicator(df.high, df.low, df.close).cci() # Volatility features['atr'] = volatility.AverageTrueRange(df.high, df.low, df.close).average_true_range() features['bb_width'] = ( volatility.BollingerBands(df.close).bollinger_hband() - volatility.BollingerBands(df.close).bollinger_lband() ) / df.close # === Price-derived features === # Returns at different horizons for period in [1, 3, 6, 12, 24]: features[f'return_{period}h'] = df.close.pct_change(period) # Distance from moving averages (normalized) for period in [20, 50, 200]: ma = df.close.rolling(period).mean() features[f'dist_ma_{period}'] = (df.close - ma) / ma # === Volume features === features['volume_ratio'] = df.volume / df.volume.rolling(20).mean() features['obv'] = (np.sign(df.close.diff()) * df.volume).cumsum() features['obv_ratio'] = features['obv'] / features['obv'].rolling(20).mean() # === Market microstructure === features['high_low_range'] = (df.high - df.low) / df.close features['close_position'] = (df.close - df.low) / (df.high - df.low + 1e-10) return features.dropna() 

An important nuance: all indicators that "look forward" in time must be shifted by 1 step back. The current candle's signal uses the previous candle's data—this eliminates lookahead.

Which model to choose: LightGBM or LSTM?

For structured data, the best baseline is Gradient Boosting (LightGBM). It trains quickly, is well interpretable via feature importance, and is robust to outliers. The LightGBM documentation recommends it for time series with many features.

import lightgbm as lgb from sklearn.model_selection import TimeSeriesSplit class DirectionPredictor: def __init__(self, horizon: int = 4): self.horizon = horizon # predict direction after N candles self.model = None self.feature_cols = None def prepare_target(self, df: pd.DataFrame) -> pd.Series: """Target: 1 if price rises by X% over horizon, else 0""" future_return = df.close.shift(-self.horizon) / df.close - 1 threshold = 0.005 # 0.5% return (future_return > threshold).astype(int) def train(self, features: pd.DataFrame, prices: pd.DataFrame): y = self.prepare_target(prices) # Align indices common_idx = features.index.intersection(y.dropna().index) X = features.loc[common_idx] y = y.loc[common_idx] # Walk-forward validation: train on first 70%, test on last 30% split = int(len(X) * 0.7) X_train, X_test = X.iloc[:split], X.iloc[split:] y_train, y_test = y.iloc[:split], y.iloc[split:] params = { 'objective': 'binary', 'metric': 'auc', 'learning_rate': 0.05, 'num_leaves': 31, 'min_data_in_leaf': 50, 'feature_fraction': 0.8, 'bagging_fraction': 0.8, 'bagging_freq': 5, 'verbose': -1 } train_data = lgb.Dataset(X_train, label=y_train) val_data = lgb.Dataset(X_test, label=y_test) self.model = lgb.train( params, train_data, valid_sets=[val_data], num_boost_round=500, callbacks=[lgb.early_stopping(50), lgb.log_evaluation(100)] ) self.feature_cols = X.columns.tolist() def predict_proba(self, features: pd.DataFrame) -> float: X = features[self.feature_cols].iloc[-1:] return float(self.model.predict(X)[0]) 

LSTM for sequence modeling—if the hypothesis is that the sequence of events matters, LSTM can be more effective, but on daily and hourly data LightGBM often performs similarly.

import torch import torch.nn as nn class PriceLSTM(nn.Module): def __init__(self, input_size: int, hidden_size: int = 64, num_layers: int = 2): super().__init__() self.lstm = nn.LSTM( input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, dropout=0.2 ) self.classifier = nn.Sequential( nn.Linear(hidden_size, 32), nn.ReLU(), nn.Dropout(0.3), nn.Linear(32, 1), nn.Sigmoid() ) def forward(self, x: torch.Tensor) -> torch.Tensor: lstm_out, _ = self.lstm(x) last_output = lstm_out[:, -1, :] return self.classifier(last_output) 

Walk-forward validation

Standard train/test split is unacceptable for time series. We use a rolling window:

def walk_forward_backtest( model_class, features: pd.DataFrame, prices: pd.DataFrame, train_window: int = 365, test_window: int = 30, step: int = 30 ) -> pd.DataFrame: results = [] n = len(features) for start in range(0, n - train_window - test_window, step): train_end = start + train_window test_end = train_end + test_window X_train = features.iloc[start:train_end] X_test = features.iloc[train_end:test_end] p_train = prices.iloc[start:train_end] p_test = prices.iloc[train_end:test_end] model = model_class() model.train(X_train, p_train) predictions = [model.predict_proba(X_test.iloc[:i+1]) for i in range(len(X_test))] period_results = simulate_trading(predictions, p_test) results.append(period_results) return pd.concat(results) 

How to integrate an ML model into a trading bot

class MLTradingBot: def __init__(self, model: DirectionPredictor, threshold: float = 0.65): self.model = model self.threshold = threshold async def on_candle(self, candle: Candle): features = self.feature_eng.update(candle) prob_up = self.model.predict_proba(features) if prob_up > self.threshold and not self.has_position(): await self.open_long() elif prob_up < (1 - self.threshold) and not self.has_position(): await self.open_short() elif self.has_position(): current_side = self.position.side if current_side == 'long' and prob_up < 0.5: await self.close_position("model_signal_weak") 

A threshold of 0.65 means "only enter when the model is 65%+ confident." This reduces the number of trades but improves their quality. Additionally, we implement model drift monitoring and automatic retraining every 30–90 days.

ML bot development stages

What's included in development

• Formation of trading hypothesis and validation on historical data
• Development of feature pipeline (technical indicators, on-chain metrics, order book imbalance)
• Baseline model and walk-forward validation including transaction costs (0.1-0.2% per trade)
• Selection and training of final model (LightGBM, LSTM, transformers)
• Exchange integration via WebSocket/REST API (Binance, Bybit, OKX, etc.)
• Model drift monitoring and automatic retraining every 30-90 days
• Architecture documentation and team training
• 3-month warranty support

Common mistakes in ML trading

An ML bot is not a set-and-forget solution. Markets drift, models degrade. It requires live model metric monitoring and periodic retraining. But with the right approach, an ML strategy provides a real edge.

Want a consultation on ML bot architecture for your strategy? Contact us—we'll evaluate your task and propose the optimal solution. Order the development of an adaptive strategy with a technical implementation guarantee.

Useful links

• walk-forward validation — time series validation method
• LightGBM documentation — official library documentation