def test_scheduler_can_do_epoch_step(self, algo, schedule, get_params, ref_levels): model = get_basic_conv_test_model() config = get_empty_config() config['compression'] = Dict({ 'algorithm': algo, 'sparsity_init': 0.2, "params": { **get_params(), "schedule": schedule } }) _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) scheduler = compression_ctrl.scheduler assert pytest.approx(scheduler.current_sparsity_level) == ref_levels[0] for ref_level in ref_levels[1:]: scheduler.epoch_step() assert pytest.approx(scheduler.current_sparsity_level) == ref_level _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) scheduler = compression_ctrl.scheduler assert pytest.approx(scheduler.current_sparsity_level) == ref_levels[0] for i, ref_level in enumerate(ref_levels[1:]): scheduler.epoch_step(i) assert pytest.approx(scheduler.current_sparsity_level) == ref_level
def test_checkpoint_callback_make_checkpoints(mocker, tmp_path): save_freq = 2 config = get_basic_quantization_config() gen_setup_spy = mocker.spy(QuantizationBuilder, '_get_quantizer_setup') model, compression_ctrl = create_compressed_model_and_algo_for_test( get_basic_conv_test_model(), config, force_no_init=True) assert isinstance(compression_ctrl, QuantizationController) quantizer_setup = gen_setup_spy.spy_return compression_callbacks = create_compression_callbacks(compression_ctrl, log_tensorboard=False) dataset_len = 8 dummy_x = tf.random.normal((dataset_len, ) + model.input_shape[1:]) dummy_y = tf.random.normal((dataset_len, ) + model.output_shape[1:]) model.compile(loss=tf.losses.CategoricalCrossentropy()) ckpt_path = tmp_path / 'checkpoint' ckpt = tf.train.Checkpoint( model=model, compression_state=TFCompressionState(compression_ctrl)) model.fit(dummy_x, dummy_y, epochs=5, batch_size=2, callbacks=[ CheckpointManagerCallback(ckpt, str(ckpt_path), save_freq), *compression_callbacks ]) assert sorted(os.listdir(ckpt_path)) == REF_CKPT_DIR[save_freq] new_compression_state = load_compression_state(ckpt_path) new_model, new_compression_ctrl = create_compressed_model_and_algo_for_test( get_basic_conv_test_model(), config, new_compression_state) new_model.compile(loss=tf.losses.CategoricalCrossentropy()) new_ckpt = tf.train.Checkpoint( model=new_model, compression_state=TFCompressionState(new_compression_ctrl)) load_checkpoint(new_ckpt, ckpt_path) builder = QuantizationBuilder(config) builder.load_state(new_compression_state['builder_state']) # pylint:disable=protected-access new_quantizer_setup = builder._quantizer_setup assert _quantization_setup_cmp(quantizer_setup, new_quantizer_setup) assert new_compression_ctrl.get_state() == compression_ctrl.get_state() assert tf.reduce_all([ tf.reduce_all(w_new == w) for w_new, w in zip(new_model.weights, model.weights) ])
def test_quantization_preset_with_scope_overrides(): model = get_basic_two_conv_test_model() config = get_basic_quantization_config() config['target_device'] = "TRIAL" config['compression'] = { 'algorithm': 'quantization', 'preset': 'mixed', 'scope_overrides': { 'weights': { 'conv2d': { "mode": "asymmetric", } } } } compression_model, _ = create_compressed_model_and_algo_for_test( model, config, force_no_init=True) activation_quantizers, weight_quantizers = get_quantizers( compression_model) for aq in activation_quantizers: assert aq.mode == 'asymmetric' for wq in weight_quantizers: if wq.name == 'conv2d_kernel_quantizer': assert wq.mode == 'asymmetric' else: assert wq.mode == 'symmetric'
def test_can_load_sparse_algo__with_defaults(): model = get_basic_two_conv_test_model() config = get_basic_sparsity_config(sparsity_init=0.1) sparse_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) assert isinstance(compression_ctrl, RBSparsityController) assert compression_ctrl.scheduler.initial_level == approx(0.1) conv_names = [ layer.name for layer in model.layers if isinstance(layer, tf.keras.layers.Conv2D) ] wrappers = [ layer for layer in sparse_model.layers if isinstance(layer, NNCFWrapper) ] correct_wrappers = [ wrapper for wrapper in wrappers if wrapper.name in conv_names ] assert len(conv_names) == len(wrappers) assert len(conv_names) == len(correct_wrappers) for wrapper in wrappers: op = get_op_by_cls(wrapper, RBSparsifyingWeight) mask = wrapper.get_operation_weights(op.name)['mask'] ref_mask = tf.fill(mask.shape, logit(0.99)) tf.assert_equal(mask, ref_mask)
def test_magnitude_algo_binary_masks_are_applied(): input_shape = (1, 5, 5, 1) model = get_basic_conv_test_model(input_shape=input_shape[1:]) config = get_empty_config(input_sample_sizes=input_shape) config.update(Dict({'compression': {'algorithm': "magnitude_sparsity"}})) compressed_model, _ = create_compressed_model_and_algo_for_test( model, config) conv = compressed_model.layers[1] op_name = list(conv.ops_weights.keys())[0] conv.ops_weights[op_name] = {'mask': tf.ones_like(conv.weights[0])} input_ = tf.ones(input_shape) ref_output_1 = -4 * tf.ones((1, 4, 4, 2)) output_1 = compressed_model(input_) tf.assert_equal(output_1, ref_output_1) np_mask = conv.ops_weights[op_name]['mask'].numpy() np_mask[0, 1, 0, 0] = 0 np_mask[1, 0, 0, 1] = 0 conv.ops_weights[op_name] = {'mask': tf.constant(np_mask)} ref_output_2 = -3 * tf.ones_like(ref_output_1) output_2 = compressed_model(input_) tf.assert_equal(output_2, ref_output_2) np_mask[0, 1, 0, 1] = 0 conv.ops_weights[op_name] = {'mask': tf.constant(np_mask)} ref_output_3 = ref_output_2.numpy() ref_output_3[..., 1] = -2 * np.ones_like(ref_output_1[..., 1]) ref_output_3 = tf.constant(ref_output_3) output_3 = compressed_model(input_) tf.assert_equal(output_3, ref_output_3)
def test_quantization_configs__disable_overflow_fix_and_resume_from_compression_state( tmp_path): model = get_basic_conv_test_model() config = get_basic_quantization_config() config['compression'].update({'overflow_fix': 'disable'}) compression_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config, force_no_init=True) compression_state_to_load = _save_and_load_compression_state( compression_ctrl, tmp_path) compression_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config, compression_state_to_load) assert isinstance(compression_ctrl, QuantizationController) check_specs_for_disabled_overflow_fix(compression_model)
def test_compression_controller_state(): from nncf.common.compression import BaseControllerStateNames as CtrlStateNames model = get_magnitude_test_model() config = get_basic_magnitude_sparsity_config() algo_name = config['compression']['algorithm'] config['compression']['params'] = {'schedule': 'multistep'} _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) # Test get state compression_ctrl.scheduler.current_step = 100 compression_ctrl.scheduler.current_epoch = 5 state_content = compression_ctrl.get_state()[algo_name] assert state_content[CtrlStateNames.SCHEDULER] == { 'current_step': 100, 'current_epoch': 5 } # Test load state new_state = { algo_name: { CtrlStateNames.SCHEDULER: { 'current_step': 500, 'current_epoch': 10 }, CtrlStateNames.LOSS: {}, CtrlStateNames.COMPRESSION_STAGE: None, } } compression_ctrl.load_state(new_state) assert compression_ctrl.scheduler.current_step == 500 assert compression_ctrl.scheduler.current_epoch == 10 assert compression_ctrl.get_state() == new_state
def test_no_compression_algo_not_change_model_params(): orig_model = get_basic_two_conv_test_model() model, _algo = create_compressed_model_and_algo_for_test( orig_model, NO_COMPRESSION_NNCF_CONFIG) orig_model_weights = orig_model.get_weights() model_weights = model.get_weights() TFTensorListComparator.check_equal(orig_model_weights, model_weights)
def test_quantization_configs__with_defaults(): model = get_basic_conv_test_model() config = get_basic_quantization_config() compression_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config, force_no_init=True) assert isinstance(compression_ctrl, QuantizationController) check_default_qspecs(compression_model)
def test_can_create_magnitude_algo__without_levels(): config = get_basic_magnitude_sparsity_config() config['compression']['params'] = { 'schedule': 'multistep', 'multistep_steps': [1] } _, compression_ctrl = create_compressed_model_and_algo_for_test( get_mock_model(), config) assert compression_ctrl.scheduler.current_sparsity_level == approx(0.1)
def test_adaptive_compression_training_loop(max_accuracy_degradation, final_compression_rate, reference_final_metric, should_raise_runtime_error, initial_training_phase_epochs=5, patience_epochs=3, uncompressed_model_accuracy=0.2, steps_per_epoch=20, img_size=10): set_random_seed(42) model = get_simple_conv_regression_model(img_size) dataset = get_const_target_mock_regression_dataset(img_size=img_size, num_samples=steps_per_epoch) config = get_basic_magnitude_sparsity_config(input_sample_size=[1, img_size, img_size, 1]) params = { "initial_training_phase_epochs": initial_training_phase_epochs, "patience_epochs": patience_epochs, } params.update(max_accuracy_degradation) accuracy_aware_config = { "accuracy_aware_training": { "mode": "adaptive_compression_level", "params": params } } config.update(accuracy_aware_config) compress_model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) compression_callbacks = create_compression_callbacks(compression_ctrl, log_tensorboard=False) compress_model.add_loss(compression_ctrl.loss) def inverse_loss(y_true, y_pred): return 1 / (1 + (y_true - y_pred) ** 2) compress_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01), loss=tf.keras.losses.MeanSquaredError(), metrics=inverse_loss) result_dict_to_val_metric_fn = lambda results: results['inverse_loss'] exec_ctx = pytest.raises(RuntimeError) if should_raise_runtime_error \ else contextlib.suppress() with exec_ctx as execinfo: compress_model.accuracy_aware_fit(dataset, compression_ctrl, nncf_config=config, callbacks=compression_callbacks, initial_epoch=0, steps_per_epoch=steps_per_epoch, uncompressed_model_accuracy=uncompressed_model_accuracy, result_dict_to_val_metric_fn=result_dict_to_val_metric_fn) validation_metrics = compress_model.evaluate(dataset, return_dict=True) assert result_dict_to_val_metric_fn(validation_metrics) == pytest.approx(reference_final_metric, 1e-4) assert compression_ctrl.compression_rate == pytest.approx(final_compression_rate, 1e-3) if should_raise_runtime_error: assert str(execinfo.value) == 'Cannot produce a compressed model with a ' \ 'specified minimal tolerable accuracy'
def test_sparse_algo_can_collect_sparse_ops(): model = get_basic_two_conv_test_model() config = get_basic_sparsity_config() _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) # pylint: disable=protected-access assert len(compression_ctrl.loss._target_ops) == 2
def test_compression_controller_state(): from nncf.common.compression import BaseControllerStateNames as CtrlStateNames model = get_basic_two_conv_test_model() config = get_basic_sparsity_config() algo_name = config['compression']['algorithm'] _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) # Test get state compression_ctrl.scheduler.current_step = 100 compression_ctrl.scheduler.current_epoch = 5 compression_ctrl.set_sparsity_level(0.5) compression_ctrl.freeze() assert compression_ctrl.get_state() == { algo_name: { CtrlStateNames.SCHEDULER: { 'current_step': 100, 'current_epoch': 5 }, CtrlStateNames.LOSS: { 'target': 0.5, 'disabled': True, 'p': 0.05 }, CtrlStateNames.COMPRESSION_STAGE: None } } # Test load state new_state = { CtrlStateNames.SCHEDULER: { 'current_step': 5000, 'current_epoch': 10 }, CtrlStateNames.LOSS: { 'target': 0.9, 'disabled': False, 'p': 0.5 }, CtrlStateNames.COMPRESSION_STAGE: None } compression_ctrl.load_state({algo_name: new_state}) assert tf.equal(compression_ctrl.loss.target, tf.constant(new_state[CtrlStateNames.LOSS]['target'])) assert compression_ctrl.loss.disabled == new_state[ CtrlStateNames.LOSS]['disabled'] assert compression_ctrl.loss.p == pytest.approx( new_state[CtrlStateNames.LOSS]['p']) new_real_state = compression_ctrl.get_state()[algo_name] assert new_real_state[CtrlStateNames.SCHEDULER] == new_state[ CtrlStateNames.SCHEDULER] assert new_real_state[CtrlStateNames.LOSS]['target'] == pytest.approx( new_state[CtrlStateNames.LOSS]['target']) assert new_real_state[CtrlStateNames.LOSS]['disabled'] == new_state[ CtrlStateNames.LOSS]['disabled'] assert new_real_state[CtrlStateNames.LOSS]['p'] == pytest.approx( new_state[CtrlStateNames.LOSS]['p'])
def test_can_set_sparse_layers_to_loss(): model = get_basic_conv_test_model() config = get_basic_sparsity_config() _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) loss = compression_ctrl.loss assert isinstance(loss, SparseLoss) # pylint: disable=protected-access for op, _ in loss._target_ops: assert isinstance(op, RBSparsifyingWeight)
def test_can_not_create_magnitude_algo__with_not_matched_steps_and_levels(): config = get_basic_magnitude_sparsity_config() config['compression']['params'] = { 'schedule': 'multistep', 'multistep_sparsity_levels': [0.1], 'multistep_steps': [1, 2] } with pytest.raises(ValueError): _, _ = create_compressed_model_and_algo_for_test( get_mock_model(), config)
def test_can_choose_scheduler(algo, schedule_type, scheduler_class): config = get_empty_config() config['compression'] = Dict({ 'algorithm': algo, 'params': { 'schedule': schedule_type } }) _, compression_ctrl = create_compressed_model_and_algo_for_test( get_mock_model(), config) assert isinstance(compression_ctrl.scheduler, scheduler_class)
def test_magnitude_algo_set_binary_mask_on_forward(): config = get_basic_magnitude_sparsity_config() config['compression']['params'] = {'weight_importance': 'abs'} sparse_model, compression_ctrl = create_compressed_model_and_algo_for_test( get_magnitude_test_model(), config) compression_ctrl.set_sparsity_level(0.3) TFTensorListComparator.check_equal(ref_mask_1, sparse_model.layers[1].weights[-1]) TFTensorListComparator.check_equal(ref_mask_2, sparse_model.layers[2].weights[-1])
def test_can_not_create_magnitude_algo__with_adaptive_scheduler(): config = get_empty_config() config['compression'] = { 'algorithm': 'magnitude_sparsity', 'params': { 'schedule': 'adaptive' } } with pytest.raises(ValueError): _, _ = create_compressed_model_and_algo_for_test( get_mock_model(), config)
def test_quantization_statistics(test_case): _, compression_ctrl = create_compressed_model_and_algo_for_test(test_case.model, test_case.config, force_no_init=True) actual = compression_ctrl.statistics().quantization expected = test_case.expected assert expected.wq_counter.__dict__ == actual.wq_counter.__dict__ assert expected.aq_counter.__dict__ == actual.aq_counter.__dict__ assert expected.num_wq_per_bitwidth == actual.num_wq_per_bitwidth assert expected.num_aq_per_bitwidth == actual.num_aq_per_bitwidth assert expected.ratio_of_enabled_quantizations == actual.ratio_of_enabled_quantizations
def test_magnitude_sparse_algo_sets_threshold(weight_importance, sparsity_level, threshold): model = get_magnitude_test_model() config = get_basic_magnitude_sparsity_config() config['compression']['params'] = { 'schedule': 'multistep', 'weight_importance': weight_importance } _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) if sparsity_level: compression_ctrl.set_sparsity_level(sparsity_level) assert compression_ctrl._threshold == pytest.approx(threshold, 0.01) # pylint: disable=protected-access
def test_early_exit_compression_training_loop(max_accuracy_degradation, maximal_total_epochs=100, uncompressed_model_accuracy=0.2, steps_per_epoch=20, img_size=10): set_random_seed(42) model = get_simple_conv_regression_model(img_size) dataset = get_const_target_mock_regression_dataset(img_size=img_size, num_samples=steps_per_epoch) config = get_basic_quantization_config(img_size) params = { "maximal_total_epochs": maximal_total_epochs, } params.update(max_accuracy_degradation) accuracy_aware_config = { "accuracy_aware_training": { "mode": "early_exit", "params": params } } config.update(accuracy_aware_config) config = register_default_init_args(config, dataset, batch_size=1) compress_model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) compression_callbacks = create_compression_callbacks(compression_ctrl, log_tensorboard=False) compress_model.add_loss(compression_ctrl.loss) def inverse_loss(y_true, y_pred): return 1 / (1 + (y_true - y_pred) ** 2) compress_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01), loss=tf.keras.losses.MeanSquaredError(), metrics=inverse_loss) result_dict_to_val_metric_fn = lambda results: results['inverse_loss'] compress_model.accuracy_aware_fit(dataset, compression_ctrl, nncf_config=config, callbacks=compression_callbacks, initial_epoch=0, steps_per_epoch=steps_per_epoch, uncompressed_model_accuracy=uncompressed_model_accuracy, result_dict_to_val_metric_fn=result_dict_to_val_metric_fn) original_model_accuracy = compress_model.original_model_accuracy compressed_model_accuracy = result_dict_to_val_metric_fn(compress_model.evaluate(dataset, return_dict=True)) if "maximal_absolute_accuracy_degradation" in max_accuracy_degradation: assert (original_model_accuracy - compressed_model_accuracy) <= \ max_accuracy_degradation["maximal_absolute_accuracy_degradation"] else: assert (original_model_accuracy - compressed_model_accuracy) / original_model_accuracy * 100 <= \ max_accuracy_degradation["maximal_relative_accuracy_degradation"]
def test_sparse_algo_does_not_replace_not_conv_layer(): x = tf.keras.layers.Input((10, 10, 3)) y = tf.keras.layers.Conv2D(1, 1)(x) y = tf.keras.layers.BatchNormalization()(y) model = tf.keras.Model(inputs=x, outputs=y) config = get_basic_sparsity_config() _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) assert isinstance(compression_ctrl, RBSparsityController) # pylint: disable=protected-access target_ops = compression_ctrl.loss._target_ops assert len(target_ops) == 1 assert isinstance(target_ops[0][0], RBSparsifyingWeight)
def get_basic_rb_sparse_model(model_name, local=False, config=CONF, freeze=False): model = TEST_MODELS[model_name]() if isinstance(config, Path): config = NNCFConfig.from_json(config) if local: config.update({"params": {"sparsity_level_setting_mode": 'local'}}) compress_model, algo = create_compressed_model_and_algo_for_test( model, config, force_no_init=True) if freeze: algo.freeze() return compress_model, algo, config
def test_quantization_configs__on_resume_with_compression_state( tmp_path, mocker): model = get_basic_conv_test_model() config = get_basic_quantization_config() init_spy = mocker.spy(QuantizationBuilder, 'initialize') gen_setup_spy = mocker.spy(QuantizationBuilder, '_get_quantizer_setup') dataset = get_dataset_for_test(shape=[4, 4, 1]) config = register_default_init_args(config, dataset, 10) _, compression_ctrl = create_compressed_model_and_algo_for_test( model, config) assert isinstance(compression_ctrl, QuantizationController) init_spy.assert_called() gen_setup_spy.assert_called() saved_quantizer_setup = gen_setup_spy.spy_return check_serialization(saved_quantizer_setup, _quantization_setup_cmp) compression_state_to_load = _save_and_load_compression_state( compression_ctrl, tmp_path) init_spy.reset_mock() gen_setup_spy.reset_mock() compression_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config, compression_state_to_load) assert isinstance(compression_ctrl, QuantizationController) init_spy.assert_not_called() gen_setup_spy.assert_not_called() check_default_qspecs(compression_model) builder = QuantizationBuilder(config) builder.load_state(compression_state_to_load['builder_state']) # pylint:disable=protected-access loaded_quantizer_setup = builder._quantizer_setup assert _quantization_setup_cmp(loaded_quantizer_setup, saved_quantizer_setup)
def test_eltwise_unified_scales_for_vpu(): nncf_config = get_basic_quantization_config() x_shape = [1, 1, 1, 1] y_shape = [1, 1, 1, 1] nncf_config["target_device"] = "VPU" model = get_eltwise_quantizer_linking_test_model([x_shape, y_shape]) compressed_model, _ = create_compressed_model_and_algo_for_test( model, nncf_config, force_no_init=True) non_weight_quantizers = len(collect_fake_quantize_layers(compressed_model)) assert non_weight_quantizers == 2 total_quantizations = get_total_quantizations(compressed_model) assert total_quantizations == 8
def test_quantize_outputs_removal(): config = get_basic_quantization_config() sample_size = [2, 32, 32, 3] model = get_quantize_outputs_removal_test_model(sample_size) model, _ = create_compressed_model_and_algo_for_test(model, config, force_no_init=True) ref_fake_quantize_layers = ['input/fake_quantize'] actual_fake_quantize_layers = [ layer.name for layer in model.layers if isinstance(layer, FakeQuantize) ] assert actual_fake_quantize_layers == ref_fake_quantize_layers assert len(actual_fake_quantize_layers) == len(ref_fake_quantize_layers)
def test_export_overflow_fix(sf_mode): model = get_basic_two_conv_test_model() config = get_basic_quantization_config() config['compression'].update({'overflow_fix': sf_mode}) enabled = sf_mode in ['enable', 'first_layer_only'] compression_model, compression_ctrl = create_compressed_model_and_algo_for_test( model, config, force_no_init=True) activation_quantizers_be, weight_quantizers_be = get_quantizers( compression_model) for idx, wq in enumerate(weight_quantizers_be): if sf_mode == 'first_layer_only' and idx > 0: enabled = False ref_weight_qspec = TFQuantizerSpec(mode=QuantizationMode.SYMMETRIC, num_bits=8, signedness_to_force=True, per_channel=True, narrow_range=not enabled, half_range=enabled) compare_qspecs(ref_weight_qspec, wq) ref_activation_qspec = TFQuantizerSpec(mode=QuantizationMode.SYMMETRIC, num_bits=8, signedness_to_force=None, per_channel=False, narrow_range=False, half_range=False) for wq in activation_quantizers_be: compare_qspecs(ref_activation_qspec, wq) enabled = sf_mode in ['enable', 'first_layer_only'] compression_ctrl.export_model('/tmp/test.pb') activation_quantizers_ae, weight_quantizers_ae = get_quantizers( compression_model) for idx, wq in enumerate(weight_quantizers_ae): if sf_mode == 'first_layer_only' and idx > 0: enabled = False ref_weight_qspec = TFQuantizerSpec(mode=QuantizationMode.SYMMETRIC, num_bits=8, signedness_to_force=True, per_channel=True, narrow_range=not enabled, half_range=False) compare_qspecs(ref_weight_qspec, wq) for wq in activation_quantizers_ae: compare_qspecs(ref_activation_qspec, wq)
def test_scheduler_can_do_epoch_step__with_rb_algo(): config = NNCFConfig() config['input_info'] = [{"sample_size": [1, 4, 4, 1]}] config['compression'] = { 'algorithm': 'rb_sparsity', 'sparsity_init': 0.2, "params": { 'schedule': 'polynomial', 'power': 1, 'sparsity_target_epoch': 2, 'sparsity_target': 0.6, 'sparsity_freeze_epoch': 3 } } _, compression_ctrl = create_compressed_model_and_algo_for_test( get_basic_conv_test_model(), config) scheduler = compression_ctrl.scheduler loss = compression_ctrl.loss assert not loss.disabled # pylint: disable=protected-access for op, op_weights in loss._target_ops: assert op.get_trainable_weight(op_weights) scheduler.epoch_step() assert pytest.approx(loss.target_sparsity_rate, abs=1e-3) == 0.2 assert pytest.approx(loss(), abs=1e-3) == 16 assert not loss.disabled scheduler.epoch_step() assert pytest.approx(loss.target_sparsity_rate, abs=1e-3) == 0.4 assert pytest.approx(loss(), abs=1e-3) == 64 assert not loss.disabled scheduler.epoch_step() assert pytest.approx(loss.target_sparsity_rate, abs=1e-3) == 0.6 assert pytest.approx(loss(), abs=1e-3) == 144 assert not loss.disabled scheduler.epoch_step() assert loss.disabled assert pytest.approx(loss.target_sparsity_rate, abs=1e-3) == 0.6 assert loss() == 0 for op, op_weights in loss._target_ops: assert not op.get_trainable_weight(op_weights)
def test_struct_auxiliary_nodes_nncf_graph(): model = get_basic_conv_test_model() config = get_basic_quantization_config() compressed_model, _ = create_compressed_model_and_algo_for_test( model, config, force_no_init=True) nncf_graph = convert_keras_model_to_nncf_graph(compressed_model) input_nodes = nncf_graph.get_input_nodes() output_nodes = nncf_graph.get_output_nodes() assert len(input_nodes) == 1 assert len(output_nodes) == 1 assert input_nodes[0].metatype in INPUT_NOOP_METATYPES assert output_nodes[0].metatype in OUTPUT_NOOP_METATYPES
def test_unified_scales_with_concat(target_device, model_creator, ref_aq_module_count, ref_quantizations): nncf_config = get_basic_quantization_config() x_shape = [1, 4, 1, 1] y_shape = [1, 4, 1, 1] nncf_config["target_device"] = target_device model = model_creator([x_shape, y_shape]) compressed_model, _ = create_compressed_model_and_algo_for_test( model, nncf_config, force_no_init=True) non_weight_quantizers = len(collect_fake_quantize_layers(compressed_model)) assert non_weight_quantizers == ref_aq_module_count total_quantizations = get_total_quantizations(compressed_model) assert total_quantizations == ref_quantizations