Improve down-prediction accuracy: 44% -> 63%, overall 55% -> 62%

Enhanced training v4:
- Weighted sampling (1.5x for down samples)
- Imbalanced dataset (55% down / 45% up)
- 8 epochs with lower LR (3e-6)
- Converged after 2 iterations

Metrics:
- Direction accuracy: 55.1% -> 62.3%
- Down-prediction accuracy: 44.2% -> 62.6%
- Up-prediction accuracy: 65.9% -> 62.0% (slight decrease, better balanced)

README.md

@@ -1,14 +1,3 @@
----
-title: TSLM - Time Series Language Model
-emoji: 📈
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
-short_description: BTC price prediction API based on Kronos model
----
-
 # Kronos BTC Prediction API
 
 基于 Kronos 时序预测模型的 BTC 价格预测 API 服务。
@@ -25,26 +14,196 @@ short_description: BTC price prediction API based on Kronos model
 
 ## API 端点
 
-- `GET /health` - 健康检查
-- `POST /predict` - 价格预测
-- `POST /signal` - 交易信号
+### 健康检查
+
+```
+GET /health
+```
+
+**响应示例:**
+```json
+{
+  "status": "healthy",
+  "model_loaded": true,
+  "model_version": "iter5 (converged)",
+  "device": "cpu",
+  "timestamp": "2024-01-15T10:30:00.000000"
+}
+```
+
+### 价格预测
+
+```
+POST /predict
+```
+
+基于历史 OHLCV 数据预测未来价格走势。
+
+**请求参数:**
+
+| 字段 | 类型 | 必填 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| data | List[OHLCVData] | Yes | - | 历史 K 线数据 (至少 100 条) |
+| pred_len | int | No | 24 | 预测长度 (1-72 小时) |
+| n_paths | int | No | 30 | Monte Carlo 路径数 (10-100) |
+| temperature | float | No | 1.0 | 采样温度 (0.1-2.0) |
+| top_p | float | No | 0.9 | Top-p 采样 (0.5-1.0) |
+
+**OHLCVData 格式:**
+```json
+{
+  "timestamp": "2024-01-15T10:00:00",
+  "open": 42000.0,
+  "high": 42500.0,
+  "low": 41800.0,
+  "close": 42300.0,
+  "volume": 1234.56,
+  "amount": 52000000.0  // 可选
+}
+```
+
+**响应示例:**
+```json
+{
+  "current_price": 42300.0,
+  "mean_forecast": 42850.5,
+  "min_forecast": 41200.0,
+  "max_forecast": 44100.0,
+  "upside_probability": 0.65,
+  "expected_return": 0.013,
+  "volatility_amplification": 0.42,
+  "confidence": 0.78,
+  "forecast_prices": [42350.0, 42400.0, ...],
+  "timestamp": "2024-01-15T10:30:00.000000"
+}
+```
+
+### 交易信号
+
+```
+POST /signal
+```
+
+基于预测结果生成交易信号。
+
+**请求参数:**
+
+| 字段 | 类型 | 必填 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| data | List[OHLCVData] | Yes | - | 历史 K 线数据 |
+| buy_threshold | float | No | 0.58 | 买入阈值 (0.5-0.9) |
+| sell_threshold | float | No | 0.42 | 卖出阈值 (0.1-0.5) |
+| stop_loss | float | No | 0.03 | 止损比例 (0.01-0.1) |
+| take_profit | float | No | 0.08 | 止盈比例 (0.02-0.2) |
+| n_paths | int | No | 30 | Monte Carlo 路径数 |
+
+**响应示例:**
+```json
+{
+  "signal": "BUY",
+  "confidence": 0.78,
+  "current_price": 42300.0,
+  "target_price": 42850.5,
+  "stop_loss_price": 41031.0,
+  "take_profit_price": 45684.0,
+  "upside_probability": 0.65,
+  "expected_return": 0.013,
+  "suggested_position_size": 0.15,
+  "reason": "Upside probability 65.0% > 58%",
+  "timestamp": "2024-01-15T10:30:00.000000"
+}
+```
+
+**信号类型:**
+- `STRONG_BUY`: 强烈买入 (上涨概率 > 70%, 低波动)
+- `BUY`: 买入 (上涨概率 > buy_threshold)
+- `HOLD`: 持有 (中性区间或低置信度)
+- `SELL`: 卖出 (上涨概率 < sell_threshold)
+- `STRONG_SELL`: 强烈卖出 (下跌概率 > 70%, 低波动)
 
 ## 快速开始
 
+### 使用 Python SDK
+
 ```python
 from client import KronosClient
 
-client = KronosClient("https://xianqiu-tslm.hf.space")
+# 连接到 API
+client = KronosClient("https://your-space.hf.space")
 
-# 价格预测
+# 获取价格预测
 prediction = client.predict(ohlcv_data, pred_len=24)
-print(f"上涨概率: {prediction.upside_probability:.1%}")
+print(f"上涨概率: {prediction['upside_probability']:.1%}")
 
-# 交易信号
+# 获取交易信号
 signal = client.get_signal(ohlcv_data)
-print(f"信号: {signal.signal}")
+print(f"信号: {signal['signal']}, 置信度: {signal['confidence']:.1%}")
+```
+
+### 使用 cURL
+
+```bash
+# 健康检查
+curl https://your-space.hf.space/health
+
+# 价格预测
+curl -X POST https://your-space.hf.space/predict \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": [...],
+    "pred_len": 24,
+    "n_paths": 30
+  }'
 ```
 
-## API 文档
+## 本地部署
+
+```bash
+# 安装依赖
+pip install -r requirements.txt
+
+# 启动服务
+python app.py
+
+# 服务将在 http://localhost:7860 启动
+# API 文档: http://localhost:7860/docs
+```
+
+## HuggingFace Space 部署
+
+1. 创建新的 HuggingFace Space (选择 "Docker" 或 "Gradio" SDK)
+2. 上传所有文件:
+   ```
+   hf_space/
+   ├── app.py
+   ├── requirements.txt
+   ├── README.md
+   ├── client.py
+   ├── model/
+   │   ├── __init__.py
+   │   ├── kronos.py
+   │   └── module.py
+   └── models/
+       ├── tokenizer/
+       │   ├── config.json
+       │   └── model.safetensors
+       └── predictor/
+           ├── config.json
+           └── model.safetensors
+   ```
+3. Space 将自动构建和部署
+
+## 注意事项
+
+- **最小数据要求**: 至少 100 条 OHLCV 数据点
+- **时间间隔**: 建议使用 1 小时 K 线数据
+- **CPU 推理**: HuggingFace Space 免费版使用 CPU，预测约需 5-10 秒
+- **并发限制**: 免费版有请求频率限制，建议间隔 1 秒以上
+
+## 许可证
+
+MIT License
+
+## 联系方式
 
-访问 `/docs` 查看完整的 Swagger API 文档。
+如有问题或建议，请提交 Issue。

client.py

@@ -1,643 +1,410 @@
+#!/usr/bin/env python3
 """
-Kronos BTC Prediction API Client SDK
+Kronos BTC 预测 API 测试客户端
 
-用于连接 Kronos BTC 预测 API 的 Python 客户端。
+可直接运行来验证 HuggingFace Space API 是否正常工作。
 
-使用示例:
-    from client import KronosClient
+使用方法:
+    # 测试健康检查
+    python client.py health
     
-    client = KronosClient("https://your-space.hf.space")
+    # 测试预测 API
+    python client.py predict
     
-    # 健康检查
-    health = client.health()
+    # 测试交易信号 API  
+    python client.py signal
     
-    # 价格预测
-    prediction = client.predict(ohlcv_data, pred_len=24)
+    # 运行所有测试
+    python client.py all
     
-    # 交易信号
-    signal = client.get_signal(ohlcv_data)
+    # 使用自定义 URL
+    python client.py all --url https://your-space.hf.space
 """
 
+import argparse
+import json
+import sys
 import time
-from datetime import datetime
-from typing import List, Dict, Any, Optional, Union
-from dataclasses import dataclass
-from enum import Enum
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
 
-import httpx
-import pandas as pd
+import requests
 
 
-class SignalType(str, Enum):
-    """交易信号类型"""
-    STRONG_BUY = "STRONG_BUY"
-    BUY = "BUY"
-    HOLD = "HOLD"
-    SELL = "SELL"
-    STRONG_SELL = "STRONG_SELL"
+# ==================== 配置 ====================
 
+DEFAULT_API_URL = "https://xianqiu-tslm.hf.space"
 
-@dataclass
-class OHLCVData:
-    """OHLCV K线数据"""
-    timestamp: str
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: float
-    amount: Optional[float] = None
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "timestamp": self.timestamp,
-            "open": self.open,
-            "high": self.high,
-            "low": self.low,
-            "close": self.close,
-            "volume": self.volume,
-            "amount": self.amount
-        }
+# 币安 API
+BINANCE_API = "https://api.binance.com/api/v3/klines"
 
 
-@dataclass
-class PredictResult:
-    """预测结果"""
-    current_price: float
-    mean_forecast: float
-    min_forecast: float
-    max_forecast: float
-    upside_probability: float
-    expected_return: float
-    volatility_amplification: float
-    confidence: float
-    forecast_prices: List[float]
-    timestamp: str
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PredictResult":
-        return cls(**data)
-    
-    def __repr__(self) -> str:
-        return (
-            f"PredictResult(\n"
-            f"  current_price={self.current_price:.2f},\n"
-            f"  mean_forecast={self.mean_forecast:.2f},\n"
-            f"  upside_probability={self.upside_probability:.1%},\n"
-            f"  expected_return={self.expected_return:.2%},\n"
-            f"  confidence={self.confidence:.1%}\n"
-            f")"
-        )
+# ==================== 辅助函数 ====================
 
+def fetch_btc_data(symbol: str = "BTCUSDT", interval: str = "1h", limit: int = 200) -> List[Dict]:
+    """
+    从币安获取 BTC K线数据
+    
+    Args:
+        symbol: 交易对
+        interval: K线周期 (1h, 4h, 1d 等)
+        limit: 获取条数 (最大 1000)
+    
+    Returns:
+        OHLCV 数据列表
+    """
+    print(f"[Binance] 获取 {symbol} {interval} K线数据 (最近 {limit} 条)...")
+    
+    params = {
+        "symbol": symbol,
+        "interval": interval,
+        "limit": limit
+    }
+    
+    try:
+        response = requests.get(BINANCE_API, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+    except requests.exceptions.RequestException as e:
+        print(f"[Error] 无法连接币安 API: {e}")
+        print("[Info] 使用模拟数据...")
+        return generate_mock_data(limit)
+    
+    ohlcv_list = []
+    for item in data:
+        ohlcv_list.append({
+            "timestamp": datetime.fromtimestamp(item[0] / 1000).isoformat(),
+            "open": float(item[1]),
+            "high": float(item[2]),
+            "low": float(item[3]),
+            "close": float(item[4]),
+            "volume": float(item[5]),
+            "amount": float(item[7])  # Quote asset volume
+        })
+    
+    print(f"[OK] 获取到 {len(ohlcv_list)} 条数据")
+    print(f"     时间范围: {ohlcv_list[0]['timestamp']} ~ {ohlcv_list[-1]['timestamp']}")
+    print(f"     当前价格: ${ohlcv_list[-1]['close']:,.2f}")
+    
+    return ohlcv_list
 
-@dataclass
-class SignalResult:
-    """交易信号结果"""
-    signal: SignalType
-    confidence: float
-    current_price: float
-    target_price: float
-    stop_loss_price: float
-    take_profit_price: float
-    upside_probability: float
-    expected_return: float
-    suggested_position_size: float
-    reason: str
-    timestamp: str
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "SignalResult":
-        data["signal"] = SignalType(data["signal"])
-        return cls(**data)
-    
-    def __repr__(self) -> str:
-        return (
-            f"SignalResult(\n"
-            f"  signal={self.signal.value},\n"
-            f"  confidence={self.confidence:.1%},\n"
-            f"  current_price={self.current_price:.2f},\n"
-            f"  target_price={self.target_price:.2f},\n"
-            f"  stop_loss={self.stop_loss_price:.2f},\n"
-            f"  take_profit={self.take_profit_price:.2f},\n"
-            f"  position_size={self.suggested_position_size:.1%},\n"
-            f"  reason='{self.reason}'\n"
-            f")"
-        )
 
+def generate_mock_data(n: int = 200) -> List[Dict]:
+    """生成模拟 K线数据 (当币安 API 不可用时使用)"""
+    import random
+    
+    base_price = 100000.0
+    data = []
+    current_time = datetime.utcnow() - timedelta(hours=n)
+    
+    for i in range(n):
+        change = random.gauss(0, 0.01)  # 1% 标准差
+        base_price *= (1 + change)
+        
+        high = base_price * (1 + random.random() * 0.005)
+        low = base_price * (1 - random.random() * 0.005)
+        close = random.uniform(low, high)
+        
+        data.append({
+            "timestamp": current_time.isoformat(),
+            "open": round(base_price, 2),
+            "high": round(high, 2),
+            "low": round(low, 2),
+            "close": round(close, 2),
+            "volume": round(random.uniform(100, 1000), 2),
+            "amount": round(random.uniform(1000000, 10000000), 2)
+        })
+        
+        current_time += timedelta(hours=1)
+    
+    return data
 
-@dataclass
-class HealthResult:
-    """健康检查结果"""
-    status: str
-    model_loaded: bool
-    model_version: str
-    device: str
-    timestamp: str
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "HealthResult":
-        return cls(**data)
 
+def print_json(data: Any, title: str = None):
+    """美化打印 JSON"""
+    if title:
+        print(f"\n{'='*60}")
+        print(f"  {title}")
+        print(f"{'='*60}")
+    print(json.dumps(data, indent=2, ensure_ascii=False))
 
-class KronosClientError(Exception):
-    """Kronos 客户端错误"""
-    pass
 
+# ==================== API 测试函数 ====================
 
-class KronosClient:
-    """
-    Kronos BTC 预测 API 客户端
-    
-    Args:
-        base_url: API 服务地址 (如 "https://your-space.hf.space")
-        timeout: 请求超时时间 (秒)
-        max_retries: 最大重试次数
-    
-    Examples:
-        >>> client = KronosClient("https://your-space.hf.space")
-        >>> health = client.health()
-        >>> print(f"Status: {health.status}")
-    """
-    
-    def __init__(
-        self,
-        base_url: str,
-        timeout: float = 60.0,
-        max_retries: int = 3
-    ):
-        self.base_url = base_url.rstrip("/")
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self._client = httpx.Client(timeout=timeout)
-    
-    def __enter__(self):
-        return self
-    
-    def __exit__(self, *args):
-        self.close()
-    
-    def close(self):
-        """关闭客户端"""
-        self._client.close()
-    
-    def _request(
-        self,
-        method: str,
-        endpoint: str,
-        json: Optional[Dict] = None,
-        retry_count: int = 0
-    ) -> Dict[str, Any]:
-        """发送 HTTP 请求"""
-        url = f"{self.base_url}{endpoint}"
-        
-        try:
-            response = self._client.request(method, url, json=json)
-            
-            if response.status_code == 503:
-                # 模型未加载，等待重试
-                if retry_count < self.max_retries:
-                    time.sleep(5)
-                    return self._request(method, endpoint, json, retry_count + 1)
-                raise KronosClientError("Model not loaded after retries")
-            
-            response.raise_for_status()
-            return response.json()
-        
-        except httpx.ConnectError as e:
-            raise KronosClientError(f"Connection failed: {e}")
-        except httpx.TimeoutException as e:
-            raise KronosClientError(f"Request timeout: {e}")
-        except httpx.HTTPStatusError as e:
-            raise KronosClientError(f"HTTP error {e.response.status_code}: {e.response.text}")
-    
-    def health(self) -> HealthResult:
-        """
-        健康检查
-        
-        Returns:
-            HealthResult: 健康状态
-        """
-        data = self._request("GET", "/health")
-        return HealthResult.from_dict(data)
-    
-    def predict(
-        self,
-        data: Union[List[Dict], List[OHLCVData], pd.DataFrame],
-        pred_len: int = 24,
-        n_paths: int = 30,
-        temperature: float = 1.0,
-        top_p: float = 0.9
-    ) -> PredictResult:
-        """
-        预测 BTC 价格走势
-        
-        Args:
-            data: OHLCV 数据 (至少 100 条)
-                - List[Dict]: 字典列表
-                - List[OHLCVData]: OHLCVData 对象列表
-                - pd.DataFrame: DataFrame (需包含 timestamp, open, high, low, close, volume 列)
-            pred_len: 预测长度 (1-72 小时)
-            n_paths: Monte Carlo 路径数 (10-100)
-            temperature: 采样温度 (0.1-2.0)
-            top_p: Top-p 采样 (0.5-1.0)
-        
-        Returns:
-            PredictResult: 预测结果
-        
-        Examples:
-            >>> result = client.predict(df, pred_len=24)
-            >>> print(f"上涨概率: {result.upside_probability:.1%}")
-        """
-        ohlcv_list = self._convert_data(data)
-        
-        if len(ohlcv_list) < 100:
-            raise KronosClientError(f"At least 100 data points required, got {len(ohlcv_list)}")
-        
-        request_data = {
-            "data": ohlcv_list,
-            "pred_len": pred_len,
-            "n_paths": n_paths,
-            "temperature": temperature,
-            "top_p": top_p
-        }
-        
-        response = self._request("POST", "/predict", json=request_data)
-        return PredictResult.from_dict(response)
-    
-    def get_signal(
-        self,
-        data: Union[List[Dict], List[OHLCVData], pd.DataFrame],
-        buy_threshold: float = 0.58,
-        sell_threshold: float = 0.42,
-        stop_loss: float = 0.03,
-        take_profit: float = 0.08,
-        n_paths: int = 30
-    ) -> SignalResult:
-        """
-        获取交易信号
-        
-        Args:
-            data: OHLCV 数据 (至少 100 条)
-            buy_threshold: 买入阈值 (0.5-0.9)
-            sell_threshold: 卖出阈值 (0.1-0.5)
-            stop_loss: 止损比例 (0.01-0.1)
-            take_profit: 止盈比例 (0.02-0.2)
-            n_paths: Monte Carlo 路径数 (10-100)
-        
-        Returns:
-            SignalResult: 交易信号
-        
-        Examples:
-            >>> signal = client.get_signal(df)
-            >>> if signal.signal == SignalType.BUY:
-            ...     print(f"买入! 目标价: {signal.target_price:.2f}")
-        """
-        ohlcv_list = self._convert_data(data)
-        
-        if len(ohlcv_list) < 100:
-            raise KronosClientError(f"At least 100 data points required, got {len(ohlcv_list)}")
-        
-        request_data = {
-            "data": ohlcv_list,
-            "buy_threshold": buy_threshold,
-            "sell_threshold": sell_threshold,
-            "stop_loss": stop_loss,
-            "take_profit": take_profit,
-            "n_paths": n_paths
-        }
-        
-        response = self._request("POST", "/signal", json=request_data)
-        return SignalResult.from_dict(response)
-    
-    def _convert_data(
-        self,
-        data: Union[List[Dict], List[OHLCVData], pd.DataFrame]
-    ) -> List[Dict[str, Any]]:
-        """转换数据格式"""
-        if isinstance(data, pd.DataFrame):
-            return self._dataframe_to_list(data)
-        elif isinstance(data, list):
-            if len(data) == 0:
-                return []
-            if isinstance(data[0], OHLCVData):
-                return [d.to_dict() for d in data]
-            elif isinstance(data[0], dict):
-                return data
-        
-        raise KronosClientError(f"Unsupported data type: {type(data)}")
-    
-    def _dataframe_to_list(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
-        """将 DataFrame 转换为列表"""
-        required_cols = ["open", "high", "low", "close", "volume"]
-        for col in required_cols:
-            if col not in df.columns:
-                raise KronosClientError(f"Missing required column: {col}")
-        
-        result = []
-        for _, row in df.iterrows():
-            # 处理时间戳
-            if "timestamp" in df.columns:
-                ts = row["timestamp"]
-                if isinstance(ts, pd.Timestamp):
-                    ts = ts.isoformat()
-                elif isinstance(ts, datetime):
-                    ts = ts.isoformat()
-                else:
-                    ts = str(ts)
-            else:
-                ts = datetime.utcnow().isoformat()
+def test_health(base_url: str) -> bool:
+    """测试健康检查 API"""
+    print("\n" + "="*60)
+    print("  TEST: /health")
+    print("="*60)
+    
+    url = f"{base_url}/health"
+    print(f"[Request] GET {url}")
+    
+    try:
+        start = time.time()
+        response = requests.get(url, timeout=30)
+        elapsed = time.time() - start
+        
+        print(f"[Response] Status: {response.status_code} ({elapsed:.2f}s)")
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"\n[Result]")
+            print(f"  Status:        {data.get('status', 'N/A')}")
+            print(f"  Model Loaded:  {data.get('model_loaded', 'N/A')}")
+            print(f"  Model Version: {data.get('model_version', 'N/A')}")
+            print(f"  Device:        {data.get('device', 'N/A')}")
+            print(f"  Timestamp:     {data.get('timestamp', 'N/A')}")
+            return True
+        else:
+            print(f"[Error] {response.text}")
+            return False
             
-            result.append({
-                "timestamp": ts,
-                "open": float(row["open"]),
-                "high": float(row["high"]),
-                "low": float(row["low"]),
-                "close": float(row["close"]),
-                "volume": float(row["volume"]),
-                "amount": float(row["amount"]) if "amount" in df.columns else None
-            })
-        
-        return result
+    except requests.exceptions.RequestException as e:
+        print(f"[Error] 请求失败: {e}")
+        return False
 
 
-class AsyncKronosClient:
-    """
-    异步 Kronos BTC 预测 API 客户端
-    
-    用于异步场景 (如 asyncio 应用)。
-    
-    Examples:
-        >>> async with AsyncKronosClient("https://your-space.hf.space") as client:
-        ...     health = await client.health()
-        ...     prediction = await client.predict(df)
-    """
-    
-    def __init__(
-        self,
-        base_url: str,
-        timeout: float = 60.0,
-        max_retries: int = 3
-    ):
-        self.base_url = base_url.rstrip("/")
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self._client: Optional[httpx.AsyncClient] = None
-    
-    async def __aenter__(self):
-        self._client = httpx.AsyncClient(timeout=self.timeout)
-        return self
-    
-    async def __aexit__(self, *args):
-        await self.close()
-    
-    async def close(self):
-        """关闭客户端"""
-        if self._client:
-            await self._client.aclose()
-            self._client = None
-    
-    async def _request(
-        self,
-        method: str,
-        endpoint: str,
-        json: Optional[Dict] = None,
-        retry_count: int = 0
-    ) -> Dict[str, Any]:
-        """发送 HTTP 请求"""
-        if not self._client:
-            raise KronosClientError("Client not initialized. Use 'async with' context.")
-        
-        url = f"{self.base_url}{endpoint}"
-        
-        try:
-            response = await self._client.request(method, url, json=json)
+def test_predict(base_url: str, data: List[Dict] = None) -> bool:
+    """测试预测 API"""
+    print("\n" + "="*60)
+    print("  TEST: /predict")
+    print("="*60)
+    
+    # 获取数据
+    if data is None:
+        data = fetch_btc_data(limit=200)
+    
+    url = f"{base_url}/predict"
+    payload = {
+        "data": data,
+        "pred_len": 24,
+        "n_paths": 30,
+        "temperature": 1.0,
+        "top_p": 0.9
+    }
+    
+    print(f"\n[Request] POST {url}")
+    print(f"  数据点数:   {len(data)}")
+    print(f"  预测长度:   {payload['pred_len']} 小时")
+    print(f"  Monte Carlo: {payload['n_paths']} 路径")
+    
+    try:
+        start = time.time()
+        response = requests.post(url, json=payload, timeout=120)
+        elapsed = time.time() - start
+        
+        print(f"\n[Response] Status: {response.status_code} ({elapsed:.2f}s)")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"\n[Result]")
+            print(f"  当前价格:     ${result.get('current_price', 0):,.2f}")
+            print(f"  预测均值:     ${result.get('mean_forecast', 0):,.2f}")
+            print(f"  预测范围:     ${result.get('min_forecast', 0):,.2f} ~ ${result.get('max_forecast', 0):,.2f}")
+            print(f"  上涨概率:     {result.get('upside_probability', 0)*100:.1f}%")
+            print(f"  预期收益:     {result.get('expected_return', 0)*100:.2f}%")
+            print(f"  波动放大:     {result.get('volatility_amplification', 0):.2f}x")
+            print(f"  置信度:       {result.get('confidence', 0)*100:.1f}%")
+            print(f"  预测点数:     {len(result.get('forecast_prices', []))} 个")
             
-            if response.status_code == 503:
-                if retry_count < self.max_retries:
-                    import asyncio
-                    await asyncio.sleep(5)
-                    return await self._request(method, endpoint, json, retry_count + 1)
-                raise KronosClientError("Model not loaded after retries")
+            # 显示部分预测价格
+            prices = result.get('forecast_prices', [])
+            if prices:
+                print(f"\n  预测价格趋势 (每6小时):")
+                for i in range(0, len(prices), 6):
+                    print(f"    +{i}h: ${prices[i]:,.2f}")
             
-            response.raise_for_status()
-            return response.json()
-        
-        except httpx.ConnectError as e:
-            raise KronosClientError(f"Connection failed: {e}")
-        except httpx.TimeoutException as e:
-            raise KronosClientError(f"Request timeout: {e}")
-        except httpx.HTTPStatusError as e:
-            raise KronosClientError(f"HTTP error {e.response.status_code}: {e.response.text}")
-    
-    async def health(self) -> HealthResult:
-        """健康检查"""
-        data = await self._request("GET", "/health")
-        return HealthResult.from_dict(data)
-    
-    async def predict(
-        self,
-        data: Union[List[Dict], List[OHLCVData], pd.DataFrame],
-        pred_len: int = 24,
-        n_paths: int = 30,
-        temperature: float = 1.0,
-        top_p: float = 0.9
-    ) -> PredictResult:
-        """预测 BTC 价格走势"""
-        ohlcv_list = self._convert_data(data)
-        
-        if len(ohlcv_list) < 100:
-            raise KronosClientError(f"At least 100 data points required")
-        
-        request_data = {
-            "data": ohlcv_list,
-            "pred_len": pred_len,
-            "n_paths": n_paths,
-            "temperature": temperature,
-            "top_p": top_p
-        }
-        
-        response = await self._request("POST", "/predict", json=request_data)
-        return PredictResult.from_dict(response)
-    
-    async def get_signal(
-        self,
-        data: Union[List[Dict], List[OHLCVData], pd.DataFrame],
-        buy_threshold: float = 0.58,
-        sell_threshold: float = 0.42,
-        stop_loss: float = 0.03,
-        take_profit: float = 0.08,
-        n_paths: int = 30
-    ) -> SignalResult:
-        """获取交易信号"""
-        ohlcv_list = self._convert_data(data)
-        
-        if len(ohlcv_list) < 100:
-            raise KronosClientError(f"At least 100 data points required")
-        
-        request_data = {
-            "data": ohlcv_list,
-            "buy_threshold": buy_threshold,
-            "sell_threshold": sell_threshold,
-            "stop_loss": stop_loss,
-            "take_profit": take_profit,
-            "n_paths": n_paths
-        }
-        
-        response = await self._request("POST", "/signal", json=request_data)
-        return SignalResult.from_dict(response)
-    
-    def _convert_data(
-        self,
-        data: Union[List[Dict], List[OHLCVData], pd.DataFrame]
-    ) -> List[Dict[str, Any]]:
-        """转换数据格式"""
-        if isinstance(data, pd.DataFrame):
-            return self._dataframe_to_list(data)
-        elif isinstance(data, list):
-            if len(data) == 0:
-                return []
-            if isinstance(data[0], OHLCVData):
-                return [d.to_dict() for d in data]
-            elif isinstance(data[0], dict):
-                return data
-        
-        raise KronosClientError(f"Unsupported data type: {type(data)}")
-    
-    def _dataframe_to_list(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
-        """将 DataFrame 转换为列表"""
-        required_cols = ["open", "high", "low", "close", "volume"]
-        for col in required_cols:
-            if col not in df.columns:
-                raise KronosClientError(f"Missing required column: {col}")
-        
-        result = []
-        for _, row in df.iterrows():
-            if "timestamp" in df.columns:
-                ts = row["timestamp"]
-                if isinstance(ts, pd.Timestamp):
-                    ts = ts.isoformat()
-                elif isinstance(ts, datetime):
-                    ts = ts.isoformat()
-                else:
-                    ts = str(ts)
-            else:
-                ts = datetime.utcnow().isoformat()
+            return True
+        elif response.status_code == 503:
+            print(f"[Warning] 模型未加载，请稍后重试")
+            print(f"  Response: {response.text}")
+            return False
+        else:
+            print(f"[Error] {response.text}")
+            return False
             
-            result.append({
-                "timestamp": ts,
-                "open": float(row["open"]),
-                "high": float(row["high"]),
-                "low": float(row["low"]),
-                "close": float(row["close"]),
-                "volume": float(row["volume"]),
-                "amount": float(row["amount"]) if "amount" in df.columns else None
-            })
-        
-        return result
+    except requests.exceptions.Timeout:
+        print(f"[Error] 请求超时 (>120s)")
+        return False
+    except requests.exceptions.RequestException as e:
+        print(f"[Error] 请求失败: {e}")
+        return False
 
 
-# ==================== 使用示例 ====================
-
-if __name__ == "__main__":
-    import asyncio
-    
-    # 示例数据 (实际使用时替换为真实数据)
-    def create_sample_data() -> pd.DataFrame:
-        """创建示例数据"""
-        import numpy as np
-        
-        np.random.seed(42)
-        n = 120
-        
-        dates = pd.date_range(start="2024-01-01", periods=n, freq="1h")
-        base_price = 42000
-        
-        prices = [base_price]
-        for i in range(1, n):
-            change = np.random.randn() * 100
-            prices.append(prices[-1] + change)
-        
-        df = pd.DataFrame({
-            "timestamp": dates,
-            "open": prices,
-            "high": [p + np.random.rand() * 50 for p in prices],
-            "low": [p - np.random.rand() * 50 for p in prices],
-            "close": [p + np.random.randn() * 20 for p in prices],
-            "volume": np.random.rand(n) * 1000 + 100
-        })
-        
-        return df
-    
-    # 同步示例
-    def sync_example():
-        print("=== 同步客户端示例 ===")
-        
-        # 创建客户端
-        client = KronosClient("http://localhost:7860")
-        
-        try:
-            # 健康检查
-            health = client.health()
-            print(f"Status: {health.status}")
-            print(f"Model loaded: {health.model_loaded}")
+def test_signal(base_url: str, data: List[Dict] = None) -> bool:
+    """测试交易信号 API"""
+    print("\n" + "="*60)
+    print("  TEST: /signal")
+    print("="*60)
+    
+    # 获取数据
+    if data is None:
+        data = fetch_btc_data(limit=200)
+    
+    url = f"{base_url}/signal"
+    payload = {
+        "data": data,
+        "buy_threshold": 0.58,
+        "sell_threshold": 0.42,
+        "stop_loss": 0.03,
+        "take_profit": 0.08,
+        "n_paths": 30
+    }
+    
+    print(f"\n[Request] POST {url}")
+    print(f"  数据点数:     {len(data)}")
+    print(f"  买入阈值:     {payload['buy_threshold']}")
+    print(f"  卖出阈值:     {payload['sell_threshold']}")
+    print(f"  止损比例:     {payload['stop_loss']*100:.1f}%")
+    print(f"  止盈比例:     {payload['take_profit']*100:.1f}%")
+    
+    try:
+        start = time.time()
+        response = requests.post(url, json=payload, timeout=120)
+        elapsed = time.time() - start
+        
+        print(f"\n[Response] Status: {response.status_code} ({elapsed:.2f}s)")
+        
+        if response.status_code == 200:
+            result = response.json()
+            signal = result.get('signal', 'N/A')
             
-            # 创建示例数据
-            df = create_sample_data()
-            print(f"\n数据点数: {len(df)}")
+            # 信号颜色
+            signal_icons = {
+                'STRONG_BUY': '[++]',
+                'BUY': '[+]',
+                'HOLD': '[=]',
+                'SELL': '[-]',
+                'STRONG_SELL': '[--]'
+            }
             
-            # 预测
-            prediction = client.predict(df, pred_len=24)
-            print(f"\n预测结果:")
-            print(prediction)
+            print(f"\n[Result]")
+            print(f"  信号:         {signal_icons.get(signal, '')} {signal}")
+            print(f"  置信度:       {result.get('confidence', 0)*100:.1f}%")
+            print(f"  当前价格:     ${result.get('current_price', 0):,.2f}")
+            print(f"  目标价格:     ${result.get('target_price', 0):,.2f}")
+            print(f"  止损价格:     ${result.get('stop_loss_price', 0):,.2f}")
+            print(f"  止盈价格:     ${result.get('take_profit_price', 0):,.2f}")
+            print(f"  上涨概率:     {result.get('upside_probability', 0)*100:.1f}%")
+            print(f"  预期收益:     {result.get('expected_return', 0)*100:.2f}%")
+            print(f"  建议仓位:     {result.get('suggested_position_size', 0)*100:.1f}%")
+            print(f"  原因:         {result.get('reason', 'N/A')}")
             
-            # 交易信号
-            signal = client.get_signal(df)
-            print(f"\n交易信号:")
-            print(signal)
+            return True
+        elif response.status_code == 503:
+            print(f"[Warning] 模型未加载，请稍后重试")
+            print(f"  Response: {response.text}")
+            return False
+        else:
+            print(f"[Error] {response.text}")
+            return False
             
-        except KronosClientError as e:
-            print(f"Error: {e}")
-        finally:
-            client.close()
-    
-    # 异步示例
-    async def async_example():
-        print("\n=== 异步客户端示例 ===")
-        
-        async with AsyncKronosClient("http://localhost:7860") as client:
-            try:
-                # 健康检查
-                health = await client.health()
-                print(f"Status: {health.status}")
-                
-                # 创建示例数据
-                df = create_sample_data()
-                
-                # 并发预测和信号
-                prediction, signal = await asyncio.gather(
-                    client.predict(df),
-                    client.get_signal(df)
-                )
-                
-                print(f"\n预测结果:")
-                print(prediction)
-                print(f"\n交易信号:")
-                print(signal)
-                
-            except KronosClientError as e:
-                print(f"Error: {e}")
-    
-    # 运行示例
-    print("Kronos Client SDK 示例\n")
-    print("注意: 请确保 API 服务已启动 (python app.py)\n")
-    
-    # 仅打印帮助信息，不实际运行
-    print("同步使用:")
-    print("  client = KronosClient('http://localhost:7860')")
-    print("  prediction = client.predict(df)")
-    print("  signal = client.get_signal(df)")
-    print()
-    print("异步使用:")
-    print("  async with AsyncKronosClient('http://localhost:7860') as client:")
-    print("      prediction = await client.predict(df)")
-    print("      signal = await client.get_signal(df)")
+    except requests.exceptions.Timeout:
+        print(f"[Error] 请求超时 (>120s)")
+        return False
+    except requests.exceptions.RequestException as e:
+        print(f"[Error] 请求失败: {e}")
+        return False
+
+
+def run_all_tests(base_url: str) -> bool:
+    """运行所有测试"""
+    print("\n" + "#"*60)
+    print("#")
+    print("#  Kronos BTC 预测 API 测试")
+    print(f"#  URL: {base_url}")
+    print(f"#  时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("#")
+    print("#"*60)
+    
+    results = {}
+    
+    # 1. 健康检查
+    results['health'] = test_health(base_url)
+    
+    if not results['health']:
+        print("\n[Warning] 健康检查失败，API 可能未启动")
+        print("  请检查 HuggingFace Space 是否正在运行")
+        return False
+    
+    # 2. 获取数据 (只获取一次，两个测试共用)
+    print("\n" + "-"*60)
+    data = fetch_btc_data(limit=200)
+    
+    # 3. 预测测试
+    results['predict'] = test_predict(base_url, data)
+    
+    # 4. 信号测试
+    results['signal'] = test_signal(base_url, data)
+    
+    # 汇总
+    print("\n" + "="*60)
+    print("  测试结果汇总")
+    print("="*60)
+    
+    for test_name, passed in results.items():
+        status = "PASS" if passed else "FAIL"
+        icon = "[OK]" if passed else "[X]"
+        print(f"  {icon} {test_name}: {status}")
+    
+    all_passed = all(results.values())
+    
+    print("\n" + "-"*60)
+    if all_passed:
+        print("  所有测试通过!")
+    else:
+        print("  部分测试失败，请检查 API 状态")
+    print("-"*60)
+    
+    return all_passed
+
+
+# ==================== 主函数 ====================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Kronos BTC 预测 API 测试客户端",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  python client.py health              # 测试健康检查
+  python client.py predict             # 测试预测 API
+  python client.py signal              # 测试交易信号 API
+  python client.py all                 # 运行所有测试
+  python client.py all --url http://localhost:7860  # 测试本地服务
+        """
+    )
+    
+    parser.add_argument(
+        "command",
+        choices=["health", "predict", "signal", "all"],
+        help="要执行的测试命令"
+    )
+    
+    parser.add_argument(
+        "--url",
+        default=DEFAULT_API_URL,
+        help=f"API 地址 (默认: {DEFAULT_API_URL})"
+    )
+    
+    args = parser.parse_args()
+    
+    # 执行测试
+    if args.command == "health":
+        success = test_health(args.url)
+    elif args.command == "predict":
+        success = test_predict(args.url)
+    elif args.command == "signal":
+        success = test_signal(args.url)
+    elif args.command == "all":
+        success = run_all_tests(args.url)
+    else:
+        parser.print_help()
+        sys.exit(1)
+    
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

models/predictor/model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:28271e7c248da93c5954ee72eb7c066b986958ba5159f0be4db5c8a423ab5d74
+oid sha256:ee1a282b63487e18f0b0c2fea391a4ea335ee79e61708fecd5e2ac1d37eb5644
 size 16440776

models/tokenizer/model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:983c247a275272480aeb6d6b0cb21733fc26d1315aed6e7a4cd2ea0590bbaef5
+oid sha256:0198724df098fd7f6088ed39277089afa0150c6f533c0ce067f4483a8e8ba6a7
 size 15842376

requirements.txt

@@ -10,7 +10,6 @@ pydantic==2.5.2
 torch==2.1.0
 numpy>=1.24.0,<2.0.0
 pandas>=2.0.0
-einops>=0.7.0
 
 # Model loading
 safetensors>=0.4.0