import unittest import torch import numpy as np import os import random # Assume the canonical implementation is in 'canonical.py' # and the generated implementation is in 'loss.py' from canonical import SILoss as CanonicalSILoss from loss import SILoss as GeneratedSILoss def set_seed(seed=2025): """Sets random seeds for reproducibility across libraries.""" 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.deterministic = True torch.backends.cudnn.benchmark = False class MockDiffusionModel(torch.nn.Module): """ A mock model that simulates the behavior of a diffusion model for testing purposes. """ def __init__(self, feature_dim=16, num_encoders=2, num_patches=4, image_channels=3, image_size=8): super().__init__() self.feature_dim = feature_dim self.num_encoders = num_encoders self.num_patches = num_patches flat_image_size = image_channels * image_size * image_size self.denoising_layer = torch.nn.Linear(flat_image_size, flat_image_size) self.projection_layers = torch.nn.ModuleList([ torch.nn.Linear(flat_image_size, num_patches * feature_dim) for _ in range(num_encoders) ]) def forward(self, x, t, **kwargs): """ Simulates a forward pass. zs_tilde is a list of tensors of shape (B, N_patches, F_dim). """ batch_size = x.shape[0] x_flat = x.view(batch_size, -1) model_output = self.denoising_layer(x_flat).view(x.shape) zs_tilde = [] for proj_layer in self.projection_layers: proj_output_reshaped = proj_layer(x_flat).view( batch_size, self.num_patches, self.feature_dim ) zs_tilde.append(proj_output_reshaped) return model_output, zs_tilde class TestSILossEquivalence(unittest.TestCase): """ Test suite to verify the functional equivalence of a generated SILoss implementation against a canonical one. """ def setUp(self): """Set up common test data.""" self.batch_size = 2 self.image_channels = 3 self.image_size = 8 self.feature_dim = 16 self.num_encoders = 2 self.num_patches = 4 self.images = torch.randn(self.batch_size, self.image_channels, self.image_size, self.image_size) self.zs = [ torch.randn(self.batch_size, self.num_patches, self.feature_dim) for _ in range(self.num_encoders) ] self.mock_model = MockDiffusionModel( feature_dim=self.feature_dim, num_encoders=self.num_encoders, num_patches=self.num_patches ) def test_initialization(self): """Instruction 1: Test that the SILoss class is initialized correctly.""" params = {'prediction': 'v', 'path_type': 'cosine', 'weighting': 'lognormal'} canonical_loss = CanonicalSILoss(**params) generated_loss = GeneratedSILoss(**params) for key, value in params.items(): self.assertEqual(getattr(canonical_loss, key), value) self.assertEqual(getattr(generated_loss, key), getattr(canonical_loss, key)) def test_interpolant_method(self): """Instruction 2: Test the 'interpolant' method.""" t = torch.tensor([0.0, 0.25, 0.5, 0.75, 1.0]) for path in ["linear", "cosine"]: with self.subTest(path=path): canonical_loss_fn = CanonicalSILoss(path_type=path) generated_loss_fn = GeneratedSILoss(path_type=path) c_outputs = canonical_loss_fn.interpolant(t) g_outputs = generated_loss_fn.interpolant(t) # Compare all four return values for equivalence for c_out, g_out in zip(c_outputs, g_outputs): if isinstance(c_out, torch.Tensor): torch.testing.assert_close(c_out, g_out) else: self.assertEqual(c_out, g_out) def _run_call_comparison(self, path_type, weighting): """ Helper function to run a full comparison of the __call__ method. This version uses the canonical output's shape as the ground truth. """ canonical_loss_fn = CanonicalSILoss(path_type=path_type, weighting=weighting) generated_loss_fn = GeneratedSILoss(path_type=path_type, weighting=weighting) set_seed() c_denoising_loss, c_proj_loss = canonical_loss_fn(self.mock_model, self.images, zs=self.zs) set_seed() g_denoising_loss, g_proj_loss = generated_loss_fn(self.mock_model, self.images, zs=self.zs) # 1. Compare denoising loss (shape should be stable) self.assertEqual(c_denoising_loss.shape, (self.batch_size,), "Canonical denoising loss has unexpected shape.") self.assertEqual(g_denoising_loss.shape, c_denoising_loss.shape, "Denoising loss shape mismatch.") torch.testing.assert_close(c_denoising_loss, g_denoising_loss, msg="Denoising loss value mismatch.") # 2. Compare projection loss (shape may be unstable in canonical code) self.assertEqual(g_proj_loss.shape, c_proj_loss.shape, f"Projection loss shape mismatch. Canonical is {c_proj_loss.shape}, Generated is {g_proj_loss.shape}.") torch.testing.assert_close(c_proj_loss, g_proj_loss, msg="Projection loss value mismatch.") def test_call_method_all_configs(self): """ Instruction 3: Test the '__call__' method across all configurations. """ for path_type in ["linear", "cosine"]: for weighting in ["uniform", "lognormal"]: with self.subTest(path=path_type, weight=weighting): self._run_call_comparison(path_type=path_type, weighting=weighting) def test_call_invalid_prediction_type(self): """Instruction 3 Edge Case: Test __call__ for unsupported prediction types.""" with self.assertRaises(NotImplementedError): loss_fn = CanonicalSILoss(prediction="unsupported") loss_fn(self.mock_model, self.images, zs=self.zs) with self.assertRaises(NotImplementedError): loss_fn = GeneratedSILoss(prediction="unsupported") loss_fn(self.mock_model, self.images, zs=self.zs) def test_call_with_zs_as_none(self): """Instruction 3 Edge Case: Test __call__ when zs is None.""" canonical_loss_fn = CanonicalSILoss() generated_loss_fn = GeneratedSILoss() with self.assertRaises(Exception): canonical_loss_fn(self.mock_model, self.images, zs=None) with self.assertRaises(Exception): generated_loss_fn(self.mock_model, self.images, zs=None) if __name__ == '__main__': unittest.main(argv=['first-arg-is-ignored'], exit=False)