Download annotations/annotation_49/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 14.3 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_49/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_49/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_49/test.py
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): | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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) |