Update app.py

app.py

@@ -1,14 +1,27 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-from prophet import Prophet
-import plotly.express as px
-import plotly.graph_objects as go
 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 ------------------------------------------
@@ -31,6 +44,77 @@ else:
 
 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 ---------------------------------------
 # -------------------------------------------------
@@ -38,7 +122,6 @@ 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 = {}
@@ -87,7 +170,6 @@ def _standardize_columns(df: pd.DataFrame) -> pd.DataFrame:
 
     return df
 
-
 @st.cache_data(show_spinner=False)
 def load_data() -> pd.DataFrame:
     """Load price data from CSV file."""
@@ -142,102 +224,910 @@ def load_data() -> pd.DataFrame:
         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 fit_prophet(df: pd.DataFrame, horizon_end: str, monthly=False, changepoint_prior_scale=0.05):
-    """
-    Prophet 모델�� 학습시키고 예측합니다.
-    
-    Args:
-        df: 학습 데이터 (date, price 컬럼 필요)
-        horizon_end: 예측 종료일
-        monthly: 월 단위 예측 여부
-        changepoint_prior_scale: 변화점 민감도 (낮을수록 과적합 감소)
-    """
-    # Make a copy and ensure we have data
-    df = df.copy()
-    df = df.dropna(subset=["date", "price"])
+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)
     
-    # 이상치 제거 (99 퍼센타일 초과 가격 제외)
-    upper_limit = df["price"].quantile(0.99)
-    df = df[df["price"] <= upper_limit]
+    # 인덱스 설정
+    monthly_df.set_index('date', inplace=True)
     
-    # 중복 날짜 처리
-    if monthly:
-        # 월 단위로 집계
-        df["year_month"] = df["date"].dt.strftime('%Y-%m')
-        df = df.groupby("year_month").agg({"date": "first", "price": "mean"}).reset_index(drop=True)
-    else:
-        # 일 단위로 집계
-        df = df.groupby("date")["price"].mean().reset_index()
+    # 결측치 보간 (월별 데이터에 빈 월이 있을 수 있음)
+    if len(monthly_df) > 1:
+        monthly_df = monthly_df.asfreq('M', method='ffill')
     
-    if len(df) < 2:
-        st.warning(f"데이터 포인트가 부족합니다. 예측을 위해서는 최소 2개 이상의 유효 데이터가 필요합니다. (현재 {len(df)}개)")
-        return None, None
+    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
     
-    # Convert to Prophet format
-    prophet_df = df.rename(columns={"date": "ds", "price": "y"})
+    # 월별 데이터 준비
+    monthly_df = prepare_monthly_data(df)
     
+    # 모델 학습
     try:
-        # Fit the model with tuned parameters
-        m = Prophet(
-            yearly_seasonality=True, 
-            weekly_seasonality=False, 
-            daily_seasonality=False,
-            changepoint_prior_scale=changepoint_prior_scale,  # 과적합 방지
-            seasonality_prior_scale=10.0,  # 계절성 조정
-            seasonality_mode='multiplicative'  # 곱셈 모드 (가격 데이터에 적합)
+        model = SARIMAX(
+            monthly_df['price'],
+            order=order,
+            seasonal_order=seasonal_order,
+            enforce_stationarity=False,
+            enforce_invertibility=False
         )
+        results = model.fit(disp=False)
         
-        # 한국 명절 효과 추가 (설날, 추석)
-        m.add_country_holidays(country_name='South Korea')
+        # 예측 기간 계산
+        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)
         
-        m.fit(prophet_df)
+        # 예측 수행
+        forecast = results.get_forecast(steps=periods)
+        pred_mean = forecast.predicted_mean
+        pred_ci = forecast.conf_int()
         
-        # Generate future dates
-        if monthly:
-            # 월 단위 예측
-            future_periods = (pd.Timestamp(horizon_end).year - df["date"].max().year) * 12 + \
-                             (pd.Timestamp(horizon_end).month - df["date"].max().month) + 1
-            future = m.make_future_dataframe(periods=future_periods, freq='MS')  # 월 시작일
-            future = future.resample('MS', on='ds').first().reset_index()  # 중복 제거
-        else:
-            # 일 단위 예측
-            periods = max((pd.Timestamp(horizon_end) - df["date"].max()).days, 1)
-            future = m.make_future_dataframe(periods=periods, freq="D")
+        # 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
+        })
         
-        # Make predictions
-        forecast = m.predict(future)
+        # 월별로 결과 변환 (날짜, 가격)
+        fc_df_monthly = pd.DataFrame({
+            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
+        })
         
-        # 예측값 범위 조정 (음수 예측 방지 및 상한값 설정)
-        forecast['yhat'] = np.maximum(forecast['yhat'], 0)  # 음수 제거
-        max_historical = prophet_df['y'].max() * 5  # 최대 역사적 가격의 5배로 제한
-        forecast['yhat'] = np.minimum(forecast['yhat'], max_historical)  # 상한값 설정
+        # 학습 데이터 기간의 ��과 추가
+        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
         
-        return m, forecast
+        # 예측 기간의 결과 추가
+        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"Prophet 모델 생성 중 오류: {str(e)}")
-        return None, None
+        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 format_currency(value):
-    """원화 형식으로 숫자 포맷팅"""
-    return f"{value:,.0f}원"
+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
 
 # -------------------------------------------------
-# LOAD DATA ---------------------------------------
+# MAIN APP ---------------------------------------
 # -------------------------------------------------
+# 데이터 로드
 raw_df = load_data()
 
 if len(raw_df) == 0:
@@ -249,6 +1139,13 @@ 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("선택한 품목 데이터 없음")
@@ -283,15 +1180,22 @@ with st.expander("데이터 진단"):
 
 if len(macro_df) < 2:
     st.warning(f"{selected_item}에 대한 데이터가 충분하지 않습니다. 전체 기간 데이터를 표시합니다.")
-    fig = px.line(item_df, x="date", y="price", title=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("장기 예측 모델 생성 중..."):
-            # 월 단위 예측으로 변경
-            m_macro, fc_macro = fit_prophet(macro_df, MACRO_END, monthly=True, changepoint_prior_scale=0.01)
+            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 m_macro is not None and fc_macro is not None:
+        if fc_macro is not None:
             # 실제 데이터와 예측 데이터 구분
             cutoff_date = pd.Timestamp("2025-01-01")
             
@@ -309,8 +1213,10 @@ else:
                     line=dict(color="blue", width=2)
                 ))
             
-            # 예측 데이터 추가 (2025-2030)
+            # 예측 기간 자르기
             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"], 
@@ -338,6 +1244,9 @@ else:
                     name="95% 신뢰 구간"
                 ))
             
+            # 음수 예측값 제거
+            fig.update_yaxes(range=[0, None])
+            
             # 레이아웃 설정
             fig.update_layout(
                 title=f"{selected_item} 장기 가격 예측 (1996-2030)",
@@ -373,11 +1282,17 @@ else:
                 st.error(f"예측가 계산 오류: {str(e)}")
         else:
             st.warning("예측 모델을 생성할 수 없습니다.")
-            fig = px.line(item_df, x="date", y="price", title=f"{selected_item} 과거 가격")
+            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)}")
-        fig = px.line(item_df, x="date", y="price", title=f"{selected_item} 과거 가격")
+        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)
 
 # -------------------------------------------------
@@ -399,15 +1314,19 @@ except Exception as e:
 
 if len(micro_df) < 2:
     st.warning(f"최근 데이터가 충분하지 않습니다.")
-    fig = px.line(item_df, x="date", y="price", title=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:
         with st.spinner("단기 예측 모델 생성 중..."):
-            # 월 단위 예측으로 변경
-            m_micro, fc_micro = fit_prophet(micro_df, MICRO_END, monthly=True, changepoint_prior_scale=0.05)
+            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 m_micro is not None and fc_micro is not None:
+        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")
@@ -481,6 +1400,9 @@ else:
                     name="95% 신뢰 구간"
                 ))
             
+            # 음수 예측값 제거
+            fig.update_yaxes(range=[0, None])
+            
             # 레이아웃 설정
             fig.update_layout(
                 title=f"{selected_item} 월별 단기 예측 (2024-2026)",
@@ -541,36 +1463,54 @@ else:
 # -------------------------------------------------
 # SEASONALITY & PATTERN ---------------------------
 # -------------------------------------------------
-with st.expander("📆 시즈널리티 & 패턴 설명"):
-    if 'm_micro' in locals() and m_micro is not None and 'fc_micro' in locals() and fc_micro is not None:
+if 'fc_micro' in locals() and fc_micro is not None:
+    with st.expander("📆 시즈널리티 & 패턴 설명"):
         try:
-            comp_fig = m_micro.plot_components(fc_micro)
-            st.pyplot(comp_fig)
-
-            month_season = (fc_micro[["ds", "yearly"]]
-                            .assign(month=lambda d: d.ds.dt.month)
-                            .groupby("month")["yearly"].mean())
-            st.markdown(
-                f"**연간 피크 월:** {int(month_season.idxmax())}월  \n"
-                f"**연간 저점 월:** {int(month_season.idxmin())}월  \n"
-                f"**연간 변동폭:** {month_season.max() - month_season.min():.1f}")
-            
-            # 월별 계절성 차트
-            month_names = ["1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월"]
-            month_values = month_season.values
-            
-            fig = px.bar(
-                x=month_names, 
-                y=month_values,
-                title=f"{selected_item} 월별 가격 변동 패턴",
-                labels={"x": "월", "y": "상대적 가격 변동"}
-            )
-            
-            st.plotly_chart(fig, use_container_width=True)
+            # 월별 계절성 분석
+            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)}")
-    else:
-        st.info("패턴 분석을 위한 충분한 데이터가 없습니다.")
+            st.error(f"계절성 분석 오류: {str(e)}")
+            st.info("이 품목에 대한 계절성 패턴을 분석할 수 없습니다.")
 
 # -------------------------------------------------
 # FOOTER ------------------------------------------