Sync from GitHub Actions

CLAUDE.md

@@ -107,7 +107,7 @@ POST /nbeats/evaluate                 → 훈련/테스트 분리 평가
 POST /api/{prophet,arima,xgboost,ets,lightgbm,theta}/predict
 GET  /api/{prophet,arima,xgboost,ets,lightgbm,theta}/parameters
 
-POST /api/hybrid/predict              → 7모델 앙상블 (file + forecast_horizon(1~500)만 수신)
+POST /api/hybrid/predict              → 7모델 앙상블 (file + forecast_horizon(1~500) + model_weights(JSON, 선택))
 GET  /api/timesfm/status              → TimesFM 로딩 상태 (not_loaded|loading|loaded|error)
 POST /api/timesfm/predict             → TimesFM 제로샷 예측
 ```
@@ -177,6 +177,8 @@ class DataProfile:
 앙상블 가중치도 DataProfile로 조정된다 (ensemble_service.py):
 volatility > 0.3 → nbeats·prophet +0.05, trend stable → ets·theta +0.05,
 구조 변화점 존재 → xgboost·lightgbm +0.05, 합계 1.0 정규화.
+`model_weights`(JSON, 선택)로 수동 가중치를 넘기면 자동 조정 대신 사용되며,
+가중치 0인 모델은 실행 자체를 건너뛴다 (양수 모델 2개 미만이면 422).
 
 ---
 

main.py

@@ -83,7 +83,10 @@ from src.domains.time_series_prediction.theta_service import (
     predict_with_theta,
     evaluate_with_theta,
 )
-from src.domains.time_series_prediction.ensemble_service import run_ensemble_async
+from src.domains.time_series_prediction.ensemble_service import (
+    normalize_manual_weights,
+    run_ensemble_async,
+)
 
 logging.basicConfig(
     level=logging.INFO,
@@ -580,12 +583,26 @@ async def hybrid_page():
 async def hybrid_predict(
     file: UploadFile = File(...),
     forecast_horizon: int = Form(30, ge=1, le=500),
+    model_weights: Optional[str] = Form(None),
 ):
-    """7개 모델 앙상블 예측 (가중 평균 + 모델 간 불확실성 구간)."""
+    """7개 모델 앙상블 예측 (가중 평균 + 모델 간 불확실성 구간).
+
+    model_weights(JSON, 선택): 모델별 수동 가중치. 미전송 시 DataProfile 자동 가중치.
+    """
     try:
+        manual = None
+        if model_weights:
+            try:
+                parsed = json.loads(model_weights)
+                if not isinstance(parsed, dict):
+                    raise ValueError("model_weights는 JSON 객체여야 합니다.")
+                manual = normalize_manual_weights(parsed)
+            except ValueError as exc:  # JSONDecodeError 포함
+                raise HTTPException(status_code=422, detail=f"model_weights 오류: {exc}")
+
         df = await _load_validated_df(file)
 
-        ensemble = await run_ensemble_async(df, forecast_horizon)
+        ensemble = await run_ensemble_async(df, forecast_horizon, manual_weights=manual)
         if not ensemble.get("success"):
             raise HTTPException(status_code=422, detail=ensemble.get("error", "앙상블 실패"))
 

src/domains/time_series_prediction/ensemble_service.py

@@ -70,6 +70,36 @@ def compute_model_weights(data_profile: DataProfile) -> dict[str, float]:
     return {k: v / total for k, v in weights.items()}
 
 
+def normalize_manual_weights(weights: dict) -> dict[str, float]:
+    """
+    사용자 지정 가중치 검증·정규화.
+
+    - 모델명은 _DEFAULT_WEIGHTS 키만 허용, 미지정 모델은 0(실행 제외)
+    - 음수·비숫자·비유한 값 거부
+    - 양수 가중치 모델이 2개 미만이면 앙상블 불가로 거부
+    - 합계 1.0으로 정규화해 반환
+    """
+    unknown = set(weights) - set(_DEFAULT_WEIGHTS)
+    if unknown:
+        raise ValueError(f"알 수 없는 모델명: {sorted(unknown)}")
+
+    normalized: dict[str, float] = {}
+    for name in _DEFAULT_WEIGHTS:
+        v = weights.get(name, 0)
+        if isinstance(v, bool) or not isinstance(v, (int, float)) or not np.isfinite(v):
+            raise ValueError(f"{name} 가중치는 0 이상의 숫자여야 합니다: {v!r}")
+        if v < 0:
+            raise ValueError(f"{name} 가중치는 음수일 수 없습니다: {v}")
+        normalized[name] = float(v)
+
+    positive = [n for n, v in normalized.items() if v > 0]
+    if len(positive) < 2:
+        raise ValueError("양수 가중치 모델이 2개 이상 필요합니다 (앙상블 최소 구성).")
+
+    total = sum(normalized.values())
+    return {k: v / total for k, v in normalized.items()}
+
+
 def _df_to_data_list(result_df: pd.DataFrame) -> list[dict]:
     """모델 결과 DataFrame을 dict 리스트로 변환."""
     rows = []
@@ -178,17 +208,24 @@ def aggregate_predictions(
     }
 
 
-async def run_ensemble_async(df: pd.DataFrame, forecast_horizon: int) -> dict:
+async def run_ensemble_async(
+    df: pd.DataFrame,
+    forecast_horizon: int,
+    manual_weights: Optional[dict[str, float]] = None,
+) -> dict:
     """
     7개 모델을 비동기 병렬 실행 후 앙상블 결과 반환.
 
     각 모델은 run_in_executor로 ThreadPool에서 실행한다.
     실패한 모델은 제외하고 성공 모델만 집계.
     성공 모델이 2개 미만이면 오류를 반환한다.
+
+    manual_weights가 주어지면 DataProfile 자동 가중치 대신 사용하며,
+    가중치 0인 모델은 실행 자체를 건너뛴다.
     """
     values = df["y"].values
     data_profile = profile_series(values, df=df)
-    weights = compute_model_weights(data_profile)
+    weights = manual_weights if manual_weights is not None else compute_model_weights(data_profile)
 
     loop = asyncio.get_running_loop()
 
@@ -203,6 +240,10 @@ async def run_ensemble_async(df: pd.DataFrame, forecast_horizon: int) -> dict:
         ("theta",     predict_with_theta,     lambda: apply_theta_defaults({})),
     ]
 
+    # 수동 가중치에서 0인 모델은 실행하지 않는다 (시간 절약 + 명시적 제외)
+    if manual_weights is not None:
+        model_configs = [c for c in model_configs if manual_weights.get(c[0], 0) > 0]
+
     async def _run_one(name: str, fn, params: dict) -> tuple[str, Optional[dict]]:
         """단일 모델을 ThreadPool에서 실행. 180초 초과 시 타임아웃으로 제외."""
         async with _MODEL_SEMAPHORE:

static/hybrid.html

@@ -217,6 +217,52 @@
       margin-top: 0.2rem;
     }
 
+    .weight-mode-row {
+      display: flex;
+      gap: 1.25rem;
+      font-size: 0.85rem;
+    }
+
+    .weight-mode-row .radio-label {
+      display: flex;
+      align-items: center;
+      gap: 0.35rem;
+      cursor: pointer;
+      color: var(--text);
+      font-size: 0.85rem;
+      font-weight: 400;
+      text-transform: none;
+      letter-spacing: normal;
+    }
+
+    .weights-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(105px, 1fr));
+      gap: 0.5rem;
+      margin-top: 0.4rem;
+    }
+
+    .weight-item label {
+      display: block;
+      font-size: 0.68rem;
+      font-weight: 400;
+      color: var(--text-muted);
+      margin-bottom: 0.2rem;
+      text-transform: none;
+      letter-spacing: normal;
+    }
+
+    .weight-item input {
+      width: 100%;
+      padding: 0.35rem 0.5rem;
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      background: var(--bg);
+      color: var(--accent);
+      font-size: 0.85rem;
+      font-family: 'JetBrains Mono', monospace;
+    }
+
     .opt-group input:focus {
       outline: none;
       border-color: var(--accent);
@@ -472,6 +518,17 @@
           </div>
           <div class="freq-hint" id="freqHint">파일 업로드 시 자동 감지</div>
         </div>
+
+        <div class="opt-group">
+          <label>모델 가중치</label>
+          <div class="weight-mode-row">
+            <label class="radio-label"><input type="radio" name="weightMode" value="auto" checked> 자동 (데이터 특성 기반)</label>
+            <label class="radio-label"><input type="radio" name="weightMode" value="manual"> 수동</label>
+          </div>
+          <div class="weights-grid" id="weightsGrid" style="display:none;"></div>
+          <div class="freq-hint" id="weightsHint" style="display:none;">
+            합계는 자동으로 1로 정규화 · 0 = 해당 모델 제외 (양수 가중치 모델 2개 이상 필요)</div>
+        </div>
       </div>
 
       <div class="actions">
@@ -506,7 +563,7 @@
         </div>
         <div class="card">
           <div class="card-title">앙상블 방식</div>
-          <p style="color:var(--text-muted);font-size:0.875rem;line-height:1.7;">7개 모델을 병렬 실행한 뒤 데이터 특성(변동성·추세·구조 변화)에 따라 가중치를 조정해 평균합니다. 불확실성 구간은 모델 간 예측 표준편차(±1.96σ)로 산출됩니다.</p>
+          <p id="ensembleMethodDesc" style="color:var(--text-muted);font-size:0.875rem;line-height:1.7;"></p>
         </div>
       </div>
 
@@ -594,19 +651,105 @@
       freqHint.textContent = `감지된 주기: ${info.label} 단위`;
     }
 
+    // ─── 모델 가중치 패널 (자동/수동) ───
+    // 기본값은 ensemble_service._DEFAULT_WEIGHTS와 동일
+    const WEIGHT_MODELS = [
+      ['nbeats', 'N-BEATS', 0.20], ['prophet', 'Prophet', 0.20],
+      ['arima', 'ARIMA', 0.15], ['xgboost', 'XGBoost', 0.15],
+      ['lightgbm', 'LightGBM', 0.15], ['ets', 'ETS', 0.10], ['theta', 'Theta', 0.05],
+    ];
+    const weightsGrid = document.getElementById('weightsGrid');
+    const weightsHint = document.getElementById('weightsHint');
+
+    WEIGHT_MODELS.forEach(([key, label, def]) => {
+      const item = document.createElement('div');
+      item.className = 'weight-item';
+      const lab = document.createElement('label');
+      lab.textContent = label;
+      lab.setAttribute('for', `weight-${key}`);
+      const input = document.createElement('input');
+      input.type = 'number';
+      input.id = `weight-${key}`;
+      input.min = '0';
+      input.step = '0.05';
+      input.value = def;
+      item.append(lab, input);
+      weightsGrid.appendChild(item);
+    });
+
+    function isManualWeightMode() {
+      return document.querySelector('input[name="weightMode"]:checked').value === 'manual';
+    }
+
+    function resetWeightPanel() {
+      document.querySelector('input[name="weightMode"][value="auto"]').checked = true;
+      WEIGHT_MODELS.forEach(([key, , def]) => {
+        document.getElementById(`weight-${key}`).value = def;
+      });
+      toggleWeightPanel();
+    }
+
+    function toggleWeightPanel() {
+      const manual = isManualWeightMode();
+      weightsGrid.style.display = manual ? 'grid' : 'none';
+      weightsHint.style.display = manual ? 'block' : 'none';
+    }
+
+    document.querySelectorAll('input[name="weightMode"]').forEach(r =>
+      r.addEventListener('change', toggleWeightPanel));
+
+    // 수동 가중치 수집·검증. 유효하면 {모델: 가중치}, 아니면 오류 문자열 반환.
+    function collectManualWeights() {
+      const weights = {};
+      for (const [key, label] of WEIGHT_MODELS) {
+        const v = parseFloat(document.getElementById(`weight-${key}`).value);
+        if (!isFinite(v) || v < 0) return `${label} 가중치는 0 이상의 숫자여야 합니다.`;
+        weights[key] = v;
+      }
+      const positive = Object.values(weights).filter(v => v > 0).length;
+      if (positive < 2) return '양수 가중치 모델이 2개 이상 필요합니다.';
+      return weights;
+    }
+
+    // 백엔드(data_service)가 ds로 매핑하는 컬럼명과 동일하게 유지
+    const DATE_HEADERS = ['ds', 'date', 'time', 'datetime'];
+
+    function extractDatesFromRows(rows) {
+      if (rows.length < 3) return null;
+      const header = rows[0].map(h => String(h).trim().toLowerCase().replace(/"/g, ''));
+      const dateIdx = header.findIndex(h => DATE_HEADERS.includes(h));
+      if (dateIdx < 0) return null;
+      return rows.slice(1, 12)
+        .map(r => (r[dateIdx] != null && r[dateIdx] !== '') ? r[dateIdx] : null)
+        .filter(v => v != null);
+    }
+
     async function detectFreqFromFile(file) {
       const name = file.name.toLowerCase();
-      if (!name.endsWith('.csv')) return false;
-      const text = await file.text();
-      const lines = text.split('\n').filter(l => l.trim());
-      if (lines.length < 3) return false;
-      const header = lines[0].split(',').map(h => h.trim().toLowerCase().replace(/"/g, ''));
-      const dateIdx = header.findIndex(h => h === 'date' || h === 'ds');
-      if (dateIdx < 0) return false;
-      const dates = lines.slice(1, 12).map(l => {
-        const cols = l.split(',');
-        return cols[dateIdx] ? cols[dateIdx].trim().replace(/"/g, '') : '';
-      }).filter(Boolean);
+      let dates = null;
+
+      if (name.endsWith('.csv')) {
+        const text = await file.text();
+        const lines = text.split('\n').filter(l => l.trim());
+        const rows = lines.map(l => l.split(',').map(c => c.trim().replace(/"/g, '')));
+        dates = extractDatesFromRows(rows);
+      } else if (name.endsWith('.xlsx') || name.endsWith('.xls')) {
+        const buf = await file.arrayBuffer();
+        const wb = XLSX.read(buf, { type: 'array', cellDates: true });
+        const rows = XLSX.utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]], { header: 1, raw: true });
+        dates = extractDatesFromRows(rows);
+      } else if (name.endsWith('.json')) {
+        const arr = JSON.parse(await file.text());
+        if (Array.isArray(arr) && arr.length >= 2 && typeof arr[0] === 'object') {
+          const keys = Object.keys(arr[0]);
+          const dateKey = keys.find(k => DATE_HEADERS.includes(k.trim().toLowerCase()));
+          if (dateKey) dates = arr.slice(0, 11).map(r => r[dateKey]).filter(v => v != null);
+        }
+      } else {
+        return false;
+      }
+
+      if (!dates) return false;
       const freq = detectFreqFromDates(dates);
       if (freq) { applyFreq(freq); return true; }
       return false;
@@ -637,18 +780,30 @@
       predictBtn.disabled = true;
       statusEl.className = 'status';
       resultsSection.classList.remove('visible');
+      resetWeightPanel();
       if (mainChart) { mainChart.destroy(); mainChart = null; }
       if (weightsChart) { weightsChart.destroy(); weightsChart = null; }
     });
 
     predictBtn.addEventListener('click', async () => {
       if (!fileInput.files[0]) return;
-      setStatus('loading', '<span class="spinner"></span>7개 모델 병렬 실행 중... (최대 2분 소요)');
+
+      let manualWeights = null;
+      let modelCount = 7;
+      if (isManualWeightMode()) {
+        const collected = collectManualWeights();
+        if (typeof collected === 'string') { setStatus('error', collected); return; }
+        manualWeights = collected;
+        modelCount = Object.values(collected).filter(v => v > 0).length;
+      }
+
+      setStatus('loading', `<span class="spinner"></span>${modelCount}개 모델 병렬 실행 중... (최대 2분 소요)`);
       predictBtn.disabled = true;
 
       const formData = new FormData();
       formData.append('file', fileInput.files[0]);
       formData.append('forecast_horizon', document.getElementById('forecastHorizon').value);
+      if (manualWeights) formData.append('model_weights', JSON.stringify(manualWeights));
 
       try {
         const res = await fetch('/api/hybrid/predict', { method: 'POST', body: formData });
@@ -658,6 +813,9 @@
           return;
         }
         renderResults(json);
+        document.getElementById('ensembleMethodDesc').textContent = manualWeights
+          ? `사용자 지정 가중치로 ${modelCount}개 모델을 병렬 실행해 평균합니다. 불확실성 구간은 모델 간 예측 표준편차(±1.96σ)로 산출됩니다.`
+          : '7개 모델을 병렬 실행한 뒤 데이터 특성(변동성·추세·구조 변화)에 따라 가중치를 조정해 평균합니다. 불확실성 구간은 모델 간 예측 표준편차(±1.96σ)로 산출됩니다.';
         latestResult = json;
         setStatus('success', `예측 완료 — 사용 모델: ${(json.models_used || []).map(escHtml).join(', ')}`);
         resultsSection.classList.add('visible');