Upload 6 files

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+.pytest_cache/
+.venv/
+*.pyc

Dockerfile

@@ -1,21 +1,25 @@
-# 使用官方轻量级 Python 镜像
-FROM python:3.10-slim
+FROM python:3.13-slim
 
-# 设置工作目录
-WORKDIR /app
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+ENV CUDA_VISIBLE_DEVICES=""
+ENV TRANSFORMERS_NO_ADVISORY_WARNINGS=1
+ENV HF_HUB_DISABLE_TELEMETRY=1
+ENV TIMESFM_BACKEND=baseline_cpu
+ENV TIMESFM_MAX_CONTEXT_LENGTH=512
+ENV TIMESFM_MAX_HORIZON_STEP=288
+ENV TIMESFM_MIN_REQUIRED_POINTS=32
+ENV UV_SYSTEM_PYTHON=1
 
-# 安装系统依赖 (如有需要)
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
 
-# 复制依赖文件并安装
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+COPY requirements.txt /app/requirements.txt
+RUN python -m pip install --no-cache-dir uv
+RUN uv pip install --no-cache-dir -r /app/requirements.txt
 
-# 复制代码到容器
-COPY . .
+COPY . /app
 
-# 暴露 Space 默认端口
 EXPOSE 7860
 
-# 启动命令
-CMD ["python", "app.py"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

app.py

@@ -1,44 +1,31 @@
+from __future__ import annotations
+
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-import torch
-from transformers import TimesFm2_5ModelForPrediction
-import uvicorn
-import os
 
-app = FastAPI(title="Equinai Prediction API")
+from schemas import HealthResponse, PredictRequest, PredictResponse
+from service import TimesFmService
+
+app = FastAPI(title="TimesFm Space", version="0.1.0")
+service = TimesFmService()
+
+
+@app.get("/health", response_model=HealthResponse)
+def health() -> HealthResponse:
+    return service.health()
 
-# 1. 全局加载模型
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_id = "google/timesfm-2.5-200m-transformers"
 
-print(f"Loading model to {device}...")
-model = TimesFm2_5ModelForPrediction.from_pretrained(model_id).to(device)
+@app.get("/")
+def root() -> dict[str, str]:
+    return {"service": "timesfm", "status": "ok"}
 
-class PredictRequest(BaseModel):
-    # 传入历史 K 线序列 (收盘价等)
-    inputs: list[float] 
-    # 预测步长
-    horizon: int = 24 
 
-@app.post("/predict")
-async def predict(req: PredictRequest):
+@app.post("/predict", response_model=PredictResponse)
+def predict(payload: PredictRequest) -> PredictResponse:
     try:
-        # 转换输入格式为 Tensor (Batch, Sequence_Length)
-        input_tensor = torch.tensor([req.inputs], dtype=torch.float32).to(device)
-        
-        # 执行推理
-        with torch.no_grad():
-            outputs = model(past_values=input_tensor)
-            # 根据 TimesFM 2.5 架构获取预测值
-            predictions = outputs.point_forecast # 获取点预测结果
-            
-        return {
-            "status": "success",
-            "predictions": predictions.cpu().numpy().tolist()[0]
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-if __name__ == "__main__":
-    # Space 默认监听端口为 7860
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+        return service.predict(payload)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+    except Exception as exc:  # pragma: no cover - API guardrail
+        raise HTTPException(status_code=500, detail="prediction_failed") from exc

requirements.txt

@@ -1,6 +1,3 @@
-fastapi
-uvicorn
-pydantic
-torch --index-url https://download.pytorch.org/whl/cpu  # 若用 GPU 则去掉 index-url
-transformers
-numpy
+fastapi==0.115.12
+uvicorn==0.34.0
+pydantic==2.11.3

schemas.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import List
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class HealthResponse(BaseModel):
+    status: str
+    model: str
+    model_id: str
+    backend: str
+    device: str
+    ready: bool
+    max_context_length: int
+    max_horizon_step: int
+
+
+class PredictRequest(BaseModel):
+    symbol: str = Field(..., min_length=1, max_length=32)
+    close_prices: List[float] = Field(..., min_length=8)
+    context_length: int = Field(..., ge=8, le=2048)
+    horizons: List[int] = Field(..., min_length=1, max_length=64)
+
+    @field_validator("symbol")
+    @classmethod
+    def validate_symbol(cls, value: str) -> str:
+        normalized = value.strip().upper()
+        if not normalized:
+            raise ValueError("symbol must not be empty")
+        return normalized
+
+    @field_validator("close_prices")
+    @classmethod
+    def validate_close_prices(cls, values: List[float]) -> List[float]:
+        if any(price <= 0 for price in values):
+            raise ValueError("close_prices must be positive")
+        return values
+
+    @field_validator("horizons")
+    @classmethod
+    def validate_horizons(cls, values: List[int]) -> List[int]:
+        if any(step <= 0 for step in values):
+            raise ValueError("horizons must be positive integers")
+        if len(set(values)) != len(values):
+            raise ValueError("horizons must not contain duplicates")
+        return values
+
+
+class PredictionItem(BaseModel):
+    step: int = Field(..., gt=0)
+    pred_price: float = Field(..., gt=0)
+    pred_confidence: float = Field(..., ge=0, le=1)
+
+
+class PredictResponse(BaseModel):
+    model_id: str
+    predictions: List[PredictionItem]

service.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import math
+import os
+from statistics import mean
+from typing import Any
+
+from schemas import HealthResponse, PredictRequest, PredictResponse, PredictionItem
+
+
+class TimesFmService:
+    """CPU-first HF Space service wrapper.
+
+    HuggingFace free Spaces are CPU-only in our rollout, so this service keeps
+    the HTTP contract stable and intentionally avoids any GPU assumption. The
+    default backend is a deterministic CPU baseline that is cheap to start,
+    predictable for contract tests, and compatible with `tsf-bridge`.
+    """
+
+    def __init__(self) -> None:
+        self.model_id = "timesfm"
+        self.model_name = os.getenv(
+            "TIMESFM_MODEL_NAME",
+            "google/timesfm-2.5-200m-transformers",
+        )
+        self.backend = os.getenv("TIMESFM_BACKEND", "baseline_cpu").strip() or "baseline_cpu"
+        self.device = "cpu"
+        self.ready = True
+        self.max_context_length = int(os.getenv("TIMESFM_MAX_CONTEXT_LENGTH", "512"))
+        self.max_horizon_step = int(os.getenv("TIMESFM_MAX_HORIZON_STEP", "288"))
+        self.confidence_floor = float(os.getenv("TIMESFM_CONFIDENCE_FLOOR", "0.20"))
+        self.confidence_ceiling = float(os.getenv("TIMESFM_CONFIDENCE_CEILING", "0.85"))
+        self.min_required_points = int(os.getenv("TIMESFM_MIN_REQUIRED_POINTS", "32"))
+
+    def health(self) -> HealthResponse:
+        return HealthResponse(
+            status="ok",
+            model=self.model_name,
+            model_id=self.model_id,
+            backend=self.backend,
+            device=self.device,
+            ready=self.ready,
+            max_context_length=self.max_context_length,
+            max_horizon_step=self.max_horizon_step,
+        )
+
+    def predict(self, payload: PredictRequest) -> PredictResponse:
+        self._validate_request(payload)
+        closes = payload.close_prices[-payload.context_length :]
+
+        predictions = self._predict_with_baseline(closes, payload.horizons)
+        return PredictResponse(model_id=self.model_id, predictions=predictions)
+
+    def _validate_request(self, payload: PredictRequest) -> None:
+        if payload.context_length > self.max_context_length:
+            raise ValueError(
+                f"context_length {payload.context_length} exceeds "
+                f"TIMESFM_MAX_CONTEXT_LENGTH={self.max_context_length}"
+            )
+        if payload.context_length > len(payload.close_prices):
+            raise ValueError("context_length must not exceed len(close_prices)")
+        if len(payload.close_prices) < self.min_required_points:
+            raise ValueError(
+                f"at least {self.min_required_points} close prices are required "
+                "for CPU baseline stability"
+            )
+        if any(step > self.max_horizon_step for step in payload.horizons):
+            raise ValueError(
+                f"horizons contain values above TIMESFM_MAX_HORIZON_STEP={self.max_horizon_step}"
+            )
+
+    def _predict_with_baseline(
+        self, close_prices: list[float], horizons: list[int]
+    ) -> list[PredictionItem]:
+        last_price = close_prices[-1]
+        short_window = close_prices[-min(8, len(close_prices)) :]
+        long_window = close_prices[-min(32, len(close_prices)) :]
+
+        short_mean = mean(short_window)
+        long_mean = mean(long_window)
+        momentum = 0.0 if short_mean == 0 else (last_price - short_mean) / short_mean
+        regime_bias = 0.0 if long_mean == 0 else (short_mean - long_mean) / long_mean
+
+        predictions: list[PredictionItem] = []
+        for step in horizons:
+            damped_step = math.log(step + 1.0)
+            expected_return = momentum * 0.55 + regime_bias * 0.45
+            expected_return *= min(1.0, damped_step / 3.5)
+
+            pred_price = max(0.00000001, last_price * (1.0 + expected_return))
+            confidence = self._confidence(close_prices, step, abs(expected_return))
+            predictions.append(
+                PredictionItem(
+                    step=step,
+                    pred_price=round(pred_price, 8),
+                    pred_confidence=round(confidence, 4),
+                )
+            )
+        return predictions
+
+    def _confidence(
+        self, close_prices: list[float], step: int, expected_move_abs: float
+    ) -> float:
+        if len(close_prices) < 3:
+            return self.confidence_floor
+
+        changes: list[float] = []
+        for previous, current in zip(close_prices[:-1], close_prices[1:]):
+            if previous <= 0:
+                continue
+            changes.append(abs((current - previous) / previous))
+
+        realized_vol = mean(changes[-min(32, len(changes)) :]) if changes else 0.0
+        signal_to_noise = expected_move_abs / (realized_vol + 1e-9)
+        horizon_decay = 1.0 / (1.0 + math.log(step + 1.0))
+        raw = 0.25 + min(signal_to_noise, 2.0) * 0.25 + horizon_decay * 0.35
+        return max(self.confidence_floor, min(self.confidence_ceiling, raw))
+
+    def describe_runtime(self) -> dict[str, Any]:
+        return {
+            "model_id": self.model_id,
+            "model_name": self.model_name,
+            "backend": self.backend,
+            "device": self.device,
+            "ready": self.ready,
+            "max_context_length": self.max_context_length,
+            "max_horizon_step": self.max_horizon_step,
+            "min_required_points": self.min_required_points,
+        }