| Quy trình thiết kế hệ thống Backtest chiến lược Crypto: Đo lường hiệu suất mô hình trước khi cấu hình Bot chạy Live 24/7

Trong giao dịch thuật toán (Algo Trading), có một câu nói nổi tiếng: "Nếu bạn không thể chứng minh chiến lược của mình có lợi nhuận trong quá khứ, chắc chắn nó sẽ không thể kiếm được tiền trong tương lai". Thiết kế hệ thống Backtest (Kiểm thử chiến lược) là bước bắt buộc cuối cùng và quan trọng nhất để xác định xem ý tưởng giao dịch của bạn là một mỏ vàng thực sự hay chỉ là một ảo tưởng toán học trước khi mạo hiểm nạp tiền thật chạy Bot.

Bài viết này sẽ hướng dẫn bạn tự tay lập trình một cỗ máy Backtesting Engine bằng Python cực kỳ tinh gọn, giúp đo lường tỷ lệ Win Rate, Profit Factor và Max Drawdown dựa trên dữ liệu lịch sử tải về từ Binance API.

🎨 Sơ đồ vận hành luồng kiểm thử chiến lược của Bot

1. Bản chất của Backtesting và các cạm bẫy cần tránh

Nhìn vào sơ đồ quy trình phía trên, thay vì kết nối trực tiếp với Websocket và API để đặt lệnh thật trên Binance, hệ thống Backtest hoạt động hoàn toàn offline:

• Dữ liệu đầu vào (Input): Sử dụng tệp dữ liệu nến lịch sử (Klines) đã thu thập từ REST API.
• Mô phỏng (Simulation): Chạy một vòng lặp qua từng cây nến lịch sử, tính toán chỉ báo kỹ thuật (RSI, Momentum) tại thời điểm đó và giả lập đặt lệnh khớp ngay trong code.
• Đầu ra (Output): Xuất ra bảng thống kê kết quả lợi nhuận và biểu đồ tăng trưởng vốn (Equity Curve).

⚠️ Cạm bẫy lớn nhất: Overfitting (Quá khớp dữ liệu)

Overfitting xảy ra khi bạn cố gắng tinh chỉnh các tham số của chỉ báo kỹ thuật (ví dụ: tối ưu hóa chu kỳ RSI bằng các con số lẻ tẻ) để đạt được đường cong vốn đẹp nhất trên dữ liệu quá khứ. Kết quả là Bot sẽ hoạt động cực tệ khi đưa vào chạy thực tế vì thị trường tương lai luôn biến động và không bao giờ lặp lại y hệt quá khứ. Hãy giữ chiến lược của bạn đơn giản và logic nhất có thể.

2. Lập trình cỗ máy Backtesting Engine chuyên nghiệp bằng Python

Dưới đây là mã nguồn Python hoàn chỉnh. Chúng ta sẽ tải dữ liệu nến lịch sử của cặp giao dịch BTCUSDT, giả lập chiến lược giao dịch theo chỉ báo RSI (Mua khi RSI quá bán dưới 30, Bán khi RSI quá mua trên 70) và tính toán chi tiết hiệu quả tài chính:

import pandas as pd
import numpy as np
import requests

# Bước 1: Thu thập dữ liệu lịch sử từ Binance API để backtest
def get_historical_klines(symbol="BTCUSDT", interval="1h", limit=500):
    print("🔄 Đang tải dữ liệu nến lịch sử từ Binance API...")
    url = f"https://api.binance.com/api/v3/klines"
    params = {
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }
    r = requests.get(url, params=params)
    data = r.json()
    
    # Định dạng DataFrame
    df = pd.DataFrame(data, columns=[
        'Open Time', 'Open', 'High', 'Low', 'Close', 'Volume',
        'Close Time', 'Quote Asset Volume', 'Number of Trades',
        'Taker Buy Base Asset Volume', 'Taker Buy Quote Asset Volume', 'Ignore'
    ])
    
    df['Close'] = df['Close'].astype(float)
    df['High'] = df['High'].astype(float)
    df['Low'] = df['Low'].astype(float)
    return df[['Close', 'High', 'Low']]

# Bước 2: Hàm tính chỉ báo RSI
def calculate_rsi(series, period=14):
    delta = series.diff()
    up = delta.clip(lower=0)
    down = -delta.clip(upper=0)
    ema_up = up.ewm(com=period - 1, adjust=False).mean()
    ema_down = down.ewm(com=period - 1, adjust=False).mean()
    rs = ema_up / ema_down
    return 100 - (100 / (1 + rs))

# Bước 3: Lập trình công cụ Backtest Engine mô phỏng tài khoản và khớp lệnh
def run_backtest(df, initial_balance=1000.0):
    print("🌲 Đang khởi chạy vòng lặp kiểm thử chiến lược (Backtest)...")
    
    # Khởi tạo các trạng thái tài khoản
    balance = initial_balance
    position = 0.0      # Số lượng BTC nắm giữ
    entry_price = 0.0   # Giá vào lệnh
    trades = []         # Nhật ký giao dịch
    
    df['RSI'] = calculate_rsi(df['Close'], period=14)
    df.dropna(inplace=True)
    
    # Vòng lặp duyệt qua từng cây nến lịch sử
    for i in range(len(df)):
        current_price = df['Close'].iloc[i]
        current_rsi = df['RSI'].iloc[i]
        
        # Chiến lược Mua (BUY): RSI < 30 và chưa nắm giữ vị thế nào
        if current_rsi < 30 and position == 0.0:
            position = balance / current_price # Mua tối đa số dư tài khoản
            entry_price = current_price
            balance = 0.0
            trades.append({
                "type": "BUY",
                "price": current_price,
                "time_index": i
            })
            
        # Chiến lược Bán (SELL): RSI > 70 và đang nắm giữ vị thế
        elif current_rsi > 70 and position > 0.0:
            balance = position * current_price # Bán toàn bộ lượng coin đang giữ
            profit = (current_price - entry_price) / entry_price * 100
            position = 0.0
            trades.append({
                "type": "SELL",
                "price": current_price,
                "time_index": i,
                "profit_pct": profit
            })
            
    # Nếu kết thúc thời gian backtest mà vẫn đang giữ vị thế, đóng lệnh cưỡng bức theo giá cuối cùng
    if position > 0.0:
        balance = position * df['Close'].iloc[-1]
        profit = (df['Close'].iloc[-1] - entry_price) / entry_price * 100
        trades.append({
            "type": "SELL_FORCE",
            "price": df['Close'].iloc[-1],
            "time_index": len(df) - 1,
            "profit_pct": profit
        })
        
    return balance, trades

# Bước 4: Tính toán và báo cáo các chỉ số hiệu suất tài chính cốt lõi (Metrics)
def report_performance(initial_balance, final_balance, trades):
    total_profit = final_balance - initial_balance
    total_profit_pct = (total_profit / initial_balance) * 100
    
    # Lọc danh sách các lệnh bán để tính toán Win Rate
    sell_trades = [t for t in trades if "SELL" in t['type']]
    total_trades = len(sell_trades)
    
    if total_trades == 0:
        print("📭 Không phát sinh giao dịch nào trong khoảng thời gian kiểm thử.")
        return
        
    winning_trades = [t for t in sell_trades if t['profit_pct'] > 0]
    losing_trades = [t for t in sell_trades if t['profit_pct'] <= 0]
    
    win_rate = (len(winning_trades) / total_trades) * 100 if total_trades > 0 else 0
    
    # Tính hệ số lợi nhuận (Profit Factor)
    gross_profit = sum([t['profit_pct'] for t in winning_trades])
    gross_loss = abs(sum([t['profit_pct'] for t in losing_trades]))
    profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf')
    
    print("n================ BÁO CÁO HIỆU SUẤT BACKTEST ================")
    print(f"💵 Vốn ban đầu: {initial_balance:.2f} USD")
    print(f"💰 Vốn cuối kỳ: {final_balance:.2f} USD")
    print(f"📈 Tổng lợi nhuận ròng: {total_profit:.2f} USD ({total_profit_pct:.2f}%)")
    print(f"📊 Tổng số giao dịch hoàn tất: {total_trades}")
    print(f"🎯 Tỷ lệ Win Rate: {win_rate:.2f}%")
    print(f"⚖️ Hệ số lợi nhuận (Profit Factor): {profit_factor:.2f}")
    print("============================================================n")
    
    print("📜 Chi tiết nhật ký giao dịch:")
    for idx, t in enumerate(sell_trades):
        print(f"   Lệnh {idx+1}: {t['type']} | Lợi nhuận: {t['profit_pct']:.2f}%")

if __name__ == "__main__":
    df = get_historical_klines()
    initial_cap = 1000.0
    final_cap, trade_log = run_backtest(df, initial_balance=initial_cap)
    report_performance(initial_cap, final_cap, trade_log)

3. Các chỉ số hiệu suất quan trọng nhất cần ghi nhớ

1. Win Rate (Tỷ lệ thắng): Tỷ lệ lệnh thắng trên tổng số lệnh. Tuy nhiên, Win Rate cao không có nghĩa là chắc chắn kiếm được tiền. Một chiến lược có Win Rate 30% vẫn tạo ra siêu lợi nhuận nếu các lệnh thắng có mức lời cực lớn so với các lệnh thua nhỏ (tỷ lệ Risk/Reward cao).
2. Profit Factor (Hệ số lợi nhuận): Bằng tổng số tiền thắng chia cho tổng số tiền thua. Một chiến lược giao dịch được đánh giá là tốt và chạy ổn định khi Profit Factor > 1.5.
3. Max Drawdown (Mức sụt giảm tài sản lớn nhất): Đo lường khoảng cách từ đỉnh tài sản (peak) cao nhất đến đáy tài sản (trough) thấp nhất trong suốt quá trình backtest. Nếu mức sụt giảm này vượt quá 20-30%, chiến lược đó cực kỳ rủi ro và cần phải giảm đòn bẩy hoặc thiết kế lại cơ chế cắt lỗ.

🎓 Trở thành nhà giao dịch thuật toán chuyên nghiệp cùng Hướng Nghiệp Dữ Liệu

Tự tay lập trình và làm chủ hệ thống Backtesting chuyên nghiệp là kỹ năng phân biệt giữa một trader nghiệp dư và một nhà giao dịch định lượng (Quantitative Trader) đẳng cấp.

Nếu bạn muốn sở hữu các thuật toán Backtest nâng cao (như kiểm thử đa khung thời gian, kiểm thử danh mục đầu tư đa tài sản, tối ưu hóa tham số thuật toán di truyền) hãy đăng ký tham gia khóa đào tạo "Lập trình Bot Auto Trading thực chiến" tại Hướng Nghiệp Dữ Liệu:

• Học trực tiếp 1-1 cùng chuyên gia lập trình: Cùng bạn phân tích, tối ưu chiến lược giao dịch và biến ý tưởng của bạn thành dòng tiền ổn định.
• Thư viện công cụ cao cấp bậc nhất: Sở hữu ngay các file code backtest chuyên nghiệp có khả năng kết xuất báo cáo dưới dạng biểu đồ tương tác sắc nét và tự động tối ưu hóa tham số.
• Lộ trình đào tạo toàn diện: Từ kiến thức lập trình cơ bản đến các giải pháp Machine Learning, phân tích định lượng nâng cao ứng dụng vào các thị trường Crypto, Forex và Chứng khoán.

👉 Đăng ký nhận lộ trình học tập chi tiết và ưu đãi học phí qua Zalo:

💬 LIÊN HỆ TƯ VẤN TRỰC TIẾP QUA ZALO

🧠 Bản Chất Của Backtesting Và Các Cạm Bẫy Cần Tránh

Trong giao dịch thuật toán (Algo Trading), có một câu nói nổi tiếng: “Nếu bạn không thể chứng minh chiến lược của mình có lợi nhuận trong quá khứ, chắc chắn nó sẽ không thể kiếm được tiền trong tương lai”. Thiết kế hệ thống Backtest (Kiểm thử chiến lược) là bước bắt buộc cuối cùng và quan trọng nhất để xác định xem ý tưởng giao dịch của bạn là một mỏ vàng thực sự hay chỉ là một ảo tưởng toán học trước khi mạo hiểm nạp tiền thật chạy Bot.

Bài viết này sẽ hướng dẫn bạn tự tay lập trình một cỗ máy Backtesting Engine bằng Python cực kỳ tinh gọn, giúp đo lường tỷ lệ Win Rate, Profit Factor và Max Drawdown dựa trên dữ liệu lịch sử tải về từ Binance API.

Cách Backtest Hoạt Động

Thay vì kết nối trực tiếp với Websocket và API để đặt lệnh thật trên Binance, hệ thống Backtest hoạt động hoàn toàn offline:

• Dữ liệu đầu vào (Input): Sử dụng tệp dữ liệu nến lịch sử (Klines) đã thu thập từ REST API.
• Mô phỏng (Simulation): Chạy một vòng lặp qua từng cây nến lịch sử, tính toán chỉ báo kỹ thuật (RSI, Momentum) tại thời điểm đó và giả lập đặt lệnh khớp ngay trong code.
• Đầu ra (Output): Xuất ra bảng thống kê kết quả lợi nhuận và biểu đồ tăng trưởng vốn (Equity Curve).

⚠️ Cạm Bẫy Lớn Nhất: Overfitting (Quá Khớp Dữ Liệu)

Overfitting xảy ra khi bạn cố gắng tinh chỉnh các tham số của chỉ báo kỹ thuật (ví dụ: tối ưu hóa chu kỳ RSI bằng các con số lẻ tẻ) để đạt được đường cong vốn đẹp nhất trên dữ liệu quá khứ. Kết quả là Bot sẽ hoạt động cực tệ khi đưa vào chạy thực tế vì thị trường tương lai luôn biến động và không bao giờ lặp lại y hệt quá khứ. Hãy giữ chiến lược của bạn đơn giản và logic nhất có thể.

⚙️ Lập Trình Cỗ Máy Backtesting Engine

Dưới đây là mã nguồn Python hoàn chỉnh. Chúng ta sẽ tải dữ liệu nến lịch sử của cặp giao dịch BTCUSDT, giả lập chiến lược giao dịch theo chỉ báo RSI (Mua khi RSI quá bán dưới 30, Bán khi RSI quá mua trên 70) và tính toán hiệu suất:

# [BACKTEST ENGINE - PYTHON]
import requests
import pandas as pd
import numpy as np

# 1. TẢI DỮ LIỆU TỪ BINANCE API
def fetch_klines(symbol="BTCUSDT", interval="1h", limit=1000):
    url = "https://api.binance.com/api/v3/klines"
    params = {"symbol": symbol, "interval": interval, "limit": limit}
    data = requests.get(url, params=params, timeout=15).json()

    df = pd.DataFrame(data, columns=[
        "time", "open", "high", "low", "close", "volume",
        "close_time", "qav", "trades", "tbav", "tqav", "ignore"])
    df = df[["time", "open", "high", "low", "close", "volume"]]
    df["time"] = pd.to_datetime(df["time"], unit="ms")
    for col in ["open", "high", "low", "close", "volume"]:
        df[col] = df[col].astype(float)
    return df

# 2. TÍNH RSI
def compute_rsi(close, period=14):
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = (-delta.clip(upper=0))
    avg_gain = gain.rolling(period).mean()
    avg_loss = loss.rolling(period).mean()
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    return rsi

# 3. TẠO TÍN HIỆU (RSI  70 bán)
def generate_signals(df, rsi_period=14):
    df["rsi"] = compute_rsi(df["close"], rsi_period)
    df["signal"] = 0
    df.loc[df["rsi"]  70, "signal"] = -1  # Bán
    return df

# 4. VÒNG LẶP BACKTEST
def backtest(df, initial_balance=10000):
    balance = initial_balance
    position = 0  # 0: không giữ, 1: đang giữ
    trades = []

    for i in range(len(df)):
        price = df["close"].iloc[i]
        signal = df["signal"].iloc[i]

        # Mua: chưa giữ + có tín hiệu mua
        if signal == 1 and position == 0:
            position = 1
            entry_price = price
            entry_time = df["time"].iloc[i]
            trades.append({"type": "BUY", "price": entry_price,
                           "time": entry_time})

        # Bán: đang giữ + có tín hiệu bán
        elif signal == -1 and position == 1:
            position = 0
            pnl_pct = (price - entry_price) / entry_price
            balance *= (1 + pnl_pct)
            trades[-1]["exit_price"] = price
            trades[-1]["exit_time"] = df["time"].iloc[i]
            trades[-1]["pnl_pct"] = pnl_pct

    return balance, trades, df

📊 Đo Lường Hiệu Suất: Win Rate, Profit Factor, Max DD

# [ĐO LƯỜNG HIỆU SUẤT - PYTHON]
def performance_metrics(trades, equity_curve):
    # Win rate
    wins = [t for t in trades if t.get("pnl_pct", 0) > 0]
    win_rate = len(wins) / len(trades) if trades else 0

    # Profit factor
    gross_profit = sum(t["pnl_pct"] for t in trades
                       if t.get("pnl_pct", 0) > 0)
    gross_loss = abs(sum(t["pnl_pct"] for t in trades
                         if t.get("pnl_pct", 0)  peak:
            peak = e
        dd = (peak - e) / peak
        max_dd = max(max_dd, dd)

    return {
        "win_rate": win_rate,
        "profit_factor": profit_factor,
        "max_drawdown": max_dd,
        "total_trades": len(trades),
    }

# Chạy toàn bộ
df = fetch_klines("BTCUSDT", "1h", 1000)
df = generate_signals(df)
final_balance, trades, df = backtest(df)
metrics = performance_metrics(trades, compute_equity_curve(df, trades))

print("=== KẾT QUẢ BACKTEST BTCUSDT ===")
print(f"Win rate: {metrics['win_rate']:.1%}")
print(f"Profit factor: {metrics['profit_factor']:.2f}")
print(f"Max DD: {metrics['max_drawdown']:.1%}")
print(f"Tổng lệnh: {metrics['total_trades']}")

📈 Vẽ Equity Curve Và Phân Tích

# [VẼ EQUITY CURVE - PYTHON]
import matplotlib.pyplot as plt

def plot_equity_curve(equity_curve, title="Equity Curve BTCUSDT"):
    plt.figure(figsize=(12, 6))
    plt.plot(equity_curve, linewidth=2)
    plt.axhline(10000, color="gray", linestyle="--", alpha=0.5)
    plt.title(title)
    plt.xlabel("Số nến (phiên)")
    plt.ylabel("Vốn ($)")
    plt.grid(alpha=0.3)
    plt.show()

# Đọc equity curve từ backtest
# plot_equity_curve(equity_curve)
# Nhìn: đường đi lên đều + drawdown nhỏ = chiến lược tốt
# Đường gồ ghề + DD sâu = cần xem lại

🔍 Phân Tích Sâu: Vì Sao RSI Mean Reversion Hoạt Động

Chiến lược RSI (mua quá bán, bán quá mua) là chiến lược Mean Reversion — dựa trên giả định giá có xu hướng quay về giá trị trung bình sau các biến động thái quá:

• RSI < 30: Thị trường quá bán → khả năng bật lên.
• RSI > 70: Thị trường quá mua → khả năng điều chỉnh.

Trong thị trường sideway, chiến lược này hoạt động tốt. Nhưng trong xu hướng mạnh (trend), RSI có thể “nằm vùng” — quá bán rồi còn quá bán hơn, gây thua lỗ. Đây là lý do cần thêm bộ lọc xu hướng.

🔄 Thêm Bộ Lọc Xu Hướng (Trend Filter)

# [BỘ LỌC XU HƯỚNG - PYTHON]
def add_trend_filter(df, ma_period=50):
    # Chỉ mua khi giá trên MA50 (uptrend)
    df["ma50"] = df["close"].rolling(ma_period).mean()
    df["trend_up"] = df["close"] > df["ma50"]

    # Chỉ nhận tín hiệu mua khi uptrend
    df.loc[~df["trend_up"] & (df["signal"] == 1), "signal"] = 0
    return df

# Kết hợp: RSI + trend filter
df = fetch_klines("BTCUSDT", "1h", 1000)
df = generate_signals(df)
df = add_trend_filter(df)

# Lợi ích: tránh mua trong downtrend
# (RSI quá bán nhưng giá vẫn tiếp tục giảm)

✅ Checklist Trước Khi Cấu Hình Bot Live

• ✅ Backtest trên dữ liệu đủ dài (3-5 năm, qua bull + bear).
• ✅ Win rate và profit factor chấp nhận được.
• ✅ Max drawdown trong giới hạn an toàn (< 20%).
• ✅ Bao gồm phí giao dịch và slippage.
• ✅ Walk-forward kiểm chứng (không chỉ 1 đoạn dữ liệu).
• ✅ Forward test trên demo 1-2 tháng.
• ✅ Chiến lược đơn giản, logic rõ ràng (tránh overfit).

❓ Câu Hỏi Thường Gặp

Hỏi: Backtest bao lâu là đủ?
Tối thiểu 3-5 năm, qua cả thị trường tăng (bull), giảm (bear) và đi ngang (sideway).

Hỏi: RSI nên dùng tham số nào?
Mặc định 14, ngưỡng 30/70. Nhưng phải backtest nhiều bộ tham số để tìm vùng ổn định, tránh chọn con số tối ưu cục bộ (overfit).

Hỏi: Backtest cần tính phí và slippage không?
Bắt buộc. Backtest không tính phí sẽ “đẹp giả” — live thực tế bị phí giao dịch ăn mòn lợi nhuận.

Hỏi: Học backtest bài bản ở đâu?
Tại Hướng Nghiệp Dữ Liệu — chuỗi Python 365 ngày và khóa Algo Trading thực chiến.

🚀 Học xây dựng hệ thống backtest và bot trading: Tham gia khóa học tại Hướng Nghiệp Dữ Liệu để làm chủ backtesting engine, quản lý rủi ro và triển khai bot live.

📊 Ví Dụ Kết Quả Backtest Thực Tế

Dưới đây là bảng kết quả mẫu khi chạy backtest chiến lược RSI trên BTCUSDT khung 1h (1000 nến):

Quan sát: thêm trend filter giảm số lệnh nhưng tăng win rate, profit factor và giảm drawdown — chất lượng lệnh tốt hơn nhiều. Đây là bài học: ít lệnh chất lượng cao > nhiều lệnh nhiễu.

⚠️ Các Cạm Bẫy Khác Cần Tránh

🔄 Walk-Forward Validation — Kiểm Chứng Đáng Tin

Thay vì test toàn bộ dữ liệu một lần, walk-forward chia thành nhiều đoạn và trượt dần — mô phỏng sát thực tế:

# [WALK-FORWARD - PYTHON]
def walk_forward(df, train_pct=0.6, test_pct=0.2, steps=3):
    n = len(df)
    step_size = int(n * test_pct)
    results = []

    for i in range(steps):
        start_test = i * step_size
        train_end = start_test + int(n * train_pct)
        test_end = min(start_test + step_size, n)

        if test_end - start_test  chiến lược robust
# Nếu đoạn nào âm nặng -> chiến lược phụ thuộc giai đoạn

📈 Vẽ Đồ Thị So Sánh Chiến Lược

# [SO SÁNH EQUITY CURVE - PYTHON]
def plot_comparison(equity_base, equity_filtered):
    plt.figure(figsize=(12, 6))
    plt.plot(equity_base, label="RSI không filter", alpha=0.7)
    plt.plot(equity_filtered, label="RSI + trend filter", linewidth=2)
    plt.legend()
    plt.title("So sánh Equity Curve")
    plt.xlabel("Phiên")
    plt.ylabel("Vốn ($)")
    plt.grid(alpha=0.3)
    plt.show()

# Nhìn: đường filter mượt hơn, DD nhỏ hơn
# = chiến lược ổn định hơn

✅ Checklist Trước Khi Cấu Hình Bot Live

• ✅ Backtest trên dữ liệu đủ dài (3-5 năm, qua bull + bear).
• ✅ Win rate và profit factor chấp nhận được.
• ✅ Max drawdown trong giới hạn an toàn (< 20%).
• ✅ Bao gồm phí giao dịch và slippage.
• ✅ Walk-forward kiểm chứng (không chỉ 1 đoạn dữ liệu).
• ✅ Forward test trên demo 1-2 tháng.
• ✅ Chiến lược đơn giản, logic rõ ràng (tránh overfit).

🚀 Học xây dựng hệ thống backtest và bot trading: Tham gia khóa học tại Hướng Nghiệp Dữ Liệu để làm chủ backtesting engine, quản lý rủi ro và triển khai bot live.

Đặng Trí Thanh

Giám đốc Công nghệ · DNT Digital · Giảng viên HNDL

1.318 Bài viết

15.4k Người theo dõi

120k+ Lượt đọc

Đặng Trí Thanh — Founder & CTO · Hướng Nghiệp Dữ Liệu - DNT Digital. Chuyên đào tạo và triển khai thực chiến Python, MT5 và hệ thống bot auto trading / IB cho học viên và doanh nghiệp.

Theo dõi Liên hệ Zalo