Upload 3 files

src/kfold_mlp_app.py

@@ -0,0 +1,350 @@
+"""
+kfold_mlp_app.py — 피하주사 약물동태 예측 앱 (K-Fold 앙상블)
+==============================================================
+mlp_kfold.py 로 학습한 5개 fold 모델을 모두 불러와
+앙상블 평균으로 예측하고, fold 간 편차로 신뢰구간을 표시한다.
+
+사전 준비: python mlp_kfold.py 실행 후 outputs_kfold/folds/ 생성
+실행:      streamlit run kfold_mlp_app.py
+"""
+
+import matplotlib
+import matplotlib.pyplot as plt
+import io
+import numpy as np
+import pandas as pd
+import streamlit as st
+import tensorflow as tf
+import keras
+from keras import layers
+from pathlib import Path
+
+BASE_DIR    = Path(__file__).resolve().parent
+OUTPUT_DIR  = BASE_DIR / "outputs_kfold"
+FOLDS_DIR   = OUTPUT_DIR / "folds"
+
+PARAM_NAMES  = ["Lp_ve", "K", "p_le", "sigma_ve", "sigma_le",
+                "p_ve", "D_gel", "k_decay", "kf_m", "kr_m"]
+OUTPUT_NAMES = ["c_lymph", "c_vessel", "c_decay", "c_ecm"]
+LOG_TRANSFORM_PARAMS = {"K", "p_le", "p_ve", "D_gel", "k_decay", "kr_m"}
+N_PARAMS  = 10
+N_OUTPUTS = 4
+
+# === 모델 구조 (mlp_kfold.py와 반드시 동일) ===
+HIDDEN_DIMS = [128, 256, 256, 128]
+L2          = 1e-5
+
+PARAM_RANGES = {
+    "Lp_ve":    (4e-12,  1.6e-11),
+    "K":        (1e-16,  1e-13),
+    "p_le":     (1e-9,   1e-7),
+    "sigma_ve": (0.01,   0.99),
+    "sigma_le": (0.01,   0.50),
+    "p_ve":     (1e-11,  1e-8),
+    "D_gel":    (1e-12,  1e-9),
+    "k_decay":  (1e-8,   1e-4),
+    "kf_m":     (0.1,    3.0),
+    "kr_m":     (2.5,    200.0),
+}
+DEFAULT_VALUES = np.array([
+    8e-12, 1e-15, 1e-8, 0.9, 0.1,
+    1e-9, 45e-12, 1.7e-6, 0.48, 4.2,
+])
+COLORS = ["#2ecc71", "#e74c3c", "#3498db", "#f39c12"]
+_trapz = np.trapezoid if hasattr(np, "trapezoid") else np.trapz
+
+
+def _setup_font():
+    candidates = ["AppleGothic", "Malgun Gothic", "NanumGothic", "Noto Sans CJK KR"]
+    available = {f.name for f in matplotlib.font_manager.fontManager.ttflist}
+    for name in candidates:
+        if name in available:
+            matplotlib.rc("font", family=name)
+            break
+    matplotlib.rc("axes", unicode_minus=False)
+
+_setup_font()
+
+
+def build_mlp(n_t):
+    """mlp_kfold.py의 build_mlp와 동일 구조 (가중치 로드용)."""
+    inp = keras.Input(shape=(N_PARAMS,), name="params")
+    x = inp
+    for h in HIDDEN_DIMS:
+        x = layers.Dense(h, kernel_regularizer=keras.regularizers.l2(L2) if L2 > 0 else None)(x)
+        x = layers.Activation(tf.nn.silu)(x)
+    out = layers.Dense(n_t * N_OUTPUTS, activation="linear", name="curve")(x)
+    return keras.Model(inp, out, name="MLP_fold")
+
+
+@st.cache_resource
+def load_folds():
+    """folds/fold*/ 의 가중치 + 스케일러를 모두 로드."""
+    if not FOLDS_DIR.exists():
+        raise FileNotFoundError(
+            f"folds 폴더를 찾을 수 없습니다.\n경로: {FOLDS_DIR.resolve()}\n\n"
+            "먼저 학습을 실행하세요:\n  python mlp_kfold.py"
+        )
+    fold_dirs = sorted([d for d in FOLDS_DIR.iterdir()
+                        if d.is_dir() and d.name.startswith("fold")])
+    if not fold_dirs:
+        raise FileNotFoundError(f"fold 모델이 없습니다: {FOLDS_DIR.resolve()}")
+
+    # 시간축은 fold 공통 (첫 fold 기준)
+    sc0 = np.load(fold_dirs[0] / "scalers.npz")
+    time_arr = sc0["time_arr"]
+    n_t = len(time_arr)
+
+    folds = []
+    for fd in fold_dirs:
+        sc = np.load(fd / "scalers.npz")
+        model = build_mlp(n_t)
+        model.load_weights(str(fd / "model.weights.h5"))
+        folds.append({
+            "name": fd.name,
+            "model": model,
+            "param_mean": sc["param_mean"],
+            "param_std":  sc["param_std"],
+            "param_log_mask": sc["param_log_mask"].astype(bool),
+            "out_mean": sc["out_mean"],
+            "out_std":  sc["out_std"],
+        })
+    return folds, time_arr, n_t
+
+
+def preprocess(params, fold):
+    lm = fold["param_log_mask"]
+    pt = params.copy().astype(np.float64)
+    pt[lm] = np.log10(np.clip(pt[lm], 1e-300, None))
+    return ((pt - fold["param_mean"]) / fold["param_std"]).astype(np.float32)
+
+
+def predict_ensemble(folds, params, n_t):
+    """
+    각 fold로 예측 후 스택.
+    반환: preds (n_folds, n_t, N_OUTPUTS)
+    """
+    preds = []
+    for fold in folds:
+        x = preprocess(params, fold).reshape(1, -1)
+        p = fold["model"](x, training=False).numpy().reshape(n_t, N_OUTPUTS)
+        p = p * fold["out_std"] + fold["out_mean"]
+        preds.append(p)
+    return np.stack(preds, axis=0)
+
+
+def check_range(params):
+    warnings = []
+    for name, val in zip(PARAM_NAMES, params):
+        lo, hi = PARAM_RANGES[name]
+        if val < lo or val > hi:
+            warnings.append(f"**{name}** = {val:.3e}  (허용: {lo:.1e} ~ {hi:.1e})")
+    return warnings
+
+
+def plot_combined(mean, std, time_arr):
+    fig, ax = plt.subplots(figsize=(12, 5))
+    for k, name in enumerate(OUTPUT_NAMES):
+        ax.plot(time_arr, mean[:, k], color=COLORS[k], lw=2.5, label=name)
+        ax.fill_between(time_arr, mean[:, k] - std[:, k], mean[:, k] + std[:, k],
+                        color=COLORS[k], alpha=0.18)
+    ax.set_xlabel("Time (min)", fontsize=12)
+    ax.set_ylabel("농도 (%)", fontsize=12)
+    ax.set_title("약물동태 예측", fontsize=13, fontweight="bold")
+    ax.set_xlim(time_arr.min(), time_arr.max())
+    ax.set_ylim(bottom=0)
+    ax.legend(fontsize=11)
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    return fig
+
+
+def plot_subplots(mean, std, time_arr):
+    fig, axes = plt.subplots(2, 2, figsize=(14, 7))
+    axes = axes.flatten()
+    for k, name in enumerate(OUTPUT_NAMES):
+        ax = axes[k]
+        ax.plot(time_arr, mean[:, k], color=COLORS[k], lw=2.5)
+        ax.fill_between(time_arr, mean[:, k] - std[:, k], mean[:, k] + std[:, k],
+                        color=COLORS[k], alpha=0.18)
+        ax.set_title(name, fontsize=12, fontweight="bold")
+        ax.set_xlabel("Time (min)", fontsize=10)
+        ax.set_ylabel("농도 (%)", fontsize=10)
+        ax.set_xlim(time_arr.min(), time_arr.max())
+        ax.set_ylim(bottom=0)
+        ax.grid(True, alpha=0.3)
+    plt.suptitle("구획별 농도-시간 곡선 (± 편차)", fontsize=13, y=1.01)
+    plt.tight_layout()
+    return fig
+
+
+st.set_page_config(page_title="PK Surrogate — K-Fold Ensemble", page_icon="💉", layout="wide")
+st.title("💉 피하주사 약물동태 예측 모델")
+st.markdown("10개 파라미터 → 4구획 농도-시간 곡선 (0~72시간) | "
+            "음영은 fold 간 편차(예측 신뢰도)")
+
+try:
+    folds, time_arr, n_t = load_folds()
+except FileNotFoundError as e:
+    st.error(str(e))
+    st.stop()
+except Exception as e:
+    st.error(f"로딩 실패: {e}")
+    st.stop()
+
+st.sidebar.header("📋 파라미터 입력")
+st.sidebar.markdown("---")
+input_params = []
+for i, name in enumerate(PARAM_NAMES):
+    dv = float(DEFAULT_VALUES[i])
+    lo, hi = PARAM_RANGES[name]
+    fmt = "%.2e" if (abs(dv) < 1e-3 or abs(dv) > 1e3) else "%.4f"
+    val = st.sidebar.number_input(
+        label=f"{name}  ({lo:.1e} ~ {hi:.1e})",
+        value=dv, format=fmt, key=f"p_{i}",
+    )
+    input_params.append(val)
+st.sidebar.markdown("---")
+predict_btn = st.sidebar.button("🔮 예측하기", type="primary", use_container_width=True)
+
+with st.expander("ℹ️ 모델 정보", expanded=False):
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("모델", "MLP")
+    c2.metric("구조", "[128,256,256,128]")
+    c3.metric("Dropout", "0.0  (L2=1e-5)")
+    c4.metric("Fold 수", f"{len(folds)}개")
+
+if predict_btn:
+    params = np.array(input_params, dtype=np.float64)
+
+    oor = check_range(params)
+    if oor:
+        st.warning(
+            "⚠️ **외삽 경고**: 아래 파라미터가 학습 범위를 벗어났습니다. "
+            "예측 신뢰도가 낮을 수 있습니다.\n\n"
+            + "\n".join(f"- {w}" for w in oor)
+        )
+
+    with st.spinner("예측 중..."):
+        preds = predict_ensemble(folds, params, n_t)   # (n_folds, n_t, 4)
+        mean = preds.mean(axis=0)
+        std  = preds.std(axis=0)
+
+    # fold 간 편차가 크면 신뢰도 낮음 경고
+    rel_spread = float(std.mean())
+    if rel_spread > 1.0:  # 평균 편차 1%p 이상이면
+        st.warning(
+            f"⚠️ **예측 불확실성 높음**: fold 간 평균 편차가 {rel_spread:.2f}%p입니다. "
+            "이 파라미터 영역은 학습 데이터가 성겨 신뢰도가 낮을 수 있습니다. "
+            "COMSOL 직접 검증을 권장합니다."
+        )
+
+    st.markdown("---")
+    st.subheader("📈 72시간 최종값 요약")
+    # 총농도(4구획 합)를 맨 앞에 추가
+    total_mean = mean.sum(axis=1)   # (n_t,) 시점별 4구획 합
+    total_std  = std.sum(axis=1)
+    cols = st.columns(5)
+    cols[0].metric(
+        label="c_total (총합)",
+        value=f"{total_mean[-1]:.2f}%",
+        delta=f"max: {total_mean.max():.2f}%",
+        delta_color="off",
+    )
+    for k, name in enumerate(OUTPUT_NAMES):
+        cols[k + 1].metric(
+            label=name,
+            value=f"{mean[-1, k]:.2f}%",
+            delta=f"±{std[-1, k]:.2f}%p (fold 편차)",
+            delta_color="off",
+        )
+
+    st.markdown("---")
+    st.subheader("📊 농도-시간 곡선")
+    tab1, tab2 = st.tabs(["전체 비교", "구획별 상세"])
+    with tab1:
+        fig1 = plot_combined(mean, std, time_arr)
+        st.pyplot(fig1); plt.close(fig1)
+    with tab2:
+        fig2 = plot_subplots(mean, std, time_arr)
+        st.pyplot(fig2); plt.close(fig2)
+
+    st.markdown("---")
+    st.subheader("📋 PK 지표")
+    # %AUC: 각 구획 AUC가 전체 AUC 합에서 차지하는 비율 (합 100%)
+    auc_vals = np.array([_trapz(mean[:, k], time_arr) for k in range(N_OUTPUTS)])
+    auc_total = auc_vals.sum() + 1e-12
+    rows = []
+    for k, name in enumerate(OUTPUT_NAMES):
+        curve = mean[:, k]
+        rows.append({
+            "구획":        name,
+            "Cmax (%)":    f"{curve.max():.2f}",
+            "Tmax (min)":  f"{time_arr[int(np.argmax(curve))]:.0f}",
+            "%AUC":        f"{auc_vals[k] / auc_total * 100:.1f}%",
+            "72hr (%)":    f"{curve[-1]:.2f}",
+        })
+    st.table(rows)
+
+    # ── 시점별 농도값 엑셀 다운로드 ──
+    st.markdown("---")
+    st.subheader("📥 시점별 농도값 다운로드")
+    st.markdown("모델이 예측한 42개 시점의 구획별 농도값을 엑셀로 저장합니다.")
+
+    df_out = pd.DataFrame({"time_min": time_arr, "time_hr": time_arr / 60.0})
+    for k, name in enumerate(OUTPUT_NAMES):
+        df_out[name] = mean[:, k]
+
+    buf = io.BytesIO()
+    with pd.ExcelWriter(buf, engine="openpyxl") as writer:
+        df_out.to_excel(writer, index=False, sheet_name="농도_시간별")
+        # 입력 파라미터도 별도 시트로 기록 (재현용)
+        pd.DataFrame({"parameter": PARAM_NAMES, "value": input_params}
+                     ).to_excel(writer, index=False, sheet_name="입력_파라미터")
+    buf.seek(0)
+
+    st.download_button(
+        label="⬇️ 엑셀 다운로드 (.xlsx)",
+        data=buf,
+        file_name="농도_시간별_예측.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        use_container_width=False,
+    )
+    with st.expander("미리보기"):
+        st.dataframe(df_out.style.format({
+            "time_min": "{:.0f}", "time_hr": "{:.2f}",
+            **{name: "{:.3f}" for name in OUTPUT_NAMES},
+        }), use_container_width=True)
+
+    with st.expander("🔍 입력 파라미터 확인"):
+        st.json({
+            name: (f"{val:.3e}" if (abs(val) < 1e-3 or abs(val) > 1e3) else f"{val:.4f}")
+            for name, val in zip(PARAM_NAMES, input_params)
+        })
+
+else:
+    st.info("👈 왼쪽 사이드바에서 파라미터를 입력하고 **예측하기** 버튼을 누르세요.")
+    st.markdown("""
+    ### 예측 신뢰도
+    fold 간 **편차(음영)**가 그 파라미터 영역에서의 예측 신뢰도를 나타냅니다.
+    편차가 크면 학습 데이터가 성긴 영역이라 신뢰도가 낮습니다.
+
+    ### 출력 구획
+    | 구획 | 설명 |
+    |------|------|
+    | c_lymph | 림프관 배출 |
+    | c_vessel | 혈관 배출 |
+    | c_decay | 분해 |
+    | c_ecm | 세포외기질 잔류 |
+
+    ### 주의사항
+    - 파라미터 범위를 벗어나면 **외삽 경고**
+    - fold 편차가 크면 **불확실성 경고** (COMSOL 직접 검증 권장)
+    """)
+
+if __name__ == "__main__":
+    import os, subprocess, sys
+    if os.environ.get("STREAMLIT_RUNNING") != "1":
+        env = os.environ.copy()
+        env["STREAMLIT_RUNNING"] = "1"
+        subprocess.run([sys.executable, "-m", "streamlit", "run", __file__], env=env)

src/mlp_kfold.py

@@ -0,0 +1,493 @@
+"""
+mlp_kfold.py — MLP 단일 모델 + K-Fold 교차검증
+================================================
+단일 분할의 운(運)을 제거하고 전체 데이터에 대해
+평균±std로 신뢰성 있는 성능을 평가한다.
+
+설계:
+  - 층화 K-Fold (k_decay × p_ve 기준)로 데이터를 K등분
+  - 각 fold가 한 번씩 test가 됨 (전체 케이스가 정확히 1번씩 평가됨)
+  - 나머지에서 val 일부 분리, 나머지 train
+  - K개 모델의 test 지표를 평균±std로 보고
+  - 각 fold 모델/스케일러 저장
+
+모델 설정 (기존 최적):
+  구조 [128,256,256,128] SiLU, dropout=0, l2=1e-5
+  시간가중 MSE(tau=2000), epochs=1000, patience_es=80
+
+실행: python mlp_kfold.py
+"""
+
+from __future__ import annotations
+import os
+os.environ["PYTHONHASHSEED"] = "42"
+os.environ["TF_DETERMINISTIC_OPS"] = "1"
+os.environ["TF_CUDNN_DETERMINISTIC"] = "1"
+
+import json
+import random
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import matplotlib.font_manager as fm
+
+def set_korean_font():
+    candidates = ["AppleGothic", "Malgun Gothic", "NanumGothic",
+                  "NanumBarunGothic", "DejaVu Sans"]
+    available = {f.name for f in fm.fontManager.ttflist}
+    for font in candidates:
+        if font in available:
+            plt.rcParams["font.family"] = font
+            break
+    plt.rcParams["axes.unicode_minus"] = False  # 유니코드 마이너스 대신 ASCII 하이픈 사용
+
+set_korean_font()
+
+# 폰트 글리프 경고 숨김 (U+2212 등 무해한 치환 경고)
+import logging
+logging.getLogger("matplotlib.font_manager").setLevel(logging.ERROR)
+import warnings
+warnings.filterwarnings("ignore", message="Glyph.*missing from font")
+warnings.filterwarnings("ignore", message=".*does not have a glyph.*")
+from sklearn.metrics import mean_absolute_error, r2_score
+
+import tensorflow as tf
+tf.get_logger().setLevel("ERROR")  # retracing 등 무해한 경고 숨김
+import keras
+from keras import layers, callbacks
+
+
+# ─────────────────────────────────────────────
+# 0. 설정
+# ─────────────────────────────────────────────
+BASE_DIR   = Path(__file__).resolve().parent
+DATA_PATH  = BASE_DIR / "정제_전체_long.xlsx"
+OUTPUT_DIR = BASE_DIR / "outputs_kfold"
+for d in (OUTPUT_DIR, OUTPUT_DIR / "folds"):
+    d.mkdir(parents=True, exist_ok=True)
+
+SEED      = 42
+N_OUTPUTS = 4
+N_PARAMS  = 10
+
+PARAM_NAMES  = ["Lp_ve", "K", "p_le", "sigma_ve", "sigma_le",
+                "p_ve", "D_gel", "k_decay", "kf_m", "kr_m"]
+OUTPUT_NAMES = ["c_lymph", "c_vessel", "c_decay", "c_ecm"]
+LOG_TRANSFORM_PARAMS = {"K", "p_le", "p_ve", "D_gel", "k_decay", "kr_m"}
+EXCLUDE_CASES = {304, 312, 313, 317}
+
+# === K-Fold 설정 ===
+N_FOLDS       = 5      # 5-fold (각 fold test ≈ 20%)
+VAL_RATIO     = 0.15   # train 내에서 val로 떼는 비율
+STRATIFY_BINS = 5      # 층화 기준 분위수
+
+# === 외딴 케이스 제외 설정 ===
+# 곡선이 파라미터 이웃과 크게 다른(=데이터가 성겨 보간 불가능한) 케이스를
+# 학습/평가 전에 제외. 모델 결과가 아닌 데이터 구조만으로 판정하므로 객관적.
+# 목적: 데이터 커버리지가 충분한 정상 영역에서의 본래 성능 측정.
+#       제외된 영역은 추가 COMSOL 샘플링으로 별도 보완.
+EXCLUDE_SPARSE   = True   # True: 외딴 케이스 제외, False: 전체 사용
+SPARSE_NEIGHBORS = 5      # 국소 불일치 계산용 이웃 수
+SPARSE_IQR_K     = 1.5    # 이상치 임계 (Q3 + K×IQR)
+
+# === 모델 설정 (기존 최적) ===
+HIDDEN_DIMS     = [128, 256, 256, 128]
+DROPOUT         = 0.0
+L2              = 1e-5
+TIME_WEIGHT_TAU = 2000.0
+EPOCHS          = 1000
+BATCH_SIZE      = 16
+LEARNING_RATE   = 1e-3
+WEIGHT_DECAY    = 1e-5
+PATIENCE_ES     = 80
+PATIENCE_LR     = 30
+MIN_DELTA       = 1e-5  # 이보다 작은 val_loss 개선은 무시 (조기종료 정상 작동)
+
+
+def set_seed(seed=SEED):
+    random.seed(seed)
+    np.random.seed(seed)
+    tf.random.set_seed(seed)
+    try:
+        tf.config.experimental.enable_op_determinism()
+    except Exception:
+        pass
+
+
+# ─────────────────────────────────────────────
+# 1. 데이터 로드
+# ─────────────────────────────────────────────
+def load_data(path):
+    df = pd.read_excel(path)
+    required = {"case", "time_min", *PARAM_NAMES, *OUTPUT_NAMES}
+    missing = required - set(df.columns)
+    if missing:
+        raise ValueError(f"누락된 컬럼: {missing}")
+
+    if EXCLUDE_CASES:
+        before = df["case"].nunique()
+        df = df[~df["case"].isin(EXCLUDE_CASES)].copy()
+        print(f"  제외된 발산 케이스: {sorted(EXCLUDE_CASES)} ({before}->{df['case'].nunique()})")
+
+    cases = sorted(df["case"].unique())
+    n = len(cases)
+    ref_t = df[df["case"] == cases[0]].sort_values("time_min")["time_min"].values
+    n_t = len(ref_t)
+
+    P = np.zeros((n, N_PARAMS), dtype=np.float64)
+    C = np.zeros((n, n_t, N_OUTPUTS), dtype=np.float64)
+    for i, c in enumerate(cases):
+        sub = df[df["case"] == c].sort_values("time_min")
+        if len(sub) != n_t or not np.allclose(sub["time_min"].values, ref_t):
+            raise ValueError(f"case {c}: 시간 그리드 불일치")
+        P[i] = sub[PARAM_NAMES].iloc[0].values
+        C[i] = sub[OUTPUT_NAMES].values
+
+    n_clip = (C < 0).sum()
+    if n_clip > 0:
+        print(f"  음수 농도 클리핑: {n_clip}개 -> 0 (최소 {C.min():.4f})")
+        C = np.clip(C, 0.0, None)
+
+    print(f"  로드 완료: 케이스 {n}개, 시간점 {n_t}개")
+    return P, C, ref_t, cases
+
+
+# ─────────────────────────────────────────────
+# 2. 스케일러
+# ─────────────────────────────────────────────
+
+
+# ─────────────────────────────────────────────
+# 1-b. 외딴(sparse) 케이스 탐지
+# ─────────────────────────────────────────────
+def detect_sparse_cases(params, curves):
+    """
+    각 케이스의 곡선이 '파라미터 공간 이웃들의 곡선'과 얼마나 다른지(국소 불일치)
+    측정해, IQR 이상치를 외딴 케이스로 판정한다.
+    국소 불일치가 크다 = 파라미터는 가까운데 거동이 급변 = 데이터 해상도 부족 영역.
+
+    반환: keep_mask (True=유지), sparse_idx (제외 인덱스), mismatch (점수)
+    """
+    from scipy.spatial.distance import cdist
+    log_mask = np.array([n in LOG_TRANSFORM_PARAMS for n in PARAM_NAMES], dtype=bool)
+    Pl = params.copy().astype(float)
+    Pl[:, log_mask] = np.log10(np.clip(Pl[:, log_mask], 1e-300, None))
+    Psc = (Pl - Pl.mean(0)) / (Pl.std(0) + 1e-12)
+
+    D = cdist(Psc, Psc)
+    np.fill_diagonal(D, np.inf)
+
+    mismatch = np.zeros(len(params))
+    for i in range(len(params)):
+        nn = np.argsort(D[i])[:SPARSE_NEIGHBORS]
+        neighbor_mean = curves[nn].mean(axis=0)
+        mismatch[i] = np.abs(curves[i] - neighbor_mean).mean()
+
+    q1, q3 = np.percentile(mismatch, [25, 75])
+    thr = q3 + SPARSE_IQR_K * (q3 - q1)
+    sparse_idx = np.where(mismatch > thr)[0]
+    keep_mask = mismatch <= thr
+    return keep_mask, sparse_idx, mismatch, thr
+
+class ParamScaler:
+    def __init__(self):
+        self.log_mask_ = np.array([n in LOG_TRANSFORM_PARAMS for n in PARAM_NAMES], dtype=bool)
+        self.mean_ = None; self.std_ = None
+
+    def _apply_log(self, X):
+        Xt = X.copy().astype(np.float64)
+        Xt[:, self.log_mask_] = np.log10(np.clip(Xt[:, self.log_mask_], 1e-300, None))
+        return Xt
+
+    def fit(self, X):
+        Xt = self._apply_log(X)
+        self.mean_ = Xt.mean(0); self.std_ = Xt.std(0) + 1e-12
+        return self
+
+    def transform(self, X):     return (self._apply_log(X) - self.mean_) / self.std_
+    def fit_transform(self, X): return self.fit(X).transform(X)
+
+
+class OutputScaler:
+    def __init__(self):
+        self.mean_ = None; self.std_ = None
+
+    def fit(self, Y):
+        Yf = Y.reshape(-1, N_OUTPUTS)
+        self.mean_ = Yf.mean(0); self.std_ = Yf.std(0) + 1e-12
+        return self
+
+    def transform(self, Y):         return (Y - self.mean_) / self.std_
+    def inverse_transform(self, Y): return Y * self.std_ + self.mean_
+    def fit_transform(self, Y):     return self.fit(Y).transform(Y)
+
+
+# ─────────────────────────────────────────────
+# 3. 층화 K-Fold 분할
+# ─────────────────────────────────────────────
+def make_strata(params):
+    """k_decay × p_ve 기준 층 라벨 생성."""
+    kd = np.log10(np.clip(params[:, PARAM_NAMES.index("k_decay")], 1e-300, None))
+    pv = np.log10(np.clip(params[:, PARAM_NAMES.index("p_ve")], 1e-300, None))
+    kb = pd.qcut(kd, q=STRATIFY_BINS, labels=False, duplicates="drop")
+    pb = pd.qcut(pv, q=STRATIFY_BINS, labels=False, duplicates="drop")
+    return kb * (STRATIFY_BINS + 1) + pb
+
+
+def stratified_kfold_indices(params, n_folds, seed):
+    """
+    층화 K-Fold: 각 층 내부를 n_folds로 나눠 fold마다 고르게 분배.
+    반환: fold_assign (각 케이스의 fold 번호 0..n_folds-1)
+    """
+    rng = np.random.default_rng(seed)
+    strata = make_strata(params)
+    fold_assign = np.full(len(params), -1, dtype=int)
+    for s in np.unique(strata):
+        idx = np.where(strata == s)[0]
+        rng.shuffle(idx)
+        # 층 내부를 순환 배정 (각 fold에 고르게)
+        for j, i in enumerate(idx):
+            fold_assign[i] = j % n_folds
+    return fold_assign
+
+
+def split_train_val(train_idx, params, val_ratio, seed):
+    """train 인덱스에서 val을 층화로 분리."""
+    rng = np.random.default_rng(seed)
+    strata = make_strata(params)[train_idx]
+    tr, va = [], []
+    for s in np.unique(strata):
+        local = np.where(strata == s)[0]
+        rng.shuffle(local)
+        nv = max(1, round(len(local) * val_ratio))
+        if len(local) - nv < 1:
+            tr.extend(train_idx[local].tolist()); continue
+        va.extend(train_idx[local[:nv]].tolist())
+        tr.extend(train_idx[local[nv:]].tolist())
+    return np.array(tr), np.array(va)
+
+
+# ─────────────────────────────────────────────
+# 4. 손실 / 모델
+# ─────────────────────────────────────────────
+def make_time_weighted_loss(time_arr, n_t):
+    w = np.exp(-time_arr / TIME_WEIGHT_TAU)
+    w = (w / w.mean()).astype(np.float32)
+    tw = tf.constant(w.reshape(1, n_t, 1), dtype=tf.float32)
+
+    @tf.function
+    def loss_fn(y_true, y_pred):
+        yt = tf.reshape(y_true, (-1, n_t, N_OUTPUTS))
+        yp = tf.reshape(y_pred, (-1, n_t, N_OUTPUTS))
+        return tf.reduce_mean(tf.square(yt - yp) * tw)
+    return loss_fn
+
+
+def build_mlp(n_t):
+    inp = keras.Input(shape=(N_PARAMS,), name="params")
+    x = inp
+    for h in HIDDEN_DIMS:
+        x = layers.Dense(h, kernel_regularizer=keras.regularizers.l2(L2) if L2 > 0 else None)(x)
+        x = layers.Activation(tf.nn.silu)(x)
+        if DROPOUT > 0:
+            x = layers.Dropout(DROPOUT)(x)
+    out = layers.Dense(n_t * N_OUTPUTS, activation="linear", name="curve")(x)
+    return keras.Model(inp, out, name="MLP_single")
+
+
+# ─────────────────────────────────────────────
+# 5. 평가 지표
+# ─────────────────────────────────────────────
+def evaluate(y_true, y_pred):
+    case_mae = np.abs(y_true - y_pred).mean(axis=(1, 2))
+    per = {name: float(mean_absolute_error(y_true[..., k].reshape(-1),
+                                           y_pred[..., k].reshape(-1)))
+           for k, name in enumerate(OUTPUT_NAMES)}
+    return {
+        "MAE_overall": float(mean_absolute_error(y_true.reshape(-1), y_pred.reshape(-1))),
+        "R2_overall":  float(r2_score(y_true.reshape(-1), y_pred.reshape(-1))),
+        "case_MAE_mean": float(case_mae.mean()),
+        "case_MAE_max":  float(case_mae.max()),
+        "case_MAE_p90":  float(np.percentile(case_mae, 90)),
+        "case_MAE_std":  float(case_mae.std()),
+        "per_compartment_MAE": per,
+    }
+
+
+# ─────────────────────────────────────────────
+# 6. 단일 fold 학습
+# ─────────────────────────────────────────────
+def train_one_fold(fold, itr, iva, ite, params, curves, time_arr, n_t):
+    print(f"\n{'='*55}")
+    print(f"  Fold {fold+1}/{N_FOLDS}  (train={len(itr)}, val={len(iva)}, test={len(ite)})")
+    print(f"{'='*55}")
+
+    ps = ParamScaler()
+    X_tr = ps.fit_transform(params[itr]).astype(np.float32)
+    X_va = ps.transform(params[iva]).astype(np.float32)
+    X_te = ps.transform(params[ite]).astype(np.float32)
+
+    osc = OutputScaler(); osc.fit(curves[itr])
+    Y_tr = osc.transform(curves[itr]).reshape(len(itr), -1).astype(np.float32)
+    Y_va = osc.transform(curves[iva]).reshape(len(iva), -1).astype(np.float32)
+    Y_te_raw = curves[ite]
+
+    loss_fn = make_time_weighted_loss(time_arr, n_t)
+
+    set_seed(SEED)  # fold마다 동일 초기화 (모델 변동 통제, 분할 효과만 측정)
+    model = build_mlp(n_t)
+    model.compile(optimizer=keras.optimizers.Adam(LEARNING_RATE, weight_decay=WEIGHT_DECAY),
+                  loss=loss_fn, metrics=["mae"])
+    cbs = [
+        callbacks.EarlyStopping(monitor="val_loss", patience=PATIENCE_ES,
+                                min_delta=MIN_DELTA, restore_best_weights=True, verbose=0),
+        callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5,
+                                    patience=PATIENCE_LR, min_delta=MIN_DELTA,
+                                    min_lr=1e-7, verbose=0),
+    ]
+    h = model.fit(X_tr, Y_tr, validation_data=(X_va, Y_va),
+                  epochs=EPOCHS, batch_size=BATCH_SIZE, callbacks=cbs, verbose=0)
+    ep = len(h.history["val_loss"])
+
+    pred = osc.inverse_transform(model.predict(X_te, verbose=0).reshape(-1, n_t, N_OUTPUTS))
+    metrics = evaluate(Y_te_raw, pred)
+    print(f"  ep={ep}  test MAE 평균={metrics['case_MAE_mean']:.3f}%  "
+          f"최대={metrics['case_MAE_max']:.3f}%  R2={metrics['R2_overall']:.4f}")
+
+    # fold 산출물 저장 (가중치 + 스케일러 → 재현/추론용)
+    fdir = OUTPUT_DIR / "folds" / f"fold{fold+1}"
+    fdir.mkdir(parents=True, exist_ok=True)
+    model.save_weights(str(fdir / "model.weights.h5"))
+    np.savez(fdir / "scalers.npz",
+             param_mean=ps.mean_, param_std=ps.std_, param_log_mask=ps.log_mask_,
+             out_mean=osc.mean_, out_std=osc.std_, time_arr=time_arr,
+             test_idx=ite)
+    return metrics, h, pred, Y_te_raw, ite
+
+
+# ─────────────────────────────────────────────
+# 7. 종합 시각화
+# ─────────────────────────────────────────────
+def plot_kfold_summary(fold_metrics, histories, save_path):
+    fig, axes = plt.subplots(1, 2, figsize=(13, 4.5))
+    fig.suptitle("K-Fold 교차검증 결과", fontsize=14, fontweight="bold", y=1.02)
+
+    # 왼쪽: fold별 평균/최대 MAE 막대
+    ax = axes[0]
+    folds = [f"F{i+1}" for i in range(len(fold_metrics))]
+    means = [m["case_MAE_mean"] for m in fold_metrics]
+    maxes = [m["case_MAE_max"] for m in fold_metrics]
+    x = np.arange(len(folds)); width = 0.38
+    ax.bar(x - width/2, means, width, label="평균 MAE", color="#2E5C8A")
+    ax.bar(x + width/2, maxes, width, label="최대 MAE", color="#C62828")
+    ax.axhline(np.mean(means), color="#2E5C8A", linestyle="--", linewidth=1,
+               alpha=0.7, label=f"평균의 평균 {np.mean(means):.3f}%")
+    ax.set_xticks(x); ax.set_xticklabels(folds)
+    ax.set_ylabel("MAE (%)", fontsize=11)
+    ax.set_title("Fold별 test MAE", fontsize=12)
+    ax.legend(fontsize=9); ax.grid(True, alpha=0.3, axis="y")
+
+    # 오른쪽: fold별 val loss 곡선
+    ax2 = axes[1]
+    for i, h in enumerate(histories):
+        vl = h.history["val_loss"]
+        ax2.plot(np.arange(1, len(vl)+1), vl, linewidth=1.3, alpha=0.8, label=f"Fold {i+1}")
+    ax2.set_xlabel("Epoch", fontsize=11); ax2.set_ylabel("Val Loss", fontsize=11)
+    ax2.set_title("Fold별 검증 손실", fontsize=12)
+    ax2.set_yscale("log")
+    ax2.legend(fontsize=8); ax2.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    print(f"\n  요약 그래프 저장: {save_path}")
+
+
+# ─────────────────────────────────────────────
+# 8. 메인
+# ─────────────────────────────────────────────
+def main():
+    print("=" * 60)
+    print(f"  MLP {N_FOLDS}-Fold 교차검증")
+    print("=" * 60)
+
+    print("\n[1] 데이터 로드")
+    params, curves, time_arr, cases = load_data(DATA_PATH)
+    n_t = len(time_arr)
+
+    if EXCLUDE_SPARSE:
+        print("\n[1-b] 외딴 케이스 제외 (국소 불일치 IQR 기준)")
+        keep, sparse_idx, mismatch, thr = detect_sparse_cases(params, curves)
+        excl_cases = [cases[i] for i in sparse_idx]
+        print(f"  임계값(Q3+{SPARSE_IQR_K}×IQR) = {thr:.2f}%")
+        print(f"  제외 {len(sparse_idx)}개 / 유지 {keep.sum()}개")
+        print(f"  제외 케이스: {sorted(excl_cases)}")
+        params = params[keep]
+        curves = curves[keep]
+        cases = [c for i, c in enumerate(cases) if keep[i]]
+
+    print(f"\n[2] 층화 {N_FOLDS}-Fold 분할")
+    fold_assign = stratified_kfold_indices(params, N_FOLDS, SEED)
+    for f in range(N_FOLDS):
+        print(f"  Fold {f+1}: test {int((fold_assign==f).sum())}개")
+
+    print("\n[3] Fold별 학습")
+    fold_metrics, histories = [], []
+    # 전체 케이스에 대한 out-of-fold 예측 (각 케이스가 test였을 때의 예측)
+    oof_pred = np.zeros_like(curves)
+    oof_filled = np.zeros(len(cases), dtype=bool)
+
+    for f in range(N_FOLDS):
+        ite = np.where(fold_assign == f)[0]
+        rest = np.where(fold_assign != f)[0]
+        itr, iva = split_train_val(rest, params, VAL_RATIO, SEED + f)
+        metrics, h, pred, _, test_idx = train_one_fold(
+            f, itr, iva, ite, params, curves, time_arr, n_t)
+        fold_metrics.append(metrics); histories.append(h)
+        oof_pred[test_idx] = pred
+        oof_filled[test_idx] = True
+
+    # ── 종합 ──
+    print("\n" + "=" * 60)
+    print("  K-Fold 종합 결과")
+    print("=" * 60)
+    keys = ["case_MAE_mean", "case_MAE_max", "case_MAE_p90", "R2_overall"]
+    labels = {"case_MAE_mean": "평균 MAE", "case_MAE_max": "최대 MAE",
+              "case_MAE_p90": "p90 MAE", "R2_overall": "R²"}
+    summary = {}
+    for k in keys:
+        vals = np.array([m[k] for m in fold_metrics])
+        summary[k] = {"mean": float(vals.mean()), "std": float(vals.std()),
+                      "min": float(vals.min()), "max": float(vals.max())}
+        unit = "" if k == "R2_overall" else "%"
+        print(f"  {labels[k]:10s}: {vals.mean():.3f}{unit} ± {vals.std():.3f}  "
+              f"[{vals.min():.3f}, {vals.max():.3f}]")
+
+    # 전체 OOF 지표 (모든 케이스가 정확히 1번씩 test됨 → 가장 신뢰도 높은 단일 수치)
+    assert oof_filled.all(), "일부 케이스가 평가되지 않음"
+    oof_metrics = evaluate(curves, oof_pred)
+    print(f"\n  [전체 OOF] 평균 MAE={oof_metrics['case_MAE_mean']:.3f}%  "
+          f"최대={oof_metrics['case_MAE_max']:.3f}%  "
+          f"p90={oof_metrics['case_MAE_p90']:.3f}%  R²={oof_metrics['R2_overall']:.4f}")
+    print("  [전체 OOF 구획별 MAE]")
+    for name, v in oof_metrics["per_compartment_MAE"].items():
+        print(f"    {name:<10}: {v:.3f}%")
+
+    print("\n[4] 저장")
+    with open(OUTPUT_DIR / "kfold_metrics.json", "w", encoding="utf-8") as fp:
+        json.dump({"per_fold": fold_metrics, "summary": summary,
+                   "oof": oof_metrics}, fp, indent=2, ensure_ascii=False)
+    np.savez(OUTPUT_DIR / "oof_predictions.npz",
+             y_true=curves, y_pred=oof_pred, fold_assign=fold_assign, time_arr=time_arr)
+    plot_kfold_summary(fold_metrics, histories, OUTPUT_DIR / "kfold_summary.png")
+    print(f"  저장: {OUTPUT_DIR}/ (kfold_metrics.json, oof_predictions.npz, "
+          f"kfold_summary.png, folds/)")
+    print("\n완료.")
+
+
+if __name__ == "__main__":
+    main()

src/requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+tensorflow-cpu
+numpy
+pandas
+openpyxl