Update inference.py

inference.py

@@ -11,8 +11,9 @@ import json  # 👈 JSON 라이브러리 추가
 import sys
 sys.path.append('.')
 
-from models import TimeXer # 사용하는 모델에 맞게 수정
-from utils.metrics import metric # 성능 평가를 위해 추가
+from models import TimeXer
+from utils.metrics import metric
+from utils.timefeatures import time_features
 
 # --- 1. 인자 파싱 (수정 없음) ---
 parser = argparse.ArgumentParser(description='Time Series Prediction')
@@ -48,81 +49,123 @@ parser.add_argument('--freq', type=str, default='t', help='freq for time feature
 args = parser.parse_args()
 
 
+
+        prediction_padded = np.concatenate((padding, prediction_scaled), axis=1)
+        prediction = scaler.inverse_transform(prediction_padded)[:, -args.c_out:]
+    else:
+        prediction = scaler.inverse_transform(prediction_scaled)
+
+    return prediction
+
+
 # --- 2. 공통 함수: 모델 및 스케일러 로드 (수정 없음) ---
 def load_model_and_scaler(args):
     device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
-    # ⭐️ 수정 사항 2: args에 device 정보 추가 (TimeXer 모델 초기화 시 필요할 수 있음)
     args.device = device
     model = TimeXer.Model(args).float().to(device)
     model.load_state_dict(torch.load(args.checkpoint_path, map_location=device))
     model.eval()
     scaler = joblib.load(args.scaler_path)
-    # 진행 상황을 stderr로 출력하여 stdout의 JSON 결과와 분리
     print(f"Using device: {device}", file=sys.stderr)
     print("Model and scaler loaded successfully.", file=sys.stderr)
     return model, scaler, device
 
-# --- 3. 모드 1: 단일 미래 예측 함수 (수정 없음) ---
+# --- 3. 모드 1: 단일 미래 예측 함수 ---
 def predict_future(args, model, scaler, device):
-    # ... (이전과 동일한 코드) ...
-    # 이 함수는 예측 결과(prediction)만 반환하면 됩니다.
     df_input = pd.read_csv(args.predict_input_file)
-    if 'date' in df_input.columns:
-        df_input = df_input.drop(columns=['date'])
-    raw_input = df_input.tail(args.seq_len).values
+    df_input['date'] = pd.to_datetime(df_input['date'])
+
+    # ⭐️ 알려주신 정확한 컬럼 이름으로 수정
+    cols_to_scale = ['air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'residual']
     
+    # 1. 인코더 입력(x_enc) 생성
+    raw_input = df_input[cols_to_scale].tail(args.seq_len).values
     input_scaled = scaler.transform(raw_input)
     batch_x = torch.from_numpy(input_scaled).float().unsqueeze(0).to(device)
     
+    # 2. 인코더 시간 정보(x_mark_enc) 생성
+    df_stamp_enc = df_input.tail(args.seq_len)[['date']].reset_index(drop=True)
+    enc_mark = time_features(df_stamp_enc, timeenc=0, freq=args.freq)
+    batch_x_mark = torch.from_numpy(enc_mark).float().unsqueeze(0).to(device)
+    
+    # 3. 디코더 입력(x_dec) 생성
+    dec_inp_label = input_scaled[-args.label_len:]
+    dec_inp_pred = np.zeros([args.pred_len, args.enc_in])
+    decoder_input = np.concatenate([dec_inp_label, dec_inp_pred], axis=0)
+    batch_y = torch.from_numpy(decoder_input).float().unsqueeze(0).to(device)
+    
+    # 4. 디코더 시간 정보(x_mark_dec) 생성
+    last_date = df_stamp_enc['date'].iloc[-1]
+    future_dates = pd.date_range(start=last_date, periods=args.pred_len + 1, freq='5T')[1:] # 5분 단위 가정
+    df_stamp_dec = pd.DataFrame({'date': list(df_stamp_enc['date'].values[-args.label_len:]) + list(future_dates)})
+    dec_mark = time_features(df_stamp_dec, timeenc=0, freq=args.freq)
+    batch_y_mark = torch.from_numpy(dec_mark).float().unsqueeze(0).to(device)
+
+    # 5. 모델 호출
     with torch.no_grad():
-        # TimeXer 모델의 forward 함수에 맞게 인자 전달
-        # 여기서는 batch_x만 필요하다고 가정. 필요 시 batch_x_mark 등 추가
-        outputs = model(batch_x)
+        outputs = model(batch_x, batch_x_mark, batch_y, batch_y_mark)
         
     prediction_scaled = outputs.detach().cpu().numpy()[0]
     
-    # 스케일 복원 로직
-    if args.features == 'MS' and scaler.n_features_in_ > 1:
+    # 스케일 복원
+    if scaler.n_features_in_ > 1:
         padding = np.zeros((prediction_scaled.shape[0], scaler.n_features_in_ - args.c_out))
-        # 예측 결과를 마지막 feature 자리에 위치
         prediction_padded = np.concatenate((padding, prediction_scaled), axis=1)
         prediction = scaler.inverse_transform(prediction_padded)[:, -args.c_out:]
     else:
         prediction = scaler.inverse_transform(prediction_scaled)
-
     return prediction
 
-
-# --- 4. 모드 2: 전체 기간 롤링 평가 함수 (수정 없음) ---
+# --- 4. 모드 2: 전체 기간 롤링 평가 함수 (⭐️⭐️⭐️ 이 함수를 완성했습니다 ⭐️⭐️⭐️) ---
 def evaluate_performance(args, model, scaler, device):
-    # ... (이전과 동일한 코드) ...
-    # 이 함수는 예측값들과 실제값들을 반환하면 됩니다.
     df_eval = pd.read_csv(args.evaluate_file)
-    if 'date' in df_eval.columns:
-        df_eval = df_eval.drop(columns=['date'])
-    raw_data = df_eval.values
+    df_eval['date'] = pd.to_datetime(df_eval['date'])
+    
+    # ⭐️ 알려주신 정확한 컬럼 이름으로 수정
+    cols_to_scale = ['air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'residual']
+    raw_data = df_eval[cols_to_scale].values
     data_scaled = scaler.transform(raw_data)
+    
+    df_stamp = time_features(df_eval[['date']], timeenc=0, freq=args.freq)
 
     preds_unscaled = []
     trues_unscaled = []
 
     num_samples = len(data_scaled) - args.seq_len - args.pred_len + 1
     for i in tqdm(range(num_samples), desc="Evaluating", file=sys.stderr):
+        # 1. 인코더/디코더 입력 생성 (매 스텝마다)
         s_begin = i
         s_end = s_begin + args.seq_len
-        input_scaled = data_scaled[s_begin:s_end]
-        batch_x = torch.from_numpy(input_scaled).float().unsqueeze(0).to(device)
-
+        
+        batch_x = data_scaled[s_begin:s_end]
+        batch_x_mark = df_stamp[s_begin:s_end]
+        
         true_begin = s_end
         true_end = true_begin + args.pred_len
         true_scaled = data_scaled[true_begin:true_end]
         
+        dec_inp_label = batch_x[-args.label_len:]
+        dec_inp_pred = np.zeros([args.pred_len, args.enc_in])
+        batch_y = np.concatenate([dec_inp_label, dec_inp_pred], axis=0)
+        
+        dec_mark_label = df_stamp[s_end-args.label_len:s_end]
+        dec_mark_pred = df_stamp[true_begin:true_end]
+        batch_y_mark = np.concatenate([dec_mark_label, dec_mark_pred], axis=0)
+
+        # 텐서로 변환
+        batch_x = torch.from_numpy(batch_x).float().unsqueeze(0).to(device)
+        batch_x_mark = torch.from_numpy(batch_x_mark).float().unsqueeze(0).to(device)
+        batch_y = torch.from_numpy(batch_y).float().unsqueeze(0).to(device)
+        batch_y_mark = torch.from_numpy(batch_y_mark).float().unsqueeze(0).to(device)
+        
+        # 2. 모델 호출
         with torch.no_grad():
-            outputs = model(batch_x)
+            outputs = model(batch_x, batch_x_mark, batch_y, batch_y_mark)
         
         pred_scaled = outputs.detach().cpu().numpy()[0]
-
-        if args.features == 'MS' and scaler.n_features_in_ > 1:
+        
+        # 3. 스케일 복원
+        if scaler.n_features_in_ > 1:
             padding = np.zeros((pred_scaled.shape[0], scaler.n_features_in_ - args.c_out))
             pred_padded = np.concatenate((padding, pred_scaled), axis=1)
             pred_unscaled = scaler.inverse_transform(pred_padded)[:, -args.c_out:]