def get_all_quantizers_per_full_scope(model): all_quantizations = OrderedDict() for class_type in QUANTIZATION_MODULES.registry_dict.values(): quantization_type = class_type.__name__ all_quantizations.update( get_all_modules_by_type( model.get_compression_modules_by_type( CompressionModuleType.ACTIVATION_QUANTIZER), quantization_type)) all_quantizations.update( get_all_modules_by_type( model.get_compression_modules_by_type( CompressionModuleType.FUNCTION_QUANTIZER), quantization_type)) all_quantizations.update( get_all_modules_by_type(model.get_nncf_wrapped_model(), quantization_type)) all_quantizations = OrderedDict( sorted(all_quantizations.items(), key=lambda x: str(x[0]))) return all_quantizations
def test_get_all_layers_by_type__for_multiple_type(): model = TestModel() act_bn = get_all_modules_by_type(model, ['ReLU', 'AvgPool2d']) ref_bn = [ 'TestModel/AvgPool2d[avgpool]', 'TestModel/Sequential[layer1]/ReLU[relu01]', 'TestModel/Sequential[layer2]/Sequential[layer1]/ReLU[relu01]', 'TestModel/Sequential[layer2]/ReLU[relu02]' ] assert list(act_bn.keys()) == ref_bn assert isinstance(act_bn, OrderedDict)
def test_get_all_layers_by_type__for_multiple_type(): model = ModelForTest() act_bn = get_all_modules_by_type(model, ['ReLU', 'AvgPool2d']) act_bn = OrderedDict((str(k), v) for k, v in act_bn.items()) ref_bn = [ 'ModelForTest/AvgPool2d[avgpool]', 'ModelForTest/Sequential[layer1]/ReLU[relu01]', 'ModelForTest/Sequential[layer2]/Sequential[layer1]/ReLU[relu01]', 'ModelForTest/Sequential[layer2]/ReLU[relu02]'] assert list(act_bn.keys()) == ref_bn assert isinstance(act_bn, OrderedDict)
def split_quantizers(quant_model): quantizers = get_all_modules_by_type( quant_model, list(INITIALIZABLE_MODULES.registry_dict.keys())) weight_quantizers = [] activation_quantizers = [] for name, data in quantizers.items(): if 'UpdateWeight' in name: weight_quantizers.append(data) else: activation_quantizers.append(data) return weight_quantizers, activation_quantizers
def check_sign_and_scale(model, ref_table): model_conv = get_all_modules_by_type(model, 'SymmetricQuantizer') for scope, module in model_conv.items(): for pattern, ref_values in ref_table.items(): match = re.search(pattern, str(scope)) if match: assert isinstance(module, SymmetricQuantizer) assert module.signed == ref_values[ 0], 'sign is not matched for {}'.format(str(scope)) assert module.scale == ref_values[ 1], 'scale is not matched for {}'.format(str(scope))
def test_sparse_network(self, model_name, model_builder, input_size, algo, params): model = model_builder() from nncf.layers import NNCF_MODULES_MAP sparsifiable_modules = list(NNCF_MODULES_MAP.values()) ref_num_sparsed = len(get_all_modules_by_type(model, sparsifiable_modules)) config = get_empty_config(input_sample_size=input_size) config["compression"] = {"algorithm": algo, "params": params} compressed_model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) assert ref_num_sparsed == len(compression_ctrl.sparsified_module_info) check_model_graph(compressed_model, model_name, algo)
def test_scale_and_sign_init_for_quant_algo(): model = TwoConvTestModel() config = get_empty_config() config['compression'] = { 'algorithm': 'quantization', 'initializer': { 'num_init_steps': 1 } } reset_context('orig') reset_context('quantized_graphs') compression_algo = create_compression_algorithm(model, config) model = compression_algo.model input_sample_size = config.input_sample_size class OnesDatasetMock: def __init__(self, input_size): self.input_size = input_size super().__init__() def __getitem__(self, index): return torch.ones(self.input_size), torch.ones(1) def __len__(self): return 1 data_loader = torch.utils.data.DataLoader(OnesDatasetMock( input_sample_size[1:]), batch_size=1, num_workers=1, shuffle=False) compression_algo.initialize(data_loader) model_conv = get_all_modules_by_type(model, 'Quantize') ref_table = { '.*Sequential\\[0\\].*UpdateWeight.*': (True, 1), '.*Sequential\\[1\\].*UpdateWeight. *': (False, 1), '.*activation_quantizers.*Sequential\\[0\\].*': (True, 4), '.*activation_quantizers.*Sequential\\[1\\].*': (True, 24) } for name, module in model_conv.items(): for pattern, ref_values in ref_table.items(): match = re.search(pattern, name) if match: assert isinstance(module, Quantize) assert module.signed == ref_values[ 0], 'sign is not matched for {}'.format(name) assert module.scale == ref_values[ 1], 'scale is not matched for {}'.format(name)
def check_correct_nncf_modules_replacement(model: NNCFNetwork, compressed_model: NNCFNetwork) \ -> Tuple[Dict[Scope, Module], Dict[Scope, Module]]: """ Check that all convolutions in model was replaced by NNCF convolution. :param model: original model :param compressed_model: compressed model :return: list of all convolutions in original model and list of all NNCF convolutions from compressed model """ NNCF_MODULES_REVERSED_MAP = {value: key for key, value in NNCF_MODULES_MAP.items()} original_modules = get_all_modules_by_type(model, list(NNCF_MODULES_MAP.values())) nncf_modules = get_all_modules_by_type(compressed_model.get_nncf_wrapped_model(), list(NNCF_MODULES_MAP.keys())) assert len(original_modules) == len(nncf_modules) print(original_modules, nncf_modules) for scope in original_modules.keys(): sparse_scope = deepcopy(scope) elt = sparse_scope.pop() # type: ScopeElement elt.calling_module_class_name = NNCF_MODULES_REVERSED_MAP[elt.calling_module_class_name] sparse_scope.push(elt) print(sparse_scope, nncf_modules) assert sparse_scope in nncf_modules return original_modules, nncf_modules
def test_can_create_magnitude_sparse_algo__with_defaults( update_mask_on_forward): model = MagnitudeTestModel() config = get_basic_magnitude_sparsity_config() config['compression']['params'] = \ {'schedule': 'multistep', 'update_mask_on_forward': update_mask_on_forward} compression_algo = create_compression_algorithm(deepcopy(model), config) assert isinstance(compression_algo, MagnitudeSparsity) sparse_model = compression_algo.model assert compression_algo.sparsity_level == approx(0.1) assert len(list(sparse_model.modules())) == 11 model_conv = get_all_modules_by_type(model, 'Conv2d') sparse_model_conv = get_all_modules_by_type(sparse_model, 'NNCFConv2d') assert len(model_conv) == len(sparse_model_conv) i = 0 for module_name in model_conv: scope = module_name.split('/') scope[-1] = scope[-1].replace('Conv2d', 'NNCFConv2d') sparse_module_name = '/'.join(scope) assert sparse_module_name in sparse_model_conv store = [] sparse_module = sparse_model_conv[sparse_module_name] ref_mask = torch.ones_like( sparse_module.weight ) if update_mask_on_forward or i == 0 else ref_mask_2 i += 1 for op in sparse_module.pre_ops.values(): if isinstance(op, UpdateWeight) and isinstance( op.operand, MagnitudeSparsifyingWeight): assert op.operand.threshold == approx(0.24, 0.1) assert torch.allclose(op.operand.binary_mask, ref_mask) assert isinstance(op.operand.weight_importance, type(normed_magnitude)) assert op.__class__.__name__ not in store store.append(op.__class__.__name__)
def get_avg_traces(model, init_device: str): """ Assigns bigger average traces for DepthWise Conv than for ordinary Conv and Linear""" all_convs = get_all_modules_by_type(model, 'Conv2d') dw_conv_indexes = [i for i, conv in enumerate(all_convs.values()) if conv.groups == conv.in_channels] dw_conv_indexes.append(len(all_convs)) num_traces = len(all_convs) + 1 # +1 Linear mock_avg_traces = [] scale = 1e-1 for i in range(num_traces): relative_sensativity = 2 * num_traces + i if i in dw_conv_indexes else num_traces - i mock_avg_traces.append(torch.Tensor([scale * relative_sensativity]).to(init_device)) return mock_avg_traces
def test_get_all_layers_by_type__with_ignored_scope(ignored_scopes): model = ModelForTest() model_modules = set() for _, module in model.named_modules(): model_modules.add(module.__class__.__name__) model_modules = list(model_modules) act_modules = get_all_modules_by_type(model, model_modules, ignored_scopes=ignored_scopes) for module_scope, _ in act_modules.items(): for scope in ignored_scopes: assert not str(module_scope).startswith(str(scope))
def test_get_all_layers_by_type__for_standart_type(): model = TestModel() act_bn = get_all_modules_by_type(model, 'BatchNorm2d') ref_bn = { 'TestModel/BatchNorm2d[bn1]': model.bn1, 'TestModel/BatchNorm2d[bn2]': model.bn2, 'TestModel/BatchNorm2d[norm10]': model.norm10, 'TestModel/BatchNorm2d[norm20]': model.norm20, 'TestModel/Sequential[layer1]/BatchNorm2d[norm01]': model.norm10, 'TestModel/Sequential[layer2]/BatchNorm2d[norm02]': model.norm20, 'TestModel/Sequential[layer2]/Sequential[layer1]/BatchNorm2d[norm01]': model.norm10, } assert act_bn == ref_bn
def test_get_all_layers_by_type__with_ignored_scope(ignored_scope): model = TestModel() model_modules = set() for _, module in model.named_modules(): model_modules.add(module.__class__.__name__) model_modules = list(model_modules) act_modules = get_all_modules_by_type(model, model_modules, ignored_scope=ignored_scope) for module_name in act_modules: for scope in ignored_scope: assert not module_name.startswith(scope)
def test_get_all_layers_by_type__for_standard_type(): model = ModelForTest() act_bn = get_all_modules_by_type(model, 'BatchNorm2d') act_bn = OrderedDict((str(k), v) for k, v in act_bn.items()) ref_bn = { 'ModelForTest/BatchNorm2d[bn1]': model.bn1, 'ModelForTest/BatchNorm2d[bn2]': model.bn2, 'ModelForTest/BatchNorm2d[norm10]': model.norm10, 'ModelForTest/BatchNorm2d[norm20]': model.norm20, 'ModelForTest/Sequential[layer1]/BatchNorm2d[norm01]': model.norm10, 'ModelForTest/Sequential[layer2]/BatchNorm2d[norm02]': model.norm20, 'ModelForTest/Sequential[layer2]/Sequential[layer1]/BatchNorm2d[norm01]': model.norm10, } assert act_bn == ref_bn
def test_scope_overrides(self, wrap_dataloader): config = create_config() config['target_device'] = 'NONE' config["compression"]["scope_overrides"] = { r"{re}NNCFConv2d\[[0-9]*\]$": { "bits": 7, "mode": "asymmetric", }, "/nncf_model_input_0": { "bits": 7, "mode": "asymmetric", }, r"{re}NNCFConv2d\[[0-9]*\]/conv2d_0": { "bits": 7, "signed": False, } } data_loader = self.create_dataloader(wrap_dataloader, config) config.register_extra_structs([QuantizationRangeInitArgs(data_loader)]) _, compressed_model = self.create_algo_and_compressed_model(config) quantizers = get_all_modules_by_type( compressed_model, ['SymmetricQuantizer', 'AsymmetricQuantizer']) quantizer_str_dict = {str(k): v for k, v in quantizers.items()} group_1 = [ quantizer_str_dict[ "NNCFNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/" "Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/" "AsymmetricQuantizer[op]"], quantizer_str_dict[ "NNCFNetwork/ModuleDict[activation_quantizers]/AsymmetricQuantizer" "[/nncf_model_input_0]"], quantizer_str_dict[ "NNCFNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/" "Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/" "AsymmetricQuantizer[op]"] ] group_2 = [ quantizer_str_dict[ "NNCFNetwork/ModuleDict[activation_quantizers]/" "SymmetricQuantizer[TwoConvTestModel/Sequential[features]" "/Sequential[0]/NNCFConv2d[0]/conv2d_0]"] ] for quantizer in group_1: assert isinstance(quantizer, AsymmetricQuantizer) assert quantizer.levels == 2**7 for quantizer in group_2: assert isinstance(quantizer, SymmetricQuantizer) assert not quantizer.signed
def test_sparse_network(self, desc: ModelDesc, algo): model = desc.model_builder() from nncf.layers import NNCF_MODULES_MAP sparsifiable_modules = list(NNCF_MODULES_MAP.values()) ref_num_sparsed = len( get_all_modules_by_type(model, sparsifiable_modules)) config = get_empty_config(input_sample_sizes=desc.input_sample_sizes) config["compression"] = {"algorithm": algo} compressed_model, compression_ctrl = \ create_compressed_model_and_algo_for_test(model, config, dummy_forward_fn=desc.dummy_forward_fn) assert ref_num_sparsed == len(compression_ctrl.sparsified_module_info) check_model_graph(compressed_model, desc.dot_filename, algo)
def test_sparse_network(self, model_name, model_builder, input_size, algo, params): model = model_builder() from nncf.layers import NNCF_MODULES_MAP sparsifiable_modules = list(NNCF_MODULES_MAP.values()) ref_num_sparsed = len(get_all_modules_by_type(model, sparsifiable_modules)) ctx = reset_context('test') config = get_empty_config(input_sample_size=input_size) config["compression"] = {"algorithm": algo, "params": params} compression_algo = create_compression_algorithm(model, config) assert ref_num_sparsed == len(compression_algo.sparsified_module_info) model = compression_algo.model with context('test') as c: _ = model(torch.zeros(input_size)) c.reset_scope_operator_call_counters() _ = model(torch.zeros(input_size)) check_graph(to_networkx(ctx), model_name, algo)
def test_load_state_sets_initialized_flag(): config = get_basic_quantization_config() model = TwoConvTestModel() quant_model, _ = create_compressed_model_and_algo_for_test(model, config) load_state(quant_model, { 'module.features.0.0.pre_ops.0.op.signed_tensor': torch.tensor([1.0]), # quantizer of 1st conv's weights 'module.features.1.0.pre_ops.0.op.scale': torch.tensor([1.0]) # quantizer of 2nd conv's weights }) quantizers = get_all_modules_by_type(quant_model, 'SymmetricQuantizer') for scope, module in quantizers.items(): if 'activation_quantizers' in str(scope) or 'UpdateInputs' in str(scope): assert not module.initialized else: assert module.initialized
def get_mock_avg_traces(model): all_convs = get_all_modules_by_type(model, 'Conv2d') dw_conv_indexes = [ i for i, conv in enumerate(all_convs.values()) if conv.groups == conv.in_channels ] dw_conv_indexes.append(len(all_convs)) num_traces = len(all_convs) + 1 # +1 Linear mock_avg_traces = [] scale = 1e-1 device = next(model.parameters()).device for i in range(num_traces): relative_sensativity = 2 * num_traces + i if i in dw_conv_indexes else num_traces - i mock_avg_traces.append( torch.Tensor([scale * relative_sensativity]).to(device)) return mock_avg_traces
def get_avg_traces_with_int4_layers_indexes(model, init_device: str): """ Assigns bigger average traces for DepthWise Conv than for ordinary Conv and Linear""" all_layers = get_all_modules_by_type(model, ['Conv2d', 'Linear']) int4_indexes = [] for i, layer in enumerate(all_layers.values()): if isinstance(layer, nn.Conv2d) and layer.groups != layer.in_channels: int4_indexes.append(i) num_traces = len(all_layers) mock_avg_traces = [] scale = 1e-1 for i in range(num_traces): relative_sensitivity = 2 * num_traces + i if i not in int4_indexes else num_traces - i mock_avg_traces.append(torch.Tensor([scale * relative_sensitivity]).to(init_device)) return torch.Tensor(mock_avg_traces).to(init_device), int4_indexes
def test_sparse_network(self, model_name, model_builder, forward_fn_, algo, params): model = model_builder() from nncf.layers import NNCF_MODULES_MAP sparsifiable_modules = list(NNCF_MODULES_MAP.values()) ref_num_sparsed = len(get_all_modules_by_type(model, sparsifiable_modules)) ctx = reset_context('test') config = get_empty_config() config["compression"] = {"algorithm": algo, "params": params} compression_algo = create_compression_algorithm(model, config, dummy_forward_fn=forward_fn_) assert ref_num_sparsed == len(compression_algo.sparsified_module_info) model = compression_algo.model model.to(self.device) with context('test') as c: forward_fn_(model) c.reset_scope_operator_call_counters() forward_fn_(model) check_graph(ctx.graph, model_name, algo)
def scale_signed_dumping_worker(gpu, ngpus_per_node, config, tmp_path): distributed_init_test_default(gpu, ngpus_per_node, config) data_loader = create_rank_dataloader(config, gpu) model = safe_thread_call(partial(squeezenet1_1, pretrained=True)) config.register_extra_structs([QuantizationRangeInitArgs(data_loader)]) quant_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) compression_scheduler = compression_ctrl.scheduler quant_model = post_compression_test_distr_init(compression_ctrl, config, ngpus_per_node, quant_model) criterion = torch.nn.MSELoss().cuda(config.gpu) optimizer = torch.optim.Adam(quant_model.parameters(), lr=0.01) torch.backends.cudnn.benchmark = True # just to reproduce the same scale values without Dropout quant_model.eval() act_sum = 0 for layer in get_all_modules_by_type(quant_model, "SymmetricQuantizer").values(): act_sum += layer.scale.sum() ref_sum = 4447.291 assert act_sum.item() == approx(ref_sum, 0.01), \ 'sum of scales is not expected {} vs {} rank {}'.format(act_sum.item(), ref_sum, config.rank) out_file_path = get_path_after_broadcast(tmp_path, config.rank) save_params(quant_model, out_file_path) compression_scheduler.step() for i, (input_, _) in enumerate(data_loader): if i > 5: break output = quant_model(input_) optimizer.zero_grad() dummy_target = torch.randn(1000).cuda(config.gpu, non_blocking=True) loss = criterion(output, dummy_target) compression_scheduler.step() loss.backward() optimizer.step() compression_scheduler.step() out_file_path = get_path_path_after_train_iters(tmp_path, config.rank) save_params(quant_model, out_file_path)
def test_scope_overrides(self, wrap_dataloader): config = self.create_config() config["compression"]["scope_overrides"] = { r"{re}NNCFConv2d\[[0-9]*\]$": { "bits": 7, "mode": "asymmetric", }, r"{re}NNCFConv2d\[[0-9]*\]/conv2d_0": { "bits": 7, "signed": False, } } algo = self.create_algo(config) data_loader = self.create_dataloader(wrap_dataloader, config, algo) algo.initialize(data_loader) quantizers = get_all_modules_by_type( algo.model, ['SymmetricQuantizer', 'AsymmetricQuantizer']) group_1 = [ quantizers[ "QuantizedNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/" "Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/" "AsymmetricQuantizer[op]"], quantizers[ "QuantizedNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/" "Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateInputs[1]/" "AsymmetricQuantizer[op]"], quantizers[ 'QuantizedNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/' 'Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/' 'AsymmetricQuantizer[op]'] ] group_2 = [ quantizers[ 'QuantizedNetwork/ModuleDict[activation_quantizers]/' 'SymmetricQuantizer[TwoConvTestModel/Sequential[features]' '/Sequential[0]/NNCFConv2d[0]/conv2d_0]'] ] for quantizer in group_1: assert isinstance(quantizer, AsymmetricQuantizer) assert quantizer.levels == 2**7 for quantizer in group_2: assert isinstance(quantizer, SymmetricQuantizer) assert not quantizer.signed
def disable_quantizer_gradients(): config = get_quantization_config_without_range_init() config['input_info'] = { "sample_size": [1, 3, 10, 10], } model = MobileNetV2(num_classes=10) model.eval() model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) original_requires_grad_per_param = get_requires_grad_per_param(model) quantization_types = [class_type.__name__ for class_type in QUANTIZATION_MODULES.registry_dict.values()] all_quantizations = get_all_modules_by_type(model, quantization_types) quantizers_switcher = QuantizersSwitcher(list(all_quantizations.values())) disabled_parameters = HAWQPrecisionInitializer.disable_all_gradients_except_weights_of_quantized_modules( quantizers_switcher, compression_ctrl.quantized_weight_modules_registry, model, get_scopes_of_skipped_weight_quantizers()) return quantizers_switcher, disabled_parameters, model, original_requires_grad_per_param
def test_can_quantize_inputs_for_sparsity_plus_quantization(): model = BasicConvTestModel() config = get_basic_sparsity_plus_quantization_config() sparse_quantized_model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) assert isinstance(compression_ctrl, CompositeCompressionAlgorithmController) sparse_quantized_model_conv = get_all_modules_by_type(sparse_quantized_model, 'NNCFConv2d') nncf_module = next(iter(sparse_quantized_model_conv.values())) assert len(nncf_module.pre_ops) == 3 # 1x weight sparsifier + 1x weight quantizer + 1x input quantizer assert isinstance(nncf_module.pre_ops['0'], UpdateWeight) assert isinstance(nncf_module.pre_ops['0'].op, RBSparsifyingWeight) assert isinstance(nncf_module.pre_ops['1'], UpdateWeight) assert isinstance(nncf_module.pre_ops['1'].op, SymmetricQuantizer) assert isinstance(nncf_module.pre_ops['2'], UpdateInputs) assert isinstance(nncf_module.pre_ops['2'].op, SymmetricQuantizer)
def __init__(self, model, num_init_steps): self.model = model def apply_collected_fn(initializer, modules_to_init_, distributed_): for name, module in modules_to_init_.items(): if hasattr(module, 'initialized'): if module.initialized: continue max_value = initializer.get_max_value(module) min_value = initializer.get_min_value(module) module_initializer = MIN_MAX_INITIALIZERS.get(type(module).__name__) module_initializer(module, name, min_value, max_value, distributed_) self.modules_to_init = OrderedDict() for module_type, _ in MIN_MAX_INITIALIZERS.registry_dict.items(): self.modules_to_init.update(get_all_modules_by_type(self.model, module_type)) # NOTE: Order of modules must be the same to correctly broadcast parameters (e.g. input_low and input_range) self.modules_to_init = OrderedDict(sorted(self.modules_to_init.items())) self.initializer = MinMaxInitializer(self.modules_to_init, apply_collected_fn, num_init_steps)
def _register_weight_sparsifying_operations(self, device, ignored_scope, logger): sparsified_modules = get_all_modules_by_type(self._model, NNCF_MODULES) self.sparsified_module_info = [] for module_name, module in sparsified_modules.items(): if in_scope_list(module_name, ignored_scope): logger.info( "Ignored adding Weight Sparsifier in scope: {}".format( module_name)) continue logger.info( "Adding Weight Sparsifier in scope: {}".format(module_name)) operation = self.create_weight_sparsifying_operation(module) opid = module.register_pre_forward_operation( UpdateWeight(operation).to(device)) self.sparsified_module_info.append( SparseModuleInfo(module_name, module, module.get_pre_op(opid).operand))
def test_disable_quantizer_gradients(): config = get_basic_quantization_config() config['input_info'] = { "sample_size": (1, 3, 10, 10), } model = MobileNetV2(num_classes=10) model.eval() model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) quantization_types = [class_type.__name__ for class_type in QUANTIZATION_MODULES.registry_dict.values()] all_quantizations = get_all_modules_by_type(model, quantization_types) HessianAwarePrecisionInitializeRunner.disable_quantizer_gradients( all_quantizations, compression_ctrl.quantized_weight_modules_registry, model) actual_state = get_requires_grad_per_param(model) path_to_ref = str(TEST_ROOT / 'data/hawq_reference/mobilenet_v2_requires_grad_per_param.json') compare_with_ref_if_exists(actual_state, path_to_ref)
def test_scope_overrides(self, wrap_dataloader): config = self.create_config() config["compression"]["scope_overrides"] = { r"{re}NNCFConv2d\[[0-9]*\]$": { "bits": 7, "mode": "asymmetric", }, r"{re}NNCFConv2d\[[0-9]*\]/conv2d_0": { "bits": 7, "signed": False, } } algo, compressed_model = self.create_algo_and_compressed_model(config) device = next(compressed_model.parameters()).device data_loader = self.create_dataloader(wrap_dataloader, config, device) algo.initialize(data_loader) quantizers = get_all_modules_by_type(compressed_model, ['SymmetricQuantizer', 'AsymmetricQuantizer']) quantizer_str_dict = {str(k): v for k, v in quantizers.items()} group_1 = [quantizer_str_dict["NNCFNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/" "Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/" "AsymmetricQuantizer[op]"], quantizer_str_dict["NNCFNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/" "Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateInputs[1]/" "AsymmetricQuantizer[op]"], quantizer_str_dict['NNCFNetwork/TwoConvTestModel[nncf_module]/Sequential[features]/' 'Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/' 'AsymmetricQuantizer[op]'] ] group_2 = [quantizer_str_dict['NNCFNetwork/ModuleDict[activation_quantizers]/' 'SymmetricQuantizer[TwoConvTestModel/Sequential[features]' '/Sequential[0]/NNCFConv2d[0]/conv2d_0]']] for quantizer in group_1: assert isinstance(quantizer, AsymmetricQuantizer) assert quantizer.levels == 2 ** 7 for quantizer in group_2: assert isinstance(quantizer, SymmetricQuantizer) assert not quantizer.signed
def test_enable_quantizer_gradients(): config = get_basic_quantization_config() config['input_info'] = { "sample_size": (1, 3, 10, 10), } model = MobileNetV2(num_classes=10) model.eval() model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) quantization_types = [class_type.__name__ for class_type in QUANTIZATION_MODULES.registry_dict.values()] all_quantizations = get_all_modules_by_type(model, quantization_types) original = get_requires_grad_per_param(model) disabled = HessianAwarePrecisionInitializeRunner.disable_quantizer_gradients( all_quantizations, compression_ctrl.quantized_weight_modules_registry, model) HessianAwarePrecisionInitializeRunner.enable_quantizer_gradients(model, all_quantizations, disabled) actual = get_requires_grad_per_param(model) assert original == actual