Create app-backup.py

app-backup.py

@@ -0,0 +1,1688 @@
+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')
+
+# 필요한 추가 라이브러리 로드
+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."""
+    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))
+        
+        # 표준화 전 상세 로그
+        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}개 행이 제외되었습니다.")
+        
+        # 표준화 후 로그
+        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())
+        
+        # 날짜 변환 전후 데이터 수 확인
+        before_date_convert = len(df)
+        
+        # YYYYMM 형식 변환 (숫자로 저장된 경우도 처리)
+        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
+        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)}")
+        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 품목별 가격 예측 시스템 | 데이터 분석 자동화")