Update app.py

app.py

@@ -1,1688 +1,35 @@
+import os
+import sys
 import streamlit as st
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import plotly.graph_objects as go
-from datetime import date
-from pathlib import Path
-import matplotlib.font_manager as fm
-import matplotlib as mpl
-import warnings
-warnings.filterwarnings('ignore')
+from tempfile import NamedTemporaryFile
 
-# 필요한 추가 라이브러리 로드
-try:
-    import statsmodels.api as sm
-    from statsmodels.tsa.statespace.sarimax import SARIMAX
-    from statsmodels.tsa.holtwinters import ExponentialSmoothing, SimpleExpSmoothing, Holt
-    from statsmodels.tsa.seasonal import seasonal_decompose
-    from sklearn.linear_model import LinearRegression
-    from sklearn.metrics import mean_absolute_percentage_error
-except ImportError:
-    st.error("필요한 라이브러리가 설치되지 않았습니다. 터미널에서 다음 명령을 실행하세요:")
-    st.code("pip install statsmodels scikit-learn")
-    st.stop()
-
-# -------------------------------------------------
-# CONFIG ------------------------------------------
-# -------------------------------------------------
-CSV_PATH = Path("2025-domae.csv")
-MACRO_START, MACRO_END = "1996-01-01", "2030-12-31"
-MICRO_START, MICRO_END = "2024-01-01", "2026-12-31"
-
-
-# 한글 폰트 설정
-font_list = [f.name for f in fm.fontManager.ttflist if 'gothic' in f.name.lower() or 
-             'gulim' in f.name.lower() or 'malgun' in f.name.lower() or 
-             'nanum' in f.name.lower() or 'batang' in f.name.lower()]
-
-if font_list:
-    font_name = font_list[0]
-    plt.rcParams['font.family'] = font_name
-    mpl.rcParams['axes.unicode_minus'] = False
-else:
-    plt.rcParams['font.family'] = 'DejaVu Sans'
-
-st.set_page_config(page_title="품목별 가격 예측", page_icon="📈", layout="wide")
-
-# -------------------------------------------------
-# 품목별 최적 모델 매핑 ---------------------------
-# -------------------------------------------------
-item_models = {
-    "갈치": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.82, "model2": "Holt-Winters", "accuracy2": 99.80},
-    "감자": {"model1": "ETS(Multiplicative)", "accuracy1": 99.58, "model2": "SARIMA(1,0,1)(1,0,1,12)", "accuracy2": 98.70},
-    "건고추": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.96, "model2": "Holt", "accuracy2": 99.79},
-    "건다시마": {"model1": "Naive", "accuracy1": 99.59, "model2": "SeasonalNaive", "accuracy2": 99.34},
-    "고구마": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.89, "model2": "ETS(Multiplicative)", "accuracy2": 98.91},
-    "고등어": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.48, "model2": "ETS(Additive)", "accuracy2": 99.42},
-    "김": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.99, "model2": "SARIMA(0,1,1)(0,1,1,12)", "accuracy2": 99.93},
-    "깐마늘(국산)": {"model1": "SeasonalNaive", "accuracy1": 99.79, "model2": "MovingAverage-6 m", "accuracy2": 98.65},
-    "깻잎": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.68, "model2": "Holt", "accuracy2": 99.54},
-    "녹두": {"model1": "WeightedMA-6 m", "accuracy1": 99.53, "model2": "Fourier + LR", "accuracy2": 99.53},
-    "느타리버섯": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.84, "model2": "LinearTrend", "accuracy2": 99.80},
-    "당근": {"model1": "Holt", "accuracy1": 99.25, "model2": "ETS(Multiplicative)", "accuracy2": 97.27},
-    "들깨": {"model1": "Holt", "accuracy1": 99.57, "model2": "Holt-Winters", "accuracy2": 99.17},
-    "땅콩": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.74, "model2": "ETS(Additive)", "accuracy2": 99.37},
-    "레몬": {"model1": "WeightedMA-6 m", "accuracy1": 99.99, "model2": "LinearTrend", "accuracy2": 98.99},
-    "망고": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.38, "model2": "Holt-Winters", "accuracy2": 99.02},
-    "메밀": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.48, "model2": "SARIMA(0,1,1)(0,1,1,12)", "accuracy2": 98.99},
-    "멜론": {"model1": "Naive", "accuracy1": 99.07, "model2": "ETS(Multiplicative)", "accuracy2": 99.01},
-    "명태": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 100.00, "model2": "MovingAverage-6 m", "accuracy2": 99.93},
-    "무": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.54, "model2": "SeasonalNaive", "accuracy2": 88.29, "special": "accuracy_drop"},
-    "물오징어": {"model1": "Holt-Winters", "accuracy1": 99.91, "model2": "ETS(Multiplicative)", "accuracy2": 99.36},
-    "미나리": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 98.71, "model2": "LinearTrend", "accuracy2": 98.54},
-    "바나나": {"model1": "MovingAverage-6 m", "accuracy1": 99.81, "model2": "ETS(Multiplicative)", "accuracy2": 98.86},
-    "방울토마토": {"model1": "ETS(Multiplicative)", "accuracy1": 99.62, "model2": "Holt", "accuracy2": 98.28},
-    "배": {"model1": "ETS(Additive)", "accuracy1": 99.34, "model2": "LinearTrend", "accuracy2": 98.57},
-    "배추": {"model1": "Holt", "accuracy1": 99.98, "model2": "MovingAverage-6 m", "accuracy2": 99.71},
-    "북어": {"model1": "Fourier + LR", "accuracy1": 99.96, "model2": "MovingAverage-6 m", "accuracy2": 99.94},
-    "붉은고추": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.75, "model2": "LinearTrend", "accuracy2": 97.61},
-    "브로콜리": {"model1": "Holt", "accuracy1": 99.54, "model2": "Naive", "accuracy2": 99.93},
-    "사과": {"model1": "Holt-Winters", "accuracy1": 99.89, "model2": "ETS(Multiplicative)", "accuracy2": 98.91},
-    "상추": {"model1": "ETS(Additive)", "accuracy1": 99.11, "model2": "Holt-Winters", "accuracy2": 97.61},
-    "새송이버섯": {"model1": "SimpleExpSmoothing", "accuracy1": 99.95, "model2": "Holt-Winters", "accuracy2": 99.40},
-    "새우": {"model1": "ETS(Additive)", "accuracy1": 99.87, "model2": "Naive", "accuracy2": 99.96},
-    "생강": {"model1": "Naive", "accuracy1": 99.27, "model2": "ETS(Additive)", "accuracy2": 98.53},
-    "수박": {"model1": "Naive", "accuracy1": 99.91, "model2": "SARIMA(1,1,1)(1,1,1,12)", "accuracy2": 99.45},
-    "시금치": {"model1": "Holt-Winters", "accuracy1": 99.70, "model2": "SeasonalNaive", "accuracy2": 98.73},
-    "쌀": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.99, "model2": "Holt-Winters", "accuracy2": 99.88},
-    "알배기배추": {"model1": "WeightedMA-6 m", "accuracy1": 98.19, "model2": "SeasonalNaive", "accuracy2": 95.73},
-    "양배추": {"model1": "Holt-Winters", "accuracy1": 99.05, "model2": "WeightedMA-6 m", "accuracy2": 97.85},
-    "양파": {"model1": "ETS(Additive)", "accuracy1": 99.93, "model2": "WeightedMA-6 m", "accuracy2": 99.51},
-    "얼갈이배추": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.77, "model2": "SeasonalNaive", "accuracy2": 98.55},
-    "열무": {"model1": "SeasonalNaive", "accuracy1": 99.96, "model2": "Holt", "accuracy2": 99.50},
-    "오이": {"model1": "SeasonalNaive", "accuracy1": 99.82, "model2": "ETS(Additive)", "accuracy2": 98.48},
-    "전복": {"model1": "Holt", "accuracy1": 99.90, "model2": "Fourier + LR", "accuracy2": 99.90},
-    "참깨": {"model1": "WeightedMA-6 m", "accuracy1": 100.00, "model2": "LinearTrend", "accuracy2": 86.44, "special": "accuracy_drop"},
-    "찹쌀": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.71, "model2": "Naive", "accuracy2": 98.64, "special": "accuracy_drop"},
-    "콩": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.98, "model2": "ETS(Additive)", "accuracy2": 99.68},
-    "토마토": {"model1": "SeasonalNaive", "accuracy1": 97.31, "model2": "MovingAverage-6 m", "accuracy2": 97.57},
-    "파": {"model1": "MovingAverage-6 m", "accuracy1": 99.92, "model2": "Holt-Winters", "accuracy2": 97.77},
-    "파인애플": {"model1": "Naive", "accuracy1": 99.51, "model2": "SARIMA(1,0,1)(1,0,1,12)", "accuracy2": 96.39},
-    "파프리카": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.04, "model2": "WeightedMA-6 m", "accuracy2": 99.36},
-    "팥": {"model1": "ETS(Additive)", "accuracy1": 99.87, "model2": "Holt-Winters", "accuracy2": 75.08, "special": "accuracy_drop"},
-    "팽이버섯": {"model1": "SeasonalNaive", "accuracy1": 99.84, "model2": "Fourier + LR", "accuracy2": 98.49},
-    "풋고추": {"model1": "Holt-Winters", "accuracy1": 98.95, "model2": "ETS(Multiplicative)", "accuracy2": 98.73},
-    "피망": {"model1": "Fourier + LR", "accuracy1": 99.64, "model2": "WeightedMA-6 m", "accuracy2": 98.93},
-    "호박": {"model1": "ETS(Multiplicative)", "accuracy1": 99.98, "model2": "SeasonalNaive", "accuracy2": 96.61},
-    "홍합": {"model1": "Naive", "accuracy1": 99.86, "model2": "SeasonalNaive", "accuracy2": 98.56},
-}
-
-# 기타 품목에 대한 기본 모델 (리스트에 없는 품목)
-default_models = {
-    "model1": "SARIMA(1,0,1)(1,0,1,12)", 
-    "accuracy1": 99.0, 
-    "model2": "ETS(Multiplicative)", 
-    "accuracy2": 98.0
-}
-
-# -------------------------------------------------
-# UTILITIES ---------------------------------------
-# -------------------------------------------------
-DATE_CANDIDATES = {"date", "ds", "ymd", "날짜", "prce_reg_mm", "etl_ldg_dt"}
-ITEM_CANDIDATES = {"item", "품목", "code", "category", "pdlt_nm", "spcs_nm"}
-PRICE_CANDIDATES = {"price", "y", "value", "가격", "avrg_prce"}
-
-def _standardize_columns(df: pd.DataFrame) -> pd.DataFrame:
-    """Standardize column names to date/item/price and deduplicate."""
-    col_map = {}
-    for c in df.columns:
-        lc = c.lower()
-        if lc in DATE_CANDIDATES:
-            col_map[c] = "date"
-        elif lc in PRICE_CANDIDATES:
-            col_map[c] = "price"
-        elif lc in ITEM_CANDIDATES:
-            # first hit as item, second as species
-            if "item" not in col_map.values():
-                col_map[c] = "item"
-            else:
-                col_map[c] = "species"
-    df = df.rename(columns=col_map)
-
-    # ── handle duplicated columns after rename ─────────────────────────
-    if df.columns.duplicated().any():
-        df = df.loc[:, ~df.columns.duplicated()]
-
-    # ── index datetime to column ───────────────────────────────────────
-    if "date" not in df.columns and df.index.dtype.kind == "M":
-        df.reset_index(inplace=True)
-        df.rename(columns={df.columns[0]: "date"}, inplace=True)
-
-    # ── convert YYYYMM string to datetime ──────────────────────────────────────
-    if "date" in df.columns and pd.api.types.is_object_dtype(df["date"]):
-        if len(df) > 0:
-            # 더 유연한 날짜 변환
-            try:
-                # 샘플 확인 (문자열로 변환하여 안전하게 처리)
-                sample = str(df["date"].iloc[0])
-                
-                # YYYYMM 형식 (6자리)
-                if sample.isdigit() and len(sample) == 6:
-                    df["date"] = pd.to_datetime(df["date"].astype(str), format="%Y%m", errors="coerce")
-                    df["date"] = df["date"] + pd.offsets.MonthEnd(0)  # 해당 월의 마지막 날로 설정
-                
-                # YYYYMMDD 형식 (8자리)
-                elif sample.isdigit() and len(sample) == 8:
-                    df["date"] = pd.to_datetime(df["date"].astype(str), format="%Y%m%d", errors="coerce")
-                
-                # 기타 형식은 자동 감지
-                else:
-                    df["date"] = pd.to_datetime(df["date"], errors="coerce")
-            except:
-                # 실패 시 일반 변환 시도
-                df["date"] = pd.to_datetime(df["date"], errors="coerce")
-
-    # ── build item from pdlt_nm + spcs_nm if needed ────────────────────
-    if "item" not in df.columns and {"pdlt_nm", "spcs_nm"}.issubset(df.columns):
-        df["item"] = df["pdlt_nm"].str.strip() + "-" + df["spcs_nm"].str.strip()
-
-    # ── merge item + species ───────────────────────────────────────────
-    if {"item", "species"}.issubset(df.columns):
-        df["item"] = df["item"].astype(str).str.strip() + "-" + df["species"].astype(str).str.strip()
-        df.drop(columns=["species"], inplace=True)
-
-    return df
-
-@st.cache_data(show_spinner=False)
-def load_data() -> pd.DataFrame:
-    """Load price data from CSV file."""
+def main():
     try:
-        if not CSV_PATH.exists():
-            st.error(f"💾 {CSV_PATH} 파일을 찾을 수 없습니다.")
-            st.stop()
-            
-        # CSV 파일 직접 로드
-        df = pd.read_csv(CSV_PATH)
-        st.sidebar.success(f"CSV 데이터 로드 완료: {len(df)}개 행")
-        
-        # 데이터 표준화 전 원본 데이터 형태 확인
-        st.sidebar.write("원본 데이터 컬럼:", list(df.columns))
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
         
-        # 표준화 전 상세 로그
-        before_std = len(df)
-        df = _standardize_columns(df)
-        after_std = len(df)
-        if before_std != after_std:
-            st.sidebar.warning(f"표준화 중 {before_std - after_std}개 행이 제외되었습니다.")
+        if not code:
+            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            return
         
-        # 표준화 후 로그
-        st.sidebar.write("표준화 후 컬럼:", list(df.columns))
-
-        # 필수 컬럼 확인
-        missing = {c for c in ["date", "item", "price"] if c not in df.columns}
-        if missing:
-            st.error(f"필수 컬럼 누락: {', '.join(missing)} — 파일 컬럼명을 확인하세요.")
-            st.stop()
-
-        # 날짜 데이터 확인
-        st.sidebar.write("날짜 컬럼 데이터 샘플:", df["date"].head().tolist())
+        # Create a temporary Python file
+        with NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
         
-        # 날짜 변환 전후 데이터 수 확인
-        before_date_convert = len(df)
+        # Execute the code
+        exec(compile(code, tmp_path, 'exec'), globals())
         
-        # YYYYMM 형식 변환 (숫자로 저장된 경우도 처리)
+        # Clean up the temporary file
         try:
-            # 데이터 타입 확인
-            if pd.api.types.is_integer_dtype(df["date"]):
-                # 정수형 YYYYMM을 문자열로 변환 후 처리
-                df["date"] = df["date"].astype(str)
-                
-            # 문자열 형식 처리
-            if pd.api.types.is_object_dtype(df["date"]):
-                # YYYYMM 형식인지 확인 (6자리 숫자)
-                if df["date"].str.match(r'^\d{6}$').all():
-                    # 연, 월 구분해서 datetime으로 변환
-                    df["year"] = df["date"].str[:4].astype(int)
-                    df["month"] = df["date"].str[4:6].astype(int)
-                    df["date"] = pd.to_datetime(dict(year=df["year"], month=df["month"], day=1))
-                    # 월의 마지막 날로 설정
-                    df["date"] = df["date"] + pd.offsets.MonthEnd(0)
-                    # 임시 컬럼 삭제
-                    df.drop(columns=["year", "month"], inplace=True)
-                else:
-                    # 일반 변환 시도
-                    df["date"] = pd.to_datetime(df["date"], errors="coerce")
-        except Exception as e:
-            st.sidebar.warning(f"날짜 변환 오류: {str(e)}")
-            # 최후의 방법으로 다시 시도
-            try:
-                df["date"] = pd.to_datetime(df["date"].astype(str), format="%Y%m", errors="coerce")
-                df["date"] = df["date"] + pd.offsets.MonthEnd(0)
-            except:
-                df["date"] = pd.to_datetime(df["date"], errors="coerce")
-        
-        # 날짜 변환 후 데이터 확인
-        st.sidebar.write("날짜 변환 후 샘플:", df["date"].head().tolist())
-        after_date_convert = df.dropna(subset=["date"]).shape[0]
-        if before_date_convert != after_date_convert:
-            st.sidebar.warning(f"날짜 변환 중 {before_date_convert - after_date_convert}개 행이 제외되었습니다.")
-
-        # 가격 데이터 숫자로 변환
-        df["price"] = pd.to_numeric(df["price"], errors="coerce")
-        
-        # NA 데이터 처리 전후 수 확인
-        before_na_drop = len(df)
-        df = df.dropna(subset=["date", "item", "price"])
-        after_na_drop = len(df)
-        if before_na_drop != after_na_drop:
-            st.sidebar.warning(f"NA 제거 중 {before_na_drop - after_na_drop}개 행이 제외되었습니다.")
-        
-        # 결과 정렬
-        df.sort_values("date", inplace=True)
-        
-        # 데이터 정보 표시
-        if len(df) > 0:
-            st.sidebar.write(f"최종 데이터: {len(df)}개 행")
-            # datetime 형식인지 확인
-            if pd.api.types.is_datetime64_dtype(df["date"]):
-                st.sidebar.write(f"데이터 날짜 범위: {df['date'].min().strftime('%Y-%m-%d')} ~ {df['date'].max().strftime('%Y-%m-%d')}")
-            else:
-                st.sidebar.write(f"데이터 날짜 범위: 날짜 형식 변환 실패. 현재 형식: {type(df['date'].iloc[0])}")
-            st.sidebar.write(f"총 품목 수: {df['item'].nunique()}")
-            st.sidebar.write(f"품목별 평균 데이터 수: {len(df)/df['item'].nunique():.1f}개")
-        else:
-            st.error("유효한 데이터가 없습니다!")
-            
-        return df
-    except Exception as e:
-        st.error(f"데이터 로드 중 오류 발생: {str(e)}")
-        import traceback
-        st.code(traceback.format_exc())
-        st.stop()
-
-@st.cache_data(show_spinner=False)
-def get_items(df: pd.DataFrame):
-    return sorted(df["item"].unique())
-
-def get_best_model_for_item(item):
-    """품목에 맞는 최적 모델 정보 반환"""
-    return item_models.get(item, default_models)
-
-def format_currency(value):
-    """원화 형식으로 숫자 포맷팅"""
-    if pd.isna(value) or not np.isfinite(value):
-        return "N/A"
-    return f"{value:,.0f}원"
-
-# -------------------------------------------------
-# 모델 구현부 --------------------------------------
-# -------------------------------------------------
-@st.cache_data(show_spinner=False, ttl=3600)
-def prepare_monthly_data(df):
-    """월별 데이터 준비"""
-    # 월별로 집계
-    monthly_df = df.copy()
-    monthly_df['year_month'] = monthly_df['date'].dt.strftime('%Y-%m')
-    monthly_df = monthly_df.groupby('year_month').agg({'date': 'last', 'price': 'mean'}).reset_index(drop=True)
-    monthly_df.sort_values('date', inplace=True)
-    
-    # 인덱스 설정
-    monthly_df.set_index('date', inplace=True)
-    
-    # 결측치 보간 (월별 데이터에 빈 월이 있을 수 있음)
-    if len(monthly_df) > 1:
-        monthly_df = monthly_df.asfreq('M', method='ffill')
-    
-    return monthly_df
-
-def fit_sarima(df, order, seasonal_order, horizon_end):
-    """SARIMA 모델 구현"""
-    import pandas as pd
-    import numpy as np
-    from statsmodels.tsa.statespace.sarimax import SARIMAX
-    
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    # 모델 학습
-    try:
-        model = SARIMAX(
-            monthly_df['price'],
-            order=order,
-            seasonal_order=seasonal_order,
-            enforce_stationarity=False,
-            enforce_invertibility=False
-        )
-        results = model.fit(disp=False)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        forecast = results.get_forecast(steps=periods)
-        pred_mean = forecast.predicted_mean
-        pred_ci = forecast.conf_int()
-        
-        # Prophet 형식��로 결과 변환
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': pred_mean.values,
-            'yhat_lower': pred_ci.iloc[:, 0].values,
-            'yhat_upper': pred_ci.iloc[:, 1].values
-        })
-        
-        # 월별로 결과 변환 (날짜, 가격)
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = 0
-        
-        try:
-            # 가능하면 계절성 분해
-            decomposition = seasonal_decompose(monthly_df['price'], model='multiplicative', period=12)
-            trend = decomposition.trend
-            seasonal = decomposition.seasonal
-            
-            # 결과에 계절성 반영
-            for i, date in enumerate(fc_df_monthly['ds']):
-                month = date.month
-                if month in seasonal.index.month:
-                    seasonal_value = seasonal[seasonal.index.month == month].mean()
-                    fc_df_monthly.loc[i, 'yearly'] = seasonal_value
+            os.unlink(tmp_path)
         except:
             pass
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"SARIMA 모델 오류: {str(e)}")
-        return None
-
-def fit_ets(df, seasonal_type, horizon_end):
-    """ETS 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    # 모델 파라미터 설정
-    if seasonal_type == 'multiplicative':
-        trend_type = 'add'
-        seasonal = 'mul'
-    else:  # additive
-        trend_type = 'add'
-        seasonal = 'add'
-        
-    # 모델 학습
-    try:
-        model = ExponentialSmoothing(
-            monthly_df['price'],
-            trend=trend_type,
-            seasonal=seasonal,
-            seasonal_periods=12,
-            damped=True
-        )
-        results = model.fit(optimized=True)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        forecast = results.forecast(periods)
-        
-        # Prophet 형식으로 결과 변환
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 신뢰 구간 추정 (ETS는 기본 신뢰 구간을 제공하지 않음)
-        std_error = np.std(results.resid)
-        lower_bound = forecast - 1.96 * std_error
-        upper_bound = forecast + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': forecast.values,
-            'yhat_lower': lower_bound.values,
-            'yhat_upper': upper_bound.values
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = 0
-        
-        try:
-            # 가능하면 계절성 분해
-            decomposition = seasonal_decompose(monthly_df['price'], model=seasonal_type, period=12)
-            trend = decomposition.trend
-            seasonal = decomposition.seasonal
             
-            # 결과에 계절성 반영
-            for i, date in enumerate(fc_df_monthly['ds']):
-                month = date.month
-                if month in seasonal.index.month:
-                    seasonal_value = seasonal[seasonal.index.month == month].mean()
-                    fc_df_monthly.loc[i, 'yearly'] = seasonal_value
-        except:
-            pass
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"ETS 모델 오류: {str(e)}")
-        return None
-
-def fit_holt(df, horizon_end):
-    """Holt 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    # 모델 학습
-    try:
-        model = Holt(monthly_df['price'], damped=True)
-        results = model.fit(optimized=True)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        forecast = results.forecast(periods)
-        
-        # Prophet 형식으로 결과 변환
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 신뢰 구간 추정
-        std_error = np.std(results.resid)
-        lower_bound = forecast - 1.96 * std_error
-        upper_bound = forecast + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': forecast.values,
-            'yhat_lower': lower_bound.values,
-            'yhat_upper': upper_bound.values
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = fc_df_monthly['yhat']  # Holt는 추세만 모델링
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Holt 모델 오류: {str(e)}")
-        return None
-
-def fit_holt_winters(df, horizon_end):
-    """Holt-Winters 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    # 모델 학습
-    try:
-        model = ExponentialSmoothing(
-            monthly_df['price'],
-            trend='add',
-            seasonal='mul',  # 계절성은 곱셈 방식이 농산물 가격에 더 적합
-            seasonal_periods=12,
-            damped=True
-        )
-        results = model.fit(optimized=True)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        forecast = results.forecast(periods)
-        
-        # Prophet 형식으로 결과 변환
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 신뢰 구간 추정
-        std_error = np.std(results.resid)
-        lower_bound = forecast - 1.96 * std_error
-        upper_bound = forecast + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': forecast.values,
-            'yhat_lower': lower_bound.values,
-            'yhat_upper': upper_bound.values
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = 0
-        
-        try:
-            # Holt-Winters 모델에서 계절성 추출
-            seasonal = results.seasonal_
-            
-            # 결과에 계절성 반영
-            for i, date in enumerate(fc_df_monthly['ds']):
-                month = date.month - 1  # 0-indexed
-                if month < len(seasonal):
-                    fc_df_monthly.loc[i, 'yearly'] = seasonal[month] * fc_df_monthly.loc[i, 'yhat']
-                    fc_df_monthly.loc[i, 'trend'] = fc_df_monthly.loc[i, 'yhat'] - fc_df_monthly.loc[i, 'yearly']
-        except:
-            pass
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Holt-Winters 모델 오류: {str(e)}")
-        return None
-
-def fit_moving_average(df, window, horizon_end):
-    """이동 평균 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 마지막 window 개월의 평균 계산
-        last_values = monthly_df['price'].iloc[-window:]
-        ma_value = last_values.mean()
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행 (모든 미래 시점에 동일한 값)
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 신뢰 구간 추정
-        std_error = last_values.std()
-        lower_bound = ma_value - 1.96 * std_error
-        upper_bound = ma_value + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': [ma_value] * len(future_dates),
-            'yhat_lower': [lower_bound] * len(future_dates),
-            'yhat_upper': [upper_bound] * len(future_dates)
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = fc_df_monthly['yhat']
-        
-        return fc_df_monthly
-    
     except Exception as e:
-        st.error(f"이동 평균 모델 오류: {str(e)}")
-        return None
-
-def fit_weighted_ma(df, window, horizon_end):
-    """가중 이동 평균 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 마지막 window 개월의 가중 평균 계산
-        last_values = monthly_df['price'].iloc[-window:].to_numpy()
-        
-        # 가중치 생성 (최근 데이터에 더 높은 가중치)
-        weights = np.arange(1, window + 1)
-        weights = weights / np.sum(weights)
-        
-        wma_value = np.sum(last_values * weights)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행 (모든 미래 시점에 동일한 값)
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 신뢰 구간 추정
-        std_error = np.std(last_values)
-        lower_bound = wma_value - 1.96 * std_error
-        upper_bound = wma_value + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': [wma_value] * len(future_dates),
-            'yhat_lower': [lower_bound] * len(future_dates),
-            'yhat_upper': [upper_bound] * len(future_dates)
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = fc_df_monthly['yhat']
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"가중 이동 평균 모델 오류: {str(e)}")
-        return None
-
-def fit_naive(df, horizon_end):
-    """단순 Naive 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 마지막 값 사용
-        last_value = monthly_df['price'].iloc[-1]
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행 (모든 미래 시점에 마지막 값)
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 신뢰 구간 추정 (과거 12개월 표준편차 사용)
-        history_std = monthly_df['price'].iloc[-12:].std() if len(monthly_df) >= 12 else monthly_df['price'].std()
-        lower_bound = last_value - 1.96 * history_std
-        upper_bound = last_value + 1.96 * history_std
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': [last_value] * len(future_dates),
-            'yhat_lower': [lower_bound] * len(future_dates),
-            'yhat_upper': [upper_bound] * len(future_dates)
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = fc_df_monthly['yhat']
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Naive 모델 오류: {str(e)}")
-        return None
-
-def fit_seasonal_naive(df, horizon_end):
-    """계절성 Naive 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행 (각 월에 대해 작년 같은 달 가격 사용)
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        future_values = []
-        lower_bounds = []
-        upper_bounds = []
-        
-        for date in future_dates:
-            # 같은 월의 값 찾기
-            same_month_values = monthly_df[monthly_df.index.month == date.month]['price']
-            
-            if len(same_month_values) > 0:
-                # 같은 월 가장 최근 값 사용
-                forecast_value = same_month_values.iloc[-1]
-                
-                # 신뢰 구간
-                std_error = same_month_values.std() if len(same_month_values) > 1 else monthly_df['price'].std()
-                lower_bound = forecast_value - 1.96 * std_error
-                upper_bound = forecast_value + 1.96 * std_error
-            else:
-                # 같은 월 데이터 없으면 전체 평균 사용
-                forecast_value = monthly_df['price'].mean()
-                std_error = monthly_df['price'].std()
-                lower_bound = forecast_value - 1.96 * std_error
-                upper_bound = forecast_value + 1.96 * std_error
-                
-            future_values.append(forecast_value)
-            lower_bounds.append(lower_bound)
-            upper_bounds.append(upper_bound)
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': future_values,
-            'yhat_lower': lower_bounds,
-            'yhat_upper': upper_bounds
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = fc_df_monthly['yhat']
-        fc_df_monthly['trend'] = 0
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Seasonal Naive 모델 오류: {str(e)}")
-        return None
-
-def fit_fourier_lr(df, horizon_end):
-    """Fourier + 선형 회귀 모델 구현"""
-    from sklearn.linear_model import LinearRegression
-    
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 시간 변수 생성
-        y = monthly_df['price'].values
-        t = np.arange(len(y))
-        
-        # Fourier 특성 생성 (연간 계절성)
-        p = 12  # 주기 (1년)
-        X = np.column_stack([
-            t,  # 선형 추세
-            np.sin(2 * np.pi * t / p),
-            np.cos(2 * np.pi * t / p),
-            np.sin(4 * np.pi * t / p),
-            np.cos(4 * np.pi * t / p)
-        ])
-        
-        # 모델 학습
-        model = LinearRegression()
-        model.fit(X, y)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        # 미래 시점 특성 생성
-        t_future = np.arange(len(y), len(y) + periods)
-        X_future = np.column_stack([
-            t_future,
-            np.sin(2 * np.pi * t_future / p),
-            np.cos(2 * np.pi * t_future / p),
-            np.sin(4 * np.pi * t_future / p),
-            np.cos(4 * np.pi * t_future / p)
-        ])
-        
-        # 예측
-        forecast = model.predict(X_future)
-        
-        # 신뢰 구간 추정
-        y_pred = model.predict(X)
-        mse = np.mean((y - y_pred) ** 2)
-        std_error = np.sqrt(mse)
-        
-        lower_bound = forecast - 1.96 * std_error
-        upper_bound = forecast + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': forecast,
-            'yhat_lower': lower_bound,
-            'yhat_upper': upper_bound
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['trend'] = model.coef_[0] * np.arange(len(fc_df_monthly)) + model.intercept_
-        
-        # 계절성 계산
-        season_features = np.column_stack([
-            np.sin(2 * np.pi * np.arange(len(fc_df_monthly)) / p),
-            np.cos(2 * np.pi * np.arange(len(fc_df_monthly)) / p),
-            np.sin(4 * np.pi * np.arange(len(fc_df_monthly)) / p),
-            np.cos(4 * np.pi * np.arange(len(fc_df_monthly)) / p)
-        ])
-        
-        seasonal_effect = np.dot(season_features, model.coef_[1:5])
-        fc_df_monthly['yearly'] = seasonal_effect
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Fourier + LR 모델 오류: {str(e)}")
-        return None
-
-def fit_linear_trend(df, horizon_end):
-    """선형 추세 모델 구현"""
-    from sklearn.linear_model import LinearRegression
-    
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 시간 변수 생성
-        y = monthly_df['price'].values
-        t = np.arange(len(y)).reshape(-1, 1)
-        
-        # 모델 학습
-        model = LinearRegression()
-        model.fit(t, y)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        t_future = np.arange(len(y), len(y) + periods).reshape(-1, 1)
-        forecast = model.predict(t_future)
-        
-        # 신뢰 구간 추정
-        y_pred = model.predict(t)
-        mse = np.mean((y - y_pred) ** 2)
-        std_error = np.sqrt(mse)
-        
-        lower_bound = forecast - 1.96 * std_error
-        upper_bound = forecast + 1.96 * std_error
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': forecast,
-            'yhat_lower': lower_bound,
-            'yhat_upper': upper_bound
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = fc_df_monthly['yhat']
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Linear Trend 모델 오류: {str(e)}")
-        return None
-
-def fit_simple_exp_smoothing(df, horizon_end):
-    """단순 지수 평활 모델 구현"""
-    # 월별 데이터 준비
-    monthly_df = prepare_monthly_data(df)
-    
-    try:
-        # 모델 학습
-        model = SimpleExpSmoothing(monthly_df['price'])
-        results = model.fit(optimized=True)
-        
-        # 예측 기간 계산
-        last_date = monthly_df.index[-1]
-        end_date = pd.Timestamp(horizon_end)
-        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
-        
-        # 예측 수행
-        forecast = results.forecast(periods)
-        
-        # 신뢰 구간 추정
-        std_error = np.std(results.resid)
-        lower_bound = forecast - 1.96 * std_error
-        upper_bound = forecast + 1.96 * std_error
-        
-        # Prophet 형식으로 결과 변환
-        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
-        
-        fc_df = pd.DataFrame({
-            'ds': future_dates,
-            'yhat': forecast.values,
-            'yhat_lower': lower_bound.values,
-            'yhat_upper': upper_bound.values
-        })
-        
-        # 월별로 결과 변환
-        fc_df_monthly = pd.DataFrame({
-            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
-        })
-        
-        # 학습 데이터 기간의 결과 추가
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
-        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
-        
-        # 예측 기간의 결과 추가
-        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
-        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
-        
-        # yearly, trend 컴포넌트 추가 (Prophet 호환)
-        fc_df_monthly['yearly'] = 0
-        fc_df_monthly['trend'] = fc_df_monthly['yhat']
-        
-        return fc_df_monthly
-    
-    except Exception as e:
-        st.error(f"Simple Exponential Smoothing 모델 오류: {str(e)}")
-        return None
-
-@st.cache_data(show_spinner=False, ttl=3600)
-def fit_optimal_model(df, item_name, horizon_end, model_type="primary"):
-    """품목별 최적 모델 적용"""
-    # 데이터 준비 및 정리
-    df = df.copy()
-    df = df.dropna(subset=["date", "price"])
-    
-    # 품목별 최적 모델 선택
-    model_info = get_best_model_for_item(item_name)
-    
-    if model_type == "primary":
-        model_name = model_info["model1"]
-        accuracy = model_info["accuracy1"]
-    else:  # backup
-        model_name = model_info["model2"]
-        accuracy = model_info["accuracy2"]
-    
-    st.info(f"{item_name}에 최적화된 {model_name} 모델 적용 (정확도: {accuracy}%)")
-    
-    # 특수 처리가 필요한 품목 확인
-    needs_monitoring = "special" in model_info and model_info["special"] == "accuracy_drop"
-    if needs_monitoring:
-        st.warning(f"⚠️ {item_name}는 특정 월에 정확도가 급락할 수 있는 품목입니다. 예측 결과를 주의 깊게 살펴보세요.")
-    
-    # 모델 선택 및 학습
-    if "SARIMA(1,0,1)(1,0,1,12)" in model_name:
-        return fit_sarima(df, order=(1,0,1), seasonal_order=(1,0,1,12), horizon_end=horizon_end)
-    elif "SARIMA(1,1,1)(1,1,1,12)" in model_name:
-        return fit_sarima(df, order=(1,1,1), seasonal_order=(1,1,1,12), horizon_end=horizon_end)
-    elif "SARIMA(0,1,1)(0,1,1,12)" in model_name:
-        return fit_sarima(df, order=(0,1,1), seasonal_order=(0,1,1,12), horizon_end=horizon_end)
-    elif "ETS(Multiplicative)" in model_name:
-        return fit_ets(df, seasonal_type="multiplicative", horizon_end=horizon_end)
-    elif "ETS(Additive)" in model_name:
-        return fit_ets(df, seasonal_type="additive", horizon_end=horizon_end)
-    elif "Holt-Winters" in model_name:
-        return fit_holt_winters(df, horizon_end=horizon_end)
-    elif "Holt" in model_name:
-        return fit_holt(df, horizon_end=horizon_end)
-    elif "MovingAverage-6 m" in model_name:
-        return fit_moving_average(df, window=6, horizon_end=horizon_end)
-    elif "WeightedMA-6 m" in model_name:
-        return fit_weighted_ma(df, window=6, horizon_end=horizon_end)
-    elif "Naive" in model_name and "Seasonal" not in model_name:
-        return fit_naive(df, horizon_end=horizon_end)
-    elif "SeasonalNaive" in model_name:
-        return fit_seasonal_naive(df, horizon_end=horizon_end)
-    elif "Fourier + LR" in model_name:
-        return fit_fourier_lr(df, horizon_end=horizon_end)
-    elif "LinearTrend" in model_name:
-        return fit_linear_trend(df, horizon_end=horizon_end)
-    elif "SimpleExpSmoothing" in model_name:
-        return fit_simple_exp_smoothing(df, horizon_end=horizon_end)
-    else:
-        st.warning(f"알 수 없는 모델: {model_name}. 기본 모델(SARIMA)을 사용합니다.")
-        return fit_sarima(df, order=(1,0,1), seasonal_order=(1,0,1,12), horizon_end=horizon_end)
-
-def fit_ensemble_model(df, item_name, horizon_end):
-    """1위와 2위 모델의 앙상블 수행"""
-    # 1위 모델 예측
-    fc1 = fit_optimal_model(df, item_name, horizon_end, model_type="primary")
-    
-    # 2위 모델 예측
-    fc2 = fit_optimal_model(df, item_name, horizon_end, model_type="backup")
-    
-    # 두 모델 모두 성공한 경우만 앙상블
-    if fc1 is not None and fc2 is not None:
-        # 앙상블 가중치 계산 (정확도 기반)
-        model_info = get_best_model_for_item(item_name)
-        acc1 = model_info["accuracy1"]
-        acc2 = model_info["accuracy2"]
-        
-        # 정확도 차이가 0.2%p 이내인 경우 앙상블 수행
-        accuracy_diff = abs(acc1 - acc2)
-        
-        if accuracy_diff <= 0.2:
-            st.success(f"두 모델의 정확도 차이가 {accuracy_diff:.2f}%p로 작아 앙상블을 수행합니다.")
-            
-            # 정확도 기반 가중치 계산
-            total_acc = acc1 + acc2
-            w1 = acc1 / total_acc
-            w2 = acc2 / total_acc
-            
-            # 앙상블 결과 생성
-            fc_ensemble = fc1.copy()
-            fc_ensemble['yhat'] = w1 * fc1['yhat'] + w2 * fc2['yhat']
-            fc_ensemble['yhat_lower'] = w1 * fc1['yhat_lower'] + w2 * fc2['yhat_lower']
-            fc_ensemble['yhat_upper'] = w1 * fc1['yhat_upper'] + w2 * fc2['yhat_upper']
-            
-            return fc_ensemble
-        else:
-            st.info(f"정확도 차이가 {accuracy_diff:.2f}%p로 커서 1위 모델만 사용합니다.")
-            return fc1
-    
-    # 하나라도 실패한 경우 성공한 모델 반환
-    return fc1 if fc1 is not None else fc2
-
-# -------------------------------------------------
-# MAIN APP ---------------------------------------
-# -------------------------------------------------
-# 데이터 로드
-raw_df = load_data()
-
-if len(raw_df) == 0:
-    st.error("데이터가 비어 있습니다. 파일을 확인해주세요.")
-    st.stop()
-
-st.sidebar.header("🔍 품목 선택")
-selected_item = st.sidebar.selectbox("품목", get_items(raw_df))
-current_date = date.today()
-st.sidebar.caption(f"오늘: {current_date}")
-
-# 선택된 품목의 최적 모델 정보 표시
-model_info = get_best_model_for_item(selected_item)
-st.sidebar.subheader("품목별 최적 모델")
-st.sidebar.markdown(f"**1위 모델:** {model_info['model1']} (정확도: {model_info['accuracy1']}%)")
-st.sidebar.markdown(f"**2위 모델:** {model_info['model2']} (정확도: {model_info['accuracy2']}%)")
-
-# 데이터 필터링
-item_df = raw_df.query("item == @selected_item").copy()
-if item_df.empty:
-    st.error("선택한 품목 데이터 없음")
-    st.stop()
-    
-# 데이터 수 검사
-if len(item_df) < 2:
-    st.warning(f"선택한 품목 '{selected_item}' 데이터가 너무 적습니다 (데이터 수: {len(item_df)}). 예측이 부정확할 수 있습니다.")
-else:
-    st.success(f"선택한 품목 '{selected_item}'에 대해 {len(item_df)}개의 데이터가 있습니다.")
-
-# -------------------------------------------------
-# MACRO FORECAST 1996‑2030 ------------------------
-# -------------------------------------------------
-# -------------------------------------------------
-# MACRO FORECAST 1996‑2030 ------------------------
-# -------------------------------------------------
-st.header(f"📈 {selected_item} 가격 예측 대시보드")
-
-# 데이터 필터링 로직
-try:
-    macro_start_dt = pd.Timestamp("1996-01-01")
-    # 데이터의 시작일이 1996년 이후인지 확인
-    if item_df["date"].min() > macro_start_dt:
-        macro_start_dt = item_df["date"].min()
-    
-    macro_df = item_df[item_df["date"] >= macro_start_dt].copy()
-except Exception as e:
-    st.error(f"날짜 필터링 오류: {str(e)}")
-    macro_df = item_df.copy()  # 필터링 없이 전체 데이터 사용
-
-# Add diagnostic info
-with st.expander("데이터 진단"):
-    st.write(f"- 전체 데이터 수: {len(item_df)}")
-    st.write(f"- 분석 데이터 수: {len(macro_df)}")
-    if len(macro_df) > 0:
-        st.write(f"- 기간: {macro_df['date'].min().strftime('%Y-%m-%d')} ~ {macro_df['date'].max().strftime('%Y-%m-%d')}")
-        st.dataframe(macro_df.head())
-    else:
-        st.write("데이터가 없습니다.")
-
-if len(macro_df) < 2:
-    st.warning(f"{selected_item}에 대한 데이터가 충분하지 않습니다. 전체 기간 데이터를 표시합니다.")
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=item_df["date"], y=item_df["price"], mode="lines", name="실제 가격"))
-    fig.update_layout(title=f"{selected_item} 과거 가격")
-    st.plotly_chart(fig, use_container_width=True)
-else:
-    try:
-        # 데이터 충분한 경우 품목별 최적 모델 사용
-        use_ensemble = st.checkbox("앙상블 모델 사용 (1위 + 2위 모델 결합)", value=False)
-        
-        with st.spinner("장기 예측 모델 생성 중..."):
-            if use_ensemble:
-                fc_macro = fit_ensemble_model(macro_df, selected_item, MACRO_END)
-            else:
-                fc_macro = fit_optimal_model(macro_df, selected_item, MACRO_END)
-        
-        if fc_macro is not None:
-            # 실제 데이터와 예측 데이터 구분
-            cutoff_date = pd.Timestamp("2025-01-01")
-            
-            # 플롯 생성
-            fig = go.Figure()
-            
-            # 실제 데이터 추가 (1996-2024)
-            historical_data = macro_df[macro_df["date"] < cutoff_date].copy()
-            if not historical_data.empty:
-                fig.add_trace(go.Scatter(
-                    x=historical_data["date"], 
-                    y=historical_data["price"],
-                    mode="lines",
-                    name="실제 가격 (1996-2024)",
-                    line=dict(color="blue", width=2)
-                ))
-            
-            # 예측 기간 자르기
-            forecast_data = fc_macro[fc_macro["ds"] >= cutoff_date].copy()
-            
-            # 2025-2030 예측 데이터
-            if not forecast_data.empty:
-                fig.add_trace(go.Scatter(
-                    x=forecast_data["ds"], 
-                    y=forecast_data["yhat"],
-                    mode="lines",
-                    name="예측 가격 (2025-2030)",
-                    line=dict(color="red", width=2, dash="dash")
-                ))
-                
-                # 신뢰 구간 추가
-                fig.add_trace(go.Scatter(
-                    x=forecast_data["ds"],
-                    y=forecast_data["yhat_upper"],
-                    mode="lines",
-                    line=dict(width=0),
-                    showlegend=False
-                ))
-                fig.add_trace(go.Scatter(
-                    x=forecast_data["ds"],
-                    y=forecast_data["yhat_lower"],
-                    mode="lines",
-                    line=dict(width=0),
-                    fill="tonexty",
-                    fillcolor="rgba(255, 0, 0, 0.1)",
-                    name="95% 신뢰 구간"
-                ))
-            
-            # 음수 예측값 제거
-            fig.update_yaxes(range=[0, None])
-            
-            # 레이아웃 설정
-            fig.update_layout(
-                title=f"{selected_item} 장기 가격 예측 (1996-2030)",
-                xaxis_title="연도",
-                yaxis_title="가격 (원)",
-                legend=dict(
-                    orientation="h",
-                    yanchor="bottom",
-                    y=1.02,
-                    xanchor="right",
-                    x=1
-                )
-            )
-            
-            # 차트 표시
-            st.plotly_chart(fig, use_container_width=True)
-            
-            # 연도별 예측가 표시
-            try:
-                latest_price = macro_df.iloc[-1]["price"]
-                
-                # 연도별 예측가 계산을 위한 함수
-                def get_yearly_prediction(year_end):
-                    target_date = pd.Timestamp(f"{year_end}-12-31")
-                    # 날짜 기반으로 가장 가까운 날짜의 예측값 찾기
-                    date_diffs = abs(fc_macro["ds"] - target_date)
-                    closest_idx = date_diffs.idxmin()
-                    pred_value = fc_macro.loc[closest_idx, "yhat"]
-                    pct_change = (pred_value - latest_price) / latest_price * 100
-                    return pred_value, pct_change
-                
-                # 연도별 예측가 표시
-                col1, col2, col3 = st.columns(3)
-                
-                # 2025년 예측가
-                pred_2025, pct_2025 = get_yearly_prediction(2025)
-                col1.metric("2025년 예측가", format_currency(pred_2025), f"{pct_2025:+.1f}%")
-                
-                # 2027년 예측가
-                pred_2027, pct_2027 = get_yearly_prediction(2027)
-                col2.metric("2027년 예측가", format_currency(pred_2027), f"{pct_2027:+.1f}%")
-                
-                # 2030년 예측가
-                pred_2030, pct_2030 = get_yearly_prediction(2030)
-                col3.metric("2030년 예측가", format_currency(pred_2030), f"{pct_2030:+.1f}%")
-                
-                # 추가 연도 예측가 (확장 가능)
-                with st.expander("더 많은 연도별 예측가 보기"):
-                    col4, col5, col6 = st.columns(3)
-                    
-                    # 2026년 예측가
-                    pred_2026, pct_2026 = get_yearly_prediction(2026)
-                    col4.metric("2026년 예측가", format_currency(pred_2026), f"{pct_2026:+.1f}%")
-                    
-                    # 2028년 예측가
-                    pred_2028, pct_2028 = get_yearly_prediction(2028)
-                    col5.metric("2028년 예측가", format_currency(pred_2028), f"{pct_2028:+.1f}%")
-                    
-                    # 2029년 예측가
-                    pred_2029, pct_2029 = get_yearly_prediction(2029)
-                    col6.metric("2029년 예측가", format_currency(pred_2029), f"{pct_2029:+.1f}%")
-                    
-            except Exception as e:
-                st.error(f"예측가 계산 오류: {str(e)}")
-        else:
-            st.warning("예측 모델을 생성할 수 없습니다.")
-            fig = go.Figure()
-            fig.add_trace(go.Scatter(x=macro_df["date"], y=macro_df["price"], mode="lines", name="실제 가격"))
-            fig.update_layout(title=f"{selected_item} 과거 가격")
-            st.plotly_chart(fig, use_container_width=True)
-    except Exception as e:
-        st.error(f"장기 예측 오류 발생: {str(e)}")
+        st.error(f"⚠️ Error loading or executing the application: {str(e)}")
         import traceback
         st.code(traceback.format_exc())
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(x=macro_df["date"], y=macro_df["price"], mode="lines", name="실제 가격"))
-        fig.update_layout(title=f"{selected_item} 과거 가격")
-        st.plotly_chart(fig, use_container_width=True)
-
-# -------------------------------------------------
-# MICRO FORECAST 2024‑2026 ------------------------
-# -------------------------------------------------
-# -------------------------------------------------
-# MICRO FORECAST 2024‑2026 ------------------------
-# -------------------------------------------------
-st.subheader("🔎 2024–2026 단기 예측 (월별)")
-
-# 데이터 필터링 - 최근 3년 데이터 활용
-try:
-    three_years_ago = pd.Timestamp("2021-01-01")
-    if item_df["date"].min() > three_years_ago:
-        three_years_ago = item_df["date"].min()
-    
-    micro_df = item_df[item_df["date"] >= three_years_ago].copy()
-except Exception as e:
-    st.error(f"단기 예측 데이터 필터링 오류: {str(e)}")
-    # 최근 데이터 사용
-    micro_df = item_df.sort_values("date").tail(24).copy()
-
-if len(micro_df) < 2:
-    st.warning(f"최근 데이터가 충분하지 않습니다.")
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=item_df["date"], y=item_df["price"], mode="lines", name="실제 가격"))
-    fig.update_layout(title=f"{selected_item} 최근 가격")
-    st.plotly_chart(fig, use_container_width=True)
-else:
-    try:
-        with st.spinner("단기 예측 모델 생성 중..."):
-            if use_ensemble:
-                fc_micro = fit_ensemble_model(micro_df, selected_item, MICRO_END)
-            else:
-                fc_micro = fit_optimal_model(micro_df, selected_item, MICRO_END)
-            
-        if fc_micro is not None:
-            # 2024-01-01부터 2026-12-31까지 필터링
-            start_date = pd.Timestamp("2024-01-01")
-            end_date = pd.Timestamp("2026-12-31")
-            
-            # 월별 데이터 준비
-            monthly_historical = micro_df.copy()
-            monthly_historical["year_month"] = monthly_historical["date"].dt.strftime("%Y-%m")
-            monthly_historical = monthly_historical.groupby("year_month").agg({
-                "date": "first", 
-                "price": "mean"
-            }).reset_index(drop=True)
-            
-            monthly_historical = monthly_historical[
-                (monthly_historical["date"] >= start_date) & 
-                (monthly_historical["date"] <= end_date)
-            ]
-            
-            monthly_forecast = fc_micro[
-                (fc_micro["ds"] >= start_date) & 
-                (fc_micro["ds"] <= end_date)
-            ].copy()
-            
-            # 월별 차트 생성
-            fig = go.Figure()
-            
-            # 2024년 실제 데이터
-            actual_2024 = monthly_historical[
-                (monthly_historical["date"] >= pd.Timestamp("2024-01-01")) & 
-                (monthly_historical["date"] <= pd.Timestamp("2024-12-31"))
-            ]
-            
-            if not actual_2024.empty:
-                fig.add_trace(go.Scatter(
-                    x=actual_2024["date"],
-                    y=actual_2024["price"],
-                    mode="lines+markers",
-                    name="2024 실제 가격",
-                    line=dict(color="blue", width=2),
-                    marker=dict(size=8)
-                ))
-            
-            # 2024년 이후 예측 데이터
-            cutoff = pd.Timestamp("2024-12-31")
-            future_data = monthly_forecast[monthly_forecast["ds"] > cutoff]
-            
-            if not future_data.empty:
-                fig.add_trace(go.Scatter(
-                    x=future_data["ds"],
-                    y=future_data["yhat"],
-                    mode="lines+markers",
-                    name="2025-2026 예측 가격",
-                    line=dict(color="red", width=2, dash="dash"),
-                    marker=dict(size=8)
-                ))
-                
-                # 신뢰 구간 추가
-                fig.add_trace(go.Scatter(
-                    x=future_data["ds"],
-                    y=future_data["yhat_upper"],
-                    mode="lines",
-                    line=dict(width=0),
-                    showlegend=False
-                ))
-                fig.add_trace(go.Scatter(
-                    x=future_data["ds"],
-                    y=future_data["yhat_lower"],
-                    mode="lines",
-                    line=dict(width=0),
-                    fill="tonexty",
-                    fillcolor="rgba(255, 0, 0, 0.1)",
-                    name="95% 신뢰 구간"
-                ))
-            
-            # 음수 예측값 제거
-            fig.update_yaxes(range=[0, None])
-            
-            # 레이아웃 설정
-            fig.update_layout(
-                title=f"{selected_item} 월별 단기 예측 (2024-2026)",
-                xaxis_title="월",
-                yaxis_title="가격 (원)",
-                xaxis=dict(
-                    tickformat="%Y-%m",
-                    dtick="M3",  # 3개월 간격
-                    tickangle=45
-                ),
-                legend=dict(
-                    orientation="h",
-                    yanchor="bottom",
-                    y=1.02,
-                    xanchor="right",
-                    x=1
-                )
-            )
-            
-            # 차트 표시
-            st.plotly_chart(fig, use_container_width=True)
-            
-            # 월별 예측 가격 표시 (2025-2026)
-            with st.expander("월별 예측 가격 상세보기"):
-                monthly_detail = monthly_forecast[monthly_forecast["ds"] > cutoff].copy()
-                monthly_detail["날짜"] = monthly_detail["ds"].dt.strftime("%Y년 %m월")
-                monthly_detail["예측가격"] = monthly_detail["yhat"].apply(format_currency)
-                monthly_detail["하한값"] = monthly_detail["yhat_lower"].apply(format_currency)
-                monthly_detail["상한값"] = monthly_detail["yhat_upper"].apply(format_currency)
-                
-                st.dataframe(
-                    monthly_detail[["날짜", "예측가격", "하한값", "상한값"]], 
-                    hide_index=True
-                )
-            
-            # 월별/연도별 예측가 표시 함수
-            def get_monthly_prediction(year, month):
-                target_date = pd.Timestamp(f"{year}-{month:02d}-01")
-                # 가장 가까운 날짜의 예측값 찾기
-                date_diffs = abs(monthly_forecast["ds"] - target_date)
-                closest_idx = date_diffs.idxmin()
-                
-                if closest_idx in monthly_forecast.index:
-                    pred_value = monthly_forecast.loc[closest_idx, "yhat"]
-                    
-                    # 현재 가격 기준 변화율 계산
-                    latest_price = monthly_historical.iloc[-1]["price"] if not monthly_historical.empty else micro_df.iloc[-1]["price"]
-                    pct_change = (pred_value - latest_price) / latest_price * 100
-                    
-                    return pred_value, pct_change
-                else:
-                    return None, None
-            
-            # 2025년과 2026년의 주요 월별 예측가
-            st.subheader("주요 월별 예측가")
-            
-            col1, col2, col3 = st.columns(3)
-            
-            # 2025년 6월 예측가
-            pred_2025_06, pct_2025_06 = get_monthly_prediction(2025, 6)
-            if pred_2025_06 is not None:
-                col1.metric("2025년 6월", format_currency(pred_2025_06), f"{pct_2025_06:+.1f}%")
-            else:
-                col1.metric("2025년 6월", "데이터 없음", "0%")
-            
-            # 2025년 12월 예측가
-            pred_2025_12, pct_2025_12 = get_monthly_prediction(2025, 12)
-            if pred_2025_12 is not None:
-                col2.metric("2025년 12월", format_currency(pred_2025_12), f"{pct_2025_12:+.1f}%")
-            else:
-                col2.metric("2025년 12월", "데이터 없음", "0%")
-            
-            # 2026년 12월 예측가
-            pred_2026_12, pct_2026_12 = get_monthly_prediction(2026, 12)
-            if pred_2026_12 is not None:
-                col3.metric("2026년 12월", format_currency(pred_2026_12), f"{pct_2026_12:+.1f}%")
-            else:
-                col3.metric("2026년 12월", "데이터 없음", "0%")
-            
-            # 농산물 계절성에 맞는 추가 월별 데이터 표시
-            with st.expander("더 많은 월별 예측가 보기"):
-                # 분기별로 나눠서 표시
-                for year in [2025, 2026]:
-                    st.write(f"### {year}년 분기별 예측가")
-                    q1, q2, q3, q4 = st.columns(4)
-                    
-                    # 1분기 (3월)
-                    pred_q1, pct_q1 = get_monthly_prediction(year, 3)
-                    if pred_q1 is not None:
-                        q1.metric(f"{year}년 3월", format_currency(pred_q1), f"{pct_q1:+.1f}%")
-                    else:
-                        q1.metric(f"{year}년 3월", "데이터 없음", "0%")
-                    
-                    # 2분기 (6월)
-                    pred_q2, pct_q2 = get_monthly_prediction(year, 6)
-                    if pred_q2 is not None:
-                        q2.metric(f"{year}년 6월", format_currency(pred_q2), f"{pct_q2:+.1f}%")
-                    else:
-                        q2.metric(f"{year}년 6월", "데이터 없음", "0%")
-                    
-                    # 3분기 (9월)
-                    pred_q3, pct_q3 = get_monthly_prediction(year, 9)
-                    if pred_q3 is not None:
-                        q3.metric(f"{year}년 9월", format_currency(pred_q3), f"{pct_q3:+.1f}%")
-                    else:
-                        q3.metric(f"{year}년 9월", "데이터 없음", "0%")
-                    
-                    # 4분기 (12월)
-                    pred_q4, pct_q4 = get_monthly_prediction(year, 12)
-                    if pred_q4 is not None:
-                        q4.metric(f"{year}년 12월", format_currency(pred_q4), f"{pct_q4:+.1f}%")
-                    else:
-                        q4.metric(f"{year}년 12월", "데이터 없음", "0%")
-            
-        else:
-            st.warning("단기 예측 모델을 생성할 수 없습니다.")
-    except Exception as e:
-        st.error(f"단기 예측 오류: {str(e)}")
-        st.code(traceback.format_exc())
-
-# -------------------------------------------------
-# SEASONALITY & PATTERN ---------------------------
-# -------------------------------------------------
-if 'fc_micro' in locals() and fc_micro is not None:
-    with st.expander("📆 시즈널리티 & 패턴 설명"):
-        try:
-            # 월별 계절성 분석
-            if "yearly" in fc_micro.columns and fc_micro["yearly"].sum() != 0:
-                month_season = fc_micro.copy()
-                month_season["month"] = month_season["ds"].dt.month
-                month_seasonality = month_season.groupby("month")["yearly"].mean()
-                
-                # 월 이름 설정
-                month_names = ["1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월"]
-                
-                # 계절성 차트 그리기
-                fig = go.Figure()
-                fig.add_trace(go.Bar(
-                    x=month_names,
-                    y=month_seasonality.values,
-                    marker_color=['blue' if x >= 0 else 'red' for x in month_seasonality.values]
-                ))
-                
-                fig.update_layout(
-                    title=f"{selected_item} 월별 계절성 패턴",
-                    xaxis_title="월",
-                    yaxis_title="상대적 가격 변동",
-                )
-                
-                st.plotly_chart(fig, use_container_width=True)
-                
-                # 피크와 저점 계산
-                peak_month = month_seasonality.idxmax()
-                low_month = month_seasonality.idxmin()
-                seasonality_range = month_seasonality.max() - month_seasonality.min()
-                
-                st.markdown(
-                    f"**연간 피크 월:** {month_names[peak_month-1]}  \n"
-                    f"**연간 저점 월:** {month_names[low_month-1]}  \n"
-                    f"**연간 변동폭:** {seasonality_range:.1f}")
-                
-                # 계절성이 높은 품목인지 설명
-                if abs(seasonality_range) > 30:
-                    st.info(f"{selected_item}은(는) 계절성이 매우 강한 품목입니다. 특정 달에 가격이 크게 변동할 수 있습니다.")
-                elif abs(seasonality_range) > 10:
-                    st.info(f"{selected_item}은(는) 계절성이 중간 정도인 품목입니다.")
-                else:
-                    st.info(f"{selected_item}은(는) 계절성이 약한 품목입니다. 연중 가격이 비교적 안정적입니다.")
-        except Exception as e:
-            st.error(f"계절성 분석 오류: {str(e)}")
-            st.info("이 품목에 대한 계절성 패턴을 분석할 수 없습니다.")
 
-# -------------------------------------------------
-# FOOTER ------------------------------------------
-# -------------------------------------------------
-st.markdown("---")
-st.caption("© 2025 품목별 가격 예측 시스템 | 데이터 분석 자동화")
+if __name__ == "__main__":
+    main()