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
