mcy98's picture
Upload folder using huggingface_hub
22e9602 verified
Raw History Blame Contribute Delete
14.3 kB
import unittest
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import os
import random
import pandas as pd
from unittest.mock import patch, MagicMock, call
import copy
# Assume the canonical and generated code are in these files,
# each containing the 'Exp_Main' class with the target functions.
try:
from exp.canonical import Exp_Main as CanonicalExp
from exp.exp_main import Exp_Main as GeneratedExp
except ImportError as e:
print(f"Error: Could not import Exp_Main. Make sure canonical.py and exp_main.py exist. Details: {e}")
exit()
# --- Test Configuration ---
SEED = 2025
BATCH_SIZE = 4
SEQ_LEN = 96
PRED_LEN = 24
LABEL_LEN = 48
FEATURES = 7
PATCH_LEN_THRESHOLD = 12
TRAIN_EPOCHS = 1
def set_seed(seed=SEED):
"""Sets a seed for all relevant random number generators to ensure reproducibility."""
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
def cloned_state_dict(m):
# detach+clone to fully decouple from the module's live parameters
return {k: v.detach().cpu().clone() for k, v in m.state_dict().items()}
# --- Mock Objects for Test Setup ---
class MockArgs:
"""A mock class to simulate the 'args' object needed by the experiment class."""
def __init__(self, use_ps_loss=True):
self.ps_lambda = 0.5
self.use_ps_loss = use_ps_loss
self.patch_len_threshold = PATCH_LEN_THRESHOLD
self.use_gpu = False
self.gpu = 0
self.use_multi_gpu = False
self.device_ids = [0]
self.device = 'cpu'
self.model = 'DLinear'
self.features = 'M'
self.seq_len = SEQ_LEN
self.pred_len = PRED_LEN
self.label_len = LABEL_LEN
self.enc_in = FEATURES
self.c_out = FEATURES
self.individual = False
self.use_amp = False
self.output_attention = False
self.learning_rate = 0.001
self.train_epochs = TRAIN_EPOCHS
self.patience = 3
self.checkpoints = './test_checkpoints/'
self.train_only = False
self.test_flop = False
self.lradj = 'type1'
def create_mock_dataloader(num_batches=2):
"""Creates a mock data loader that yields a few batches of correctly shaped data."""
mock_data = []
for _ in range(num_batches):
batch_x = torch.randn(BATCH_SIZE, SEQ_LEN, FEATURES)
batch_y = torch.randn(BATCH_SIZE, LABEL_LEN + PRED_LEN, FEATURES)
batch_x_mark = torch.randn(BATCH_SIZE, SEQ_LEN, 4)
batch_y_mark = torch.randn(BATCH_SIZE, LABEL_LEN + PRED_LEN, 4)
mock_data.append((batch_x, batch_y, batch_x_mark, batch_y_mark))
return mock_data
# --- Unit Test Suite ---
class TestPSLossEquivalence(unittest.TestCase):
@classmethod
def setUpClass(cls):
set_seed(SEED)
cls.args_with_ps = MockArgs(use_ps_loss=True)
cls.args_without_ps = MockArgs(use_ps_loss=False)
time_steps = torch.linspace(0, 10 * np.pi, SEQ_LEN)
sine_wave = torch.sin(time_steps).unsqueeze(0).unsqueeze(-1)
cls.true_series = sine_wave.repeat(BATCH_SIZE, 1, FEATURES)
noise = torch.randn(BATCH_SIZE, SEQ_LEN, FEATURES) * 0.1
cls.pred_series = cls.true_series + noise
cls.mock_train_loader = create_mock_dataloader()
cls.mock_vali_loader = create_mock_dataloader(1)
cls.mock_test_loader = create_mock_dataloader(1)
def setUp(self):
set_seed(SEED)
self.canonical_exp = CanonicalExp(self.args_with_ps)
self.generated_exp = GeneratedExp(self.args_with_ps)
self.generated_exp.model.load_state_dict(self.canonical_exp.model.state_dict())
self.canonical_exp_no_ps = CanonicalExp(self.args_without_ps)
self.generated_exp_no_ps = GeneratedExp(self.args_without_ps)
self.generated_exp_no_ps.model.load_state_dict(self.canonical_exp_no_ps.model.state_dict())
def test_01_init_equivalence(self):
self.assertEqual(self.canonical_exp.ps_lambda, self.generated_exp.ps_lambda)
# ... (rest of the tests are unchanged)
def test_02_create_patches_equivalence(self):
patch_len, stride = 16, 8
c_patches = self.canonical_exp.create_patches(self.true_series.clone(), patch_len, stride)
g_patches = self.generated_exp.create_patches(self.true_series.clone(), patch_len, stride)
torch.testing.assert_close(c_patches, g_patches, msg="Mismatch in 'create_patches' output")
def test_03_fouriour_based_adaptive_patching_equivalence(self):
c_true, c_pred = self.canonical_exp.fouriour_based_adaptive_patching(self.true_series.clone(), self.pred_series.clone())
g_true, g_pred = self.generated_exp.fouriour_based_adaptive_patching(self.true_series.clone(), self.pred_series.clone())
torch.testing.assert_close(c_true, g_true, msg="Mismatch in 'true_patch'")
torch.testing.assert_close(c_pred, g_pred, msg="Mismatch in 'pred_patch'")
def test_04_patch_wise_structural_loss_equivalence(self):
true_patch, pred_patch = self.canonical_exp.fouriour_based_adaptive_patching(self.true_series.clone(), self.pred_series.clone())
c_corr, c_var, c_mean = self.canonical_exp.patch_wise_structural_loss(true_patch.clone(), pred_patch.clone())
g_corr, g_var, g_mean = self.generated_exp.patch_wise_structural_loss(true_patch.clone(), pred_patch.clone())
torch.testing.assert_close(c_corr, g_corr, msg="Mismatch in correlation loss")
torch.testing.assert_close(c_var, g_var, msg="Mismatch in variance loss")
torch.testing.assert_close(c_mean, g_mean, msg="Mismatch in mean loss")
def test_05_gradient_based_dynamic_weighting_equivalence(self):
c_pred = self.canonical_exp.model(self.true_series.clone())
g_pred = self.generated_exp.model(self.true_series.clone())
true_series_for_loss = self.true_series[:, -PRED_LEN:, :].clone()
c_true_patch, c_pred_patch = self.canonical_exp.fouriour_based_adaptive_patching(true_series_for_loss, c_pred)
c_corr, c_var, c_mean = self.canonical_exp.patch_wise_structural_loss(c_true_patch, c_pred_patch)
g_true_patch, g_pred_patch = self.generated_exp.fouriour_based_adaptive_patching(true_series_for_loss, g_pred)
g_corr, g_var, g_mean = self.generated_exp.patch_wise_structural_loss(g_true_patch, g_pred_patch)
c_alpha, c_beta, c_gamma = self.canonical_exp.gradient_based_dynamic_weighting(true_series_for_loss, c_pred, c_corr, c_var, c_mean)
g_alpha, g_beta, g_gamma = self.generated_exp.gradient_based_dynamic_weighting(true_series_for_loss, g_pred, g_corr, g_var, g_mean)
torch.testing.assert_close(c_alpha, g_alpha, msg="Mismatch in dynamic weight 'alpha'")
torch.testing.assert_close(c_beta, g_beta, msg="Mismatch in dynamic weight 'beta'")
torch.testing.assert_close(c_gamma, g_gamma, msg="Mismatch in dynamic weight 'gamma'")
def test_06_ps_loss_orchestration_equivalence(self):
c_pred = self.canonical_exp.model(self.true_series.clone())
g_pred = self.generated_exp.model(self.true_series.clone())
true_series_for_loss = self.true_series[:, -PRED_LEN:, :].clone()
canonical_final_loss = self.canonical_exp.ps_loss(true_series_for_loss, c_pred)
generated_final_loss = self.generated_exp.ps_loss(true_series_for_loss, g_pred)
torch.testing.assert_close(canonical_final_loss, generated_final_loss, msg="Mismatch in the final ps_loss value")
def test_07_vali_equivalence(self):
criterion = nn.MSELoss()
c_loss = self.canonical_exp.vali(None, self.mock_vali_loader, criterion)
g_loss = self.generated_exp.vali(None, self.mock_vali_loader, criterion)
self.assertAlmostEqual(c_loss, g_loss, places=6, msg="Mismatch in validation loss")
@patch('exp.exp_main.torch.load')
@patch('exp.canonical.torch.load')
@patch('exp.exp_main.EarlyStopping')
@patch('exp.canonical.EarlyStopping')
def test_08a_train_equivalence_with_ps_loss(self, mock_es_canonical, mock_es_generated, mock_torch_load_c, mock_torch_load_g):
mock_es_instance = MagicMock()
mock_es_instance.early_stop = False
mock_es_canonical.return_value = mock_es_instance
mock_es_generated.return_value = mock_es_instance
# mock_torch_load_c.return_value = self.canonical_exp.model.state_dict()
# mock_torch_load_g.return_value = self.generated_exp.model.state_dict()
c_ckpt = cloned_state_dict(self.canonical_exp.model)
g_ckpt = cloned_state_dict(self.generated_exp.model)
mock_torch_load_c.side_effect = lambda *a, **kw: {k: v.clone() for k, v in c_ckpt.items()}
mock_torch_load_g.side_effect = lambda *a, **kw: {k: v.clone() for k, v in g_ckpt.items()}
# FIX: Use separate side_effect iterators to ensure data is not shared across calls
canonical_side_effects = [(None, self.mock_train_loader), (None, self.mock_vali_loader), (None, self.mock_test_loader)]
with patch('exp.canonical.data_provider', side_effect=canonical_side_effects):
self.canonical_exp.train('setting_c')
generated_side_effects = [(None, self.mock_train_loader), (None, self.mock_vali_loader), (None, self.mock_test_loader)]
with patch('exp.exp_main.data_provider', side_effect=generated_side_effects):
self.generated_exp.train('setting_g')
for (name_c, param_c), (name_g, param_g) in zip(self.canonical_exp.model.named_parameters(), self.generated_exp.model.named_parameters()):
self.assertEqual(name_c, name_g)
# FIX: Add a tolerance to the assertion to account for minor floating point differences.
torch.testing.assert_close(param_c.data, param_g.data, rtol=1e-5, atol=1e-5, msg=f"Weight mismatch for '{name_c}' with PS-Loss")
@patch('exp.exp_main.torch.load')
@patch('exp.canonical.torch.load')
@patch('exp.exp_main.EarlyStopping')
@patch('exp.canonical.EarlyStopping')
def test_08b_train_equivalence_without_ps_loss(self, mock_es_canonical, mock_es_generated, mock_torch_load_c, mock_torch_load_g):
mock_es_instance = MagicMock()
mock_es_instance.early_stop = False
mock_es_canonical.return_value = mock_es_instance
mock_es_generated.return_value = mock_es_instance
# mock_torch_load_c.return_value = self.canonical_exp_no_ps.model.state_dict()
# mock_torch_load_g.return_value = self.generated_exp_no_ps.model.state_dict()
c_ckpt = cloned_state_dict(self.canonical_exp.model)
g_ckpt = cloned_state_dict(self.generated_exp.model)
mock_torch_load_c.side_effect = lambda *a, **kw: {k: v.clone() for k, v in c_ckpt.items()}
mock_torch_load_g.side_effect = lambda *a, **kw: {k: v.clone() for k, v in g_ckpt.items()}
canonical_side_effects = [(None, self.mock_train_loader), (None, self.mock_vali_loader), (None, self.mock_test_loader)]
with patch('exp.canonical.data_provider', side_effect=canonical_side_effects):
self.canonical_exp_no_ps.train('setting_c_no_ps')
generated_side_effects = [(None, self.mock_train_loader), (None, self.mock_vali_loader), (None, self.mock_test_loader)]
with patch('exp.exp_main.data_provider', side_effect=generated_side_effects):
self.generated_exp_no_ps.train('setting_g_no_ps')
for (name_c, param_c), (name_g, param_g) in zip(self.canonical_exp_no_ps.model.named_parameters(), self.generated_exp_no_ps.model.named_parameters()):
self.assertEqual(name_c, name_g)
# FIX: Add a tolerance to the assertion.
torch.testing.assert_close(param_c.data, param_g.data, rtol=1e-5, atol=1e-5, msg=f"Weight mismatch for '{name_c}' without PS-Loss")
@patch('exp.canonical.metric', return_value=(0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1))
@patch('exp.exp_main.metric', return_value=(0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1))
@patch('builtins.open')
@patch('numpy.save')
@patch('os.makedirs')
def test_09_test_equivalence(self, mock_makedirs, mock_save, mock_open, mock_metric_g, mock_metric_c):
with patch('exp.canonical.data_provider', return_value=(None, self.mock_test_loader)):
self.canonical_exp.test('setting_c')
c_preds_call = mock_metric_c.call_args[0][0]
c_trues_call = mock_metric_c.call_args[0][1]
with patch('exp.exp_main.data_provider', return_value=(None, self.mock_test_loader)):
self.generated_exp.test('setting_g')
g_preds_call = mock_metric_g.call_args[0][0]
g_trues_call = mock_metric_g.call_args[0][1]
np.testing.assert_allclose(c_preds_call, g_preds_call, rtol=1e-6, err_msg="Mismatch in predictions passed to metric function")
np.testing.assert_allclose(c_trues_call, g_trues_call, rtol=1e-6, err_msg="Mismatch in ground truth passed to metric function")
@patch('pandas.DataFrame.to_csv')
@patch('numpy.save')
@patch('os.makedirs')
def test_10_predict_equivalence(self, mock_makedirs, mock_save, mock_to_csv):
mock_pred_data = MagicMock(scale=False)
mock_pred_data.future_dates = list(range(PRED_LEN))
mock_pred_data.cols = [f'c_{i}' for i in range(FEATURES + 1)]
mock_data_provider_return = (mock_pred_data, self.mock_test_loader)
with patch('exp.canonical.data_provider', return_value=mock_data_provider_return):
self.canonical_exp.predict('setting_c')
c_preds_saved = mock_save.call_args[0][1]
with patch('exp.exp_main.data_provider', return_value=mock_data_provider_return):
self.generated_exp.predict('setting_g')
g_preds_saved = mock_save.call_args_list[1][0][1]
np.testing.assert_allclose(c_preds_saved, g_preds_saved, rtol=1e-6, err_msg="Mismatch in final predictions array")
if __name__ == '__main__':
unittest.main(argv=['first-arg-is-ignored'], exit=False)