import unittest import torch import torch.nn as nn import random import os import numpy as np # Note: The 'try...except' block has been removed to ensure that any # ImportError during setup is reported clearly to the user, as it is the # likely root cause of the previous errors. See the __main__ block for # instructions on handling dependencies for standalone execution. from peft.tuners.canonical import ( LoraConfig as CanonicalLoraConfig, LoraModel as CanonicalLoraModel, Linear as CanonicalLinear, mark_only_lora_as_trainable as canonical_mark_only_lora_as_trainable, ) from peft.tuners.lora import ( LoraConfig as GeneratedLoraConfig, LoraModel as GeneratedLoraModel, Linear as GeneratedLinear, mark_only_lora_as_trainable as generated_mark_only_lora_as_trainable, ) def set_seed(seed=2025): """Sets the seed for reproducibility across all relevant 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.benchmark = False torch.backends.cudnn.deterministic = True class SimpleModel(nn.Module): """A simple dummy model for testing the model wrapper.""" def __init__(self, in_features=16, out_features=16): super().__init__() self.q_proj = nn.Linear(in_features, out_features, bias=True) self.v_proj = nn.Linear(in_features, out_features, bias=False) self.unrelated = nn.Linear(in_features, out_features) def forward(self, x): return self.unrelated(self.v_proj(self.q_proj(x))) class TestLoraMoeEquivalence(unittest.TestCase): """ Test suite to evaluate the functional equivalence of a generated LoRAMoE implementation against a canonical ground truth implementation. """ def setUp(self): """Set up common resources and configurations for all tests.""" set_seed() self.batch_size = 2 self.seq_len = 5 self.in_features = 16 self.out_features = 16 self.input_tensor = torch.randn(self.batch_size, self.seq_len, self.in_features) self.task_types_tensor = torch.randint(0, 2, (self.batch_size,)) self.lora_config_params = { 'r': 4, 'lora_alpha': 8, 'lora_nums': 2, 'blc_alpha': 0.1, 'blc_weight': 0.1, 'lora_dropout': 0.0, 'target_modules': ["q_proj", "v_proj"], 'fan_in_fan_out': False, 'merge_weights': False, 'bias': 'lora_only', 'modules_to_save': None } self.linear_layer_params = { key: self.lora_config_params[key] for key in ['r', 'lora_alpha', 'lora_nums', 'blc_alpha', 'blc_weight', 'lora_dropout', 'fan_in_fan_out', 'merge_weights'] } def test_lora_config_initialization(self): """Instruction 1: Tests if LoraConfig initializes identically.""" canonical_config = CanonicalLoraConfig(**self.lora_config_params) generated_config = GeneratedLoraConfig(**self.lora_config_params) self.assertDictEqual(canonical_config.__dict__, generated_config.__dict__) def test_cv_squared_utility(self): """Instruction 6: Tests the cv_squared utility function.""" canonical_layer = CanonicalLinear(self.in_features, self.out_features, **self.linear_layer_params) generated_layer = GeneratedLinear(self.in_features, self.out_features, **self.linear_layer_params) for test_input in [torch.tensor([1., 2., 7., 10.]), torch.tensor([5., 5., 5.]), torch.tensor([10.])]: with self.subTest(input=test_input): self.assertAlmostEqual(canonical_layer.cv_squared(test_input).item(), generated_layer.cv_squared(test_input).item(), places=7) def test_mark_only_lora_as_trainable(self): """Instruction 3: Tests the parameter freezing utility.""" for bias_mode in ['none', 'all', 'lora_only']: with self.subTest(bias=bias_mode): config = self.lora_config_params.copy() config['bias'] = bias_mode set_seed(); canonical_model = CanonicalLoraModel(CanonicalLoraConfig(**config), SimpleModel()) set_seed(); generated_model = GeneratedLoraModel(GeneratedLoraConfig(**config), SimpleModel()) self.assertDictEqual({n: p.requires_grad for n, p in canonical_model.named_parameters()}, {n: p.requires_grad for n, p in generated_model.named_parameters()}) def test_lora_model_wrapper_and_linear_initialization(self): """Instructions 2 & 4: Tests wrapper and layer initialization.""" set_seed(); canonical_model = CanonicalLoraModel(CanonicalLoraConfig(**self.lora_config_params), SimpleModel()) set_seed(); generated_model = GeneratedLoraModel(GeneratedLoraConfig(**self.lora_config_params), SimpleModel()) self.assertIsInstance(canonical_model.model.q_proj, CanonicalLinear) self.assertIsInstance(generated_model.model.q_proj, GeneratedLinear) self.assertNotIsInstance(canonical_model.model.unrelated, CanonicalLinear) def test_reset_parameters_initialization(self): """Instruction 5: Tests the weight initialization of the Linear layer.""" set_seed() canonical_layer = CanonicalLinear(self.in_features, self.out_features, bias=True, **self.linear_layer_params) set_seed() generated_layer = GeneratedLinear(self.in_features, self.out_features, bias=True, **self.linear_layer_params) torch.testing.assert_close(canonical_layer.lora_route.weight, generated_layer.lora_route.weight) for i in range(self.linear_layer_params['lora_nums']): torch.testing.assert_close(getattr(canonical_layer, f'lora_A{i}').weight, getattr(generated_layer, f'lora_A{i}').weight) torch.testing.assert_close(getattr(canonical_layer, f'lora_B{i}').weight, getattr(generated_layer, f'lora_B{i}').weight) def test_linear_layer_forward_pass_equivalence(self): """Instruction 7: Tests the forward pass of the custom Linear layer.""" set_seed(); canonical_layer = CanonicalLinear(self.in_features, self.out_features, **self.linear_layer_params) set_seed(); generated_layer = GeneratedLinear(self.in_features, self.out_features, **self.linear_layer_params) with self.subTest(case="with_task_types"): canonical_output, canonical_loss = canonical_layer(self.input_tensor, self.task_types_tensor) generated_output, generated_loss = generated_layer(self.input_tensor, self.task_types_tensor) torch.testing.assert_close(canonical_output, generated_output) torch.testing.assert_close(canonical_loss, generated_loss) with self.subTest(case="without_task_types"): canonical_output, canonical_loss = canonical_layer(self.input_tensor, task_types=None) generated_output, generated_loss = generated_layer(self.input_tensor, task_types=None) torch.testing.assert_close(canonical_output, generated_output) self.assertEqual(canonical_loss.item(), 0.0) if __name__ == '__main__': # This block helps run this test script standalone by mocking the `peft.utils` # dependency, which can cause an `ImportError` in the target code due to its # relative import (`from ..utils import ...`). If you encounter an # `ImportError`, it means your environment needs to be configured to find # the `peft` library, or you can rely on this mocking for isolated testing. import sys if 'peft.utils' not in sys.modules: print("\nNOTE: Mocking 'peft.utils' for standalone execution.\n") class PeftConfig: pass class PeftType: LORA = "LORA" def transpose(w, f): return w.T if f else w mock_utils = type(sys)('utils') mock_utils.PeftConfig = PeftConfig mock_utils.PeftType = PeftType mock_utils.transpose = transpose sys.modules['peft.utils'] = mock_utils sys.modules['..utils'] = mock_utils # For the relative import unittest.main(verbosity=2)