Download annotations/annotation_47/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 8.24 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_47/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_47/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_47/test.py
8.24 kB
| 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) |