Freqtrade 2026：使用机器学习构建AI驱动的加密货币交易策略 — 完整机器人设置指南

# 创建user_data目录结构
mkdir -p freqtrade/user_data/strategies
mkdir -p freqtrade/user_data/configs

# 下载官方docker-compose文件
cd freqtrade
curl -o docker-compose.yml https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docker-compose.yml

# 运行初始化命令创建默认配置
docker compose run --rm freqtrade new-config --config user_data/config.json

# user_data/strategies/SampleStrategy.py
import numpy as np
import talib.abstract as ta
from pandas import DataFrame
from freqtrade.strategy import IStrategy

class SampleStrategy(IStrategy):
    """
    A simple RSI-based strategy for Freqtrade.
    """
    minimal_roi = {
        "0": 0.10,     # 10% 利润目标
        "30": 0.05,    # 30分钟后5%
        "60": 0.02,    # 60分钟后2%
        "120": 0       # 120分钟后退出
    }
    stoploss = -0.10     # 10% 止损
    trailing_stop = True
    trailing_stop_positive = 0.02
    trailing_stop_positive_offset = 0.03
    timeframe = '5m'     # 5分钟K线
    can_short = False    # 仅现货交易

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # RSI指标
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
        
        # MACD指标
        macd = ta.MACD(dataframe)
        dataframe['macd'] = macd['macd']
        dataframe['macdsignal'] = macd['macdsignal']
        dataframe['macdhist'] = macd['macdhist']
        
        # 布林带
        bollinger = ta.BBANDS(dataframe, timeperiod=20, nbdevup=2.0, nbdevdn=2.0)
        dataframe['bb_lower'] = bollinger['lowerband']
        dataframe['bb_middle'] = bollinger['middleband']
        dataframe['bb_upper'] = bollinger['upperband']
        
        # ATR波动率指标
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
        
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe['rsi'] < 30) &                    # 超卖条件
                (dataframe['macd'] > dataframe['macdsignal']) &  # MACD金叉
                (dataframe['close'] < dataframe['bb_lower'])   # 价格低于布林带下轨
            ),
            'enter_long'
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe['rsi'] > 70) &                    # 超买条件
                (dataframe['macd'] < dataframe['macdsignal'])  # MACD死叉
            ),
            'exit_long'
        ] = 1
        return dataframe

# 使用你的策略启动Freqtrade
docker compose up -d

# 查看日志
docker compose logs -f freqtrade

// 添加到 config.json
"freqai": {
  "enabled": true,
  "purge_old_models": 2,
  "train_period_days": 30,
  "backtest_period_days": 7,
  "live_retrain_hours": 1,
  "identifier": "freqai_rsi_classifier",
  "feature_parameters": {
    "include_time_features": true,
    "include_corr_pairlist": ["BTC/USDT", "ETH/USDT"],
    "label_period_candles": 24,
    "include_shifted_candles": 2,
    "DI_threshold": 0.9,
    "weight_factor": 0.9,
    "principal_component_analysis": false,
    "use_SVM_to_remove_outliers": true,
    "indicator_periods_candles": [10, 20, 50]
  },
  "data_split_parameters": {
    "test_size": 0.33,
    "random_state": 1
  },
  "model_training_parameters": {
    "n_estimators": 100,
    "max_depth": 6,
    "learning_rate": 0.1,
    "num_leaves": 32
  }
}

# user_data/strategies/FreqAIStrategy.py
import pandas as pd
from freqtrade.strategy import IStrategy

class FreqAISrategy(IStrategy):
    """
    Strategy using FreqAI ML predictions as entry signals.
    """
    minimal_roi = {"0": 0.15, "60": 0.05, "120": 0}
    stoploss = -0.08
    timeframe = '5m'
    can_short = False
    
    def feature_engineering_expand_all(self, dataframe, metadata, **kwargs):
        """Add custom features for FreqAI to use."""
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)
        dataframe["macdhist"] = ta.MACD(dataframe)['macdhist']
        dataframe["atr"] = ta.ATR(dataframe, timeperiod=14)
        
        # 添加波动率特征
        dataframe["volatility"] = dataframe["close"].rolling(24).std()
        dataframe["price_change_1h"] = dataframe["close"].pct_change(12)
        
        return dataframe

    def feature_engineering_expand_basic(self, dataframe, metadata, **kwargs):
        return dataframe

    def feature_engineering_standard(self, dataframe, metadata, **kwargs):
        return dataframe

    def set_freqai_targets(self, dataframe, metadata, **kwargs):
        """Define what we want to predict - price goes up or down."""
        dataframe["&-target"] = (
            dataframe["close"].shift(-24) > dataframe["close"]
        ).astype(int)
        return dataframe

    def populate_indicators(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe = self.freqai.start(dataframe, metadata, self)
        return dataframe

    def populate_entry_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        # 当ML预测上涨且置信度高时入场
        dataframe.loc[
            (
                (dataframe["&-target"] == 1) &           # ML预测: 上涨
                (dataframe["do_predict"] == 1) &         # 模型有置信度
                (dataframe["&-target_probability"] > 0.6)  # 概率 > 60%
            ),
            "enter_long"
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe.loc[
            (
                (dataframe["&-target"] == 0) |           # ML预测: 下跌
                (dataframe["do_predict"] != 1)             # 模型不确定
            ),
            "exit_long"
        ] = 1
        return dataframe

# 运行超参数优化
docker compose run --rm freqtrade hyperopt \
  --strategy SampleStrategy \
  --spaces buy sell roi stoploss trailing \
  --epochs 100 \
  --timerange 20260101-20260331 \
  --hyperopt-loss SharpeHyperOptLossDaily

# 首先下载历史数据
docker compose run --rm freqtrade download-data \
  --exchange binance \
  --pairs BTC/USDT ETH/USDT SOL/USDT BNB/USDT XRP/USDT \
  --timeframes 5m 15m 1h \
  --timerange 20240101-20260331

# 运行回测
docker compose run --rm freqtrade backtesting \
  --strategy SampleStrategy \
  --timerange 20260101-20260331 \
  --pairs BTC/USDT ETH/USDT SOL/USDT \
  --export trades \
  --export-filename user_data/backtest_results.json

# 在Freqtrade的Jupyter容器中运行
import pandas as pd
from freqtrade.data.history import load_pair_history
from freqtrade.resolvers import StrategyResolver

# 加载历史数据
pair = "BTC/USDT"
timeframe = "5m"
timerange = "20260101-20260331"

data = load_pair_history(
    datadir="user_data/data/binance",
    pair=pair,
    timeframe=timeframe,
    timerange=timerange
)

# 加载并运行策略
strategy = StrategyResolver.load_strategy("SampleStrategy")
dataframe = strategy.analyze_ticker(data, {'pair': pair})

# 查看信号
signals = dataframe[dataframe['enter_long'] == 1]
print(f"发现 {len(signals)} 个入场信号")
print(signals[['date', 'close', 'rsi', 'macdhist']].head(10))

# 启动API服务器（在config.json中启用）
# 查询当前状态
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/status

# 获取交易历史
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/trades

# 获取利润摘要
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/profit

# 强制入场
curl -X POST -u admin:your-secure-password \
  -H "Content-Type: application/json" \
  -d '{"pair": "BTC/USDT", "side": "long"}' \
  http://localhost:8080/api/v1/forceentry

// 高级风险管理设置
"max_open_trades": 3,
"stake_amount": "unlimited",
"tradable_balance_ratio": 0.95,
"amend_last_stake_amount": true,
"available_capital": 5000,
"stake_amount_mode": "unlimited",

"order_types": {
  "entry": "limit",
  "exit": "limit",
  "emergency_exit": "market",
  "stoploss": "market",
  "stoploss_on_exchange": true,
  "stoploss_on_exchange_interval": 60
},

"protections": [
  {
    "method": "CooldownPeriod",
    "stop_duration_candles": 2
  },
  {
    "method": "MaxDrawdown",
    "lookback_period_candles": 48,
    "trade_limit": 20,
    "stop_duration_candles": 4,
    "max_allowed_drawdown": 0.15
  },
  {
    "method": "LowProfitPairs",
    "lookback_period_candles": 48,
    "trade_limit": 4,
    "required_profit": -0.05,
    "stop_duration": 60
  }
]

# 添加到策略中实现动态止损
def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
                    current_rate: float, current_profit: float, **kwargs) -> float:
    """基于ATR的动态止损."""
    dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
    if dataframe.empty:
        return self.stoploss
    
    last_candle = dataframe.iloc[-1]
    atr = last_candle['atr']
    
    # 在2x ATR处止损
    stoploss_price = trade.open_rate - (2 * atr)
    
    # 从当前价格转换为百分比
    return stoploss_from_absolute(stoploss_price, current_rate, is_short=trade.is_short)

def informative_pairs(self):
    """定义用于分析的高时间框架交易对."""
    return [
        ("BTC/USDT", "1h"),
        ("ETH/USDT", "1h"),
    ]

def populate_indicators(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
    # 获取BTC的1小时数据
    inf_pair, inf_timeframe = self.informative_pairs()[0]
    informative = self.dp.get_pair_dataframe(inf_pair, inf_timeframe)
    
    # 计算1小时趋势
    informative['ema50_1h'] = ta.EMA(informative, timeperiod=50)
    informative['ema200_1h'] = ta.EMA(informative, timeperiod=200)
    informative['trend_1h'] = np.where(
        informative['ema50_1h'] > informative['ema200_1h'], 1, -1
    )
    
    # 合并到5分钟数据框
    dataframe = merge_informative_pair(dataframe, informative, self.timeframe, inf_timeframe)
    
    dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
    
    return dataframe

# 支持FreqAI GPU的docker-compose.yml
version: '3.8'

services:
  freqtrade:
    image: freqtradeorg/freqtrade:stable
    container_name: freqtrade_gpu
    restart: unless-stopped
    volumes:
      - ./user_data:/freqtrade/user_data
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - FREQTRADE__FREQAI__MODEL_TRAINING__DEVICE=cuda
    command: >
      trade --strategy FreqAIStrategy --config user_data/config.json

# docker-compose.yml
version: '3.8'

services:
  freqtrade:
    image: freqtradeorg/freqtrade:stable
    container_name: freqtrade_prod
    restart: unless-stopped
    volumes:
      - ./user_data:/freqtrade/user_data
    ports:
      - "127.0.0.1:8080:8080"
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: '2.0'
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/v1/ping"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    command: >
      trade --strategy SampleStrategy --config user_data/config.json

# 自定义模型示例
from freqtrade.freqai.base_models import BaseRegressionModel
from sklearn.ensemble import RandomForestRegressor

class MyCustomModel(BaseRegressionModel):
    def fit(self, data_dictionary: dict, **kwargs):
        model = RandomForestRegressor(n_estimators=200, max_depth=10)
        model.fit(data_dictionary["train_features"], data_dictionary["train_labels"])
        return model