Freqtrade 2026: 머신러닝으로 AI 기반 암호화폐 트레이딩 전략 구축하기 \u2014 완전한 봇 설정 가이드

# 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

# 기본 설정을 생성하는 init 명령 실행
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):
    """
    Freqtrade용 간단한 RSI 기반 전략.
    """
    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분 캔들
    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):
    """
    FreqAI ML 예측을 진입 신호로 사용하는 전략.
    """
    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):
        """FreqAI가 사용할 커스텀 특징 추가."""
        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 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:
        dataframe.loc[
            (
                (dataframe["&-target"] == 1) &
                (dataframe["do_predict"] == 1) &
                (dataframe["&-target_probability"] > 0.6)
            ),
            "enter_long"
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe.loc[
            (
                (dataframe["&-target"] == 0) |
                (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"

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

# 전략 로드 및 실행
strategy = StrategyResolver.load_strategy("SampleStrategy")
dataframe = strategy.analyze_ticker(data, {'pair': pair})

# 신호 확인
signals = dataframe[dataframe['enter_long'] == 1]
print(f"{len(signals)}개 진입 신호 발견")

# 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 -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,

"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:
    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
    )
    
    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