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)