Deploy approved upload classification regression and forecasting

Dockerfile

@@ -6,14 +6,14 @@ WORKDIR /app
 COPY --chown=user:user requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY --chown=user:user app.py .
+COPY --chown=user:user app.py upload_predict.py .
 USER user
 ENV HOME=/home/user \
     HF_HOME=/home/user/.cache/huggingface \
     PYTHONUNBUFFERED=1
 
 # 공개 체크포인트를 이미지 빌드 때 받아 첫 요청의 다운로드 지연을 없앤다.
-RUN python -c "from huggingface_hub import hf_hub_download; hf_hub_download(repo_id='jingang/TabICL', filename='tabicl-classifier-v2-20260212.ckpt')"
+RUN python -c "from huggingface_hub import hf_hub_download; hf_hub_download(repo_id='jingang/TabICL', filename='tabicl-classifier-v2-20260212.ckpt'); hf_hub_download(repo_id='jingang/TabICL', filename='tabicl-regressor-v2-20260212.ckpt')"
 
 EXPOSE 7860
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -8,4 +8,6 @@ app_port: 7860
 license: bsd-3-clause
 ---
 
-ONTIC 공개 제품 미리보기에서 사용하는 합성 데이터 전용 TabICL 추론 API.
+ONTIC 공개 제품 미리보기에서 사용하는 합성 데모 및 사용자 업로드 표의 분류·회귀·시계열 예측 API.
+
+`/predict-upload`는 익명 숫자 행렬과 정답, 시계열 날짜를 받아 실제 TabICL 추론과 보류 검증을 실행한다. 입력 행은 저장하지 않는다. 분류·회귀는 최대 1,000개 과거 사례·30개 변수·100개 예측 대상, 시계열은 최대 1,000개 관측과 24개 미래 기간으로 제한한다.

app.py

@@ -1,16 +1,23 @@
-"""ONTIC 정적 데모용 실제 TabICL 추론 API — 합성 예시 데이터만 취급한다."""
+"""ONTIC 실제 TabICL 추론 API — 합성 데모와 승인된 사용자 표를 처리한다."""
 from __future__ import annotations
 
 from copy import deepcopy
 from importlib.metadata import version
+import json
+import logging
 from threading import Lock
 from time import perf_counter
+from typing import Annotated
+from uuid import UUID, uuid4
 
 import numpy as np
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 from tabicl import TabICLClassifier
+from upload_predict import router as upload_router
 
 HF_REPO = "jingang/TabICL"
 CHECKPOINT = "tabicl-classifier-v2-20260212.ckpt"
@@ -20,13 +27,60 @@ ALLOWED_ORIGINS = [
     "http://localhost:8787",
 ]
 
-app = FastAPI(title="ONTIC TabICL Demo API", version="1.0.0")
+app = FastAPI(title="ONTIC TabICL Demo API", version="2.0.0")
+app.include_router(upload_router)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=ALLOWED_ORIGINS,
     allow_methods=["GET", "POST", "OPTIONS"],
     allow_headers=["Content-Type"],
 )
+logger = logging.getLogger("uvicorn.error")
+
+@app.exception_handler(RequestValidationError)
+async def input_error(request, exc):
+    if request.url.path != '/predict-upload':
+        from fastapi.exception_handlers import request_validation_exception_handler
+        return await request_validation_exception_handler(request, exc)
+    messages = [e['msg'].removeprefix('Value error, ') for e in exc.errors() if e['type'] == 'value_error']
+    detail = messages[0] if messages else '입력 크기·자료형·필수 필드를 확인해 주세요.'
+    return JSONResponse(status_code=422, content={'detail': detail})
+
+
+
+@app.middleware("http")
+async def log_request_status(request: Request, call_next):
+    try:
+        request_id = str(UUID(request.headers.get("x-request-id", "")))
+    except ValueError:
+        request_id = str(uuid4())
+    started = perf_counter()
+    try:
+        if request.url.path == '/predict-upload':
+            chunks = []
+            size = 0
+            async for chunk in request.stream():
+                size += len(chunk)
+                if size > 512000:
+                    return JSONResponse(status_code=413, content={'detail': '예측 요청은 500KB 이하로 줄여 주세요.'})
+                chunks.append(chunk)
+            request._body = b''.join(chunks)
+        response = await call_next(request)
+    except Exception:
+        response = JSONResponse(
+            status_code=500,
+            content={"detail": "요청을 처리하지 못했습니다. 잠시 후 다시 시도해 주세요."},
+        )
+    status = response.status_code
+    response.headers["x-request-id"] = request_id
+    logger.info(json.dumps({
+        "request_id": request_id,
+        "stage": "hf_demo" if request.url.path == "/demo" else "hf_request",
+        "status": status,
+        "code": "ok" if status < 400 else "invalid_request" if status == 422 else "request_failed",
+        "elapsed_ms": round((perf_counter() - started) * 1000, 1),
+    }))
+    return response
 
 
 SCENARIOS = {
@@ -37,7 +91,8 @@ SCENARIOS = {
         "features": ["문의 증가", "구매 간격", "주문 금액 감소", "방문 감소"],
         "weights": [1.2, 1.0, 0.8, 0.55],
         "queries": [[0.5, 0.4, 0.3, 0.2], [0.35, 0.3, 0.2, 0.15], [0.25, 0.2, 0.15, 0.1], [0.15, 0.1, 0.1, 0.05], [0.05, 0.05, 0.0, 0.0]],
-        "summary": "최근 문의 증가와 구매 간격 확대가 함께 나타난 고객을 우선 검토합니다.",
+        "entity": "고객",
+        "risk": "이탈 위험",
     },
     "stockout": {
         "seed": 84,
@@ -46,7 +101,8 @@ SCENARIOS = {
         "features": ["수요 속도", "재고 소진", "공급 지연", "미처리 주문"],
         "weights": [1.1, 1.25, 0.85, 0.65],
         "queries": [[0.5, 0.45, 0.3, 0.2], [0.35, 0.3, 0.25, 0.15], [0.25, 0.2, 0.15, 0.1], [0.15, 0.1, 0.05, 0.05], [0.05, 0.0, 0.05, 0.0]],
-        "summary": "수요 속도와 예상 재고 소진 시점을 함께 보고 보충 우선순위를 정합니다.",
+        "entity": "품목",
+        "risk": "재고 부족 위험",
     },
     "defect": {
         "seed": 126,
@@ -55,17 +111,30 @@ SCENARIOS = {
         "features": ["온도 편차", "진동 증가", "비가동 시간", "작업 변경"],
         "weights": [1.25, 1.15, 0.7, 0.5],
         "queries": [[0.5, 0.4, 0.3, 0.2], [0.35, 0.3, 0.2, 0.15], [0.25, 0.2, 0.15, 0.1], [0.15, 0.1, 0.1, 0.05], [0.05, 0.05, 0.0, 0.0]],
-        "summary": "공정 온도 편차와 진동 증가가 겹친 배치를 우선 점검합니다.",
+        "entity": "생산 배치",
+        "risk": "불량 발생 위험",
     },
 }
+QUESTION_SCENARIOS = {spec["question"]: key for key, spec in SCENARIOS.items()}
 
 _lock = Lock()
 _cache: dict[str, dict] = {}
 
 
 class DemoRequest(BaseModel):
-    question: str = Field(default=SCENARIOS["churn"]["question"], max_length=200)
-    selected_features: list[int] = Field(default_factory=lambda: [0, 1, 2, 3])
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    question: str = Field(min_length=1, max_length=200)
+    selected_features: list[Annotated[int, Field(strict=True, ge=0, le=3)]] = Field(
+        min_length=1, max_length=4
+    )
+
+    @field_validator("selected_features")
+    @classmethod
+    def unique_features(cls, selected: list[int]) -> list[int]:
+        if len(selected) != len(set(selected)):
+            raise ValueError("예측 기준은 중복 없이 선택해 주세요.")
+        return selected
 
 
 def model_info() -> dict:
@@ -81,23 +150,29 @@ def model_info() -> dict:
 
 
 def scenario_for(question: str) -> str:
-    if "재고" in question or "품목" in question:
-        return "stockout"
-    if "불량" in question or "생산" in question or "배치" in question:
-        return "defect"
-    return "churn"
+    if question not in QUESTION_SCENARIOS:
+        raise HTTPException(
+            status_code=422,
+            detail="지원하지 않는 질문입니다. 공개 데모의 이탈·재고·불량 예시 질문만 사용할 수 있습니다.",
+        )
+    return QUESTION_SCENARIOS[question]
 
 
 def infer_scenario(key: str, selected_features: list[int]) -> tuple[dict, bool]:
-    selected = tuple(sorted(set(selected_features)))
-    if not selected or any(index < 0 or index > 3 for index in selected):
+    if (
+        not selected_features
+        or any(type(index) is not int or index < 0 or index > 3 for index in selected_features)
+        or len(selected_features) != len(set(selected_features))
+    ):
         raise HTTPException(status_code=422, detail="Select at least one valid feature index (0-3).")
+    selected = tuple(sorted(selected_features))
     cache_key = f"{key}:{','.join(map(str, selected))}"
     with _lock:
         if cache_key in _cache:
             return deepcopy(_cache[cache_key]), True
 
         spec = SCENARIOS[key]
+        selected_feature_names = [spec["features"][index] for index in selected]
         rng = np.random.default_rng(spec["seed"])
         context = rng.normal(size=(96, 4))
         weights = np.asarray(spec["weights"], dtype=float)
@@ -128,7 +203,7 @@ def infer_scenario(key: str, selected_features: list[int]) -> tuple[dict, bool]:
         signals = sorted(
             [
                 {"feature": feature, "value": round(float(value), 2)}
-                for feature, value in zip((spec["features"][index] for index in selected), top_query)
+                for feature, value in zip(selected_feature_names, top_query)
             ],
             key=lambda item: abs(item["value"]),
             reverse=True,
@@ -136,12 +211,16 @@ def infer_scenario(key: str, selected_features: list[int]) -> tuple[dict, bool]:
         result = {
             "scenario": key,
             "question": spec["question"],
-            "summary": spec["summary"],
+            "summary": (
+                f"합성 {spec['entity']} 데이터에서 선택한 {', '.join(selected_feature_names)} "
+                f"기준으로 {spec['risk']} 순위를 계산했습니다."
+            ),
             "data": "synthetic_demo",
             "model": model_info(),
             "predictions": predictions,
             "signals": signals,
             "selected_features": list(selected),
+            "selected_feature_names": selected_feature_names,
             "seconds": round(elapsed, 3),
         }
         _cache[cache_key] = result
@@ -151,7 +230,7 @@ def infer_scenario(key: str, selected_features: list[int]) -> tuple[dict, bool]:
 @app.get("/")
 @app.get("/health")
 def health() -> dict:
-    return {"ok": True, "model": model_info(), "scenarios": list(SCENARIOS)}
+    return {"ok": True, "model": model_info(), "scenarios": list(SCENARIOS), "upload_modes": ["classification", "regression", "forecast"]}
 
 
 @app.post("/demo")

requirements.txt

@@ -1,5 +1,5 @@
 fastapi==0.141.1
 numpy==2.5.3
-tabicl==2.2.0
+tabicl[forecast]==2.2.0
 torch==2.14.0
 uvicorn==0.52.4

upload_predict.py

@@ -0,0 +1,186 @@
+"""Bounded inference on user-approved anonymous tables; never logs or persists rows."""
+
+from typing import Literal
+from threading import Lock
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from fastapi import APIRouter, HTTPException
+from sklearn.metrics import accuracy_score, mean_absolute_error
+from sklearn.model_selection import train_test_split
+
+router = APIRouter()
+lock = Lock()
+REGRESSION = "tabicl-regressor-v2-20260212.ckpt"
+CLASSIFICATION = "tabicl-classifier-v2-20260212.ckpt"
+
+
+class PredictionInput(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    mode: Literal["classification", "regression", "forecast"]
+    x: list[list[float | None]] = Field(default_factory=list, max_length=1000)
+    y: list[float] = Field(min_length=12, max_length=1000)
+    query: list[list[float | None]] = Field(default_factory=list, max_length=100)
+    times: list[str] = Field(default_factory=list, max_length=1000)
+    horizon: int = Field(default=3, ge=1, le=24)
+
+    @model_validator(mode="after")
+    def check(self):
+        if not np.isfinite(self.y).all():
+            raise ValueError("정답 값은 유한한 숫자여야 합니다.")
+        if self.mode == "forecast":
+            if len(self.times) != len(self.y):
+                raise ValueError("날짜와 관측값 개수가 다릅니다.")
+            if len(self.y) < max(12, self.horizon * 3):
+                raise ValueError("예측 기간의 3배 이상, 최소 12개 시점이 필요합니다.")
+            dates = pd.to_datetime(self.times, errors="coerce")
+            if (
+                dates.isna().any()
+                or dates.has_duplicates
+                or not dates.is_monotonic_increasing
+            ):
+                raise ValueError("날짜는 중복 없이 시간순이어야 합니다.")
+            if pd.infer_freq(dates) is None:
+                raise ValueError(
+                    "일·월·연 단위 등 일정한 간격의 시계열을 선택해 주세요."
+                )
+        else:
+            if len(self.x) != len(self.y) or not self.query:
+                raise ValueError("학습 데이터와 예측 대상이 필요합니다.")
+            width = len(self.x[0])
+            if not 1 <= width <= 30 or any(
+                len(row) != width for row in self.x + self.query
+            ):
+                raise ValueError("변수 개수는 1~30개이며 모든 행이 같아야 합니다.")
+            for row in self.x + self.query:
+                if any(v is not None and not np.isfinite(v) for v in row):
+                    raise ValueError("입력값은 유한한 숫자여야 합니다.")
+            if any(all(row[i] is None for row in self.x) for i in range(width)):
+                raise ValueError("전체가 결측인 변수는 제외해 주세요.")
+            if self.mode == "classification":
+                classes, counts = np.unique(self.y, return_counts=True)
+                if len(classes) < 2 or len(classes) > 10 or counts.min() < 3:
+                    raise ValueError(
+                        "분류는 2~10종의 결과와 종류별 최소 3개 사례가 필요합니다."
+                    )
+        return self
+
+
+def infer_upload(data: PredictionInput):
+    from tabicl import TabICLClassifier, TabICLRegressor
+
+    config = dict(
+        device="cpu", n_estimators=2, random_state=42, allow_auto_download=False
+    )
+    y = np.asarray(data.y)
+    if data.mode == "forecast":
+        from tabicl import TabICLForecaster
+
+        frame = pd.DataFrame({"timestamp": pd.to_datetime(data.times), "target": y})
+        n = data.horizon
+        forecaster = TabICLForecaster(
+            tabicl_config={**config, "checkpoint_version": REGRESSION}
+        )
+        validation = forecaster.predict_df(
+            frame.iloc[:-n], prediction_length=n
+        ).reset_index()
+        mae = mean_absolute_error(y[-n:], validation["target"].to_numpy())
+        baseline = mean_absolute_error(y[-n:], np.repeat(y[-n - 1], n))
+        future = forecaster.predict_df(frame, prediction_length=n).reset_index()
+        predictions = [
+            {"time": str(row["timestamp"]), "value": float(row["target"])}
+            for _, row in future.iterrows()
+        ]
+        return dict(
+            mode=data.mode,
+            predictions=predictions,
+            validation={
+                "metric": "MAE",
+                "value": float(mae),
+                "baseline": float(baseline),
+                "rows": n,
+                "split": "마지막 기간 보류 검증",
+            },
+            checkpoint=REGRESSION,
+            context_rows=len(y),
+        )
+    x = np.asarray(data.x, dtype=float)
+    query = np.asarray(data.query, dtype=float)
+    indices = np.arange(len(y))
+    if data.mode == "classification":
+        train, test = train_test_split(
+            indices,
+            test_size=max(len(np.unique(y)), int(np.ceil(len(y) * 0.2))),
+            random_state=42,
+            stratify=y,
+        )
+        model = TabICLClassifier(**config, checkpoint_version=CLASSIFICATION)
+    else:
+        train, test = train_test_split(indices, test_size=0.2, random_state=42)
+        model = TabICLRegressor(**config, checkpoint_version=REGRESSION)
+    model.fit(x[train], y[train])
+    held = model.predict(x[test])
+    if data.mode == "classification":
+        values, counts = np.unique(y[train], return_counts=True)
+        baseline = float(np.mean(y[test] == values[counts.argmax()]))
+        validation = dict(
+            metric="accuracy",
+            value=float(accuracy_score(y[test], held)),
+            baseline=baseline,
+        )
+    else:
+        validation = dict(
+            metric="MAE",
+            value=float(mean_absolute_error(y[test], held)),
+            baseline=float(
+                mean_absolute_error(y[test], np.repeat(np.mean(y[train]), len(test)))
+            ),
+        )
+    validation.update(
+        rows=len(test), split="무작위 20% 보류 검증 (시계열에는 사용하지 않음)"
+    )
+    model.fit(x, y)
+    if data.mode == "classification":
+        probs = model.predict_proba(query)
+        predictions = [
+            dict(
+                value=float(model.classes_[row.argmax()]),
+                probabilities=[float(p) for p in row],
+            )
+            for row in probs
+        ]
+        classes = [float(c) for c in model.classes_]
+    else:
+        predictions = [dict(value=float(v)) for v in model.predict(query)]
+        classes = []
+    return dict(
+        mode=data.mode,
+        predictions=predictions,
+        classes=classes,
+        validation=validation,
+        checkpoint=CLASSIFICATION if data.mode == "classification" else REGRESSION,
+        context_rows=len(y),
+    )
+
+
+@router.post("/predict-upload")
+def predict_upload(data: PredictionInput):
+    if not lock.acquire(blocking=False):
+        raise HTTPException(
+            429, "모델이 다른 요청을 처리하고 있습니다. 잠시 후 다시 실행해 주세요."
+        )
+    try:
+        result = infer_upload(data)
+        result["real_inference"] = True
+        return result
+    except (ValueError, ImportError) as exc:
+        # Return a fixed message; exception strings may contain user values.
+        raise HTTPException(
+            422, "모델 입력이나 시계열 간격을 확인해 주세요. 지원되지 않는 형식입니다."
+        ) from exc
+    except Exception as exc:
+        raise HTTPException(
+            503, "모델을 준비하거나 계산하지 못했습니다. 잠시 후 다시 실행해 주세요."
+        ) from exc
+    finally:
+        lock.release()