def test_load_state__with_resume_checkpoint(_resume_algos, _model_wrapper, mocker): config_save = get_empty_config() config_save['compression'] = [{ 'algorithm': algo } for algo in _resume_algos['save_algos'] if algo != 'EMPTY'] register_bn_adaptation_init_args(config_save) orig_model = BasicConvTestModel() num_model_params = len(orig_model.state_dict()) model_save, compressed_ctrl_save = create_compressed_model_and_algo_for_test( orig_model, config_save) saved_model_state = model_save.state_dict() saved_checkpoint = compressed_ctrl_save.get_compression_state() ref_num_loaded = _resume_algos[ 'ref_num_compression_params'] + num_model_params + 1 # padding_value config_resume = get_empty_config() config_resume['compression'] = [{ 'algorithm': algo } for algo in _resume_algos['load_algos'] if algo != 'EMPTY'] register_bn_adaptation_init_args(config_resume) from nncf.torch.checkpoint_loading import KeyMatcher key_matcher_run_spy = mocker.spy(KeyMatcher, 'run') model, _ = create_compressed_model_and_algo_for_test( BasicConvTestModel(), config_resume, compression_state=saved_checkpoint) load_state(model, saved_model_state, _resume_algos['is_strict']) key_matcher_run_spy.assert_called_once() act_num_loaded = len(key_matcher_run_spy.spy_return) assert act_num_loaded == ref_num_loaded
def test_can_export_compressed_model_with_input_output_names(tmp_path): test_path = str(tmp_path.joinpath('test.onnx')) target_input_names = ['input1', 'input2'] target_output_names = ['output1', 'output2'] model = BasicTestModelWithTwoInputOutput() config = get_basic_asym_quantization_config() config["input_info"] = [{'sample_size': [1, 1, 4, 4]}, {'sample_size': [1, 1, 4, 4]}] register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) compression_ctrl.export_model(test_path, input_names=target_input_names, output_names=target_output_names) assert os.path.exists(test_path) onnx_model = onnx.load(test_path) # pylint: disable=no-member curr_input_names = [node.name for node in onnx_model.graph.input] curr_output_names = [node.name for node in onnx_model.graph.output] assert curr_input_names == target_input_names assert curr_output_names == target_output_names
def test_quantize_outputs_with_scope_overrides(): config = get_quantization_config_without_range_init() config["input_info"] = [{ "sample_size": [2, 3, 32, 32], }] model = QuantizeOutputsTestModel() config['compression']['quantize_outputs'] = True config['target_device'] = "TRIAL" config['compression']['scope_overrides'] = { "activations": { "/nncf_model_output_0": { "bits": 4, "mode": "asymmetric", } } } register_bn_adaptation_init_args(config) model, ctrl = create_compressed_model_and_algo_for_test(model, config) output_quantizers =\ [q for qid, q in ctrl.all_quantizations.items() if isinstance(qid, NonWeightQuantizerId)] for q in output_quantizers[1:]: assert q.num_bits == 8 assert isinstance(q, SymmetricQuantizer) assert output_quantizers[0].num_bits == 4 assert isinstance(output_quantizers[0], AsymmetricQuantizer)
def test_staged_scheduler_with_empty_quantization(): config = get_squeezenet_quantization_config() config['compression'].update({ 'params': { "activations_quant_start_epoch": 1, "weights_quant_start_epoch": 2, } }) register_bn_adaptation_init_args(config) model = squeezenet1_1(num_classes=10, dropout=0) model, algo = create_compressed_model_and_algo_for_test(model, config) scheduler = algo.scheduler for module in algo.all_quantizations.values(): assert not module.is_enabled_quantization() scheduler.epoch_step() for module in algo.all_quantizations.values(): assert not module.is_enabled_quantization() scheduler.epoch_step() for wq_info in algo.weight_quantizers.values(): assert not wq_info.quantizer_module_ref.is_enabled_quantization() for aq_info in algo.non_weight_quantizers.values(): assert aq_info.quantizer_module_ref.is_enabled_quantization() scheduler.epoch_step() for module in algo.all_quantizations.values(): assert module.is_enabled_quantization()
def test_multiprocessing_distributed_shares_init_scales_signedness_across_gpus( tmp_path, runs_subprocess_in_precommit): if not torch.cuda.is_available(): pytest.skip("Skipping CUDA test cases for CPU only setups") num_init_samples = 10 config = get_squeezenet_quantization_config() config['compression']['initializer'] = { 'range': { 'num_init_samples': num_init_samples } } ngpus_per_node = torch.cuda.device_count() config.world_size = ngpus_per_node register_bn_adaptation_init_args(config) torch.multiprocessing.spawn(scale_signed_dumping_worker, nprocs=ngpus_per_node, args=(ngpus_per_node, config, tmp_path), join=True) assert not compare_multi_gpu_dump(config, tmp_path, get_path_after_broadcast) assert not compare_multi_gpu_dump(config, tmp_path, get_path_path_after_train_iters)
def test_can_quantize_inputs_for_sparsity_plus_quantization(): model = BasicConvTestModel() config = get_basic_sparsity_plus_quantization_config() register_bn_adaptation_init_args(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) == 2 # 1x weight sparsifier + 1x weight 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) input_quantizer = get_all_modules(sparse_quantized_model)[ f'NNCFNetwork/ModuleDict[{EXTERNAL_QUANTIZERS_STORAGE_NAME}]'] assert len(input_quantizer) == 1 assert isinstance(list(input_quantizer.values())[0], SymmetricQuantizer)
def test_can_export_compressed_model_with_specified_domain_for_custom_ops(tmp_path): test_path = str(tmp_path.joinpath('test.onnx')) model = BasicTestModelWithTwoInputOutput() config = get_basic_asym_quantization_config() config["input_info"] = [{'sample_size': [1, 1, 4, 4]}, {'sample_size': [1, 1, 4, 4]}] register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) compression_ctrl.export_model(test_path) assert os.path.exists(test_path) onnx_model = onnx.load(test_path) count_custom_ops = 0 # pylint: disable=no-member for op_node in onnx_model.graph.node: if op_node.op_type == "FakeQuantize": assert op_node.domain == DOMAIN_CUSTOM_OPS_NAME count_custom_ops += 1 assert count_custom_ops == 4
def test_quantization_configs__with_defaults(): model = BasicConvTestModel() config = get_quantization_config_without_range_init() register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) assert isinstance(compression_ctrl, QuantizationController) weight_quantizers = compression_ctrl.weight_quantizers activation_quantizer_infos = compression_ctrl.non_weight_quantizers ref_weight_qspec = PTQuantizerSpec( num_bits=8, mode=QuantizationMode.SYMMETRIC, signedness_to_force=True, narrow_range=True, half_range=False, scale_shape=model.wq_scale_shape_per_channel, logarithm_scale=False) for wq_info in weight_quantizers.values(): compare_qspecs(ref_weight_qspec, wq_info.quantizer_module_ref) ref_activation_qspec = PTQuantizerSpec(num_bits=8, mode=QuantizationMode.SYMMETRIC, signedness_to_force=None, narrow_range=False, half_range=False, scale_shape=(1, ), logarithm_scale=False) for aq_info in activation_quantizer_infos.values(): compare_qspecs(ref_activation_qspec, aq_info.quantizer_module_ref)
def test_quantization_preset_with_scope_overrides(): model = QuantizeOutputsTestModel() config = get_empty_config(input_sample_sizes=[2, 3, 32, 32]) config['target_device'] = "TRIAL" config['compression'] = { 'algorithm': 'quantization', 'preset': 'mixed', 'scope_overrides': { 'weights': { 'QuantizeOutputsTestModel/NNCFConv2d[conv5]/conv2d_0': { "mode": "asymmetric", } } } } register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) for wq_info in compression_ctrl.weight_quantizers.values(): if wq_info.affected_insertions[0].target_node_name !=\ 'QuantizeOutputsTestModel/NNCFConv2d[conv5]/conv2d_0': assert isinstance(wq_info.quantizer_module_ref, SymmetricQuantizer) else: assert isinstance(wq_info.quantizer_module_ref, AsymmetricQuantizer) for aq_info in compression_ctrl.non_weight_quantizers.values(): assert isinstance(aq_info.quantizer_module_ref, AsymmetricQuantizer)
def test_activation_quantizers_order_is_the_same__for_resnet50( tmp_path, runs_subprocess_in_precommit): if not torch.cuda.is_available(): pytest.skip("Skipping CUDA test cases for CPU only setups") config = get_empty_config(input_sample_sizes=[1, 3, 224, 224]) config['compression'] = { 'algorithm': 'quantization', "initializer": { "range": { "num_init_samples": 0 } } } register_bn_adaptation_init_args(config) ngpus_per_node = torch.cuda.device_count() torch.multiprocessing.spawn(activation_quantizers_dumping_worker, nprocs=ngpus_per_node, args=(config, tmp_path), join=True) with open(get_path_to_keys(tmp_path, 0), 'r', encoding='utf8') as f: ref_list = f.readlines() for i in range(1, ngpus_per_node): with open(get_path_to_keys(tmp_path, i), 'r', encoding='utf8') as f: curr_list = f.readlines() assert curr_list == ref_list
def test_quantize_outputs(): config = get_quantization_config_without_range_init() config["input_info"] = [{ "sample_size": [2, 3, 32, 32], }] model = QuantizeOutputsTestModel() config['compression']['quantize_outputs'] = True register_bn_adaptation_init_args(config) model, qctrl = create_compressed_model_and_algo_for_test(model, config) REF_QUANTIZED_OUTPUT_MODULE_SCOPES = [ 'QuantizeOutputsTestModel/NNCFConv2d[conv1]/conv2d_0|OUTPUT', 'QuantizeOutputsTestModel/NNCFConv2d[conv2]/conv2d_0|OUTPUT', 'QuantizeOutputsTestModel/NNCFConv2d[conv3]/conv2d_0|OUTPUT', 'QuantizeOutputsTestModel/NNCFConv2d[conv4]/conv2d_0|OUTPUT' ] actual_output_quantizer_str_scopes =\ [str(aq_id) for aq_id in qctrl.non_weight_quantizers if 'nncf_model_input' not in str(aq_id)] assert len(REF_QUANTIZED_OUTPUT_MODULE_SCOPES) == len( actual_output_quantizer_str_scopes) for ref_qinput_scope_str in REF_QUANTIZED_OUTPUT_MODULE_SCOPES: matches = [] for aq_id in qctrl.non_weight_quantizers: if str(aq_id) == ref_qinput_scope_str: matches.append(aq_id) assert len(matches) == 1 quantizer = qctrl.non_weight_quantizers[ matches[0]].quantizer_module_ref assert isinstance(quantizer, SymmetricQuantizer)
def test_export_stacked_bi_lstm(tmp_path): p = LSTMTestSizes(3, 3, 3, 3) config = get_empty_config( input_sample_sizes=[1, p.hidden_size, p.input_size]) config['compression'] = {'algorithm': 'quantization'} register_bn_adaptation_init_args(config) # TODO: batch_first=True fails with building graph: ambiguous call to mul or sigmoid test_rnn = NNCF_RNN('LSTM', input_size=p.input_size, hidden_size=p.hidden_size, num_layers=2, bidirectional=True, batch_first=False) model, algo = create_compressed_model_and_algo_for_test(test_rnn, config) test_path = str(tmp_path.joinpath('test.onnx')) algo.export_model(test_path) assert os.path.exists(test_path) onnx_num = 0 model = onnx.load(test_path) # pylint: disable=no-member for node in model.graph.node: if node.op_type == 'FakeQuantize': onnx_num += 1 assert onnx_num == 54
def test_can_load_quant_algo__with_defaults(): model = BasicConvTestModel() config = get_quantization_config_without_range_init() register_bn_adaptation_init_args(config) builder = create_compression_algorithm_builder(config) assert isinstance(builder, QuantizationBuilder) quant_model, _ = create_compressed_model_and_algo_for_test( deepcopy(model), config) model_conv = get_all_modules_by_type(model, 'Conv2d') quant_model_conv = get_all_modules_by_type( quant_model.get_nncf_wrapped_model(), 'NNCFConv2d') assert len(model_conv) == len(quant_model_conv) for module_scope, _ in model_conv.items(): quant_scope = deepcopy(module_scope) # type: Scope quant_scope.pop() quant_scope.push(ScopeElement('NNCFConv2d', 'conv')) assert quant_scope in quant_model_conv.keys() store = [] for op in quant_model_conv[quant_scope].pre_ops.values(): if isinstance(op, (UpdateInputs, UpdateWeight)) and isinstance( op.operand, SymmetricQuantizer): assert op.__class__.__name__ not in store store.append(op.__class__.__name__) assert UpdateWeight.__name__ in store
def test_load_state_interoperability(_algos, _model_wrapper, is_resume): config_save = get_empty_config() config_save['compression'] = [{ 'algorithm': algo } for algo in _algos['save_algos']] register_bn_adaptation_init_args(config_save) compressed_model_save, _ = create_compressed_model_and_algo_for_test( BasicConvTestModel(), config_save) model_save = _model_wrapper['save_model'](compressed_model_save) saved_model_state = model_save.state_dict() ref_num_loaded = len(saved_model_state) config_resume = get_empty_config() config_resume['compression'] = [{ 'algorithm': algo } for algo in _algos['load_algos']] register_bn_adaptation_init_args(config_resume) compressed_model_resume, _ = create_compressed_model_and_algo_for_test( BasicConvTestModel(), config_resume) model_resume = _model_wrapper['resume_model'](compressed_model_resume) if not is_resume or (is_resume and _algos['is_resume_ok']): act_num_loaded = load_state(model_resume, saved_model_state, is_resume) if ('magnitude_sparsity' in _algos['load_algos'] or 'const_sparsity' in _algos['load_algos']) \ and 'rb_sparsity' in _algos['save_algos']: # no need to load _mask and _uniform ref_num_loaded -= 2 assert act_num_loaded == ref_num_loaded else: with pytest.raises(RuntimeError): load_state(model_resume, saved_model_state, is_resume)
def get_config_for_logarithm_scale(logarithm_scale: bool, quantization_type: str) -> NNCFConfig: nncf_config = NNCFConfig() nncf_config.update({ "input_info": { "sample_size": SAMPLE_SIZE }, "target_device": 'TRIAL', "compression": { "algorithm": "quantization", "initializer": { "range": { "num_init_samples": 4, "type": "percentile", "params": { "min_percentile": 0.001, "max_percentile": 99.999 } } }, "activations": { "mode": quantization_type, "logarithm_scale": logarithm_scale }, "weights": { "mode": quantization_type, "signed": True, "logarithm_scale": logarithm_scale } } }) class RandDatasetMock: def __getitem__(self, index): return torch.rand(*SAMPLE_SIZE) def __len__(self): return 4 data_loader = torch.utils.data.DataLoader(RandDatasetMock(), batch_size=1, shuffle=False, drop_last=True) class SquadInitializingDataloader( nncf.torch.initialization.PTInitializingDataLoader): def get_inputs(self, batch): return batch, {} def get_target(self, batch): return None initializing_data_loader = SquadInitializingDataloader(data_loader) init_range = nncf.config.structures.QuantizationRangeInitArgs( initializing_data_loader) nncf_config.register_extra_structs([init_range]) register_bn_adaptation_init_args(nncf_config) return nncf_config
def test_quantization_configs__with_precisions_list(): desc = TestPrecisionInitDesc() model = desc.model_creator() config = desc.config register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) desc.check_precision_init(compression_ctrl)
def test_can_compress_with_config_and_resume_of_old_checkpoint(): model = SingleConv2dIdentityModel() config = get_basic_quantization_config( input_info={"sample_size": [1, 3, 100, 100]}) register_bn_adaptation_init_args(config) create_compressed_model_and_algo_for_test(model, config, compression_state=old_style_sd)
def test_unified_scales_are_identical_in_onnx(self, tmp_path): # pylint:disable=no-member nncf_config = get_quantization_config_without_range_init(model_size=1) nncf_config["compression"]["quantize_outputs"] = True nncf_config["input_info"] = [ { "sample_size": [1, 1, 1, 2], }, ] nncf_config["target_device"] = "VPU" register_bn_adaptation_init_args(nncf_config) compressed_model, compression_ctrl = create_compressed_model_and_algo_for_test( SimplerModelForUnifiedScalesTesting(), nncf_config) with torch.no_grad(): for quant_info in compression_ctrl.non_weight_quantizers.values(): if isinstance(quant_info.quantizer_module_ref, AsymmetricQuantizer): quant_info.quantizer_module_ref.input_range *= torch.abs( torch.rand_like( quant_info.quantizer_module_ref.input_range)) else: quant_info.quantizer_module_ref.scale *= torch.abs( torch.rand_like(quant_info.quantizer_module_ref.scale)) test_input1 = torch.ones([1, 1, 1, 2]) compressed_model.forward(test_input1) onnx_path = str(tmp_path / "model.onnx") compression_ctrl.export_model(onnx_path) onnx_model = onnx.load(onnx_path) fq_nodes = TestsWithONNXInspection.get_fq_nodes(onnx_model) eltwise_dominator_predicate = partial( TestsWithONNXInspection.immediately_dominates_add_or_mul, graph=onnx_model.graph) eltwise_fq_nodes = list(filter(eltwise_dominator_predicate, fq_nodes)) cat_dominator_predicate = partial( TestsWithONNXInspection.immediately_dominates_cat, graph=onnx_model.graph) cat_fq_nodes = list(filter(cat_dominator_predicate, fq_nodes)) fq_nodes_grouped_by_output = TestsWithONNXInspection.group_nodes_by_output_target( eltwise_fq_nodes + cat_fq_nodes, onnx_model.graph) for unified_scale_group in fq_nodes_grouped_by_output: inputs = [ resolve_constant_node_inputs_to_values(fq_node, onnx_model.graph) for fq_node in unified_scale_group ] for inputs_dict in inputs[1:]: curr_values = list(inputs_dict.values()) ref_values = list(inputs[0].values()) assert curr_values == ref_values # All inputs for unified scale quantizers must be equal
def test_quantize_network(self, desc: ModelDesc, _case_config): model = desc.model_builder() config = get_basic_quantization_config(_case_config.quant_type, input_sample_sizes=desc.input_sample_sizes) register_bn_adaptation_init_args(config) compressed_model, _ = \ create_compressed_model_and_algo_for_test(model, config, dummy_forward_fn=desc.dummy_forward_fn, wrap_inputs_fn=desc.wrap_inputs_fn) check_model_graph(compressed_model, desc.dot_filename, _case_config.graph_dir)
def test_debug_mode(): config = get_quantization_config_without_range_init() register_bn_adaptation_init_args(config) model = BasicConvTestModel() with nncf_debug(): model, _ = create_compressed_model_and_algo_for_test(model, config) model.forward( torch.zeros(BasicConvTestModel.INPUT_SIZE, device=next(model.parameters()).device))
def test_can_export_compressed_model(self, tmp_path, config_provider, model_provider): test_path = str(tmp_path.joinpath('test.onnx')) model = model_provider() config = config_provider() register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) compression_ctrl.export_model(test_path) assert os.path.exists(test_path)
def test_renamed_activation_quantizer_storage_in_state_dict(): model = SingleConv2dIdentityModel() config = get_basic_quantization_config( input_info={"sample_size": [1, 3, 100, 100]}) register_bn_adaptation_init_args(config) compressed_model, _ = create_compressed_model_and_algo_for_test( model, config) with pytest.deprecated_call(): _ = load_state(compressed_model, old_style_sd, is_resume=True)
def test_resnet18__with_not_qinput(_case_config): model = test_models.ResNet18() input_shape = [1, 3, 32, 32] config = get_basic_quantization_config(_case_config.quant_type, input_sample_sizes=input_shape) config["compression"].update({"quantize_inputs": False}) register_bn_adaptation_init_args(config) compressed_model, _ = create_compressed_model_and_algo_for_test(model, config) check_model_graph(compressed_model, 'resnet18_no_qinput.dot', _case_config.graph_dir)
def test_output_quantization(_case_config): model = test_models.UNet() input_shape = [1, 3, 360, 480] config = get_basic_quantization_config(_case_config.quant_type, input_sample_sizes=input_shape) config["compression"].update({"quantize_outputs": True}) register_bn_adaptation_init_args(config) compressed_model, _ = create_compressed_model_and_algo_for_test(model, config) check_model_graph(compressed_model, 'unet_qoutput.dot', _case_config.graph_dir)
def test_context_independence(model_name, model_builder, input_size, _case_config): config = get_basic_quantization_config(_case_config.quant_type, input_sample_sizes=input_size[0]) register_bn_adaptation_init_args(config) compressed_models = [create_compressed_model_and_algo_for_test(model_builder[0](), config)[0], create_compressed_model_and_algo_for_test(model_builder[1](), config)[0]] for i, compressed_model in enumerate(compressed_models): check_model_graph(compressed_model, model_name[i], _case_config.graph_dir)
def test_multiple_forward(): # Check that all convolution nodes in model have op_address and layer_attributes # for case with multiple forward of one module model = TestModelMultipleForward() config = get_basic_sparsity_plus_quantization_config() register_bn_adaptation_init_args(config) sparse_quantized_model, _ = create_compressed_model_and_algo_for_test(model, config) graph = sparse_quantized_model.get_original_graph() for node in list(graph.get_all_nodes())[1:-2]: assert node.layer_attributes is not None
def test_weight_and_act_quantizer_scale_unification(self, tmp_path): # pylint:disable=no-member nncf_config = get_quantization_config_without_range_init(model_size=1) nncf_config["input_info"] = [ { "sample_size": [1, 5], "type": "long", "filler": "zeros" }, ] nncf_config["target_device"] = "VPU" register_bn_adaptation_init_args(nncf_config) compressed_model, compression_ctrl = create_compressed_model_and_algo_for_test( TwoEmbeddingAddModel(), nncf_config) with torch.no_grad(): for quant_module in compression_ctrl.all_quantizations.values(): if isinstance(quant_module, AsymmetricQuantizer): quant_module.input_range *= torch.abs( torch.rand_like(quant_module.input_range)) else: quant_module.scale *= torch.abs( torch.rand_like(quant_module.scale)) test_input1 = torch.ones([1, 5], dtype=torch.long) compressed_model.forward(test_input1) onnx_path = str(tmp_path / "model.onnx") compression_ctrl.export_model(onnx_path) onnx_model = onnx.load(onnx_path) fq_nodes = TestsWithONNXInspection.get_fq_nodes(onnx_model) eltwise_dominator_predicate = partial( TestsWithONNXInspection.immediately_dominates_add_or_mul, graph=onnx_model.graph) embedding_dominator_predicate = partial( TestsWithONNXInspection.immediately_dominates_embedding, graph=onnx_model.graph) eltwise_fq_nodes = list(filter(eltwise_dominator_predicate, fq_nodes)) embedding_weight_fq_nodes = list( filter(embedding_dominator_predicate, fq_nodes)) fq_nodes_with_expected_unified_scales = embedding_weight_fq_nodes + eltwise_fq_nodes unified_fq_node_inputs = [ resolve_constant_node_inputs_to_values(fq_node, onnx_model.graph) for fq_node in fq_nodes_with_expected_unified_scales ] for inputs_dict in unified_fq_node_inputs[1:]: curr_values = list(inputs_dict.values()) ref_values = list(unified_fq_node_inputs[0].values()) assert curr_values == ref_values # All inputs for unified scale quantizers must be equal
def test_can_create_quant_loss_and_scheduler(): config = get_quantization_config_without_range_init() register_bn_adaptation_init_args(config) _, compression_ctrl = create_compressed_model_and_algo_for_test( BasicConvTestModel(), config) loss = compression_ctrl.loss assert isinstance(loss, PTCompressionLoss) scheduler = compression_ctrl.scheduler assert isinstance(scheduler, CompressionScheduler)
def test_synthetic_model_quantization(synthetic_model_desc: IModelDesc): config = get_basic_quantization_config(input_sample_sizes=synthetic_model_desc.get_input_sample_sizes(), input_info=synthetic_model_desc.get_input_info()) register_bn_adaptation_init_args(config) model = synthetic_model_desc.get_model() compressed_model, _ = create_compressed_model_and_algo_for_test( model, config, wrap_inputs_fn=synthetic_model_desc.get_wrap_inputs_fn()) check_model_graph(compressed_model, synthetic_model_desc.get_dot_filename(), os.path.join('quantized', 'synthetic_model'))
def create_config(): config = get_empty_config() config['compression'] = { 'algorithm': 'quantization', 'initializer': { 'range': { 'num_init_samples': 1 } } } register_bn_adaptation_init_args(config) return config