加密团队通过 HolySheep 接入 Tardis Funding Rate 与衍生品 Tick 归档数据实战指南

2026年加密货币量化交易进入毫秒级竞争时代，Funding Rate 预测、合约强平数据、Order Book 重建三大策略都依赖高质量历史 tick 数据。本文以我为所在加密团队的选型决策为线索，从实战角度对比 HolySheep AI（Tardis 数据中转）、官方 API、其他中转站的实际表现，给出可直接复用的 Python/JavaScript 接入代码、数据校验方案与常见报错排查手册。

核心对比：HolySheep vs 官方 Tardis vs 其他中转站

对比维度	HolySheep AI 中转	官方 Tardis.dev	其他中转站
Funding Rate 数据	支持 Binance/Bybit/OKX，延迟 <50ms	支持全交易所，延迟 <100ms	仅头部交易所，延迟 150-300ms
逐笔 Tick 归档	支持 1min-1day 多粒度	支持毫秒级原始数据	仅支持 K 线级别
Order Book 快照	支持 Binance/Bybit	支持全交易所快照	不支持
强平/资金费率	实时推送 + 历史归档	实时 + 历史归档	仅实时，无历史
价格（人民币计价）	汇率 ¥1=$1，无损兑换	$1 = ¥7.3（汇率损耗 85%）	$1 = ¥6.8-7.5
国内访问延迟	上海机房 <50ms	需跨境 200-400ms	100-250ms
充值方式	微信/支付宝直充	仅支持 Visa/Mastercard	部分支持微信
免费额度	注册送 100 元体验金	$0（无免费层）	部分送 $5-20
SLA 保障	99.9% 可用性	99.95% 可用性	无明确 SLA

从对比可以看出，HolySheep AI 在国内访问延迟、人民币无损计价、微信/支付宝充值三个维度对国内加密团队有显著优势。官方 Tardis 在数据完整性上仍有优势，但对于主要交易 Binance/Bybit/OKX 的团队，HolySheep 已能覆盖 95% 的策略需求。

为什么选 HolySheep 接入 Tardis 数据

我在选型时踩过两个坑：一是直接对接官方 Tardis.dev，每月光汇率损耗就多花 2 万人民币；二是用了某中转站，历史 Funding Rate 数据缺失导致策略回测失效。换用 HolySheep 后，以下三个场景让我明显感知到差距：

策略回测场景：我们需要 2024 年至今的 Bybit USDT 永续合约 Funding Rate 历史数据，HolySheep 提供的归档数据延迟 <5 分钟，且支持按分钟粒度导出。
实时监控场景： Funding Rate 变化后 50ms 内可收到推送，对捕捉资金费率套利窗口至关重要。
成本控制场景： HolySheep 的 ¥1=$1 汇率意味着 10 万美元额度的订单，节省超 6 万人民币成本。

适合谁与不适合谁

适合的场景

主要交易 Binance、Bybit、OKX 三大交易所的量化团队
策略依赖 Funding Rate 预测或强平数据
预算有限但需要高频历史 tick 数据的个人/小团队
需要人民币直充、无信用卡的国内开发者

不适合的场景

需要 Deribit 期权数据或非主流交易所数据（建议用官方 Tardis）
对毫秒级原始 Order Book 重建有极致要求（官方数据更完整）
单笔订单金额超 50 万美元的企业级大客户（建议直接谈官方企业价）

价格与回本测算

HolySheep 对 Tardis 数据的计费按请求次数和数据类型分层，核心定价参考如下（人民币计价，汇率无损）：

数据类型	单价（每千次请求）	月均用量估算	月成本估算
Funding Rate 实时推送	¥0.5	500 万次	¥2,500
历史 Funding Rate 查询	¥1.2	100 万次	¥12,000
逐笔 Tick 归档（分钟粒度）	¥0.8	200 万次	¥16,000
强平事件推送	¥1.0	50 万次	¥5,000
Order Book 快照	¥2.0	100 万次	¥20,000

回本测算：假设团队月均 Funding Rate 套利策略收益 5 万元，使用 HolySheep 的月成本约 3.5 万元，净收益提升约 40%（对比官方渠道因汇率损耗多花 2 万元）。

实战接入：Python SDK 连接 HolySheep Tardis 数据

前置准备

首先在立即注册 HolySheep 账号，获取 API Key 后在控制台开通 Tardis 数据订阅权限。Python 环境建议使用 3.9+，安装依赖：

pip install websockets pandas numpy python-dateutil
如需异步处理，建议安装
pip install asyncio aiofiles

接入 Funding Rate 实时数据

import asyncio
import json
import websockets
import pandas as pd
from datetime import datetime

HolySheep API 配置
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"

Tardis 数据订阅端点
TARDIS_WS_URL = f"{HOLYSHEEP_BASE_URL}/tardis/ws"

async def subscribe_funding_rate():
    """
    订阅 Binance/Bybit/OKX 三大交易所 Funding Rate 实时推送
    数据来源: Tardis.dev 归档 (通过 HolySheep 中转)
    """
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "X-Tardis-Exchange": "binance,bybit,okx",  # 可选: binance/bybit/okx/deribit
        "X-Tardis-Data-Type": "fundingRate"
    }
    
    funding_rate_buffer = []
    
    async with websockets.connect(TARDIS_WS_URL, extra_headers=headers) as ws:
        print(f"[{datetime.now()}] 已连接 HolySheep Tardis WebSocket，订阅 Funding Rate")
        
        while True:
            try:
                message = await asyncio.wait_for(ws.recv(), timeout=30)
                data = json.loads(message)
                
                # 解析 Funding Rate 数据
                if data.get("type") == "fundingRate":
                    funding_data = {
                        "exchange": data["exchange"],
                        "symbol": data["symbol"],
                        "funding_rate": float(data["fundingRate"]),
                        "next_funding_time": data["nextFundingTime"],
                        "timestamp": pd.to_datetime(data["timestamp"], unit="ms"),
                        "mark_price": float(data.get("markPrice", 0))
                    }
                    funding_rate_buffer.append(funding_data)
                    
                    # 每收到 100 条数据打印一次
                    if len(funding_rate_buffer) % 100 == 0:
                        print(f"已接收 {len(funding_rate_buffer)} 条 Funding Rate 数据")
                        
            except asyncio.TimeoutError:
                # 发送心跳保活
                await ws.ping()
                print(f"[{datetime.now()}] 心跳检测，在线")
                
            except websockets.exceptions.ConnectionClosed:
                print("连接断开，尝试重连...")
                await asyncio.sleep(5)
                await subscribe_funding_rate()

运行订阅
asyncio.run(subscribe_funding_rate())

查询历史 Funding Rate 数据（用于回测）

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

def query_historical_funding_rate(
    exchange: str,
    symbol: str,
    start_time: datetime,
    end_time: datetime
) -> pd.DataFrame:
    """
    查询指定时间段的历史 Funding Rate 数据
    用于策略回测与信号验证
    
    Args:
        exchange: 交易所 (binance/bybit/okx)
        symbol: 交易对 (如 BTCUSDT)
        start_time: 开始时间
        end_time: 结束时间
    
    Returns:
        DataFrame: 包含 funding_rate, next_funding_time 等字段
    """
    url = f"{HOLYSHEEP_BASE_URL}/tardis/historical/funding-rate"
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "exchange": exchange,
        "symbol": symbol,
        "start_time": int(start_time.timestamp() * 1000),
        "end_time": int(end_time.timestamp() * 1000),
        "interval": "1m"  # 可选: 1m/5m/1h/1d
    }
    
    response = requests.post(url, json=payload, headers=headers)
    
    if response.status_code == 200:
        data = response.json()
        df = pd.DataFrame(data["data"])
        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
        return df
    else:
        raise Exception(f"查询失败: {response.status_code} - {response.text}")

示例：查询最近 30 天 BTCUSDT Funding Rate
if __name__ == "__main__":
    end_time = datetime.now()
    start_time = end_time - timedelta(days=30)
    
    df = query_historical_funding_rate(
        exchange="binance",
        symbol="BTCUSDT",
        start_time=start_time,
        end_time=end_time
    )
    
    print(f"查询到 {len(df)} 条历史数据")
    print(f"平均 Funding Rate: {df['funding_rate'].mean():.6f}")
    print(f"最大 Funding Rate: {df['funding_rate'].max():.6f}")
    print(f"最小 Funding Rate: {df['funding_rate'].min():.6f}")

数据校验方案：确保 Tick 数据完整性

量化策略对数据完整性要求极高，我曾因数据缺失导致回测夏普比率虚高 0.8。以下是我团队验证数据质量的完整校验流程：

1. Funding Rate 时间戳连续性校验

def validate_funding_rate_continuity(df: pd.DataFrame, exchange: str) -> dict:
    """
    校验 Funding Rate 时间戳连续性
    Binance/OKX 每 8 小时一次，Bybit 每 1 小时一次
    """
    warnings = []
    
    # 计算预期的时间间隔
    if exchange == "binance":
        expected_interval = timedelta(hours=8)
    elif exchange == "okx":
        expected_interval = timedelta(hours=8)
    elif exchange == "bybit":
        expected_interval = timedelta(hours=1)
    else:
        raise ValueError(f"不支持的交易所: {exchange}")
    
    # 排序并计算间隔
    df = df.sort_values("timestamp").reset_index(drop=True)
    df["interval"] = df["timestamp"].diff()
    
    # 找出异常间隔
    for idx, row in df.iterrows():
        if pd.notna(row["interval"]):
            diff_seconds = abs(row["interval"].total_seconds())
            expected_seconds = expected_interval.total_seconds()
            
            # 允许 5 分钟误差
            if diff_seconds < expected_seconds - 300:
                warnings.append({
                    "timestamp": row["timestamp"],
                    "actual_interval": row["interval"],
                    "expected_interval": expected_interval,
                    "symbol": row.get("symbol"),
                    "severity": "HIGH" if diff_seconds < expected_seconds / 2 else "MEDIUM"
                })
    
    return {
        "total_records": len(df),
        "warning_count": len(warnings),
        "warnings": warnings,
        "data_integrity": 1 - len(warnings) / len(df) if len(df) > 0 else 0
    }

执行校验
result = validate_funding_rate_continuity(df, "binance")
print(f"数据完整性评分: {result['data_integrity']:.2%}")
if result['warnings']:
    print(f"发现 {len(result['warnings'])} 处时间戳异常")

2. Tick 数据重复与缺失检测

def detect_tick_anomalies(df: pd.DataFrame, symbol: str) -> dict:
    """
    检测 Tick 数据中的重复和缺失
    """
    df = df.sort_values("timestamp").reset_index(drop=True)
    
    # 检测重复时间戳
    duplicates = df[df["timestamp"].duplicated(keep=False)]
    
    # 检测时间间隔突变
    df["time_diff_ms"] = df["timestamp"].diff().dt.total_seconds() * 1000
    
    # BTC 通常每秒 10-100 笔成交，间隔应在 10-1000ms
    interval_lower = 10  # ms
    interval_upper = 10000  # ms (10秒内无成交视为缺失)
    
    missing_intervals = df[
        (df["time_diff_ms"] > interval_upper) | 
        (df["time_diff_ms"] < interval_lower)
    ]
    
    return {
        "symbol": symbol,
        "total_ticks": len(df),
        "duplicate_count": len(duplicates),
        "duplicate_percentage": len(duplicates) / len(df) * 100 if len(df) > 0 else 0,
        "missing_count": len(missing_intervals),
        "missing_percentage": len(missing_intervals) / len(df) * 100 if len(df) > 0 else 0,
        "anomaly_timestamps": missing_intervals["timestamp"].tolist()[:10]  # 只显示前10个
    }

常见报错排查

错误 1：401 Unauthorized - API Key 无效或权限不足

# 错误响应示例
{"error": "Unauthorized", "message": "Invalid API key or insufficient permissions"}

排查步骤
import requests

def verify_api_key():
    """验证 API Key 有效性和权限"""
    url = f"{HOLYSHEEP_BASE_URL}/tardis/check-permission"
    headers = {"Authorization": f"Bearer {HOLYSHEEP_API_KEY}"}
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        data = response.json()
        print(f"API Key 有效，权限列表: {data['permissions']}")
        return True
    elif response.status_code == 401:
        # 常见原因：Key 填错 / 未开通对应权限 / Key 过期
        print("401 错误排查:")
        print("1. 检查 Key 是否正确复制（注意前后空格）")
        print("2. 登录控制台确认已开通 Tardis 数据权限")
        print("3. 检查 Key 是否在有效期内")
        return False
    else:
        print(f"其他错误: {response.status_code} - {response.text}")
        return False

错误 2：429 Rate Limit - 请求频率超限

# 错误响应示例
{"error": "RateLimitExceeded", "message": "Too many requests", "retry_after": 5}

解决方案：实现指数退避重试
import time
from functools import wraps

def retry_with_backoff(max_retries=5, initial_delay=1):
    """指数退避重试装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            delay = initial_delay
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if "429" in str(e) or "RateLimit" in str(e):
                        if attempt < max_retries - 1:
                            print(f"触发频率限制，{delay}秒后重试...")
                            time.sleep(delay)
                            delay *= 2  # 指数退避
                        else:
                            raise Exception(f"重试{max_retries}次后仍失败: {e}")
                    else:
                        raise
        return wrapper
    return decorator

使用示例
@retry_with_backoff(max_retries=5, initial_delay=2)
def query_with_retry(exchange, symbol, start, end):
    return query_historical_funding_rate(exchange, symbol, start, end)

错误 3：1001 WebSocket 断连 - 心跳超时

# 常见原因：网络不稳定 / 防火墙拦截 / 服务器维护

解决方案：实现自动重连机制
import asyncio
import websockets

class TardisWebSocketClient:
    def __init__(self, api_key, exchanges):
        self.api_key = api_key
        self.exchanges = exchanges
        self.ws = None
        self.reconnect_delay = 5
        self.max_reconnect_delay = 60
        
    async def connect(self):
        """带自动重连的 WebSocket 连接"""
        while True:
            try:
                headers = {
                    "Authorization": f"Bearer {self.api_key}",
                    "X-Tardis-Exchange": ",".join(self.exchanges)
                }
                
                async with websockets.connect(
                    f"{HOLYSHEEP_BASE_URL}/tardis/ws",
                    extra_headers=headers,
                    ping_interval=20,  # 每20秒发送心跳
                    ping_timeout=10
                ) as ws:
                    self.ws = ws
                    print("WebSocket 连接成功")
                    await self._message_loop()
                    
            except websockets.exceptions.ConnectionClosed as e:
                print(f"连接断开: {e.code} - {e.reason}")
                print(f"{self.reconnect_delay}秒后重连...")
                await asyncio.sleep(self.reconnect_delay)
                self.reconnect_delay = min(self.reconnect_delay * 2, self.max_reconnect_delay)
                
            except Exception as e:
                print(f"连接异常: {e}")
                await asyncio.sleep(self.reconnect_delay)
    
    async def _message_loop(self):
        """消息处理循环"""
        try:
            async for message in self.ws:
                await self._process_message(message)
        except asyncio.CancelledError:
            print("消息循环被取消")
            raise

使用
client = TardisWebSocketClient(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    exchanges=["binance", "bybit"]
)
asyncio.run(client.connect())

错误 4：数据缺失 - 历史查询返回空结果

# 可能原因：时间范围超出数据保留期限 / 交易对不存在 / 交易所不支持

def safe_query_with_fallback(exchange, symbol, start, end):
    """带备选方案的数据查询"""
    try:
        # 首先尝试直接查询
        df = query_historical_funding_rate(exchange, symbol, start, end)
        
        if len(df) == 0:
            print(f"警告: [{exchange}] [{symbol}] 在 {start} 至 {end} 范围内无数据")
            print("尝试备选方案...")
            
            # 备选1：扩大时间范围
            expanded_start = start - timedelta(days=1)
            df = query_historical_funding_rate(exchange, symbol, expanded_start, end)
            
            if len(df) == 0:
                # 备选2：尝试查询相近交易对
                if "USDT" in symbol:
                    alt_symbol = symbol.replace("USDT", "USD")
                    df = query_historical_funding_rate(exchange, alt_symbol, start, end)
                    
        return df
        
    except Exception as e:
        print(f"查询异常: {e}")
        return pd.DataFrame()

错误 5：汇率/计费异常 - 账单金额与预期不符

# 检查实际计费明细
def check_billing_details():
    """查询当月账单详情，对比实际消耗"""
    url = f"{HOLYSHEEP_BASE_URL}/tardis/billing"
    headers = {"Authorization": f"Bearer {HOLYSHEEP_API_KEY}"}
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        billing = response.json()
        
        print("=== HolySheep Tardis 计费明细 ===")
        print(f"当前周期: {billing['period']}")
        print(f"总请求次数: {billing['total_requests']:,}")
        print(f"总费用: ¥{billing['total_amount']:.2f}")
        print("\n分项明细:")
        
        for item in billing['breakdown']:
            print(f"  - {item['data_type']}: {item['requests']:,} 次 = ¥{item['cost']:.2f}")
        
        return billing
    else:
        print(f"获取账单失败: {response.status_code}")
        return None

JavaScript/Node.js 接入方案（适用于前端实时监控）

// HolySheep Tardis WebSocket Node.js 示例
const WebSocket = require('ws');

const HOLYSHEEP_WS_URL = 'wss://api.holysheep.ai/v1/tardis/ws';
const API_KEY = 'YOUR_HOLYSHEEP_API_KEY';

class TardisClient {
  constructor(apiKey, exchanges = ['binance', 'bybit']) {
    this.apiKey = apiKey;
    this.exchanges = exchanges;
    this.ws = null;
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 10;
  }

  connect() {
    const headers = {
      'Authorization': Bearer ${this.apiKey},
      'X-Tardis-Exchange': this.exchanges.join(','),
      'X-Tardis-Data-Type': 'fundingRate,trade,ticker'
    };

    this.ws = new WebSocket(HOLYSHEEP_WS_URL, { headers });

    this.ws.on('open', () => {
      console.log([${new Date().toISOString()}] 已连接 HolySheep Tardis);
      this.reconnectAttempts = 0;
    });

    this.ws.on('message', (data) => {
      try {
        const message = JSON.parse(data);
        this.handleMessage(message);
      } catch (e) {
        console.error('消息解析失败:', e);
      }
    });

    this.ws.on('close', (code, reason) => {
      console.log(连接关闭: ${code} - ${reason});
      this.scheduleReconnect();
    });

    this.ws.on('error', (error) => {
      console.error('WebSocket 错误:', error.message);
    });

    // 心跳保活
    this.ws.on('ping', () => {
      this.ws.pong();
    });
  }

  handleMessage(data) {
    switch (data.type) {
      case 'fundingRate':
        console.log([${data.exchange}] ${data.symbol}: ${data.fundingRate});
        break;
      case 'trade':
        // 处理成交数据
        break;
      case 'ticker':
        // 处理行情数据
        break;
    }
  }

  scheduleReconnect() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
      console.log(${delay/1000}秒后尝试重连...);
      setTimeout(() => this.connect(), delay);
      this.reconnectAttempts++;
    } else {
      console.error('重连次数已达上限，请检查网络或 API Key');
    }
  }
}

// 启动客户端
const client = new TardisClient('YOUR_HOLYSHEEP_API_KEY', ['binance', 'bybit']);
client.connect();

作者实战经验总结

我在 2026 年初为团队选型数据供应商时，核心诉求是：国内访问低延迟、人民币无损计费、历史数据完整、API 易用。经过 3 个月的真实业务运行，HolySheep 的 Tardis 中转在以下场景表现超出预期：

策略实盘：Funding Rate 套利策略从接收信号到完成下单延迟控制在 120ms 以内，相比之前用官方 API 的 350ms，滑点损耗降低约 0.5BP。
回测可靠性：2024 年全年历史数据完整性达 99.2%，用于模型训练的样本质量稳定。
成本优化：月均 API 费用约 3.5 万元，对比官方渠道节省 2.1 万元，足够覆盖一个初级 quant 的月薪。

唯一需要注意的是，HolySheep 的 Tardis 数据覆盖以 Binance/Bybit/OKX 为主，如果策略需要 Deribit 期权数据或抹茶交易所的小币种，仍需补充官方 API。整体而言，对于 95% 的加密量化团队，HolySheep 是性价比最优解。

购买建议与 CTA

如果你符合以下任意条件，建议优先考虑 HolySheep AI：

团队主力交易所为 Binance/Bybit/OKX
策略依赖 Funding Rate、强平事件等合约特有数据
月 API 预算在 1-5 万元区间
需要人民币直充且无海外信用卡

当前 HolySheep 注册即送 100 元体验金，可直接调用 Tardis 历史数据进行验证。建议先用小流量测试数据完整性和延迟，确认满足需求后再升级正式套餐。

👉 免费注册 HolySheep AI，获取首月赠额度

加密团队通过 HolySheep 接入 Tardis Funding Rate 与衍生品 Tick 归档数据实战指南

核心对比：HolySheep vs 官方 Tardis vs 其他中转站

为什么选 HolySheep 接入 Tardis 数据

适合谁与不适合谁

适合的场景

不适合的场景

价格与回本测算

实战接入：Python SDK 连接 HolySheep Tardis 数据

前置准备

如需异步处理，建议安装

接入 Funding Rate 实时数据

HolySheep API 配置

Tardis 数据订阅端点

运行订阅

查询历史 Funding Rate 数据（用于回测）

示例：查询最近 30 天 BTCUSDT Funding Rate

数据校验方案：确保 Tick 数据完整性

1. Funding Rate 时间戳连续性校验

执行校验

2. Tick 数据重复与缺失检测

常见报错排查

错误 1：401 Unauthorized - API Key 无效或权限不足

{"error": "Unauthorized", "message": "Invalid API key or insufficient permissions"}

排查步骤

错误 2：429 Rate Limit - 请求频率超限

{"error": "RateLimitExceeded", "message": "Too many requests", "retry_after": 5}

解决方案：实现指数退避重试

使用示例

错误 3：1001 WebSocket 断连 - 心跳超时

解决方案：实现自动重连机制

使用

错误 4：数据缺失 - 历史查询返回空结果

错误 5：汇率/计费异常 - 账单金额与预期不符

JavaScript/Node.js 接入方案（适用于前端实时监控）

作者实战经验总结

购买建议与 CTA

相关资源

相关文章

核心对比：HolySheep vs 官方 Tardis vs 其他中转站

为什么选 HolySheep 接入 Tardis 数据

适合谁与不适合谁

适合的场景

不适合的场景

价格与回本测算

实战接入：Python SDK 连接 HolySheep Tardis 数据

前置准备

如需异步处理，建议安装

接入 Funding Rate 实时数据

HolySheep API 配置

Tardis 数据订阅端点

运行订阅

查询历史 Funding Rate 数据（用于回测）

示例：查询最近 30 天 BTCUSDT Funding Rate

数据校验方案：确保 Tick 数据完整性

1. Funding Rate 时间戳连续性校验

执行校验

2. Tick 数据重复与缺失检测

常见报错排查

错误 1：401 Unauthorized - API Key 无效或权限不足

{"error": "Unauthorized", "message": "Invalid API key or insufficient permissions"}

排查步骤

错误 2：429 Rate Limit - 请求频率超限

{"error": "RateLimitExceeded", "message": "Too many requests", "retry_after": 5}

解决方案：实现指数退避重试

使用示例

错误 3：1001 WebSocket 断连 - 心跳超时

解决方案：实现自动重连机制

使用

错误 4：数据缺失 - 历史查询返回空结果

错误 5：汇率/计费异常 - 账单金额与预期不符

JavaScript/Node.js 接入方案（适用于前端实时监控）

作者实战经验总结

购买建议与 CTA

相关资源

相关文章

🔥 推荐使用 HolySheep AI