Merge pull request #1 from singbong/bong/modeling

Analysis_code/4.sampling_data_test/analysis.ipynb

@@ -1,244 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "70effd7a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f38ce7d1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df= pd.read_csv(\"../../data/oversampled_data_test_for_model/combined_sampled_data_test.csv\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "2bae91e4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>region</th>\n",
-       "      <th>model</th>\n",
-       "      <th>data_sample</th>\n",
-       "      <th>CSI</th>\n",
-       "      <th>MCC</th>\n",
-       "      <th>Accuracy</th>\n",
-       "      <th>fold_csi</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>seoul</td>\n",
-       "      <td>LightGBM</td>\n",
-       "      <td>pure</td>\n",
-       "      <td>0.505041</td>\n",
-       "      <td>0.646992</td>\n",
-       "      <td>0.936174</td>\n",
-       "      <td>[[0.46595932802825235, 0.5771195097037204, 0.4...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>busan</td>\n",
-       "      <td>LightGBM</td>\n",
-       "      <td>pure</td>\n",
-       "      <td>0.430188</td>\n",
-       "      <td>0.600801</td>\n",
-       "      <td>0.956971</td>\n",
-       "      <td>[[0.32824427480911017, 0.4782608695651431, 0.4...</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "  region     model data_sample       CSI       MCC  Accuracy  \\\n",
-       "0  seoul  LightGBM        pure  0.505041  0.646992  0.936174   \n",
-       "1  busan  LightGBM        pure  0.430188  0.600801  0.956971   \n",
-       "\n",
-       "                                            fold_csi  \n",
-       "0  [[0.46595932802825235, 0.5771195097037204, 0.4...  \n",
-       "1  [[0.32824427480911017, 0.4782608695651431, 0.4...  "
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df.head(2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "6893a958",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>region</th>\n",
-       "      <th>model</th>\n",
-       "      <th>data_sample</th>\n",
-       "      <th>CSI</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>busan</td>\n",
-       "      <td>LightGBM</td>\n",
-       "      <td>ctgan10000</td>\n",
-       "      <td>0.467663</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>daegu</td>\n",
-       "      <td>XGBoost</td>\n",
-       "      <td>smote</td>\n",
-       "      <td>0.454066</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>daejeon</td>\n",
-       "      <td>LightGBM</td>\n",
-       "      <td>smote</td>\n",
-       "      <td>0.521335</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>gwangju</td>\n",
-       "      <td>LightGBM</td>\n",
-       "      <td>smote</td>\n",
-       "      <td>0.522731</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>incheon</td>\n",
-       "      <td>XGBoost</td>\n",
-       "      <td>smote</td>\n",
-       "      <td>0.589146</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>seoul</td>\n",
-       "      <td>XGBoost</td>\n",
-       "      <td>smote</td>\n",
-       "      <td>0.582266</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "    region     model data_sample       CSI\n",
-       "0    busan  LightGBM  ctgan10000  0.467663\n",
-       "1    daegu   XGBoost       smote  0.454066\n",
-       "2  daejeon  LightGBM       smote  0.521335\n",
-       "3  gwangju  LightGBM       smote  0.522731\n",
-       "4  incheon   XGBoost       smote  0.589146\n",
-       "5    seoul   XGBoost       smote  0.582266"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 지역별로 CSI가 가장 높은 model과 data_sample 조합 보기\n",
-    "top_csi_per_region = df.loc[df.groupby('region')['CSI'].idxmax()][['region', 'model', 'data_sample', 'CSI']]\n",
-    "top_csi_per_region = top_csi_per_region.sort_values('region').reset_index(drop=True)\n",
-    "top_csi_per_region"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2942ba86",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d55af59c",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py39",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.18"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

Analysis_code/5.optima/deepgbm_ctgan10000/deepgbm_ctgan10000_daegu.py

@@ -0,0 +1,97 @@
+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="daegu", 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_daegu_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="daegu",
+        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/deepgbm_ctgan10000_daejeon.py

@@ -0,0 +1,97 @@
+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="daejeon", 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_daejeon_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="daejeon",
+        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/deepgbm_ctgan10000_gwangju.py

@@ -0,0 +1,97 @@
+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="gwangju", 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_gwangju_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="gwangju",
+        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/deepgbm_ctgan10000_incheon.py

@@ -0,0 +1,97 @@
+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="incheon", 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_incheon_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="incheon",
+        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/deepgbm_ctgan10000_seoul.py

@@ -0,0 +1,97 @@
+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="seoul", 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_seoul_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="seoul",
+        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/ft_transformer_ctgan10000_daegu.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="daegu", 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_daegu_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="daegu",
+        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/ft_transformer_ctgan10000_daejeon.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="daejeon", 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_daejeon_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="daejeon",
+        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/ft_transformer_ctgan10000_gwangju.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="gwangju", 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_gwangju_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="gwangju",
+        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/ft_transformer_ctgan10000_incheon.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="incheon", 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_incheon_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="incheon",
+        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/ft_transformer_ctgan10000_seoul.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="seoul", 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_seoul_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="seoul",
+        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/lgb_ctgan10000/LGB_ctgan10000_busan.py

@@ -281,6 +281,7 @@ print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
 
 # Trials 객체 저장
 import os
+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)
 trials_path = os.path.join(base_dir, "optimization_history/lgb_ctgan10000_busan_trials.pkl")
 joblib.dump(trials, trials_path)

Analysis_code/5.optima/lgb_ctgan10000/LGB_ctgan10000_daegu.py

@@ -0,0 +1,317 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from warnings import filterwarnings
+from sklearn.metrics import confusion_matrix
+from lightgbm import LGBMClassifier
+from hyperopt import fmin, tpe, Trials, hp
+
+filterwarnings('ignore')
+
+# 상수 정의
+RANDOM_STATE = 42
+N_ESTIMATORS = 4000
+EARLY_STOPPING_ROUNDS = 400
+MAX_EVALS = 100
+DEVICE = 'gpu'
+OBJECTIVE = 'multiclassova'
+
+# Fold 설정: (train_years, val_year)
+FOLD_CONFIGS = [
+    ([2018, 2019], 2020),  # Fold 1
+    ([2018, 2020], 2019),  # Fold 2
+    ([2019, 2020], 2018),  # Fold 3
+]
+
+def calculate_csi(y_true, y_pred):
+    """CSI(Critical Success Index) 점수를 계산합니다.
+    
+    Args:
+        y_true: 실제 레이블
+        y_pred: 예측 레이블
+        
+    Returns:
+        CSI 점수 (0~1 사이의 값)
+    """
+    cm = confusion_matrix(y_true, y_pred)
+    
+    # 혼동 행렬에서 H(Hit), F(False alarm), M(Miss) 추출
+    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 csi_metric(y_true, pred_prob):
+    """LightGBM용 CSI 메트릭 함수.
+    
+    Args:
+        y_true: 실제 레이블
+        pred_prob: 예측 확률 (shape: [n_samples, n_classes])
+        
+    Returns:
+        ('CSI', score, higher_better) 튜플
+    """
+    y_pred_binary = np.argmax(pred_prob, axis=1)
+    score = calculate_csi(y_true, y_pred_binary)
+    return 'CSI', score, 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 split_data(df_sampled, df_original, train_years, val_year):
+    """데이터를 학습용과 검증용으로 분할합니다.
+    
+    Args:
+        df_sampled: 샘플링된 데이터프레임
+        df_original: 원본 데이터프레임
+        train_years: 학습에 사용할 연도 리스트
+        val_year: 검증에 사용할 연도
+        
+    Returns:
+        (X_train, X_val, y_train, y_val) 튜플
+    """
+    # 학습 데이터: 샘플링된 데이터에서 train_years에 해당하는 데이터
+    train_mask = df_sampled['year'].isin(train_years)
+    X_train = df_sampled.loc[train_mask, df_sampled.columns != 'multi_class'].copy()
+    y_train = df_sampled.loc[train_mask, 'multi_class']
+    
+    # 검증 데이터: 원본 데이터에서 val_year에 해당하는 데이터
+    val_mask = df_original['year'] == val_year
+    X_val = df_original.loc[val_mask, df_original.columns != 'multi_class'].copy()
+    y_val = df_original.loc[val_mask, 'multi_class']
+    
+    # 'year' 컬럼 제거
+    X_train = X_train.drop(columns=['year'])
+    X_val = X_val.drop(columns=['year'])
+    
+    return X_train, X_val, y_train, y_val
+
+
+def create_lgb_model(search_space=None, best_params=None):
+    """LightGBM 모델을 생성합니다.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간 (objective_func에서 사용)
+        best_params: 최적화된 하이퍼파라미터 (최종 모델 학습에서 사용)
+        
+    Returns:
+        LGBMClassifier 인스턴스
+    """
+    base_params = {
+        'n_estimators': N_ESTIMATORS,
+        'device': DEVICE,
+        'objective': OBJECTIVE,
+        'random_state': RANDOM_STATE,
+        'early_stopping_rounds': EARLY_STOPPING_ROUNDS,
+        'verbose': -1,
+    }
+    
+    if search_space is not None:
+        # 하이퍼파라미터 최적화 중
+        params = {
+            **base_params,
+            'learning_rate': search_space['learning_rate'],
+            'max_depth': int(search_space['max_depth']),
+            'num_leaves': int(search_space['num_leaves']),
+            'min_child_weight': int(search_space['min_child_weight']),
+            'subsample': search_space['subsample'],
+            'colsample_bytree': search_space['colsample_bytree'],
+            'reg_alpha': search_space['reg_alpha'],
+            'reg_lambda': search_space['reg_lambda'],
+        }
+    elif best_params is not None:
+        # 최적화된 파라미터로 최종 모델 생성
+        params = {
+            **base_params,
+            'learning_rate': best_params['learning_rate'],
+            'max_depth': int(best_params['max_depth']),
+            'num_leaves': int(best_params['num_leaves']),
+            'min_child_weight': int(best_params['min_child_weight']),
+            'subsample': best_params['subsample'],
+            'colsample_bytree': best_params['colsample_bytree'],
+            'reg_alpha': best_params['reg_alpha'],
+            'reg_lambda': best_params['reg_lambda'],
+        }
+    else:
+        params = base_params
+    
+    return LGBMClassifier(**params)
+
+# 데이터 로딩
+print("데이터 로딩 중...")
+# 파일 위치 기반으로 데이터 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+df_daegu = pd.read_csv(os.path.join(data_base_dir, "data_for_modeling/daegu_train.csv"))
+df_ctgan_daegu_1 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_1_daegu.csv"))
+df_ctgan_daegu_2 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_2_daegu.csv"))
+df_ctgan_daegu_3 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_3_daegu.csv"))
+
+# 데이터 전처리
+print("데이터 전처리 중...")
+df_ctgan_daegu_1 = preprocessing(df_ctgan_daegu_1)
+df_ctgan_daegu_2 = preprocessing(df_ctgan_daegu_2)
+df_ctgan_daegu_3 = preprocessing(df_ctgan_daegu_3)
+df_daegu = preprocessing(df_daegu)
+
+# CTGAN 데이터 리스트 (fold 순서와 일치)
+df_ctgan_list = [df_ctgan_daegu_1, df_ctgan_daegu_2, df_ctgan_daegu_3]
+
+# 하이퍼파라미터 검색 공간 정의
+lgb_search_space = {
+    'learning_rate': hp.loguniform('learning_rate', np.log(0.01), np.log(0.2)),
+    'max_depth': hp.quniform('max_depth', 3, 15, 1),
+    'num_leaves': hp.quniform('num_leaves', 20, 150, 1),  # 2^max_depth 보다는 작게
+    'min_child_weight': hp.quniform('min_child_weight', 1, 20, 1),
+    'subsample': hp.uniform('subsample', 0.6, 1.0),
+    'colsample_bytree': hp.uniform('colsample_bytree', 0.6, 1.0),
+    'reg_alpha': hp.uniform('reg_alpha', 0.0, 1.0),
+    'reg_lambda': hp.uniform('reg_lambda', 0.0, 1.0)
+}
+
+
+def objective_func(search_space):
+    """하이퍼파라미터 최적화를 위한 목적 함수.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간
+        
+    Returns:
+        평균 CSI 점수의 음수값 (hyperopt는 최소화를 수행하므로)
+    """
+    lgb_model = create_lgb_model(search_space=search_space)
+    csi_scores = []
+
+    # 각 fold에 대해 교차 검증 수행
+    for df_ctgan, (train_years, val_year) in zip(df_ctgan_list, FOLD_CONFIGS):
+        X_train, X_val, y_train, y_val = split_data(
+            df_ctgan, df_daegu, train_years, val_year
+        )
+        
+        lgb_model.fit(
+            X_train, y_train,
+            eval_set=[(X_val, y_val)],
+            eval_metric=csi_metric
+        )
+        
+        csi = calculate_csi(y_val, lgb_model.predict(X_val))
+        csi_scores.append(csi)
+
+    # 평균 CSI의 음수값 반환 (hyperopt는 최소화를 수행)
+    return -1 * round(np.mean(csi_scores), 4)
+
+
+# 하이퍼파라미터 최적화
+print("하이퍼파라미터 최적화 시작...")
+trials = Trials()
+lgb_best = fmin(
+    fn=objective_func,
+    space=lgb_search_space,
+    algo=tpe.suggest,
+    max_evals=MAX_EVALS,
+    trials=trials
+)
+
+# 최적화 결과 분석 및 출력
+print(f"\n최적화 완료. 최적 파라미터: {lgb_best}")
+
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+import os
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_ctgan10000_daegu_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습
+print("최종 모델 학습 시작...")
+models = []
+
+for fold_idx, (df_ctgan, (train_years, val_year)) in enumerate(
+    zip(df_ctgan_list, FOLD_CONFIGS), start=1
+):
+    print(f"Fold {fold_idx} 학습 중... (학습 연도: {train_years}, 검증 연도: {val_year})")
+    
+    X_train, X_val, y_train, y_val = split_data(
+        df_ctgan, df_daegu, train_years, val_year
+    )
+    
+    lgb_model = create_lgb_model(best_params=lgb_best)
+    lgb_model.fit(X_train, y_train, eval_set=[(X_val, y_val)])
+    
+    # 검증 성능 출력
+    val_csi = calculate_csi(y_val, lgb_model.predict(X_val))
+    print(f"Fold {fold_idx} 검증 CSI: {val_csi:.4f}")
+    
+    models.append(lgb_model)
+
+# 모델 저장
+print("모델 저장 중...")
+model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_ctgan10000_daegu.pkl")
+joblib.dump(models, model_save_path)
+print(f"모델이 {model_save_path}에 저장되었습니다.")
+

Analysis_code/5.optima/lgb_ctgan10000/LGB_ctgan10000_daejeon.py

@@ -0,0 +1,317 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from warnings import filterwarnings
+from sklearn.metrics import confusion_matrix
+from lightgbm import LGBMClassifier
+from hyperopt import fmin, tpe, Trials, hp
+
+filterwarnings('ignore')
+
+# 상수 정의
+RANDOM_STATE = 42
+N_ESTIMATORS = 4000
+EARLY_STOPPING_ROUNDS = 400
+MAX_EVALS = 100
+DEVICE = 'gpu'
+OBJECTIVE = 'multiclassova'
+
+# Fold 설정: (train_years, val_year)
+FOLD_CONFIGS = [
+    ([2018, 2019], 2020),  # Fold 1
+    ([2018, 2020], 2019),  # Fold 2
+    ([2019, 2020], 2018),  # Fold 3
+]
+
+def calculate_csi(y_true, y_pred):
+    """CSI(Critical Success Index) 점수를 계산합니다.
+    
+    Args:
+        y_true: 실제 레이블
+        y_pred: 예측 레이블
+        
+    Returns:
+        CSI 점수 (0~1 사이의 값)
+    """
+    cm = confusion_matrix(y_true, y_pred)
+    
+    # 혼동 행렬에서 H(Hit), F(False alarm), M(Miss) 추출
+    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 csi_metric(y_true, pred_prob):
+    """LightGBM용 CSI 메트릭 함수.
+    
+    Args:
+        y_true: 실제 레이블
+        pred_prob: 예측 확률 (shape: [n_samples, n_classes])
+        
+    Returns:
+        ('CSI', score, higher_better) 튜플
+    """
+    y_pred_binary = np.argmax(pred_prob, axis=1)
+    score = calculate_csi(y_true, y_pred_binary)
+    return 'CSI', score, 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 split_data(df_sampled, df_original, train_years, val_year):
+    """데이터를 학습용과 검증용으로 분할합니다.
+    
+    Args:
+        df_sampled: 샘플링된 데이터프레임
+        df_original: 원본 데이터프레임
+        train_years: 학습에 사용할 연도 리스트
+        val_year: 검증에 사용할 연도
+        
+    Returns:
+        (X_train, X_val, y_train, y_val) 튜플
+    """
+    # 학습 데이터: 샘플링된 데이터에서 train_years에 해당하는 데이터
+    train_mask = df_sampled['year'].isin(train_years)
+    X_train = df_sampled.loc[train_mask, df_sampled.columns != 'multi_class'].copy()
+    y_train = df_sampled.loc[train_mask, 'multi_class']
+    
+    # 검증 데이터: 원본 데이터에서 val_year에 해당하는 데이터
+    val_mask = df_original['year'] == val_year
+    X_val = df_original.loc[val_mask, df_original.columns != 'multi_class'].copy()
+    y_val = df_original.loc[val_mask, 'multi_class']
+    
+    # 'year' 컬럼 제거
+    X_train = X_train.drop(columns=['year'])
+    X_val = X_val.drop(columns=['year'])
+    
+    return X_train, X_val, y_train, y_val
+
+
+def create_lgb_model(search_space=None, best_params=None):
+    """LightGBM 모델을 생성합니다.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간 (objective_func에서 사용)
+        best_params: 최적화된 하이퍼파라미터 (최종 모델 학습에서 사용)
+        
+    Returns:
+        LGBMClassifier 인스턴스
+    """
+    base_params = {
+        'n_estimators': N_ESTIMATORS,
+        'device': DEVICE,
+        'objective': OBJECTIVE,
+        'random_state': RANDOM_STATE,
+        'early_stopping_rounds': EARLY_STOPPING_ROUNDS,
+        'verbose': -1,
+    }
+    
+    if search_space is not None:
+        # 하이퍼파라미터 최적화 중
+        params = {
+            **base_params,
+            'learning_rate': search_space['learning_rate'],
+            'max_depth': int(search_space['max_depth']),
+            'num_leaves': int(search_space['num_leaves']),
+            'min_child_weight': int(search_space['min_child_weight']),
+            'subsample': search_space['subsample'],
+            'colsample_bytree': search_space['colsample_bytree'],
+            'reg_alpha': search_space['reg_alpha'],
+            'reg_lambda': search_space['reg_lambda'],
+        }
+    elif best_params is not None:
+        # 최적화된 파라미터로 최종 모델 생성
+        params = {
+            **base_params,
+            'learning_rate': best_params['learning_rate'],
+            'max_depth': int(best_params['max_depth']),
+            'num_leaves': int(best_params['num_leaves']),
+            'min_child_weight': int(best_params['min_child_weight']),
+            'subsample': best_params['subsample'],
+            'colsample_bytree': best_params['colsample_bytree'],
+            'reg_alpha': best_params['reg_alpha'],
+            'reg_lambda': best_params['reg_lambda'],
+        }
+    else:
+        params = base_params
+    
+    return LGBMClassifier(**params)
+
+# 데이터 로딩
+print("데이터 로딩 중...")
+# 파일 위치 기반으로 데이터 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+df_daejeon = pd.read_csv(os.path.join(data_base_dir, "data_for_modeling/daejeon_train.csv"))
+df_ctgan_daejeon_1 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_1_daejeon.csv"))
+df_ctgan_daejeon_2 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_2_daejeon.csv"))
+df_ctgan_daejeon_3 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_3_daejeon.csv"))
+
+# 데이터 전처리
+print("데이터 전처리 중...")
+df_ctgan_daejeon_1 = preprocessing(df_ctgan_daejeon_1)
+df_ctgan_daejeon_2 = preprocessing(df_ctgan_daejeon_2)
+df_ctgan_daejeon_3 = preprocessing(df_ctgan_daejeon_3)
+df_daejeon = preprocessing(df_daejeon)
+
+# CTGAN 데이터 리스트 (fold 순서와 일치)
+df_ctgan_list = [df_ctgan_daejeon_1, df_ctgan_daejeon_2, df_ctgan_daejeon_3]
+
+# 하이퍼파라미터 검색 공간 정의
+lgb_search_space = {
+    'learning_rate': hp.loguniform('learning_rate', np.log(0.01), np.log(0.2)),
+    'max_depth': hp.quniform('max_depth', 3, 15, 1),
+    'num_leaves': hp.quniform('num_leaves', 20, 150, 1),  # 2^max_depth 보다는 작게
+    'min_child_weight': hp.quniform('min_child_weight', 1, 20, 1),
+    'subsample': hp.uniform('subsample', 0.6, 1.0),
+    'colsample_bytree': hp.uniform('colsample_bytree', 0.6, 1.0),
+    'reg_alpha': hp.uniform('reg_alpha', 0.0, 1.0),
+    'reg_lambda': hp.uniform('reg_lambda', 0.0, 1.0)
+}
+
+
+def objective_func(search_space):
+    """하이퍼파라미터 최적화를 위한 목적 함수.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간
+        
+    Returns:
+        평균 CSI 점수의 음수값 (hyperopt는 최소화를 수행하므로)
+    """
+    lgb_model = create_lgb_model(search_space=search_space)
+    csi_scores = []
+
+    # 각 fold에 대해 교차 검증 수행
+    for df_ctgan, (train_years, val_year) in zip(df_ctgan_list, FOLD_CONFIGS):
+        X_train, X_val, y_train, y_val = split_data(
+            df_ctgan, df_daejeon, train_years, val_year
+        )
+        
+        lgb_model.fit(
+            X_train, y_train,
+            eval_set=[(X_val, y_val)],
+            eval_metric=csi_metric
+        )
+        
+        csi = calculate_csi(y_val, lgb_model.predict(X_val))
+        csi_scores.append(csi)
+
+    # 평균 CSI의 음수값 반환 (hyperopt는 최소화를 수행)
+    return -1 * round(np.mean(csi_scores), 4)
+
+
+# 하이퍼파라미터 최적화
+print("하이퍼파라미터 최적화 시작...")
+trials = Trials()
+lgb_best = fmin(
+    fn=objective_func,
+    space=lgb_search_space,
+    algo=tpe.suggest,
+    max_evals=MAX_EVALS,
+    trials=trials
+)
+
+# 최적화 결과 분석 및 출력
+print(f"\n최적화 완료. 최적 파라미터: {lgb_best}")
+
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+import os
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_ctgan10000_daejeon_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습
+print("최종 모델 학습 시작...")
+models = []
+
+for fold_idx, (df_ctgan, (train_years, val_year)) in enumerate(
+    zip(df_ctgan_list, FOLD_CONFIGS), start=1
+):
+    print(f"Fold {fold_idx} 학습 중... (학습 연도: {train_years}, 검증 연도: {val_year})")
+    
+    X_train, X_val, y_train, y_val = split_data(
+        df_ctgan, df_daejeon, train_years, val_year
+    )
+    
+    lgb_model = create_lgb_model(best_params=lgb_best)
+    lgb_model.fit(X_train, y_train, eval_set=[(X_val, y_val)])
+    
+    # 검증 성능 출력
+    val_csi = calculate_csi(y_val, lgb_model.predict(X_val))
+    print(f"Fold {fold_idx} 검증 CSI: {val_csi:.4f}")
+    
+    models.append(lgb_model)
+
+# 모델 저장
+print("모델 저장 중...")
+model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_ctgan10000_daejeon.pkl")
+joblib.dump(models, model_save_path)
+print(f"모델이 {model_save_path}에 저장되었습니다.")
+

Analysis_code/5.optima/lgb_ctgan10000/LGB_ctgan10000_gwangju.py

@@ -0,0 +1,317 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from warnings import filterwarnings
+from sklearn.metrics import confusion_matrix
+from lightgbm import LGBMClassifier
+from hyperopt import fmin, tpe, Trials, hp
+
+filterwarnings('ignore')
+
+# 상수 정의
+RANDOM_STATE = 42
+N_ESTIMATORS = 4000
+EARLY_STOPPING_ROUNDS = 400
+MAX_EVALS = 100
+DEVICE = 'gpu'
+OBJECTIVE = 'multiclassova'
+
+# Fold 설정: (train_years, val_year)
+FOLD_CONFIGS = [
+    ([2018, 2019], 2020),  # Fold 1
+    ([2018, 2020], 2019),  # Fold 2
+    ([2019, 2020], 2018),  # Fold 3
+]
+
+def calculate_csi(y_true, y_pred):
+    """CSI(Critical Success Index) 점수를 계산합니다.
+    
+    Args:
+        y_true: 실제 레이블
+        y_pred: 예측 레이블
+        
+    Returns:
+        CSI 점수 (0~1 사이의 값)
+    """
+    cm = confusion_matrix(y_true, y_pred)
+    
+    # 혼동 행렬에서 H(Hit), F(False alarm), M(Miss) 추출
+    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 csi_metric(y_true, pred_prob):
+    """LightGBM용 CSI 메트릭 함수.
+    
+    Args:
+        y_true: 실제 레이블
+        pred_prob: 예측 확률 (shape: [n_samples, n_classes])
+        
+    Returns:
+        ('CSI', score, higher_better) 튜플
+    """
+    y_pred_binary = np.argmax(pred_prob, axis=1)
+    score = calculate_csi(y_true, y_pred_binary)
+    return 'CSI', score, 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 split_data(df_sampled, df_original, train_years, val_year):
+    """데이터를 학습용과 검증용으로 분할합니다.
+    
+    Args:
+        df_sampled: 샘플링된 데이터프레임
+        df_original: 원본 데이터프레임
+        train_years: 학습에 사용할 연도 리스트
+        val_year: 검증에 사용할 연도
+        
+    Returns:
+        (X_train, X_val, y_train, y_val) 튜플
+    """
+    # 학습 데이터: 샘플링된 데이터에서 train_years에 해당하는 데이터
+    train_mask = df_sampled['year'].isin(train_years)
+    X_train = df_sampled.loc[train_mask, df_sampled.columns != 'multi_class'].copy()
+    y_train = df_sampled.loc[train_mask, 'multi_class']
+    
+    # 검증 데이터: 원본 데이터에서 val_year에 해당하는 데이터
+    val_mask = df_original['year'] == val_year
+    X_val = df_original.loc[val_mask, df_original.columns != 'multi_class'].copy()
+    y_val = df_original.loc[val_mask, 'multi_class']
+    
+    # 'year' 컬럼 제거
+    X_train = X_train.drop(columns=['year'])
+    X_val = X_val.drop(columns=['year'])
+    
+    return X_train, X_val, y_train, y_val
+
+
+def create_lgb_model(search_space=None, best_params=None):
+    """LightGBM 모델을 생성합니다.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간 (objective_func에서 사용)
+        best_params: 최적화된 하이퍼파라미터 (최종 모델 학습에서 사용)
+        
+    Returns:
+        LGBMClassifier 인스턴스
+    """
+    base_params = {
+        'n_estimators': N_ESTIMATORS,
+        'device': DEVICE,
+        'objective': OBJECTIVE,
+        'random_state': RANDOM_STATE,
+        'early_stopping_rounds': EARLY_STOPPING_ROUNDS,
+        'verbose': -1,
+    }
+    
+    if search_space is not None:
+        # 하이퍼파라미터 최적화 중
+        params = {
+            **base_params,
+            'learning_rate': search_space['learning_rate'],
+            'max_depth': int(search_space['max_depth']),
+            'num_leaves': int(search_space['num_leaves']),
+            'min_child_weight': int(search_space['min_child_weight']),
+            'subsample': search_space['subsample'],
+            'colsample_bytree': search_space['colsample_bytree'],
+            'reg_alpha': search_space['reg_alpha'],
+            'reg_lambda': search_space['reg_lambda'],
+        }
+    elif best_params is not None:
+        # 최적화된 파라미터로 최종 모델 생성
+        params = {
+            **base_params,
+            'learning_rate': best_params['learning_rate'],
+            'max_depth': int(best_params['max_depth']),
+            'num_leaves': int(best_params['num_leaves']),
+            'min_child_weight': int(best_params['min_child_weight']),
+            'subsample': best_params['subsample'],
+            'colsample_bytree': best_params['colsample_bytree'],
+            'reg_alpha': best_params['reg_alpha'],
+            'reg_lambda': best_params['reg_lambda'],
+        }
+    else:
+        params = base_params
+    
+    return LGBMClassifier(**params)
+
+# 데이터 로딩
+print("데이터 로딩 중...")
+# 파일 위치 기반으로 데이터 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+df_gwangju = pd.read_csv(os.path.join(data_base_dir, "data_for_modeling/gwangju_train.csv"))
+df_ctgan_gwangju_1 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_1_gwangju.csv"))
+df_ctgan_gwangju_2 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_2_gwangju.csv"))
+df_ctgan_gwangju_3 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_3_gwangju.csv"))
+
+# 데이터 전처리
+print("데이터 전처리 중...")
+df_ctgan_gwangju_1 = preprocessing(df_ctgan_gwangju_1)
+df_ctgan_gwangju_2 = preprocessing(df_ctgan_gwangju_2)
+df_ctgan_gwangju_3 = preprocessing(df_ctgan_gwangju_3)
+df_gwangju = preprocessing(df_gwangju)
+
+# CTGAN 데이터 리스트 (fold 순서와 일치)
+df_ctgan_list = [df_ctgan_gwangju_1, df_ctgan_gwangju_2, df_ctgan_gwangju_3]
+
+# 하이퍼파라미터 검색 공간 정의
+lgb_search_space = {
+    'learning_rate': hp.loguniform('learning_rate', np.log(0.01), np.log(0.2)),
+    'max_depth': hp.quniform('max_depth', 3, 15, 1),
+    'num_leaves': hp.quniform('num_leaves', 20, 150, 1),  # 2^max_depth 보다는 작게
+    'min_child_weight': hp.quniform('min_child_weight', 1, 20, 1),
+    'subsample': hp.uniform('subsample', 0.6, 1.0),
+    'colsample_bytree': hp.uniform('colsample_bytree', 0.6, 1.0),
+    'reg_alpha': hp.uniform('reg_alpha', 0.0, 1.0),
+    'reg_lambda': hp.uniform('reg_lambda', 0.0, 1.0)
+}
+
+
+def objective_func(search_space):
+    """하이퍼파라미터 최적화를 위한 목적 함수.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간
+        
+    Returns:
+        평균 CSI 점수의 음수값 (hyperopt는 최소화를 수행하므로)
+    """
+    lgb_model = create_lgb_model(search_space=search_space)
+    csi_scores = []
+
+    # 각 fold에 대해 교차 검증 수행
+    for df_ctgan, (train_years, val_year) in zip(df_ctgan_list, FOLD_CONFIGS):
+        X_train, X_val, y_train, y_val = split_data(
+            df_ctgan, df_gwangju, train_years, val_year
+        )
+        
+        lgb_model.fit(
+            X_train, y_train,
+            eval_set=[(X_val, y_val)],
+            eval_metric=csi_metric
+        )
+        
+        csi = calculate_csi(y_val, lgb_model.predict(X_val))
+        csi_scores.append(csi)
+
+    # 평균 CSI의 음수값 반환 (hyperopt는 최소화를 수행)
+    return -1 * round(np.mean(csi_scores), 4)
+
+
+# 하이퍼파라미터 최적화
+print("하이퍼파라미터 최적화 시작...")
+trials = Trials()
+lgb_best = fmin(
+    fn=objective_func,
+    space=lgb_search_space,
+    algo=tpe.suggest,
+    max_evals=MAX_EVALS,
+    trials=trials
+)
+
+# 최적화 결과 분석 및 출력
+print(f"\n최적화 완료. 최적 파라미터: {lgb_best}")
+
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+import os
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_ctgan10000_gwangju_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습
+print("최종 모델 학습 시작...")
+models = []
+
+for fold_idx, (df_ctgan, (train_years, val_year)) in enumerate(
+    zip(df_ctgan_list, FOLD_CONFIGS), start=1
+):
+    print(f"Fold {fold_idx} 학습 중... (학습 연도: {train_years}, 검증 연도: {val_year})")
+    
+    X_train, X_val, y_train, y_val = split_data(
+        df_ctgan, df_gwangju, train_years, val_year
+    )
+    
+    lgb_model = create_lgb_model(best_params=lgb_best)
+    lgb_model.fit(X_train, y_train, eval_set=[(X_val, y_val)])
+    
+    # 검증 성능 출력
+    val_csi = calculate_csi(y_val, lgb_model.predict(X_val))
+    print(f"Fold {fold_idx} 검증 CSI: {val_csi:.4f}")
+    
+    models.append(lgb_model)
+
+# 모델 저장
+print("모델 저장 중...")
+model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_ctgan10000_gwangju.pkl")
+joblib.dump(models, model_save_path)
+print(f"모델이 {model_save_path}에 저장되었습니다.")
+

Analysis_code/5.optima/lgb_ctgan10000/LGB_ctgan10000_incheon.py

@@ -0,0 +1,317 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from warnings import filterwarnings
+from sklearn.metrics import confusion_matrix
+from lightgbm import LGBMClassifier
+from hyperopt import fmin, tpe, Trials, hp
+
+filterwarnings('ignore')
+
+# 상수 정의
+RANDOM_STATE = 42
+N_ESTIMATORS = 4000
+EARLY_STOPPING_ROUNDS = 400
+MAX_EVALS = 100
+DEVICE = 'gpu'
+OBJECTIVE = 'multiclassova'
+
+# Fold 설정: (train_years, val_year)
+FOLD_CONFIGS = [
+    ([2018, 2019], 2020),  # Fold 1
+    ([2018, 2020], 2019),  # Fold 2
+    ([2019, 2020], 2018),  # Fold 3
+]
+
+def calculate_csi(y_true, y_pred):
+    """CSI(Critical Success Index) 점수를 계산합니다.
+    
+    Args:
+        y_true: 실제 레이블
+        y_pred: 예측 레이블
+        
+    Returns:
+        CSI 점수 (0~1 사이의 값)
+    """
+    cm = confusion_matrix(y_true, y_pred)
+    
+    # 혼동 행렬에서 H(Hit), F(False alarm), M(Miss) 추출
+    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 csi_metric(y_true, pred_prob):
+    """LightGBM용 CSI 메트릭 함수.
+    
+    Args:
+        y_true: 실제 레이블
+        pred_prob: 예측 확률 (shape: [n_samples, n_classes])
+        
+    Returns:
+        ('CSI', score, higher_better) 튜플
+    """
+    y_pred_binary = np.argmax(pred_prob, axis=1)
+    score = calculate_csi(y_true, y_pred_binary)
+    return 'CSI', score, 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 split_data(df_sampled, df_original, train_years, val_year):
+    """데이터를 학습용과 검증용으로 분할합니다.
+    
+    Args:
+        df_sampled: 샘플링된 데이터프레임
+        df_original: 원본 데이터프레임
+        train_years: 학습에 사용할 연도 리스트
+        val_year: 검증에 사용할 연도
+        
+    Returns:
+        (X_train, X_val, y_train, y_val) 튜플
+    """
+    # 학습 데이터: 샘플링된 데이터에서 train_years에 해당하는 데이터
+    train_mask = df_sampled['year'].isin(train_years)
+    X_train = df_sampled.loc[train_mask, df_sampled.columns != 'multi_class'].copy()
+    y_train = df_sampled.loc[train_mask, 'multi_class']
+    
+    # 검증 데이터: 원본 데이터에서 val_year에 해당하는 데이터
+    val_mask = df_original['year'] == val_year
+    X_val = df_original.loc[val_mask, df_original.columns != 'multi_class'].copy()
+    y_val = df_original.loc[val_mask, 'multi_class']
+    
+    # 'year' 컬럼 제거
+    X_train = X_train.drop(columns=['year'])
+    X_val = X_val.drop(columns=['year'])
+    
+    return X_train, X_val, y_train, y_val
+
+
+def create_lgb_model(search_space=None, best_params=None):
+    """LightGBM 모델을 생성합니다.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간 (objective_func에서 사용)
+        best_params: 최적화된 하이퍼파라미터 (최종 모델 학습에서 사용)
+        
+    Returns:
+        LGBMClassifier 인스턴스
+    """
+    base_params = {
+        'n_estimators': N_ESTIMATORS,
+        'device': DEVICE,
+        'objective': OBJECTIVE,
+        'random_state': RANDOM_STATE,
+        'early_stopping_rounds': EARLY_STOPPING_ROUNDS,
+        'verbose': -1,
+    }
+    
+    if search_space is not None:
+        # 하이퍼파라미터 최적화 중
+        params = {
+            **base_params,
+            'learning_rate': search_space['learning_rate'],
+            'max_depth': int(search_space['max_depth']),
+            'num_leaves': int(search_space['num_leaves']),
+            'min_child_weight': int(search_space['min_child_weight']),
+            'subsample': search_space['subsample'],
+            'colsample_bytree': search_space['colsample_bytree'],
+            'reg_alpha': search_space['reg_alpha'],
+            'reg_lambda': search_space['reg_lambda'],
+        }
+    elif best_params is not None:
+        # 최적화된 파라미터로 최종 모델 생성
+        params = {
+            **base_params,
+            'learning_rate': best_params['learning_rate'],
+            'max_depth': int(best_params['max_depth']),
+            'num_leaves': int(best_params['num_leaves']),
+            'min_child_weight': int(best_params['min_child_weight']),
+            'subsample': best_params['subsample'],
+            'colsample_bytree': best_params['colsample_bytree'],
+            'reg_alpha': best_params['reg_alpha'],
+            'reg_lambda': best_params['reg_lambda'],
+        }
+    else:
+        params = base_params
+    
+    return LGBMClassifier(**params)
+
+# 데이터 로딩
+print("데이터 로딩 중...")
+# 파일 위치 기반으로 데이터 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+df_incheon = pd.read_csv(os.path.join(data_base_dir, "data_for_modeling/incheon_train.csv"))
+df_ctgan_incheon_1 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_1_incheon.csv"))
+df_ctgan_incheon_2 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_2_incheon.csv"))
+df_ctgan_incheon_3 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_3_incheon.csv"))
+
+# 데이터 전처리
+print("데이터 전처리 중...")
+df_ctgan_incheon_1 = preprocessing(df_ctgan_incheon_1)
+df_ctgan_incheon_2 = preprocessing(df_ctgan_incheon_2)
+df_ctgan_incheon_3 = preprocessing(df_ctgan_incheon_3)
+df_incheon = preprocessing(df_incheon)
+
+# CTGAN 데이터 리스트 (fold 순서와 일치)
+df_ctgan_list = [df_ctgan_incheon_1, df_ctgan_incheon_2, df_ctgan_incheon_3]
+
+# 하이퍼파라미터 검색 공간 정의
+lgb_search_space = {
+    'learning_rate': hp.loguniform('learning_rate', np.log(0.01), np.log(0.2)),
+    'max_depth': hp.quniform('max_depth', 3, 15, 1),
+    'num_leaves': hp.quniform('num_leaves', 20, 150, 1),  # 2^max_depth 보다는 작게
+    'min_child_weight': hp.quniform('min_child_weight', 1, 20, 1),
+    'subsample': hp.uniform('subsample', 0.6, 1.0),
+    'colsample_bytree': hp.uniform('colsample_bytree', 0.6, 1.0),
+    'reg_alpha': hp.uniform('reg_alpha', 0.0, 1.0),
+    'reg_lambda': hp.uniform('reg_lambda', 0.0, 1.0)
+}
+
+
+def objective_func(search_space):
+    """하이퍼파라미터 최적화를 위한 목적 함수.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간
+        
+    Returns:
+        평균 CSI 점수의 음수값 (hyperopt는 최소화를 수행하므로)
+    """
+    lgb_model = create_lgb_model(search_space=search_space)
+    csi_scores = []
+
+    # 각 fold에 대해 교차 검증 수행
+    for df_ctgan, (train_years, val_year) in zip(df_ctgan_list, FOLD_CONFIGS):
+        X_train, X_val, y_train, y_val = split_data(
+            df_ctgan, df_incheon, train_years, val_year
+        )
+        
+        lgb_model.fit(
+            X_train, y_train,
+            eval_set=[(X_val, y_val)],
+            eval_metric=csi_metric
+        )
+        
+        csi = calculate_csi(y_val, lgb_model.predict(X_val))
+        csi_scores.append(csi)
+
+    # 평균 CSI의 음수값 반환 (hyperopt는 최소화를 수행)
+    return -1 * round(np.mean(csi_scores), 4)
+
+
+# 하이퍼파라미터 최적화
+print("하이퍼파라미터 최적화 시작...")
+trials = Trials()
+lgb_best = fmin(
+    fn=objective_func,
+    space=lgb_search_space,
+    algo=tpe.suggest,
+    max_evals=MAX_EVALS,
+    trials=trials
+)
+
+# 최적화 결과 분석 및 출력
+print(f"\n최적화 완료. 최적 파라미터: {lgb_best}")
+
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+import os
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_ctgan10000_incheon_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습
+print("최종 모델 학습 시작...")
+models = []
+
+for fold_idx, (df_ctgan, (train_years, val_year)) in enumerate(
+    zip(df_ctgan_list, FOLD_CONFIGS), start=1
+):
+    print(f"Fold {fold_idx} 학습 중... (학습 연도: {train_years}, 검증 연도: {val_year})")
+    
+    X_train, X_val, y_train, y_val = split_data(
+        df_ctgan, df_incheon, train_years, val_year
+    )
+    
+    lgb_model = create_lgb_model(best_params=lgb_best)
+    lgb_model.fit(X_train, y_train, eval_set=[(X_val, y_val)])
+    
+    # 검증 성능 출력
+    val_csi = calculate_csi(y_val, lgb_model.predict(X_val))
+    print(f"Fold {fold_idx} 검증 CSI: {val_csi:.4f}")
+    
+    models.append(lgb_model)
+
+# 모델 저장
+print("모델 저장 중...")
+model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_ctgan10000_incheon.pkl")
+joblib.dump(models, model_save_path)
+print(f"모델이 {model_save_path}에 저장되었습니다.")
+

Analysis_code/5.optima/lgb_ctgan10000/LGB_ctgan10000_seoul.py

@@ -0,0 +1,317 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from warnings import filterwarnings
+from sklearn.metrics import confusion_matrix
+from lightgbm import LGBMClassifier
+from hyperopt import fmin, tpe, Trials, hp
+
+filterwarnings('ignore')
+
+# 상수 정의
+RANDOM_STATE = 42
+N_ESTIMATORS = 4000
+EARLY_STOPPING_ROUNDS = 400
+MAX_EVALS = 100
+DEVICE = 'gpu'
+OBJECTIVE = 'multiclassova'
+
+# Fold 설정: (train_years, val_year)
+FOLD_CONFIGS = [
+    ([2018, 2019], 2020),  # Fold 1
+    ([2018, 2020], 2019),  # Fold 2
+    ([2019, 2020], 2018),  # Fold 3
+]
+
+def calculate_csi(y_true, y_pred):
+    """CSI(Critical Success Index) 점수를 계산합니다.
+    
+    Args:
+        y_true: 실제 레이블
+        y_pred: 예측 레이블
+        
+    Returns:
+        CSI 점수 (0~1 사이의 값)
+    """
+    cm = confusion_matrix(y_true, y_pred)
+    
+    # 혼동 행렬에서 H(Hit), F(False alarm), M(Miss) 추출
+    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 csi_metric(y_true, pred_prob):
+    """LightGBM용 CSI 메트릭 함수.
+    
+    Args:
+        y_true: 실제 레이블
+        pred_prob: 예측 확률 (shape: [n_samples, n_classes])
+        
+    Returns:
+        ('CSI', score, higher_better) 튜플
+    """
+    y_pred_binary = np.argmax(pred_prob, axis=1)
+    score = calculate_csi(y_true, y_pred_binary)
+    return 'CSI', score, 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 split_data(df_sampled, df_original, train_years, val_year):
+    """데이터를 학습용과 검증용으로 분할합니다.
+    
+    Args:
+        df_sampled: 샘플링된 데이터프레임
+        df_original: 원본 데이터프레임
+        train_years: 학습에 사용할 연도 리스트
+        val_year: 검증에 사용할 연도
+        
+    Returns:
+        (X_train, X_val, y_train, y_val) 튜플
+    """
+    # 학습 데이터: 샘플링된 데이터에서 train_years에 해당하는 데이터
+    train_mask = df_sampled['year'].isin(train_years)
+    X_train = df_sampled.loc[train_mask, df_sampled.columns != 'multi_class'].copy()
+    y_train = df_sampled.loc[train_mask, 'multi_class']
+    
+    # 검증 데이터: 원본 데이터에서 val_year에 해당하는 데이터
+    val_mask = df_original['year'] == val_year
+    X_val = df_original.loc[val_mask, df_original.columns != 'multi_class'].copy()
+    y_val = df_original.loc[val_mask, 'multi_class']
+    
+    # 'year' 컬럼 제거
+    X_train = X_train.drop(columns=['year'])
+    X_val = X_val.drop(columns=['year'])
+    
+    return X_train, X_val, y_train, y_val
+
+
+def create_lgb_model(search_space=None, best_params=None):
+    """LightGBM 모델을 생성합니다.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간 (objective_func에서 사용)
+        best_params: 최적화된 하이퍼파라미터 (최종 모델 학습에서 사용)
+        
+    Returns:
+        LGBMClassifier 인스턴스
+    """
+    base_params = {
+        'n_estimators': N_ESTIMATORS,
+        'device': DEVICE,
+        'objective': OBJECTIVE,
+        'random_state': RANDOM_STATE,
+        'early_stopping_rounds': EARLY_STOPPING_ROUNDS,
+        'verbose': -1,
+    }
+    
+    if search_space is not None:
+        # 하이퍼파라미터 최적화 중
+        params = {
+            **base_params,
+            'learning_rate': search_space['learning_rate'],
+            'max_depth': int(search_space['max_depth']),
+            'num_leaves': int(search_space['num_leaves']),
+            'min_child_weight': int(search_space['min_child_weight']),
+            'subsample': search_space['subsample'],
+            'colsample_bytree': search_space['colsample_bytree'],
+            'reg_alpha': search_space['reg_alpha'],
+            'reg_lambda': search_space['reg_lambda'],
+        }
+    elif best_params is not None:
+        # 최적화된 파라미터로 최종 모델 생성
+        params = {
+            **base_params,
+            'learning_rate': best_params['learning_rate'],
+            'max_depth': int(best_params['max_depth']),
+            'num_leaves': int(best_params['num_leaves']),
+            'min_child_weight': int(best_params['min_child_weight']),
+            'subsample': best_params['subsample'],
+            'colsample_bytree': best_params['colsample_bytree'],
+            'reg_alpha': best_params['reg_alpha'],
+            'reg_lambda': best_params['reg_lambda'],
+        }
+    else:
+        params = base_params
+    
+    return LGBMClassifier(**params)
+
+# 데이터 로딩
+print("데이터 로딩 중...")
+# 파일 위치 기반으로 데이터 디렉토리 경로 설정
+current_file_dir = os.path.dirname(os.path.abspath(__file__))
+data_base_dir = os.path.abspath(os.path.join(current_file_dir, '../../../data'))
+df_seoul = pd.read_csv(os.path.join(data_base_dir, "data_for_modeling/seoul_train.csv"))
+df_ctgan_seoul_1 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_1_seoul.csv"))
+df_ctgan_seoul_2 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_2_seoul.csv"))
+df_ctgan_seoul_3 = pd.read_csv(os.path.join(data_base_dir, "data_oversampled/ctgan10000/ctgan10000_3_seoul.csv"))
+
+# 데이터 전처리
+print("데이터 전처리 중...")
+df_ctgan_seoul_1 = preprocessing(df_ctgan_seoul_1)
+df_ctgan_seoul_2 = preprocessing(df_ctgan_seoul_2)
+df_ctgan_seoul_3 = preprocessing(df_ctgan_seoul_3)
+df_seoul = preprocessing(df_seoul)
+
+# CTGAN 데이터 리스트 (fold 순서와 일치)
+df_ctgan_list = [df_ctgan_seoul_1, df_ctgan_seoul_2, df_ctgan_seoul_3]
+
+# 하이퍼파라미터 검색 공간 정의
+lgb_search_space = {
+    'learning_rate': hp.loguniform('learning_rate', np.log(0.01), np.log(0.2)),
+    'max_depth': hp.quniform('max_depth', 3, 15, 1),
+    'num_leaves': hp.quniform('num_leaves', 20, 150, 1),  # 2^max_depth 보다는 작게
+    'min_child_weight': hp.quniform('min_child_weight', 1, 20, 1),
+    'subsample': hp.uniform('subsample', 0.6, 1.0),
+    'colsample_bytree': hp.uniform('colsample_bytree', 0.6, 1.0),
+    'reg_alpha': hp.uniform('reg_alpha', 0.0, 1.0),
+    'reg_lambda': hp.uniform('reg_lambda', 0.0, 1.0)
+}
+
+
+def objective_func(search_space):
+    """하이퍼파라미터 최적화를 위한 목적 함수.
+    
+    Args:
+        search_space: 하이퍼파라미터 검색 공간
+        
+    Returns:
+        평균 CSI 점수의 음수값 (hyperopt는 최소화를 수행하므로)
+    """
+    lgb_model = create_lgb_model(search_space=search_space)
+    csi_scores = []
+
+    # 각 fold에 대해 교차 검증 수행
+    for df_ctgan, (train_years, val_year) in zip(df_ctgan_list, FOLD_CONFIGS):
+        X_train, X_val, y_train, y_val = split_data(
+            df_ctgan, df_seoul, train_years, val_year
+        )
+        
+        lgb_model.fit(
+            X_train, y_train,
+            eval_set=[(X_val, y_val)],
+            eval_metric=csi_metric
+        )
+        
+        csi = calculate_csi(y_val, lgb_model.predict(X_val))
+        csi_scores.append(csi)
+
+    # 평균 CSI의 음수값 반환 (hyperopt는 최소화를 수행)
+    return -1 * round(np.mean(csi_scores), 4)
+
+
+# 하이퍼파라미터 최적화
+print("하이퍼파라미터 최적화 시작...")
+trials = Trials()
+lgb_best = fmin(
+    fn=objective_func,
+    space=lgb_search_space,
+    algo=tpe.suggest,
+    max_evals=MAX_EVALS,
+    trials=trials
+)
+
+# 최적화 결과 분석 및 출력
+print(f"\n최적화 완료. 최적 파라미터: {lgb_best}")
+
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+import os
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_ctgan10000_seoul_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
+# 최적화된 하이퍼파라미터로 최종 모델 학습
+print("최종 모델 학습 시작...")
+models = []
+
+for fold_idx, (df_ctgan, (train_years, val_year)) in enumerate(
+    zip(df_ctgan_list, FOLD_CONFIGS), start=1
+):
+    print(f"Fold {fold_idx} 학습 중... (학습 연도: {train_years}, 검증 연도: {val_year})")
+    
+    X_train, X_val, y_train, y_val = split_data(
+        df_ctgan, df_seoul, train_years, val_year
+    )
+    
+    lgb_model = create_lgb_model(best_params=lgb_best)
+    lgb_model.fit(X_train, y_train, eval_set=[(X_val, y_val)])
+    
+    # 검증 성능 출력
+    val_csi = calculate_csi(y_val, lgb_model.predict(X_val))
+    print(f"Fold {fold_idx} 검증 CSI: {val_csi:.4f}")
+    
+    models.append(lgb_model)
+
+# 모델 저장
+print("모델 저장 중...")
+model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_ctgan10000_seoul.pkl")
+joblib.dump(models, model_save_path)
+print(f"모델이 {model_save_path}에 저장되었습니다.")
+

Analysis_code/5.optima/lgb_pure/LGB_pure_daegu.py

@@ -271,6 +271,7 @@ print(f"  - 최저 CSI: {min(csi_scores):.4f}")
 print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
 
 # Trials 객체 저장
+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)
 trials_path = os.path.join(base_dir, "optimization_history/lgb_pure_daegu_trials.pkl")
 joblib.dump(trials, trials_path)

Analysis_code/5.optima/lgb_pure/LGB_pure_daejeon.py

@@ -271,6 +271,7 @@ print(f"  - 최저 CSI: {min(csi_scores):.4f}")
 print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
 
 # Trials 객체 저장
+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)
 trials_path = os.path.join(base_dir, "optimization_history/lgb_pure_daejeon_trials.pkl")
 joblib.dump(trials, trials_path)

Analysis_code/5.optima/lgb_pure/LGB_pure_gwangju.py

@@ -271,6 +271,7 @@ print(f"  - 최저 CSI: {min(csi_scores):.4f}")
 print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
 
 # Trials 객체 저장
+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)
 trials_path = os.path.join(base_dir, "optimization_history/lgb_pure_gwangju_trials.pkl")
 joblib.dump(trials, trials_path)

Analysis_code/5.optima/lgb_pure/LGB_pure_incheon.py

@@ -271,6 +271,7 @@ print(f"  - 최저 CSI: {min(csi_scores):.4f}")
 print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
 
 # Trials 객체 저장
+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)
 trials_path = os.path.join(base_dir, "optimization_history/lgb_pure_incheon_trials.pkl")
 joblib.dump(trials, trials_path)

Analysis_code/5.optima/lgb_pure/LGB_pure_seoul.py

@@ -271,6 +271,7 @@ print(f"  - 최저 CSI: {min(csi_scores):.4f}")
 print(f"  - 평균 CSI: {np.mean(csi_scores):.4f}")
 
 # Trials 객체 저장
+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)
 trials_path = os.path.join(base_dir, "optimization_history/lgb_pure_seoul_trials.pkl")
 joblib.dump(trials, trials_path)

Analysis_code/5.optima/lgb_smote/LGB_smote_busan.py

@@ -259,6 +259,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smote_busan_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []
@@ -283,6 +308,7 @@ for fold_idx, (df_smote, (train_years, val_year)) in enumerate(
 
 # 모델 저장
 print("모델 저장 중...")
+base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
 model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_smote_busan.pkl")
 joblib.dump(models, model_save_path)
 print(f"모델이 {model_save_path}에 저장되었습니다.")

Analysis_code/5.optima/lgb_smote/LGB_smote_daegu.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smote_daegu_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []
@@ -284,6 +309,7 @@ for fold_idx, (df_smote, (train_years, val_year)) in enumerate(
 
 # 모델 저장
 print("모델 저장 중...")
+base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
 model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_smote_daegu.pkl")
 joblib.dump(models, model_save_path)
 print(f"모델이 {model_save_path}에 저장되었습니다.")

Analysis_code/5.optima/lgb_smote/LGB_smote_daejeon.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smote_daejeon_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []
@@ -284,6 +309,7 @@ for fold_idx, (df_smote, (train_years, val_year)) in enumerate(
 
 # 모델 저장
 print("모델 저장 중...")
+base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
 model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_smote_daejeon.pkl")
 joblib.dump(models, model_save_path)
 print(f"모델이 {model_save_path}에 저장되었습니다.")

Analysis_code/5.optima/lgb_smote/LGB_smote_gwangju.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smote_gwangju_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []
@@ -284,6 +309,7 @@ for fold_idx, (df_smote, (train_years, val_year)) in enumerate(
 
 # 모델 저장
 print("모델 저장 중...")
+base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
 model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_smote_gwangju.pkl")
 joblib.dump(models, model_save_path)
 print(f"모델이 {model_save_path}에 저장되었습니다.")

Analysis_code/5.optima/lgb_smote/LGB_smote_incheon.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smote_incheon_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []
@@ -284,6 +309,7 @@ for fold_idx, (df_smote, (train_years, val_year)) in enumerate(
 
 # 모델 저장
 print("모델 저장 중...")
+base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
 model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_smote_incheon.pkl")
 joblib.dump(models, model_save_path)
 print(f"모델이 {model_save_path}에 저장되었습니다.")

Analysis_code/5.optima/lgb_smote/LGB_smote_seoul.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smote_seoul_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []
@@ -284,6 +309,7 @@ for fold_idx, (df_smote, (train_years, val_year)) in enumerate(
 
 # 모델 저장
 print("모델 저장 중...")
+base_dir = os.path.dirname(os.path.dirname(current_file_dir))  # 5.optima 디렉토리
 model_save_path = os.path.join(base_dir, "save_model/lgb_optima/lgb_smote_seoul.pkl")
 joblib.dump(models, model_save_path)
 print(f"모델이 {model_save_path}에 저장되었습니다.")

Analysis_code/5.optima/lgb_smotenc_ctgan20000/LGB_smotenc_ctgan20000_busan.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smotenc_ctgan20000_busan_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []

Analysis_code/5.optima/lgb_smotenc_ctgan20000/LGB_smotenc_ctgan20000_daegu.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smotenc_ctgan20000_daegu_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []

Analysis_code/5.optima/lgb_smotenc_ctgan20000/LGB_smotenc_ctgan20000_daejeon.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smotenc_ctgan20000_daejeon_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []

Analysis_code/5.optima/lgb_smotenc_ctgan20000/LGB_smotenc_ctgan20000_gwangju.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smotenc_ctgan20000_gwangju_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []

Analysis_code/5.optima/lgb_smotenc_ctgan20000/LGB_smotenc_ctgan20000_incheon.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smotenc_ctgan20000_incheon_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []

Analysis_code/5.optima/lgb_smotenc_ctgan20000/LGB_smotenc_ctgan20000_seoul.py

@@ -260,6 +260,31 @@ lgb_best = fmin(
 )
 print(f"최적화 완료. 최적 파라미터: {lgb_best}")
 
+# Best loss (CSI 점수의 음수값이므로, 실제 CSI는 -loss)
+best_loss = trials.best_trial['result']['loss']
+best_csi = -best_loss
+print(f"최적 CSI 점수: {best_csi:.4f} (loss: {best_loss:.4f})")
+
+# 모든 trial의 loss 값 추출
+losses = [trial['result']['loss'] for trial in trials.trials if trial['result']['status'] == 'ok']
+csi_scores = [-loss for loss in losses]
+
+print(f"\n최적화 과정 요약:")
+print(f"  - 총 시도 횟수: {len(trials.trials)}")
+print(f"  - 성공한 시도: {len(losses)}")
+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}")
+
+# Trials 객체 저장
+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)
+trials_path = os.path.join(base_dir, "optimization_history/lgb_smotenc_ctgan20000_seoul_trials.pkl")
+joblib.dump(trials, trials_path)
+print(f"\n최적화 Trials 객체가 {trials_path}에 저장되었습니다.")
+
 # 최적화된 하이퍼파라미터로 최종 모델 학습
 print("최종 모델 학습 시작...")
 models = []

Analysis_code/5.optima/resnet_like_ctgan10000/resnet_like_ctgan10000_daegu.py

@@ -0,0 +1,97 @@
+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="daegu", 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_daegu_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="daegu",
+        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/resnet_like_ctgan10000_daejeon.py

@@ -0,0 +1,97 @@
+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="daejeon", 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_daejeon_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="daejeon",
+        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/resnet_like_ctgan10000_gwangju.py

@@ -0,0 +1,97 @@
+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="gwangju", 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_gwangju_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="gwangju",
+        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/resnet_like_ctgan10000_incheon.py

@@ -0,0 +1,97 @@
+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="incheon", 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_incheon_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="incheon",
+        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/resnet_like_ctgan10000_seoul.py

@@ -0,0 +1,97 @@
+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="seoul", 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_seoul_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="seoul",
+        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/run_bash/deepgbm/run_deepgbm_ctgan10000.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+
+# 스크립트 디렉토리로 이동 (상위 디렉토리인 5.optima로 이동)
+cd "$(dirname "$0")/../.."
+
+# 시작 시간 기록
+START_TIME=$(date +%s)
+echo "=========================================="
+echo "DeepGBM CTGAN10000 파일 실행 시작"
+echo "시작 시간: $(date '+%Y-%m-%d %H:%M:%S')"
+echo "GPU: 0번 (CUDA_VISIBLE_DEVICES=0)"
+echo "=========================================="
+echo ""
+
+# 실행할 파일 목록
+FILES=(
+    "deepgbm_ctgan10000_busan.py"
+    "deepgbm_ctgan10000_daegu.py"
+    "deepgbm_ctgan10000_daejeon.py"
+    "deepgbm_ctgan10000_gwangju.py"
+    "deepgbm_ctgan10000_incheon.py"
+    "deepgbm_ctgan10000_seoul.py"
+)
+
+# 에러 발생 시 중단 여부 (set -e를 사용하면 에러 발생 시 즉시 중단)
+set -e
+
+# 각 파일 실행
+SUCCESS_COUNT=0
+FAIL_COUNT=0
+
+for file in "${FILES[@]}"; do
+    filepath="deepgbm_ctgan10000/$file"
+    if [ ! -f "$filepath" ]; then
+        echo "⚠️  경고: $filepath 파일을 찾을 수 없습니다. 건너뜁니다."
+        FAIL_COUNT=$((FAIL_COUNT + 1))
+        continue
+    fi
+    
+    echo "----------------------------------------"
+    echo "실행 중: $filepath"
+    echo "시작 시간: $(date '+%Y-%m-%d %H:%M:%S')"
+    echo "----------------------------------------"
+    
+    FILE_START=$(date +%s)
+    
+    # Python 스크립트 실행 (GPU 0번 설정)
+    if CUDA_VISIBLE_DEVICES=0 python3 -u "$filepath"; then
+        FILE_END=$(date +%s)
+        FILE_DURATION=$((FILE_END - FILE_START))
+        echo ""
+        echo "✓ 완료: $filepath (소요 시간: ${FILE_DURATION}초)"
+        SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
+    else
+        FILE_END=$(date +%s)
+        FILE_DURATION=$((FILE_END - FILE_START))
+        echo ""
+        echo "✗ 실패: $filepath (소요 시간: ${FILE_DURATION}초)"
+        FAIL_COUNT=$((FAIL_COUNT + 1))
+        echo "에러 발생으로 인해 스크립트를 중단합니다."
+        exit 1
+    fi
+    echo ""
+done
+
+# 종료 시간 기록
+END_TIME=$(date +%s)
+TOTAL_DURATION=$((END_TIME - START_TIME))
+HOURS=$((TOTAL_DURATION / 3600))
+MINUTES=$(((TOTAL_DURATION % 3600) / 60))
+SECONDS=$((TOTAL_DURATION % 60))
+
+echo "=========================================="
+echo "DeepGBM CTGAN10000 파일 실행 완료"
+echo "종료 시간: $(date '+%Y-%m-%d %H:%M:%S')"
+echo "총 소요 시간: ${HOURS}시간 ${MINUTES}분 ${SECONDS}초"
+echo "성공: ${SUCCESS_COUNT}개"
+echo "실패: ${FAIL_COUNT}개"
+echo "=========================================="
+

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

@@ -0,0 +1,80 @@
+#!/bin/bash
+
+# 스크립트 디렉토리로 이동 (상위 디렉토리인 5.optima로 이동)
+cd "$(dirname "$0")/../.."
+
+# 시작 시간 기록
+START_TIME=$(date +%s)
+echo "=========================================="
+echo "FT-Transformer CTGAN10000 파일 실행 시작"
+echo "시작 시간: $(date '+%Y-%m-%d %H:%M:%S')"
+echo "GPU: 1번 (CUDA_VISIBLE_DEVICES=1)"
+echo "=========================================="
+echo ""
+
+# 실행할 파일 목록
+FILES=(
+    "ft_transformer_ctgan10000_busan.py"
+    "ft_transformer_ctgan10000_daegu.py"
+    "ft_transformer_ctgan10000_daejeon.py"
+    "ft_transformer_ctgan10000_gwangju.py"
+    "ft_transformer_ctgan10000_incheon.py"
+    "ft_transformer_ctgan10000_seoul.py"
+)
+
+# 에러 발생 시 중단 여부 (set -e를 사용하면 에러 발생 시 즉시 중단)
+set -e
+
+# 각 파일 실행
+SUCCESS_COUNT=0
+FAIL_COUNT=0
+
+for file in "${FILES[@]}"; do
+    filepath="ft_transformer_ctgan10000/$file"
+    if [ ! -f "$filepath" ]; then
+        echo "⚠️  경고: $filepath 파일을 찾을 수 없습니다. 건너뜁니다."
+        FAIL_COUNT=$((FAIL_COUNT + 1))
+        continue
+    fi
+    
+    echo "----------------------------------------"
+    echo "실행 중: $filepath"
+    echo "시작 시간: $(date '+%Y-%m-%d %H:%M:%S')"
+    echo "----------------------------------------"
+    
+    FILE_START=$(date +%s)
+    
+    # Python 스크립트 실행 (GPU 1번 설정, 색상 코드 비활성화)
+    if NO_COLOR=1 TERM=dumb CUDA_VISIBLE_DEVICES=1 python3 -u "$filepath"; then
+        FILE_END=$(date +%s)
+        FILE_DURATION=$((FILE_END - FILE_START))
+        echo ""
+        echo "✓ 완료: $filepath (소요 시간: ${FILE_DURATION}초)"
+        SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
+    else
+        FILE_END=$(date +%s)
+        FILE_DURATION=$((FILE_END - FILE_START))
+        echo ""
+        echo "✗ 실패: $filepath (소요 시간: ${FILE_DURATION}초)"
+        FAIL_COUNT=$((FAIL_COUNT + 1))
+        echo "에러 발생으로 인해 스크립트를 중단합니다."
+        exit 1
+    fi
+    echo ""
+done
+
+# 종료 시간 기록
+END_TIME=$(date +%s)
+TOTAL_DURATION=$((END_TIME - START_TIME))
+HOURS=$((TOTAL_DURATION / 3600))
+MINUTES=$(((TOTAL_DURATION % 3600) / 60))
+SECONDS=$((TOTAL_DURATION % 60))
+
+echo "=========================================="
+echo "FT-Transformer CTGAN10000 파일 실행 완료"
+echo "종료 시간: $(date '+%Y-%m-%d %H:%M:%S')"
+echo "총 소요 시간: ${HOURS}시간 ${MINUTES}분 ${SECONDS}초"
+echo "성공: ${SUCCESS_COUNT}개"
+echo "실패: ${FAIL_COUNT}개"
+echo "=========================================="
+

Analysis_code/5.optima/run_bash/lgb/lgb_ctgan10000.log

@@ -0,0 +1,219 @@
+nohup: ignoring input
+/bin/bash: /opt/conda/lib/libtinfo.so.6: no version information available (required by /bin/bash)
+==========================================
+LGB CTGAN10000 파일 실행 시작
+시작 시간: 2025-12-28 04:29:39
+GPU: 1번 (CUDA_VISIBLE_DEVICES=1)
+==========================================
+
+----------------------------------------
+실행 중: lgb_ctgan10000/LGB_ctgan10000_busan.py
+시작 시간: 2025-12-28 04:29:39
+----------------------------------------
+데이터 로딩 중...
+데이터 전처리 중...
+하이퍼파라미터 최적화 시작...
+
  0%|          | 0/100 [00:00<?, ?trial/s, best loss=?]
  1%|          | 1/100 [01:04<1:47:14, 65.00s/trial, best loss: -0.4238]
  2%|▏         | 2/100 [01:54<1:31:25, 55.98s/trial, best loss: -0.4576]
  3%|▎         | 3/100 [02:31<1:16:36, 47.39s/trial, best loss: -0.4733]
  4%|▍         | 4/100 [03:21<1:17:24, 48.38s/trial, best loss: -0.4758]
  5%|▌         | 5/100 [04:00<1:10:52, 44.77s/trial, best loss: -0.4758]
  6%|▌         | 6/100 [04:24<59:01, 37.68s/trial, best loss: -0.4758]  
  7%|▋         | 7/100 [04:54<54:54, 35.42s/trial, best loss: -0.4758]
  8%|▊         | 8/100 [05:41<59:49, 39.02s/trial, best loss: -0.4758]
  9%|▉         | 9/100 [06:04<51:22, 33.87s/trial, best loss: -0.4758]
 10%|█         | 10/100 [06:52<57:39, 38.44s/trial, best loss: -0.4758]
 11%|█         | 11/100 [07:30<56:39, 38.20s/trial, best loss: -0.4835]
 12%|█▏        | 12/100 [08:01<52:39, 35.90s/trial, best loss: -0.4835]
 13%|█▎        | 13/100 [08:23<46:16, 31.91s/trial, best loss: -0.4835]
 14%|█▍        | 14/100 [08:46<41:36, 29.03s/trial, best loss: -0.4835]
 15%|█▌        | 15/100 [09:24<44:58, 31.74s/trial, best loss: -0.4835]
 16%|█▌        | 16/100 [10:12<51:30, 36.80s/trial, best loss: -0.4835]
 17%|█▋        | 17/100 [10:47<50:13, 36.30s/trial, best loss: -0.4835]
 18%|█▊        | 18/100 [11:15<46:03, 33.70s/trial, best loss: -0.4835]
 19%|█▉        | 19/100 [11:52<46:41, 34.58s/trial, best loss: -0.4835]
 20%|██        | 20/100 [12:13<40:56, 30.71s/trial, best loss: -0.4835]
 21%|██        | 21/100 [12:44<40:26, 30.71s/trial, best loss: -0.4835]
 22%|██▏       | 22/100 [13:14<39:43, 30.56s/trial, best loss: -0.4836]
 23%|██▎       | 23/100 [13:40<37:14, 29.02s/trial, best loss: -0.4836]
 24%|██▍       | 24/100 [14:23<42:05, 33.24s/trial, best loss: -0.4836]
 25%|██▌       | 25/100 [14:53<40:20, 32.27s/trial, best loss: -0.4836]
 26%|██▌       | 26/100 [15:18<37:18, 30.25s/trial, best loss: -0.4836]
 27%|██▋       | 27/100 [15:47<36:22, 29.90s/trial, best loss: -0.4836]
 28%|██▊       | 28/100 [16:40<44:02, 36.70s/trial, best loss: -0.4836]
 29%|██▉       | 29/100 [17:20<44:27, 37.57s/trial, best loss: -0.4836]
 30%|███       | 30/100 [18:02<45:34, 39.06s/trial, best loss: -0.4836]
 31%|███       | 31/100 [18:26<39:34, 34.42s/trial, best loss: -0.4836]
 32%|███▏      | 32/100 [19:00<39:06, 34.51s/trial, best loss: -0.4836]
 33%|███▎      | 33/100 [19:37<39:24, 35.29s/trial, best loss: -0.4836]
 34%|███▍      | 34/100 [20:20<41:17, 37.54s/trial, best loss: -0.4836]
 35%|███▌      | 35/100 [20:46<36:49, 33.99s/trial, best loss: -0.4836]
 36%|███▌      | 36/100 [21:42<43:21, 40.65s/trial, best loss: -0.4836]
 37%|███▋      | 37/100 [22:19<41:21, 39.38s/trial, best loss: -0.4836]
 38%|███▊      | 38/100 [23:07<43:38, 42.23s/trial, best loss: -0.4836]
 39%|███▉      | 39/100 [23:30<36:47, 36.19s/trial, best loss: -0.4836]
 40%|████      | 40/100 [24:00<34:29, 34.49s/trial, best loss: -0.4836]
 41%|████      | 41/100 [24:30<32:32, 33.10s/trial, best loss: -0.4836]
 42%|████▏     | 42/100 [24:56<29:53, 30.93s/trial, best loss: -0.4836]
 43%|████▎     | 43/100 [25:27<29:21, 30.90s/trial, best loss: -0.4836]
 44%|████▍     | 44/100 [25:50<26:44, 28.65s/trial, best loss: -0.4836]
 45%|████▌     | 45/100 [26:40<32:11, 35.13s/trial, best loss: -0.4836]
 46%|████▌     | 46/100 [27:16<31:53, 35.43s/trial, best loss: -0.4836]
 47%|████▋     | 47/100 [27:57<32:41, 37.01s/trial, best loss: -0.4836]
 48%|████▊     | 48/100 [28:48<35:47, 41.30s/trial, best loss: -0.4836]
 49%|████▉     | 49/100 [29:27<34:26, 40.53s/trial, best loss: -0.4836]
 50%|█████     | 50/100 [29:54<30:25, 36.51s/trial, best loss: -0.4836]
 51%|█████     | 51/100 [30:53<35:10, 43.06s/trial, best loss: -0.4836]
 52%|█████▏    | 52/100 [31:20<30:35, 38.24s/trial, best loss: -0.4836]
 53%|█████▎    | 53/100 [31:53<28:54, 36.90s/trial, best loss: -0.4836]
 54%|█████▍    | 54/100 [33:09<37:07, 48.43s/trial, best loss: -0.4836]
 55%|█████▌    | 55/100 [33:34<31:10, 41.56s/trial, best loss: -0.4836]
 56%|█████▌    | 56/100 [33:56<26:01, 35.48s/trial, best loss: -0.4836]
 57%|█████▋    | 57/100 [34:25<24:02, 33.54s/trial, best loss: -0.4836]
 58%|█████▊    | 58/100 [35:00<23:51, 34.09s/trial, best loss: -0.4836]
 59%|█████▉    | 59/100 [35:53<27:15, 39.88s/trial, best loss: -0.4836]
 60%|██████    | 60/100 [36:31<26:10, 39.26s/trial, best loss: -0.4836]
 61%|██████    | 61/100 [36:57<22:56, 35.30s/trial, best loss: -0.4836]
 62%|██████▏   | 62/100 [37:32<22:11, 35.04s/trial, best loss: -0.4836]
 63%|██████▎   | 63/100 [37:57<19:47, 32.11s/trial, best loss: -0.4836]
 64%|██████▍   | 64/100 [38:23<18:11, 30.33s/trial, best loss: -0.4836]
 65%|██████▌   | 65/100 [39:08<20:11, 34.62s/trial, best loss: -0.4836]
 66%|██████▌   | 66/100 [39:40<19:14, 33.96s/trial, best loss: -0.4836]
 67%|██████▋   | 67/100 [40:11<18:06, 32.93s/trial, best loss: -0.4836]
 68%|██████▊   | 68/100 [40:36<16:23, 30.74s/trial, best loss: -0.4836]
 69%|██████▉   | 69/100 [41:04<15:20, 29.70s/trial, best loss: -0.4836]
 70%|███████   | 70/100 [41:31<14:34, 29.15s/trial, best loss: -0.4836]
 71%|███████   | 71/100 [41:55<13:17, 27.51s/trial, best loss: -0.4836]
 72%|███████▏  | 72/100 [42:36<14:45, 31.64s/trial, best loss: -0.4836]
 73%|███████▎  | 73/100 [43:06<13:58, 31.06s/trial, best loss: -0.4836]
 74%|███████▍  | 74/100 [43:34<12:59, 29.97s/trial, best loss: -0.4836]
 75%|███████▌  | 75/100 [44:05<12:43, 30.53s/trial, best loss: -0.4836]
 76%|███████▌  | 76/100 [44:46<13:24, 33.52s/trial, best loss: -0.4836]
 77%|███████▋  | 77/100 [45:22<13:09, 34.35s/trial, best loss: -0.4836]
 78%|███████▊  | 78/100 [45:53<12:11, 33.24s/trial, best loss: -0.4836]
 79%|███████▉  | 79/100 [46:20<10:58, 31.38s/trial, best loss: -0.4836]
 80%|████████  | 80/100 [46:45<09:51, 29.59s/trial, best loss: -0.4836]
 81%|████████  | 81/100 [47:20<09:53, 31.23s/trial, best loss: -0.4836]
 82%|████████▏ | 82/100 [47:51<09:19, 31.11s/trial, best loss: -0.4836]
 83%|████████▎ | 83/100 [48:23<08:55, 31.49s/trial, best loss: -0.4836]
 84%|████████▍ | 84/100 [49:06<09:14, 34.66s/trial, best loss: -0.4836]
 85%|████████▌ | 85/100 [49:31<07:59, 31.94s/trial, best loss: -0.4836]
 86%|████████▌ | 86/100 [50:18<08:28, 36.32s/trial, best loss: -0.4836]
 87%|████████▋ | 87/100 [51:01<08:20, 38.50s/trial, best loss: -0.4836]
 88%|████████▊ | 88/100 [52:08<09:24, 47.02s/trial, best loss: -0.4836]
 89%|████████▉ | 89/100 [52:57<08:43, 47.60s/trial, best loss: -0.4836]
 90%|█████████ | 90/100 [53:37<07:31, 45.17s/trial, best loss: -0.4836]
 91%|█████████ | 91/100 [54:28<07:04, 47.18s/trial, best loss: -0.4836]
 92%|█████████▏| 92/100 [55:14<06:13, 46.70s/trial, best loss: -0.4836]
 93%|█████████▎| 93/100 [56:21<06:08, 52.71s/trial, best loss: -0.4836]
 94%|█████████▍| 94/100 [57:02<04:55, 49.27s/trial, best loss: -0.4836]
 95%|█████████▌| 95/100 [57:39<03:48, 45.62s/trial, best loss: -0.4836]
 96%|█████████▌| 96/100 [58:33<03:12, 48.15s/trial, best loss: -0.4836]
 97%|█████████▋| 97/100 [59:14<02:17, 45.95s/trial, best loss: -0.4836]
 98%|█████████▊| 98/100 [59:54<01:28, 44.22s/trial, best loss: -0.4836]
 99%|█████████▉| 99/100 [1:00:48<00:47, 47.12s/trial, best loss: -0.4836]
+
+최적화 완료. 최적 파라미터: {'colsample_bytree': 0.7243835590014314, 'learning_rate': 0.052472053724070156, 'max_depth': 15.0, 'min_child_weight': 9.0, 'num_leaves': 120.0, 'reg_alpha': 0.566895668532905, 'reg_lambda': 0.9659771198744264, 'subsample': 0.8425484904296862}
+최적 CSI 점수: 0.4836 (loss: -0.4836)
+
+최적화 과정 요약:
+  - 총 시도 횟수: 100
+  - 성공한 시도: 100
+  - 최초 CSI: 0.4238
+  - 최종 CSI: 0.4676
+  - 최고 CSI: 0.4836
+  - 최저 CSI: 0.4200
+  - 평균 CSI: 0.4700
+
+최적화 Trials 객체가 /workspace/visibility_prediction/Analysis_code/optimization_history/lgb_ctgan10000_busan_trials.pkl에 저장되었습니다.
+최종 모델 학습 시작...
+Fold 1 학습 중... (학습 연도: [2018, 2019], 검증 연도: 2020)
+Fold 1 검증 CSI: 0.3905
+Fold 2 학습 중... (학습 연도: [2018, 2020], 검증 연도: 2019)
+Fold 2 검증 CSI: 0.5044
+Fold 3 학습 중... (학습 연도: [2019, 2020], 검증 연도: 2018)
+Fold 3 검증 CSI: 0.4985
+모델 저장 중...
+모델이 /workspace/visibility_prediction/Analysis_code/save_model/lgb_optima/lgb_ctgan10000_busan.pkl에 저장되었습니다.
+
+✓ 완료: lgb_ctgan10000/LGB_ctgan10000_busan.py (소요 시간: 3720초)
+
+----------------------------------------
+실행 중: lgb_ctgan10000/LGB_ctgan10000_daegu.py
+시작 시간: 2025-12-28 05:31:39
+----------------------------------------
+데이터 로딩 중...
+데이터 전처리 중...
+하이퍼파라미터 최적화 시작...
+
  0%|          | 0/100 [00:00<?, ?trial/s, best loss=?]
  1%|          | 1/100 [00:18<31:06, 18.85s/trial, best loss: -0.3977]
  2%|▏         | 2/100 [00:59<52:04, 31.88s/trial, best loss: -0.4107]
  3%|▎         | 3/100 [01:25<46:42, 28.89s/trial, best loss: -0.4107]
  4%|▍         | 4/100 [02:15<59:36, 37.25s/trial, best loss: -0.4107]
  5%|▌         | 5/100 [02:48<56:54, 35.94s/trial, best loss: -0.4107]
  6%|▌         | 6/100 [03:16<52:00, 33.20s/trial, best loss: -0.4107]
  7%|▋         | 7/100 [04:01<57:30, 37.10s/trial, best loss: -0.4107]
  8%|▊         | 8/100 [04:43<58:56, 38.44s/trial, best loss: -0.4107]
  9%|▉         | 9/100 [05:10<52:53, 34.88s/trial, best loss: -0.4107]
 10%|█         | 10/100 [05:34<47:28, 31.65s/trial, best loss: -0.4107]
 11%|█         | 11/100 [06:25<55:28, 37.39s/trial, best loss: -0.4107]
 12%|█▏        | 12/100 [06:52<50:33, 34.47s/trial, best loss: -0.4107]
 13%|█▎        | 13/100 [07:15<44:44, 30.85s/trial, best loss: -0.4155]
 14%|█▍        | 14/100 [07:47<44:52, 31.31s/trial, best loss: -0.4155]
 15%|█▌        | 15/100 [08:10<40:45, 28.77s/trial, best loss: -0.4161]
 16%|█▌        | 16/100 [08:33<37:35, 26.85s/trial, best loss: -0.4161]
 17%|█▋        | 17/100 [09:15<43:36, 31.53s/trial, best loss: -0.4161]
 18%|█▊        | 18/100 [09:51<45:05, 32.99s/trial, best loss: -0.4161]
 19%|█▉        | 19/100 [10:14<40:11, 29.77s/trial, best loss: -0.4161]
 20%|██        | 20/100 [11:04<48:02, 36.03s/trial, best loss: -0.4161]
 21%|██        | 21/100 [11:25<41:14, 31.32s/trial, best loss: -0.4203]
 22%|██▏       | 22/100 [11:51<38:51, 29.89s/trial, best loss: -0.4203]
 23%|██▎       | 23/100 [12:16<36:18, 28.29s/trial, best loss: -0.4203]
 24%|██▍       | 24/100 [12:42<35:07, 27.72s/trial, best loss: -0.4203]
 25%|██▌       | 25/100 [13:04<32:21, 25.88s/trial, best loss: -0.4203]
 26%|██▌       | 26/100 [13:25<30:16, 24.54s/trial, best loss: -0.4203]
 27%|██▋       | 27/100 [13:46<28:42, 23.60s/trial, best loss: -0.4203]
 28%|██▊       | 28/100 [14:08<27:40, 23.06s/trial, best loss: -0.4203]
 29%|██▉       | 29/100 [14:33<27:46, 23.47s/trial, best loss: -0.4203]
 30%|███       | 30/100 [14:53<26:12, 22.46s/trial, best loss: -0.4207]
 31%|███       | 31/100 [15:14<25:33, 22.22s/trial, best loss: -0.4254]
 32%|███▏      | 32/100 [15:36<24:48, 21.90s/trial, best loss: -0.4254]
 33%|███▎      | 33/100 [15:57<24:20, 21.80s/trial, best loss: -0.4254]
 34%|███▍      | 34/100 [16:19<23:58, 21.79s/trial, best loss: -0.4254]
 35%|███▌      | 35/100 [16:47<25:30, 23.55s/trial, best loss: -0.4254]
 36%|███▌      | 36/100 [17:12<25:35, 24.00s/trial, best loss: -0.4254]
 37%|███▋      | 37/100 [17:34<24:35, 23.42s/trial, best loss: -0.4254]
 38%|███▊      | 38/100 [18:02<25:41, 24.86s/trial, best loss: -0.4254]
 39%|███▉      | 39/100 [18:24<24:19, 23.93s/trial, best loss: -0.4254]
 40%|████      | 40/100 [18:50<24:31, 24.52s/trial, best loss: -0.4254]
 41%|████      | 41/100 [19:17<25:04, 25.51s/trial, best loss: -0.4254]
 42%|████▏     | 42/100 [19:50<26:51, 27.78s/trial, best loss: -0.4254]
 43%|████▎     | 43/100 [20:16<25:36, 26.96s/trial, best loss: -0.4254]
 44%|████▍     | 44/100 [20:49<27:04, 29.00s/trial, best loss: -0.4254]
 45%|████▌     | 45/100 [21:07<23:36, 25.75s/trial, best loss: -0.4254]
 46%|████▌     | 46/100 [21:26<21:14, 23.60s/trial, best loss: -0.4254]
 47%|████▋     | 47/100 [21:49<20:41, 23.42s/trial, best loss: -0.4254]
 48%|████▊     | 48/100 [22:09<19:27, 22.45s/trial, best loss: -0.4254]
 49%|████▉     | 49/100 [23:08<28:18, 33.30s/trial, best loss: -0.4254]
 50%|█████     | 50/100 [23:33<25:45, 30.90s/trial, best loss: -0.4254]
 51%|█████     | 51/100 [23:54<22:51, 27.99s/trial, best loss: -0.4254]
 52%|█████▏    | 52/100 [24:46<28:08, 35.17s/trial, best loss: -0.4255]
 53%|█████▎    | 53/100 [25:19<26:54, 34.35s/trial, best loss: -0.4255]
 54%|█████▍    | 54/100 [26:00<27:54, 36.41s/trial, best loss: -0.4255]
 55%|█████▌    | 55/100 [26:52<30:51, 41.14s/trial, best loss: -0.4255]
 56%|█████▌    | 56/100 [27:21<27:32, 37.55s/trial, best loss: -0.4255]
 57%|█████▋    | 57/100 [27:54<25:48, 36.01s/trial, best loss: -0.4255]
 58%|█████▊    | 58/100 [28:38<27:00, 38.59s/trial, best loss: -0.4308]
 59%|█████▉    | 59/100 [29:22<27:21, 40.03s/trial, best loss: -0.4308]
 60%|██████    | 60/100 [29:55<25:16, 37.92s/trial, best loss: -0.4308]
 61%|██��███    | 61/100 [30:42<26:27, 40.70s/trial, best loss: -0.4308]
 62%|██████▏   | 62/100 [31:22<25:35, 40.40s/trial, best loss: -0.4308]
 63%|██████▎   | 63/100 [32:08<26:04, 42.29s/trial, best loss: -0.4308]
 64%|██████▍   | 64/100 [32:58<26:41, 44.49s/trial, best loss: -0.4308]
 65%|██████▌   | 65/100 [33:35<24:39, 42.28s/trial, best loss: -0.4308]
 66%|██████▌   | 66/100 [34:26<25:30, 45.01s/trial, best loss: -0.4308]
 67%|██████▋   | 67/100 [35:12<24:52, 45.21s/trial, best loss: -0.4308]
 68%|██████▊   | 68/100 [36:03<25:03, 47.00s/trial, best loss: -0.4308]
 69%|██████▉   | 69/100 [36:49<24:05, 46.63s/trial, best loss: -0.4308]
 70%|███████   | 70/100 [37:31<22:40, 45.35s/trial, best loss: -0.4308]
 71%|███████   | 71/100 [38:07<20:28, 42.35s/trial, best loss: -0.4308]
 72%|███████▏  | 72/100 [38:45<19:12, 41.15s/trial, best loss: -0.4308]
 73%|███████▎  | 73/100 [39:21<17:45, 39.48s/trial, best loss: -0.4308]
 74%|███████▍  | 74/100 [39:55<16:22, 37.80s/trial, best loss: -0.4308]
 75%|███████▌  | 75/100 [40:30<15:26, 37.07s/trial, best loss: -0.4308]
 76%|███████▌  | 76/100 [41:12<15:22, 38.43s/trial, best loss: -0.4308]
 77%|███████▋  | 77/100 [41:43<13:55, 36.31s/trial, best loss: -0.4308]
 78%|███████▊  | 78/100 [42:09<12:10, 33.21s/trial, best loss: -0.4308]
 79%|███████▉  | 79/100 [42:37<11:02, 31.57s/trial, best loss: -0.4308]
 80%|████████  | 80/100 [43:10<10:44, 32.23s/trial, best loss: -0.4308]
 81%|████████  | 81/100 [43:46<10:28, 33.10s/trial, best loss: -0.4308]
 82%|████████▏ | 82/100 [44:40<11:49, 39.44s/trial, best loss: -0.4317]
 83%|████████▎ | 83/100 [45:16<10:55, 38.57s/trial, best loss: -0.4317]
 84%|████████▍ | 84/100 [46:07<11:13, 42.10s/trial, best loss: -0.4317]
 85%|████████▌ | 85/100 [47:05<11:43, 46.91s/trial, best loss: -0.4317]
 86%|████████▌ | 86/100 [47:54<11:05, 47.51s/trial, best loss: -0.4317]
 87%|████████▋ | 87/100 [48:33<09:44, 44.98s/trial, best loss: -0.4317]
 88%|████████▊ | 88/100 [48:57<07:46, 38.87s/trial, best loss: -0.4317]
 89%|████████▉ | 89/100 [49:25<06:31, 35.56s/trial, best loss: -0.4317]
 90%|█████████ | 90/100 [50:23<07:01, 42.18s/trial, best loss: -0.4339]
 91%|█████████ | 91/100 [51:11<06:35, 43.97s/trial, best loss: -0.4339]
 92%|█████████▏| 92/100 [52:08<06:21, 47.75s/trial, best loss: -0.4339]
 93%|█████████▎| 93/100 [52:49<05:21, 45.99s/trial, best loss: -0.4339]
 94%|█████████▍| 94/100 [53:41<04:45, 47.66s/trial, best loss: -0.4339]
 95%|█████████▌| 95/100 [54:27<03:56, 47.24s/trial, best loss: -0.4339]
 96%|█████████▌| 96/100 [55:20<03:14, 48.75s/trial, best loss: -0.4339]
 97%|█████████▋| 97/100 [55:47<02:06, 42.27s/trial, best loss: -0.4339]
 98%|█████████▊| 98/100 [56:52<01:38, 49.05s/trial, best loss: -0.4339]
 99%|█████████▉| 99/100 [57:25<00:44, 44.40s/trial, best loss: -0.4339]
+
+최적화 완료. 최적 파라미터: {'colsample_bytree': 0.885595994008888, 'learning_rate': 0.010106842270671093, 'max_depth': 14.0, 'min_child_weight': 1.0, 'num_leaves': 122.0, 'reg_alpha': 0.12648188723964116, 'reg_lambda': 0.873682924904797, 'subsample': 0.7806598236159817}
+최적 CSI 점수: 0.4339 (loss: -0.4339)
+
+최적화 과정 요약:
+  - 총 시도 횟수: 100
+  - 성공한 시도: 100
+  - 최초 CSI: 0.3977
+  - 최종 CSI: 0.3974
+  - 최고 CSI: 0.4339
+  - 최저 CSI: 0.3802
+  - 평균 CSI: 0.4106
+
+최적화 Trials 객체가 /workspace/visibility_prediction/Analysis_code/optimization_history/lgb_ctgan10000_daegu_trials.pkl에 저장되었습니다.
+최종 모델 학습 시작...
+Fold 1 학습 중... (학습 연도: [2018, 2019], 검증 연도: 2020)
+Fold 1 검증 CSI: 0.4293
+Fold 2 학습 중... (학습 연도: [2018, 2020], 검증 연도: 2019)
+Fold 2 검증 CSI: 0.4656
+Fold 3 학습 중... (학습 연도: [2019, 2020], 검증 연도: 2018)
+Fold 3 검증 CSI: 0.3270
+모델 저장 중...
+모델이 /workspace/visibility_prediction/Analysis_code/save_model/lgb_optima/lgb_ctgan10000_daegu.pkl에 저장되었습니다.
+
+✓ 완료: lgb_ctgan10000/LGB_ctgan10000_daegu.py (소요 시간: 3538초)
+
+----------------------------------------
+실행 중: lgb_ctgan10000/LGB_ctgan10000_daejeon.py
+시작 시간: 2025-12-28 06:30:37
+----------------------------------------
+데이터 로딩 중...
+데이터 전처리 중...
+하��퍼파라미터 최적화 시작...
+
  0%|          | 0/100 [00:00<?, ?trial/s, best loss=?]
  1%|          | 1/100 [00:28<47:17, 28.66s/trial, best loss: -0.4792]
  2%|▏         | 2/100 [01:38<1:25:59, 52.65s/trial, best loss: -0.4833]
  3%|▎         | 3/100 [02:12<1:11:30, 44.23s/trial, best loss: -0.4833]
  4%|▍         | 4/100 [02:44<1:02:52, 39.29s/trial, best loss: -0.4833]
  5%|▌         | 5/100 [03:08<53:32, 33.81s/trial, best loss: -0.4833]  
  6%|▌         | 6/100 [03:41<52:46, 33.68s/trial, best loss: -0.4833]
  7%|▋         | 7/100 [04:23<56:25, 36.40s/trial, best loss: -0.4833]
  8%|▊         | 8/100 [05:32<1:11:34, 46.68s/trial, best loss: -0.4833]
  9%|▉         | 9/100 [06:02<1:02:47, 41.41s/trial, best loss: -0.4864]
 10%|█         | 10/100 [07:04<1:12:04, 48.05s/trial, best loss: -0.4864]
 11%|█         | 11/100 [07:31<1:01:24, 41.40s/trial, best loss: -0.4864]
 12%|█▏        | 12/100 [07:54<52:32, 35.82s/trial, best loss: -0.4864]  
 13%|█▎        | 13/100 [09:06<1:07:45, 46.72s/trial, best loss: -0.4878]
 14%|█▍        | 14/100 [09:35<59:23, 41.44s/trial, best loss: -0.4878]  
 15%|█▌        | 15/100 [10:15<58:02, 40.98s/trial, best loss: -0.4878]
 16%|█▌        | 16/100 [10:42<51:40, 36.91s/trial, best loss: -0.4878]
 17%|█▋        | 17/100 [11:16<49:36, 35.86s/trial, best loss: -0.4878]
 18%|█▊        | 18/100 [11:59<52:13, 38.21s/trial, best loss: -0.4878]
 19%|█▉        | 19/100 [12:54<58:10, 43.09s/trial, best loss: -0.4878]
 20%|██        | 20/100 [13:18<50:04, 37.56s/trial, best loss: -0.4878]
 21%|██        | 21/100 [14:05<53:03, 40.30s/trial, best loss: -0.4878]
 22%|██▏       | 22/100 [14:40<50:06, 38.54s/trial, best loss: -0.4878]
 23%|██▎       | 23/100 [15:37<56:52, 44.32s/trial, best loss: -0.4878]
 24%|██▍       | 24/100 [16:00<47:53, 37.81s/trial, best loss: -0.4878]
 25%|██▌       | 25/100 [17:12<1:00:06, 48.08s/trial, best loss: -0.4878]
 26%|██▌       | 26/100 [17:39<51:24, 41.69s/trial, best loss: -0.4878]  
 27%|██▋       | 27/100 [18:33<55:09, 45.34s/trial, best loss: -0.4878]
 28%|██▊       | 28/100 [19:15<53:28, 44.56s/trial, best loss: -0.4878]
 29%|██▉       | 29/100 [19:59<52:25, 44.30s/trial, best loss: -0.4878]
 30%|███       | 30/100 [20:24<44:59, 38.56s/trial, best loss: -0.4878]
 31%|███       | 31/100 [21:21<50:25, 43.84s/trial, best loss: -0.4878]
 32%|███▏      | 32/100 [22:25<56:51, 50.17s/trial, best loss: -0.4878]
 33%|███▎      | 33/100 [22:54<48:42, 43.62s/trial, best loss: -0.4878]
 34%|███▍      | 34/100 [23:21<42:43, 38.84s/trial, best loss: -0.4894]
 35%|███▌      | 35/100 [23:52<39:29, 36.46s/trial, best loss: -0.4894]
 36%|███▌      | 36/100 [24:14<34:09, 32.02s/trial, best loss: -0.4894]
 37%|███▋      | 37/100 [25:02<38:37, 36.79s/trial, best loss: -0.4894]
 38%|███▊      | 38/100 [25:30<35:24, 34.27s/trial, best loss: -0.4894]
 39%|███▉      | 39/100 [26:02<34:10, 33.62s/trial, best loss: -0.4894]
 40%|████      | 40/100 [26:31<31:57, 31.97s/trial, best loss: -0.4894]
 41%|████      | 41/100 [27:05<32:16, 32.82s/trial, best loss: -0.4894]
 42%|████▏     | 42/100 [27:45<33:44, 34.91s/trial, best loss: -0.4894]
 43%|████▎     | 43/100 [28:17<32:15, 33.95s/trial, best loss: -0.4894]
 44%|████▍     | 44/100 [28:50<31:28, 33.72s/trial, best loss: -0.4894]
 45%|████▌     | 45/100 [29:24<30:56, 33.75s/trial, best loss: -0.4894]
 46%|████▌     | 46/100 [30:01<31:23, 34.88s/trial, best loss: -0.4894]
 47%|████▋     | 47/100 [30:38<31:23, 35.54s/trial, best loss: -0.4894]
 48%|████▊     | 48/100 [31:05<28:20, 32.71s/trial, best loss: -0.4894]
 49%|████▉     | 49/100 [31:46<30:03, 35.36s/trial, best loss: -0.4894]
 50%|█████     | 50/100 [32:24<30:08, 36.17s/trial, best loss: -0.4894]
 51%|█████     | 51/100 [33:17<33:40, 41.24s/trial, best loss: -0.4894]
 52%|█████▏    | 52/100 [33:40<28:34, 35.72s/trial, best loss: -0.4894]
 53%|█████▎    | 53/100 [34:57<37:33, 47.95s/trial, best loss: -0.4894]
 54%|█████▍    | 54/100 [35:22<31:33, 41.17s/trial, best loss: -0.4894]
 55%|█████▌    | 55/100 [36:12<32:59, 43.98s/trial, best loss: -0.4894]
 56%|█████▌    | 56/100 [36:39<28:21, 38.67s/trial, best loss: -0.4894]
 57%|█████▋    | 57/100 [37:38<32:05, 44.79s/trial, best loss: -0.4894]
 58%|█████▊    | 58/100 [38:18<30:26, 43.49s/trial, best loss: -0.4894]
 59%|█████▉    | 59/100 [38:46<26:35, 38.90s/trial, best loss: -0.4894]
 60%|██████    | 60/100 [39:14<23:41, 35.55s/trial, best loss: -0.4894]
 61%|██████    | 61/100 [40:09<26:51, 41.32s/trial, best loss: -0.4894]
 62%|██████▏   | 62/100 [40:48<25:48, 40.76s/trial, best loss: -0.4894]
 63%|██████▎   | 63/100 [41:20<23:25, 37.97s/trial, best loss: -0.4894]
 64%|██████���   | 64/100 [41:54<22:03, 36.77s/trial, best loss: -0.4894]
 65%|██████▌   | 65/100 [42:27<20:53, 35.82s/trial, best loss: -0.4894]
 66%|██████▌   | 66/100 [43:12<21:46, 38.42s/trial, best loss: -0.4894]
 67%|██████▋   | 67/100 [43:46<20:25, 37.13s/trial, best loss: -0.4894]
 68%|██████▊   | 68/100 [44:18<19:00, 35.65s/trial, best loss: -0.4894]
 69%|██████▉   | 69/100 [44:52<18:09, 35.16s/trial, best loss: -0.4894]
 70%|███████   | 70/100 [45:42<19:50, 39.67s/trial, best loss: -0.4894]
 71%|███████   | 71/100 [46:24<19:24, 40.15s/trial, best loss: -0.4894]
 72%|███████▏  | 72/100 [46:52<17:05, 36.63s/trial, best loss: -0.4901]
 73%|███████▎  | 73/100 [47:36<17:26, 38.74s/trial, best loss: -0.4901]
 74%|███████▍  | 74/100 [48:08<15:56, 36.80s/trial, best loss: -0.4901]
 75%|███████▌  | 75/100 [48:34<14:00, 33.61s/trial, best loss: -0.4908]
 76%|███████▌  | 76/100 [49:02<12:44, 31.84s/trial, best loss: -0.4908]
 77%|███████▋  | 77/100 [49:28<11:29, 29.97s/trial, best loss: -0.4908]
 78%|███████▊  | 78/100 [49:52<10:22, 28.28s/trial, best loss: -0.4908]
 79%|███████▉  | 79/100 [50:21<10:01, 28.64s/trial, best loss: -0.4908]
 80%|████████  | 80/100 [50:46<09:11, 27.56s/trial, best loss: -0.4908]
 81%|████████  | 81/100 [51:16<08:53, 28.06s/trial, best loss: -0.4908]
 82%|████████▏ | 82/100 [51:46<08:36, 28.69s/trial, best loss: -0.4908]
 83%|████████▎ | 83/100 [52:15<08:10, 28.85s/trial, best loss: -0.4908]
 84%|████████▍ | 84/100 [52:46<07:51, 29.44s/trial, best loss: -0.4908]
 85%|████████▌ | 85/100 [53:12<07:08, 28.55s/trial, best loss: -0.4908]
 86%|████████▌ | 86/100 [53:43<06:48, 29.21s/trial, best loss: -0.4908]
 87%|████████▋ | 87/100 [54:08<06:03, 27.99s/trial, best loss: -0.4908]
 88%|████████▊ | 88/100 [54:32<05:20, 26.69s/trial, best loss: -0.4908]
 89%|████████▉ | 89/100 [54:56<04:45, 26.00s/trial, best loss: -0.4908]
 90%|█████████ | 90/100 [55:31<04:45, 28.51s/trial, best loss: -0.4908]
 91%|█████████ | 91/100 [56:00<04:20, 28.91s/trial, best loss: -0.4908]
 92%|█████████▏| 92/100 [56:37<04:09, 31.18s/trial, best loss: -0.4908]
 93%|█████████▎| 93/100 [57:05<03:31, 30.15s/trial, best loss: -0.4908]
 94%|█████████▍| 94/100 [57:26<02:44, 27.48s/trial, best loss: -0.4908]
 95%|█████████▌| 95/100 [57:53<02:16, 27.34s/trial, best loss: -0.4908]
 96%|█████████▌| 96/100 [58:28<01:58, 29.56s/trial, best loss: -0.4908]
 97%|█████████▋| 97/100 [58:53<01:24, 28.32s/trial, best loss: -0.4908]
 98%|█████████▊| 98/100 [59:16<00:53, 26.57s/trial, best loss: -0.4908]
 99%|█████████▉| 99/100 [59:58<00:31, 31.41s/trial, best loss: -0.4908]
+
+최적화 완료. 최적 파라미터: {'colsample_bytree': 0.7077604272501928, 'learning_rate': 0.10351387699107398, 'max_depth': 6.0, 'min_child_weight': 4.0, 'num_leaves': 51.0, 'reg_alpha': 0.06973941883143871, 'reg_lambda': 0.8477821589656351, 'subsample': 0.8664583588640111}
+최적 CSI 점수: 0.4908 (loss: -0.4908)
+
+최적화 과정 요약:
+  - 총 시도 횟수: 100
+  - 성공한 시도: 100
+  - 최초 CSI: 0.4792
+  - 최종 CSI: 0.4809
+  - 최고 CSI: 0.4908
+  - 최저 CSI: 0.4682
+  - 평균 CSI: 0.4815
+
+최적화 Trials 객체가 /workspace/visibility_prediction/Analysis_code/optimization_history/lgb_ctgan10000_daejeon_trials.pkl에 저장되었습니다.
+최종 모델 학습 시작...
+Fold 1 학습 중... (학습 연도: [2018, 2019], 검증 연도: 2020)
+Fold 1 검증 CSI: 0.4324
+Fold 2 학습 중... (학습 연도: [2018, 2020], 검증 연도: 2019)
+Fold 2 검증 CSI: 0.4714
+Fold 3 학습 중... (학습 연도: [2019, 2020], 검증 연도: 2018)
+Fold 3 검증 CSI: 0.5557
+모델 저장 중...
+모델이 /workspace/visibility_prediction/Analysis_code/save_model/lgb_optima/lgb_ctgan10000_daejeon.pkl에 저장되었습니다.
+
+✓ 완료: lgb_ctgan10000/LGB_ctgan10000_daejeon.py (소요 시간: 3642초)
+
+----------------------------------------
+실행 중: lgb_ctgan10000/LGB_ctgan10000_gwangju.py
+시작 시간: 2025-12-28 07:31:19
+----------------------------------------
+데이터 로딩 중...
+데이터 전처리 중...
+하이퍼파라미터 최적화 시작...
+
  0%|          | 0/100 [00:00<?, ?trial/s, best loss=?]
  1%|          | 1/100 [01:02<1:42:38, 62.20s/trial, best loss: -0.4807]
  2%|▏         | 2/100 [01:49<1:27:01, 53.28s/trial, best loss: -0.4841]
  3%|▎         | 3/100 [02:42<1:25:52, 53.12s/trial, best loss: -0.4848]
  4%|▍         | 4/100 [03:15<1:12:13, 45.14s/trial, best loss: -0.4916]
  5%|▌         | 5/100 [04:13<1:19:05, 49.96s/trial, best loss: -0.4916]
  6%|▌         | 6/100 [05:10<1:22:01, 52.35s/trial, best loss: -0.4916]
  7%|▋         | 7/100 [05:34<1:06:33, 42.94s/trial, best loss: -0.4916]
  8%|▊         | 8/100 [06:55<1:24:29, 55.10s/trial, best loss: -0.4916]
  9%|▉         | 9/100 [07:43<1:20:06, 52.82s/trial, best loss: -0.4916]
 10%|█         | 10/100 [08:33<1:18:03, 52.04s/trial, best loss: -0.4916]
 11%|█         | 11/100 [08:58<1:04:48, 43.69s/trial, best loss: -0.4916]
 12%|█▏        | 12/100 [09:36<1:01:44, 42.09s/trial, best loss: -0.4916]
 13%|█▎        | 13/100 [11:00<1:19:31, 54.85s/trial, best loss: -0.4916]
 14%|█▍        | 14/100 [12:01<1:21:08, 56.61s/trial, best loss: -0.4916]
 15%|█▌        | 15/100 [12:29<1:08:01, 48.02s/trial, best loss: -0.4916]
 16%|█▌        | 16/100 [13:15<1:06:13, 47.30s/trial, best loss: -0.4916]
 17%|█▋        | 17/100 [13:36<54:35, 39.46s/trial, best loss: -0.4916]  
 18%|█▊        | 18/100 [14:34<1:01:25, 44.94s/trial, best loss: -0.4916]
 19%|█▉        | 19/100 [15:04<54:45, 40.56s/trial, best loss: -0.4916]  
 20%|██        | 20/100 [16:14<1:05:52, 49.40s/trial, best loss: -0.4916]
 21%|██        | 21/100 [16:54<1:01:24, 46.64s/trial, best loss: -0.4971]
 22%|██▏       | 22/100 [17:30<56:16, 43.29s/trial, best loss: -0.4971]  
 23%|██▎       | 23/100 [18:01<51:01, 39.77s/trial, best loss: -0.4971]
 24%|██▍       | 24/100 [18:33<47:11, 37.25s/trial, best loss: -0.4971]
 25%|██▌       | 25/100 [19:12<47:11, 37.75s/trial, best loss: -0.4971]
 26%|██▌       | 26/100 [19:48<45:54, 37.22s/trial, best loss: -0.4971]
 27%|██▋       | 27/100 [20:30<47:14, 38.83s/trial, best loss: -0.4971]
 28%|██▊       | 28/100 [21:01<43:51, 36.55s/trial, best loss: -0.4971]
 29%|██▉       | 29/100 [21:48<47:00, 39.73s/trial, best loss: -0.4971]
 30%|███       | 30/100 [22:23<44:41, 38.30s/trial, best loss: -0.4971]
 31%|███       | 31/100 [22:49<39:43, 34.54s/trial, best loss: -0.4971]
 32%|███▏      | 32/100 [23:13<35:34, 31.39s/trial, best loss: -0.4971]
 33%|███▎      | 33/100 [23:34<31:37, 28.32s/trial, best loss: -0.4971]
 34%|███▍      | 34/100 [24:14<35:00, 31.82s/trial, best loss: -0.4971]
 35%|███▌      | 35/100 [24:59<38:36, 35.64s/trial, best loss: -0.4971]
 36%|███▌      | 36/100 [25:35<38:10, 35.80s/trial, best loss: -0.4971]
 37%|███▋      | 37/100 [26:39<46:25, 44.22s/trial, best loss: -0.4971]
 38%|███▊      | 38/100 [27:04<39:35, 38.31s/trial, best loss: -0.4971]
 39%|███▉      | 39/100 [27:38<37:49, 37.20s/trial, best loss: -0.4971]
 40%|████      | 40/100 [28:10<35:45, 35.75s/trial, best loss: -0.4971]
 41%|████      | 41/100 [28:34<31:29, 32.03s/trial, best loss: -0.4971]
 42%|████▏     | 42/100 [29:01<29:39, 30.67s/trial, best loss: -0.4971]
 43%|████▎     | 43/100 [29:33<29:29, 31.05s/trial, best loss: -0.4971]
 44%|████▍     | 44/100 [30:15<32:02, 34.33s/trial, best loss: -0.4971]
 45%|████▌     | 45/100 [30:46<30:33, 33.34s/trial, best loss: -0.4971]
 46%|████▌     | 46/100 [31:18<29:33, 32.84s/trial, best loss: -0.4971]
 47%|████▋     | 47/100 [31:55<30:00, 33.97s/trial, best loss: -0.4971]
 48%|████▊     | 48/100 [32:40<32:31, 37.52s/trial, best loss: -0.4971]
 49%|████▉     | 49/100 [33:06<28:58, 34.08s/trial, best loss: -0.4971]
 50%|█████     | 50/100 [33:29<25:34, 30.69s/trial, best loss: -0.4971]
 51%|█████     | 51/100 [33:54<23:39, 28.96s/trial, best loss: -0.4971]
 52%|█████▏    | 52/100 [34:21<22:42, 28.39s/trial, best loss: -0.4971]
 53%|█████▎    | 53/100 [34:57<23:53, 30.51s/trial, best loss: -0.4971]
 54%|█████▍    | 54/100 [35:35<25:16, 32.96s/trial, best loss: -0.4971]
 55%|█████▌    | 55/100 [36:07<24:24, 32.54s/trial, best loss: -0.4971]
 56%|█████▌    | 56/100 [37:12<31:05, 42.40s/trial, best loss: -0.4971]
 57%|█████▋    | 57/100 [37:49<29:04, 40.57s/trial, best loss: -0.4971]
 58%|█████▊    | 58/100 [38:23<27:06, 38.72s/trial, best loss: -0.4971]
 59%|█████▉    | 59/100 [38:56<25:20, 37.08s/trial, best loss: -0.4971]
 60%|██████    | 60/100 [39:30<24:08, 36.22s/trial, best loss: -0.4971]
 61%|██████    | 61/100 [40:38<29:41, 45.69s/trial, best loss: -0.4971]
 62%|██████▏   | 62/100 [41:09<26:05, 41.21s/trial, best loss: -0.4971]
 63%|██████▎   | 63/100 [41:45<24:28, 39.69s/trial, best loss: -0.4971]
 64%|██████▍   | 64/100 [42:17<22:26, 37.40s/trial, best loss: -0.4971]
 65%|██████▌   | 65/100 [42:46<20:20, 34.88s/trial, best loss: -0.4971]
 66%|██████▌   | 66/100 [43:19<19:23, 34.21s/trial, best loss: -0.4994]
 67%|���█████▋   | 67/100 [43:52<18:36, 33.85s/trial, best loss: -0.4994]
 68%|██████▊   | 68/100 [44:26<18:10, 34.08s/trial, best loss: -0.4994]
 69%|██████▉   | 69/100 [45:15<19:46, 38.27s/trial, best loss: -0.4994]
 70%|███████   | 70/100 [45:56<19:36, 39.23s/trial, best loss: -0.4994]
 71%|███████   | 71/100 [46:41<19:51, 41.09s/trial, best loss: -0.4994]
 72%|███████▏  | 72/100 [47:26<19:44, 42.29s/trial, best loss: -0.4994]
 73%|███████▎  | 73/100 [48:36<22:40, 50.38s/trial, best loss: -0.4994]
 74%|███████▍  | 74/100 [49:12<20:01, 46.21s/trial, best loss: -0.4994]
 75%|███████▌  | 75/100 [49:58<19:11, 46.04s/trial, best loss: -0.4994]
 76%|███████▌  | 76/100 [50:36<17:24, 43.52s/trial, best loss: -0.4994]
 77%|███████▋  | 77/100 [51:07<15:19, 39.98s/trial, best loss: -0.4994]
 78%|███████▊  | 78/100 [52:08<16:54, 46.11s/trial, best loss: -0.4994]
 79%|███████▉  | 79/100 [52:46<15:22, 43.92s/trial, best loss: -0.4994]
 80%|████████  | 80/100 [53:27<14:18, 42.91s/trial, best loss: -0.4994]
 81%|████████  | 81/100 [53:59<12:33, 39.67s/trial, best loss: -0.4994]
 82%|████████▏ | 82/100 [54:47<12:39, 42.19s/trial, best loss: -0.4994]
 83%|████████▎ | 83/100 [55:36<12:30, 44.15s/trial, best loss: -0.4994]
 84%|████████▍ | 84/100 [56:13<11:10, 41.89s/trial, best loss: -0.4994]
 85%|████████▌ | 85/100 [56:50<10:09, 40.66s/trial, best loss: -0.4994]
 86%|████████▌ | 86/100 [57:41<10:11, 43.69s/trial, best loss: -0.4994]
 87%|████████▋ | 87/100 [58:47<10:54, 50.36s/trial, best loss: -0.4994]
 88%|████████▊ | 88/100 [59:26<09:22, 46.84s/trial, best loss: -0.4994]
 89%|████████▉ | 89/100 [1:00:02<08:02, 43.84s/trial, best loss: -0.4994]
 90%|█████████ | 90/100 [1:00:31<06:33, 39.38s/trial, best loss: -0.4994]
 91%|█████████ | 91/100 [1:01:09<05:48, 38.76s/trial, best loss: -0.4994]
 92%|█████████▏| 92/100 [1:01:45<05:04, 38.04s/trial, best loss: -0.4994]
 93%|█████████▎| 93/100 [1:02:39<04:59, 42.76s/trial, best loss: -0.4994]
 94%|█████████▍| 94/100 [1:03:06<03:48, 38.12s/trial, best loss: -0.4994]
 95%|█████████▌| 95/100 [1:03:39<03:02, 36.58s/trial, best loss: -0.4994]
 96%|█████████▌| 96/100 [1:04:16<02:26, 36.56s/trial, best loss: -0.4994]
 97%|█████████▋| 97/100 [1:04:51<01:48, 36.21s/trial, best loss: -0.4994]
 98%|█████████▊| 98/100 [1:05:15<01:05, 32.67s/trial, best loss: -0.4994]
 99%|█████████▉| 99/100 [1:05:43<00:31, 31.21s/trial, best loss: -0.4994]
+
+최적화 완료. 최적 파라미터: {'colsample_bytree': 0.9974290644555891, 'learning_rate': 0.03488079849604818, 'max_depth': 15.0, 'min_child_weight': 13.0, 'num_leaves': 47.0, 'reg_alpha': 0.22968749134640387, 'reg_lambda': 0.42745540115072206, 'subsample': 0.9875948361694687}
+최적 CSI 점수: 0.4994 (loss: -0.4994)
+
+최적화 과정 요약:
+  - 총 시도 횟수: 100
+  - 성공한 시도: 100
+  - 최초 CSI: 0.4807
+  - 최종 CSI: 0.4865
+  - 최고 CSI: 0.4994
+  - 최저 CSI: 0.4678
+  - 평균 CSI: 0.4866
+
+최적화 Trials 객체가 /workspace/visibility_prediction/Analysis_code/optimization_history/lgb_ctgan10000_gwangju_trials.pkl에 저장되었습니다.
+최종 모델 학습 시작...
+Fold 1 학습 중... (학습 연도: [2018, 2019], 검증 연도: 2020)
+Fold 1 검증 CSI: 0.4045
+Fold 2 학습 중... (학습 연도: [2018, 2020], 검증 연도: 2019)
+Fold 2 검증 CSI: 0.5536
+Fold 3 학습 중... (학습 연도: [2019, 2020], 검증 연도: 2018)
+Fold 3 검증 CSI: 0.5277
+모델 저장 중...
+모델이 /workspace/visibility_prediction/Analysis_code/save_model/lgb_optima/lgb_ctgan10000_gwangju.pkl에 저장되었습니다.
+
+✓ 완료: lgb_ctgan10000/LGB_ctgan10000_gwangju.py (소요 시간: 4001초)
+
+----------------------------------------
+실행 중: lgb_ctgan10000/LGB_ctgan10000_incheon.py
+시작 시간: 2025-12-28 08:38:00
+----------------------------------------
+데이터 로딩 중...
+데이터 전처리 중...
+하이퍼파라미터 최적화 시작...
+
  0%|          | 0/100 [00:00<?, ?trial/s, best loss=?]
  1%|          | 1/100 [00:54<1:30:09, 54.64s/trial, best loss: -0.5469]
  2%|▏         | 2/100 [01:19<1:00:47, 37.22s/trial, best loss: -0.5519]
  3%|▎         | 3/100 [01:50<55:12, 34.15s/trial, best loss: -0.5519]  
  4%|▍         | 4/100 [02:25<55:19, 34.57s/trial, best loss: -0.5519]
  5%|▌         | 5/100 [03:31<1:12:51, 46.01s/trial, best loss: -0.5557]
  6%|��         | 6/100 [04:02<1:03:56, 40.81s/trial, best loss: -0.5557]
  7%|▋         | 7/100 [04:30<56:42, 36.58s/trial, best loss: -0.5557]  
  8%|▊         | 8/100 [05:14<59:48, 39.00s/trial, best loss: -0.5557]
  9%|▉         | 9/100 [05:44<54:59, 36.26s/trial, best loss: -0.5557]
 10%|█         | 10/100 [06:26<56:54, 37.94s/trial, best loss: -0.5557]
 11%|█         | 11/100 [06:56<52:53, 35.66s/trial, best loss: -0.5557]
 12%|█▏        | 12/100 [08:02<1:05:32, 44.69s/trial, best loss: -0.5557]
 13%|█▎        | 13/100 [08:46<1:04:34, 44.53s/trial, best loss: -0.5557]
 14%|█▍        | 14/100 [09:35<1:05:36, 45.77s/trial, best loss: -0.5557]
 15%|█▌        | 15/100 [10:59<1:21:31, 57.55s/trial, best loss: -0.5557]
 16%|█▌        | 16/100 [11:22<1:05:53, 47.07s/trial, best loss: -0.5557]
 17%|█▋        | 17/100 [12:15<1:07:27, 48.77s/trial, best loss: -0.5557]
 18%|█▊        | 18/100 [12:46<59:16, 43.37s/trial, best loss: -0.5557]  
 19%|█▉        | 19/100 [13:18<54:13, 40.17s/trial, best loss: -0.5557]
 20%|██        | 20/100 [13:43<47:31, 35.64s/trial, best loss: -0.5557]
 21%|██        | 21/100 [14:13<44:40, 33.93s/trial, best loss: -0.5557]
 22%|██▏       | 22/100 [15:23<58:03, 44.67s/trial, best loss: -0.5557]
 23%|██▎       | 23/100 [15:46<49:03, 38.23s/trial, best loss: -0.5557]
 24%|██▍       | 24/100 [16:16<45:01, 35.55s/trial, best loss: -0.5557]
 25%|██▌       | 25/100 [16:48<43:17, 34.64s/trial, best loss: -0.5557]
 26%|██▌       | 26/100 [17:28<44:29, 36.07s/trial, best loss: -0.5557]
 27%|██▋       | 27/100 [17:55<40:51, 33.59s/trial, best loss: -0.5557]
 28%|██▊       | 28/100 [18:25<39:01, 32.52s/trial, best loss: -0.556] 
 29%|██▉       | 29/100 [19:42<54:10, 45.78s/trial, best loss: -0.556]
 30%|███       | 30/100 [20:16<49:15, 42.23s/trial, best loss: -0.556]
 31%|███       | 31/100 [20:49<45:25, 39.50s/trial, best loss: -0.556]
 32%|███▏      | 32/100 [21:32<45:48, 40.41s/trial, best loss: -0.556]
 33%|███▎      | 33/100 [22:16<46:24, 41.57s/trial, best loss: -0.5567]
 34%|███▍      | 34/100 [22:57<45:31, 41.39s/trial, best loss: -0.5567]
 35%|███▌      | 35/100 [23:40<45:17, 41.81s/trial, best loss: -0.5567]
 36%|███▌      | 36/100 [24:46<52:33, 49.28s/trial, best loss: -0.5567]
 37%|███▋      | 37/100 [25:24<48:09, 45.86s/trial, best loss: -0.558] 
 38%|███▊      | 38/100 [26:06<46:08, 44.65s/trial, best loss: -0.558]
 39%|███▉      | 39/100 [26:54<46:31, 45.76s/trial, best loss: -0.558]
 40%|████      | 40/100 [27:40<45:35, 45.60s/trial, best loss: -0.558]
 41%|████      | 41/100 [28:19<42:58, 43.71s/trial, best loss: -0.558]
 42%|████▏     | 42/100 [29:14<45:34, 47.14s/trial, best loss: -0.558]
 43%|████▎     | 43/100 [29:56<43:11, 45.47s/trial, best loss: -0.558]
 44%|████▍     | 44/100 [30:58<47:01, 50.39s/trial, best loss: -0.558]
 45%|████▌     | 45/100 [31:43<44:47, 48.86s/trial, best loss: -0.558]
 46%|████▌     | 46/100 [32:39<46:01, 51.15s/trial, best loss: -0.558]
 47%|████▋     | 47/100 [33:32<45:28, 51.48s/trial, best loss: -0.558]
 48%|████▊     | 48/100 [34:10<41:20, 47.70s/trial, best loss: -0.558]
 49%|████▉     | 49/100 [34:49<38:16, 45.04s/trial, best loss: -0.558]
 50%|█████     | 50/100 [35:28<35:54, 43.09s/trial, best loss: -0.558]
 51%|█████     | 51/100 [36:07<34:20, 42.06s/trial, best loss: -0.558]
 52%|█████▏    | 52/100 [36:43<32:09, 40.19s/trial, best loss: -0.558]
 53%|█████▎    | 53/100 [37:19<30:30, 38.94s/trial, best loss: -0.558]
 54%|█████▍    | 54/100 [37:47<27:17, 35.59s/trial, best loss: -0.558]
 55%|█████▌    | 55/100 [38:19<25:50, 34.45s/trial, best loss: -0.558]
 56%|█████▌    | 56/100 [39:05<27:44, 37.83s/trial, best loss: -0.558]
 57%|█████▋    | 57/100 [39:37<25:53, 36.12s/trial, best loss: -0.558]
 58%|█████▊    | 58/100 [40:15<25:40, 36.67s/trial, best loss: -0.558]
 59%|█████▉    | 59/100 [40:53<25:27, 37.25s/trial, best loss: -0.558]
 60%|██████    | 60/100 [41:39<26:29, 39.73s/trial, best loss: -0.558]
 61%|██████    | 61/100 [42:12<24:36, 37.85s/trial, best loss: -0.558]
 62%|██████▏   | 62/100 [42:45<22:55, 36.21s/trial, best loss: -0.558]
 63%|██████▎   | 63/100 [43:34<24:41, 40.05s/trial, best loss: -0.558]
 64%|██████▍   | 64/100 [43:56<20:46, 34.61s/trial, best loss: -0.558]
 65%|██████▌   | 65/100 [44:36<21:12, 36.36s/trial, best loss: -0.558]
 66%|██████▌   | 66/100 [45:08<19:49, 34.98s/trial, best loss: -0.558]
 67%|██████▋   | 67/100 [45:36<18:03, 32.83s/trial, best loss: -0.558]
 68%|██████▊   | 68/100 [46:02<16:32, 31.03s/trial, best loss: -0.558]
 69%|██████▉   | 69/100 [46:45<17:48, 34.45s/trial, best loss: -0.5588]
 70%|███��███   | 70/100 [47:26<18:11, 36.38s/trial, best loss: -0.5588]
 71%|███████   | 71/100 [48:08<18:24, 38.10s/trial, best loss: -0.5588]
 72%|███████▏  | 72/100 [48:40<16:57, 36.33s/trial, best loss: -0.5588]
 73%|███████▎  | 73/100 [49:47<20:26, 45.41s/trial, best loss: -0.5588]
 74%|███████▍  | 74/100 [50:25<18:42, 43.17s/trial, best loss: -0.5588]
 75%|███████▌  | 75/100 [51:28<20:32, 49.28s/trial, best loss: -0.5588]
 76%|███████▌  | 76/100 [52:21<20:06, 50.28s/trial, best loss: -0.5588]
 77%|███████▋  | 77/100 [53:03<18:18, 47.74s/trial, best loss: -0.5588]
 78%|███████▊  | 78/100 [53:47<17:11, 46.87s/trial, best loss: -0.5588]
 79%|███████▉  | 79/100 [54:27<15:40, 44.78s/trial, best loss: -0.5588]
 80%|████████  | 80/100 [55:22<15:58, 47.90s/trial, best loss: -0.5588]
 81%|████████  | 81/100 [55:57<13:54, 43.91s/trial, best loss: -0.5588]
 82%|████████▏ | 82/100 [56:31<12:14, 40.78s/trial, best loss: -0.5588]
 83%|████████▎ | 83/100 [57:01<10:39, 37.63s/trial, best loss: -0.5588]
 84%|████████▍ | 84/100 [57:42<10:18, 38.68s/trial, best loss: -0.5588]
 85%|████████▌ | 85/100 [58:32<10:29, 41.95s/trial, best loss: -0.5588]
 86%|████████▌ | 86/100 [59:09<09:27, 40.52s/trial, best loss: -0.5588]
 87%|████████▋ | 87/100 [59:52<08:58, 41.40s/trial, best loss: -0.5588]
 88%|████████▊ | 88/100 [1:00:15<07:08, 35.74s/trial, best loss: -0.5588]
 89%|████████▉ | 89/100 [1:00:53<06:40, 36.37s/trial, best loss: -0.5588]
 90%|█████████ | 90/100 [1:01:38<06:30, 39.04s/trial, best loss: -0.5588]
 91%|█████████ | 91/100 [1:02:20<05:59, 39.93s/trial, best loss: -0.5588]
 92%|█████████▏| 92/100 [1:03:11<05:45, 43.19s/trial, best loss: -0.5592]
 93%|█████████▎| 93/100 [1:04:06<05:27, 46.72s/trial, best loss: -0.5592]
 94%|█████████▍| 94/100 [1:05:23<05:34, 55.81s/trial, best loss: -0.5592]
 95%|█████████▌| 95/100 [1:06:36<05:05, 61.13s/trial, best loss: -0.5592]
 96%|█████████▌| 96/100 [1:07:16<03:39, 54.80s/trial, best loss: -0.5592]
 97%|█████████▋| 97/100 [1:07:55<02:30, 50.12s/trial, best loss: -0.5592]
 98%|█████████▊| 98/100 [1:08:36<01:34, 47.21s/trial, best loss: -0.5592]
 99%|█████████▉| 99/100 [1:09:51<00:55, 55.54s/trial, best loss: -0.5592]
+
+최적화 완료. 최적 파라미터: {'colsample_bytree': 0.7615743363801121, 'learning_rate': 0.032013705340192794, 'max_depth': 12.0, 'min_child_weight': 4.0, 'num_leaves': 135.0, 'reg_alpha': 0.07355917150019742, 'reg_lambda': 0.7693270890686972, 'subsample': 0.8491133431153928}
+최적 CSI 점수: 0.5592 (loss: -0.5592)
+
+최적화 과정 요약:
+  - 총 시도 횟수: 100
+  - 성공한 시도: 100
+  - 최초 CSI: 0.5469
+  - 최종 CSI: 0.5567
+  - 최고 CSI: 0.5592
+  - 최저 CSI: 0.5428
+  - 평균 CSI: 0.5520
+
+최적화 Trials 객체가 /workspace/visibility_prediction/Analysis_code/optimization_history/lgb_ctgan10000_incheon_trials.pkl에 저장되었습니다.
+최종 모델 학습 시작...
+Fold 1 학습 중... (학습 연도: [2018, 2019], 검증 연도: 2020)
+Fold 1 검증 CSI: 0.4967
+Fold 2 학습 중... (학습 연도: [2018, 2020], 검증 연도: 2019)
+Fold 2 검증 CSI: 0.6068
+Fold 3 학습 중... (학습 연도: [2019, 2020], 검증 연도: 2018)
+Fold 3 검증 CSI: 0.5748
+모델 저장 중...
+모델이 /workspace/visibility_prediction/Analysis_code/save_model/lgb_optima/lgb_ctgan10000_incheon.pkl에 저장되었습니다.
+
+✓ 완료: lgb_ctgan10000/LGB_ctgan10000_incheon.py (소요 시간: 4299초)
+
+----------------------------------------
+실행 중: lgb_ctgan10000/LGB_ctgan10000_seoul.py
+시작 시간: 2025-12-28 09:49:39
+----------------------------------------
+데이터 로딩 중...
+데이터 전처리 중...
+하이퍼파라미터 최적화 시작...
+
  0%|          | 0/100 [00:00<?, ?trial/s, best loss=?]
  1%|          | 1/100 [01:13<2:01:00, 73.34s/trial, best loss: -0.5479]
  2%|▏         | 2/100 [01:43<1:18:00, 47.76s/trial, best loss: -0.5552]
  3%|▎         | 3/100 [02:04<57:22, 35.48s/trial, best loss: -0.558]   
  4%|▍         | 4/100 [03:04<1:12:39, 45.41s/trial, best loss: -0.558]
  5%|▌         | 5/100 [03:45<1:09:30, 43.90s/trial, best loss: -0.558]
  6%|▌         | 6/100 [04:11<58:53, 37.59s/trial, best loss: -0.5639] 
  7%|▋         | 7/100 [04:54<1:01:02, 39.38s/trial, best loss: -0.5639]
  8%|▊         | 8/100 [05:50<1:08:46, 44.86s/trial, best loss: -0.5639]
  9%|▉         | 9/100 [06:40<1:10:17, 46.34s/trial, best loss: -0.5639]
 10%|█         | 10/100 [07:29<1:10:30, 47.01s/trial, best loss: -0.5639]
 11%|█         | 11/100 [08:14<1:08:51, 46.42s/trial, best loss: -0.5639]
 12%|█▏        | 12/100 [08:33<56:03, 38.22s/trial, best loss: -0.5639]  
 13%|█▎        | 13/100 [08:57<49:03, 33.84s/trial, best loss: -0.5639]
 14%|█▍        | 14/100 [09:20<43:45, 30.53s/trial, best loss: -0.5639]
 15%|█▌        | 15/100 [09:49<42:37, 30.09s/trial, best loss: -0.5639]
 16%|█▌        | 16/100 [11:05<1:01:44, 44.10s/trial, best loss: -0.5639]
 17%|█▋        | 17/100 [11:51<1:01:40, 44.58s/trial, best loss: -0.5639]
 18%|█▊        | 18/100 [12:21<55:03, 40.28s/trial, best loss: -0.5639]  
 19%|█▉        | 19/100 [12:46<47:51, 35.45s/trial, best loss: -0.5639]
 20%|██        | 20/100 [13:30<50:43, 38.05s/trial, best loss: -0.5639]
 21%|██        | 21/100 [13:54<44:35, 33.86s/trial, best loss: -0.5639]
 22%|██▏       | 22/100 [14:21<41:16, 31.75s/trial, best loss: -0.5639]
 23%|██▎       | 23/100 [14:43<37:04, 28.89s/trial, best loss: -0.5639]
 24%|██▍       | 24/100 [15:09<35:34, 28.08s/trial, best loss: -0.5639]
 25%|██▌       | 25/100 [15:31<32:49, 26.26s/trial, best loss: -0.5639]
 26%|██▌       | 26/100 [15:54<31:08, 25.25s/trial, best loss: -0.5639]
 27%|██▋       | 27/100 [16:19<30:45, 25.28s/trial, best loss: -0.5639]
 28%|██▊       | 28/100 [16:46<30:58, 25.81s/trial, best loss: -0.5639]
 29%|██▉       | 29/100 [17:08<28:59, 24.51s/trial, best loss: -0.5639]
 30%|███       | 30/100 [17:43<32:21, 27.74s/trial, best loss: -0.5639]
 31%|███       | 31/100 [18:09<31:10, 27.11s/trial, best loss: -0.5639]
 32%|███▏      | 32/100 [18:37<31:01, 27.38s/trial, best loss: -0.5639]
 33%|███▎      | 33/100 [19:01<29:22, 26.31s/trial, best loss: -0.5639]
 34%|███▍      | 34/100 [19:30<30:00, 27.28s/trial, best loss: -0.5639]
 35%|███▌      | 35/100 [19:58<29:44, 27.46s/trial, best loss: -0.5639]
 36%|███▌      | 36/100 [20:22<28:19, 26.55s/trial, best loss: -0.5639]
 37%|███▋      | 37/100 [21:29<40:25, 38.50s/trial, best loss: -0.5639]
 38%|███▊      | 38/100 [21:51<34:50, 33.72s/trial, best loss: -0.5639]
 39%|███▉      | 39/100 [22:17<31:58, 31.44s/trial, best loss: -0.5639]
 40%|████      | 40/100 [22:41<28:57, 28.96s/trial, best loss: -0.5639]
 41%|████      | 41/100 [23:15<30:07, 30.63s/trial, best loss: -0.5639]
 42%|████▏     | 42/100 [23:39<27:46, 28.74s/trial, best loss: -0.5639]
 43%|████▎     | 43/100 [24:00<25:01, 26.34s/trial, best loss: -0.5639]
 44%|████▍     | 44/100 [24:27<24:44, 26.51s/trial, best loss: -0.5639]
 45%|████▌     | 45/100 [25:06<27:45, 30.28s/trial, best loss: -0.5639]
 46%|████▌     | 46/100 [26:00<33:30, 37.23s/trial, best loss: -0.5639]
 47%|████▋     | 47/100 [26:37<32:59, 37.35s/trial, best loss: -0.5639]
 48%|████▊     | 48/100 [27:20<33:53, 39.11s/trial, best loss: -0.5639]
 49%|████▉     | 49/100 [28:20<38:25, 45.22s/trial, best loss: -0.5639]
 50%|█████     | 50/100 [28:53<34:36, 41.53s/trial, best loss: -0.5639]
 51%|█████     | 51/100 [29:31<32:57, 40.36s/trial, best loss: -0.5639]
 52%|█████▏    | 52/100 [30:14<32:59, 41.23s/trial, best loss: -0.5639]
 53%|█████▎    | 53/100 [30:47<30:18, 38.70s/trial, best loss: -0.5639]
 54%|█████▍    | 54/100 [31:18<28:03, 36.61s/trial, best loss: -0.5639]
 55%|█████▌    | 55/100 [31:49<26:11, 34.93s/trial, best loss: -0.5639]
 56%|█████▌    | 56/100 [32:46<30:26, 41.51s/trial, best loss: -0.5639]
 57%|█████▋    | 57/100 [33:33<30:59, 43.25s/trial, best loss: -0.5639]
 58%|█████▊    | 58/100 [34:05<27:50, 39.78s/trial, best loss: -0.5639]
 59%|█████▉    | 59/100 [34:53<28:45, 42.09s/trial, best loss: -0.5639]
 60%|██████    | 60/100 [35:17<24:35, 36.90s/trial, best loss: -0.5639]
 61%|██████    | 61/100 [35:44<22:03, 33.93s/trial, best loss: -0.5639]
 62%|██████▏   | 62/100 [36:08<19:31, 30.83s/trial, best loss: -0.5639]
 63%|██████▎   | 63/100 [36:36<18:26, 29.91s/trial, best loss: -0.5639]
 64%|██████▍   | 64/100 [36:56<16:16, 27.13s/trial, best loss: -0.5639]
 65%|██████▌   | 65/100 [37:22<15:30, 26.57s/trial, best loss: -0.5639]
 66%|██████▌   | 66/100 [37:54<16:05, 28.41s/trial, best loss: -0.5655]
 67%|██████▋   | 67/100 [38:28<16:32, 30.06s/trial, best loss: -0.5655]
 68%|██████▊   | 68/100 [39:05<17:07, 32.12s/trial, best loss: -0.5655]
 69%|██████▉   | 69/100 [39:35<16:15, 31.48s/trial, best loss: -0.5655]
 70%|███████   | 70/100 [40:17<17:17, 34.58s/trial, best loss: -0.5655]
 71%|███████   | 71/100 [40:41<15:13, 31.49s/trial, best loss: -0.5655]
 72%|███████▏  | 72/100 [41:26<16:34, 35.53s/trial, best loss: -0.5655]
 73%|███████▎  | 73/100 [41:53<14:51, 33.02s/trial, best loss: -0.5655]
 74%|███████▍  | 74/100 [42:31<14:57, 34.53s/trial, best loss: -0.5655]
 75%|███████▌  | 75/100 [43:02<13:50, 33.22s/trial, best loss: -0.5655]
 76%|███████▌  | 76/100 [43:46<14:37, 36.58s/trial, best loss: -0.5655]
 77%|███████▋  | 77/100 [44:15<13:06, 34.20s/trial, best loss: -0.5655]
 78%|███████▊  | 78/100 [44:47<12:22, 33.75s/trial, best loss: -0.5655]
 79%|███████▉  | 79/100 [45:17<11:20, 32.40s/trial, best loss: -0.5655]
 80%|████████  | 80/100 [45:48<10:41, 32.08s/trial, best loss: -0.5655]
 81%|████████  | 81/100 [46:27<10:47, 34.07s/trial, best loss: -0.5655]
 82%|████████▏ | 82/100 [47:05<10:36, 35.34s/trial, best loss: -0.5655]
 83%|████████▎ | 83/100 [47:37<09:44, 34.37s/trial, best loss: -0.5655]
 84%|████████▍ | 84/100 [48:20<09:50, 36.90s/trial, best loss: -0.5655]
 85%|████████▌ | 85/100 [48:51<08:46, 35.11s/trial, best loss: -0.5655]
 86%|████████▌ | 86/100 [49:25<08:06, 34.73s/trial, best loss: -0.5655]
 87%|████████▋ | 87/100 [49:56<07:16, 33.56s/trial, best loss: -0.5655]
 88%|████████▊ | 88/100 [50:33<06:56, 34.70s/trial, best loss: -0.566] 
 89%|████████▉ | 89/100 [51:19<06:57, 37.99s/trial, best loss: -0.566]
 90%|█████████ | 90/100 [51:54<06:10, 37.08s/trial, best loss: -0.566]
 91%|█████████ | 91/100 [52:47<06:18, 42.10s/trial, best loss: -0.566]
 92%|█████████▏| 92/100 [53:24<05:23, 40.43s/trial, best loss: -0.5671]
 93%|█████████▎| 93/100 [54:01<04:36, 39.53s/trial, best loss: -0.5671]
 94%|█████████▍| 94/100 [54:56<04:24, 44.12s/trial, best loss: -0.5671]
 95%|█████████▌| 95/100 [55:34<03:31, 42.24s/trial, best loss: -0.5671]
 96%|█████████▌| 96/100 [56:12<02:43, 40.95s/trial, best loss: -0.5671]
 97%|█████████▋| 97/100 [56:56<02:05, 41.79s/trial, best loss: -0.5671]
 98%|█████████▊| 98/100 [57:43<01:26, 43.42s/trial, best loss: -0.5671]
 99%|█████████▉| 99/100 [58:35<00:45, 45.96s/trial, best loss: -0.5671]
+
+최적화 완료. 최적 파라미터: {'colsample_bytree': 0.661683034534645, 'learning_rate': 0.02117850018558707, 'max_depth': 15.0, 'min_child_weight': 16.0, 'num_leaves': 83.0, 'reg_alpha': 0.6438462886327296, 'reg_lambda': 0.8929153518940249, 'subsample': 0.9547922722157274}
+최적 CSI 점수: 0.5671 (loss: -0.5671)
+
+최적화 과정 요약:
+  - 총 시도 횟수: 100
+  - 성공한 시도: 100
+  - 최초 CSI: 0.5479
+  - 최종 CSI: 0.5505
+  - 최고 CSI: 0.5671
+  - 최저 CSI: 0.5432
+  - 평균 CSI: 0.5579
+
+최적화 Trials 객체가 /workspace/visibility_prediction/Analysis_code/optimization_history/lgb_ctgan10000_seoul_trials.pkl에 저장되었습니다.
+최종 모델 학습 시작...
+Fold 1 학습 중... (학습 연도: [2018, 2019], 검증 연도: 2020)
+Fold 1 검증 CSI: 0.4967
+Fold 2 학습 중... (학습 연도: [2018, 2020], 검증 연도: 2019)
+Fold 2 검증 CSI: 0.5994
+Fold 3 학습 중... (학습 연도: [2019, 2020], 검증 연도: 2018)
+Fold 3 검증 CSI: 0.5777
+모델 저장 중...
+모델이 /workspace/visibility_prediction/Analysis_code/save_model/lgb_optima/lgb_ctgan10000_seoul.pkl에 저장되었습니다.
+
+✓ 완료: lgb_ctgan10000/LGB_ctgan10000_seoul.py (소요 시간: 3571초)
+
+==========================================
+LGB CTGAN10000 파일 실행 완료
+종료 시간: 2025-12-28 10:49:10
+총 소요 시간: 6시간 19분 31초
+성공: 6개
+실패: 0개
+==========================================