ในโลกของ High-Frequency Trading และ Cryptocurrency Market Making การมีข้อมูล Order Book ที่แม่นยำและรวดเร็วคือกุญแจสำคัญในการสร้าง стратегия ที่ทำกำไรได้ บทความนี้จะพาคุณเรียนรู้การใช้ Tardis Order Book API ร่วมกับ HolySheep AI สำหรับการ Backtest และ Optimize Market Making Strategy อย่างมีประสิทธิภาพ

Tardis Order Book คืออะไร

Tardis เป็นบริการที่ให้ข้อมูล Market Data คุณภาพสูงสำหรับ Cryptocurrency exchanges โดยเฉพาะ Order Book data ที่มีความละเอียดถึงระดับ Tick-by-Tick ทำให้นักเทรดและ Algo Traders สามารถวิเคราะห์และสร้าง Backtest ที่แม่นยำได้

ข้อมูลที่ Tardis ให้บริการ

- **Level 2 Order Book**: ข้อมูล Bid/Ask ทุกระดับราคา - **Trade Data**: รายละเอียดของทุก Transaction - **Funding Rate**: อัตราการ Funding สำหรับ Perpetual Futures - **Liquidation Data**: ข้อมูลการ Liquidation - **Insurance Fund**: สถานะของ Insurance Fund

ตารางเปรียบเทียบบริการ API สำหรับ Market Making

| คุณสมบัติ | HolySheep AI | API อย่างเป็นทางการ | บริการรีเลย์ทั่วไป | |-----------|---------------|----------------------|-------------------| | **ราคาเฉลี่ยต่อ 1M tokens** | $0.42 - $15 | $15 - $60 | $3 - $25 | | **ความเร็ว Latency** | < 50ms | 100-300ms | 80-200ms | | **ฟรีเครดิตเมื่อสมัคร** | ✅ มี | ❌ ไม่มี | ❌ บางเจ้า | | **วิธีการชำระเงิน** | WeChat/Alipay, USD | บัตรเครดิตเท่านั้น | หลากหลาย | | **อัตราแลกเปลี่ยน** | ¥1 = $1 (ประหยัด 85%+) | อัตราปกติ | อัตราปกติ | | **Support ไทย** | ✅ มี | ❌ ไม่มี | จำกัด | | **Uptime** | 99.9% | 99.5% | 95-99% | | **Model ล่าสุด** | GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2 | ขึ้นกับผู้ให้บริการ | จำกัด | จากตารางจะเห็นได้ว่า HolySheep AI ให้ความคุ้มค่าสูงสุดสำหรับนักพัฒนาที่ต้องการใช้งาน API สำหรับ Market Making Strategy

การตั้งค่า Environment และการเชื่อมต่อ

ขั้นตอนที่ 1: ติดตั้ง Dependencies

# ติดตั้ง Python packages ที่จำเป็น
pip install pandas numpy requests asyncio aiohttp
pip install tardis_client  # Tardis API Client
pip install holyapi        # HolySheep AI SDK (ถ้ามี)


หรือติดตั้งทุกอย่างในคำสั่งเดียว

pip install pandas numpy requests asyncio aiohttp tardis_client holyapi

ขั้นตอนที่ 2: การกำหนดค่า API Keys

import os
import json
from datetime import datetime


==== HolySheep AI Configuration ====

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # แทนที่ด้วย API Key จริงของคุณ


==== Tardis Configuration ====

TARDIS_API_KEY = "your_tardis_api_key"  # ลงทะเบียนที่ https://tardis.dev
TARDIS_EXCHANGE = "binance"  # exchanges: binance, bybit, okex, etc.
TARDIS_SYMBOL = "btcusdt"    # trading pair


==== Model Selection for Strategy Analysis ====


ราคาเป็น USD ต่อ 1M tokens (2026)

MODEL_PRICING = {
    "gpt-4.1": 8.00,
    "claude-sonnet-4.5": 15.00,
    "gemini-2.5-flash": 2.50,
    "deepseek-v3.2": 0.42
}

class Config:
    """คลาสสำหรับจัดการ Configuration ทั้งหมด"""
    
    def __init__(self):
        self.holysheep_base_url = HOLYSHEEP_BASE_URL
        self.holysheep_api_key = HOLYSHEEP_API_KEY
        self.tardis_api_key = TARDIS_API_KEY
        self.exchange = TARDIS_EXCHANGE
        self.symbol = TARDIS_SYMBOL
        self.model = "deepseek-v3.2"  # เลือกโมเดลที่คุ้มค่าที่สุด
        
    def get_model_cost(self, model_name: str) -> float:
        """ดึงราคาของโมเดลต่อ 1M tokens"""
        return MODEL_PRICING.get(model_name, 0.42)
        
    def validate_config(self) -> bool:
        """ตรวจสอบความถูกต้องของ Configuration"""
        if not self.holysheep_api_key or self.holysheep_api_key == "YOUR_HOLYSHEEP_API_KEY":
            print("⚠️  กรุณาตั้งค่า HolySheep API Key ก่อนใช้งาน")
            return False
        if not self.tardis_api_key or self.tardis_api_key == "your_tardis_api_key":
            print("⚠️  กรุณาตั้งค่า Tardis API Key ก่อนใช้งาน")
            return False
        return True


สร้าง instance ของ Config

config = Config()
print(f"✅ Configuration พร้อมใช้งาน")
print(f"   Base URL: {config.holysheep_base_url}")
print(f"   Model: {config.model}")
print(f"   Model Cost: ${config.get_model_cost(config.model)}/1M tokens")

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

import requests
import pandas as pd
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import asyncio

class TardisDataFetcher:
    """คลาสสำหรับดึงข้อมูล Order Book จาก Tardis API"""
    
    def __init__(self, api_key: str, exchange: str, symbol: str):
        self.api_key = api_key
        self.exchange = exchange
        self.symbol = symbol
        self.base_url = "https://api.tardis.dev/v1"
        
    def fetch_orderbook_snapshots(
        self, 
        start_date: datetime, 
        end_date: datetime,
        channels: List[str] = ["orderbook"]
    ) -> pd.DataFrame:
        """
        ดึงข้อมูล Order Book snapshots จาก Tardis
        
        Args:
            start_date: วันที่เริ่มต้น
            end_date: วันที่สิ้นสุด
            channels: ช่องข้อมูลที่ต้องการ (orderbook, trades, funding)
        """
        
        # สร้าง request ไปยัง Tardis API
        url = f"{self.base_url}/export"
        
        # กำหนด payload สำหรับการ export
        payload = {
            "exchange": self.exchange,
            "symbol": self.symbol,
            "datatypes": channels,
            "from": start_date.isoformat(),
            "to": end_date.isoformat(),
            "format": "csv"
        }
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        print(f"📡 กำลังดึงข้อมูลจาก Tardis...")
        print(f"   Exchange: {self.exchange}")
        print(f"   Symbol: {self.symbol}")
        print(f"   ช่วงเวลา: {start_date} ถึง {end_date}")
        
        # ทำ request
        response = requests.post(url, json=payload, headers=headers)
        
        if response.status_code == 200:
            # ดาวน์โหลด CSV data
            data = pd.read_csv(pd.io.common.BytesIO(response.content))
            print(f"✅ ดึงข้อมูลสำเร็จ: {len(data)} records")
            return data
        else:
            print(f"❌ เกิดข้อผิดพลาด: {response.status_code}")
            print(f"   {response.text}")
            return pd.DataFrame()
    
    def fetch_trades(self, start_date: datetime, end_date: datetime) -> pd.DataFrame:
        """ดึงข้อมูล Trade history"""
        return self.fetch_orderbook_snapshots(
            start_date, 
            end_date, 
            channels=["trades"]
        )
    
    def calculate_orderbook_features(self, df: pd.DataFrame) -> pd.DataFrame:
        """
        คำนวณ Features ต่างๆ จาก Order Book data
        สำหรับใช้ใน Market Making Strategy
        """
        
        print("🔧 กำลังคำนวณ Order Book Features...")
        
        # กรองเฉพาะ Order Book data
        if 'type' in df.columns:
            orderbook_df = df[df['type'] == 'orderbook'].copy()
        else:
            orderbook_df = df.copy()
        
        # คำนวณ Order Book Imbalance
        if 'bidSize' in orderbook_df.columns and 'askSize' in orderbook_df.columns:
            orderbook_df['imbalance'] = (
                (orderbook_df['bidSize'] - orderbook_df['askSize']) / 
                (orderbook_df['bidSize'] + orderbook_df['askSize'])
            )
        
        # คำนวณ Spread
        if 'bidPrice' in orderbook_df.columns and 'askPrice' in orderbook_df.columns:
            orderbook_df['spread'] = orderbook_df['askPrice'] - orderbook_df['bidPrice']
            orderbook_df['spread_pct'] = (
                orderbook_df['spread'] / orderbook_df['askPrice'] * 100
            )
        
        # คำนวณ Mid Price
        if 'bidPrice' in orderbook_df.columns and 'askPrice' in orderbook_df.columns:
            orderbook_df['mid_price'] = (
                (orderbook_df['bidPrice'] + orderbook_df['askPrice']) / 2
            )
        
        # คำนวณ Order Book Depth
        depth_columns = [col for col in orderbook_df.columns if 'bid' in col.lower() or 'ask' in col.lower()]
        
        print(f"✅ คำนวณ Features สำเร็จ: {len(orderbook_df)} records")
        print(f"   Features ที่สร้าง: imbalance, spread, spread_pct, mid_price")
        
        return orderbook_df


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

if __name__ == "__main__":
    fetcher = TardisDataFetcher(
        api_key=TARDIS_API_KEY,
        exchange=TARDIS_EXCHANGE,
        symbol=TARDIS_SYMBOL
    )
    
    # ดึงข้อมูลย้อนหลัง 7 วัน
    end_date = datetime.now()
    start_date = end_date - timedelta(days=7)
    
    # ดึงข้อมูล (uncomment เมื่อมี API key จริง)
    # df = fetcher.fetch_orderbook_snapshots(start_date, end_date)
    # df_with_features = fetcher.calculate_orderbook_features(df)
    
    print("✅ ตัวอย่างการใช้งาน TardisDataFetcher")

สร้าง Market Making Strategy และ Backtest Engine

import numpy as np
from dataclasses import dataclass
from typing import Tuple, List, Optional
from enum import Enum

class OrderSide(Enum):
    """ประเภทของ Order"""
    BID = "bid"      # คำสั่งซื้อ (Long position)
    ASK = "ask"      # คำสั่งขาย (Short position)

@dataclass
class Order:
    """โครงสร้างข้อมูลของ Order"""
    order_id: str
    side: OrderSide
    price: float
    quantity: float
    timestamp: datetime
    
@dataclass
class MarketMakingConfig:
    """Configuration สำหรับ Market Making Strategy"""
    spread_multiplier: float = 1.5      # คูณด้วย spread เฉลี่ย
    order_refresh_time: int = 5         # วินาที
    min_spread_bps: float = 5.0         # spread ขั้นต่ำ (basis points)
    max_position_size: float = 1.0     # ขนาด position สูงสุด
    inventory_target: float = 0.0      # inventory เป้าหมาย
    
class MarketMakingStrategy:
    """
    Market Making Strategy ที่ใช้ Order Book data
    สำหรับการวาง Bid/Ask orders และทำกำไรจาก Spread
    """
    
    def __init__(self, config: MarketMakingConfig):
        self.config = config
        self.active_orders: List[Order] = []
        self.position = 0.0  # ปัจจุบัน position
        self.cash = 0.0      # เงินสด
        self.trades: List[dict] = []
        
    def calculate_order_prices(self, mid_price: float, spread: float) -> Tuple[float, float]:
        """
        คำนวณราคาสำหรับวาง Bid และ Ask orders
        
        Args:
            mid_price: ราคากลาง
            spread: Spread ปัจจุบัน
            
        Returns:
            (bid_price, ask_price)
        """
        
        # ใช้ spread ที่ปรับแล้ว
        adjusted_spread = max(
            spread * self.config.spread_multiplier,
            mid_price * self.config.min_spread_bps / 10000
        )
        
        bid_price = mid_price - adjusted_spread / 2
        ask_price = mid_price + adjusted_spread / 2
        
        return bid_price, ask_price
    
    def should_place_order(
        self, 
        imbalance: float,
        volatility: float
    ) -> Tuple[bool, bool]:
        """
        ตัดสินใจว่าควรวาง Order หรือไม่
        
        Args:
            imbalance: Order book imbalance (-1 ถึง 1)
            volatility: Volatility ของตลาด
            
        Returns:
            (should_place_bid, should_place_ask)
        """
        
        # ถ้า Imbalance บวกมาก (Bid มากกว่า) ให้ระวังการ place ask
        should_place_ask = imbalance < 0.3 and self.position < self.config.max_position_size
        
        # ถ้า Imbalance ลบมาก (Ask มากกว่า) ให้ระวังการ place bid  
        should_place_bid = imbalance > -0.3 and self.position > -self.config.max_position_size
        
        # ถ้า Volatility สูงเกินไป ให้หยุดการเทรด
        if volatility > 0.05:  # 5% volatility threshold
            return False, False
            
        return should_place_bid, should_place_ask
    
    def execute_order(
        self, 
        side: OrderSide, 
        price: float, 
        quantity: float,
        timestamp: datetime
    ) -> dict:
        """
        Execute Order และอัปเดต Position
        
        Args:
            side: ฝั่งของ Order
            price: ราคา
            quantity: ปริมาณ
            timestamp: เวลาที่ execute
            
        Returns:
            Trade execution details
        """
        
        order_id = f"{timestamp.isoformat()}_{side.value}_{price}"
        
        if side == OrderSide.BID:
            # ซื้อ - เพิ่ม position และลด cash
            self.position += quantity
            self.cash -= price * quantity
        else:
            # ขาย - ลด position และเพิ่ม cash
            self.position -= quantity
            self.cash += price * quantity
            
        order = Order(order_id, side, price, quantity, timestamp)
        self.active_orders.append(order)
        
        trade = {
            'order_id': order_id,
            'side': side.value,
            'price': price,
            'quantity': quantity,
            'timestamp': timestamp,
            'position': self.position,
            'cash': self.cash
        }
        
        self.trades.append(trade)
        
        return trade
    
    def calculate_pnl(self) -> dict:
        """คำนวณกำไร/ขาดทุน"""
        
        if not self.trades:
            return {'total_pnl': 0, 'realized_pnl': 0, 'unrealized_pnl': 0}
            
        total_trades = len(self.trades)
        buy_value = sum(
            t['price'] * t['quantity'] 
            for t in self.trades if t['side'] == 'bid'
        )
        sell_value = sum(
            t['price'] * t['quantity'] 
            for t in self.trades if t['side'] == 'ask'
        )
        
        realized_pnl = sell_value - buy_value
        
        # Unrealized P&L = Position * (Current Price - Avg Buy Price)
        if self.position != 0:
            avg_buy_price = buy_value / sum(
                t['quantity'] for t in self.trades if t['side'] == 'bid'
            ) if buy_value > 0 else 0
            unrealized_pnl = self.position * avg_buy_price
        else:
            unrealized_pnl = 0
            
        total_pnl = realized_pnl + unrealized_pnl
        
        return {
            'total_pnl': total_pnl,
            'realized_pnl': realized_pnl,
            'unrealized_pnl': unrealized_pnl,
            'total_trades': total_trades,
            'position': self.position,
            'cash': self.cash
        }


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

config = MarketMakingConfig(
    spread_multiplier=1.5,
    order_refresh_time=5,
    min_spread_bps=5.0,
    max_position_size=1.0
)

strategy = MarketMakingStrategy(config)


ทดสอบการคำนวณ

mid_price = 50000.0
spread = 10.0

bid_price, ask_price = strategy.calculate_order_prices(mid_price, spread)
print(f"📊 Mid Price: ${mid_price:,.2f}")
print(f"📊 Spread: ${spread:,.2f}")
print(f"📊 Bid Price: ${bid_price:,.2f}")
print(f"📊 Ask Price: ${ask_price:,.2f}")


ทดสอบการ execute order

trade = strategy.execute_order(
    OrderSide.BID, 
    price=bid_price, 
    quantity=0.1, 
    timestamp=datetime.now()
)
print(f"\n✅ Trade Executed:")
print(f"   Order ID: {trade['order_id']}")
print(f"   Side: {trade['side']}")
print(f"   Price: ${trade['price']:,.2f}")
print(f"   Quantity: {trade['quantity']}")

pnl = strategy.calculate_pnl()
print(f"\n💰 P&L Summary:")
print(f"   Total PnL: ${pnl['total_pnl']:,.2f}")
print(f"   Position: {pnl['position']}")
print(f"   Cash: ${pnl['cash']:,.2f}")

Backtest Engine สำหรับ Market Making Strategy

import pandas as pd
import numpy as np
from typing import List, Dict, Optional
from dataclasses import dataclass, field
import json

@dataclass
class BacktestResult:
    """ผลลัพธ์ของ Backtest"""
    total_pnl: float
    sharpe_ratio: float
    max_drawdown: float
    win_rate: float
    total_trades: int
    avg_spread_captured: float
    execution_latency_ms: float
    
    def to_dict(self) -> dict:
        return {
            'total_pnl': self.total_pnl,
            'sharpe_ratio': self.sharpe_ratio,
            'max_drawdown': self.max_drawdown,
            'win_rate': self.win_rate,
            'total_trades': self.total_trades,
            'avg_spread_captured': self.avg_spread_captured,
            'execution_latency_ms': self.execution_latency_ms
        }

class BacktestEngine:
    """
    Backtest Engine สำหรับทดสอบ Market Making Strategy
    โดยใช้ข้อมูล Order Book จาก Tardis
    """
    
    def __init__(self, strategy: MarketMakingStrategy):
        self.strategy = strategy
        self.trade_history: List[dict] = []
        self.equity_curve: List[float] = []
        self.daily_pnl: List[float] = []
        
    def run_backtest(
        self, 
        orderbook_data: pd.DataFrame,
        initial_capital: float = 100000.0,
        simulate_latency: bool = True
    ) -> BacktestResult:
        """
        Run Backtest ด้วยข้อมูล Order Book
        
        Args:
            orderbook_data: DataFrame ที่มี columns: timestamp, mid_price, spread, imbalance
            initial_capital: เงินทุนเริ่มต้น
            simulate_latency: จำลอง latency หรือไม่
            
        Returns:
            BacktestResult object
        """
        
        print("🚀 เริ่มกระบวนการ Backtest...")
        print(f"   จำนวน Records: {len(orderbook_data)}")
        print(f"   เงินทุนเริ่มต้น: ${initial_capital:,.2f}")
        
        # Reset strategy state
        self.strategy.position = 0.0
        self.strategy.cash = initial_capital
        self.strategy.trades = []
        
        self.trade_history = []
        self.equity_curve = []
        
        # Simulation parameters
        avg_latency_list = []
        
        for idx, row in orderbook_data.iterrows():
            timestamp = row['timestamp'] if 'timestamp' in row else pd.Timestamp(idx)
            mid_price = row['mid_price']
            spread = row['spread']
            imbalance = row['imbalance']
            
            # จำลอง Latency (ถ้าเปิดใช้งาน)
            if simulate_latency:
                latency_ms = np.random.normal(50, 10)  # avg 50ms, std 10ms
                avg_latency_list.append(latency_ms)
                
                # ปรับราคาตาม latency (price slippage)
                slippage = spread * (latency_ms / 1000) * 0.01
            else:
                latency_ms = 0
                slippage = 0
            
            # คำนวณราคา Bid/Ask
            bid_price, ask_price = self.strategy.calculate_order_prices(mid_price, spread)
            
            # ตรวจสอบว่าควรวาง Order หรือไม่
            volatility = row.get('volatility', 0.01)
            should_bid, should_ask = self.strategy.should_place_order(imbalance, volatility)
            
            # Execute Orders
            if should_bid and self.strategy.position > -self.strategy.config.max_position_size:
                # Simulate ว่า Order ถูก filled
                if np.random.random() > 0.3:  # 70% fill rate
                    trade = self.strategy.execute_order(
                        OrderSide.BID,
                        bid_price - slippage,  # ราคาหลัง slippage
                        0.01,  # quantity
                        timestamp
                    )
                    trade['latency_ms'] = latency_ms
                    self.trade_history.append(trade)
            
            if should_ask and self.strategy.position < self.strategy.config.max_position_size:
                if np.random.random() > 0.3:  # 70% fill rate
                    trade = self.strategy.execute_order(
                        OrderSide.ASK,
                        ask_price + slippage,
                        0.01,
                        timestamp
                    )
                    trade['latency_ms'] = latency_ms
                    self.trade_history.append(trade)
            
            # คำนวณ Equity
            current_equity = self.strategy.cash + self.strategy.position * mid_price
            self.equity_curve.append(current_equity)
        
        # คำนวณผลลัพธ์
        result = self._calculate_results(avg_latency_list, initial_capital)
        
        print(f"\n✅ Backtest เสร็จสมบูรณ์!")
        print(f"   Total PnL: ${result.total_pnl:,.2f}")
        print(f"   Sharpe Ratio: {result.sharpe_ratio:.2f}")
        print(f"   Max Drawdown: {result.max_drawdown:.2%}")
        print(f"   Win Rate: {result.win_rate:.2%}")
        print(f"   Total Trades: {result.total_trades}")
        print(f"   Avg Latency: {result.execution_latency_ms:.2f}ms")
        
        return result
    
    def _calculate_results(
        self, 
        latency_list: List[float],
        initial_capital: float
    ) -> BacktestResult:
        """คำนวณผลลัพธ์ของ Backtest"""
        
        pnl_dict = self.strategy.calculate_pnl()
        
        # คำนวณ Sharpe Ratio
        equity_series = pd.Series(self.equity_curve)
        returns = equity_series.pct_change().dropna()
        sharpe_ratio = (returns.mean() / returns.std() * np.sqrt(252)) if returns.std() > 0 else 0
        
        # คำนวณ Max Drawdown
        rolling_max = equity_series.expanding().max()
        drawdown = (equity_series - rolling_max) / rolling_max
        max_drawdown = abs(drawdown.min())
        
        # คำนวณ Win Rate
        total_trades = len(self.trade_history)
        if total_trades > 0:
            winning_trades = sum(
                1 for t in self.trade_history 
                if (t['side'] == 'ask' and self.strategy.position <= 0) or
                   (t['side'] == 'bid' and self.strategy.position >= 0)
            )
            win_rate = winning_trades / total_trades
        else:
            win_rate = 0
        
        # คำนวณ Avg Spread Captured
        spreads_captured = [
            t['price'] * t['quantity'] * 0.001  # ประมาณ 0.1% ของ trade value
            for t in self.trade_history
        ]
        avg_spread = np.mean(spreads_captured) if spreads_captured else 0
        
        # คำนวณ Avg Latency
        avg_latency = np.mean(latency_list) if latency_list else 0
        
        return BacktestResult(
            total_pnl=pnl_dict['total_pnl'],
            sharpe_ratio=sharpe_ratio,
            max_drawdown=max_drawdown,
            win_rate=win_rate,
            total_trades=total_trades,
            avg_spread_captured=avg_spread,
            execution_latency_ms=avg_latency
        )
    
    def optimize_parameters(
        self,
        orderbook_data: pd.DataFrame,
        param_grid: Dict[str, List]
    ) -> Dict:
        """
        Optimize Strategy Parameters โดยใช้ Grid Search
        
        Args:
            orderbook_data: ข้อมูลสำหรับ Backtest
            param_grid: Dictionary ของ parameters ที่จะ test
            
        Returns:
            Best parameters และ results
        """
        
        print("🔍 เริ่มกระบวนการ Parameter Optimization...")
        print(f"   Parameter Grid: {param_grid}")
        
        best_result = None
        best_params = None
        best_sharpe = -999
        
        results_list = []
        
        # Generate all combinations
        from itertools import product
        param_names = list(param_grid.keys())
        param_values = list(param_grid.values())
        
        total_combinations = 1
        for values in param_values:
            total_combinations *= len(values)
        
        print(f"   Total Combinations: {total_combinations}")
        
        for idx, combination in enumerate(product(*param_values)):
            params = dict(zip(param_names, combination))
            
            # Update strategy config
            self.strategy.config = MarketMakingConfig(
                spread_multiplier=

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