ในโลกของการซื้อขายสินทรัพย์ดิจิทัล กลยุทธ์ Market Making ถือเป็นหัวใจสำคัญที่ทำให้ตลาดมีสภาพคล่อง แต่ทำไมบางครั้งนักเทรดรายใหญ่ถึงสามารถคาดเดาการเคลื่อนไหวของราคาได้แม่นยำกว่าคนอื่น? คำตอบอยู่ที่ การวิเคราะห์ Order Book ด้วย Machine Learning บทความนี้จะพาคุณเรียนรู้วิธีสร้างโมเดลที่สามารถคาดการณ์พฤติกรรมของ Order Book เพื่อใช้ในกลยุทธ์ Market Making ได้อย่างมีประสิทธิภาพ

ทำความรู้จัก Order Book และความสำคัญใน Market Making

Order Book คือบันทึกคำสั่งซื้อ-ขายที่รอการจับคู่ในตลาด ประกอบด้วยราคาและปริมาณที่ผู้ซื้อ-ผู้ขายต้องการ สำหรับ Market Maker การเข้าใจรูปแบบของ Order Book จะช่วยให้:

เปรียบเทียบ API สำหรับ Machine Learning

เกณฑ์ HolySheep AI API อย่างเป็นทางการ บริการรีเลย์ทั่วไป
ราคาต่อ 1M Tokens (GPT-4) $8 $30-60 $15-25
ความเร็ว (Latency) <50ms 100-300ms 80-200ms
การชำระเงิน WeChat/Alipay, ¥1=$1 บัตรเครดิตเท่านั้น บัตรเครดิต/PayPal
เครดิตฟรี มีเมื่อลงทะเบียน ไม่มี จำกัด
ความเสถียร SLA 99.9% สูงมาก ปานกลาง
รองรับ Fine-tuning มี มี บางผู้ให้บริการ

สถาปัตยกรรมโมเดลสำหรับ Order Book Prediction

การคาดการณ์ Order Book ต้องอาศัยโมเดลหลายประเภท แต่ละโมเดลมีจุดเด่นที่แตกต่างกัน:

1. LSTM (Long Short-Term Memory)

เหมาะสำหรับการจับลำดับเวลาของการเปลี่ยนแปลงราคาและปริมาณ โมเดลนี้เก่งในการจดจำรูปแบบที่เกิดขึ้นซ้ำๆ ใน Order Book

2. Transformer Architecture

ใช้ Attention Mechanism เพื่อให้ความสำคัญกับส่วนต่างๆ ของ Order Book ที่มีผลต่อการคาดการณ์มากที่สุด

3. XGBoost/LightGBM

โมเดลแบบ Gradient Boosting ที่ทำงานได้ดีกับข้อมูลที่มี Feature หลายมิติ รวดเร็วในการเทรนและ Inference

การเตรียมข้อมูล Order Book

ก่อนจะนำข้อมูลไปเทรนโมเดล ต้องทำ Feature Engineering ที่เหมาะสม:

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler

def extract_orderbook_features(orderbook_snapshot):
    """
    สกัด Feature จาก Order Book Snapshot
    """
    features = {}
    
    # Bid-Ask Spread
    features['spread'] = orderbook_snapshot['asks'][0][0] - orderbook_snapshot['bids'][0][0]
    features['spread_pct'] = features['spread'] / orderbook_snapshot['bids'][0][0]
    
    # Bid-Ask Volume Imbalance
    bid_volume = sum([x[1] for x in orderbook_snapshot['bids'][:10]])
    ask_volume = sum([x[1] for x in orderbook_snapshot['asks'][:10]])
    features['volume_imbalance'] = (bid_volume - ask_volume) / (bid_volume + ask_volume)
    
    # Weighted Mid Price
    features['mid_price'] = (orderbook_snapshot['asks'][0][0] + orderbook_snapshot['bids'][0][0]) / 2
    
    # Price levels depth
    for i in range(5):
        features[f'bid_depth_{i}'] = sum([x[1] for x in orderbook_snapshot['bids'][:i+1]])
        features[f'ask_depth_{i}'] = sum([x[1] for x in orderbook_snapshot['asks'][:i+1]])
    
    return features


ตัวอย่างการใช้งาน

sample_orderbook = {
    'bids': [[100.0, 50], [99.5, 30], [99.0, 100], [98.5, 80], [98.0, 60]],
    'asks': [[100.5, 40], [101.0, 60], [101.5, 90], [102.0, 70], [102.5, 50]]
}
features = extract_orderbook_features(sample_orderbook)
print(f"Features extracted: {list(features.keys())}")

สร้างโมเดล LSTM สำหรับ Mid-Price Prediction

โมเดล LSTM เหมาะสำหรับการคาดการณ์ Mid-Price ในอีก 5-10 วินาทีข้างหน้า:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
import holy_sheep_sdk  # ใช้ HolySheep AI SDK


สร้างการเชื่อมต่อกับ HolySheep API

client = holy_sheep_sdk.Client(
    base_url="https://api.holysheep.ai/v1",
    api_key="YOUR_HOLYSHEEP_API_KEY"
)

def build_lstm_model(input_shape):
    """
    สร้างโมเดล LSTM สำหรับ Order Book Prediction
    """
    model = Sequential([
        LSTM(128, return_sequences=True, input_shape=input_shape),
        Dropout(0.2),
        LSTM(64, return_sequences=False),
        Dropout(0.2),
        Dense(32, activation='relu'),
        Dense(1)  # Output: Mid-price prediction
    ])
    
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    return model


การเตรียมข้อมูลสำหรับ Sequence Learning

def create_sequences(data, seq_length=20):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:(i + seq_length)])
        y.append(data[i + seq_length, 0])  # Mid-price target
    return np.array(X), np.array(y)


ตัวอย่างการเทรน


historical_data: DataFrame ที่มี columns ['bid_price', 'ask_price', 'bid_volume', 'ask_volume']

X_train, y_train = create_sequences(historical_data.values, seq_length=20)

model = build_lstm_model(input_shape=(20, historical_data.shape[1]))
history = model.fit(X_train, y_train, epochs=50, batch_size=64, validation_split=0.2)


ใช้โมเดลที่เทรนแล้วสำหรับ Prediction

def predict_mid_price(model, recent_orderbooks):
    """คาดการณ์ Mid-Price ในอนาคต"""
    features = np.array([extract_orderbook_features(ob) for ob in recent_orderbooks])
    features = features.reshape(1, 20, -1)
    prediction = model.predict(features)
    return prediction[0][0]


ทำนาย Mid-Price

predicted_price = predict_mid_price(model, recent_20_orderbooks)
print(f"Predicted Mid-Price: {predicted_price:.2f}")

ใช้ Transformer สำหรับ Order Flow Prediction

สำหรับโมเดลที่ซับซ้อนมากขึ้น สามารถใช้ Transformer เพื่อจับ Order Flow:

import torch
import torch.nn as nn

class OrderBookTransformer(nn.Module):
    def __init__(self, feature_dim=12, d_model=64, nhead=4, num_layers=2):
        super().__init__()
        
        self.embedding = nn.Linear(feature_dim, d_model)
        self.positional_encoding = PositionalEncoding(d_model)
        
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, 
            nhead=nhead, 
            dim_feedforward=128,
            dropout=0.1
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        
        self.output_layer = nn.Sequential(
            nn.Linear(d_model, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )
    
    def forward(self, x):
        # x shape: (batch, seq_len, feature_dim)
        x = self.embedding(x)
        x = self.positional_encoding(x)
        x = self.transformer(x)
        x = x[:, -1, :]  # ใช้ Output จาก Sequence สุดท้าย
        return self.output_layer(x)


การคำนวณ Order Flow Direction

def calculate_order_flow_direction(orderbook_changes):
    """
    คำนวณทิศทาง Order Flow
    Returns: 1 (Buy Pressure), -1 (Sell Pressure), 0 (Neutral)
    """
    buy_pressure = 0
    sell_pressure = 0
    
    for change in orderbook_changes:
        if change['side'] == 'bid':
            buy_pressure += change['volume'] * change['price_impact']
        else:
            sell_pressure += change['volume'] * change['price_impact']
    
    net_pressure = buy_pressure - sell_pressure
    
    if net_pressure > 0.01:
        return 1
    elif net_pressure < -0.01:
        return -1
    return 0


ตัวอย่างการใช้งาน

model = OrderBookTransformer(feature_dim=12)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)


ดึงข้อมูล Order Book ผ่าน Exchange API

recent_orderbooks = get_recent_orderbooks(exchange="binance", symbol="BTC/USDT", limit=20)
features = extract_orderbook_features_batch(recent_orderbooks)


Prediction

model.eval()
with torch.no_grad():
    features_tensor = torch.FloatTensor(features).unsqueeze(0)
    direction_pred = model(features_tensor)
    print(f"Order Flow Direction: {direction_pred.item():.4f}")

การประยุกต์ใช้ในกลยุทธ์ Market Making

เมื่อได้โมเดลที่คาดการณ์ได้แม่นยำแล้ว มาดูวิธีนำไปใช้ในกลยุทธ์ Market Making จริง:

class MarketMakingStrategy:
    def __init__(self, model, config):
        self.model = model
        self.spread = config['base_spread']
        self.position_limit = config['position_limit']
        self.inventory = 0
    
    def calculate_optimal_spread(self, orderbook_features, prediction_confidence):
        """
        คำนวณ Spread ที่เหมาะสมตามความมั่นใจของการคาดการณ์
        """
        base_spread = self.spread
        
        # ถ้าความมั่นใจสูง ลด Spread เพื่อดึงดูด volume
        if prediction_confidence > 0.8:
            adjusted_spread = base_spread * 0.7
        # ถ้าความมั่นใจต่ำ เพิ่ม Spread เพื่อป้องกันความเสี่ยง
        elif prediction_confidence < 0.5:
            adjusted_spread = base_spread * 1.5
        else:
            adjusted_spread = base_spread
        
        # ปรับตาม Volume Imbalance
        imbalance_penalty = abs(orderbook_features['volume_imbalance']) * 0.2
        adjusted_spread *= (1 + imbalance_penalty)
        
        return adjusted_spread
    
    def generate_orders(self, current_price, orderbook_features, prediction):
        """
        สร้างคำสั่งซื้อขายตามกลยุทธ์
        """
        # คำนวณความมั่นใจจาก prediction
        prediction_confidence = self.get_confidence(prediction)
        optimal_spread = self.calculate_optimal_spread(
            orderbook_features, 
            prediction_confidence
        )
        
        # คำนวณราคาคำสั่ง
        bid_price = current_price - (optimal_spread / 2)
        ask_price = current_price + (optimal_spread / 2)
        
        # กำหนดขนาดตามความเสี่ยง
        if self.inventory > self.position_limit * 0.7:
            # Inventory สูงเกิน ลดขนาดของฝั่ง Buy
            bid_size = self.calculate_size(self.inventory, 'sell')
            ask_size = 0  # ไม่รับ Buy อีก
        elif self.inventory < -self.position_limit * 0.7:
            # Inventory ต่ำเกิน ลดขนาดของฝั่ง Sell
            ask_size = self.calculate_size(self.inventory, 'buy')
            bid_size = 0  # ไม่รับ Sell อีก
        else:
            bid_size = self.calculate_size(self.inventory, 'both')
            ask_size = self.calculate_size(self.inventory, 'both')
        
        return {
            'bid': {'price': bid_price, 'size': bid_size},
            'ask': {'price': ask_price, 'size': ask_size}
        }
    
    def calculate_size(self, inventory, side):
        """คำนวณขนาดคำสั่งตาม Inventory Risk"""
        base_size = 0.1  # BTC
        inventory_ratio = abs(inventory) / self.position_limit
        risk_adjustment = 1 - (inventory_ratio * 0.5)
        return base_size * risk_adjustment


การใช้งาน

strategy = MarketMakingStrategy(model=prediction_model, config={
    'base_spread': 0.001,  # 0.1%
    'position_limit': 10   # BTC
})


วน loop หลักของ Bot

while True:
    orderbook = exchange.get_orderbook("BTC/USDT")
    features = extract_orderbook_features(orderbook)
    prediction = predict_mid_price(prediction_model, recent_orderbooks)
    
    current_price = (orderbook['bids'][0][0] + orderbook['asks'][0][0]) / 2
    orders = strategy.generate_orders(current_price, features, prediction)
    
    exchange.place_orders("BTC/USDT", orders)
    time.sleep(0.5)  # Update ทุก 500ms

ราคาและ ROI

สำหรับนักพัฒนาที่ต้องการใช้ LLM ในการวิเคราะห์และประมวลผล Order Book ราคาคือปัจจัยสำคัญ:

โมเดล ราคา/1M Tokens (Input) ราคา/1M Tokens (Output) ประหยัด vs Official
GPT-4.1 $8 $32 85%+
Claude Sonnet 4.5 $15 $75 80%+
Gemini 2.5 Flash $2.50 $10 90%+
DeepSeek V3.2 $0.42 $1.68 85%+

ตัวอย่างการคำนวณ ROI:

เหมาะกับใคร / ไม่เหมาะกับใคร

✅ เหมาะกับ:

❌ ไม่เหมาะกับ:

ทำไมต้องเลือก HolySheep

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. ข้อผิดพลาด: Rate LimitExceeded

สาเหตุ: เรียก API บ่อยเกินไปโดยไม่ได้ใช้ Rate Limiting

# ❌ วิธีที่ผิด - เรียก API ทุก Tick
while True:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "analyze"}]
    )
    # จะถูก Rate Limit ทันที


✅ วิธีที่ถูกต้อง - ใช้ Rate Limiter

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_calls, time_window):
        self.max_calls = max_calls
        self.time_window = time_window
        self.calls = deque()
    
    def wait_if_needed(self):
        now = time.time()
        # ลบ Call ที่เก่ากว่า Time Window
        while self.calls and self.calls[0] < now - self.time_window:
            self.calls.popleft()
        
        if len(self.calls) >= self.max_calls:
            sleep_time = self.time_window - (now - self.calls[0])
            time.sleep(sleep_time)
        
        self.calls.append(time.time())

rate_limiter = RateLimiter(max_calls=100, time_window=60)  # 100 calls/min

while True:
    rate_limiter.wait_if_needed()
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "analyze orderbook"}]
    )
    process_response(response)

2. ข้อผิดพลาด: Order Book Data Staleness

สาเหตุ: ใช้ข้อมูล Order Book ที่เก่าเกินไปสำหรับการคาดการณ์

# ❌ วิธีที่ผิด - ใช้ Snapshot เดียว
orderbook = exchange.get_orderbook("BTC/USDT")
features = extract_orderbook_features(orderbook)  # ข้อมูลอาจเก่า 5+ วินาที


✅ วิธีที่ถูกต้อง - ตรวจสอบ Timestamp และใช้ Sequence

def get_fresh_orderbook_sequence(exchange, symbol, seq_length=20, max_age_ms=5000):
    sequence = []
    for _ in range(seq_length):
        orderbook = exchange.get_orderbook(symbol)
        
        # ตรวจสอบ Timestamp
        current_time = time.time() * 1000
        if current_time - orderbook['timestamp'] > max_age_ms:
            raise DataStalenessError(f"Orderbook is {current_time - orderbook['timestamp']}ms old")
        
        sequence.append(orderbook)
        time.sleep(0.05)  # รอ 50ms ระหว่างแต่ละ Snapshot
    
    return sequence


ดึงข้อมูลที่ Fresh

try:
    recent_orderbooks = get_fresh_orderbook_sequence(exchange, "BTC/USDT", seq_length=20)
    features = extract_orderbook_features_batch(recent_orderbooks)
except DataStalenessError as e:
    logger.warning(f"Skipping prediction: {e}")
    continue

3. ข้อผิดพลาด: Model Overfitting บน Historical Data

สาเหตุ: โมเดลจดจำรูปแบบเฉพาะใน Training Data แต่ไม่ Generalize ได้

# ❌ วิธีที่ผิด - เทรนบน Data เดียวกันกับ Test
model.fit(X_train, y_train, epochs=100)
train_loss = model.evaluate(X_train, y_train)  # Loss ต่ำมาก
test_loss = model.evaluate(X_test, y_test)      # Loss สูงมาก - Overfit!


✅ วิธีที่ถูกต้อง - ใช้ Walk-Forward Validation

def walk_forward_validation(data, train_window=1000, test_window=100):
    """
    Walk-Forward Validation สำหรับ Time Series
    - Train บน Train Window
    - Test บน Test Window ที่ตามมา
    """
    results = []
    
    for i in range(train_window, len(data) - test_window, test_window):
        train_data = data[i - train_window:i]
        test_data = data[i:i + test_window]
        
        # เทรนโมเดลใหม่ทุกรอบ
        model = build_lstm_model(input_shape)
        model.fit(train_data, epochs=50, verbose=0)
        
        # ทดสอบ
        predictions = model.predict(test_data)
        actual = test_data[:, 0]  # Mid-price
        
        # คำนวณ Metrics
        mae = np.mean(np.abs(predictions - actual))
        mape = np.mean(np.abs((predictions - actual) / actual)) * 100
        
        results.append({
            'period': i,
            'mae': mae,
            'mape': mape,
            'model': model
        })
        
        print(f"Period {i}: MAE={mae:.4f}, MAPE={mape:.2f}%")
    
    return results


ทดสอบด้วย Walk-Forward

validation_results = walk_forward_validation(historical_data)
avg_mape = np.mean([r['mape'] for r in validation_results])
print(f"Average MAPE across all periods: {avg_mape:.2f}%")

4. ข้อผิดพลาด: Memory Leak เ

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

บทความที่เกี่ยวข้อง