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)