การทำ Backtesting คือการนำกลยุทธ์การลงทุนที่เราคิดขึ้นมาไปทดสอบกับข้อมูลราคาในอดีต เพื่อดูว่าถ้าเราใช้กลยุทธ์นี้ตั้งแต่ปีที่แล้ว เราจะได้กำไรหรือขาดทุน? บทความนี้จะสอนคุณทำ Backtesting อย่างมืออาชีพโดยใช้ Tardis API แม้คุณจะไม่เคยเขียนโค้ดมาก่อนก็ตาม

Tardis API คืออะไรและทำไมต้องใช้?

Tardis API เป็นบริการที่รวบรวมข้อมูลราคาคริปโตเคอเรนซีจากตลาดต่างๆ ทั่วโลกมาไว้ให้เราสามารถเรียกใช้ได้ง่ายๆ ผ่านคำสั่งง่ายๆ ข้อมูลที่ได้ครอบคลุมทั้งราคา ปริมาณการซื้อขาย และ Order Book เพื่อให้เราทดสอบกลยุทธ์ได้อย่างแม่นยำ

ข้อดีของ Tardis API

เริ่มต้นใช้งาน Tardis API

ขั้นตอนที่ 1: สมัครสมาชิกและรับ API Key

ให้คุณเข้าไปที่เว็บไซต์ Tardis แล้วสมัครสมาชิก หลังจากสมัครเสร็จคุณจะได้ API Key ซึ่งจะเป็นชุดตัวอักษรยาวที่ใช้ในการยืนยันตัวตนเมื่อเรียกใช้งาน คุณจะเห็น API Key นี้ในหน้า Dashboard ของคุณ

ขั้นตอนที่ 2: เตรียมเครื่องมือ

สำหรับมือใหม่ เราแนะนำให้ใช้ Python ผ่าน Google Colab ซึ่งไม่ต้องติดตั้งโปรแกรมใดๆ บนเครื่อง เพียงแค่เปิดเว็บเบราว์เซอร์แล้วเข้าไปที่ colab.research.google.com ก็สามารถเขียนโค้ดได้ทันที

ขั้นตอนที่ 3: ติดตั้ง Library ที่จำเป็น

ก่อนจะเริ่มดึงข้อมูล เราต้องติดตั้ง Library ที่ช่วยให้การทำงานสะดวกขึ้น ให้พิมพ์คำสั่งด้านล่างใน Colab

!pip install tardis-dev pandas numpy matplotlib requests

หลังจากรันคำสั่งนี้ ระบบจะดาวน์โหลดและติดตั้ง Library ที่จำเป็นทั้งหมดให้อัตโนมัติ โดย Library แต่ละตัวมีหน้าที่ต่างกัน เช่น tardis-dev ใช้ดึงข้อมูลราคา pandas ใช้จัดการข้อมูลตาราง และ matplotlib ใช้วาดกราฟ

ดึงข้อมูลราคาย้อนหลัง

ตัวอย่างที่ 1: ดึงข้อมูล Bitcoin รายชั่วโมง

มาเริ่มด้วยการดึงข้อมูลราคา Bitcoin เทียบกับ USDT ย้อนหลัง 30 วัน โดยข้อมูลจะมาทีละชั่วโมง คุณสามารถ copy คำสั่งด้านล่างไปวางใน Colab ได้เลย

import tardis
import pandas as pd
from datetime import datetime, timedelta


ตั้งค่าวันที่เริ่มต้นและสิ้นสุด

end_date = datetime.now()
start_date = end_date - timedelta(days=30)


สร้าง API Client

client = tardis.Client(api_key='YOUR_TARDIS_API_KEY')


ดึงข้อมูล Binance Bitcoin/USDT รายชั่วโมง

exchange = 'binance'
symbol = 'BTC-USDT'
interval = '1h'

print(f"กำลังดึงข้อมูล {symbol} จาก {exchange}")
print(f"ช่วงเวลา: {start_date.strftime('%Y-%m-%d')} ถึง {end_date.strftime('%Y-%m-%d')}")


ดึงข้อมูล OHLCV (Open, High, Low, Close, Volume)

data = client.get_historical_realtime(
    exchange=exchange,
    symbol=symbol,
    interval=interval,
    start_date=start_date,
    end_date=end_date
)


แปลงเป็น DataFrame

df = pd.DataFrame(data)
df['timestamp'] = pd.to_datetime(df['timestamp'])
df = df.set_index('timestamp')

print(f"\nได้ข้อมูลทั้งหมด {len(df)} แท่งเทียน")
print(df.tail())

เมื่อรันคำสั่งนี้ คุณจะเห็นข้อมูลราคา Bitcoin ย้อนหลัง 30 วัน พร้อมราคาเปิด สูงสุด ต่ำสุด ปิด และปริมาณการซื้อขาย ในตารางที่อ่านง่าย

ตัวอย่างที่ 2: ดึงข้อมูลหลายเหรียญพร้อมกัน

ถ้าคุณต้องการเปรียบเทียบกลยุทธ์กับเหรียญหลายตัว เช่น BTC ETH SOL สามารถใช้คำสั่งด้านล่างได้

import warnings
warnings.filterwarnings('ignore')


รายชื่อเหรียญที่ต้องการ

symbols = ['BTC-USDT', 'ETH-USDT', 'SOL-USDT']
all_data = {}

for symbol in symbols:
    print(f"กำลังดึงข้อมูล {symbol}...")
    
    data = client.get_historical_realtime(
        exchange='binance',
        symbol=symbol,
        interval='1d',
        start_date=start_date,
        end_date=end_date
    )
    
    df = pd.DataFrame(data)
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df = df.set_index('timestamp')
    
    all_data[symbol] = df
    print(f"  ได้ข้อมูล {symbol} {len(df)} แท่งเทียน")

print("\nเสร็จสิ้นการดึงข้อมูลทั้งหมด")
print(f"เหรียญที่ได้ข้อมูล: {list(all_data.keys())}")

สร้างกลยุทธ์ Backtesting แบบง่ายๆ

ตอนนี้เรามีข้อมูลราคาแล้ว ต่อไปจะเป็นการสร้างกลยุทธ์การลงทุนแบบง่ายๆ เพื่อทดสอบ กลยุทธ์แรกที่จะลองคือ Simple Moving Average Crossover หรือการตัดกันของเส้นค่าเฉลี่ย

ทฤษฎี: กลยุทธ์ SMA Crossover

กลยุทธ์นี้ใช้หลักการง่ายๆ คือ เมื่อเส้นค่าเฉลี่ยระยะสั้น (เช่น 7 วัน) ตัดขึ้นเหนือเส้นค่าเฉลี่ยระยะยาว (เช่น 25 วัน) จะซื้อ และเมื่อตัดลงต่ำกว่าจะขาย ลองมาดูโค้ดกัน

def sma_crossover_strategy(df, short_window=7, long_window=25):
    """
    กลยุทธ์ SMA Crossover
    
    พารามิเตอร์:
    - df: DataFrame ที่มีคอลัมน์ 'close'
    - short_window: จำนวนวันเส้นค่าเฉลี่ยสั้น
    - long_window: จำนวนวันเส้นค่าเฉลี่ยยาว
    
    คืนค่า: DataFrame ที่มีสัญญาณซื้อขาย
    """
    # คำนวณเส้นค่าเฉลี่ย
    df['sma_short'] = df['close'].rolling(window=short_window).mean()
    df['sma_long'] = df['close'].rolling(window=long_window).mean()
    
    # สร้างสัญญาณ: 1 = ซื้อ, -1 = ขาย, 0 = ถือ
    df['signal'] = 0
    df.loc[df['sma_short'] > df['sma_long'], 'signal'] = 1
    df.loc[df['sma_short'] < df['sma_long'], 'signal'] = -1
    
    # ตำแหน่งที่สัญญาณเปลี่ยน
    df['position_change'] = df['signal'].diff()
    
    return df


ทดสอบกับข้อมูล BTC

btc_data = all_data['BTC-USDT'].copy()
btc_data = sma_crossover_strategy(btc_data)

print("ผลการทดสอบกลยุทธ์ SMA Crossover กับ BTC")
print(f"ระยะเวลา: {len(btc_data)} วัน")
print(f"วันที่มีสัญญาณซื้อ: {(btc_data['position_change'] == 2).sum()}")
print(f"วันที่มีสัญญาณขาย: {(btc_data['position_change'] == -2).sum()}")


แสดงตัวอย่างสัญญาณ

signals = btc_data[btc_data['position_change'] != 0][['close', 'sma_short', 'sma_long', 'signal', 'position_change']]
print("\nตัวอย่างสัญญาณที่เกิดขึ้น:")
print(signals.head(10))

คำนวณผลตอบแทนและประเมินประสิทธิภาพ

หลังจากมีสัญญาณซื้อขายแล้ว ต้องคำนวณว่ากลยุทธ์นี้ทำกำไรได้จริงหรือไม่ โดยจะคำนวณผลตอบแทน ความเสี่ยง และสถิติต่างๆ ที่สำคัญ

import numpy as np

def calculate_performance(df, initial_capital=10000):
    """
    คำนวณประสิทธิภาพของกลยุทธ์
    
    พารามิเตอร์:
    - df: DataFrame ที่มีสัญญาณซื้อขาย
    - initial_capital: เงินทุนเริ่มต้น (USD)
    """
    df = df.copy()
    
    # คำนวณผลตอบแทนรายวัน
    df['daily_return'] = df['close'].pct_change()
    
    # ผลตอบแทนของกลยุทธ์ (คูณสัญญาณที่คงค้าง)
    df['strategy_return'] = df['signal'].shift(1) * df['daily_return']
    
    # พอร์ตโฟลิโอ
    df['portfolio_value'] = initial_capital * (1 + df['strategy_return']).cumprod()
    
    # คำนวณสถิติ
    total_return = (df['portfolio_value'].iloc[-1] / initial_capital - 1) * 100
    
    # annualized return
    num_days = len(df)
    annualized_return = ((1 + total_return/100) ** (365/num_days) - 1) * 100
    
    # volatility (ความผันผวน)
    volatility = df['strategy_return'].std() * np.sqrt(365) * 100
    
    # Sharpe Ratio (อัตราส่วนความเสี่ยง-ผลตอบแทน)
    sharpe_ratio = (annualized_return / volatility) if volatility > 0 else 0
    
    # Max Drawdown (การขาดทุนสูงสุด)
    cumulative = (1 + df['strategy_return']).cumprod()
    rolling_max = cumulative.expanding().max()
    drawdown = cumulative / rolling_max - 1
    max_drawdown = drawdown.min() * 100
    
    results = {
        'total_return': total_return,
        'annualized_return': annualized_return,
        'volatility': volatility,
        'sharpe_ratio': sharpe_ratio,
        'max_drawdown': max_drawdown,
        'final_value': df['portfolio_value'].iloc[-1]
    }
    
    return results, df


คำนวณประสิทธิภาพ

results, btc_backtest = calculate_performance(btc_data)

print("=" * 50)
print("ผลการ Backtesting กลยุทธ์ SMA Crossover")
print("=" * 50)
print(f"เงินทุนเริ่มต้น: ${10000:,.2f}")
print(f"เงินทุนสุดท้าย: ${results['final_value']:,.2f}")
print(f"ผลตอบแทนรวม: {results['total_return']:.2f}%")
print(f"ผลตอบแทนต่อปี: {results['annualized_return']:.2f}%")
print(f"ความผันผวน (Volatility): {results['volatility']:.2f}%")
print(f"Sharpe Ratio: {results['sharpe_ratio']:.2f}")
print(f"การขาดทุนสูงสุด (Max Drawdown): {results['max_drawdown']:.2f}%")
print("=" * 50)

เปรียบเทียบกลยุทธ์หลายแบบ

การทดสอบเพียงกลยุทธ์เดียวยังไม่พอ ควรเปรียบเทียบกับกลยุทธ์อื่นๆ เพื่อหาว่าวิธีไหนเหมาะกับตลาดแบบไหน ต่อไปนี้คือการเปรียบเทียบกลยุทธ์ Buy and Hold กับ SMA Crossover

def buy_and_hold_strategy(df, initial_capital=10000):
    """
    กลยุทธ์ Buy and Hold - ซื้อแล้วถือยาว
    """
    df = df.copy()
    
    # ซื้อตั้งแต่วันแรกและถือ
    df['signal'] = 1
    df['daily_return'] = df['close'].pct_change()
    df['strategy_return'] = df['signal'].shift(1) * df['daily_return']
    df['portfolio_value'] = initial_capital * (1 + df['strategy_return']).cumprod()
    
    return df


ทดสอบทั้ง 2 กลยุทธ์กับทุกเหรียญ

comparison_results = []

for symbol, data in all_data.items():
    # SMA Strategy
    sma_data = sma_crossover_strategy(data.copy())
    sma_results, _ = calculate_performance(sma_data)
    
    # Buy and Hold
    bnh_data = buy_and_hold_strategy(data.copy())
    bnh_results, _ = calculate_performance(bnh_data)
    
    comparison_results.append({
        'Symbol': symbol,
        'SMA Return': f"{sma_results['total_return']:.2f}%",
        'SMA Sharpe': f"{sma_results['sharpe_ratio']:.2f}",
        'SMA MaxDD': f"{sma_results['max_drawdown']:.2f}%",
        'BnH Return': f"{bnh_results['total_return']:.2f}%",
        'BnH Sharpe': f"{bnh_results['sharpe_ratio']:.2f}",
        'BnH MaxDD': f"{bnh_results['max_drawdown']:.2f}%"
    })

comparison_df = pd.DataFrame(comparison_results)
print("\nเปรียบเทียบผลกลยุทธ์:")
print(comparison_df.to_string(index=False))

สร้างกราฟแสดงผล

การดูตัวเลขอย่างเดียวบางทีเข้าใจยาก มาสร้างกราฟเพื่อให้เห็นภาพชัดเจนขึ้น

import matplotlib.pyplot as plt

fig, axes = plt.subplots(3, 1, figsize=(14, 12))


กราฟ 1: ราคาและสัญญาณ

ax1 = axes[0]
ax1.plot(btc_backtest.index, btc_backtest['close'], label='ราคา BTC', alpha=0.7)
ax1.plot(btc_backtest.index, btc_backtest['sma_short'], label='SMA 7 วัน', linestyle='--')
ax1.plot(btc_backtest.index, btc_backtest['sma_long'], label='SMA 25 วัน', linestyle='--')


ทำเครื่องหมายจุดซื้อขาย

buy_signals = btc_backtest[btc_backtest['position_change'] == 2]
sell_signals = btc_backtest[btc_backtest['position_change'] == -2]

ax1.scatter(buy_signals.index, buy_signals['close'], marker='^', color='green', s=100, label='สัญญาณซื้อ')
ax1.scatter(sell_signals.index, sell_signals['close'], marker='v', color='red', s=100, label='สัญญาณขาย')
ax1.set_title('ราคา Bitcoin และสัญญาณซื้อขาย')
ax1.legend()
ax1.grid(True, alpha=0.3)


กราฟ 2: มูลค่าพอร์ต

ax2 = axes[1]
ax2.plot(btc_backtest.index, btc_backtest['portfolio_value'], label='SMA Strategy', linewidth=2)
ax2.axhline(y=10000, color='gray', linestyle='--', label='เงินทุนเริ่มต้น')
ax2.set_title('มูลค่าพอร์ตโฟลิโอ')
ax2.legend()
ax2.grid(True, alpha=0.3)


กราฟ 3: Drawdown

cumulative = (1 + btc_backtest['strategy_return']).cumprod()
rolling_max = cumulative.expanding().max()
drawdown = (cumulative / rolling_max - 1) * 100

ax3 = axes[2]
ax3.fill_between(drawdown.index, drawdown, 0, alpha=0.3, color='red')
ax3.plot(drawdown.index, drawdown, color='red')
ax3.set_title('Drawdown (การขาดทุนจากจุดสูงสุด)')
ax3.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('backtest_results.png', dpi=150)
plt.show()

print("\nกราฟถูกบันทึกเป็น backtest_results.png")

ใช้ AI ช่วยวิเคราะห์และปรับปรุงกลยุทธ์

หลังจากได้ผลการทดสอบแล้ว คุณอาจอยากให้ AI ช่วยวิเคราะห์และเสนอแนะกลยุทธ์ใหม่ๆ ที่ดีกว่า เราแนะนำให้ใช้ HolySheep AI ซึ่งมีความเร็วตอบสนองต่ำกว่า 50 มิลลิวินาที และราคาประหยัดกว่า 85% เมื่อเทียบกับบริการอื่น

ตัวอย่างการใช้ HolySheep AI วิเคราะห์ผล Backtesting

import requests

def analyze_with_ai(backtest_summary, holysheep_api_key):
    """
    ส่งผลการ Backtest ให้ AI วิเคราะห์และเสนอแนะ
    """
    base_url = "https://api.holysheep.ai/v1"
    
    prompt = f"""คุณเป็นผู้เชี่ยวชาญด้าน Cryptocurrency Trading
    
    ผลการ Backtesting ที่ได้:
    {backtest_summary}
    
    กรุณาวิเคราะห์และเสนอแนะ:
    1. จุดแข็งและจุดอ่อนของกลยุทธ์นี้
    2. วิธีปรับปรุงให้ดีขึ้น
    3. ความเสี่ยงที่ควรระวัง
    4. กลยุทธ์ทางเลือกอื่นๆ ที่น่าสนใจ
    """
    
    response = requests.post(
        f"{base_url}/chat/completions",
        headers={
            "Authorization": f"Bearer {holysheep_api_key}",
            "Content-Type": "application/json"
        },
        json={
            "model": "gpt-4.1",
            "messages": [
                {"role": "system", "content": "คุณเป็นที่ปรึกษาการลงทุนที่เชี่ยวชาญ"},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.7
        }
    )
    
    return response.json()


สรุปผลการทดสอบ

summary = f"""
กลยุทธ์: SMA Crossover (7/25 วัน)
เหรียญ: BTC/USDT
ระยะเวลา: 30 ว

แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง