Upload 3 files

baseline_model.py

@@ -0,0 +1,419 @@
+# train_blend_ftt_lgbm.py
+# FT-Transformer (weighted MAE + 5-Fold OOF) + LightGBM (5-Fold OOF) + OOF blending
+# pip install pandas numpy scikit-learn torch lightgbm openpyxl
+
+import os, math, json, random, pathlib
+import numpy as np
+import pandas as pd
+from typing import List, Tuple
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import mean_absolute_error
+import lightgbm as lgb
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+
+# =========================
+# Config
+# =========================
+SEED = 42
+DATA_PATH = r"C:\Users\KDT10\OneDrive\바탕 화면\AutoForm\데이터통합.xlsx"  # .xlsx 또는 .csv
+TARGET = "max_failure"
+CAT_COL = "material"  # 범주형
+NUM_COLS = ["thickness","diameter","degree","upper_radius","lower_radius","LB","RB"]  # 필요 시 물성/파생변수 추가
+N_SPLITS = 5
+
+# FT-Transformer 하이퍼파라미터 (튜닝안)
+D_MODEL = 256
+NHEAD = 8
+LAYERS = 6
+DIM_FF = 1024
+DROPOUT = 0.25
+EPOCHS = 500
+PATIENCE = 50
+LR = 5e-4
+WEIGHT_DECAY = 2e-4
+BATCH_TRAIN = 256
+BATCH_VAL = 512
+
+# LightGBM 하이퍼파라미터
+LGB_PARAMS = {
+    "objective": "mae",
+    "metric": "mae",
+    "learning_rate": 0.05,
+    "num_leaves": 31,
+    "feature_fraction": 0.9,
+    "bagging_fraction": 0.9,
+    "bagging_freq": 1,
+    "min_data_in_leaf": 20,
+    "verbosity": -1,
+    "seed": SEED,
+}
+NUM_BOOST_ROUND = 8000
+EARLY_STOP = 400
+
+ART_DIR = "artifacts_blend"
+os.makedirs(ART_DIR, exist_ok=True)
+
+# =========================
+# Utils
+# =========================
+def get_safe_device():
+    """CUDA가 실제 사용 가능한지 미리 검증하고, 실패 시 CPU로 폴백."""
+    if torch.cuda.is_available():
+        try:
+            _ = torch.zeros(1, device="cuda")
+            torch.cuda.synchronize()
+            print("[INFO] Using CUDA")
+            return torch.device("cuda")
+        except Exception as e:
+            print(f"[WARN] CUDA available but failed to initialize: {e}")
+    print("[INFO] Using CPU")
+    return torch.device("cpu")
+
+def set_seed(seed: int, device: torch.device):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if device.type == "cuda":
+        try:
+            torch.cuda.manual_seed_all(seed)
+        except Exception as e:
+            print(f"[WARN] torch.cuda.manual_seed_all failed: {e}")
+
+def read_table(path: str) -> pd.DataFrame:
+    p = pathlib.Path(path)
+    if p.suffix.lower() in (".xlsx", ".xls"):
+        return pd.read_excel(p)  # openpyxl 필요
+    return pd.read_csv(p)
+
+def ensure_categorical(df: pd.DataFrame, col: str) -> pd.DataFrame:
+    df = df.copy()
+    df[col] = df[col].astype(str).astype("category")
+    return df
+
+def tukey_biweight_weights_by_group(df, target=TARGET, group=CAT_COL, c=4.685, eps=1e-9):
+    """재질별 median/IQR 기준 Tukey biweight 가중치(0~1)"""
+    df = df.copy()
+    w = np.ones(len(df), dtype=np.float32)
+    for g, idx in df.groupby(group).groups.items():
+        y = df.loc[idx, target].astype(float)
+        med = np.median(y)
+        q1, q3 = np.percentile(y, 25), np.percentile(y, 75)
+        iqr = max(q3 - q1, eps)
+        u = (y - med) / (c * iqr)
+        w_g = np.where(np.abs(u) < 1, (1 - u**2)**2, 0.0)
+        w[idx] = w_g.astype(np.float32)
+    return np.clip(w, 0.05, 1.0).astype(np.float32)
+
+def search_best_alpha(oof_a: np.ndarray, oof_b: np.ndarray, y_true: np.ndarray):
+    alphas = np.linspace(0.0, 1.0, 1001)  # 0.0001 간격 정밀 탐색
+    best_a, best_mae = None, 1e9
+    for a in alphas:
+        blend = a*oof_a + (1-a)*oof_b
+        mae = mean_absolute_error(y_true, blend)
+        if mae < best_mae:
+            best_a, best_mae = a, mae
+    return best_a, best_mae
+
+# =========================
+# Dataset / Model
+# =========================
+class TabDataset(Dataset):
+    def __init__(self, mat_ids, num_feats, target=None, weights=None):
+        self.mat_ids = torch.tensor(mat_ids, dtype=torch.long)
+        self.num_feats = torch.tensor(num_feats, dtype=torch.float32)
+        self.target = None if target is None else torch.tensor(target, dtype=torch.float32).view(-1,1)
+        self.weights = None if weights is None else torch.tensor(weights, dtype=torch.float32).view(-1,1)
+    def __len__(self): return len(self.mat_ids)
+    def __getitem__(self, i):
+        if self.target is None:
+            return self.mat_ids[i], self.num_feats[i]
+        if self.weights is None:
+            return self.mat_ids[i], self.num_feats[i], self.target[i]
+        return self.mat_ids[i], self.num_feats[i], self.target[i], self.weights[i]
+
+class FTTransformer(nn.Module):
+    def __init__(self, n_materials:int, n_num:int, d_model:int=128, nhead:int=8,
+                 num_layers:int=4, dim_ff:int=256, dropout:float=0.2):
+        super().__init__()
+        self.mat_emb = nn.Embedding(n_materials, d_model)
+        self.num_linears = nn.ModuleList([nn.Linear(1, d_model) for _ in range(n_num)])
+        self.cls = nn.Parameter(torch.zeros(1, 1, d_model))
+        nn.init.trunc_normal_(self.cls, std=0.02)
+        enc_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, nhead=nhead,
+            dim_feedforward=dim_ff, dropout=dropout,
+            batch_first=True, activation='gelu', norm_first=True
+        )
+        self.encoder = nn.TransformerEncoder(enc_layer, num_layers=num_layers)
+        self.head = nn.Sequential(
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_model, 1)
+        )
+    def forward(self, mat_ids: torch.LongTensor, x_num: torch.FloatTensor):
+        B = x_num.size(0)
+        mat_tok = self.mat_emb(mat_ids).unsqueeze(1)   # (B,1,d)
+        num_tok = torch.cat([lin(x_num[:, i:i+1]).unsqueeze(1) for i,lin in enumerate(self.num_linears)], dim=1)
+        tokens = torch.cat([self.cls.expand(B, -1, -1), mat_tok, num_tok], dim=1)
+        h = self.encoder(tokens)
+        return self.head(h[:, 0, :])                   # (B,1)
+
+def weighted_l1_loss(pred, y, w):
+    return (w * (pred - y).abs()).sum() / (w.sum() + 1e-9)
+
+def val_mae(model, loader, device):
+    model.eval()
+    mae, n = 0.0, 0
+    with torch.no_grad():
+        for batch in loader:
+            if len(batch) == 4:
+                m,x,y,_ = batch
+            else:
+                m,x,y = batch
+            m,x,y = m.to(device), x.to(device), y.to(device)
+            p = model(m,x)
+            mae += (p - y).abs().sum().item()
+            n += y.size(0)
+    return mae / n
+
+# =========================
+# Main
+# =========================
+def main():
+    # 안전 디바이스 결정 → 그 디바이스 기준으로 시드 설정
+    device = get_safe_device()
+    set_seed(SEED, device)
+
+    # ----- Load -----
+    df = read_table(DATA_PATH).copy()
+    need = [CAT_COL] + NUM_COLS + [TARGET]
+    missing = [c for c in need if c not in df.columns]
+    if missing: raise RuntimeError(f"입력 데이터에 없는 컬럼: {missing}")
+    df = df.dropna(subset=[TARGET]).reset_index(drop=True)
+    df = ensure_categorical(df, CAT_COL)
+
+    # 샘플 가중치(없으면 로버스트 가중치 생성)
+    if "sample_weight" in df.columns:
+        df["sample_weight"] = df["sample_weight"].astype(np.float32)
+    else:
+        df["sample_weight"] = tukey_biweight_weights_by_group(df, target=TARGET, group=CAT_COL, c=4.685)
+
+    # material → id
+    materials = sorted(df[CAT_COL].astype(str).unique())
+    mat2id = {m:i for i,m in enumerate(materials)}
+    df["_mat_id"] = df[CAT_COL].astype(str).map(mat2id).astype(int)
+
+    # 공통 어레이
+    X_num_full = df[NUM_COLS].values.astype(np.float32)
+    y_full     = df[TARGET].values.astype(np.float32)
+    m_full     = df["_mat_id"].values
+    w_full     = df["sample_weight"].values.astype(np.float32)
+
+    # =========================
+    # 1) FT-Transformer 5-Fold OOF
+    # =========================
+    kf = KFold(n_splits=N_SPLITS, shuffle=True, random_state=SEED)
+    oof_dl = np.zeros(len(df), dtype=np.float32)
+    dl_models, dl_scalers = [], []
+    fold_summ_dl = []
+
+    for fold, (tr_idx, va_idx) in enumerate(kf.split(X_num_full), 1):
+        print(f"\n========== [DL] FOLD {fold}/{N_SPLITS} ==========")
+        # 스케일러 누수 방지
+        scaler = StandardScaler()
+        X_tr = scaler.fit_transform(X_num_full[tr_idx]).astype(np.float32)
+        X_va = scaler.transform(X_num_full[va_idx]).astype(np.float32)
+        y_tr, y_va = y_full[tr_idx], y_full[va_idx]
+        m_tr, m_va = m_full[tr_idx], m_full[va_idx]
+        w_tr, w_va = w_full[tr_idx], w_full[va_idx]
+
+        train_ds = TabDataset(m_tr, X_tr, y_tr, w_tr)
+        val_ds   = TabDataset(m_va, X_va, y_va, w_va)
+        train_dl = DataLoader(train_ds, batch_size=BATCH_TRAIN, shuffle=True,  num_workers=0)
+        val_dl   = DataLoader(val_ds,   batch_size=BATCH_VAL,   shuffle=False, num_workers=0)
+
+        model = FTTransformer(
+            n_materials=len(materials), n_num=len(NUM_COLS),
+            d_model=D_MODEL, nhead=NHEAD, num_layers=LAYERS, dim_ff=DIM_FF, dropout=DROPOUT
+        )
+        # 디바이스 이동에 실패하면 CPU 폴백
+        try:
+            model = model.to(device)
+        except Exception as e:
+            print(f"[WARN] model.to({device}) failed: {e}. Falling back to CPU.")
+            device = torch.device("cpu")
+            model = model.to(device)
+
+        optim = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY)
+        sched = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optim, T_0=10)
+
+        best_mae, best_state, wait = 1e9, None, 0
+        for epoch in range(1, EPOCHS+1):
+            model.train()
+            for m,x,y,w in train_dl:
+                m,x,y,w = m.to(device), x.to(device), y.to(device), w.to(device)
+                optim.zero_grad(set_to_none=True)
+                pred = model(m,x)
+                loss = weighted_l1_loss(pred, y, w)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 2.0)
+                optim.step()
+            sched.step(epoch)
+
+            mae = val_mae(model, val_dl, device)
+            print(f"[DL {epoch:03d}] VAL MAE={mae:.4f}")
+            if mae < best_mae - 1e-4:
+                best_mae, wait = mae, 0
+                best_state = {k:v.cpu().clone() for k,v in model.state_dict().items()}
+            else:
+                wait += 1
+                if wait >= PATIENCE:
+                    print("Early stopping.")
+                    break
+
+        # 복원 + fold 저장
+        if best_state is not None:
+            model.load_state_dict(best_state)
+        torch.save({
+            "state_dict": model.state_dict(),
+            "materials": materials,
+            "num_cols": NUM_COLS,
+            "scaler_mean": scaler.mean_, "scaler_scale": scaler.scale_,
+        }, os.path.join(ART_DIR, f"ftt_fold{fold}.pt"))
+        fold_summ_dl.append(best_mae)
+        print(f"[DL FOLD {fold}] best VAL MAE={best_mae:.4f}")
+
+        # ── OOF 채우기 (모델과 텐서를 같은 device에서)
+        try:
+            model = model.to(device)
+        except Exception as e:
+            print(f"[WARN] model.to({device}) failed during OOF: {e}. Falling back to CPU.")
+            device = torch.device("cpu")
+            model = model.to(device)
+
+        model.eval()
+        preds = []
+        with torch.no_grad():
+            val_loader = DataLoader(val_ds, batch_size=BATCH_VAL, shuffle=False, num_workers=0)
+            for batch in val_loader:
+                if len(batch)==4:
+                    m,x,y,_ = batch
+                else:
+                    m,x,y = batch
+                m,x = m.to(device), x.to(device)
+                p = model(m,x).cpu().numpy().ravel()
+                preds.append(p)
+        oof_dl[va_idx] = np.concatenate(preds).astype(np.float32)
+
+        # ── OOF 완료 후 CPU로 내려서 보관
+        dl_models.append(model.cpu())
+        dl_scalers.append(scaler)
+
+    oof_mae_dl = mean_absolute_error(y_full, oof_dl)
+    print("\n[DL] Fold best MAEs:", [f"{m:.4f}" for m in fold_summ_dl])
+    print(f"[DL] OOF MAE       : {oof_mae_dl:.4f}")
+    pd.DataFrame({"y_true": y_full, "y_oof_dl": oof_dl}).to_csv(os.path.join(ART_DIR, "oof_dl.csv"), index=False)
+
+    # =========================
+    # 2) LightGBM 5-Fold OOF (callbacks로 조기 종료/로그)
+    # =========================
+    df = ensure_categorical(df, CAT_COL)
+    FEATS_GBDT = [CAT_COL] + NUM_COLS
+    X_gbdt = df[FEATS_GBDT].copy()
+    y = y_full
+    w = w_full
+
+    kf2 = KFold(n_splits=N_SPLITS, shuffle=True, random_state=SEED)
+    oof_lgbm = np.zeros(len(df), dtype=np.float32)
+    lgbm_models = []
+    fold_summ_lgb = []
+
+    for fold, (tr_idx, va_idx) in enumerate(kf2.split(X_gbdt), 1):
+        print(f"\n========== [LGBM] FOLD {fold}/{N_SPLITS} ==========")
+        X_tr, X_va = X_gbdt.iloc[tr_idx], X_gbdt.iloc[va_idx]
+        y_tr, y_va = y[tr_idx], y[va_idx]
+        w_tr, w_va = w[tr_idx], w[va_idx]
+
+        dtr = lgb.Dataset(X_tr, label=y_tr, weight=w_tr,
+                          categorical_feature=[CAT_COL], free_raw_data=False)
+        dva = lgb.Dataset(X_va, label=y_va, weight=w_va,
+                          categorical_feature=[CAT_COL], reference=dtr, free_raw_data=False)
+
+        callbacks = [
+            lgb.early_stopping(EARLY_STOP, verbose=False),
+            lgb.log_evaluation(100),
+        ]
+
+        model = lgb.train(
+            LGB_PARAMS,
+            dtr,
+            num_boost_round=NUM_BOOST_ROUND,
+            valid_sets=[dtr, dva],
+            valid_names=["train","valid"],
+            callbacks=callbacks,
+        )
+
+        pred_va = model.predict(X_va, num_iteration=model.best_iteration)
+        oof_lgbm[va_idx] = pred_va.astype(np.float32)
+        mae = mean_absolute_error(y_va, pred_va)
+        fold_summ_lgb.append(mae)
+        print(f"[LGBM FOLD {fold}] VAL MAE={mae:.4f}")
+        model.save_model(os.path.join(ART_DIR, f"lgbm_fold{fold}.txt"),
+                         num_iteration=model.best_iteration)
+        lgbm_models.append(model)
+
+    oof_mae_lgb = mean_absolute_error(y, oof_lgbm)
+    print("\n[LGBM] Fold MAEs:", [f"{m:.4f}" for m in fold_summ_lgb])
+    print(f"[LGBM] OOF MAE  : {oof_mae_lgb:.4f}")
+    pd.DataFrame({"y_true": y, "y_oof_lgbm": oof_lgbm}).to_csv(os.path.join(ART_DIR, "oof_lgbm.csv"), index=False)
+
+    # =========================
+    # 3) OOF Blending (DL + LGBM)
+    # =========================
+    best_alpha, best_mae = search_best_alpha(oof_dl, oof_lgbm, y_full)
+    print(f"\n[BLEND] best α={best_alpha:.3f}, blended OOF MAE={best_mae:.4f}")
+    with open(os.path.join(ART_DIR, "blend_alpha.json"), "w") as f:
+        json.dump({"best_alpha": float(best_alpha), "oof_mae_blend": float(best_mae),
+                   "oof_mae_dl": float(oof_mae_dl), "oof_mae_lgbm": float(oof_mae_lgb)}, f, indent=2)
+
+    # =========================
+    # 4) Inference helper (예시)
+    # =========================
+    def predict_dl_ensemble(df_new: pd.DataFrame) -> np.ndarray:
+        df_new = df_new.copy()
+        df_new["_mat_id"] = df_new[CAT_COL].astype(str).map(mat2id).fillna(0).astype(int)
+        Xn = df_new[NUM_COLS].values.astype(np.float32)
+
+        preds = []
+        for mdl, sc in zip(dl_models, dl_scalers):
+            x = sc.transform(Xn).astype(np.float32)
+            mdl.eval()
+            with torch.no_grad():
+                m_ids = torch.tensor(df_new["_mat_id"].values, dtype=torch.long)
+                x_t = torch.tensor(x, dtype=torch.float32)
+                p = mdl(m_ids, x_t).cpu().numpy().ravel()
+            preds.append(p)
+        return np.mean(preds, axis=0)
+
+    def predict_lgbm_ensemble(df_new: pd.DataFrame) -> np.ndarray:
+        Xn = df_new[[CAT_COL] + NUM_COLS].copy()
+        Xn[CAT_COL] = Xn[CAT_COL].astype(str).astype("category")
+        preds = [mdl.predict(Xn, num_iteration=mdl.best_iteration) for mdl in lgbm_models]
+        return np.mean(preds, axis=0)
+
+    with open(os.path.join(ART_DIR, "materials.json"), "w", encoding="utf-8") as f:
+        json.dump({"materials": materials}, f, ensure_ascii=False, indent=2)
+    with open(os.path.join(ART_DIR, "columns.json"), "w", encoding="utf-8") as f:
+        json.dump({"num_cols": NUM_COLS, "cat_col": CAT_COL, "target": TARGET}, f, ensure_ascii=False, indent=2)
+
+    print(f"\nArtifacts saved in: {ART_DIR}")
+    print("Use predict_dl_ensemble / predict_lgbm_ensemble, and blend with best_alpha for new data.")
+
+if __name__ == "__main__":
+    device = get_safe_device()
+    main()

react_one.py

@@ -0,0 +1,93 @@
+# roofrail_filter_static.py
+import numpy as np
+import pandas as pd
+
+# 최소 허용 R (전제)
+R_MIN = 1.0
+
+# 직경별 허용범위 (직접 정의)
+# 구조: {직경: {각도: (상단R_max, 하단R_max)}}
+CONSTRAINTS = {
+    17: {deg: (2.0, 5.0) for deg in range(62, 90)},  # 62~89°
+    18: {deg: (3.0, 5.0) for deg in range(65, 91)},  # 65~90°
+    19: {deg: (3.5, 4.5) for deg in range(66, 91)},  # 66~90°
+    20: {deg: (4.0, 4.0) for deg in range(69, 91)},  # 69~90°
+    21: {deg: (4.5, 3.0) for deg in range(72, 88)},  # 72~87°
+    22: {deg: (5.0, 2.5) for deg in range(75, 88)},  # 75~87°
+}
+
+# 소재별 thinning 허용치 (실제 기준)
+THIN_LIMITS = {
+    "SPCUD": 0.25,
+    "SPCC": 0.21,
+    "SPRC340": 0.20,
+    "SPRC440": 0.17,
+    "SPFC590": 0.16,
+    "SPFC780": 0.10,
+    "SPFC980": 0.08,
+}
+
+def filter_model_outputs(
+    candidates: pd.DataFrame,
+    thinning_limits: dict = THIN_LIMITS,
+    max_failure_threshold: float = 0.97,  # ✅ 수정: 0.97 이하만 통과
+    r_min: float = R_MIN
+) -> pd.DataFrame:
+    """
+    candidates DataFrame 필수 컬럼:
+      ['material','thickness','diameter','degree','upper_r','lower_r',
+       'pred_max_failure','pred_thining']
+
+    반환: 입력 + ['allowed_R','allowed_model','final_ok','reject_reason']
+    """
+
+    df = candidates.copy()
+
+    allowed_R = []
+    reject_reason = []
+
+    for _, row in df.iterrows():
+        dia, deg, up, lo = int(row["diameter"]), int(row["degree"]), row["upper_r"], row["lower_r"]
+
+        # 1) 직경/각도 허용 여부
+        if dia not in CONSTRAINTS or deg not in CONSTRAINTS[dia]:
+            allowed_R.append(False)
+            reject_reason.append("disallowed_diameter_or_degree")
+            continue
+
+        up_max, lo_max = CONSTRAINTS[dia][deg]
+
+        # 2) R 범위 확인
+        if up < r_min or lo < r_min:
+            allowed_R.append(False)
+            reject_reason.append("R_below_min")
+            continue
+        if up > up_max:
+            allowed_R.append(False)
+            reject_reason.append("upper_r_above_max")
+            continue
+        if lo > lo_max:
+            allowed_R.append(False)
+            reject_reason.append("lower_r_above_max")
+            continue
+
+        # 통과
+        allowed_R.append(True)
+        reject_reason.append("")
+
+    df["allowed_R"] = allowed_R
+    df["reject_reason"] = reject_reason
+
+    # 3) 모델 조건
+    thin_limit = df["material"].map(thinning_limits)
+    cond_model = (
+        (df["pred_max_failure"] <= max_failure_threshold) &  # ✅ 수정: <= 0.97
+        thin_limit.notna() &
+        (df["pred_thining"] <= thin_limit)
+    )
+    df["allowed_model"] = cond_model
+
+    # 최종
+    df["final_ok"] = df["allowed_R"] & df["allowed_model"]
+
+    return df

study_model.py

@@ -0,0 +1,419 @@
+# train_blend_ftt_lgbm.py
+# FT-Transformer (weighted MAE + 5-Fold OOF) + LightGBM (5-Fold OOF) + OOF blending
+# pip install pandas numpy scikit-learn torch lightgbm openpyxl
+
+import os, math, json, random, pathlib
+import numpy as np
+import pandas as pd
+from typing import List, Tuple
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import mean_absolute_error
+import lightgbm as lgb
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+
+# =========================
+# Config
+# =========================
+SEED = 42
+DATA_PATH = r"C:\Users\KDT10\OneDrive\바탕 화면\AutoForm\데이터통합.xlsx"  # .xlsx 또는 .csv
+TARGET = "max_failure"
+CAT_COL = "material"  # 범주형
+NUM_COLS = ["thickness","diameter","degree","upper_radius","lower_radius","LB","RB"]  # 필요 시 물성/파생변수 추가
+N_SPLITS = 5
+
+# FT-Transformer 하이퍼파라미터 (튜닝안)
+D_MODEL = 256
+NHEAD = 8
+LAYERS = 6
+DIM_FF = 1024
+DROPOUT = 0.25
+EPOCHS = 500
+PATIENCE = 50
+LR = 5e-4
+WEIGHT_DECAY = 2e-4
+BATCH_TRAIN = 256
+BATCH_VAL = 512
+
+# LightGBM 하이퍼파라미터
+LGB_PARAMS = {
+    "objective": "mae",
+    "metric": "mae",
+    "learning_rate": 0.05,
+    "num_leaves": 31,
+    "feature_fraction": 0.9,
+    "bagging_fraction": 0.9,
+    "bagging_freq": 1,
+    "min_data_in_leaf": 20,
+    "verbosity": -1,
+    "seed": SEED,
+}
+NUM_BOOST_ROUND = 8000
+EARLY_STOP = 400
+
+ART_DIR = "artifacts_blend"
+os.makedirs(ART_DIR, exist_ok=True)
+
+# =========================
+# Utils
+# =========================
+def get_safe_device():
+    """CUDA가 실제 사용 가능한지 미리 검증하고, 실패 시 CPU로 폴백."""
+    if torch.cuda.is_available():
+        try:
+            _ = torch.zeros(1, device="cuda")
+            torch.cuda.synchronize()
+            print("[INFO] Using CUDA")
+            return torch.device("cuda")
+        except Exception as e:
+            print(f"[WARN] CUDA available but failed to initialize: {e}")
+    print("[INFO] Using CPU")
+    return torch.device("cpu")
+
+def set_seed(seed: int, device: torch.device):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if device.type == "cuda":
+        try:
+            torch.cuda.manual_seed_all(seed)
+        except Exception as e:
+            print(f"[WARN] torch.cuda.manual_seed_all failed: {e}")
+
+def read_table(path: str) -> pd.DataFrame:
+    p = pathlib.Path(path)
+    if p.suffix.lower() in (".xlsx", ".xls"):
+        return pd.read_excel(p)  # openpyxl 필요
+    return pd.read_csv(p)
+
+def ensure_categorical(df: pd.DataFrame, col: str) -> pd.DataFrame:
+    df = df.copy()
+    df[col] = df[col].astype(str).astype("category")
+    return df
+
+def tukey_biweight_weights_by_group(df, target=TARGET, group=CAT_COL, c=4.685, eps=1e-9):
+    """재질별 median/IQR 기준 Tukey biweight 가중치(0~1)"""
+    df = df.copy()
+    w = np.ones(len(df), dtype=np.float32)
+    for g, idx in df.groupby(group).groups.items():
+        y = df.loc[idx, target].astype(float)
+        med = np.median(y)
+        q1, q3 = np.percentile(y, 25), np.percentile(y, 75)
+        iqr = max(q3 - q1, eps)
+        u = (y - med) / (c * iqr)
+        w_g = np.where(np.abs(u) < 1, (1 - u**2)**2, 0.0)
+        w[idx] = w_g.astype(np.float32)
+    return np.clip(w, 0.05, 1.0).astype(np.float32)
+
+def search_best_alpha(oof_a: np.ndarray, oof_b: np.ndarray, y_true: np.ndarray):
+    alphas = np.linspace(0.0, 1.0, 1001)  # 0.0001 간격 정밀 탐색
+    best_a, best_mae = None, 1e9
+    for a in alphas:
+        blend = a*oof_a + (1-a)*oof_b
+        mae = mean_absolute_error(y_true, blend)
+        if mae < best_mae:
+            best_a, best_mae = a, mae
+    return best_a, best_mae
+
+# =========================
+# Dataset / Model
+# =========================
+class TabDataset(Dataset):
+    def __init__(self, mat_ids, num_feats, target=None, weights=None):
+        self.mat_ids = torch.tensor(mat_ids, dtype=torch.long)
+        self.num_feats = torch.tensor(num_feats, dtype=torch.float32)
+        self.target = None if target is None else torch.tensor(target, dtype=torch.float32).view(-1,1)
+        self.weights = None if weights is None else torch.tensor(weights, dtype=torch.float32).view(-1,1)
+    def __len__(self): return len(self.mat_ids)
+    def __getitem__(self, i):
+        if self.target is None:
+            return self.mat_ids[i], self.num_feats[i]
+        if self.weights is None:
+            return self.mat_ids[i], self.num_feats[i], self.target[i]
+        return self.mat_ids[i], self.num_feats[i], self.target[i], self.weights[i]
+
+class FTTransformer(nn.Module):
+    def __init__(self, n_materials:int, n_num:int, d_model:int=128, nhead:int=8,
+                 num_layers:int=4, dim_ff:int=256, dropout:float=0.2):
+        super().__init__()
+        self.mat_emb = nn.Embedding(n_materials, d_model)
+        self.num_linears = nn.ModuleList([nn.Linear(1, d_model) for _ in range(n_num)])
+        self.cls = nn.Parameter(torch.zeros(1, 1, d_model))
+        nn.init.trunc_normal_(self.cls, std=0.02)
+        enc_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, nhead=nhead,
+            dim_feedforward=dim_ff, dropout=dropout,
+            batch_first=True, activation='gelu', norm_first=True
+        )
+        self.encoder = nn.TransformerEncoder(enc_layer, num_layers=num_layers)
+        self.head = nn.Sequential(
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_model, 1)
+        )
+    def forward(self, mat_ids: torch.LongTensor, x_num: torch.FloatTensor):
+        B = x_num.size(0)
+        mat_tok = self.mat_emb(mat_ids).unsqueeze(1)   # (B,1,d)
+        num_tok = torch.cat([lin(x_num[:, i:i+1]).unsqueeze(1) for i,lin in enumerate(self.num_linears)], dim=1)
+        tokens = torch.cat([self.cls.expand(B, -1, -1), mat_tok, num_tok], dim=1)
+        h = self.encoder(tokens)
+        return self.head(h[:, 0, :])                   # (B,1)
+
+def weighted_l1_loss(pred, y, w):
+    return (w * (pred - y).abs()).sum() / (w.sum() + 1e-9)
+
+def val_mae(model, loader, device):
+    model.eval()
+    mae, n = 0.0, 0
+    with torch.no_grad():
+        for batch in loader:
+            if len(batch) == 4:
+                m,x,y,_ = batch
+            else:
+                m,x,y = batch
+            m,x,y = m.to(device), x.to(device), y.to(device)
+            p = model(m,x)
+            mae += (p - y).abs().sum().item()
+            n += y.size(0)
+    return mae / n
+
+# =========================
+# Main
+# =========================
+def main():
+    # 안전 디바이스 결정 → 그 디바이스 기준으로 시드 설정
+    device = get_safe_device()
+    set_seed(SEED, device)
+
+    # ----- Load -----
+    df = read_table(DATA_PATH).copy()
+    need = [CAT_COL] + NUM_COLS + [TARGET]
+    missing = [c for c in need if c not in df.columns]
+    if missing: raise RuntimeError(f"입력 데이터에 없는 컬럼: {missing}")
+    df = df.dropna(subset=[TARGET]).reset_index(drop=True)
+    df = ensure_categorical(df, CAT_COL)
+
+    # 샘플 가중치(없으면 로버스트 가중치 생성)
+    if "sample_weight" in df.columns:
+        df["sample_weight"] = df["sample_weight"].astype(np.float32)
+    else:
+        df["sample_weight"] = tukey_biweight_weights_by_group(df, target=TARGET, group=CAT_COL, c=4.685)
+
+    # material → id
+    materials = sorted(df[CAT_COL].astype(str).unique())
+    mat2id = {m:i for i,m in enumerate(materials)}
+    df["_mat_id"] = df[CAT_COL].astype(str).map(mat2id).astype(int)
+
+    # 공통 어레이
+    X_num_full = df[NUM_COLS].values.astype(np.float32)
+    y_full     = df[TARGET].values.astype(np.float32)
+    m_full     = df["_mat_id"].values
+    w_full     = df["sample_weight"].values.astype(np.float32)
+
+    # =========================
+    # 1) FT-Transformer 5-Fold OOF
+    # =========================
+    kf = KFold(n_splits=N_SPLITS, shuffle=True, random_state=SEED)
+    oof_dl = np.zeros(len(df), dtype=np.float32)
+    dl_models, dl_scalers = [], []
+    fold_summ_dl = []
+
+    for fold, (tr_idx, va_idx) in enumerate(kf.split(X_num_full), 1):
+        print(f"\n========== [DL] FOLD {fold}/{N_SPLITS} ==========")
+        # 스케일러 누수 방지
+        scaler = StandardScaler()
+        X_tr = scaler.fit_transform(X_num_full[tr_idx]).astype(np.float32)
+        X_va = scaler.transform(X_num_full[va_idx]).astype(np.float32)
+        y_tr, y_va = y_full[tr_idx], y_full[va_idx]
+        m_tr, m_va = m_full[tr_idx], m_full[va_idx]
+        w_tr, w_va = w_full[tr_idx], w_full[va_idx]
+
+        train_ds = TabDataset(m_tr, X_tr, y_tr, w_tr)
+        val_ds   = TabDataset(m_va, X_va, y_va, w_va)
+        train_dl = DataLoader(train_ds, batch_size=BATCH_TRAIN, shuffle=True,  num_workers=0)
+        val_dl   = DataLoader(val_ds,   batch_size=BATCH_VAL,   shuffle=False, num_workers=0)
+
+        model = FTTransformer(
+            n_materials=len(materials), n_num=len(NUM_COLS),
+            d_model=D_MODEL, nhead=NHEAD, num_layers=LAYERS, dim_ff=DIM_FF, dropout=DROPOUT
+        )
+        # 디바이스 이동에 실패하면 CPU 폴백
+        try:
+            model = model.to(device)
+        except Exception as e:
+            print(f"[WARN] model.to({device}) failed: {e}. Falling back to CPU.")
+            device = torch.device("cpu")
+            model = model.to(device)
+
+        optim = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY)
+        sched = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optim, T_0=10)
+
+        best_mae, best_state, wait = 1e9, None, 0
+        for epoch in range(1, EPOCHS+1):
+            model.train()
+            for m,x,y,w in train_dl:
+                m,x,y,w = m.to(device), x.to(device), y.to(device), w.to(device)
+                optim.zero_grad(set_to_none=True)
+                pred = model(m,x)
+                loss = weighted_l1_loss(pred, y, w)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 2.0)
+                optim.step()
+            sched.step(epoch)
+
+            mae = val_mae(model, val_dl, device)
+            print(f"[DL {epoch:03d}] VAL MAE={mae:.4f}")
+            if mae < best_mae - 1e-4:
+                best_mae, wait = mae, 0
+                best_state = {k:v.cpu().clone() for k,v in model.state_dict().items()}
+            else:
+                wait += 1
+                if wait >= PATIENCE:
+                    print("Early stopping.")
+                    break
+
+        # 복원 + fold 저장
+        if best_state is not None:
+            model.load_state_dict(best_state)
+        torch.save({
+            "state_dict": model.state_dict(),
+            "materials": materials,
+            "num_cols": NUM_COLS,
+            "scaler_mean": scaler.mean_, "scaler_scale": scaler.scale_,
+        }, os.path.join(ART_DIR, f"ftt_fold{fold}.pt"))
+        fold_summ_dl.append(best_mae)
+        print(f"[DL FOLD {fold}] best VAL MAE={best_mae:.4f}")
+
+        # ── OOF 채우기 (모델과 텐서를 같은 device에서)
+        try:
+            model = model.to(device)
+        except Exception as e:
+            print(f"[WARN] model.to({device}) failed during OOF: {e}. Falling back to CPU.")
+            device = torch.device("cpu")
+            model = model.to(device)
+
+        model.eval()
+        preds = []
+        with torch.no_grad():
+            val_loader = DataLoader(val_ds, batch_size=BATCH_VAL, shuffle=False, num_workers=0)
+            for batch in val_loader:
+                if len(batch)==4:
+                    m,x,y,_ = batch
+                else:
+                    m,x,y = batch
+                m,x = m.to(device), x.to(device)
+                p = model(m,x).cpu().numpy().ravel()
+                preds.append(p)
+        oof_dl[va_idx] = np.concatenate(preds).astype(np.float32)
+
+        # ── OOF 완료 후 CPU로 내려서 보관
+        dl_models.append(model.cpu())
+        dl_scalers.append(scaler)
+
+    oof_mae_dl = mean_absolute_error(y_full, oof_dl)
+    print("\n[DL] Fold best MAEs:", [f"{m:.4f}" for m in fold_summ_dl])
+    print(f"[DL] OOF MAE       : {oof_mae_dl:.4f}")
+    pd.DataFrame({"y_true": y_full, "y_oof_dl": oof_dl}).to_csv(os.path.join(ART_DIR, "oof_dl.csv"), index=False)
+
+    # =========================
+    # 2) LightGBM 5-Fold OOF (callbacks로 조기 종료/로그)
+    # =========================
+    df = ensure_categorical(df, CAT_COL)
+    FEATS_GBDT = [CAT_COL] + NUM_COLS
+    X_gbdt = df[FEATS_GBDT].copy()
+    y = y_full
+    w = w_full
+
+    kf2 = KFold(n_splits=N_SPLITS, shuffle=True, random_state=SEED)
+    oof_lgbm = np.zeros(len(df), dtype=np.float32)
+    lgbm_models = []
+    fold_summ_lgb = []
+
+    for fold, (tr_idx, va_idx) in enumerate(kf2.split(X_gbdt), 1):
+        print(f"\n========== [LGBM] FOLD {fold}/{N_SPLITS} ==========")
+        X_tr, X_va = X_gbdt.iloc[tr_idx], X_gbdt.iloc[va_idx]
+        y_tr, y_va = y[tr_idx], y[va_idx]
+        w_tr, w_va = w[tr_idx], w[va_idx]
+
+        dtr = lgb.Dataset(X_tr, label=y_tr, weight=w_tr,
+                          categorical_feature=[CAT_COL], free_raw_data=False)
+        dva = lgb.Dataset(X_va, label=y_va, weight=w_va,
+                          categorical_feature=[CAT_COL], reference=dtr, free_raw_data=False)
+
+        callbacks = [
+            lgb.early_stopping(EARLY_STOP, verbose=False),
+            lgb.log_evaluation(100),
+        ]
+
+        model = lgb.train(
+            LGB_PARAMS,
+            dtr,
+            num_boost_round=NUM_BOOST_ROUND,
+            valid_sets=[dtr, dva],
+            valid_names=["train","valid"],
+            callbacks=callbacks,
+        )
+
+        pred_va = model.predict(X_va, num_iteration=model.best_iteration)
+        oof_lgbm[va_idx] = pred_va.astype(np.float32)
+        mae = mean_absolute_error(y_va, pred_va)
+        fold_summ_lgb.append(mae)
+        print(f"[LGBM FOLD {fold}] VAL MAE={mae:.4f}")
+        model.save_model(os.path.join(ART_DIR, f"lgbm_fold{fold}.txt"),
+                         num_iteration=model.best_iteration)
+        lgbm_models.append(model)
+
+    oof_mae_lgb = mean_absolute_error(y, oof_lgbm)
+    print("\n[LGBM] Fold MAEs:", [f"{m:.4f}" for m in fold_summ_lgb])
+    print(f"[LGBM] OOF MAE  : {oof_mae_lgb:.4f}")
+    pd.DataFrame({"y_true": y, "y_oof_lgbm": oof_lgbm}).to_csv(os.path.join(ART_DIR, "oof_lgbm.csv"), index=False)
+
+    # =========================
+    # 3) OOF Blending (DL + LGBM)
+    # =========================
+    best_alpha, best_mae = search_best_alpha(oof_dl, oof_lgbm, y_full)
+    print(f"\n[BLEND] best α={best_alpha:.3f}, blended OOF MAE={best_mae:.4f}")
+    with open(os.path.join(ART_DIR, "blend_alpha.json"), "w") as f:
+        json.dump({"best_alpha": float(best_alpha), "oof_mae_blend": float(best_mae),
+                   "oof_mae_dl": float(oof_mae_dl), "oof_mae_lgbm": float(oof_mae_lgb)}, f, indent=2)
+
+    # =========================
+    # 4) Inference helper (예시)
+    # =========================
+    def predict_dl_ensemble(df_new: pd.DataFrame) -> np.ndarray:
+        df_new = df_new.copy()
+        df_new["_mat_id"] = df_new[CAT_COL].astype(str).map(mat2id).fillna(0).astype(int)
+        Xn = df_new[NUM_COLS].values.astype(np.float32)
+
+        preds = []
+        for mdl, sc in zip(dl_models, dl_scalers):
+            x = sc.transform(Xn).astype(np.float32)
+            mdl.eval()
+            with torch.no_grad():
+                m_ids = torch.tensor(df_new["_mat_id"].values, dtype=torch.long)
+                x_t = torch.tensor(x, dtype=torch.float32)
+                p = mdl(m_ids, x_t).cpu().numpy().ravel()
+            preds.append(p)
+        return np.mean(preds, axis=0)
+
+    def predict_lgbm_ensemble(df_new: pd.DataFrame) -> np.ndarray:
+        Xn = df_new[[CAT_COL] + NUM_COLS].copy()
+        Xn[CAT_COL] = Xn[CAT_COL].astype(str).astype("category")
+        preds = [mdl.predict(Xn, num_iteration=mdl.best_iteration) for mdl in lgbm_models]
+        return np.mean(preds, axis=0)
+
+    with open(os.path.join(ART_DIR, "materials.json"), "w", encoding="utf-8") as f:
+        json.dump({"materials": materials}, f, ensure_ascii=False, indent=2)
+    with open(os.path.join(ART_DIR, "columns.json"), "w", encoding="utf-8") as f:
+        json.dump({"num_cols": NUM_COLS, "cat_col": CAT_COL, "target": TARGET}, f, ensure_ascii=False, indent=2)
+
+    print(f"\nArtifacts saved in: {ART_DIR}")
+    print("Use predict_dl_ensemble / predict_lgbm_ensemble, and blend with best_alpha for new data.")
+
+if __name__ == "__main__":
+    device = get_safe_device()
+    main()