Freqtrade 2026: X\u00e2y D\u1ef1ng Chi\u1ebfn L\u01b0\u1ee3c Giao D\u1ecbch Ti\u1ec1n M\u00e3 H\u00f3a AI V\u1edbi Machine Learning \u2014 H\u01b0\u1edbng D\u1eabn Thi\u1ebft L\u1eadp Bot Ho\u00e0n Ch\u1ec9nh

# Tạo cấu trúc thư mục user_data
mkdir -p freqtrade/user_data/strategies
mkdir -p freqtrade/user_data/configs

# Tải file docker-compose chính thức
cd freqtrade
curl -o docker-compose.yml https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docker-compose.yml

# Chạy lệnh init để tạo config mặc định
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,     # Mục tiêu lợi nhuận 10%
        "30": 0.05,    # 5% sau 30 phút
        "60": 0.02,    # 2% sau 60 phút
        "120": 0       # Thoát sau 120 phút
    }
    stoploss = -0.10     # Stop loss 10%
    trailing_stop = True
    trailing_stop_positive = 0.02
    trailing_stop_positive_offset = 0.03
    timeframe = '5m'     # Nến 5 phút
    can_short = False    # Chỉ giao dịch spot

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # Chỉ báo RSI
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
        
        # Chỉ báo MACD
        macd = ta.MACD(dataframe)
        dataframe['macd'] = macd['macd']
        dataframe['macdsignal'] = macd['macdsignal']
        dataframe['macdhist'] = macd['macdhist']
        
        # Bollinger Bands
        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 cho biến động
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
        
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe['rsi'] < 30) &                    # Điều kiện quá bán
                (dataframe['macd'] > dataframe['macdsignal']) &  # MACD cắt lên
                (dataframe['close'] < dataframe['bb_lower'])   # Giá dưới BB dưới
            ),
            'enter_long'
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe['rsi'] > 70) &                    # Điều kiện quá mua
                (dataframe['macd'] < dataframe['macdsignal'])  # MACD cắt xuống
            ),
            'exit_long'
        ] = 1
        return dataframe

# Khởi động Freqtrade với chiến lược của bạn
docker compose up -d

# Kiểm tra logs
docker compose logs -f freqtrade

// Thêm vào 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):
        """Thêm features tùy chỉnh cho FreqAI sử dụng."""
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)
        dataframe["macdhist"] = ta.MACD(dataframe)['macdhist']
        dataframe["atr"] = ta.ATR(dataframe, timeperiod=14)
        
        # Thêm features biến động
        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):
        """Định nghĩa điều chúng ta muốn dự đoán — giá lên hay xuống."""
        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:
        # Vào khi ML dự đoán xu hướng tăng với độ tin cậy cao
        dataframe.loc[
            (
                (dataframe["&-target"] == 1) &           # ML dự đoán: lên
                (dataframe["do_predict"] == 1) &         # Model tự tin
                (dataframe["&-target_probability"] > 0.6)  # Xác suất > 60%
            ),
            "enter_long"
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe.loc[
            (
                (dataframe["&-target"] == 0) |           # ML dự đoán: xuống
                (dataframe["do_predict"] != 1)             # Model không chắc chắn
            ),
            "exit_long"
        ] = 1
        return dataframe

# Chạy tối ưu hyperparameter
docker compose run --rm freqtrade hyperopt \
  --strategy SampleStrategy \
  --spaces buy sell roi stoploss trailing \
  --epochs 100 \
  --timerange 20260101-20260331 \
  --hyperopt-loss SharpeHyperOptLossDaily

# Tải dữ liệu lịch sử trước
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

# Chạy backtest
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

# Chạy bên trong container Jupyter của Freqtrade
import pandas as pd
from freqtrade.data.history import load_pair_history
from freqtrade.resolvers import StrategyResolver

# Tải dữ liệu lịch sử
pair = "BTC/USDT"
timeframe = "5m"

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

# Tải và chạy chiến lược
strategy = StrategyResolver.load_strategy("SampleStrategy")
dataframe = strategy.analyze_ticker(data, {'pair': pair})

# Xem tín hiệu
signals = dataframe[dataframe['enter_long'] == 1]
print(f"Tìm thấy {len(signals)} tín hiệu vào lệnh")
print(signals[['date', 'close', 'rsi', 'macdhist']].head(10))

# Khởi động API server (đã bật trong config.json)
# Truy vấn trạng thái hiện tại
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/status

# Lấy lịch sử giao dịch
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/trades

# Lấy tóm tắt lợi nhuận
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/profit

# Ép buộc vào lệnh
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

// Cài đặt quản lý rủi ro nâng cao
"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
  }
]

# Thêm vào chiến lược để có stoploss động
def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
                    current_rate: float, current_profit: float, **kwargs) -> float:
    """Stoploss động dựa trên 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']
    
    # Stoploss tại 2x ATR
    stoploss_price = trade.open_rate - (2 * atr)
    
    # Chuyển đổi sang phần trăm từ giá hiện tại
    return stoploss_from_absolute(stoploss_price, current_rate, is_short=trade.is_short)

def informative_pairs(self):
    """Định nghĩa các cặp khung thờ gian cao hơn để phân tích."""
    return [
        ("BTC/USDT", "1h"),
        ("ETH/USDT", "1h"),
    ]

def populate_indicators(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
    # Lấy dữ liệu 1h cho BTC
    inf_pair, inf_timeframe = self.informative_pairs()[0]
    informative = self.dp.get_pair_dataframe(inf_pair, inf_timeframe)
    
    # Tính xu hướng 1h
    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
    )
    
    # Merge vào dataframe 5m
    dataframe = merge_informative_pair(dataframe, informative, self.timeframe, inf_timeframe)
    
    # Chỉ giao dịch theo hướng xu hướng 1h
    dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
    
    return dataframe

# docker-compose.yml với hỗ trợ GPU cho FreqAI
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

# Ví dụ model tùy chỉnh
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