คุณเคยสงสัยไหมว่าระบบเทรดอัตโนมัติทำงานอย่างไร? คำตอบอยู่ที่ Order Book หรือ "สมุดคำสั่งซื้อ-ขาย" ซึ่งเป็นข้อมูลสำคัญที่บอกว่าตลาดกำลังจะไปทางไหน บทความนี้จะสอนคุณตั้งแต่การติดตั้งโปรแกรมไปจนถึงสร้างโมเดล Deep Learning ทำนายราคาจาก Order Book ได้จริง โดยไม่ต้องมีพื้นฐานมาก่อนเลย

Order Book คืออะไร ทำไมต้องเรียนรู้?

ลองนึกภาพตลาดขายผลไม้ ที่มีคนอยากซื้อที่ราคาต่างกัน และมีคนอยากขายที่ราคาต่างกัน Order Book ก็เหมือนกัน แต่เป็นตลาดคริปโตแทน

┌─────────────────────────────────────────────────┐
│           ตัวอย่าง Order Book ของ BTC/USDT      │
├──────────────┬──────────────┬───────────────────┤
│    ราคา       │   ปริมาณ     │      ประเภท        │
├──────────────┼──────────────┼───────────────────┤
│  65,000.00   │   2.50       │   คำสั่งขาย (Ask)  │
│  64,999.50   │   1.20       │   คำสั่งขาย (Ask)  │
│  64,998.00   │   3.80       │   คำสั่งขาย (Ask)  │
├──────────────┼──────────────┼───────────────────┤
│  64,997.50   │  --------    │   <<< ราคาปัจจุบัน │
├──────────────┼──────────────┼───────────────────┤
│  64,997.00   │   5.10       │   คำสั่งซื้อ (Bid) │
│  64,996.50   │   2.30       │   คำสั่งซื้อ (Bid) │
│  64,995.00   │   4.00       │   คำสั่งซื้อ (Bid) │
└──────────────┴──────────────┴───────────────────┘

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

เตรียมเครื่องมือก่อนเริ่มต้น

สำหรับมือใหม่ ผมแนะนำให้ติดตั้ง Python ผ่าน Anaconda เพราะจัดการ packages ง่าย ไม่ต้องกังวลเรื่อง version conflict

ขั้นตอนที่ 1: ติดตั้งโปรแกรมที่จำเป็น

# เปิด Terminal (Command Prompt) แล้วพิมพ์คำสั่งนี้ทีละบรรทัด


สร้าง environment ใหม่ชื่อ "orderbook"

conda create -n orderbook python=3.10


เข้าไปใน environment

conda activate orderbook


ติดตั้ง packages ที่ต้องการ

pip install python-binance pandas numpy tensorflow scikit-learn matplotlib requests

💡 เคล็ดลับ: หากติดตั้ง tensorflow แล้ว error ให้ลองติดตั้ง tensorflow-cpu ก่อน เพราะ GPU version ต้องการ CUDA ที่ตั้งค่ายากกว่า

ขั้นตอนที่ 2: สมัคร Binance API

เข้าไปที่ Binance.com → ล็อกอิน → ไปที่ API Management → สร้าง API Key ใหม่ โดยเลือกแบบ System Generated

# สร้างไฟล์ config.py เพื่อเก็บ API Key อย่างปลอดภัย

API_KEY = "YOUR_BINANCE_API_KEY"
API_SECRET = "YOUR_BINANCE_API_SECRET"


⚠️ ห้ามแชร์ API Key ของคุณให้คนอื่นเด็ดขาด!


แนะนำให้ตั้ง IP restriction ด้วย

ดึงข้อมูล Order Book จาก Binance

มาเขียนโค้ดดึงข้อมูล Order Book กันเถอะ ผมจะอธิบายทีละบรรทัดให้เข้าใจง่ายๆ

import requests
import time
import json
from collections import deque

class BinanceOrderBook:
    """คลาสสำหรับดึงข้อมูล Order Book จาก Binance"""
    
    def __init__(self, symbol="BTCUSDT", limit=100):
        # symbol = คู่เทรด เช่น BTCUSDT, ETHUSDT
        # limit = จำนวนรายการที่ต้องการ (1-5000)
        self.symbol = symbol.upper()
        self.limit = limit
        self.base_url = "https://api.binance.com"
        self.order_book_data = deque(maxlen=1000)  # เก็บข้อมูล 1000 ช่วงเวลา
        
    def get_order_book(self):
        """ดึงข้อมูล Order Book ปัจจุบัน"""
        endpoint = "/api/v3/depth"
        params = {
            "symbol": self.symbol,
            "limit": self.limit
        }
        
        try:
            response = requests.get(
                self.base_url + endpoint, 
                params=params,
                timeout=10
            )
            
            if response.status_code == 200:
                return response.json()
            else:
                print(f"❌ Error: {response.status_code}")
                return None
                
        except requests.exceptions.RequestException as e:
            print(f"❌ เชื่อมต่อไม่ได้: {e}")
            return None
    
    def parse_order_book(self, data):
        """แปลงข้อมูล Order Book ให้อยู่ในรูปแบบที่ใช้งานง่าย"""
        if not data:
            return None
            
        parsed = {
            "timestamp": data.get("lastUpdateId"),
            "bids": [[float(p), float(q)] for p, q in data.get("bids", [])],
            "asks": [[float(p), float(q)] for p, q in data.get("asks", [])],
        }
        
        # คำนวณค่าที่เป็นประโยชน์
        best_bid = parsed["bids"][0][0] if parsed["bids"] else 0
        best_ask = parsed["asks"][0][0] if parsed["asks"] else 0
        spread = best_ask - best_bid
        spread_pct = (spread / best_bid) * 100 if best_bid > 0 else 0
        
        parsed["best_bid"] = best_bid
        parsed["best_ask"] = best_ask
        parsed["spread"] = spread
        parsed["spread_pct"] = spread_pct
        parsed["mid_price"] = (best_bid + best_ask) / 2
        
        # คำนวณความลึกของตลาด (Volume รวม)
        parsed["bid_volume"] = sum([q for _, q in parsed["bids"][:10]])
        parsed["ask_volume"] = sum([q for _, q in parsed["asks"][:10]])
        parsed["volume_imbalance"] = parsed["bid_volume"] - parsed["ask_volume"]
        
        return parsed
    
    def collect_historical(self, iterations=100, delay=1):
        """เก็บข้อมูล Order Book หลายๆ ช่วงเวลา"""
        print(f"📊 เริ่มเก็บข้อมูล {iterations} ช่วงเวลา...")
        
        for i in range(iterations):
            data = self.get_order_book()
            if data:
                parsed = self.parse_order_book(data)
                if parsed:
                    self.order_book_data.append(parsed)
                    
            if (i + 1) % 10 == 0:
                print(f"  ✓ เก็บได้ {i + 1}/{iterations} ช่วงเวลา")
                
            time.sleep(delay)  # รอเพื่อไม่ให้ถูก block
            
        print(f"✅ เสร็จสิ้น! เก็บข้อมูลได้ {len(self.order_book_data)} ช่วงเวลา")
        return list(self.order_book_data)


ทดสอบการใช้งาน

if __name__ == "__main__":
    # สร้าง instance
    ob = BinanceOrderBook(symbol="BTCUSDT", limit=100)
    
    # ดึงข้อมูลครั้งเดียว
    data = ob.get_order_book()
    if data:
        parsed = ob.parse_order_book(data)
        print(f"\n📈 BTC/USDT Order Book:")
        print(f"   ราคาซื้อสูงสุด: ${parsed['best_bid']:,.2f}")
        print(f"   ราคาขายต่ำสุด: ${parsed['best_ask']:,.2f}")
        print(f"   Spread: ${parsed['spread']:.2f} ({parsed['spread_pct']:.4f}%)")
        print(f"   ปริมาณซื้อ 10 อันดับ: {parsed['bid_volume']:.4f} BTC")
        print(f"   ปริมาณขาย 10 อันดับ: {parsed['ask_volume']:.4f} BTC")

เตรียมข้อมูลสำหรับโมเดล Deep Learning

ข้อมูลดิบยังไม่พร้อมสำหรับโมเดล ต้องแปลงให้อยู่ในรูปแบบที่โมเดลเข้าใจได้ ในส่วนนี้เราจะสร้าง features ที่มีประโยชน์สำหรับการทำนาย

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

class OrderBookFeatureEngineering:
    """สร้าง features จาก Order Book สำหรับ Deep Learning"""
    
    def __init__(self, window_size=10):
        # window_size = จำนวนช่วงเวลาที่ใช้ทำนาย
        self.window_size = window_size
        self.scaler = StandardScaler()
        
    def calculate_wap(self, order_book):
        """
        Weighted Average Price (WAP)
        คือราคาเฉลี่ยถ่วงน้ำหนักด้วยปริมาณ
        """
        bids = order_book["bids"]
        asks = order_book["asks"]
        
        # WAP = Σ(price × volume) / Σ(volume)
        bid_wap = sum(p * q for p, q in bids) / sum(q for _, q in bids) if bids else 0
        ask_wap = sum(p * q for p, q in asks) / sum(q for _, q in asks) if asks else 0
        
        return (bid_wap + ask_wap) / 2
    
    def calculate_depth_features(self, order_book, levels=5):
        """คำนวณความลึกของตลาดที่ระดับต่างๆ"""
        bids = order_book["bids"]
        asks = order_book["asks"]
        
        features = {}
        
        # ปริมาณรวมและราคาเฉลี่ยที่แต่ละระดับ
        for i in range(levels):
            if i < len(bids):
                features[f"bid_vol_{i}"] = bids[i][1]
                features[f"bid_price_{i}"] = bids[i][0]
            else:
                features[f"bid_vol_{i}"] = 0
                features[f"bid_price_{i}"] = 0
                
            if i < len(asks):
                features[f"ask_vol_{i}"] = asks[i][1]
                features[f"ask_price_{i}"] = asks[i][0]
            else:
                features[f"ask_vol_{i}"] = 0
                features[f"ask_price_{i}"] = 0
        
        # ปริมาณสะสม
        cum_bid_vol = 0
        cum_ask_vol = 0
        for i in range(levels):
            cum_bid_vol += features.get(f"bid_vol_{i}", 0)
            cum_ask_vol += features.get(f"ask_vol_{i}", 0)
            features[f"cum_bid_vol_{i}"] = cum_bid_vol
            features[f"cum_ask_vol_{i}"] = cum_ask_vol
        
        return features
    
    def create_features(self, order_book_history):
        """สร้าง features ทั้งหมดจากประวัติ Order Book"""
        if len(order_book_history) < self.window_size + 1:
            print("⚠️ ข้อมูลไม่เพียงพอ")
            return None, None
            
        df = pd.DataFrame(order_book_history)
        
        # Features พื้นฐาน
        features_list = []
        
        for i in range(self.window_size, len(df)):
            window = df.iloc[i-self.window_size:i]
            current = df.iloc[i]
            
            features = {}
            
            # ค่าเฉลี่ยในช่วง window
            features["avg_bid_volume"] = window["bid_volume"].mean()
            features["avg_ask_volume"] = window["ask_volume"].mean()
            features["std_bid_volume"] = window["bid_volume"].std()
            features["std_ask_volume"] = window["ask_volume"].std()
            
            # Volume Imbalance
            features["volume_imbalance"] = current["volume_imbalance"]
            features["avg_imbalance"] = window["volume_imbalance"].mean()
            
            # Spread
            features["spread"] = current["spread"]
            features["spread_pct"] = current["spread_pct"]
            features["avg_spread"] = window["spread"].mean()
            
            # Mid Price
            features["mid_price"] = current["mid_price"]
            features["price_change"] = current["mid_price"] - window["mid_price"].iloc[0]
            features["price_velocity"] = features["price_change"] / self.window_size
            
            # Order Book Depth
            depth_features = self.calculate_depth_features(current)
            features.update(depth_features)
            
            features_list.append(features)
        
        features_df = pd.DataFrame(features_list)
        
        # Target: ทิศทางราคาใน 5 นาทีข้างหน้า
        # 1 = ราคาขึ้น, 0 = ราคาคงที่, -1 = ราคาลง
        prices = df["mid_price"].values[self.window_size:]
        future_prices = df["mid_price"].values[self.window_size:]
        
        targets = []
        for i in range(len(prices)):
            if i + 5 < len(future_prices):
                change = future_prices[i + 5] - prices[i]
                if change > 0.001:  # ขึ้นมากกว่า 0.1%
                    targets.append(1)
                elif change < -0.001:  # ลงมากกว่า 0.1%
                    targets.append(-1)
                else:
                    targets.append(0)
            else:
                targets.append(0)
        
        return features_df, np.array(targets)
    
    def prepare_for_ml(self, features_df, targets):
        """เตรียมข้อมูลสำหรับโมเดล ML"""
        # แทนที่ NaN ด้วย 0
        features_df = features_df.fillna(0)
        
        # แปลงเป็น numpy array
        X = features_df.values
        
        # Normalize
        X = self.scaler.fit_transform(X)
        
        return X, targets


ทดสอบ

if __name__ == "__main__":
    # สมมติว่าเราเก็บข้อมูล Order Book ไว้แล้ว
    # order_book_history = [...] 
    
    # สร้าง features
    fe = OrderBookFeatureEngineering(window_size=10)
    
    print("✅ Feature Engineering พร้อมใช้งาน")
    print(f"📊 จำนวน features: {len(fe.calculate_depth_features({}, 5)) + 10}")

สร้างโมเดล Deep Learning ด้วย TensorFlow

ตอนนี้ข้อมูลพร้อมแล้ว มาสร้างโมเดล Deep Learning กัน! ผมจะใช้ LSTM (Long Short-Term Memory) ซึ่งเหมาะกับข้อมูลที่มีลำดับเวลา เช่น Order Book

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.optimizers import Adam

class OrderBookPredictor:
    """โมเดล Deep Learning สำหรับทำนาย Order Book"""
    
    def __init__(self, input_shape):
        self.input_shape = input_shape
        self.model = None
        self.history = None
        
    def build_lstm_model(self):
        """สร้าง LSTM model"""
        model = Sequential([
            # LSTM Layer 1
            LSTM(128, return_sequences=True, input_shape=self.input_shape),
            BatchNormalization(),
            Dropout(0.3),
            
            # LSTM Layer 2
            LSTM(64, return_sequences=False),
            BatchNormalization(),
            Dropout(0.3),
            
            # Dense Layers
            Dense(64, activation='relu'),
            Dropout(0.2),
            Dense(32, activation='relu'),
            
            # Output Layer (3 classes: ขึ้น, ลง, คงที่)
            Dense(3, activation='softmax')
        ])
        
        # Compile
        model.compile(
            optimizer=Adam(learning_rate=0.001),
            loss='sparse_categorical_crossentropy',
            metrics=['accuracy']
        )
        
        self.model = model
        return model
    
    def build_cnn_lstm_model(self):
        """สร้าง CNN-LSTM model (ทำงานได้ดีกับข้อมูลลำดับ)"""
        model = Sequential([
            # Conv1D Layer
            tf.keras.layers.Conv1D(64, 3, activation='relu', input_shape=self.input_shape),
            tf.keras.layers.MaxPooling1D(2),
            
            # LSTM Layers
            LSTM(64, return_sequences=True),
            LSTM(32),
            
            # Dense Layers
            Dense(32, activation='relu'),
            Dropout(0.2),
            Dense(3, activation='softmax')
        ])
        
        model.compile(
            optimizer=Adam(learning_rate=0.001),
            loss='sparse_categorical_crossentropy',
            metrics=['accuracy']
        )
        
        self.model = model
        return model
    
    def train(self, X_train, y_train, X_val, y_val, epochs=50, batch_size=32):
        """เทรนโมเดล"""
        
        # Callbacks
        early_stop = EarlyStopping(
            monitor='val_loss',
            patience=10,
            restore_best_weights=True
        )
        
        reduce_lr = ReduceLROnPlateau(
            monitor='val_loss',
            factor=0.5,
            patience=5,
            min_lr=0.0001
        )
        
        # Train
        self.history = self.model.fit(
            X_train, y_train,
            validation_data=(X_val, y_val),
            epochs=epochs,
            batch_size=batch_size,
            callbacks=[early_stop, reduce_lr],
            verbose=1
        )
        
        return self.history
    
    def evaluate(self, X_test, y_test):
        """ประเมินผลโมเดล"""
        results = self.model.evaluate(X_test, y_test, verbose=0)
        
        # ทำนาย
        y_pred = self.model.predict(X_test, verbose=0)
        y_pred_classes = np.argmax(y_pred, axis=1)
        
        # Classification Report
        from sklearn.metrics import classification_report, confusion_matrix
        
        print("\n📊 ผลการประเมิน:")
        print(f"   Loss: {results[0]:.4f}")
        print(f"   Accuracy: {results[1]:.4f}")
        
        print("\n📋 Classification Report:")
        print(classification_report(y_test, y_pred_classes, 
                                   target_names=['ลง', 'คงที่', 'ขึ้น']))
        
        print("\n📉 Confusion Matrix:")
        print(confusion_matrix(y_test, y_pred_classes))
        
        return results
    
    def save_model(self, path="orderbook_model.h5"):
        """บันทึกโมเดล"""
        self.model.save(path)
        print(f"✅ โมเดลถูกบันทึกที่: {path}")
    
    def load_model(self, path="orderbook_model.h5"):
        """โหลดโมเดล"""
        self.model = tf.keras.models.load_model(path)
        print(f"✅ โหลดโมเดลจาก: {path}")


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

if __name__ == "__main__":
    # สมมติว่ามีข้อมูล X, y แล้ว
    # X shape = (samples, timesteps, features)
    
    print("🏗️ สร้างโมเดล...")
    predictor = OrderBookPredictor(input_shape=(10, 30))  # (timesteps, features)
    
    # เลือกโมเดลที่ต้องการ
    predictor.build_lstm_model()
    # หรือ predictor.build_cnn_lstm_model()
    
    print("\n📋 โครงสร้างโมเดล:")
    predictor.model.summary()

รวมทุกอย่างเข้าด้วยกัน - โปรแกรม hoàn chỉnh

# main.py - โปรแกรมหลักสำหรับทำนาย Order Book

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import json


Import classes จากไฟล์อื่น


from binance_orderbook import BinanceOrderBook


from feature_engineering import OrderBookFeatureEngineering


from model import OrderBookPredictor


def main():
    print("=" * 60)
    print("🔮 Binance Order Book Prediction with Deep Learning")
    print("=" * 60)
    
    # 1️⃣ ดึงข้อมูล
    print("\n[1/4] 📡 ดึงข้อมูล Order Book...")
    ob = BinanceOrderBook(symbol="BTCUSDT", limit=100)
    order_book_history = ob.collect_historical(iterations=200, delay=0.5)
    
    # บันทึกข้อมูล
    with open("orderbook_data.json", "w") as f:
        json.dump([dict(d) for d in order_book_history], f)
    print("💾 ข้อมูลถูกบันทึกที่ orderbook_data.json")
    
    # 2️⃣ สร้าง Features
    print("\n[2/4] 🔧 สร้าง Features...")
    fe = OrderBookFeatureEngineering(window_size=10)
    features_df, targets = fe.create_features(order_book_history)
    X, y = fe.prepare_for_ml(features_df, targets)
    
    # Reshape สำหรับ LSTM (samples, timesteps, features)
    X = X.reshape(X.shape[0], 1, X.shape[1])
    
    print(f"   📊 ข้อมูลทั้งหมด: {X.shape[0]} ตัวอย่าง")
    print(f"   Features: {X.shape[2]} รายการ")
    print(f"   การกระจายของ Target:")
    print(f"   - ราคาลง: {np.sum(y == -1)} ({np.sum(y == -1)/len(y)*100:.1f}%)")
    print(f"   - ราคาคงที่: {np.sum(y == 0)} ({np.sum(y == 0)/len(y)*100:.1f}%)")
    print(f"   - ราคาขึ้น: {np.sum(y == 1)} ({np.sum(y == 1)/len(y)*100:.1f}%)")
    
    #

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