FinRL-X Quantitative Trading Infrastructure

FinRL-X is a modular quantitative trading infrastructure designed around a weight-centric architecture. The core principle is that the target portfolio weight vector serves as the sole interface contract between strategy logic and execution. This allows for modular swapping of components (e.g., replacing an Equal Weight allocator with a DRL allocator) without changing the downstream pipeline.

The architecture is organized into four layers:

1. Data: Handles market data via FMP, Yahoo Finance, WRDS, and LLM sentiment preprocessing, using SQLite for caching.
2. Strategy: Generates weight-centric signals through stock selection, portfolio allocation, timing adjustment, and risk overlay.
3. Backtest: An offline evaluation engine powered by bt that supports multi-benchmark comparison and transaction costs.
4. Execution: Manages live or paper trading via Alpaca multi-account integration with pre-trade risk checks.

The min_variance method requires historical price data to calculate volatility. Depending on your data source, you must provide the data in one of two formats within the data_dict.

Option 1: Using Fundamental Data (Quarterly)

If using fundamental data, the system relies on the adj_close_q column. Use a shorter lookback_periods (e.g., 8 quarters).

Option 2: Using Price Data (Daily)

If using daily price data, provide a prices key in the data_dict. Use a longer lookback_periods (e.g., 252 days).

Parameters

• lookback_periods: The number of historical periods to use for volatility calculation.

# Option 1: Using fundamental data (adj_close_q)
data_dict = {
    'fundamentals': fundamentals_df
}

result = strategy.generate_weights(
    data_dict,
    prediction_mode='single',
    weight_method='min_variance',
    lookback_periods=8
)

# Option 2: Using daily price data
data_dict = {
    'fundamentals': fundamentals_df,
    'prices': prices_df  # Must contain ['date', 'tic', 'close']
}

result = strategy.generate_weights(
    data_dict,
    prediction_mode='single',
    weight_method='min_variance',
    lookback_periods=252
)

Use the deploy.sh script for an automated workflow that handles dependency checks, data downloading, and strategy execution. This is the fastest way to run backtests or paper trading.

Common commands:

• Backtest: ./deploy.sh --strategy <strategy_name> --mode backtest
• Custom Date Range: ./deploy.sh --strategy <strategy_name> --mode backtest --start <YYYY-MM-DD> --end <YYYY-MM-DD>
• Single Date Signal: ./deploy.sh --strategy <strategy_name> --mode single --date <YYYY-MM-DD>
• Paper Trading (Preview): ./deploy.sh --strategy <strategy_name> --mode paper --dry-run
• Paper Trading (Execute): ./deploy.sh --strategy <strategy_name> --mode paper

# Backtest (downloads data + runs strategy)
./deploy.sh --strategy adaptive_rotation --mode backtest

# Custom date range
./deploy.sh --strategy adaptive_rotation --mode backtest --start 2020-01-01 --end 2025-12-31

# Single date signal
./deploy.sh --strategy adaptive_rotation --mode single --date 2024-12-31

# Paper trading (requires Alpaca credentials in .env)
./deploy.sh --strategy adaptive_rotation --mode paper --dry-run   # preview
./deploy.sh --strategy adaptive_rotation --mode paper              # execute

If trade_price has been updated in the database, you must recompute all y_return values to maintain data integrity. This script iterates through the fundamental_data table and updates the y_return column based on the new trade_price and the subsequent trade_price for each ticker.

import sqlite3, pandas as pd, numpy as np
conn = sqlite3.connect('data/finrl_trading.db')
df = pd.read_sql('SELECT ticker, datadate, trade_price FROM fundamental_data ORDER BY ticker, datadate', conn)
df['trade_price'] = pd.to_numeric(df['trade_price'], errors='coerce')
df['next_tp'] = df.groupby('ticker')['trade_price'].shift(-1)
df['y_return_new'] = np.where(
    (df['trade_price'] > 0) & (df['next_tp'] > 0),
    np.log(df['next_tp'] / df['trade_price']), np.nan
)
cursor = conn.cursor()
for _, row in df.iterrows():
    val = None if pd.isna(row['y_return_new']) else round(float(row['y_return_new']), 6)
    cursor.execute('UPDATE fundamental_data SET y_return = ? WHERE ticker = ? AND datadate = ?',
                   (val, row['ticker'], row['datadate']))
conn.commit()
conn.close()