Update app.py

app.py

@@ -7,6 +7,17 @@ import pandas as pd
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import plotly.express as px
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+# Supabase 연동 추가
+try:
+    from supabase import create_client, Client
+    SUPABASE_AVAILABLE = True
+except ImportError:
+    SUPABASE_AVAILABLE = False
+    print("Supabase 패키지가 설치되지 않았습니다.")
 
 STATIONS = [
     "DT_0001", "DT_0065", "DT_0008", "DT_0067", "DT_0043", "DT_0002",
@@ -15,25 +26,124 @@ STATIONS = [
 ]
 
 STATION_NAMES = {
-    "DT_0001": "인천", 
-    "DT_0065": "덕적도", 
-    "DT_0008": "안산", 
-    "DT_0067": "안흥", 
-    "DT_0043": "영흥도", 
-    "DT_0002": "평택",
-    "DT_0050": "태안", 
-    "DT_0017": "대산", 
-    "DT_0052": "인천송도", 
-    "DT_0025": "보령", 
-    "DT_0051": "서천마량", 
-    "DT_0037": "어청도",
-    "DT_0024": "장항", 
-    "DT_0018": "군산", 
-    "DT_0068": "위도", 
-    "DT_0003": "영광", 
-    "DT_0066": "향화도"
+    "DT_0001": "인천", "DT_0002": "평택", "DT_0003": "영광", "DT_0008": "안산",
+    "DT_0017": "대산", "DT_0018": "군산", "DT_0024": "장항", "DT_0025": "보령",
+    "DT_0037": "어청도", "DT_0043": "영흥도", "DT_0050": "태안", "DT_0051": "서천마량",
+    "DT_0052": "인천송도", "DT_0065": "덕적도", "DT_0066": "향화도", "DT_0067": "안흥",
+    "DT_0068": "위도"
 }
 
+def get_supabase_client():
+    """Supabase 클라이언트 생성"""
+    if not SUPABASE_AVAILABLE:
+        return None
+    
+    try:
+        url = os.getenv("SUPABASE_URL")
+        key = os.getenv("SUPABASE_KEY")
+        
+        if not url or not key:
+            print("Supabase 환경변수가 설정되지 않았습니다.")
+            return None
+            
+        return create_client(url, key)
+    except Exception as e:
+        print(f"Supabase 연결 오류: {e}")
+        return None
+
+def get_harmonic_predictions(station_id, start_time, end_time):
+    """해당 시간 범위의 조화 예측값 조회"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return []
+    
+    try:
+        result = supabase.table('harmonic_predictions')\
+            .select('predicted_at, harmonic_level')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_time.isoformat())\
+            .lte('predicted_at', end_time.isoformat())\
+            .order('predicted_at')\
+            .execute()
+        
+        return result.data if result.data else []
+    except Exception as e:
+        print(f"조화 예측값 조회 오류: {e}")
+        return []
+
+def calculate_final_tide(residual_predictions, station_id, last_time):
+    """잔차 예측 + 조화 예측 = 최종 조위 계산"""
+    # 미래 시간 범위 계산 (72개 포인트, 5분 간격)
+    start_time = last_time + timedelta(minutes=5)
+    end_time = last_time + timedelta(minutes=72*5)
+    
+    # 조화 예측값 조회
+    harmonic_data = get_harmonic_predictions(station_id, start_time, end_time)
+    
+    if not harmonic_data:
+        print("조화 예측 데이터를 찾을 수 없습니다. 잔차 예측만 반환합니다.")
+        return {
+            'times': [last_time + timedelta(minutes=(i+1)*5) for i in range(len(residual_predictions))],
+            'residual': residual_predictions.flatten(),
+            'harmonic': [0] * len(residual_predictions),
+            'final_tide': residual_predictions.flatten()
+        }
+    
+    # 시간별 매칭
+    final_results = {
+        'times': [],
+        'residual': [],
+        'harmonic': [],
+        'final_tide': []
+    }
+    
+    for i, residual in enumerate(residual_predictions.flatten()):
+        pred_time = last_time + timedelta(minutes=(i+1)*5)
+        
+        # 가장 가까운 조화 예측값 찾기
+        harmonic_value = 0
+        for h_data in harmonic_data:
+            h_time = datetime.fromisoformat(h_data['predicted_at'].replace('Z', '+00:00'))
+            if abs((h_time - pred_time).total_seconds()) < 300:  # 5분 이내
+                harmonic_value = h_data['harmonic_level']
+                break
+        
+        final_tide = residual + harmonic_value
+        
+        final_results['times'].append(pred_time)
+        final_results['residual'].append(residual)
+        final_results['harmonic'].append(harmonic_value)
+        final_results['final_tide'].append(final_tide)
+    
+    return final_results
+
+def save_predictions_to_supabase(station_id, prediction_results):
+    """예측 결과를 Supabase에 저장"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return 0
+    
+    try:
+        insert_data = []
+        for i in range(len(prediction_results['times'])):
+            insert_data.append({
+                'station_id': station_id,
+                'predicted_at': prediction_results['times'][i].isoformat(),
+                'predicted_residual': float(prediction_results['residual'][i]),
+                'harmonic_level': float(prediction_results['harmonic'][i]),
+                'final_tide_level': float(prediction_results['final_tide'][i]),
+                'model_version': 'TimeXer-v1'
+            })
+        
+        result = supabase.table('tide_predictions')\
+            .upsert(insert_data, on_conflict='station_id,predicted_at,model_version')\
+            .execute()
+        
+        return len(insert_data)
+    except Exception as e:
+        print(f"예측 결과 저장 오류: {e}")
+        return 0
+
 def get_common_args(station_id):
     return [
         "--model", "TimeXer", "--features", "MS", "--seq_len", "144", "--pred_len", "72",
@@ -82,32 +192,18 @@ def execute_inference_and_get_results(command):
     except Exception as e:
         raise gr.Error(f"내부 오류: {str(e)}")
 
-def create_prediction_plot(predictions, input_data, station_name):
-    """예측 결과 시각화"""
-    print(f"Creating plot - predictions type: {type(predictions)}, shape: {predictions.shape}")
-    
-    # 입력 데이터에서 시간 정보 추출
-    input_df = pd.read_csv(input_data.name)
-    input_df['date'] = pd.to_datetime(input_df['date'])
-    
-    # 최근 24포인트(2시간)만 표시
-    recent_data = input_df.tail(24)
-    
-    # predictions를 안전하게 변환
-    pred_values = np.array(predictions).flatten()
-    print(f"Prediction values shape: {pred_values.shape}, first 5: {pred_values[:5]}")
-    
-    # 미래 시간 생성 - 더 안전한 방법
+def create_enhanced_prediction_plot(prediction_results, input_data, station_name):
+    """잔차 + 조화 + 최종 조위를 모두 표시하는 향상된 플롯"""
     try:
-        # 마지막 시간부터 시작
-        last_time = input_df['date'].iloc[-1]
+        # 입력 데이터에서 시간 정보 추출
+        input_df = pd.read_csv(input_data.name)
+        input_df['date'] = pd.to_datetime(input_df['date'])
+        
+        # 최근 24포인트(2시간)만 표시
+        recent_data = input_df.tail(24)
         
-        # 5분 간격으로 미래 시간 생성 - pandas.date_range 사용
-        future_times = pd.date_range(
-            start=last_time,
-            periods=len(pred_values) + 1,  # +1을 해서 시작점 포함
-            freq='5min'
-        )[1:]  # 첫 번째 (현재 시간) 제외
+        # 미래 시간들
+        future_times = prediction_results['times']
         
         # 플롯 생성
         fig = go.Figure()
@@ -122,148 +218,64 @@ def create_prediction_plot(predictions, input_data, station_name):
             marker=dict(size=4)
         ))
         
-        # 예측 데이터
+        # 잔차 예측
         fig.add_trace(go.Scatter(
             x=future_times,
-            y=pred_values,
+            y=prediction_results['residual'],
             mode='lines+markers',
-            name='예측 잔차조위',
+            name='잔차 예측',
             line=dict(color='red', width=2, dash='dash'),
+            marker=dict(size=3)
+        ))
+        
+        # 조화 예측
+        fig.add_trace(go.Scatter(
+            x=future_times,
+            y=prediction_results['harmonic'],
+            mode='lines',
+            name='조화 예측',
+            line=dict(color='orange', width=2)
+        ))
+        
+        # 최종 조위 (잔차 + 조화)
+        fig.add_trace(go.Scatter(
+            x=future_times,
+            y=prediction_results['final_tide'],
+            mode='lines+markers',
+            name='최종 조위',
+            line=dict(color='green', width=3),
             marker=dict(size=4)
         ))
         
         # 구분선 추가
+        last_time = input_df['date'].iloc[-1]
         fig.add_vline(x=last_time, line_dash="dot", line_color="gray", 
                       annotation_text="예측 시작점")
         
         fig.update_layout(
-            title=f'{station_name} 잔차조위 예측 결과',
+            title=f'{station_name} 통합 조위 예측 결과',
             xaxis_title='시간',
-            yaxis_title='잔차조위 (cm)',
+            yaxis_title='수위 (cm)',
             hovermode='x unified',
-            height=500,
+            height=600,
             showlegend=True,
             xaxis=dict(
-                tickformat='%H:%M<br>%m/%d'  # 시:분 + 월/일
+                tickformat='%H:%M<br>%m/%d'
             )
         )
         
-        print("Plot with time axis created successfully")
-        
-    except Exception as time_error:
-        print(f"Time axis creation failed: {time_error}, falling back to sequence")
+        return fig
         
-        # 시간축 실패 시 순서 기반으로 fallback
+    except Exception as e:
+        print(f"Enhanced plot creation error: {e}")
+        # 에러 시 기본 플롯 반환
         fig = go.Figure()
-        
-        # 과거 데이터 (최근 2시간) - 순서 기반
-        recent_indices = list(range(-len(recent_data), 0))
-        fig.add_trace(go.Scatter(
-            x=recent_indices,
-            y=recent_data['residual'],
-            mode='lines+markers',
-            name='실제 잔차조위',
-            line=dict(color='blue', width=2),
-            marker=dict(size=4)
-        ))
-        
-        # 예측 데이터 - 순서 기반
-        future_indices = list(range(1, len(pred_values) + 1))
-        fig.add_trace(go.Scatter(
-            x=future_indices,
-            y=pred_values,
-            mode='lines+markers',
-            name='예측 잔차조위',
-            line=dict(color='red', width=2, dash='dash'),
-            marker=dict(size=4)
-        ))
-        
-        # 구분선 추가
-        fig.add_vline(x=0, line_dash="dot", line_color="gray", 
-                      annotation_text="예측 시작점")
-        
-        fig.update_layout(
-            title=f'{station_name} 잔차조위 예측 결과',
-            xaxis_title='시간 순서 (5분 간격)',
-            yaxis_title='잔차조위 (cm)',
-            hovermode='x unified',
-            height=500,
-            showlegend=True
+        fig.add_annotation(
+            text=f"시각화 생성 중 오류: {str(e)}",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False
         )
-    
-    return fig
-
-def create_evaluation_plot(predictions, truths, station_name):
-    """평가 결과 시각화"""
-    # 성능 메트릭 계산
-    mae = np.mean(np.abs(predictions - truths))
-    mse = np.mean((predictions - truths) ** 2)
-    rmse = np.sqrt(mse)
-    
-    # 서브플롯 생성
-    fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=[
-            '첫 번째 샘플: 예측 vs 실제',
-            '전체 샘플 MAE 분포',
-            '예측값 vs 실제값 산점도 (처음 1000개 포인트)',
-            '시간별 오차 분포'
-        ],
-        specs=[[{"secondary_y": False}, {"secondary_y": False}],
-               [{"secondary_y": False}, {"secondary_y": False}]]
-    )
-    
-    # 1. 첫 번째 샘플 비교
-    time_steps = list(range(72))
-    fig.add_trace(
-        go.Scatter(x=time_steps, y=predictions[0].flatten(), 
-                  name='예측', line=dict(color='red')),
-        row=1, col=1
-    )
-    fig.add_trace(
-        go.Scatter(x=time_steps, y=truths[0].flatten(), 
-                  name='실제', line=dict(color='blue')),
-        row=1, col=1
-    )
-    
-    # 2. MAE 분포
-    sample_maes = np.mean(np.abs(predictions - truths), axis=(1,2))
-    fig.add_trace(
-        go.Histogram(x=sample_maes, name='MAE 분포', nbinsx=20),
-        row=1, col=2
-    )
-    
-    # 3. 산점도 (메모리 절약을 위해 처음 1000개 포인트만)
-    pred_flat = predictions.flatten()[:1000]
-    true_flat = truths.flatten()[:1000]
-    fig.add_trace(
-        go.Scatter(x=true_flat, y=pred_flat, mode='markers', 
-                  name='예측 vs 실제', marker=dict(size=3, opacity=0.6)),
-        row=2, col=1
-    )
-    # 완벽한 예측선 추가
-    min_val, max_val = min(min(pred_flat), min(true_flat)), max(max(pred_flat), max(true_flat))
-    fig.add_trace(
-        go.Scatter(x=[min_val, max_val], y=[min_val, max_val], 
-                  mode='lines', name='완벽한 예측', line=dict(dash='dash', color='gray')),
-        row=2, col=1
-    )
-    
-    # 4. 시간별 오차
-    time_errors = np.mean(np.abs(predictions - truths), axis=0).flatten()
-    fig.add_trace(
-        go.Scatter(x=time_steps, y=time_errors, 
-                  name='시간별 평균 오차', line=dict(color='orange')),
-        row=2, col=2
-    )
-    
-    fig.update_layout(
-        title=f'{station_name} 성능 평가 결과<br>MAE: {mae:.3f} | MSE: {mse:.3f} | RMSE: {rmse:.3f}',
-        height=800,
-        showlegend=False
-    )
-    
-    return fig, {"MAE": mae, "MSE": mse, "RMSE": rmse}
+        return fig
 
 def single_prediction(station_id, input_csv_file):
     if input_csv_file is None: 
@@ -292,7 +304,7 @@ def single_prediction(station_id, input_csv_file):
                "--scaler_path", scaler_path, 
                "--predict_input_file", input_csv_file.name] + common_args
     
-    gr.Info(f"{station_name}({station_id}) 조위 예측을 실행중입니다...")
+    gr.Info(f"{station_name}({station_id}) 통합 조위 예측을 실행중입니다...")
     
     # inference 실행
     success, output = execute_inference_and_get_results(command)
@@ -301,51 +313,41 @@ def single_prediction(station_id, input_csv_file):
     try:
         prediction_file = "pred_results/prediction_future.npy"
         if os.path.exists(prediction_file):
-            predictions = np.load(prediction_file)
+            residual_predictions = np.load(prediction_file)
+            
+            # 입력 데이터에서 마지막 시간 추출
+            input_df = pd.read_csv(input_csv_file.name)
+            input_df['date'] = pd.to_datetime(input_df['date'])
+            last_time = input_df['date'].iloc[-1]
             
-            # 시각화 생성
-            plot = create_prediction_plot(predictions, input_csv_file, station_name)
+            # 최종 조위 계산 (��차 + 조화)
+            prediction_results = calculate_final_tide(residual_predictions, station_id, last_time)
+            
+            # 향상된 시각화 생성
+            plot = create_enhanced_prediction_plot(prediction_results, input_csv_file, station_name)
             
             # 예측 결과 테이블 생성
-            try:
-                import datetime
-                input_df = pd.read_csv(input_csv_file.name)
-                input_df['date'] = pd.to_datetime(input_df['date'])
-                last_date = input_df['date'].iloc[-1]
-                
-                # datetime 직접 사용으로 pandas 의존성 제거
-                if isinstance(last_date, pd.Timestamp):
-                    last_datetime = last_date.to_pydatetime()
-                else:
-                    last_datetime = pd.to_datetime(last_date).to_pydatetime()
-                
-                # 5분 간격으로 72개 시점 생성
-                time_points = []
-                for i in range(72):
-                    minutes_to_add = (i + 1) * 5
-                    next_time = last_datetime + datetime.timedelta(minutes=minutes_to_add)
-                    time_points.append(next_time)
-                
-                result_df = pd.DataFrame({
-                    '예측 시간': [t.strftime('%Y-%m-%d %H:%M') for t in time_points],
-                    '예측 잔차조위 (cm)': [f"{val:.2f}" for val in predictions]
-                })
-                
-            except Exception as e:
-                print(f"Table creation error: {e}")
-                # 에러 시 간단한 테이블 생성
-                result_df = pd.DataFrame({
-                    '예측 순서': [f"{i+1}번째 (+{(i+1)*5}분)" for i in range(len(predictions))],
-                    '예측 잔차조위 (cm)': [f"{val:.2f}" for val in predictions]
-                })
+            result_df = pd.DataFrame({
+                '예측 시간': [t.strftime('%Y-%m-%d %H:%M') for t in prediction_results['times']],
+                '잔차 예측 (cm)': [f"{val:.2f}" for val in prediction_results['residual']],
+                '조화 예측 (cm)': [f"{val:.2f}" for val in prediction_results['harmonic']],
+                '최종 조위 (cm)': [f"{val:.2f}" for val in prediction_results['final_tide']]
+            })
+            
+            # Supabase에 결과 저장
+            saved_count = save_predictions_to_supabase(station_id, prediction_results)
+            save_message = f"\n💾 Supabase에 {saved_count}개 예측 결과 저장 완료!" if saved_count > 0 else "\n⚠️ Supabase 저장 실패"
             
-            return plot, result_df, f"✅ 예측 완료!\n\n{output}"
+            return plot, result_df, f"✅ 통합 예측 완료!{save_message}\n\n{output}"
         else:
             return None, None, f"❌ 결과 파일을 찾을 수 없습니다.\n\n{output}"
             
     except Exception as e:
+        print(f"Result processing error: {e}")
+        import traceback
+        traceback.print_exc()
         return None, None, f"❌ 결과 처리 중 오류: {str(e)}\n\n{output}"
-
+        
 def rolling_evaluation(station_id, eval_csv_file):
     if eval_csv_file is None: 
         raise gr.Error("평가를 위한 입력 파일을 업로드해주세요.")
@@ -405,17 +407,22 @@ def rolling_evaluation(station_id, eval_csv_file):
         return None, None, f"❌ 결과 처리 중 오류: {str(e)}\n\n{output}"
 
 # Gradio 인터페이스
-with gr.Blocks(title="조위 예측 모델 v4.2", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🌊 조위 예측 모델 v4.2 (TimeXer 기반)")
-    gr.Markdown("TimeXer 모델을 사용한 한국 연안 17개 지점의 잔차조위 예측 시스템입니다.")
+with gr.Blocks(title="조위 예측 모델 v5.0", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🌊 통합 조위 예측 시스템 v5.0 (TimeXer + 조화분석)")
+    gr.Markdown("TimeXer 잔차 예측 + MATLAB 조화 예측을 결합한 최종 조위 예측 시스템입니다.")
+    
+    # Supabase 연결 상태 표시
+    supabase_status = "🟢 연결됨" if get_supabase_client() else "🔴 연결 안됨"
+    gr.Markdown(f"**Supabase 상태**: {supabase_status}")
     
     with gr.Tabs():
-        with gr.TabItem("🔮 단일 미래 예측"):
+        with gr.TabItem("🔮 통합 조위 예측"):
             gr.Markdown("""
-            ### 사용 방법
-            1. 관측소를 선택하세요
-            2. 최근 144개 포인트(12시간, 5분 간격)의 CSV 파일을 업로드하세요
-            3. 예측 실행 → 72개 포인트(6시간) 미래 잔차조위 예측 결과를 확인하세요
+            ### 🌟 새로운 기능
+            - **잔차 예측**: TimeXer 모델로 기상 영향 예측
+            - **조화 예측**: MATLAB 조화분석으로 천체 영향 예측
+            - **최종 조위**: 잔차 + 조화 = 완전한 조위 예측
+            - **자동 저장**: 예측 결과를 데이터베이스에 자동 저장
             """)
             
             with gr.Row():
@@ -432,47 +439,15 @@ with gr.Blocks(title="조위 예측 모델 v4.2", theme=gr.themes.Soft()) as dem
                         file_count="single"
                     )
             
-            submit_btn1 = gr.Button("🚀 예측 실행", variant="primary", size="lg")
+            submit_btn1 = gr.Button("🚀 통합 예측 실행", variant="primary", size="lg")
             
             with gr.Row():
                 with gr.Column(scale=2):
-                    plot_output1 = gr.Plot(label="예측 결과 시각화")
+                    plot_output1 = gr.Plot(label="통합 예측 결과 시각화")
                 with gr.Column(scale=1):
                     table_output1 = gr.Dataframe(label="예측 결과 테이블")
             
             text_output1 = gr.Textbox(label="실행 로그", lines=5, show_copy_button=True)
-            
-        with gr.TabItem("📊 전체 기간 롤링 평가"):
-            gr.Markdown("""
-            ### 사용 방법
-            1. 관측소를 선택하세요
-            2. 평가용 전체 데이터 CSV 파일을 업로드하세요 (최소 300행 필요)
-            3. 평가 실행 → 성능 메트릭과 예측 정확도를 확인하세요
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    station_dropdown2 = gr.Dropdown(
-                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS], 
-                        label="관측소 선택",
-                        value=STATIONS[0]
-                    )
-                with gr.Column(scale=2):
-                    file_input2 = gr.File(
-                        label="평가용 전체 데이터 (.csv 파일)", 
-                        file_types=[".csv"],
-                        file_count="single"
-                    )
-            
-            submit_btn2 = gr.Button("📈 평가 실행", variant="primary", size="lg")
-            
-            with gr.Row():
-                with gr.Column(scale=2):
-                    plot_output2 = gr.Plot(label="평가 결과 시각화")
-                with gr.Column(scale=1):
-                    table_output2 = gr.Dataframe(label="성능 메트릭")
-            
-            text_output2 = gr.Textbox(label="실행 로그", lines=5, show_copy_button=True)
     
     # 이벤트 바인딩
     submit_btn1.click(
@@ -481,42 +456,19 @@ with gr.Blocks(title="조위 예측 모델 v4.2", theme=gr.themes.Soft()) as dem
         outputs=[plot_output1, table_output1, text_output1],
         show_progress=True
     )
-    submit_btn2.click(
-        fn=rolling_evaluation, 
-        inputs=[station_dropdown2, file_input2], 
-        outputs=[plot_output2, table_output2, text_output2],
-        show_progress=True
-    )
     
     # 사용 안내
     gr.Markdown("""
-    ## 📋 CSV 파일 형식
-    
-    ```csv
-    date,air_pres,wind_dir,wind_speed,air_temp,residual
-    2024-01-01 00:00:00,1013.2,180,3.4,15.2,120.5
-    2024-01-01 00:05:00,1013.1,185,3.2,15.1,118.3
-    2024-01-01 00:10:00,1012.9,190,3.0,15.0,116.1
-    ...
-    ```
-    
-    **컬럼 설명:**
-    - **date**: 관측 시간 (5분 간격)
-    - **air_pres**: 기압 (hPa)
-    - **wind_dir**: 풍향 (도)
-    - **wind_speed**: 풍속 (m/s)
-    - **air_temp**: 기온 (°C)
-    - **residual**: 잔차 조위 (cm) - 예측 대상
+    ## 🎯 통합 예측 시스템 특징
     
-    ## 🏖️ 지원 관측소
-    인천, 덕적도, 안산, 안흥, 영흥도, 평택, 태안, 대산, 인천송도, 보령, 서천마량, 어청도, 장항, 군산, 위도, 영광, 향화도
+    ### 📊 4가지 예측 라인
+    - **파란색**: 실제 잔차조위 (과거 데이터)
+    - **빨간색**: 잔차 예측 (기상 영향)
+    - **주황색**: 조화 예측 (천체 영향) 
+    - **초록색**: 최종 조위 (잔차 + 조화)
     
-    ## ⚠️ 주의사항
-    - 예측용: 최소 144행 (12시간) 데이터 필요
-    - 평가용: 최소 300행 데이터 필요  
-    - 5분 간격 데이터 사용
-    - 처리 시간: 1-5분 소요 가능
-    - **예측 대상**: residual (잔차 조위) 컬럼
+    ### 💾 데이터 저장
+    모든 예측 결과는 Supabase 데이터베이스에 자동 저장되어 이후 분석 및 API 활용이 가능합니다.
     """)
 
 if __name__ == "__main__":