DEV Community: Stefano viana

How I Built an AI Trading Bot That Predicts Crypto with 84.6% Accuracy (and Open-Sourced It)

Stefano viana — Tue, 05 May 2026 03:25:53 +0000

The Problem

I've been trading crypto for years. Like most traders, I was losing more than I was winning. The market moves too fast for human decision-making — by the time you analyze a chart, the opportunity is gone.

So I did what any developer would do: I tried to automate it.

The First Attempt: Tree-Based Models (54% accuracy)

I started with the classic ML approach:

XGBoost + LightGBM ensemble
72 features (RSI, MACD, Bollinger Bands, volume ratios, etc.)
Walk-forward validation (no data leakage!)

The result? 54% accuracy on out-of-sample data.

That's barely better than a coin flip. And with trading fees eating 0.1% per trade, 54% actually loses money.

I tried everything:

Feature engineering (72 → 100+ features)
Hyperparameter tuning (Optuna, 500 trials)
CatBoost added to the ensemble
Different timeframes (15m, 1h, 4h)

Best I could squeeze out: 60%. Still not enough.

The Breakthrough: LSTM + Attention (84.6%)

Then I rented a GPU on RunPod ($0.44/hour, A40) and tried something different: a Bidirectional LSTM with Multi-Head Attention.

Why LSTM? Because financial markets have temporal dependencies. A candle 30 hours ago affects what happens now. Tree-based models treat each data point independently — they can't learn these sequences.

Architecture

class LSTMPredictor(nn.Module):
def init(self, input_size=19, hidden_size=128, num_layers=2):
self.lstm = nn.LSTM(
input_size, hidden_size, num_layers,
batch_first=True, bidirectional=True, dropout=0.3
)
self.attention = nn.MultiheadAttention(
hidden_size * 2, num_heads=4, batch_first=True
)
self.fc = nn.Sequential(
nn.Linear(hidden_size * 2, 64),
nn.ReLU(), nn.Dropout(0.3),
nn.Linear(64, 2) # UP or DOWN
)

Key decisions:

19 features (not 72 — less is more with LSTM)
64-hour sequences (the model "sees" nearly 3 days of history)
Bidirectional (learns patterns forward and backward)
Multi-head attention (focuses on the most important timesteps)

Training Tricks That Mattered

Data Augmentation # Add noise to prevent overfitting noise = np.random.normal(0, 0.01, features.shape) augmented = features + noise

# Time shift: offset sequences by 1-3 candles
shift = np.random.randint(1, 4)
shifted = features[shift:]

Snapshot Ensemble Instead of using the single best model, I saved the top 3 checkpoints and averaged their predictions. This reduces variance significantly:
Snapshot 1: 84.6%
Snapshot 2: 84.0%
Snapshot 3: 84.1%
Ensemble: 84.6%
Walk-Forward Validation
This is critical. Most "90% accuracy" claims use random train/test splits, which leak future data into training. Walk-forward validation is temporal:

Window 1: Train [Jan-Jun] → Test [Jul-Aug] = 70.3%
Window 2: Train [Mar-Aug] → Test [Sep-Oct] = 72.2%
Window 3: Train [May-Oct] → Test [Nov-Dec] = 85.0%
Window 4: Train [Jul-Dec] → Test [Jan-Feb] = 83.8%
Average: 77.8%

The model genuinely improved on recent data — it's not just memorizing patterns.

The 19 Features

After testing 72+ features, these 19 survived:

┌───────┬───────────────────────────┬───────────────────────────┐
│ # │ Feature │ Why It Works │
├───────┼───────────────────────────┼───────────────────────────┤
│ 1-4 │ Returns (1h, 3h, 5h, 10h) │ Multi-scale momentum │
├───────┼───────────────────────────┼───────────────────────────┤
│ 5-6 │ Volatility (10h, 20h) │ Risk regime detection │
├───────┼───────────────────────────┼───────────────────────────┤
│ 7 │ RSI (14) │ Overbought/oversold │
├───────┼───────────────────────────┼───────────────────────────┤
│ 8 │ MACD │ Trend strength │
├───────┼───────────────────────────┼───────────────────────────┤
│ 9 │ Bollinger Width │ Squeeze detection │
├───────┼───────────────────────────┼───────────────────────────┤
│ 10 │ ATR │ Volatility-adjusted stops │
├───────┼───────────────────────────┼───────────────────────────┤
│ 11 │ Volume Ratio │ Volume breakouts │
├───────┼───────────────────────────┼───────────────────────────┤
│ 12-14 │ EMA distance (9, 21, 50) │ Trend position │
├───────┼───────────────────────────┼───────────────────────────┤
│ 15 │ Candle Body Ratio │ Price action │
├───────┼───────────────────────────┼───────────────────────────┤
│ 16 │ Z-Score │ Mean reversion signal │
├───────┼───────────────────────────┼───────────────────────────┤
│ 17 │ Log Volume │ Normalized volume │
├───────┼───────────────────────────┼───────────────────────────┤
│ 18-19 │ Hour/Day encoding │ Time patterns │
└───────┴───────────────────────────┴───────────────────────────┘

From Model to Live Trading Bot

Having a good model is only half the battle. Turning it into a live trading system required:

Risk Management

ATR-based stop-loss (adapts to volatility)
Partial close at +1.5% and +3% (lock in profits)
Trailing stop (let winners run)
Max 3 concurrent positions (diversification)
Auto-unstuck (graduated exit from losing trades)

Infrastructure

Bybit API with limit orders (0.02% maker fee vs 0.055% taker)
Exchange-side stop-loss (safety net if bot crashes)
PM2 process management with auto-restart
PostgreSQL for full state persistence (survives restarts)
Telegram notifications (public + private channels)

The Blend

The final system uses both models:

60% tree-based (XGBoost + LightGBM) for baseline
40% LSTM for neural boost
Direction-aware blending for SHORT positions

Results

After deploying the LSTM model:

Old model (tree-based only): 54% accuracy, losing money to fees
New model (LSTM blend): 84.6% directional accuracy
The bot now opens positions with 80-95% confidence signals
Pump scanner catches volume spikes (5x+ average) for quick trades

Open Source

The entire codebase is open-source:

GitHub: https://github.com/stefanoviana/deepalpha

You can:

Self-host for free (bring your own API keys)
Use the cloud version at https://deepalphabot.com (free 7-day trial)
Train your own models with the included training scripts

Quick Start

git clone https://github.com/stefanoviana/deepalpha.git
cd deepalpha
pip install -r requirements.txt
cp .env.example .env # Add your Bybit API keys
python deepalpha.py

What I Learned

Walk-forward validation is non-negotiable. My tree models claimed 70.9% with random splits. Real accuracy: 54%.
Sequence models beat tabular models for time series. LSTM sees patterns that XGBoost literally cannot.
Data augmentation prevents overfitting. Adding noise + time shifts doubled the effective training data.
Less features = better. Going from 72 to 19 features improved accuracy by removing noise.
The model is 30% of the work. Risk management, infrastructure, and edge cases are the other 70%.

What's Next

Reinforcement learning for dynamic position sizing
Multi-timeframe fusion (1h + 4h + 1d)
Continuous online learning from live trades
More exchange support (currently Bybit, Binance, OKX, Gate.io)

If you find this useful, a star on https://github.com/stefanoviana/deepalpha would mean a lot. And if you have questions about the architecture, training process, or deployment — drop a comment below.

DeepAlpha is built with Python, PyTorch, ccxt, FastAPI, and PostgreSQL. It's MIT licensed and free to use.

Building an ML Trading System: 70.89% Accuracy with XGBoost

Stefano viana — Wed, 22 Apr 2026 08:02:47 +0000

How I Built a Profitable FreqAI Plugin Using Institutional ML Techniques

Stefano viana — Fri, 17 Apr 2026 11:08:29 +0000

The Problem with Default FreqAI

Standard FreqAI trains a regressor on raw future returns. You predict "price goes up 0.5% in the next 4 hours" and threshold it into buy/sell signals.

This approach has three fatal flaws:

1. Labels don't match real trades. A fixed-horizon return of +0.3% might have hit -2% stop-loss before recovering. You're training on labels that would have liquidated you.

2. Features are never pruned. You throw 200 indicators at LightGBM and hope for the best. Half of them are noise that causes overfitting.

3. No signal quality filter. Every prediction above threshold becomes a trade, even when the model is uncertain.

Fix #1: Triple Barrier Labeling (Regime-Aware)

Instead of "where is the price in 4 hours?", Triple Barrier asks: "which barrier gets hit first — profit target, stop loss, or time expiry?"

This directly aligns labels with actual trade outcomes.

I added a regime twist: the barrier sizes adapt based on the market environment (EMA24 vs EMA96):

Bull market: profit barrier = 1.2σ, stop = 2.0σ (favor longs, tolerate pullbacks)
Bear market: profit = 2.0σ, stop = 1.2σ (favor shorts, tolerate bounces)
Sideways: symmetric (1.5σ / 1.5σ)

This fixed the structural SHORT bias that naive Triple Barrier produces in bull markets.

Fix #2: SHAP Feature Selection

After the first training pass, I compute SHAP values for every feature and keep only those contributing more than 1% of total importance.

Result: 200+ features → 30 that actually predict.

The SHAP selection refreshes every N trainings, so it adapts to regime drift. Features that mattered in the 2022 bear market might not matter in the 2024 bull — and that's fine.

Fix #3: Meta-Labeling

A second LightGBM model learns when the primary model is likely right. It's trained on a binary target: did the primary model's prediction match the actual outcome?

Trades only fire when meta-confidence exceeds a threshold. This dramatically improves precision at the cost of lower recall — exactly what live trading demands.

Fix #4: Purged Walk-Forward CV

Standard k-fold CV for time series is broken. Data from the future leaks into training folds through temporal proximity.

Purged walk-forward CV inserts a gap (purge window) between training and test sets, plus an embargo period. It kills the most insidious lookahead bias.

My model went from "75% accuracy in CV, 52% live" to "63% in CV, 63% live." Honest numbers that hold up.

Fix #5: Sequential Memory Features

LightGBM sees each bar independently — it has no concept of "what happened in the last 24 hours." I added rolling statistics that give it temporal context:

Log-return mean/std/skew over 4/12/24/48 bars
Return z-score (how extreme is this move vs recent history?)
Volatility-of-volatility (regime change signal)
Close and volume lags at 1/3/6/12 bars

This captures ~70% of what an LSTM would learn, at 10% of the complexity.

Fix #6: Dynamic Position Sizing

Not all signals are equal. A 78% confidence prediction should get more capital than a 55% one.

I implemented custom_stake_amount() that scales linearly with the winning-class probability:

P=0.55 → 0.5x default stake
P=0.80 → 1.5x default stake

This concentrates risk on high-confidence signals.

Honest Backtest Results

Tested on BTC/ETH/SOL/BNB/XRP, Binance Futures, 1h bars, 90-day rolling training windows:

Market Regime	Period	Market Change	Bot Profit	Win Rate	Max DD	Sharpe
Bull	Q1 2024	+67.66%	+6.93%	62.5%	2.37%	5.98
Bear (LUNA)	May-Aug 2022	-33.60%	+0.41%	58.0%	7.74%	0.21

These are not cherry-picked. The bear market result is modest, but surviving a -34% crash with positive PnL is the whole point.

What these numbers do NOT guarantee: future performance. Do your own backtesting.

How to Use It

pip install deepalpha-freqai

In your Freqtrade config:

{
  "timeframe": "1h",
  "freqai": {
    "enabled": true,
    "model_type": "DeepAlphaModel",
    "train_period_days": 90,
    "backtest_period_days": 21
  }
}

Copy the example strategy from the repo and run:

freqtrade backtesting --strategy DeepAlphaStrategy \
  --freqaimodel DeepAlphaModel \
  --timerange 20240125-20240325

The plugin handles labels, feature engineering, meta-filtering, and position sizing for you.

What I Learned

Labeling matters more than the model. Switching from fixed-horizon to Triple Barrier was the single biggest improvement.
Fewer features = better features. SHAP pruning from 200 to 30 features improved out-of-sample accuracy by 3%.
Honest CV is non-negotiable. If your backtest accuracy is 20+ points above your live accuracy, your CV is lying.
1h timeframe > 5m. Intraday noise on 5m consistently triggered stops before signals played out. 1h gives Triple Barrier room to breathe.
The edge is in risk management, not prediction. A 63% model with proper sizing and meta-filtering beats a 70% model that trades everything.

The package is MIT licensed and free forever. If you find bugs or want to contribute, the Discord is open.

PyPI: https://pypi.org/project/deepalpha-freqai/
Website: https://deepalphabot.com
Discord: https://discord.gg/P4yX686m

Disclaimer: past performance is not future performance. This is not financial advice. Only trade with money you can afford to lose.

If you found this useful, a star on the repo or a pip install helps more than you think.

DeepAlpha v6.0 — AI Trading Report (2026-04-10)

Stefano viana — Fri, 10 Apr 2026 08:30:18 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-10)

Market

BTC: $71,482 (-0.4%)
ETH: $2,178 (-0.5%)
SOL: $83 (-0.5%)

Performance

Return since launch: +4.3%
Open positions: 3
AI model accuracy: 80.5% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.

DeepAlpha v6.0 — AI Trading Report (2026-04-09)

Stefano viana — Thu, 09 Apr 2026 20:30:35 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-09)

Market

BTC: $72,090 (+1.5%)
ETH: $2,217 (+1.3%)
SOL: $84 (+1.9%)

Performance

Return since launch: +4.9%
Open positions: 0
AI model accuracy: 80.5% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.

DeepAlpha v6.0 — AI Trading Report (2026-04-09)

Stefano viana — Thu, 09 Apr 2026 08:30:29 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-09)

Market

BTC: $70,942 (-0.1%)
ETH: $2,180 (-0.4%)
SOL: $82 (-0.3%)

Performance

Return since launch: -7.5%
Open positions: 3
AI model accuracy: 0.0% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Stefano viana — Wed, 08 Apr 2026 20:30:15 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Market

BTC: $71,336 (-0.8%)
ETH: $2,213 (-1.2%)
SOL: $83 (-2.7%)

Performance

Return since launch: -1.9%
Open positions: 2
AI model accuracy: 0.0% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Stefano viana — Wed, 08 Apr 2026 08:40:32 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Market

BTC: $71,650 (-0.4%)
ETH: $2,253 (+0.6%)
SOL: $84 (-1.2%)

Performance

Return since launch: -0.0%
Open positions: 3
AI model accuracy: 0.0% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Stefano viana — Wed, 08 Apr 2026 08:30:13 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Market

BTC: $71,650 (-0.4%)
ETH: $2,253 (+0.6%)
SOL: $84 (-1.2%)

Performance

Return since launch: -0.0%
Open positions: 3
AI model accuracy: 0.0% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.

DeepAlpha v6.0 - AI-Powered Crypto Trading System (2026-04-08)

Stefano viana — Wed, 08 Apr 2026 06:02:36 +0000

DeepAlpha v6.0 — AI Trading Report (2026-04-08)

Market

BTC: $71,690 (-0.3%)
ETH: $2,239 (-0.0%)
SOL: $85 (-1.1%)

Performance

Return since launch: +0.0%
Open positions: 0
AI model accuracy: 0.0% (walk-forward validated)

How it works

DeepAlpha is an AI-powered trading system running on Hyperliquid L1 perpetuals. It uses:

LightGBM + XGBoost ensemble trained on 7M+ samples (5 years of data)
38 features including RSI, ATR, OBI proxy, CVD, BTC correlation
Walk-forward validation (no overfitting)
BTC SMA20 regime filter
Conservative risk: 5x leverage, 3% equity per trade, ATR-based trailing stops

All trades are verifiable on-chain.

Stats: https://deepalpha.duckdns.org
Telegram: https://t.me/DeepAlphaVault

Not financial advice. Trading involves risk.