Download annotations/annotation_26/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 9.02 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_26/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_26/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_26/test.py
9.02 kB
| import unittest | |
| import torch | |
| import torch.nn as nn | |
| from types import SimpleNamespace | |
| # Assume the user's generated code is in a file named 'generation.py' | |
| # and the canonical implementation is in a file named 'canonical.py'. | |
| # Both files are expected to have the 'Model' class and its dependencies. | |
| # To make this test runnable, we will mock the dependencies. | |
| # --- Mock Dependencies --- | |
| # These mock classes simulate the behavior of the external dependencies | |
| # required by the iTransformer Model. They ensure that the Model's internal | |
| # logic can be tested without needing the actual complex layer implementations. | |
| # The key is that both canonical and generated code will use these exact same mocks. | |
| class MockFullAttention(nn.Module): | |
| def __init__(self, *args, **kwargs): | |
| super().__init__() | |
| def forward(self, queries, keys, values, attn_mask): | |
| return values, None # Simply pass through the values | |
| class MockAttentionLayer(nn.Module): | |
| def __init__(self, attention, d_model, n_heads, *args, **kwargs): | |
| super().__init__() | |
| self.d_model = d_model | |
| # This linear layer simulates the projection after attention | |
| self.out_projection = nn.Linear(d_model, d_model) | |
| def forward(self, queries, keys, values, attn_mask): | |
| # We ignore the mock attention and just project | |
| return self.out_projection(values), None | |
| class MockEncoderLayer(nn.Module): | |
| def __init__(self, attention_layer, d_model, d_ff, dropout, activation): | |
| super().__init__() | |
| self.norm1 = nn.LayerNorm(d_model) | |
| self.norm2 = nn.LayerNorm(d_model) | |
| self.attention = attention_layer | |
| self.ffn = nn.Sequential( | |
| nn.Linear(d_model, d_ff), | |
| nn.ReLU(), | |
| nn.Linear(d_ff, d_model) | |
| ) | |
| self.dropout = nn.Dropout(dropout) | |
| def forward(self, x, attn_mask): | |
| # Simplified forward pass mimicking a transformer block | |
| attn_output, _ = self.attention(x, x, x, attn_mask) | |
| x = x + self.dropout(attn_output) | |
| x = self.norm1(x) | |
| ffn_output = self.ffn(x) | |
| x = x + self.dropout(ffn_output) | |
| x = self.norm2(x) | |
| return x | |
| class MockEncoder(nn.Module): | |
| def __init__(self, attn_layers, norm_layer): | |
| super().__init__() | |
| self.layers = nn.ModuleList(attn_layers) | |
| self.norm = norm_layer | |
| def forward(self, x, attn_mask=None): | |
| for layer in self.layers: | |
| x = layer(x, attn_mask=attn_mask) | |
| if self.norm is not None: | |
| x = self.norm(x) | |
| return x, None # Return None for attentions | |
| class MockDataEmbeddingInverted(nn.Module): | |
| def __init__(self, c_in, d_model, embed_type, freq, dropout): | |
| super().__init__() | |
| # Project from seq_len (c_in) to d_model | |
| self.value_embedding = nn.Linear(c_in, d_model) | |
| self.dropout = nn.Dropout(dropout) | |
| def forward(self, x, x_mark): | |
| # x shape: [batch_size, seq_len, n_vars] | |
| # iTransformer swaps T and N, so we permute | |
| x = x.permute(0, 2, 1) # -> [batch_size, n_vars, seq_len] | |
| # Project each variate's sequence to a d_model embedding | |
| x = self.value_embedding(x) # -> [batch_size, n_vars, d_model] | |
| return self.dropout(x) | |
| # --- Monkey-patching the dependencies --- | |
| # This step replaces the actual complex layers with our simple, deterministic mocks | |
| # in the namespace of the modules we are about to import. | |
| import sys | |
| from unittest.mock import MagicMock | |
| # Create mock modules so the imports don't fail | |
| mock_layers_module = MagicMock() | |
| mock_layers_module.Transformer_EncDec = MagicMock() | |
| mock_layers_module.SelfAttention_Family = MagicMock() | |
| mock_layers_module.Embed = MagicMock() | |
| # Assign our mock classes to the attributes of the mock modules | |
| sys.modules['layers'] = mock_layers_module | |
| sys.modules['layers.Transformer_EncDec'] = mock_layers_module.Transformer_EncDec | |
| sys.modules['layers.SelfAttention_Family'] = mock_layers_module.SelfAttention_Family | |
| sys.modules['layers.Embed'] = mock_layers_module.Embed | |
| mock_layers_module.Transformer_EncDec.Encoder = MockEncoder | |
| mock_layers_module.Transformer_EncDec.EncoderLayer = MockEncoderLayer | |
| mock_layers_module.SelfAttention_Family.FullAttention = MockFullAttention | |
| mock_layers_module.SelfAttention_Family.AttentionLayer = MockAttentionLayer | |
| mock_layers_module.Embed.DataEmbedding_inverted = MockDataEmbeddingInverted | |
| # Now, import the models. They will use the mocked dependencies. | |
| from models.canonical import Model as CanonicalModel | |
| from models.iTransformer import Model as GeneratedModel | |
| class TestITransformerEquivalence(unittest.TestCase): | |
| """ | |
| Test suite to verify the functional equivalence of a generated iTransformer | |
| implementation against a canonical ground-truth implementation. | |
| """ | |
| def setUp(self): | |
| """ | |
| Set up common configurations and sample data for the tests. | |
| This method is run before each test function. | |
| """ | |
| self.base_configs = { | |
| 'seq_len': 32, | |
| 'pred_len': 16, | |
| 'enc_in': 7, | |
| 'd_model': 128, | |
| 'embed': 'timeF', | |
| 'freq': 'h', | |
| 'dropout': 0.1, | |
| 'factor': 1, | |
| 'n_heads': 8, | |
| 'd_ff': 256, | |
| 'activation': 'gelu', | |
| 'e_layers': 2, | |
| 'num_class': 10, | |
| 'task_name': 'long_term_forecast' # Default task | |
| } | |
| # Create small, representative input data | |
| self.batch_size = 4 | |
| self.x_enc = torch.randn(self.batch_size, self.base_configs['seq_len'], self.base_configs['enc_in']) | |
| self.x_mark_enc = torch.randn(self.batch_size, self.base_configs['seq_len'], 4) | |
| # Decoder inputs (for forecasting) | |
| self.x_dec = torch.randn(self.batch_size, self.base_configs['pred_len'], self.base_configs['enc_in']) | |
| self.x_mark_dec = torch.randn(self.batch_size, self.base_configs['pred_len'], 4) | |
| # Mask (for imputation) | |
| self.mask = torch.ones(self.batch_size, self.base_configs['seq_len'], self.base_configs['enc_in']) | |
| def run_comparison_test(self, configs_update): | |
| """ | |
| Helper function to run a standard comparison for a given task. | |
| """ | |
| # Ensure deterministic behavior for model weight initialization | |
| torch.manual_seed(0) | |
| # Create configs for the specific task | |
| configs_dict = self.base_configs.copy() | |
| configs_dict.update(configs_update) | |
| configs = SimpleNamespace(**configs_dict) | |
| # Initialize Canonical Model | |
| torch.manual_seed(0) # Reset seed right before init | |
| canonical_model = CanonicalModel(configs) | |
| canonical_model.eval() # Set to evaluation mode | |
| # Initialize Generated Model | |
| torch.manual_seed(0) # Reset seed right before init | |
| generated_model = GeneratedModel(configs) | |
| generated_model.eval() # Set to evaluation mode | |
| # Execute both models with identical inputs | |
| canonical_output = canonical_model( | |
| x_enc=self.x_enc, x_mark_enc=self.x_mark_enc, | |
| x_dec=self.x_dec, x_mark_dec=self.x_mark_dec, mask=self.mask | |
| ) | |
| generated_output = generated_model( | |
| x_enc=self.x_enc, x_mark_enc=self.x_mark_enc, | |
| x_dec=self.x_dec, x_mark_dec=self.x_mark_dec, mask=self.mask | |
| ) | |
| # Assert that the outputs are structurally and numerically identical | |
| self.assertIsInstance(generated_output, torch.Tensor) | |
| self.assertEqual(canonical_output.shape, generated_output.shape) | |
| torch.testing.assert_close(canonical_output, generated_output, rtol=1e-5, atol=1e-6) | |
| def test_forecasting_equivalence(self): | |
| """ | |
| Tests functional equivalence for the 'long_term_forecast' task. | |
| """ | |
| print("\nRunning test for 'long_term_forecast'...") | |
| self.run_comparison_test({'task_name': 'long_term_forecast'}) | |
| print("✅ 'long_term_forecast' test passed.") | |
| def test_imputation_equivalence(self): | |
| """ | |
| Tests functional equivalence for the 'imputation' task. | |
| """ | |
| print("\nRunning test for 'imputation'...") | |
| self.run_comparison_test({'task_name': 'imputation'}) | |
| print("✅ 'imputation' test passed.") | |
| def test_anomaly_detection_equivalence(self): | |
| """ | |
| Tests functional equivalence for the 'anomaly_detection' task. | |
| """ | |
| print("\nRunning test for 'anomaly_detection'...") | |
| self.run_comparison_test({'task_name': 'anomaly_detection'}) | |
| print("✅ 'anomaly_detection' test passed.") | |
| def test_classification_equivalence(self): | |
| """ | |
| Tests functional equivalence for the 'classification' task. | |
| """ | |
| print("\nRunning test for 'classification'...") | |
| self.run_comparison_test({'task_name': 'classification'}) | |
| print("✅ 'classification' test passed.") | |
| if __name__ == '__main__': | |
| unittest.main(argv=['first-arg-is-ignored'], exit=False) |