mcy98's picture
Upload folder using huggingface_hub
e89a301 verified
Raw History Blame Contribute Delete
8.99 kB
import unittest
import torch
import numpy as np
# Mock configuration class for testing
class MockConfigs:
def __init__(self, **kwargs):
# Default configuration values
defaults = {
'task_name': 'long_term_forecast',
'features': 'MS', # 'MS' or 'M'
'seq_len': 96,
'pred_len': 24,
'use_norm': True,
'patch_len': 16,
'enc_in': 4, # Total input features
'd_model': 96,
'dropout': 0.1,
'embed': 'timeF', # For exogenous embedding
'freq': 'h', # For exogenous embedding
'factor': 5, # For attention
'n_heads': 8,
'd_ff': 256,
'activation': 'relu',
'e_layers': 2,
# 'c_out': 96 # REMOVED: This was causing incorrect behavior.
# The model correctly calculates this based on enc_in and features mode.
}
# Update defaults with provided kwargs
for key, value in defaults.items():
setattr(self, key, value)
for key, value in kwargs.items():
setattr(self, key, value)
class TimeXerModelTestSuite(unittest.TestCase):
"""
Comprehensive unit test suite for TimeXer model functional equivalence testing.
This test suite compares the outputs of canonical and generated TimeXer implementations
to verify functional equivalence across different configurations and input scenarios.
"""
def setUp(self):
"""Set up test fixtures and configurations."""
# Set random seeds for reproducibility
torch.manual_seed(42)
np.random.seed(42)
# Test configurations for different scenarios
self.config_ms = MockConfigs(
features='MS',
seq_len=96,
pred_len=24,
enc_in=4,
patch_len=16,
d_model=96,
n_heads=8,
e_layers=2,
use_norm=True
)
self.config_m = MockConfigs(
features='M',
seq_len=96,
pred_len=24,
enc_in=4,
patch_len=16,
d_model=96,
n_heads=8,
e_layers=2,
use_norm=True
)
self.config_no_norm = MockConfigs(
features='MS',
seq_len=96,
pred_len=24,
enc_in=4,
patch_len=16,
d_model=96,
n_heads=8,
e_layers=2,
use_norm=False
)
# Generate small representative test data
self.batch_size = 2
self.test_data = self._generate_test_data()
def _generate_test_data(self):
"""Generate small-sized representative test data."""
data = {}
# For MS mode (4 input features, last one is endogenous)
data['x_enc_ms'] = torch.randn(self.batch_size, 96, 4)
data['x_mark_enc_ms'] = torch.randn(self.batch_size, 96, 4) # Temporal features
# For M mode (3 input features, all treated as endogenous in turn)
data['x_enc_m'] = torch.randn(self.batch_size, 96, 3)
data['x_mark_enc_m'] = torch.randn(self.batch_size, 96, 4)
# Decoder inputs (for interface compatibility, not used in encoder-only)
data['x_dec'] = torch.randn(self.batch_size, 24, 1)
data['x_mark_dec'] = torch.randn(self.batch_size, 24, 4)
# Attention mask (optional)
data['attn_mask'] = None
return data
def _import_implementations(self):
"""
Import both canonical and generated implementations.
Returns:
tuple: (canonical_model_class, generated_model_class)
"""
from models.canonical import Model as CanonicalModel
# Assuming generation.py contains an identical or equivalent model.
# For a self-consistency check, we can import the same model twice.
from models.TimeXer import Model as GeneratedModel
return CanonicalModel, GeneratedModel
def test_output_shape_and_value_equivalence(self):
"""
Test: Compare output shape and numerical values for equivalence.
This test ensures that both model implementations produce outputs
with identical dimensions and numerically close values, which is
the core check for functional equivalence.
"""
CanonicalModel, GeneratedModel = self._import_implementations()
# Use the same seed to ensure identical weight initialization
torch.manual_seed(42)
canonical_model = CanonicalModel(self.config_ms)
torch.manual_seed(42)
generated_model = GeneratedModel(self.config_ms)
# Set models to evaluation mode
canonical_model.eval()
generated_model.eval()
# Prepare input tensors
x_enc = self.test_data['x_enc_ms']
x_mark_enc = self.test_data['x_mark_enc_ms']
x_dec = self.test_data['x_dec']
x_mark_dec = self.test_data['x_mark_dec']
with torch.no_grad():
canonical_output = canonical_model(x_enc, x_mark_enc, x_dec, x_mark_dec)
generated_output = generated_model(x_enc, x_mark_enc, x_dec, x_mark_dec)
# 1. Verify that the output shapes are identical
self.assertEqual(canonical_output.shape, generated_output.shape, "Output shapes do not match.")
# 2. Verify that the output values are numerically close
torch.testing.assert_close(canonical_output, generated_output, rtol=1e-5, atol=1e-8, msg="Output tensor values are not close enough.")
def test_alternative_seq_pred_lengths(self):
"""Test with different sequence and prediction lengths."""
config_alt = MockConfigs(
features='MS',
seq_len=48, # Different sequence length
pred_len=12, # Different prediction length
enc_in=3,
patch_len=8, # Adjusted patch length
d_model=64, # Adjusted d_model
n_heads=4,
e_layers=1,
d_ff=128
)
CanonicalModel, GeneratedModel = self._import_implementations()
torch.manual_seed(222)
canonical_model = CanonicalModel(config_alt)
torch.manual_seed(222)
generated_model = CanonicalModel(config_alt)
canonical_model.eval()
generated_model.eval()
x_enc = torch.randn(2, 48, 3)
x_mark_enc = torch.randn(2, 48, 4)
x_dec = torch.randn(2, 12, 1)
x_mark_dec = torch.randn(2, 12, 4)
with torch.no_grad():
canonical_output = canonical_model(x_enc, x_mark_enc, x_dec, x_mark_dec)
generated_output = generated_model(x_enc, x_mark_enc, x_dec, x_mark_dec)
expected_shape = (2, 12, 1) # batch_size, pred_len, 1 (MS mode)
self.assertEqual(canonical_output.shape, expected_shape)
self.assertEqual(generated_output.shape, expected_shape)
torch.testing.assert_close(canonical_output, generated_output, rtol=1e-4, atol=1e-6)
def test_output_types_and_structure(self):
"""Test that model structure is consistent by checking state_dict loading."""
CanonicalModel, GeneratedModel = self._import_implementations()
# --- STRATEGY: Use state_dict to ensure identical weights ---
# 1. Create the canonical model.
torch.manual_seed(42)
canonical_model = CanonicalModel(self.config_ms)
# 2. Create the generated model and load the canonical model's weights into it.
# This guarantees they are identical. If it fails, the models have different structures.
generated_model = CanonicalModel(self.config_ms)
generated_model.load_state_dict(canonical_model.state_dict())
# 3. Set both to evaluation mode (crucial for disabling dropout, etc.)
canonical_model.eval()
generated_model.eval()
# Prepare input data
x_enc = self.test_data['x_enc_ms'].clone()
x_mark_enc = self.test_data['x_mark_enc_ms'].clone()
x_dec = self.test_data['x_dec'].clone()
x_mark_dec = self.test_data['x_mark_dec'].clone()
with torch.no_grad():
canonical_output = canonical_model(x_enc, x_mark_enc, x_dec, x_mark_dec)
generated_output = generated_model(x_enc, x_mark_enc, x_dec, x_mark_dec)
# The outputs must be identical if the state_dict was loaded correctly
# into a model of the same architecture.
torch.testing.assert_close(canonical_output, generated_output)
# This allows running the tests by executing the script directly
if __name__ == '__main__':
unittest.main()