checkpoint_1

Analysis_code/5.optima/deepgbm_ctgan10000/deepgbm_ctgan10000_busan.py

@@ -0,0 +1,98 @@
+import optuna
+import numpy as np
+import random
+import pandas as pd
+import joblib
+import os
+import torch
+from utils import *
+# Python 및 Numpy 시드 고정
+seed = 42
+random.seed(seed)
+np.random.seed(seed)
+
+
+# 1. Study 생성 시 'maximize'로 설정
+study = optuna.create_study(
+    direction="maximize",  # CSI 점수가 높을수록 좋으므로 maximize
+    pruner=optuna.pruners.MedianPruner(n_warmup_steps=10) # 초반 10에폭은 지켜보고 이후 가지치기
+)
+# Trial 완료 시 상세 정보 출력하는 callback 함수
+def print_trial_callback(study, trial):
+    """각 trial 완료 시 best value를 포함한 상세 정보 출력"""
+    print(f"\n{'='*80}")
+    print(f"Trial {trial.number} 완료")
+    print(f"  Value (CSI): {trial.value:.6f}" if trial.value is not None else f"  Value: {trial.value}")
+    print(f"  Parameters: {trial.params}")
+    print(f"  Best Value (CSI): {study.best_value:.6f}" if study.best_value is not None else f"  Best Value: {study.best_value}")
+    print(f"  Best Trial: {study.best_trial.number}")
+    print(f"  Best Parameters: {study.best_params}")
+    print(f"{'='*80}\n")
+
+
+
+# 2. 최적화 실행
+study.optimize(
+    lambda trial: objective(trial, model_choose="deepgbm", region="busan", data_sample='ctgan10000'), 
+    n_trials=100
+,
+    callbacks=[print_trial_callback]
+)
+
+# 3. 결과 확인 및 요약
+print(f"\n최적화 완료.")
+print(f"Best CSI Score: {study.best_value:.4f}")
+print(f"Best Hyperparameters: {study.best_params}")
+
+try:
+    # 모든 trial의 CSI 점수 추출
+    csi_scores = [trial.value for trial in study.trials if trial.value is not None]
+    
+    if len(csi_scores) > 0:
+        print(f"\n최적화 과정 요약:")
+        print(f"  - 총 시도 횟수: {len(study.trials)}")
+        print(f"  - 성공한 시도: {len(csi_scores)}")
+        print(f"  - 최초 CSI: {csi_scores[0]:.4f}")
+        print(f"  - 최종 CSI: {csi_scores[-1]:.4f}")
+        print(f"  - 최고 CSI: {max(csi_scores):.4f}")
+        print(f"  - 최저 CSI: {min(csi_scores):.4f}")
+        print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
+    
+    # Study 객체 저장
+    # 파일 위치 기반으로 base 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
+    os.makedirs(os.path.join(base_dir, "optimization_history"), exist_ok=True)
+    study_path = os.path.join(base_dir, "optimization_history/deepgbm_ctgan10000_busan_trials.pkl")
+    joblib.dump(study, study_path)
+    print(f"\n최적화 Study 객체가 {study_path}에 저장되었습니다.")
+    
+    # 최적화된 하이퍼파라미터로 최종 모델 학습 및 저장
+    print("\n" + "="*50)
+    print("최적화된 하이퍼파라미터로 최종 모델 학습 시작")
+    print("="*50)
+    
+    best_params = study.best_params
+    model_path = train_final_model(
+        best_params=best_params,
+        model_choose="deepgbm",
+        region="busan",
+        data_sample='ctgan10000',
+        target='multi',
+        n_folds=3,
+        random_state=seed
+    )
+    
+    print(f"\n최종 모델 학습 및 저장 완료!")
+    print(f"저장된 모델 경로: {model_path}")
+        
+except Exception as e:
+    print(f"\n⚠️  최적화 결과 분석 중 오류 발생: {e}")
+    import traceback
+    traceback.print_exc()
+
+# 정상 종료
+import sys
+sys.exit(0)
+
+

Analysis_code/5.optima/deepgbm_ctgan10000/utils.py

@@ -0,0 +1,721 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import random
+import os
+import copy
+from sklearn.preprocessing import QuantileTransformer, LabelEncoder
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.metrics import confusion_matrix
+from sklearn.utils.class_weight import compute_class_weight
+import pandas as pd
+import optuna
+from sklearn.metrics import accuracy_score, f1_score
+import joblib
+
+
+import sys
+# 파일 위치 기반으로 models 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+models_path = os.path.abspath(os.path.join(current_file_dir, '../../models'))
+sys.path.insert(0, models_path)
+from ft_transformer import FTTransformer
+from resnet_like import ResNetLike
+from deepgbm import DeepGBM
+import warnings
+warnings.filterwarnings('ignore')
+
+
+# Python 및 Numpy 시드 고정
+seed = 42
+random.seed(seed)
+np.random.seed(seed)
+
+# PyTorch 시드 고정
+torch.manual_seed(seed)
+torch.cuda.manual_seed(seed)
+torch.cuda.manual_seed_all(seed)  # Multi-GPU 환경에서 동일한 시드 적용
+
+# PyTorch 연산의 결정적 모드 설정
+torch.backends.cudnn.deterministic = True  # 실행마다 동일한 결과를 보장
+torch.backends.cudnn.benchmark = True  # 성능 최적화를 활성화 (가능한 한 빠른 연산 수행)
+
+
+def add_derived_features(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    제거했던 파생 변수들을 복구
+    
+    Args:
+        df: 데이터프레임
+    
+    Returns:
+        파생 변수가 추가된 데이터프레임
+    """
+    df = df.copy()
+    df['hour_sin'] = np.sin(2 * np.pi * df['hour'] / 24)
+    df['hour_cos'] = np.cos(2 * np.pi * df['hour'] / 24)
+    df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
+    df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
+    df['ground_temp - temp_C'] = df['groundtemp'] - df['temp_C']
+    return df
+
+def preprocessing(df):
+    """데이터 전처리 함수.
+    
+    Args:
+        df: 원본 데이터프레임
+        
+    Returns:
+        전처리된 데이터프레임
+    """
+    df = df[df.columns].copy()
+    df['year'] = df['year'].astype('int')
+    df['month'] = df['month'].astype('int')
+    df['hour'] = df['hour'].astype('int')
+    df = add_derived_features(df).copy()
+    df['multi_class'] = df['multi_class'].astype('int')
+    df.loc[df['wind_dir']=='정온', 'wind_dir'] = "0"
+    df['wind_dir'] = df['wind_dir'].astype('int')
+    df = df[['temp_C', 'precip_mm', 'wind_speed', 'wind_dir', 'hm',
+       'vap_pressure', 'dewpoint_C', 'loc_pressure', 'sea_pressure',
+       'solarRad', 'snow_cm', 'cloudcover', 'lm_cloudcover', 'low_cloudbase',
+       'groundtemp', 'O3', 'NO2', 'PM10', 'PM25', 'year',
+       'month', 'hour', 'ground_temp - temp_C', 'hour_sin', 'hour_cos',
+       'month_sin', 'month_cos','multi_class']].copy()
+    return df
+
+
+# 데이터셋 준비 함수
+def prepare_dataset(region, data_sample='pure', target='multi', fold=3):
+
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    return X_train, X_val, X_test, y_train, y_val, y_test, categorical_cols, numerical_cols
+
+
+
+# 데이터 변환 및 dataloader 생성 함수
+def prepare_dataloader(region, data_sample='pure', target='multi', fold=3, random_state=None):
+
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    # 연속형 변수와 범주형 변수 분리
+    X_train_num = torch.tensor(X_train[numerical_cols].values, dtype=torch.float32)
+    X_train_cat = torch.tensor(X_train[categorical_cols].values, dtype=torch.long)
+
+    X_val_num = torch.tensor(X_val[numerical_cols].values, dtype=torch.float32)
+    X_val_cat = torch.tensor(X_val[categorical_cols].values, dtype=torch.long)
+
+    X_test_num = torch.tensor(X_test[numerical_cols].values, dtype=torch.float32)
+    X_test_cat = torch.tensor(X_test[categorical_cols].values, dtype=torch.long)
+
+    # 레이블 변환
+    if target == "binary":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32)  # 이진 분류 → float32
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.float32)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32)
+    elif target == "multi":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)  # 다중 분류 → long
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.long)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.long)
+    else:
+        raise ValueError("target must be 'binary' or 'multi'")
+
+    # TensorDataset 생성
+    train_dataset = TensorDataset(X_train_num, X_train_cat, y_train_tensor)
+    val_dataset = TensorDataset(X_val_num, X_val_cat, y_val_tensor)
+    test_dataset = TensorDataset(X_test_num, X_test_cat, y_test_tensor)
+
+    # DataLoader 생성
+    if random_state == None:
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, generator=torch.Generator().manual_seed(random_state))
+    val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
+    
+    return X_train, categorical_cols, numerical_cols, train_loader, val_loader, test_loader
+
+# 데이터 변환 및 dataloader 생성 함수 (batch_size 파라미터 추가 버전)
+def prepare_dataloader_with_batchsize(region, data_sample='pure', target='multi', fold=3, random_state=None, batch_size=64):
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    # 연속형 변수와 범주형 변수 분리
+    X_train_num = torch.tensor(X_train[numerical_cols].values, dtype=torch.float32)
+    X_train_cat = torch.tensor(X_train[categorical_cols].values, dtype=torch.long)
+
+    X_val_num = torch.tensor(X_val[numerical_cols].values, dtype=torch.float32)
+    X_val_cat = torch.tensor(X_val[categorical_cols].values, dtype=torch.long)
+
+    X_test_num = torch.tensor(X_test[numerical_cols].values, dtype=torch.float32)
+    X_test_cat = torch.tensor(X_test[categorical_cols].values, dtype=torch.long)
+
+    # 레이블 변환
+    if target == "binary":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32)  # 이진 분류 → float32
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.float32)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32)
+    elif target == "multi":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)  # 다중 분류 → long
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.long)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.long)
+    else:
+        raise ValueError("target must be 'binary' or 'multi'")
+
+    # TensorDataset 생성
+    train_dataset = TensorDataset(X_train_num, X_train_cat, y_train_tensor)
+    val_dataset = TensorDataset(X_val_num, X_val_cat, y_val_tensor)
+    test_dataset = TensorDataset(X_test_num, X_test_cat, y_test_tensor)
+
+    # DataLoader 생성 (batch_size 파라미터 사용)
+    if random_state == None:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, generator=torch.Generator().manual_seed(random_state))
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+    
+    return X_train, categorical_cols, numerical_cols, train_loader, val_loader, test_loader, y_train, scaler
+
+
+def calculate_csi(y_true, pred):
+
+    cm = confusion_matrix(y_true, pred)  # 변수 이름을 cm으로 변경
+    # 혼동 행렬에서 H, F, M 추출
+    H = (cm[0, 0] + cm[1, 1])
+    
+    F = (cm[1, 0] + cm[2, 0] +
+         cm[0, 1] + cm[2, 1])
+    
+    M = (cm[0, 2] + cm[1, 2])
+    
+    # CSI 계산
+    CSI = H / (H + F + M + 1e-10)
+    return CSI
+
+def sample_weight(y_train):
+    class_weights = compute_class_weight(
+        class_weight='balanced',
+        classes=np.unique(y_train),  # 고유 클래스
+        y=y_train                   # 학습 데이터 레이블
+    )
+    sample_weights = np.array([class_weights[label] for label in y_train])
+
+    return sample_weights
+
+# 하이퍼파라미터 최적화 함수 정의
+def objective(trial, model_choose, region, data_sample='pure', target='multi', n_folds=3, random_state=42):
+    # GPU 사용 가능 여부 확인 및 device 설정
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    val_scores = []
+
+    # --- 1. 하이퍼파라미터 탐색 범위 정의 (수정됨) ---
+    if model_choose == "ft_transformer":
+        d_token = trial.suggest_int("d_token", 64, 256, step=32)
+        n_blocks = trial.suggest_int("n_blocks", 2, 6) # 깊이 축소로 과적합 방지
+        n_heads = trial.suggest_categorical("n_heads", [4, 8])
+        # d_token은 n_heads의 배수여야 함 (FT-Transformer의 구조적 제약 대응)
+        if d_token % n_heads != 0:
+            d_token = (d_token // n_heads) * n_heads
+            
+        attention_dropout = trial.suggest_float("attention_dropout", 0.1, 0.4)
+        ffn_dropout = trial.suggest_float("ffn_dropout", 0.1, 0.4)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True) # 범위 확대
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    elif model_choose == 'resnet_like':
+        d_main = trial.suggest_int("d_main", 64, 256, step=32)
+        d_hidden = trial.suggest_int("d_hidden", 64, 512, step=64)
+        n_blocks = trial.suggest_int("n_blocks", 2, 5) # 너무 깊지 않게 조절
+        dropout_first = trial.suggest_float("dropout_first", 0.1, 0.4)
+        dropout_second = trial.suggest_float("dropout_second", 0.0, 0.2)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    elif model_choose == 'deepgbm':
+        # DeepGBM의 경우 모델 특성에 맞춰 ResNet 블록 및 임베딩 차원 조절
+        d_main = trial.suggest_int("d_main", 64, 256, step=32)
+        d_hidden = trial.suggest_int("d_hidden", 64, 256, step=64)
+        n_blocks = trial.suggest_int("n_blocks", 2, 6)
+        dropout = trial.suggest_float("dropout", 0.1, 0.4)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    # --- 2. Fold별 학습 및 교차 검증 ---
+    for fold in range(1, n_folds + 1):
+        X_train_df, categorical_cols, numerical_cols, train_loader, val_loader, _, y_train, _ = prepare_dataloader_with_batchsize(
+            region, data_sample=data_sample, target=target, fold=fold, random_state=random_state, batch_size=batch_size
+        )
+
+        # 모델 초기화
+        if model_choose == "ft_transformer":
+            model = FTTransformer(
+                num_features=len(numerical_cols),
+                cat_cardinalities=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_token=d_token,
+                n_blocks=n_blocks,
+                n_heads=n_heads,
+                attention_dropout=attention_dropout,
+                ffn_dropout=ffn_dropout,
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'resnet_like':
+            input_dim = len(numerical_cols) + len(categorical_cols)
+            model = ResNetLike(
+                input_dim=input_dim,
+                d_main=d_main, 
+                d_hidden=d_hidden, 
+                n_blocks=n_blocks, 
+                dropout_first=dropout_first, 
+                dropout_second=dropout_second,
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'deepgbm':
+            model = DeepGBM(
+                num_features=len(numerical_cols),
+                cat_features=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_main=d_main,
+                d_hidden=d_hidden,
+                n_blocks=n_blocks,
+                dropout=dropout,
+                num_classes=3
+            ).to(device)
+
+        # 클래스 가중치 계산 및 손실 함수 설정 (Label Smoothing 적용)
+        if target == 'multi':
+            class_weights = compute_class_weight(
+                class_weight='balanced',
+                classes=np.unique(y_train),
+                y=y_train
+            )
+            # 클래스별 가중치 로그 출력
+            unique_classes = np.unique(y_train)
+            class_counts = {cls: np.sum(y_train == cls) for cls in unique_classes}
+            print(f"  Fold {fold} - 클래스별 가중치: {dict(zip(unique_classes, class_weights))} (클래스별 샘플 수: {class_counts})")
+            class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
+            criterion = nn.CrossEntropyLoss(weight=class_weights_tensor, label_smoothing=0.0)  # Label Smoothing 추가
+        else:
+            criterion = nn.BCEWithLogitsLoss()
+        optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
+        
+        # 학습률 스케줄러 추가: 성능 정체 시 LR을 0.5배 감소 (검증 CSI 기준)
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+
+        # 학습 설정 (에폭 및 페이션스 상향)
+        epochs = 200 
+        patience = 12 # 딥러닝의 정체 구간을 고려하여 소폭 상향
+        best_fold_csi = 0
+        counter = 0
+
+        for epoch in range(epochs):
+            model.train()
+            for x_num_batch, x_cat_batch, y_batch in train_loader:
+                x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                
+                optimizer.zero_grad()
+                y_pred = model(x_num_batch, x_cat_batch)
+                loss = criterion(y_pred, y_batch if target == 'multi' else y_batch.float())
+                loss.backward()
+                optimizer.step()
+
+            # Validation 평가
+            model.eval()
+            y_pred_val, y_true_val = [], []
+            with torch.no_grad():
+                for x_num_batch, x_cat_batch, y_batch in val_loader:
+                    x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                    output = model(x_num_batch, x_cat_batch)
+                    pred = output.argmax(dim=1) if target == 'multi' else (torch.sigmoid(output) >= 0.5).long()
+                    
+                    y_pred_val.extend(pred.cpu().numpy())
+                    y_true_val.extend(y_batch.cpu().numpy())
+
+            # CSI 계산 및 스케줄러 업데이트
+            val_csi = calculate_csi(y_true_val, y_pred_val)
+            scheduler.step(val_csi)
+
+            # Optuna Pruning 적용 (첫 번째 Fold에서 조기 종료 판단 강화)
+            trial.report(val_csi, epoch)
+            if trial.should_prune():
+                raise optuna.exceptions.TrialPruned()
+
+            # Early Stopping 체크
+            if val_csi > best_fold_csi:
+                best_fold_csi = val_csi
+                counter = 0
+            else:
+                counter += 1
+
+            if counter >= patience:
+                break
+
+        val_scores.append(best_fold_csi)
+
+    # 모든 fold의 평균 성능 반환
+    return np.mean(val_scores)
+
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습 및 저장 함수
+def train_final_model(best_params, model_choose, region, data_sample='pure', target='multi', n_folds=3, random_state=42):
+    """
+    최적화된 하이퍼파라미터로 최종 모델을 학습하고 저장합니다.
+    
+    Args:
+        best_params: 최적화된 하이퍼파라미터 딕셔너리
+        model_choose: 모델 선택 ('ft_transformer', 'resnet_like', 'deepgbm')
+        region: 지역명
+        data_sample: 데이터 샘플 타입 ('pure', 'smote', etc.)
+        target: 타겟 타입 ('multi', 'binary')
+        n_folds: 교차 검증 fold 수
+        random_state: 랜덤 시드
+    
+    Returns:
+        저장된 모델 경로 리스트
+    """
+    # GPU 사용 가능 여부 확인 및 device 설정
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    models = []
+    scalers = []  # scaler 리스트 추가
+    
+    print("최종 모델 학습 시작...")
+    
+    for fold in range(1, n_folds + 1):
+        print(f"Fold {fold} 학습 중...")
+        
+        # 최적화된 batch_size 사용
+        batch_size = best_params.get("batch_size", 64)
+        X_train_df, categorical_cols, numerical_cols, train_loader, val_loader, _, y_train, scaler = prepare_dataloader_with_batchsize(
+            region, data_sample=data_sample, target=target, fold=fold, random_state=random_state, batch_size=batch_size
+        )
+        
+        # 모델 초기화
+        if model_choose == "ft_transformer":
+            d_token = best_params["d_token"]
+            n_heads = best_params.get("n_heads", 8)
+            # d_token은 n_heads의 배수여야 함 (FT-Transformer의 구조적 제약 대응)
+            if d_token % n_heads != 0:
+                d_token = (d_token // n_heads) * n_heads
+            
+            model = FTTransformer(
+                num_features=len(numerical_cols),
+                cat_cardinalities=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_token=d_token,
+                n_blocks=best_params["n_blocks"],
+                n_heads=n_heads,
+                attention_dropout=best_params["attention_dropout"],
+                ffn_dropout=best_params["ffn_dropout"],
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'resnet_like':
+            input_dim = len(numerical_cols) + len(categorical_cols)
+            model = ResNetLike(
+                input_dim=input_dim,
+                d_main=best_params["d_main"],
+                d_hidden=best_params["d_hidden"],
+                n_blocks=best_params["n_blocks"],
+                dropout_first=best_params["dropout_first"],
+                dropout_second=best_params["dropout_second"],
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'deepgbm':
+            model = DeepGBM(
+                num_features=len(numerical_cols),
+                cat_features=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_main=best_params["d_main"],
+                d_hidden=best_params["d_hidden"],
+                n_blocks=best_params["n_blocks"],
+                dropout=best_params["dropout"],
+                num_classes=3
+            ).to(device)
+        else:
+            raise ValueError(f"Unknown model_choose: {model_choose}")
+        
+        # 클래스 가중치 계산 및 손실 함수 설정 (Label Smoothing 적용)
+        if target == 'multi':
+            class_weights = compute_class_weight(
+                class_weight='balanced',
+                classes=np.unique(y_train),
+                y=y_train
+            )
+            class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
+            criterion = nn.CrossEntropyLoss(weight=class_weights_tensor, label_smoothing=0.0)  # Label Smoothing 추가
+        else:
+            criterion = nn.BCEWithLogitsLoss()
+        optimizer = optim.AdamW(model.parameters(), lr=best_params["lr"], weight_decay=best_params["weight_decay"])
+        
+        # 학습률 스케줄러
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+        
+        # 학습 설정
+        epochs = 200
+        patience = 12
+        best_fold_csi = 0
+        counter = 0
+        best_model = None
+        
+        for epoch in range(epochs):
+            model.train()
+            for x_num_batch, x_cat_batch, y_batch in train_loader:
+                x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                
+                optimizer.zero_grad()
+                y_pred = model(x_num_batch, x_cat_batch)
+                loss = criterion(y_pred, y_batch if target == 'multi' else y_batch.float())
+                loss.backward()
+                optimizer.step()
+            
+            # Validation 평가
+            model.eval()
+            y_pred_val, y_true_val = [], []
+            with torch.no_grad():
+                for x_num_batch, x_cat_batch, y_batch in val_loader:
+                    x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                    output = model(x_num_batch, x_cat_batch)
+                    pred = output.argmax(dim=1) if target == 'multi' else (torch.sigmoid(output) >= 0.5).long()
+                    
+                    y_pred_val.extend(pred.cpu().numpy())
+                    y_true_val.extend(y_batch.cpu().numpy())
+            
+            # CSI 계산 및 스케줄러 업데이트
+            val_csi = calculate_csi(y_true_val, y_pred_val)
+            scheduler.step(val_csi)
+            
+            # Early Stopping 체크
+            if val_csi > best_fold_csi:
+                best_fold_csi = val_csi
+                counter = 0
+                best_model = copy.deepcopy(model)
+            else:
+                counter += 1
+            
+            if counter >= patience:
+                print(f"  Early stopping at epoch {epoch+1}, Best CSI: {best_fold_csi:.4f}")
+                break
+        
+        if best_model is None:
+            best_model = model
+        
+        scalers.append(scaler)  # scaler 저장 (fold 순서대로)
+        models.append(best_model)
+        print(f"  Fold {fold} 학습 완료 (검증 CSI: {best_fold_csi:.4f})")
+    
+    # 모델 저장 경로 설정
+    save_dir = f'../save_model/{model_choose}_optima'
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 파일명 생성
+    if data_sample == 'pure':
+        model_filename = f'{model_choose}_pure_{region}.pkl'
+    else:
+        model_filename = f'{model_choose}_{data_sample}_{region}.pkl'
+    
+    model_path = f'{save_dir}/{model_filename}'
+    
+    # 리스트에 담아 한 번에 저장
+    joblib.dump(models, model_path)
+    print(f"\n모든 모델 저장 완료: {model_path} (총 {len(models)}개 fold)")
+    
+    # Scaler 별도 저장
+    scaler_save_dir = f'../save_model/{model_choose}_optima/scaler'
+    os.makedirs(scaler_save_dir, exist_ok=True)
+    
+    # 파일명 생성 (모델과 동일한 패턴)
+    if data_sample == 'pure':
+        scaler_filename = f'{model_choose}_pure_{region}_scaler.pkl'
+    else:
+        scaler_filename = f'{model_choose}_{data_sample}_{region}_scaler.pkl'
+    
+    scaler_path = f'{scaler_save_dir}/{scaler_filename}'
+    joblib.dump(scalers, scaler_path)
+    print(f"Scaler 저장 완료: {scaler_path} (총 {len(scalers)}개 fold)")
+    
+    return model_path
+

Analysis_code/5.optima/ft_transformer_ctgan10000/ft_transformer_ctgan10000_busan.py

@@ -0,0 +1,96 @@
+import optuna
+import numpy as np
+import random
+import pandas as pd
+import joblib
+import os
+import torch
+from utils import *
+# Python 및 Numpy 시드 고정
+seed = 42
+random.seed(seed)
+np.random.seed(seed)
+
+
+# Trial 완료 시 상세 정보 출력하는 callback 함수
+def print_trial_callback(study, trial):
+    """각 trial 완료 시 best value를 포함한 상세 정보 출력"""
+    print(f"\n{'='*80}")
+    print(f"Trial {trial.number} 완료")
+    print(f"  Value (CSI): {trial.value:.6f}" if trial.value is not None else f"  Value: {trial.value}")
+    print(f"  Parameters: {trial.params}")
+    print(f"  Best Value (CSI): {study.best_value:.6f}" if study.best_value is not None else f"  Best Value: {study.best_value}")
+    print(f"  Best Trial: {study.best_trial.number}")
+    print(f"  Best Parameters: {study.best_params}")
+    print(f"{'='*80}\n")
+
+
+# 1. Study 생성 시 'maximize'로 설정
+study = optuna.create_study(
+    direction="maximize",  # CSI 점수가 높을수록 좋으므로 maximize
+    pruner=optuna.pruners.MedianPruner(n_warmup_steps=10) # 초반 10에폭은 지켜보고 이후 가지치기
+)
+
+# 2. 최적화 실행
+study.optimize(
+    lambda trial: objective(trial, model_choose="ft_transformer", region="busan", data_sample='ctgan10000'), 
+    n_trials=100,
+    callbacks=[print_trial_callback]
+)
+
+# 3. 결과 확인 및 요약
+print(f"\n최적화 완료.")
+print(f"Best CSI Score: {study.best_value:.4f}")
+print(f"Best Hyperparameters: {study.best_params}")
+
+try:
+    # 모든 trial의 CSI 점수 추출
+    csi_scores = [trial.value for trial in study.trials if trial.value is not None]
+    
+    if len(csi_scores) > 0:
+        print(f"\n최적화 과정 요약:")
+        print(f"  - 총 시도 횟수: {len(study.trials)}")
+        print(f"  - 성공한 시도: {len(csi_scores)}")
+        print(f"  - 최초 CSI: {csi_scores[0]:.4f}")
+        print(f"  - 최종 CSI: {csi_scores[-1]:.4f}")
+        print(f"  - 최고 CSI: {max(csi_scores):.4f}")
+        print(f"  - 최저 CSI: {min(csi_scores):.4f}")
+        print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
+    
+    # Study 객체 저장
+    # 파일 위치 기반으로 base 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
+    os.makedirs(os.path.join(base_dir, "optimization_history"), exist_ok=True)
+    study_path = os.path.join(base_dir, "optimization_history/ft_transformer_ctgan10000_busan_trials.pkl")
+    joblib.dump(study, study_path)
+    print(f"\n최적화 Study 객체가 {study_path}에 저장되었습니다.")
+    
+    # 최적화된 하이퍼파라미터로 최종 모델 학습 및 저장
+    print("\n" + "="*50)
+    print("최적화된 하이퍼파라미터로 최종 모델 학습 시작")
+    print("="*50)
+    
+    best_params = study.best_params
+    model_path = train_final_model(
+        best_params=best_params,
+        model_choose="ft_transformer",
+        region="busan",
+        data_sample='ctgan10000',
+        target='multi',
+        n_folds=3,
+        random_state=seed
+    )
+    
+    print(f"\n최종 모델 학습 및 저장 완료!")
+    print(f"저장된 모델 경로: {model_path}")
+        
+except Exception as e:
+    print(f"\n⚠️  최적화 결과 분석 중 오류 발생: {e}")
+    import traceback
+    traceback.print_exc()
+
+# 정상 종료
+import sys
+sys.exit(0)
+

Analysis_code/5.optima/ft_transformer_ctgan10000/utils.py

@@ -0,0 +1,720 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import random
+import os
+import copy
+from sklearn.preprocessing import QuantileTransformer, LabelEncoder
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.metrics import confusion_matrix
+from sklearn.utils.class_weight import compute_class_weight
+import pandas as pd
+import optuna
+from sklearn.metrics import accuracy_score, f1_score
+import joblib
+
+
+import sys
+# 파일 위치 기반으로 models 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+models_path = os.path.abspath(os.path.join(current_file_dir, '../../models'))
+sys.path.insert(0, models_path)
+from ft_transformer import FTTransformer
+from resnet_like import ResNetLike
+from deepgbm import DeepGBM
+import warnings
+warnings.filterwarnings('ignore')
+
+# Python 및 Numpy 시드 고정
+seed = 42
+random.seed(seed)
+np.random.seed(seed)
+
+# PyTorch 시드 고정
+torch.manual_seed(seed)
+torch.cuda.manual_seed(seed)
+torch.cuda.manual_seed_all(seed)  # Multi-GPU 환경에서 동일한 시드 적용
+
+# PyTorch 연산의 결정적 모드 설정
+torch.backends.cudnn.deterministic = True  # 실행마다 동일한 결과를 보장
+torch.backends.cudnn.benchmark = True  # 성능 최적화를 활성화 (가능한 한 빠른 연산 수행)
+
+
+def add_derived_features(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    제거했던 파생 변수들을 복구
+    
+    Args:
+        df: 데이터프레임
+    
+    Returns:
+        파생 변수가 추가된 데이터프레임
+    """
+    df = df.copy()
+    df['hour_sin'] = np.sin(2 * np.pi * df['hour'] / 24)
+    df['hour_cos'] = np.cos(2 * np.pi * df['hour'] / 24)
+    df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
+    df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
+    df['ground_temp - temp_C'] = df['groundtemp'] - df['temp_C']
+    return df
+
+def preprocessing(df):
+    """데이터 전처리 함수.
+    
+    Args:
+        df: 원본 데이터프레임
+        
+    Returns:
+        전처리된 데이터프레임
+    """
+    df = df[df.columns].copy()
+    df['year'] = df['year'].astype('int')
+    df['month'] = df['month'].astype('int')
+    df['hour'] = df['hour'].astype('int')
+    df = add_derived_features(df).copy()
+    df['multi_class'] = df['multi_class'].astype('int')
+    df.loc[df['wind_dir']=='정온', 'wind_dir'] = "0"
+    df['wind_dir'] = df['wind_dir'].astype('int')
+    df = df[['temp_C', 'precip_mm', 'wind_speed', 'wind_dir', 'hm',
+       'vap_pressure', 'dewpoint_C', 'loc_pressure', 'sea_pressure',
+       'solarRad', 'snow_cm', 'cloudcover', 'lm_cloudcover', 'low_cloudbase',
+       'groundtemp', 'O3', 'NO2', 'PM10', 'PM25', 'year',
+       'month', 'hour', 'ground_temp - temp_C', 'hour_sin', 'hour_cos',
+       'month_sin', 'month_cos','multi_class']].copy()
+    return df
+
+
+# 데이터셋 준비 함수
+def prepare_dataset(region, data_sample='pure', target='multi', fold=3):
+
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    return X_train, X_val, X_test, y_train, y_val, y_test, categorical_cols, numerical_cols
+
+
+
+# 데이터 변환 및 dataloader 생성 함수
+def prepare_dataloader(region, data_sample='pure', target='multi', fold=3, random_state=None):
+
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    # 연속형 변수와 범주형 변수 분리
+    X_train_num = torch.tensor(X_train[numerical_cols].values, dtype=torch.float32)
+    X_train_cat = torch.tensor(X_train[categorical_cols].values, dtype=torch.long)
+
+    X_val_num = torch.tensor(X_val[numerical_cols].values, dtype=torch.float32)
+    X_val_cat = torch.tensor(X_val[categorical_cols].values, dtype=torch.long)
+
+    X_test_num = torch.tensor(X_test[numerical_cols].values, dtype=torch.float32)
+    X_test_cat = torch.tensor(X_test[categorical_cols].values, dtype=torch.long)
+
+    # 레이블 변환
+    if target == "binary":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32)  # 이진 분류 → float32
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.float32)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32)
+    elif target == "multi":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)  # 다중 분류 → long
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.long)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.long)
+    else:
+        raise ValueError("target must be 'binary' or 'multi'")
+
+    # TensorDataset 생성
+    train_dataset = TensorDataset(X_train_num, X_train_cat, y_train_tensor)
+    val_dataset = TensorDataset(X_val_num, X_val_cat, y_val_tensor)
+    test_dataset = TensorDataset(X_test_num, X_test_cat, y_test_tensor)
+
+    # DataLoader 생성
+    if random_state == None:
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, generator=torch.Generator().manual_seed(random_state))
+    val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
+    
+    return X_train, categorical_cols, numerical_cols, train_loader, val_loader, test_loader
+
+# 데이터 변환 및 dataloader 생성 함수 (batch_size 파라미터 추가 버전)
+def prepare_dataloader_with_batchsize(region, data_sample='pure', target='multi', fold=3, random_state=None, batch_size=64):
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    # 연속형 변수와 범주형 변수 분리
+    X_train_num = torch.tensor(X_train[numerical_cols].values, dtype=torch.float32)
+    X_train_cat = torch.tensor(X_train[categorical_cols].values, dtype=torch.long)
+
+    X_val_num = torch.tensor(X_val[numerical_cols].values, dtype=torch.float32)
+    X_val_cat = torch.tensor(X_val[categorical_cols].values, dtype=torch.long)
+
+    X_test_num = torch.tensor(X_test[numerical_cols].values, dtype=torch.float32)
+    X_test_cat = torch.tensor(X_test[categorical_cols].values, dtype=torch.long)
+
+    # 레이블 변환
+    if target == "binary":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32)  # 이진 분류 → float32
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.float32)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32)
+    elif target == "multi":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)  # 다중 분류 → long
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.long)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.long)
+    else:
+        raise ValueError("target must be 'binary' or 'multi'")
+
+    # TensorDataset 생성
+    train_dataset = TensorDataset(X_train_num, X_train_cat, y_train_tensor)
+    val_dataset = TensorDataset(X_val_num, X_val_cat, y_val_tensor)
+    test_dataset = TensorDataset(X_test_num, X_test_cat, y_test_tensor)
+
+    # DataLoader 생성 (batch_size 파라미터 사용)
+    if random_state == None:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, generator=torch.Generator().manual_seed(random_state))
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+    
+    return X_train, categorical_cols, numerical_cols, train_loader, val_loader, test_loader, y_train, scaler
+
+
+def calculate_csi(y_true, pred):
+
+    cm = confusion_matrix(y_true, pred)  # 변수 이름을 cm으로 변경
+    # 혼동 행렬에서 H, F, M 추출
+    H = (cm[0, 0] + cm[1, 1])
+    
+    F = (cm[1, 0] + cm[2, 0] +
+         cm[0, 1] + cm[2, 1])
+    
+    M = (cm[0, 2] + cm[1, 2])
+    
+    # CSI 계산
+    CSI = H / (H + F + M + 1e-10)
+    return CSI
+
+def sample_weight(y_train):
+    class_weights = compute_class_weight(
+        class_weight='balanced',
+        classes=np.unique(y_train),  # 고유 클래스
+        y=y_train                   # 학습 데이터 레이블
+    )
+    sample_weights = np.array([class_weights[label] for label in y_train])
+
+    return sample_weights
+
+# 하이퍼파라미터 최적화 함수 정의
+def objective(trial, model_choose, region, data_sample='pure', target='multi', n_folds=3, random_state=42):
+    # GPU 사용 가능 여부 확인 및 device 설정
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    val_scores = []
+
+    # --- 1. 하이퍼파라미터 탐색 범위 정의 (수정됨) ---
+    if model_choose == "ft_transformer":
+        d_token = trial.suggest_int("d_token", 64, 256, step=32)
+        n_blocks = trial.suggest_int("n_blocks", 2, 6) # 깊이 축소로 과적합 방지
+        n_heads = trial.suggest_categorical("n_heads", [4, 8])
+        # d_token은 n_heads의 배수여야 함 (FT-Transformer의 구조적 제약 대응)
+        if d_token % n_heads != 0:
+            d_token = (d_token // n_heads) * n_heads
+            
+        attention_dropout = trial.suggest_float("attention_dropout", 0.1, 0.4)
+        ffn_dropout = trial.suggest_float("ffn_dropout", 0.1, 0.4)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True) # 범위 확대
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    elif model_choose == 'resnet_like':
+        d_main = trial.suggest_int("d_main", 64, 256, step=32)
+        d_hidden = trial.suggest_int("d_hidden", 64, 512, step=64)
+        n_blocks = trial.suggest_int("n_blocks", 2, 5) # 너무 깊지 않게 조절
+        dropout_first = trial.suggest_float("dropout_first", 0.1, 0.4)
+        dropout_second = trial.suggest_float("dropout_second", 0.0, 0.2)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    elif model_choose == 'deepgbm':
+        # DeepGBM의 경우 모델 특성에 맞춰 ResNet 블록 및 임베딩 차원 조절
+        d_main = trial.suggest_int("d_main", 64, 256, step=32)
+        d_hidden = trial.suggest_int("d_hidden", 64, 256, step=64)
+        n_blocks = trial.suggest_int("n_blocks", 2, 6)
+        dropout = trial.suggest_float("dropout", 0.1, 0.4)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    # --- 2. Fold별 학습 및 교차 검증 ---
+    for fold in range(1, n_folds + 1):
+        X_train_df, categorical_cols, numerical_cols, train_loader, val_loader, _, y_train, _ = prepare_dataloader_with_batchsize(
+            region, data_sample=data_sample, target=target, fold=fold, random_state=random_state, batch_size=batch_size
+        )
+
+        # 모델 초기화
+        if model_choose == "ft_transformer":
+            model = FTTransformer(
+                num_features=len(numerical_cols),
+                cat_cardinalities=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_token=d_token,
+                n_blocks=n_blocks,
+                n_heads=n_heads,
+                attention_dropout=attention_dropout,
+                ffn_dropout=ffn_dropout,
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'resnet_like':
+            input_dim = len(numerical_cols) + len(categorical_cols)
+            model = ResNetLike(
+                input_dim=input_dim,
+                d_main=d_main, 
+                d_hidden=d_hidden, 
+                n_blocks=n_blocks, 
+                dropout_first=dropout_first, 
+                dropout_second=dropout_second,
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'deepgbm':
+            model = DeepGBM(
+                num_features=len(numerical_cols),
+                cat_features=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_main=d_main,
+                d_hidden=d_hidden,
+                n_blocks=n_blocks,
+                dropout=dropout,
+                num_classes=3
+            ).to(device)
+
+        # 클래스 가중치 계산 및 손실 함수 설정 (Label Smoothing 적용)
+        if target == 'multi':
+            class_weights = compute_class_weight(
+                class_weight='balanced',
+                classes=np.unique(y_train),
+                y=y_train
+            )
+            # 클래스별 가중치 로그 출력
+            unique_classes = np.unique(y_train)
+            class_counts = {cls: np.sum(y_train == cls) for cls in unique_classes}
+            print(f"  Fold {fold} - 클래스별 가중치: {dict(zip(unique_classes, class_weights))} (클래스별 샘플 수: {class_counts})")
+            class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
+            criterion = nn.CrossEntropyLoss(weight=class_weights_tensor, label_smoothing=0.0)  # Label Smoothing 추가
+        else:
+            criterion = nn.BCEWithLogitsLoss()
+        optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
+        
+        # 학습률 스케줄러 추가: 성능 정체 시 LR을 0.5배 감소 (검증 CSI 기준)
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+
+        # 학습 설정 (에폭 및 페이션스 상향)
+        epochs = 200 
+        patience = 12 # 딥러닝의 정체 구간을 고려하여 소폭 상향
+        best_fold_csi = 0
+        counter = 0
+
+        for epoch in range(epochs):
+            model.train()
+            for x_num_batch, x_cat_batch, y_batch in train_loader:
+                x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                
+                optimizer.zero_grad()
+                y_pred = model(x_num_batch, x_cat_batch)
+                loss = criterion(y_pred, y_batch if target == 'multi' else y_batch.float())
+                loss.backward()
+                optimizer.step()
+
+            # Validation 평가
+            model.eval()
+            y_pred_val, y_true_val = [], []
+            with torch.no_grad():
+                for x_num_batch, x_cat_batch, y_batch in val_loader:
+                    x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                    output = model(x_num_batch, x_cat_batch)
+                    pred = output.argmax(dim=1) if target == 'multi' else (torch.sigmoid(output) >= 0.5).long()
+                    
+                    y_pred_val.extend(pred.cpu().numpy())
+                    y_true_val.extend(y_batch.cpu().numpy())
+
+            # CSI 계산 및 스케줄러 업데이트
+            val_csi = calculate_csi(y_true_val, y_pred_val)
+            scheduler.step(val_csi)
+
+            # Optuna Pruning 적용 (첫 번째 Fold에서 조기 종료 판단 강화)
+            trial.report(val_csi, epoch)
+            if trial.should_prune():
+                raise optuna.exceptions.TrialPruned()
+
+            # Early Stopping 체크
+            if val_csi > best_fold_csi:
+                best_fold_csi = val_csi
+                counter = 0
+            else:
+                counter += 1
+
+            if counter >= patience:
+                break
+
+        val_scores.append(best_fold_csi)
+
+    # 모든 fold의 평균 성능 반환
+    return np.mean(val_scores)
+
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습 및 저장 함수
+def train_final_model(best_params, model_choose, region, data_sample='pure', target='multi', n_folds=3, random_state=42):
+    """
+    최적화된 하이퍼파라미터로 최종 모델을 학습하고 저장합니다.
+    
+    Args:
+        best_params: 최적화된 하이퍼파라미터 딕셔너리
+        model_choose: 모델 선택 ('ft_transformer', 'resnet_like', 'deepgbm')
+        region: 지역명
+        data_sample: 데이터 샘플 타입 ('pure', 'smote', etc.)
+        target: 타겟 타입 ('multi', 'binary')
+        n_folds: 교차 검증 fold 수
+        random_state: 랜덤 시드
+    
+    Returns:
+        저장된 모델 경로 리스트
+    """
+    # GPU 사용 가능 여부 확인 및 device 설정
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    models = []
+    scalers = []  # scaler 리스트 추가
+    
+    print("최종 모델 학습 시작...")
+    
+    for fold in range(1, n_folds + 1):
+        print(f"Fold {fold} 학습 중...")
+        
+        # 최적화된 batch_size 사용
+        batch_size = best_params.get("batch_size", 64)
+        X_train_df, categorical_cols, numerical_cols, train_loader, val_loader, _, y_train, scaler = prepare_dataloader_with_batchsize(
+            region, data_sample=data_sample, target=target, fold=fold, random_state=random_state, batch_size=batch_size
+        )
+        
+        # 모델 초기화
+        if model_choose == "ft_transformer":
+            d_token = best_params["d_token"]
+            n_heads = best_params.get("n_heads", 8)
+            # d_token은 n_heads의 배수여야 함 (FT-Transformer의 구조적 제약 대응)
+            if d_token % n_heads != 0:
+                d_token = (d_token // n_heads) * n_heads
+            
+            model = FTTransformer(
+                num_features=len(numerical_cols),
+                cat_cardinalities=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_token=d_token,
+                n_blocks=best_params["n_blocks"],
+                n_heads=n_heads,
+                attention_dropout=best_params["attention_dropout"],
+                ffn_dropout=best_params["ffn_dropout"],
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'resnet_like':
+            input_dim = len(numerical_cols) + len(categorical_cols)
+            model = ResNetLike(
+                input_dim=input_dim,
+                d_main=best_params["d_main"],
+                d_hidden=best_params["d_hidden"],
+                n_blocks=best_params["n_blocks"],
+                dropout_first=best_params["dropout_first"],
+                dropout_second=best_params["dropout_second"],
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'deepgbm':
+            model = DeepGBM(
+                num_features=len(numerical_cols),
+                cat_features=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_main=best_params["d_main"],
+                d_hidden=best_params["d_hidden"],
+                n_blocks=best_params["n_blocks"],
+                dropout=best_params["dropout"],
+                num_classes=3
+            ).to(device)
+        else:
+            raise ValueError(f"Unknown model_choose: {model_choose}")
+        
+        # 클래스 가중치 계산 및 손실 함수 설정 (Label Smoothing 적용)
+        if target == 'multi':
+            class_weights = compute_class_weight(
+                class_weight='balanced',
+                classes=np.unique(y_train),
+                y=y_train
+            )
+            class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
+            criterion = nn.CrossEntropyLoss(weight=class_weights_tensor, label_smoothing=0.0)  # Label Smoothing 추가
+        else:
+            criterion = nn.BCEWithLogitsLoss()
+        optimizer = optim.AdamW(model.parameters(), lr=best_params["lr"], weight_decay=best_params["weight_decay"])
+        
+        # 학습률 스케줄러
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+        
+        # 학습 설정
+        epochs = 200
+        patience = 12
+        best_fold_csi = 0
+        counter = 0
+        best_model = None
+        
+        for epoch in range(epochs):
+            model.train()
+            for x_num_batch, x_cat_batch, y_batch in train_loader:
+                x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                
+                optimizer.zero_grad()
+                y_pred = model(x_num_batch, x_cat_batch)
+                loss = criterion(y_pred, y_batch if target == 'multi' else y_batch.float())
+                loss.backward()
+                optimizer.step()
+            
+            # Validation 평가
+            model.eval()
+            y_pred_val, y_true_val = [], []
+            with torch.no_grad():
+                for x_num_batch, x_cat_batch, y_batch in val_loader:
+                    x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                    output = model(x_num_batch, x_cat_batch)
+                    pred = output.argmax(dim=1) if target == 'multi' else (torch.sigmoid(output) >= 0.5).long()
+                    
+                    y_pred_val.extend(pred.cpu().numpy())
+                    y_true_val.extend(y_batch.cpu().numpy())
+            
+            # CSI 계산 및 스케줄러 업데이트
+            val_csi = calculate_csi(y_true_val, y_pred_val)
+            scheduler.step(val_csi)
+            
+            # Early Stopping 체크
+            if val_csi > best_fold_csi:
+                best_fold_csi = val_csi
+                counter = 0
+                best_model = copy.deepcopy(model)
+            else:
+                counter += 1
+            
+            if counter >= patience:
+                print(f"  Early stopping at epoch {epoch+1}, Best CSI: {best_fold_csi:.4f}")
+                break
+        
+        if best_model is None:
+            best_model = model
+        
+        scalers.append(scaler)  # scaler 저장 (fold 순서대로)
+        models.append(best_model)
+        print(f"  Fold {fold} 학습 완료 (검증 CSI: {best_fold_csi:.4f})")
+    
+    # 모델 저장 경로 설정
+    save_dir = f'../save_model/{model_choose}_optima'
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 파일명 생성
+    if data_sample == 'pure':
+        model_filename = f'{model_choose}_pure_{region}.pkl'
+    else:
+        model_filename = f'{model_choose}_{data_sample}_{region}.pkl'
+    
+    model_path = f'{save_dir}/{model_filename}'
+    
+    # 리스트에 담아 한 번에 저장
+    joblib.dump(models, model_path)
+    print(f"\n모든 모델 저장 완료: {model_path} (총 {len(models)}개 fold)")
+    
+    # Scaler 별도 저장
+    scaler_save_dir = f'../save_model/{model_choose}_optima/scaler'
+    os.makedirs(scaler_save_dir, exist_ok=True)
+    
+    # 파일명 생성 (모델과 동일한 패턴)
+    if data_sample == 'pure':
+        scaler_filename = f'{model_choose}_pure_{region}_scaler.pkl'
+    else:
+        scaler_filename = f'{model_choose}_{data_sample}_{region}_scaler.pkl'
+    
+    scaler_path = f'{scaler_save_dir}/{scaler_filename}'
+    joblib.dump(scalers, scaler_path)
+    print(f"Scaler 저장 완료: {scaler_path} (총 {len(scalers)}개 fold)")
+    
+    return model_path
+

Analysis_code/5.optima/resnet_like_ctgan10000/resnet_like_ctgan10000_busan.py

@@ -0,0 +1,98 @@
+import optuna
+import numpy as np
+import random
+import pandas as pd
+import joblib
+import os
+import torch
+from utils import *
+# Python 및 Numpy 시드 고정
+seed = 42
+random.seed(seed)
+np.random.seed(seed)
+
+
+# 1. Study 생성 시 'maximize'로 설정
+study = optuna.create_study(
+    direction="maximize",  # CSI 점수가 높을수록 좋으므로 maximize
+    pruner=optuna.pruners.MedianPruner(n_warmup_steps=10) # 초반 10에폭은 지켜보고 이후 가지치기
+)
+# Trial 완료 시 상세 정보 출력하는 callback 함수
+def print_trial_callback(study, trial):
+    """각 trial 완료 시 best value를 포함한 상세 정보 출력"""
+    print(f"\n{'='*80}")
+    print(f"Trial {trial.number} 완료")
+    print(f"  Value (CSI): {trial.value:.6f}" if trial.value is not None else f"  Value: {trial.value}")
+    print(f"  Parameters: {trial.params}")
+    print(f"  Best Value (CSI): {study.best_value:.6f}" if study.best_value is not None else f"  Best Value: {study.best_value}")
+    print(f"  Best Trial: {study.best_trial.number}")
+    print(f"  Best Parameters: {study.best_params}")
+    print(f"{'='*80}\n")
+
+
+
+# 2. 최적화 실행
+study.optimize(
+    lambda trial: objective(trial, model_choose="resnet_like", region="busan", data_sample='ctgan10000'), 
+    n_trials=100
+,
+    callbacks=[print_trial_callback]
+)
+
+# 3. 결과 확인 및 요약
+print(f"\n최적화 완료.")
+print(f"Best CSI Score: {study.best_value:.4f}")
+print(f"Best Hyperparameters: {study.best_params}")
+
+try:
+    # 모든 trial의 CSI 점수 추출
+    csi_scores = [trial.value for trial in study.trials if trial.value is not None]
+    
+    if len(csi_scores) > 0:
+        print(f"\n최적화 과정 요약:")
+        print(f"  - 총 시도 횟수: {len(study.trials)}")
+        print(f"  - 성공한 시도: {len(csi_scores)}")
+        print(f"  - 최초 CSI: {csi_scores[0]:.4f}")
+        print(f"  - 최종 CSI: {csi_scores[-1]:.4f}")
+        print(f"  - 최고 CSI: {max(csi_scores):.4f}")
+        print(f"  - 최저 CSI: {min(csi_scores):.4f}")
+        print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
+    
+    # Study 객체 저장
+    # 파일 위치 기반으로 base 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
+    os.makedirs(os.path.join(base_dir, "optimization_history"), exist_ok=True)
+    study_path = os.path.join(base_dir, "optimization_history/resnet_like_ctgan10000_busan_trials.pkl")
+    joblib.dump(study, study_path)
+    print(f"\n최적화 Study 객체가 {study_path}에 저장되었습니다.")
+    
+    # 최적화된 하이퍼파라미터로 최종 모델 학습 및 저장
+    print("\n" + "="*50)
+    print("최적화된 하이퍼파라미터로 최종 모델 학습 시작")
+    print("="*50)
+    
+    best_params = study.best_params
+    model_path = train_final_model(
+        best_params=best_params,
+        model_choose="resnet_like",
+        region="busan",
+        data_sample='ctgan10000',
+        target='multi',
+        n_folds=3,
+        random_state=seed
+    )
+    
+    print(f"\n최종 모델 학습 및 저장 완료!")
+    print(f"저장된 모델 경로: {model_path}")
+        
+except Exception as e:
+    print(f"\n⚠️  최적화 결과 분석 중 오류 발생: {e}")
+    import traceback
+    traceback.print_exc()
+
+# 정상 종료
+import sys
+sys.exit(0)
+
+

Analysis_code/5.optima/resnet_like_ctgan10000/utils.py

@@ -0,0 +1,719 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import random
+import os
+import copy
+from sklearn.preprocessing import QuantileTransformer, LabelEncoder
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.metrics import confusion_matrix
+from sklearn.utils.class_weight import compute_class_weight
+import pandas as pd
+import optuna
+from sklearn.metrics import accuracy_score, f1_score
+import joblib
+
+
+import sys
+# 파일 위치 기반으로 models 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+models_path = os.path.abspath(os.path.join(current_file_dir, '../../models'))
+sys.path.insert(0, models_path)
+from ft_transformer import FTTransformer
+from resnet_like import ResNetLike
+from deepgbm import DeepGBM
+import warnings
+warnings.filterwarnings('ignore')
+
+
+# Python 및 Numpy 시드 고정
+seed = 42
+random.seed(seed)
+np.random.seed(seed)
+
+# PyTorch 시드 고정
+torch.manual_seed(seed)
+torch.cuda.manual_seed(seed)
+torch.cuda.manual_seed_all(seed)  # Multi-GPU 환경에서 동일한 시드 적용
+
+# PyTorch 연산의 결정적 모드 설정
+torch.backends.cudnn.deterministic = True  # 실행마다 동일한 결과를 보장
+torch.backends.cudnn.benchmark = True  # 성능 최적화를 활성화 (가능한 한 빠른 연산 수행)
+
+
+def add_derived_features(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    제거했던 파생 변수들을 복구
+    
+    Args:
+        df: 데이터프레임
+    
+    Returns:
+        파생 변수가 추가된 데이터프레임
+    """
+    df = df.copy()
+    df['hour_sin'] = np.sin(2 * np.pi * df['hour'] / 24)
+    df['hour_cos'] = np.cos(2 * np.pi * df['hour'] / 24)
+    df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
+    df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
+    df['ground_temp - temp_C'] = df['groundtemp'] - df['temp_C']
+    return df
+
+def preprocessing(df):
+    """데이터 전처리 함수.
+    
+    Args:
+        df: 원본 데이터프레임
+        
+    Returns:
+        전처리된 데이터프레임
+    """
+    df = df[df.columns].copy()
+    df['year'] = df['year'].astype('int')
+    df['month'] = df['month'].astype('int')
+    df['hour'] = df['hour'].astype('int')
+    df = add_derived_features(df).copy()
+    df['multi_class'] = df['multi_class'].astype('int')
+    df.loc[df['wind_dir']=='정온', 'wind_dir'] = "0"
+    df['wind_dir'] = df['wind_dir'].astype('int')
+    df = df[['temp_C', 'precip_mm', 'wind_speed', 'wind_dir', 'hm',
+       'vap_pressure', 'dewpoint_C', 'loc_pressure', 'sea_pressure',
+       'solarRad', 'snow_cm', 'cloudcover', 'lm_cloudcover', 'low_cloudbase',
+       'groundtemp', 'O3', 'NO2', 'PM10', 'PM25', 'year',
+       'month', 'hour', 'ground_temp - temp_C', 'hour_sin', 'hour_cos',
+       'month_sin', 'month_cos','multi_class']].copy()
+    return df
+
+
+# 데이터셋 준비 함수
+def prepare_dataset(region, data_sample='pure', target='multi', fold=3):
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    return X_train, X_val, X_test, y_train, y_val, y_test, categorical_cols, numerical_cols
+
+
+
+# 데이터 변환 및 dataloader 생성 함수
+def prepare_dataloader(region, data_sample='pure', target='multi', fold=3, random_state=None):
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    # 연속형 변수와 범주형 변수 분리
+    X_train_num = torch.tensor(X_train[numerical_cols].values, dtype=torch.float32)
+    X_train_cat = torch.tensor(X_train[categorical_cols].values, dtype=torch.long)
+
+    X_val_num = torch.tensor(X_val[numerical_cols].values, dtype=torch.float32)
+    X_val_cat = torch.tensor(X_val[categorical_cols].values, dtype=torch.long)
+
+    X_test_num = torch.tensor(X_test[numerical_cols].values, dtype=torch.float32)
+    X_test_cat = torch.tensor(X_test[categorical_cols].values, dtype=torch.long)
+
+    # 레이블 변환
+    if target == "binary":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32)  # 이진 분류 → float32
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.float32)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32)
+    elif target == "multi":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)  # 다중 분류 → long
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.long)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.long)
+    else:
+        raise ValueError("target must be 'binary' or 'multi'")
+
+    # TensorDataset 생성
+    train_dataset = TensorDataset(X_train_num, X_train_cat, y_train_tensor)
+    val_dataset = TensorDataset(X_val_num, X_val_cat, y_val_tensor)
+    test_dataset = TensorDataset(X_test_num, X_test_cat, y_test_tensor)
+
+    # DataLoader 생성
+    if random_state == None:
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, generator=torch.Generator().manual_seed(random_state))
+    val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
+    
+    return X_train, categorical_cols, numerical_cols, train_loader, val_loader, test_loader
+
+# 데이터 변환 및 dataloader 생성 함수 (batch_size 파라미터 추가 버전)
+def prepare_dataloader_with_batchsize(region, data_sample='pure', target='multi', fold=3, random_state=None, batch_size=64):
+    # 파일 위치 기반으로 데이터 디렉토리 경로 설정
+    current_file_dir = os.path.dirname(os.path.abspath(__file__))
+    data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+    
+    # 데이터 경로 지정
+    dat_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_train.csv")
+    if data_sample == 'pure':
+        train_path = dat_path
+    else:
+        train_path = os.path.join(data_base_dir, f'data_oversampled/{data_sample}/{data_sample}_{fold}_{region}.csv')
+    test_path = os.path.join(data_base_dir, f"data_for_modeling/{region}_test.csv")
+    drop_col = ['multi_class','year']
+    target_col = f'{target}_class'
+    
+    # 데이터 로드
+    region_dat = preprocessing(pd.read_csv(dat_path, index_col=0))
+    if data_sample == 'pure':
+        region_train = region_dat.loc[~region_dat['year'].isin([2021-fold]), :]
+    else:
+        region_train = preprocessing(pd.read_csv(train_path))
+    region_val = region_dat.loc[region_dat['year'].isin([2021-fold]), :]
+    region_test = preprocessing(pd.read_csv(test_path))
+
+    # 컬럼 정렬 (일관성 유지)
+    common_columns = region_train.columns.to_list()
+    train_data = region_train[common_columns]
+    val_data = region_val[common_columns]
+    test_data = region_test[common_columns]
+
+    # 설명변수 & 타겟 분리
+    X_train = train_data.drop(columns=drop_col)
+    y_train = train_data[target_col]
+    X_val = val_data.drop(columns=drop_col)
+    y_val = val_data[target_col]
+    X_test = test_data.drop(columns=drop_col)
+    y_test = test_data[target_col]
+
+    # 범주형 & 연속형 변수 분리
+    categorical_cols = X_train.select_dtypes(include=['object', 'category', 'int64']).columns
+    numerical_cols = X_train.select_dtypes(include=['float64']).columns
+
+    # 범주형 변수 Label Encoding
+    label_encoders = {}
+    for col in categorical_cols:
+        le = LabelEncoder()
+        le.fit(X_train[col])  # Train 데이터 기준으로 학습
+        label_encoders[col] = le
+
+    # 변환 적용
+    for col in categorical_cols:
+        X_train[col] = label_encoders[col].transform(X_train[col])
+        X_val[col] = label_encoders[col].transform(X_val[col])
+        X_test[col] = label_encoders[col].transform(X_test[col])
+
+    # 연속형 변수 Quantile Transformation
+    scaler = QuantileTransformer(output_distribution='normal')
+    scaler.fit(X_train[numerical_cols])  # Train 데이터 기준으로 학습
+
+    # 변환 적용
+    X_train[numerical_cols] = scaler.transform(X_train[numerical_cols])
+    X_val[numerical_cols] = scaler.transform(X_val[numerical_cols])
+    X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])
+
+    # 연속형 변수와 범주형 변수 분리
+    X_train_num = torch.tensor(X_train[numerical_cols].values, dtype=torch.float32)
+    X_train_cat = torch.tensor(X_train[categorical_cols].values, dtype=torch.long)
+
+    X_val_num = torch.tensor(X_val[numerical_cols].values, dtype=torch.float32)
+    X_val_cat = torch.tensor(X_val[categorical_cols].values, dtype=torch.long)
+
+    X_test_num = torch.tensor(X_test[numerical_cols].values, dtype=torch.float32)
+    X_test_cat = torch.tensor(X_test[categorical_cols].values, dtype=torch.long)
+
+    # 레이블 변환
+    if target == "binary":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32)  # 이진 분류 → float32
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.float32)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32)
+    elif target == "multi":
+        y_train_tensor = torch.tensor(y_train.values, dtype=torch.long)  # 다중 분류 → long
+        y_val_tensor = torch.tensor(y_val.values, dtype=torch.long)
+        y_test_tensor = torch.tensor(y_test.values, dtype=torch.long)
+    else:
+        raise ValueError("target must be 'binary' or 'multi'")
+
+    # TensorDataset 생성
+    train_dataset = TensorDataset(X_train_num, X_train_cat, y_train_tensor)
+    val_dataset = TensorDataset(X_val_num, X_val_cat, y_val_tensor)
+    test_dataset = TensorDataset(X_test_num, X_test_cat, y_test_tensor)
+
+    # DataLoader 생성 (batch_size 파라미터 사용)
+    if random_state == None:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, generator=torch.Generator().manual_seed(random_state))
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+    
+    return X_train, categorical_cols, numerical_cols, train_loader, val_loader, test_loader, y_train, scaler
+
+
+def calculate_csi(y_true, pred):
+
+    cm = confusion_matrix(y_true, pred)  # 변수 이름을 cm으로 변경
+    # 혼동 행렬에서 H, F, M 추출
+    H = (cm[0, 0] + cm[1, 1])
+    
+    F = (cm[1, 0] + cm[2, 0] +
+         cm[0, 1] + cm[2, 1])
+    
+    M = (cm[0, 2] + cm[1, 2])
+    
+    # CSI 계산
+    CSI = H / (H + F + M + 1e-10)
+    return CSI
+
+def sample_weight(y_train):
+    class_weights = compute_class_weight(
+        class_weight='balanced',
+        classes=np.unique(y_train),  # 고유 클래스
+        y=y_train                   # 학습 데이터 레이블
+    )
+    sample_weights = np.array([class_weights[label] for label in y_train])
+
+    return sample_weights
+
+# 하이퍼파라미터 최적화 함수 정의
+def objective(trial, model_choose, region, data_sample='pure', target='multi', n_folds=3, random_state=42):
+    # GPU 사용 가능 여부 확인 및 device 설정
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    val_scores = []
+
+    # --- 1. 하이퍼파라미터 탐색 범위 정의 (수정됨) ---
+    if model_choose == "ft_transformer":
+        d_token = trial.suggest_int("d_token", 64, 256, step=32)
+        n_blocks = trial.suggest_int("n_blocks", 2, 6) # 깊이 축소로 과적합 방지
+        n_heads = trial.suggest_categorical("n_heads", [4, 8])
+        # d_token은 n_heads의 배수여야 함 (FT-Transformer의 구조적 제약 대응)
+        if d_token % n_heads != 0:
+            d_token = (d_token // n_heads) * n_heads
+            
+        attention_dropout = trial.suggest_float("attention_dropout", 0.1, 0.4)
+        ffn_dropout = trial.suggest_float("ffn_dropout", 0.1, 0.4)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True) # 범위 확대
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    elif model_choose == 'resnet_like':
+        d_main = trial.suggest_int("d_main", 64, 256, step=32)
+        d_hidden = trial.suggest_int("d_hidden", 64, 512, step=64)
+        n_blocks = trial.suggest_int("n_blocks", 2, 5) # 너무 깊지 않게 조절
+        dropout_first = trial.suggest_float("dropout_first", 0.1, 0.4)
+        dropout_second = trial.suggest_float("dropout_second", 0.0, 0.2)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    elif model_choose == 'deepgbm':
+        # DeepGBM의 경우 모델 특성에 맞춰 ResNet 블록 및 임베딩 차원 조절
+        d_main = trial.suggest_int("d_main", 64, 256, step=32)
+        d_hidden = trial.suggest_int("d_hidden", 64, 256, step=64)
+        n_blocks = trial.suggest_int("n_blocks", 2, 6)
+        dropout = trial.suggest_float("dropout", 0.1, 0.4)
+        lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+        weight_decay = trial.suggest_float("weight_decay", 1e-4, 1e-1, log=True)  # 더 공격적인 범위로 확장
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])  # Batch Size 추가
+
+    # --- 2. Fold별 학습 및 교차 검증 ---
+    for fold in range(1, n_folds + 1):
+        X_train_df, categorical_cols, numerical_cols, train_loader, val_loader, _, y_train, _ = prepare_dataloader_with_batchsize(
+            region, data_sample=data_sample, target=target, fold=fold, random_state=random_state, batch_size=batch_size
+        )
+
+        # 모델 초기화
+        if model_choose == "ft_transformer":
+            model = FTTransformer(
+                num_features=len(numerical_cols),
+                cat_cardinalities=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_token=d_token,
+                n_blocks=n_blocks,
+                n_heads=n_heads,
+                attention_dropout=attention_dropout,
+                ffn_dropout=ffn_dropout,
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'resnet_like':
+            input_dim = len(numerical_cols) + len(categorical_cols)
+            model = ResNetLike(
+                input_dim=input_dim,
+                d_main=d_main, 
+                d_hidden=d_hidden, 
+                n_blocks=n_blocks, 
+                dropout_first=dropout_first, 
+                dropout_second=dropout_second,
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'deepgbm':
+            model = DeepGBM(
+                num_features=len(numerical_cols),
+                cat_features=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_main=d_main,
+                d_hidden=d_hidden,
+                n_blocks=n_blocks,
+                dropout=dropout,
+                num_classes=3
+            ).to(device)
+
+        # 클래스 가중치 계산 및 손실 함수 설정 (Label Smoothing 적용)
+        if target == 'multi':
+            class_weights = compute_class_weight(
+                class_weight='balanced',
+                classes=np.unique(y_train),
+                y=y_train
+            )
+            # 클래스별 가중치 로그 출력
+            unique_classes = np.unique(y_train)
+            class_counts = {cls: np.sum(y_train == cls) for cls in unique_classes}
+            print(f"  Fold {fold} - 클래스별 가중치: {dict(zip(unique_classes, class_weights))} (클래스별 샘플 수: {class_counts})")
+            class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
+            criterion = nn.CrossEntropyLoss(weight=class_weights_tensor, label_smoothing=0.0)  # Label Smoothing 추가
+        else:
+            criterion = nn.BCEWithLogitsLoss()
+        optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
+        
+        # 학습률 스케줄러 추가: 성능 정체 시 LR을 0.5배 감소 (검증 CSI 기준)
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+
+        # 학습 설정 (에폭 및 페이션스 상향)
+        epochs = 200 
+        patience = 12 # 딥러닝의 정체 구간을 고려하여 소폭 상향
+        best_fold_csi = 0
+        counter = 0
+
+        for epoch in range(epochs):
+            model.train()
+            for x_num_batch, x_cat_batch, y_batch in train_loader:
+                x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                
+                optimizer.zero_grad()
+                y_pred = model(x_num_batch, x_cat_batch)
+                loss = criterion(y_pred, y_batch if target == 'multi' else y_batch.float())
+                loss.backward()
+                optimizer.step()
+
+            # Validation 평가
+            model.eval()
+            y_pred_val, y_true_val = [], []
+            with torch.no_grad():
+                for x_num_batch, x_cat_batch, y_batch in val_loader:
+                    x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                    output = model(x_num_batch, x_cat_batch)
+                    pred = output.argmax(dim=1) if target == 'multi' else (torch.sigmoid(output) >= 0.5).long()
+                    
+                    y_pred_val.extend(pred.cpu().numpy())
+                    y_true_val.extend(y_batch.cpu().numpy())
+
+            # CSI 계산 및 스케줄러 업데이트
+            val_csi = calculate_csi(y_true_val, y_pred_val)
+            scheduler.step(val_csi)
+
+            # Optuna Pruning 적용 (첫 번째 Fold에서 조기 종료 판단 강화)
+            trial.report(val_csi, epoch)
+            if trial.should_prune():
+                raise optuna.exceptions.TrialPruned()
+
+            # Early Stopping 체크
+            if val_csi > best_fold_csi:
+                best_fold_csi = val_csi
+                counter = 0
+            else:
+                counter += 1
+
+            if counter >= patience:
+                break
+
+        val_scores.append(best_fold_csi)
+
+    # 모든 fold의 평균 성능 반환
+    return np.mean(val_scores)
+
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습 및 저장 함수
+def train_final_model(best_params, model_choose, region, data_sample='pure', target='multi', n_folds=3, random_state=42):
+    """
+    최적화된 하이퍼파라미터로 최종 모델을 학습하고 저장합니다.
+    
+    Args:
+        best_params: 최적화된 하이퍼파라미터 딕셔너리
+        model_choose: 모델 선택 ('ft_transformer', 'resnet_like', 'deepgbm')
+        region: 지역명
+        data_sample: 데이터 샘플 타입 ('pure', 'smote', etc.)
+        target: 타겟 타입 ('multi', 'binary')
+        n_folds: 교차 검증 fold 수
+        random_state: 랜덤 시드
+    
+    Returns:
+        저장된 모델 경로 리스트
+    """
+    # GPU 사용 가능 여부 확인 및 device 설정
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    models = []
+    scalers = []  # scaler 리스트 추가
+    
+    print("최종 모델 학습 시작...")
+    
+    for fold in range(1, n_folds + 1):
+        print(f"Fold {fold} 학습 중...")
+        
+        # 최적화된 batch_size 사용
+        batch_size = best_params.get("batch_size", 64)
+        X_train_df, categorical_cols, numerical_cols, train_loader, val_loader, _, y_train, scaler = prepare_dataloader_with_batchsize(
+            region, data_sample=data_sample, target=target, fold=fold, random_state=random_state, batch_size=batch_size
+        )
+        
+        # 모델 초기화
+        if model_choose == "ft_transformer":
+            d_token = best_params["d_token"]
+            n_heads = best_params.get("n_heads", 8)
+            # d_token은 n_heads의 배수여야 함 (FT-Transformer의 구조적 제약 대응)
+            if d_token % n_heads != 0:
+                d_token = (d_token // n_heads) * n_heads
+            
+            model = FTTransformer(
+                num_features=len(numerical_cols),
+                cat_cardinalities=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_token=d_token,
+                n_blocks=best_params["n_blocks"],
+                n_heads=n_heads,
+                attention_dropout=best_params["attention_dropout"],
+                ffn_dropout=best_params["ffn_dropout"],
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'resnet_like':
+            input_dim = len(numerical_cols) + len(categorical_cols)
+            model = ResNetLike(
+                input_dim=input_dim,
+                d_main=best_params["d_main"],
+                d_hidden=best_params["d_hidden"],
+                n_blocks=best_params["n_blocks"],
+                dropout_first=best_params["dropout_first"],
+                dropout_second=best_params["dropout_second"],
+                num_classes=3
+            ).to(device)
+        elif model_choose == 'deepgbm':
+            model = DeepGBM(
+                num_features=len(numerical_cols),
+                cat_features=[len(X_train_df[col].unique()) for col in categorical_cols],
+                d_main=best_params["d_main"],
+                d_hidden=best_params["d_hidden"],
+                n_blocks=best_params["n_blocks"],
+                dropout=best_params["dropout"],
+                num_classes=3
+            ).to(device)
+        else:
+            raise ValueError(f"Unknown model_choose: {model_choose}")
+        
+        # 클래스 가중치 계산 및 손실 함수 설정 (Label Smoothing 적용)
+        if target == 'multi':
+            class_weights = compute_class_weight(
+                class_weight='balanced',
+                classes=np.unique(y_train),
+                y=y_train
+            )
+            class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
+            criterion = nn.CrossEntropyLoss(weight=class_weights_tensor, label_smoothing=0.0)  # Label Smoothing 추가
+        else:
+            criterion = nn.BCEWithLogitsLoss()
+        optimizer = optim.AdamW(model.parameters(), lr=best_params["lr"], weight_decay=best_params["weight_decay"])
+        
+        # 학습률 스케줄러
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+        
+        # 학습 설정
+        epochs = 200
+        patience = 12
+        best_fold_csi = 0
+        counter = 0
+        best_model = None
+        
+        for epoch in range(epochs):
+            model.train()
+            for x_num_batch, x_cat_batch, y_batch in train_loader:
+                x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                
+                optimizer.zero_grad()
+                y_pred = model(x_num_batch, x_cat_batch)
+                loss = criterion(y_pred, y_batch if target == 'multi' else y_batch.float())
+                loss.backward()
+                optimizer.step()
+            
+            # Validation 평가
+            model.eval()
+            y_pred_val, y_true_val = [], []
+            with torch.no_grad():
+                for x_num_batch, x_cat_batch, y_batch in val_loader:
+                    x_num_batch, x_cat_batch, y_batch = x_num_batch.to(device), x_cat_batch.to(device), y_batch.to(device)
+                    output = model(x_num_batch, x_cat_batch)
+                    pred = output.argmax(dim=1) if target == 'multi' else (torch.sigmoid(output) >= 0.5).long()
+                    
+                    y_pred_val.extend(pred.cpu().numpy())
+                    y_true_val.extend(y_batch.cpu().numpy())
+            
+            # CSI 계산 및 스케줄러 업데이트
+            val_csi = calculate_csi(y_true_val, y_pred_val)
+            scheduler.step(val_csi)
+            
+            # Early Stopping 체크
+            if val_csi > best_fold_csi:
+                best_fold_csi = val_csi
+                counter = 0
+                best_model = copy.deepcopy(model)
+            else:
+                counter += 1
+            
+            if counter >= patience:
+                print(f"  Early stopping at epoch {epoch+1}, Best CSI: {best_fold_csi:.4f}")
+                break
+        
+        if best_model is None:
+            best_model = model
+        
+        scalers.append(scaler)  # scaler 저장 (fold 순서대로)
+        models.append(best_model)
+        print(f"  Fold {fold} 학습 완료 (검증 CSI: {best_fold_csi:.4f})")
+    
+    # 모델 저장 경로 설정
+    save_dir = f'../save_model/{model_choose}_optima'
+    os.makedirs(save_dir, exist_ok=True)
+    
+    # 파일명 생성
+    if data_sample == 'pure':
+        model_filename = f'{model_choose}_pure_{region}.pkl'
+    else:
+        model_filename = f'{model_choose}_{data_sample}_{region}.pkl'
+    
+    model_path = f'{save_dir}/{model_filename}'
+    
+    # 리스트에 담아 한 번에 저장
+    joblib.dump(models, model_path)
+    print(f"\n모든 모델 저장 완료: {model_path} (총 {len(models)}개 fold)")
+    
+    # Scaler 별도 저장
+    scaler_save_dir = f'../save_model/{model_choose}_optima/scaler'
+    os.makedirs(scaler_save_dir, exist_ok=True)
+    
+    # 파일명 생성 (모델과 동일한 패턴)
+    if data_sample == 'pure':
+        scaler_filename = f'{model_choose}_pure_{region}_scaler.pkl'
+    else:
+        scaler_filename = f'{model_choose}_{data_sample}_{region}_scaler.pkl'
+    
+    scaler_path = f'{scaler_save_dir}/{scaler_filename}'
+    joblib.dump(scalers, scaler_path)
+    print(f"Scaler 저장 완료: {scaler_path} (총 {len(scalers)}개 fold)")
+    
+    return model_path
+

Analysis_code/5.optima/run_bash/deepgbm/run_deepgbm_pure.sh

@@ -45,7 +45,7 @@ for file in "${FILES[@]}"; do
     FILE_START=$(date +%s)
     
     # Python 스크립트 실행 (GPU 1번 설정)
-    if CUDA_VISIBLE_DEVICES=1 python3 -u "$filepath"; then
+    if CUDA_VISIBLE_DEVICES=0 python3 -u "$filepath"; then
         FILE_END=$(date +%s)
         FILE_DURATION=$((FILE_END - FILE_START))
         echo ""

Analysis_code/5.optima/run_bash/deepgbm/run_deepgbm_smote.sh

@@ -45,7 +45,7 @@ for file in "${FILES[@]}"; do
     FILE_START=$(date +%s)
     
     # Python 스크립트 실행 (GPU 1번 설정)
-    if CUDA_VISIBLE_DEVICES=1 python3 -u "$filepath"; then
+    if CUDA_VISIBLE_DEVICES=0 python3 -u "$filepath"; then
         FILE_END=$(date +%s)
         FILE_DURATION=$((FILE_END - FILE_START))
         echo ""

Analysis_code/5.optima/run_bash/deepgbm/run_deepgbm_smotenc_ctgan20000.sh

@@ -45,7 +45,7 @@ for file in "${FILES[@]}"; do
     FILE_START=$(date +%s)
     
     # Python 스크립트 실행 (GPU 1번 설정)
-    if CUDA_VISIBLE_DEVICES=1 python3 -u "$filepath"; then
+    if CUDA_VISIBLE_DEVICES=0 python3 -u "$filepath"; then
         FILE_END=$(date +%s)
         FILE_DURATION=$((FILE_END - FILE_START))
         echo ""

Analysis_code/5.optima/run_bash/ft_transformer/run_ft_transformer_smotenc_ctgan20000.sh

@@ -45,7 +45,7 @@ for file in "${FILES[@]}"; do
     FILE_START=$(date +%s)
     
     # Python 스크립트 실행 (GPU 0번 설정)
-    if CUDA_VISIBLE_DEVICES=1 python3 -u "$filepath"; then
+    if CUDA_VISIBLE_DEVICES=0 python3 -u "$filepath"; then
         FILE_END=$(date +%s)
         FILE_DURATION=$((FILE_END - FILE_START))
         echo ""

Analysis_code/5.optima/run_bash/resnet_like/resnet_like_smotenc_ctgan20000.log

@@ -0,0 +1,343 @@
+nohup: ignoring input
+/bin/bash: /opt/conda/lib/libtinfo.so.6: no version information available (required by /bin/bash)
+==========================================
+ResNet-Like SMOTENC CTGAN20000 파일 실행 시작
+시작 시간: 2025-12-25 16:59:09
+GPU: 0번 (CUDA_VISIBLE_DEVICES=0)
+==========================================
+
+----------------------------------------
+실행 중: resnet_like_smotenc_ctgan20000/resnet_like_smotenc_ctgan20000_busan.py
+시작 시간: 2025-12-25 16:59:09
+----------------------------------------
+[I 2025-12-25 16:59:11,068] A new study created in memory with name: no-name-07508dc2-d1e4-4e1f-80e4-6cb900bd0bcc
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:00:25,723] Trial 0 finished with value: 0.4301307659086353 and parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 0 완료
+  Value (CSI): 0.430131
+  Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:09:00,346] Trial 1 finished with value: 0.34866160612685354 and parameters: {'d_main': 192, 'd_hidden': 320, 'n_blocks': 4, 'dropout_first': 0.27116449295886247, 'dropout_second': 0.012755481146547676, 'lr': 1.6105326621013827e-05, 'weight_decay': 0.09159870455148564, 'batch_size': 32}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 1 완료
+  Value (CSI): 0.348662
+  Parameters: {'d_main': 192, 'd_hidden': 320, 'n_blocks': 4, 'dropout_first': 0.27116449295886247, 'dropout_second': 0.012755481146547676, 'lr': 1.6105326621013827e-05, 'weight_decay': 0.09159870455148564, 'batch_size': 32}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:10:23,826] Trial 2 finished with value: 0.4298469011463266 and parameters: {'d_main': 160, 'd_hidden': 64, 'n_blocks': 5, 'dropout_first': 0.2779266822607858, 'dropout_second': 0.08398746485299519, 'lr': 0.009843086320286042, 'weight_decay': 0.00023371434986427377, 'batch_size': 256}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 2 완료
+  Value (CSI): 0.429847
+  Parameters: {'d_main': 160, 'd_hidden': 64, 'n_blocks': 5, 'dropout_first': 0.2779266822607858, 'dropout_second': 0.08398746485299519, 'lr': 0.009843086320286042, 'weight_decay': 0.00023371434986427377, 'batch_size': 256}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:14:03,913] Trial 3 finished with value: 0.3845075126216187 and parameters: {'d_main': 64, 'd_hidden': 384, 'n_blocks': 2, 'dropout_first': 0.2753804618350803, 'dropout_second': 0.024769672838715607, 'lr': 0.00044363391353525626, 'weight_decay': 0.0002347247602245694, 'batch_size': 32}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 3 완료
+  Value (CSI): 0.384508
+  Parameters: {'d_main': 64, 'd_hidden': 384, 'n_blocks': 2, 'dropout_first': 0.2753804618350803, 'dropout_second': 0.024769672838715607, 'lr': 0.00044363391353525626, 'weight_decay': 0.0002347247602245694, 'batch_size': 32}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:21:11,653] Trial 4 finished with value: 0.3309491353413913 and parameters: {'d_main': 256, 'd_hidden': 384, 'n_blocks': 4, 'dropout_first': 0.28310034806911577, 'dropout_second': 0.006932423729906057, 'lr': 1.136506228965239e-05, 'weight_decay': 0.0036183895571627513, 'batch_size': 32}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 4 완료
+  Value (CSI): 0.330949
+  Parameters: {'d_main': 256, 'd_hidden': 384, 'n_blocks': 4, 'dropout_first': 0.28310034806911577, 'dropout_second': 0.006932423729906057, 'lr': 1.136506228965239e-05, 'weight_decay': 0.0036183895571627513, 'batch_size': 32}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:22:14,266] Trial 5 finished with value: 0.3899932374661734 and parameters: {'d_main': 128, 'd_hidden': 384, 'n_blocks': 2, 'dropout_first': 0.2844695689401958, 'dropout_second': 0.1572561815094476, 'lr': 0.0008860248969002365, 'weight_decay': 0.0037909150895975353, 'batch_size': 256}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 5 완료
+  Value (CSI): 0.389993
+  Parameters: {'d_main': 128, 'd_hidden': 384, 'n_blocks': 2, 'dropout_first': 0.2844695689401958, 'dropout_second': 0.1572561815094476, 'lr': 0.0008860248969002365, 'weight_decay': 0.0037909150895975353, 'batch_size': 256}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:22:55,435] Trial 6 pruned. 
+
+================================================================================
+Trial 6 완료
+  Value (CSI): 0.241888
+  Parameters: {'d_main': 128, 'd_hidden': 64, 'n_blocks': 5, 'dropout_first': 0.1806643232253578, 'dropout_second': 0.020619058831649786, 'lr': 1.3595828033778886e-05, 'weight_decay': 0.00022285919677684105, 'batch_size': 32}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:24:23,815] Trial 7 finished with value: 0.40834348300054496 and parameters: {'d_main': 160, 'd_hidden': 320, 'n_blocks': 4, 'dropout_first': 0.1717426678254888, 'dropout_second': 0.0934178652146346, 'lr': 0.0007575854806569902, 'weight_decay': 0.01534216484408197, 'batch_size': 128}. Best is trial 0 with value: 0.4301307659086353.
+
+================================================================================
+Trial 7 완료
+  Value (CSI): 0.408343
+  Parameters: {'d_main': 160, 'd_hidden': 320, 'n_blocks': 4, 'dropout_first': 0.1717426678254888, 'dropout_second': 0.0934178652146346, 'lr': 0.0007575854806569902, 'weight_decay': 0.01534216484408197, 'batch_size': 128}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:24:32,169] Trial 8 pruned. 
+
+================================================================================
+Trial 8 완료
+  Value (CSI): 0.209073
+  Parameters: {'d_main': 224, 'd_hidden': 384, 'n_blocks': 3, 'dropout_first': 0.14151506978958192, 'dropout_second': 0.07948320800127218, 'lr': 1.004046861765609e-05, 'weight_decay': 0.007637138900375409, 'batch_size': 256}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:25:12,850] Trial 9 pruned. 
+
+================================================================================
+Trial 9 완료
+  Value (CSI): 0.208511
+  Parameters: {'d_main': 128, 'd_hidden': 256, 'n_blocks': 4, 'dropout_first': 0.2317115408820841, 'dropout_second': 0.14700723302643884, 'lr': 1.2612737429485679e-05, 'weight_decay': 0.04037328340694686, 'batch_size': 32}
+  Best Value (CSI): 0.430131
+  Best Trial: 0
+  Best Parameters: {'d_main': 224, 'd_hidden': 256, 'n_blocks': 2, 'dropout_first': 0.10156371676747883, 'dropout_second': 0.022497091377821434, 'lr': 0.003727359142958118, 'weight_decay': 0.00038742389242139776, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:26:41,245] Trial 10 finished with value: 0.45568873098715307 and parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 10 완료
+  Value (CSI): 0.455689
+  Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:27:47,879] Trial 11 finished with value: 0.42197542511098435 and parameters: {'d_main': 256, 'd_hidden': 192, 'n_blocks': 3, 'dropout_first': 0.11027426804047841, 'dropout_second': 0.04995550792691689, 'lr': 0.009638623921852399, 'weight_decay': 0.0007413784723226764, 'batch_size': 128}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 11 완료
+  Value (CSI): 0.421975
+  Parameters: {'d_main': 256, 'd_hidden': 192, 'n_blocks': 3, 'dropout_first': 0.11027426804047841, 'dropout_second': 0.04995550792691689, 'lr': 0.009638623921852399, 'weight_decay': 0.0007413784723226764, 'batch_size': 128}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:29:29,987] Trial 12 finished with value: 0.44433747481934155 and parameters: {'d_main': 224, 'd_hidden': 512, 'n_blocks': 2, 'dropout_first': 0.10499188234645457, 'dropout_second': 0.05134622783384764, 'lr': 0.0031463084726703365, 'weight_decay': 0.0008736315412771812, 'batch_size': 64}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 12 완료
+  Value (CSI): 0.444337
+  Parameters: {'d_main': 224, 'd_hidden': 512, 'n_blocks': 2, 'dropout_first': 0.10499188234645457, 'dropout_second': 0.05134622783384764, 'lr': 0.0031463084726703365, 'weight_decay': 0.0008736315412771812, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:31:13,317] Trial 13 finished with value: 0.42346682809059244 and parameters: {'d_main': 224, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.38531025057952983, 'dropout_second': 0.05770605194787165, 'lr': 0.0029524632666265583, 'weight_decay': 0.0010566025989832471, 'batch_size': 64}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 13 완료
+  Value (CSI): 0.423467
+  Parameters: {'d_main': 224, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.38531025057952983, 'dropout_second': 0.05770605194787165, 'lr': 0.0029524632666265583, 'weight_decay': 0.0010566025989832471, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:32:54,124] Trial 14 finished with value: 0.43889187275926794 and parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 2, 'dropout_first': 0.13826103711935042, 'dropout_second': 0.12295366379536615, 'lr': 0.002792553877523577, 'weight_decay': 0.0012655524586531054, 'batch_size': 64}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 14 완료
+  Value (CSI): 0.438892
+  Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 2, 'dropout_first': 0.13826103711935042, 'dropout_second': 0.12295366379536615, 'lr': 0.002792553877523577, 'weight_decay': 0.0012655524586531054, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:33:10,457] Trial 15 pruned. 
+
+================================================================================
+Trial 15 완료
+  Value (CSI): 0.382440
+  Parameters: {'d_main': 192, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.11005239342556938, 'dropout_second': 0.05282313351206165, 'lr': 0.0014744290756182105, 'weight_decay': 0.0014332063342351049, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:33:19,805] Trial 16 pruned. 
+
+================================================================================
+Trial 16 완료
+  Value (CSI): 0.353548
+  Parameters: {'d_main': 192, 'd_hidden': 448, 'n_blocks': 2, 'dropout_first': 0.1888472184430823, 'dropout_second': 0.18995712629771064, 'lr': 0.00021100251322998348, 'weight_decay': 0.00011516083231935141, 'batch_size': 128}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:33:36,528] Trial 17 pruned. 
+
+================================================================================
+Trial 17 완료
+  Value (CSI): 0.369598
+  Parameters: {'d_main': 224, 'd_hidden': 448, 'n_blocks': 3, 'dropout_first': 0.148777791202791, 'dropout_second': 0.06125371639544101, 'lr': 0.004966293343601136, 'weight_decay': 0.002047276938146628, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:35:19,256] Trial 18 finished with value: 0.43554917854930214 and parameters: {'d_main': 64, 'd_hidden': 448, 'n_blocks': 2, 'dropout_first': 0.10183795686380824, 'dropout_second': 0.11092680117376562, 'lr': 0.009728600379224997, 'weight_decay': 0.0006966213827491482, 'batch_size': 64}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 18 완료
+  Value (CSI): 0.435549
+  Parameters: {'d_main': 64, 'd_hidden': 448, 'n_blocks': 2, 'dropout_first': 0.10183795686380824, 'dropout_second': 0.11092680117376562, 'lr': 0.009728600379224997, 'weight_decay': 0.0006966213827491482, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:35:29,604] Trial 19 pruned. 
+
+================================================================================
+Trial 19 완료
+  Value (CSI): 0.374277
+  Parameters: {'d_main': 256, 'd_hidden': 128, 'n_blocks': 3, 'dropout_first': 0.20458013340839706, 'dropout_second': 0.03936539506356172, 'lr': 0.002044084446572949, 'weight_decay': 0.0005937198842313242, 'batch_size': 128}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:35:38,703] Trial 20 pruned. 
+
+================================================================================
+Trial 20 완료
+  Value (CSI): 0.279321
+  Parameters: {'d_main': 224, 'd_hidden': 512, 'n_blocks': 2, 'dropout_first': 0.13947875703479234, 'dropout_second': 0.07418201307448172, 'lr': 0.005384115015845719, 'weight_decay': 0.0025611933143003217, 'batch_size': 128}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:35:53,337] Trial 21 pruned. 
+
+================================================================================
+Trial 21 완료
+  Value (CSI): 0.362717
+  Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 2, 'dropout_first': 0.13626921113677734, 'dropout_second': 0.10030012446906778, 'lr': 0.002037737924762407, 'weight_decay': 0.001347899826038143, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:36:08,009] Trial 22 pruned. 
+
+================================================================================
+Trial 22 완료
+  Value (CSI): 0.343606
+  Parameters: {'d_main': 256, 'd_hidden': 448, 'n_blocks': 2, 'dropout_first': 0.1293383333282218, 'dropout_second': 0.11731304342724859, 'lr': 0.004738846815538181, 'weight_decay': 0.0013996905007623878, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})
+  Fold 3 - 클래스별 가중치: {0: 0.9437235772357724, 1: 0.9168878357030016, 2: 1.1768558509236167} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16439})
+[I 2025-12-25 17:38:04,053] Trial 23 finished with value: 0.4283188153909843 and parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.15657019116372836, 'dropout_second': 0.03579914728063769, 'lr': 0.0024610566433362767, 'weight_decay': 0.0005158217464369175, 'batch_size': 64}. Best is trial 10 with value: 0.45568873098715307.
+
+================================================================================
+Trial 23 완료
+  Value (CSI): 0.428319
+  Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.15657019116372836, 'dropout_second': 0.03579914728063769, 'lr': 0.0024610566433362767, 'weight_decay': 0.0005158217464369175, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+[I 2025-12-25 17:38:20,002] Trial 24 pruned. 
+
+================================================================================
+Trial 24 완료
+  Value (CSI): 0.366959
+  Parameters: {'d_main': 192, 'd_hidden': 448, 'n_blocks': 2, 'dropout_first': 0.12366099999313362, 'dropout_second': 0.066707588276286, 'lr': 0.0054929082954202554, 'weight_decay': 0.0010668358869719242, 'batch_size': 64}
+  Best Value (CSI): 0.455689
+  Best Trial: 10
+  Best Parameters: {'d_main': 256, 'd_hidden': 512, 'n_blocks': 3, 'dropout_first': 0.1045169105881141, 'dropout_second': 0.05372596450552944, 'lr': 0.00943776593390798, 'weight_decay': 0.0010575459741554466, 'batch_size': 128}
+================================================================================
+
+  Fold 1 - 클래스별 가중치: {0: 0.9429593495934959, 1: 0.9205079365079365, 2: 1.1721238580321771} (클래스별 샘플 수: {0: 20500, 1: 21000, 2: 16492})
+  Fold 2 - 클래스별 가중치: {0: 0.9440162601626017, 1: 0.917172195892575, 2: 1.1759332401612284} (클래스별 샘플 수: {0: 20500, 1: 21100, 2: 16457})