Skip to content
The Algotrading Book

Chapter 358: ConvNeXt for Trading — Modern ConvNets Competing with Transformers

Chapter 358: ConvNeXt for Trading — Modern ConvNets Competing with Transformers

Overview

ConvNeXt represents the evolution of convolutional neural networks, incorporating design principles from Vision Transformers (ViT) while maintaining the efficiency and simplicity of convolutions. This chapter explores how to apply ConvNeXt architecture to financial time series prediction and trading signal generation using cryptocurrency market data.

The key insight from the original paper “A ConvNet for the 2020s” (Liu et al., 2022) is that many design choices in Transformers can be successfully incorporated into ConvNets, creating models that compete with or exceed Transformer performance while being more efficient.

Trading Strategy

Core Approach: Use ConvNeXt architecture to process multi-channel financial time series (OHLCV + technical indicators) as 1D sequences, generating trading signals for cryptocurrency pairs.

Key Advantages for Trading:

  1. Efficient long-range dependencies — Large kernel sizes (7×1) capture patterns across longer time horizons
  2. Hierarchical feature extraction — Multi-stage architecture captures patterns at different time scales
  3. Computational efficiency — Faster inference than Transformers for real-time trading
  4. Robust to noise — Depthwise separable convolutions reduce overfitting

Edge: ConvNeXt combines the inductive biases of CNNs (translation equivariance, locality) with modern training techniques, making it particularly suitable for financial time series where patterns repeat across different time periods.

ConvNeXt Architecture Fundamentals

Key Design Principles

  1. Macro Design — Stage ratios (3:3:9:3) and stem cell design
  2. ResNeXt-ification — Grouped convolutions with depthwise separable convolutions
  3. Inverted Bottleneck — Expand channels, apply depthwise conv, contract
  4. Large Kernel Sizes — Use 7×7 kernels (adapted to 7×1 for 1D time series)
  5. Layer Normalization — Replace BatchNorm with LayerNorm
  6. Fewer Activation Functions — Single GELU per block
  7. Separate Downsampling Layers — Explicit downsampling between stages

ConvNeXt Block Structure

Input
  │
  ├─→ Depthwise Conv 7×1 (groups=C)
  │
  ├─→ LayerNorm
  │
  ├─→ Pointwise Conv 1×1 (expand 4×)
  │
  ├─→ GELU
  │
  ├─→ Pointwise Conv 1×1 (contract)
  │
  └─→ Residual Connection → Output

Technical Implementation

Architecture for Trading

Input: [batch, channels, sequence_length]
       [B, C, T] where C = OHLCV + indicators


Stage 1: Stem + ConvNeXt Blocks ×3
  - Patchify stem: Conv 4×1, stride 4
  - Channels: 96 → 96


Stage 2: Downsample + ConvNeXt Blocks ×3
  - Downsample: LayerNorm + Conv 2×1, stride 2
  - Channels: 96 → 192


Stage 3: Downsample + ConvNeXt Blocks ×9
  - Channels: 192 → 384


Stage 4: Downsample + ConvNeXt Blocks ×3
  - Channels: 384 → 768


Head: Global Average Pool → LayerNorm → FC → Softmax/Sigmoid
  - Classification: [Long, Short, Hold] or
  - Regression: Price change prediction

Rust Implementation

The Rust implementation provides:

  • High-performance inference for production trading systems
  • Memory efficiency for processing large historical datasets
  • Integration with Bybit exchange for cryptocurrency data
  • Modular design for easy customization

Project Structure

358_convnext_trading/
├── README.md
├── README.ru.md
├── readme.simple.md
├── readme.simple.ru.md
└── rust/
    ├── Cargo.toml
    ├── src/
    │   ├── lib.rs
    │   ├── main.rs
    │   ├── convnext/
    │   │   ├── mod.rs
    │   │   ├── block.rs
    │   │   ├── model.rs
    │   │   └── layers.rs
    │   ├── data/
    │   │   ├── mod.rs
    │   │   ├── bybit.rs
    │   │   ├── features.rs
    │   │   └── dataset.rs
    │   ├── trading/
    │   │   ├── mod.rs
    │   │   ├── signals.rs
    │   │   ├── strategy.rs
    │   │   └── backtest.rs
    │   └── utils/
    │       ├── mod.rs
    │       └── metrics.rs
    └── examples/
        ├── fetch_data.rs
        ├── train_model.rs
        └── live_signals.rs

Data Pipeline

Bybit Data Fetching

// Fetch OHLCV data from Bybit
let client = BybitClient::new();
let candles = client.get_klines(
    "BTCUSDT",
    Interval::H1,
    start_time,
    end_time
).await?;

Feature Engineering

Feature GroupIndicators
PriceOpen, High, Low, Close (normalized)
VolumeVolume, VWAP, Volume SMA
MomentumRSI, MACD, Stochastic
VolatilityATR, Bollinger Bands, Keltner Channels
TrendEMA (9, 21, 50, 200), ADX

Input Tensor Construction

// Shape: [batch, channels, sequence_length]
// Example: [32, 20, 256] - 32 samples, 20 features, 256 time steps
let input = Tensor::zeros(&[batch_size, num_features, seq_length]);

Model Training

Loss Functions

  1. Classification (Direction Prediction)

    • CrossEntropyLoss for [Long, Short, Hold]
    • Weighted by class frequency to handle imbalance

  2. Regression (Return Prediction)

    • MSE for continuous return prediction
    • Huber Loss for robustness to outliers

Training Configuration

let config = TrainingConfig {
    learning_rate: 4e-4,
    batch_size: 32,
    epochs: 100,
    weight_decay: 0.05,
    warmup_epochs: 5,
    label_smoothing: 0.1,
    drop_path_rate: 0.1,
    layer_scale_init: 1e-6,
};

Data Augmentation for Time Series

  1. Time Warping — Slight stretching/compression of time axis
  2. Magnitude Scaling — Random scaling of values
  3. Jittering — Adding small Gaussian noise
  4. Window Slicing — Random cropping with padding

Trading Strategy

Signal Generation

pub fn generate_signal(model: &ConvNeXt, features: &Tensor) -> Signal {
    let logits = model.forward(features);
    let probs = softmax(&logits, -1);


    let long_prob = probs[0];
    let short_prob = probs[1];
    let hold_prob = probs[2];


    if long_prob > CONFIDENCE_THRESHOLD && long_prob > short_prob {
        Signal::Long { confidence: long_prob }
    } else if short_prob > CONFIDENCE_THRESHOLD && short_prob > long_prob {
        Signal::Short { confidence: short_prob }
    } else {
        Signal::Hold
    }
}

Position Sizing

Kelly Criterion with risk management:

pub fn calculate_position_size(
    signal: &Signal,
    portfolio_value: f64,
    max_risk_per_trade: f64,  // e.g., 0.02 (2%)
) -> f64 {
    let edge = signal.confidence - 0.5;  // Edge over random
    let win_rate = signal.confidence;
    let win_loss_ratio = 1.5;  // Target reward/risk


    // Kelly fraction
    let kelly_f = (win_rate * win_loss_ratio - (1.0 - win_rate)) / win_loss_ratio;


    // Half-Kelly for safety
    let position_fraction = kelly_f * 0.5;


    // Apply maximum risk constraint
    let max_position = portfolio_value * max_risk_per_trade;


    (portfolio_value * position_fraction).min(max_position)
}

Backtesting Framework

Performance Metrics

pub struct BacktestMetrics {
    pub total_return: f64,
    pub sharpe_ratio: f64,
    pub sortino_ratio: f64,
    pub max_drawdown: f64,
    pub win_rate: f64,
    pub profit_factor: f64,
    pub avg_trade_duration: Duration,
    pub total_trades: usize,
}

Example Backtest Results (BTC/USDT, 1H)

MetricValue
Total Return+47.3%
Sharpe Ratio1.82
Sortino Ratio2.41
Max Drawdown-12.4%
Win Rate58.7%
Profit Factor1.65
Total Trades342

Note: Results are illustrative. Past performance doesn’t guarantee future results.

Model Variants

  • Parameters: ~28M
  • Channels: [96, 192, 384, 768]
  • Blocks: [3, 3, 9, 3]
  • Best for: Real-time inference

ConvNeXt-Small

  • Parameters: ~50M
  • Channels: [96, 192, 384, 768]
  • Blocks: [3, 3, 27, 3]
  • Best for: Higher accuracy

ConvNeXt-Base

  • Parameters: ~89M
  • Channels: [128, 256, 512, 1024]
  • Blocks: [3, 3, 27, 3]
  • Best for: Research/ensemble

Key Metrics

MetricDescriptionTarget
Direction AccuracyCorrect prediction of price direction>55%
Sharpe RatioRisk-adjusted return>1.5
Sortino RatioDownside risk-adjusted return>2.0
Max DrawdownLargest peak-to-trough decline<15%
Profit FactorGross profit / Gross loss>1.5
Win RatePercentage of profitable trades>55%

Dependencies (Rust)

[dependencies]
ndarray = "0.15"
ndarray-rand = "0.14"
tokio = { version = "1.0", features = ["full"] }
reqwest = { version = "0.11", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
chrono = { version = "0.4", features = ["serde"] }
hmac = "0.12"
sha2 = "0.10"
hex = "0.4"
anyhow = "1.0"

Usage Examples

Fetching Data

Terminal window
cd 358_convnext_trading/rust
cargo run --example fetch_data -- --symbol BTCUSDT --interval 1h --days 365

Training Model

Terminal window
cargo run --example train_model -- --data data/btcusdt_1h.json --epochs 100

Generating Live Signals

Terminal window
cargo run --example live_signals -- --symbol BTCUSDT --interval 1h

Expected Outcomes

  1. ConvNeXt implementation optimized for 1D time series
  2. Bybit data pipeline for cryptocurrency OHLCV data
  3. Feature engineering module with technical indicators
  4. Training framework with proper validation
  5. Backtesting engine with comprehensive metrics
  6. Trading signal generator for live operation

References

  1. A ConvNet for the 2020s

  2. Deep Residual Learning for Image Recognition

  3. An Image is Worth 16x16 Words: Transformers for Image Recognition

  4. Financial Machine Learning

    • López de Prado, M. (2018)
    • Advances in Financial Machine Learning

Difficulty Level

Advanced

Prerequisites: Deep Learning fundamentals, CNN architectures, Time series analysis, Rust programming, Trading basics