hyperliquid交易历史胜率统计（Win Rate）算法

SHI XIAOLONG

— 12 min read

胜率统计（Win Rate）算法详解

📋 目录

  1. 算法概述
  2. 核心概念
  3. 计算公式
  4. 算法实现
  5. 应用场景
  6. 完整代码示例
  7. 测试用例

算法概述

什么是胜率（Win Rate）？

胜率是指在所有交易中，盈利交易占总交易的百分比，是评估交易策略准确性的关键指标。

指标意义

  • Win Rate > 50%: 盈利交易多于亏损交易
  • Win Rate = 50%: 盈亏交易数量相等
  • Win Rate < 50%: 亏损交易多于盈利交易

为什么需要胜率？

胜率反映了交易策略的成功率，但需要与盈亏比结合分析：

胜率 盈亏比 评估
80% 1:5 ❌ 高胜率但盈亏比差
40% 5:1 ✅ 低胜率但盈亏比优秀
60% 3:1 🏆 理想组合

核心概念

1. 胜率（Win Rate）

win_rate = (winning_trades / total_trades) * 100

示例：

  • 总交易：100 笔
  • 盈利交易：65 笔
  • 亏损交易：35 笔
  • 胜率: 65%

2. 方向偏好（Bias）

衡量交易者偏向做多还是做空，范围 0-100：

  • Bias = 50: 中性，多空平衡
  • Bias > 50: 偏多头（Long Bias）
  • Bias < 50: 偏空头（Short Bias）
bias = ((long_trades - short_trades) / total_trades * 100 + 100) / 2

示例：

  • 总交易：100 笔
  • 多头交易：70 笔
  • 空头交易：30 笔
  • 方向偏好: ((70-30)/100*100+100)/2 = 70（偏多）

3. 交易方向识别

Hyperliquid 交易方向字段（dir）格式：

方向字段 含义 分类
"Open Long" 开多仓 多头
"Close Long" 平多仓 多头
"Open Short" 开空仓 空头
"Close Short" 平空仓 空头
"Short > Long" 从空翻多 多头
"Long > Short" 从多翻空 空头

计算公式

核心公式

1. 胜率计算

win_rate = (winning_trades / total_pnl_trades) * 100

其中：
- winning_trades: 盈利交易次数（closedPnl > 0）
- total_pnl_trades: 有盈亏的交易总数（排除 closedPnl = 0）

2. 方向偏好计算

bias = ((long_trades - short_trades) / total_trades * 100 + 100) / 2

其中：
- long_trades: 多头交易次数
- short_trades: 空头交易次数
- total_trades: 总交易次数

公式推导

方向偏好推导

假设：
- 总交易数 = 100
- 多头交易 = 70
- 空头交易 = 30

计算步骤：
1. 多空差值 = 70 - 30 = 40
2. 差值占比 = 40 / 100 = 0.4 = 40%
3. 转换到 0-100 范围 = (40 + 100) / 2 = 70

结果：bias = 70（偏多 20%）

边界情况：

  • 全部多头：bias = ((100-0)/100*100+100)/2 = 100
  • 全部空头：bias = ((0-100)/100*100+100)/2 = 0
  • 多空平衡：bias = ((50-50)/100*100+100)/2 = 50

算法实现

核心函数：calculate_win_rate()

代码位置: apex_fork.py:285-356

from typing import List, Dict
from decimal import Decimal


def calculate_win_rate(fills: List[Dict]) -> Dict[str, float]:
    """
    计算胜率和交易统计信息

    参数：
        fills: 成交记录列表，包含 'closedPnl' 和 'dir' 字段

    返回：
        字典，包含：
        - winRate: 胜率（百分比）
        - bias: 方向偏好（0-100，50为中性，>50偏多，<50偏空）
        - totalTrades: 总交易次数

    算法说明：
        1. 统计盈利和亏损交易次数
        2. 统计多头和空头交易次数
        3. 计算胜率 = 盈利次数 / 总次数
        4. 计算方向偏好 = (多头-空头) / 总数
    """
    # 边界条件：无交易数据
    if not fills:
        return {"winRate": 0, "bias": 50, "totalTrades": 0}

    # 初始化计数器
    long_trades = 0      # 多头交易次数
    short_trades = 0     # 空头交易次数
    winning_trades = 0   # 盈利交易次数
    losing_trades = 0    # 亏损交易次数

    # 遍历所有成交记录
    for fill in fills:
        # 安全获取已实现盈亏
        closed_pnl_value = fill.get('closedPnl')
        if closed_pnl_value is None:
            continue

        closed_pnl = Decimal(str(closed_pnl_value))
        direction = fill.get('dir', '').strip()

        # 标准化方向判断（不区分大小写）
        direction_lower = direction.lower()

        # ==================== 统计交易方向 ====================

        # 判断多头交易
        if any(term in direction_lower for term in ['open long', 'close long']):
            # 排除 "Short > Long" 这种包含 long 但实际是从空翻多的情况
            if 'short' not in direction_lower or direction_lower.endswith('long'):
                long_trades += 1
        # 特殊处理：从空翻多
        elif 'short > long' in direction_lower or 'short>long' in direction_lower:
            long_trades += 1

        # 判断空头交易
        elif any(term in direction_lower for term in ['open short', 'close short']):
            # 排除 "Long > Short" 这种包含 short 但实际是从多翻空的情况
            if 'long' not in direction_lower or direction_lower.endswith('short'):
                short_trades += 1
        # 特殊处理：从多翻空
        elif 'long > short' in direction_lower or 'long>short' in direction_lower:
            short_trades += 1

        # ==================== 统计盈亏次数 ====================

        # 排除零盈亏交易（可能是仓位调整，不算真正的平仓）
        if closed_pnl != 0:
            if closed_pnl > 0:
                winning_trades += 1
            else:
                losing_trades += 1

    # ==================== 计算统计指标 ====================

    total_trades = len(fills)
    total_pnl_trades = winning_trades + losing_trades

    # 计算胜率
    win_rate = (winning_trades / total_pnl_trades * 100) if total_pnl_trades > 0 else 0

    # 计算方向偏好
    bias = ((long_trades - short_trades) / total_trades * 100 + 100) / 2 if total_trades > 0 else 50

    return {
        "winRate": win_rate,
        "bias": bias,
        "totalTrades": total_trades
    }

方向识别详细实现

def identify_trade_direction(direction: str) -> str:
    """
    识别交易方向

    参数：
        direction: 交易方向字符串（如 "Open Long", "Close Short"）

    返回：
        "long", "short", 或 "unknown"
    """
    direction_lower = direction.lower().strip()

    # 多头交易判断
    if any(term in direction_lower for term in ['open long', 'close long']):
        if 'short' not in direction_lower or direction_lower.endswith('long'):
            return "long"

    # 从空翻多
    if 'short > long' in direction_lower or 'short>long' in direction_lower:
        return "long"

    # 空头交易判断
    if any(term in direction_lower for term in ['open short', 'close short']):
        if 'long' not in direction_lower or direction_lower.endswith('short'):
            return "short"

    # 从多翻空
    if 'long > short' in direction_lower or 'long>short' in direction_lower:
        return "short"

    return "unknown"

算法流程图

开始
  ↓
检查数据是否为空？
  ↓ 是
返回默认值 {winRate: 0, bias: 50, totalTrades: 0}
  ↓ 否
初始化计数器
  ↓
遍历成交记录（fills）
  ↓
对每条记录：
  ├─ 获取 closedPnl
  │  ├─ > 0 → winning_trades++
  │  ├─ < 0 → losing_trades++
  │  └─ = 0 → 跳过（不计入胜率）
  │
  └─ 获取 direction
     ├─ 包含 "Open Long" 或 "Close Long" → long_trades++
     ├─ 包含 "Open Short" 或 "Close Short" → short_trades++
     ├─ 包含 "Short > Long" → long_trades++
     └─ 包含 "Long > Short" → short_trades++
  ↓
计算胜率 = winning_trades / (winning_trades + losing_trades) * 100
  ↓
计算方向偏好 = ((long_trades - short_trades) / total_trades * 100 + 100) / 2
  ↓
返回结果
  ↓
结束

应用场景

场景 1：策略评估

# 计算胜率
win_stats = calculate_win_rate(fills)

print(f"胜率: {win_stats['winRate']:.2f}%")
print(f"方向偏好: {win_stats['bias']:.2f}")
print(f"总交易次数: {win_stats['totalTrades']}")

# 评估策略
if win_stats['winRate'] > 60:
    print("✅ 高胜率策略")
elif win_stats['winRate'] > 50:
    print("✅ 正胜率策略")
else:
    print("⚠️ 低胜率策略，需提高盈亏比")

# 评估方向偏好
if win_stats['bias'] > 60:
    print("📈 偏多头策略")
elif win_stats['bias'] < 40:
    print("📉 偏空头策略")
else:
    print("⚖️ 多空平衡策略")

场景 2：策略优化建议

def get_strategy_advice(win_rate: float, profit_factor: float, bias: float) -> str:
    """根据胜率、盈亏因子和方向偏好给出建议"""

    if win_rate > 50 and profit_factor > 1.5:
        return "🏆 策略表现优秀，继续保持"

    elif win_rate > 50 and profit_factor < 1.2:
        return "⚠️ 高胜率但盈亏比不足，需要提高单笔盈利"

    elif win_rate < 50 and profit_factor > 2.0:
        return "✅ 低胜率高盈亏比策略，风格合理"

    elif win_rate < 50 and profit_factor < 1.5:
        return "❌ 低胜率低盈亏比，需要全面优化"

    # 方向偏好建议
    if abs(bias - 50) > 30:
        return "⚠️ 方向偏好过于极端，建议增加多样性"

    return "继续观察和优化"


# 使用示例
advice = get_strategy_advice(
    win_rate=55,
    profit_factor=1.8,
    bias=65
)
print(advice)

场景 3：市场趋势分析

def analyze_market_trend(win_stats: Dict, time_period: str) -> str:
    """分析市场趋势"""
    bias = win_stats['bias']

    if bias > 70:
        return f"{time_period}: 强烈看多情绪 🚀"
    elif bias > 55:
        return f"{time_period}: 偏多头市场 📈"
    elif bias < 30:
        return f"{time_period}: 强烈看空情绪 📉"
    elif bias < 45:
        return f"{time_period}: 偏空头市场 📉"
    else:
        return f"{time_period}: 市场平衡 ⚖️"


# 分析不同时期的趋势
recent_fills = [f for f in fills if f['time'] > recent_timestamp]
win_stats_recent = calculate_win_rate(recent_fills)
print(analyze_market_trend(win_stats_recent, "最近7天"))

完整代码示例

主程序示例

from typing import List, Dict
from decimal import Decimal
from datetime import datetime


class WinRateCalculator:
    """胜率统计计算器"""

    def calculate_win_rate(self, fills: List[Dict]) -> Dict[str, float]:
        """计算胜率和交易统计"""
        if not fills:
            return {"winRate": 0, "bias": 50, "totalTrades": 0}

        long_trades = 0
        short_trades = 0
        winning_trades = 0
        losing_trades = 0

        print("\n📊 交易详细分析:")
        print("=" * 80)
        print(f"{'序号':<6} {'方向':<15} {'盈亏':<12} {'金额':<15} {'分类'}")
        print("=" * 80)

        for i, fill in enumerate(fills, 1):
            closed_pnl_value = fill.get('closedPnl')
            if closed_pnl_value is None:
                continue

            closed_pnl = Decimal(str(closed_pnl_value))
            direction = fill.get('dir', '').strip()
            direction_lower = direction.lower()

            # 识别交易方向
            trade_type = "Unknown"
            if any(term in direction_lower for term in ['open long', 'close long']):
                if 'short' not in direction_lower or direction_lower.endswith('long'):
                    long_trades += 1
                    trade_type = "Long"
            elif 'short > long' in direction_lower or 'short>long' in direction_lower:
                long_trades += 1
                trade_type = "Long"
            elif any(term in direction_lower for term in ['open short', 'close short']):
                if 'long' not in direction_lower or direction_lower.endswith('short'):
                    short_trades += 1
                    trade_type = "Short"
            elif 'long > short' in direction_lower or 'long>short' in direction_lower:
                short_trades += 1
                trade_type = "Short"

            # 统计盈亏
            pnl_status = "Zero"
            result_emoji = "⚪"
            if closed_pnl != 0:
                if closed_pnl > 0:
                    winning_trades += 1
                    pnl_status = "Win"
                    result_emoji = "✅"
                else:
                    losing_trades += 1
                    pnl_status = "Loss"
                    result_emoji = "❌"

            # 打印详情
            pnl_str = f"${float(closed_pnl):,.2f}"
            print(f"{i:<6} {direction:<15} {pnl_status:<12} {pnl_str:<15} {result_emoji} {trade_type}")

        print("=" * 80)

        # 计算统计指标
        total_trades = len(fills)
        total_pnl_trades = winning_trades + losing_trades
        win_rate = (winning_trades / total_pnl_trades * 100) if total_pnl_trades > 0 else 0
        bias = ((long_trades - short_trades) / total_trades * 100 + 100) / 2 if total_trades > 0 else 50

        # 打印统计结果
        print("\n📈 统计摘要:")
        print("=" * 80)
        print(f"总交易次数: {total_trades}")
        print(f"有效交易次数: {total_pnl_trades} (排除零盈亏)")
        print(f"盈利交易: {winning_trades} 笔")
        print(f"亏损交易: {losing_trades} 笔")
        print(f"多头交易: {long_trades} 笔")
        print(f"空头交易: {short_trades} 笔")
        print("=" * 80)
        print(f"胜率: {win_rate:.2f}%")
        print(f"方向偏好: {bias:.2f} ", end="")

        if bias > 60:
            print("(偏多 📈)")
        elif bias < 40:
            print("(偏空 📉)")
        else:
            print("(平衡 ⚖️)")

        return {
            "winRate": win_rate,
            "bias": bias,
            "totalTrades": total_trades,
            "winningTrades": winning_trades,
            "losingTrades": losing_trades,
            "longTrades": long_trades,
            "shortTrades": short_trades
        }

    def get_detailed_breakdown(self, fills: List[Dict]) -> Dict:
        """获取详细分类统计"""
        long_wins = 0
        long_losses = 0
        short_wins = 0
        short_losses = 0

        for fill in fills:
            closed_pnl = float(fill.get('closedPnl', 0))
            direction = fill.get('dir', '').lower()

            is_long = any(term in direction for term in ['open long', 'close long', 'short > long', 'short>long'])
            is_short = any(term in direction for term in ['open short', 'close short', 'long > short', 'long>short'])

            if closed_pnl > 0:
                if is_long:
                    long_wins += 1
                elif is_short:
                    short_wins += 1
            elif closed_pnl < 0:
                if is_long:
                    long_losses += 1
                elif is_short:
                    short_losses += 1

        long_total = long_wins + long_losses
        short_total = short_wins + short_losses

        return {
            "long": {
                "wins": long_wins,
                "losses": long_losses,
                "total": long_total,
                "win_rate": (long_wins / long_total * 100) if long_total > 0 else 0
            },
            "short": {
                "wins": short_wins,
                "losses": short_losses,
                "total": short_total,
                "win_rate": (short_wins / short_total * 100) if short_total > 0 else 0
            }
        }


# 使用示例
if __name__ == "__main__":
    calculator = WinRateCalculator()

    # 模拟交易数据
    fills = [
        {"dir": "Open Long", "closedPnl": "0"},      # 开仓，不计入胜率
        {"dir": "Close Long", "closedPnl": "500"},   # 多头盈利
        {"dir": "Open Short", "closedPnl": "0"},     # 开仓，不计入胜率
        {"dir": "Close Short", "closedPnl": "-200"}, # 空头亏损
        {"dir": "Open Long", "closedPnl": "0"},      # 开仓，不计入胜率
        {"dir": "Close Long", "closedPnl": "300"},   # 多头盈利
        {"dir": "Open Short", "closedPnl": "0"},     # 开仓，不计入胜率
        {"dir": "Close Short", "closedPnl": "150"},  # 空头盈利
        {"dir": "Short > Long", "closedPnl": "-100"},# 翻仓，多头亏损
        {"dir": "Close Long", "closedPnl": "250"},   # 多头盈利
    ]

    # 计算胜率
    win_stats = calculator.calculate_win_rate(fills)

    # 获取详细分类
    print("\n" + "=" * 80)
    print("分方向统计:")
    print("=" * 80)

    breakdown = calculator.get_detailed_breakdown(fills)

    print(f"\n多头交易:")
    print(f"  盈利: {breakdown['long']['wins']} 笔")
    print(f"  亏损: {breakdown['long']['losses']} 笔")
    print(f"  胜率: {breakdown['long']['win_rate']:.2f}%")

    print(f"\n空头交易:")
    print(f"  盈利: {breakdown['short']['wins']} 笔")
    print(f"  亏损: {breakdown['short']['losses']} 笔")
    print(f"  胜率: {breakdown['short']['win_rate']:.2f}%")

运行结果示例

📊 交易详细分析:
================================================================================
序号   方向            盈亏         金额            分类
================================================================================
1      Open Long       Zero         $0.00           ⚪ Long
2      Close Long      Win          $500.00         ✅ Long
3      Open Short      Zero         $0.00           ⚪ Short
4      Close Short     Loss         $-200.00        ❌ Short
5      Open Long       Zero         $0.00           ⚪ Long
6      Close Long      Win          $300.00         ✅ Long
7      Open Short      Zero         $0.00           ⚪ Short
8      Close Short     Win          $150.00         ✅ Short
9      Short > Long    Loss         $-100.00        ❌ Long
10     Close Long      Win          $250.00         ✅ Long
================================================================================

📈 统计摘要:
================================================================================
总交易次数: 10
有效交易次数: 5 (排除零盈亏)
盈利交易: 4 笔
亏损交易: 2 笔
多头交易: 6 笔
空头交易: 4 笔
================================================================================
胜率: 66.67%
方向偏好: 60.00 (偏多 📈)

================================================================================
分方向统计:
================================================================================

多头交易:
  盈利: 3 笔
  亏损: 1 笔
  胜率: 75.00%

空头交易:
  盈利: 1 笔
  亏损: 1 笔
  胜率: 50.00%

测试用例

测试用例 1：高胜率

def test_high_win_rate():
    """测试用例 1: 高胜率场景"""
    calculator = WinRateCalculator()

    fills = [
        {"dir": "Close Long", "closedPnl": "100"},
        {"dir": "Close Long", "closedPnl": "200"},
        {"dir": "Close Short", "closedPnl": "150"},
        {"dir": "Close Long", "closedPnl": "300"},
        {"dir": "Close Short", "closedPnl": "-50"},  # 唯一亏损
    ]

    result = calculator.calculate_win_rate(fills)

    # 预期：4盈1亏，胜率 = 80%
    assert abs(result['winRate'] - 80.0) < 0.01
    print(f"✅ 测试用例 1 通过：胜率 = {result['winRate']:.2f}%")

测试用例 2：方向偏好

def test_direction_bias():
    """测试用例 2: 方向偏好测试"""
    calculator = WinRateCalculator()

    # 全部多头
    fills_long = [
        {"dir": "Open Long", "closedPnl": "0"},
        {"dir": "Close Long", "closedPnl": "100"},
        {"dir": "Open Long", "closedPnl": "0"},
        {"dir": "Close Long", "closedPnl": "200"},
    ]

    result_long = calculator.calculate_win_rate(fills_long)
    assert result_long['bias'] > 90  # 应该接近 100
    print(f"✅ 多头偏好测试通过：bias = {result_long['bias']:.2f}")

    # 全部空头
    fills_short = [
        {"dir": "Open Short", "closedPnl": "0"},
        {"dir": "Close Short", "closedPnl": "100"},
        {"dir": "Open Short", "closedPnl": "0"},
        {"dir": "Close Short", "closedPnl": "200"},
    ]

    result_short = calculator.calculate_win_rate(fills_short)
    assert result_short['bias'] < 10  # 应该接近 0
    print(f"✅ 空头偏好测试通过：bias = {result_short['bias']:.2f}")

测试用例 3：翻仓交易

def test_flip_trades():
    """测试用例 3: 翻仓交易识别"""
    calculator = WinRateCalculator()

    fills = [
        {"dir": "Short > Long", "closedPnl": "100"},   # 应识别为多头
        {"dir": "Long > Short", "closedPnl": "200"},   # 应识别为空头
        {"dir": "short>long", "closedPnl": "150"},     # 无空格格式
        {"dir": "long>short", "closedPnl": "-50"},     # 无空格格式
    ]

    result = calculator.calculate_win_rate(fills)

    # 应该有2个多头和2个空头
    assert result['longTrades'] == 2
    assert result['shortTrades'] == 2
    assert abs(result['bias'] - 50.0) < 0.01  # 应该平衡
    print("✅ 测试用例 3 通过：翻仓识别正确")

测试用例 4：零盈亏过滤

def test_zero_pnl_filtering():
    """测试用例 4: 零盈亏交易不计入胜率"""
    calculator = WinRateCalculator()

    fills = [
        {"dir": "Open Long", "closedPnl": "0"},     # 不计入
        {"dir": "Close Long", "closedPnl": "100"},  # 盈利
        {"dir": "Open Short", "closedPnl": "0"},    # 不计入
        {"dir": "Close Short", "closedPnl": "0"},   # 不计入（仓位调整）
        {"dir": "Close Long", "closedPnl": "-50"},  # 亏损
    ]

    result = calculator.calculate_win_rate(fills)

    # 有效交易只有2笔（1盈1亏），胜率 50%
    assert abs(result['winRate'] - 50.0) < 0.01
    assert result['totalTrades'] == 5  # 但总交易数是5
    print(f"✅ 测试用例 4 通过：零盈亏过滤正确")

测试用例 5：无数据

def test_empty_data():
    """测试用例 5: 无交易数据"""
    calculator = WinRateCalculator()

    fills = []
    result = calculator.calculate_win_rate(fills)

    assert result['winRate'] == 0
    assert result['bias'] == 50
    assert result['totalTrades'] == 0
    print("✅ 测试用例 5 通过：空数据处理正确")

运行所有测试

if __name__ == "__main__":
    print("开始运行胜率统计测试用例...\n")

    test_high_win_rate()
    test_direction_bias()
    test_flip_trades()
    test_zero_pnl_filtering()
    test_empty_data()

    print("\n🎉 所有测试用例通过！")

算法优势

优势 说明
✅ 方向识别准确 正确处理所有方向类型，包括翻仓
✅ 零盈亏过滤 合理排除开仓和仓位调整交易
✅ 方向偏好分析 提供多空倾向性分析
✅ 大小写兼容 不区分大小写的方向判断
✅ 完整统计 提供总交易数、有效交易数等详细信息

参考资料

文档生成时间: 2026-02-03
作者: Apex Calculator Team

Read more

跑步的技巧（滚动落地）

“滚动落地（rolling contact / rolling foot strike）”不是一种教条式的“脚法”，而是一种 让冲击沿着整只脚、整条后链逐级传递的落地机制。 它的核心不是“你先用哪儿着地”，而是： 你的脚落地之后，冲击是不是像轮子一样滚过去，而不是像锤子一样砸下去。 这就是滚动落地的本质。 一、什么叫“滚动落地”？ 你可以把它理解成两种完全不同的落地方式： 1. 砸地（撞击式） 脚像锤子一样拍到地上： * 要么后跟先砸 * 要么前掌先戳 * 冲击集中在一个点 * 一个结构瞬间吃掉大部分载荷 结果就是： * 后跟砸 → 膝盖难受 * 前掌戳 → 前脚掌磨烂 * 都不是长跑友好模式 这叫 撞击式着地（impact strike）。 2. 滚地（滚动式） 脚像轮胎一样“滚”过地面： * 不是某一点硬砸 * 而是外侧中足先轻触 * 再向前滚到前掌 * 最后从大脚趾蹬离

By SHI XIAOLONG

AMI的优越性

世界模型（World Models）的具体例子 如下，我按类型分类，便于理解。每类都附带实际实现、演示效果和应用场景。 1. Yann LeCun / Meta 的 JEPA 系列（最直接对应“世界模型”概念） 这些是 LeCun 主张的非生成式抽象预测世界模型代表。 * I-JEPA（Image JEPA，2023） 输入一张图像，模型把不同区域（context 和 target）编码成抽象表示，然后预测 target 的表示（不在像素级别重建）。 例子：给定一张遮挡了部分物体的图片，模型能预测“被遮挡物体的大致位置和属性”，构建对物体持久性和空间关系的理解。 这是一个“原始世界模型”，能学习物理常识（如物体不会凭空消失）。 * V-JEPA / V-JEPA 2（Video JEPA，

By SHI XIAOLONG

什么是：“世界模型（World Models）”

世界模型（World Models） 是人工智能领域的一个核心概念，尤其在 Yann LeCun 等研究者推动的下一代 AI 架构中占据中心位置。它指的是 AI 系统在内部构建的对现实世界的抽象模拟或内部表示，让机器能够像人类或动物一样“理解”物理世界、预测未来、规划行动。 简单比喻 想象你闭上眼睛也能“看到”房间里的物体会如何移动、碰撞或掉落——这就是你大脑里的世界模型。AI 的世界模型就是类似的“数字孪生”（digital twin）或“内部模拟器”：它不是简单记住数据，而是学习世界的动态、因果关系和物理直觉（如重力、物体持久性、遮挡、因果等）。 为什么需要世界模型？ 当前主流的大型语言模型（LLM） 擅长处理文本（统计模式预测），但存在根本局限： * 缺乏对物理世界的真正理解 → 容易“幻觉”、无法可靠规划。 * 样本效率低 → 人类/

By SHI XIAOLONG

K线周期可配置化设计方案

K线周期可配置化设计方案 1. 背景与目标 当前 Beta 套利策略的 K 线周期硬编码为 "1h"，分散在多个文件中。需要： 1. 将 K 线周期从 1h 改为 2h 2. 提取为环境变量 BETA_ARB_KLINE_INTERVAL，使其可在 .env 中配置 2. 影响范围分析 2.1 需要修改的文件（共 6 个） 文件 硬编码位置 修改内容 src/trading/config.py BetaArbConfig dataclass 新增 kline_interval 字段，

By SHI XIAOLONG