Download annotations/annotation_27/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 10 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_27/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_27/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_27/test.py
10 kB
| import unittest | |
| import torch | |
| import numpy as np | |
| # Assuming the canonical code is in a file named 'models/canonical.py' | |
| # and the generated code is in 'models/TimeMixer.py' | |
| # The following imports are placeholders for the actual file names. | |
| from models.canonical import Model as CanonicalModel | |
| from models.TimeMixer import Model as GeneratedModel | |
| class DotDict(dict): | |
| """A dictionary that allows for dot notation access.""" | |
| __getattr__ = dict.get | |
| __setattr__ = dict.__setitem__ | |
| __delattr__ = dict.__delitem__ | |
| class TestTimeMixerEquivalence(unittest.TestCase): | |
| """ | |
| Unit test suite to verify the functional equivalence of a generated TimeMixer | |
| model implementation against a canonical version across various tasks and configurations. | |
| """ | |
| def setUp(self): | |
| """Set up common configurations and sample data for all tests.""" | |
| torch.manual_seed(42) | |
| np.random.seed(42) | |
| self.base_config = { | |
| 'seq_len': 32, | |
| 'label_len': 16, | |
| 'pred_len': 16, | |
| 'down_sampling_window': 2, | |
| 'e_layers': 2, | |
| 'd_model': 16, | |
| 'enc_in': 7, | |
| 'c_out': 7, | |
| 'd_ff': 32, | |
| 'moving_avg': 7, | |
| 'dft_top_k': 5, | |
| 'dropout': 0.1, | |
| 'embed_type': 'timeF', | |
| 'freq': 'h', | |
| 'use_normalization': True, | |
| 'down_sampling_layers': 2, | |
| 'num_class': 10, | |
| } | |
| self.configs = { | |
| 'long_term_forecast_defaults': DotDict({ | |
| **self.base_config, 'task_name': 'long_term_forecast', 'channel_independence': False, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'long_term_forecast_channel_indep': DotDict({ | |
| **self.base_config, 'task_name': 'long_term_forecast', 'channel_independence': True, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'long_term_forecast_dft_decomp': DotDict({ | |
| **self.base_config, 'task_name': 'long_term_forecast', 'channel_independence': False, | |
| 'decomp_method': 'dft_decomp', 'downsampling_method': 'avg' | |
| }), | |
| 'long_term_forecast_max_pool': DotDict({ | |
| **self.base_config, 'task_name': 'long_term_forecast', 'channel_independence': False, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'max' | |
| }), | |
| 'long_term_forecast_conv_pool': DotDict({ | |
| **self.base_config, 'task_name': 'long_term_forecast', 'channel_independence': False, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'conv' | |
| }), | |
| 'short_term_forecast_defaults': DotDict({ | |
| **self.base_config, 'task_name': 'short_term_forecast', 'pred_len': 8, | |
| 'channel_independence': False, 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'imputation_defaults': DotDict({ | |
| **self.base_config, 'task_name': 'imputation', 'channel_independence': False, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'imputation_channel_indep': DotDict({ | |
| **self.base_config, 'task_name': 'imputation', 'channel_independence': True, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'anomaly_detection_defaults': DotDict({ | |
| **self.base_config, 'task_name': 'anomaly_detection', 'channel_independence': False, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'anomaly_detection_channel_indep': DotDict({ | |
| **self.base_config, 'task_name': 'anomaly_detection', 'channel_independence': True, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| 'classification_defaults': DotDict({ | |
| **self.base_config, 'task_name': 'classification', 'channel_independence': False, | |
| 'decomp_method': 'moving_avg', 'downsampling_method': 'avg' | |
| }), | |
| } | |
| # Generate sample data for each configuration | |
| self.sample_data = {} | |
| batch_size = 8 | |
| for name, config in self.configs.items(): | |
| dec_len = config.label_len + config.pred_len | |
| def create_time_features(size, is_2d=False): | |
| if is_2d: | |
| # For classification masking, return a 2D tensor of 0s and 1s | |
| return (torch.rand(size[0], size[1]) > 0.2).float() | |
| # For all other tasks, return the 3D time feature tensor | |
| months = torch.randint(low=1, high=13, size=(size[0], size[1], 1)) | |
| days = torch.randint(low=1, high=32, size=(size[0], size[1], 1)) | |
| weekdays = torch.randint(low=0, high=7, size=(size[0], size[1], 1)) | |
| hours = torch.randint(low=0, high=24, size=(size[0], size[1], 1)) | |
| return torch.cat([months, days, weekdays, hours], dim=-1) | |
| x_mark_enc_shape = (batch_size, config.seq_len) | |
| x_mark_dec_shape = (batch_size, dec_len) | |
| # FIX: Create a 2D mask for classification, and a 3D feature tensor for all other tasks. | |
| is_classification_task = (config.task_name == 'classification') | |
| x_mark_enc = create_time_features(x_mark_enc_shape, is_2d=is_classification_task) | |
| x_mark_dec = create_time_features(x_mark_dec_shape) # Decoder marks are not used in classification | |
| self.sample_data[name] = { | |
| 'x_enc': torch.randn(batch_size, config.seq_len, config.enc_in), | |
| 'x_mark_enc': x_mark_enc, | |
| 'x_dec': torch.randn(batch_size, dec_len, config.c_out), | |
| 'x_mark_dec': x_mark_dec, | |
| 'mask': (torch.rand(batch_size, config.seq_len, config.enc_in) > 0.2).float(), | |
| } | |
| def _are_models_equal(self, model1, model2): | |
| """Helper function to check if two models have identical parameters.""" | |
| for p1, p2 in zip(model1.parameters(), model2.parameters()): | |
| if p1.data.ne(p2.data).sum() > 0: | |
| # For debugging: print which parameters differ | |
| # print(f"Parameter mismatch: {p1.data} vs {p2.data}") | |
| return False | |
| return True | |
| def _run_equivalence_test(self, config_key): | |
| """ | |
| A generic helper function to run an equivalence test for a given configuration. | |
| It initializes, runs, and compares the canonical and generated models. | |
| """ | |
| config = self.configs[config_key] | |
| data = self.sample_data[config_key] | |
| task_name = config.task_name | |
| # 1. Initialize models with identical configurations and seeds | |
| torch.manual_seed(42) | |
| canonical_model = CanonicalModel(config) | |
| torch.manual_seed(42) | |
| generated_model = GeneratedModel(config) | |
| # Ensure model parameters are the same after initialization | |
| self.assertTrue( | |
| self._are_models_equal(canonical_model, generated_model), | |
| f"Model parameters are not equal for config: {config_key}" | |
| ) | |
| canonical_model.eval() | |
| generated_model.eval() | |
| # 2. Execute forward pass with identical inputs | |
| with torch.no_grad(): | |
| canonical_output = canonical_model( | |
| x_enc=data['x_enc'], x_mark_enc=data['x_mark_enc'], | |
| x_dec=data['x_dec'], x_mark_dec=data['x_mark_dec'], | |
| mask=data.get('mask') | |
| ) | |
| generated_output = generated_model( | |
| x_enc=data['x_enc'], x_mark_enc=data['x_mark_enc'], | |
| x_dec=data['x_dec'], x_mark_dec=data['x_mark_dec'], | |
| mask=data.get('mask') | |
| ) | |
| # 3. Compare outputs for shape and value | |
| self.assertEqual( | |
| canonical_output.shape, generated_output.shape, | |
| f"Output shape mismatch for config: {config_key}" | |
| ) | |
| torch.testing.assert_close( | |
| canonical_output, generated_output, | |
| rtol=1e-5, atol=1e-7, | |
| msg=f"Output tensors are not close for config: {config_key}" | |
| ) | |
| print(f"✅ Test passed for configuration: {config_key}") | |
| # --- Test Methods for Each Scenario --- | |
| def test_long_term_forecast_defaults(self): | |
| self._run_equivalence_test('long_term_forecast_defaults') | |
| def test_long_term_forecast_channel_indep(self): | |
| self._run_equivalence_test('long_term_forecast_channel_indep') | |
| def test_long_term_forecast_dft_decomp(self): | |
| self._run_equivalence_test('long_term_forecast_dft_decomp') | |
| def test_long_term_forecast_max_pool(self): | |
| self._run_equivalence_test('long_term_forecast_max_pool') | |
| def test_long_term_forecast_conv_pool(self): | |
| self._run_equivalence_test('long_term_forecast_conv_pool') | |
| def test_short_term_forecast_defaults(self): | |
| self._run_equivalence_test('short_term_forecast_defaults') | |
| def test_imputation_defaults(self): | |
| self._run_equivalence_test('imputation_defaults') | |
| def test_imputation_channel_indep(self): | |
| self._run_equivalence_test('imputation_channel_indep') | |
| def test_anomaly_detection_defaults(self): | |
| self._run_equivalence_test('anomaly_detection_defaults') | |
| def test_anomaly_detection_channel_indep(self): | |
| self._run_equivalence_test('anomaly_detection_channel_indep') | |
| def test_classification_defaults(self): | |
| self._run_equivalence_test('classification_defaults') | |
| if __name__ == '__main__': | |
| # To run this test, ensure the canonical and generated model code | |
| # are accessible via the specified import paths. | |
| unittest.main(argv=['first-arg-is-ignored'], exit=False, verbosity=2) |