def _sparsify_weights(
self, target_model: NNCFNetwork) -> List[PTInsertionCommand]:
device = next(target_model.parameters()).device
sparsified_module_nodes = target_model.get_weighted_original_graph_nodes(
nncf_module_names=self.compressed_nncf_module_names)
insertion_commands = []
for module_node in sparsified_module_nodes:
node_name = module_node.node_name
if not self._should_consider_scope(node_name):
nncf_logger.info(
"Ignored adding Weight Sparsifier in scope: {}".format(
node_name))
continue
nncf_logger.info(
"Adding Weight Sparsifier in scope: {}".format(node_name))
compression_lr_multiplier = \
self.config.get_redefinable_global_param_value_for_algo('compression_lr_multiplier',
self.name)
operation = self.create_weight_sparsifying_operation(
module_node, compression_lr_multiplier)
hook = operation.to(device)
insertion_commands.append(
PTInsertionCommand(
PTTargetPoint(TargetType.OPERATION_WITH_WEIGHTS,
target_node_name=node_name), hook,
TransformationPriority.SPARSIFICATION_PRIORITY))
sparsified_module = target_model.get_containing_module(node_name)
self._sparsified_module_info.append(
SparseModuleInfo(node_name, sparsified_module, hook))
return insertion_commands
def __init__(self, target_model: NNCFNetwork,
sparsified_module_info: List[SparseModuleInfo]):
super().__init__(target_model)
self._loss = ZeroCompressionLoss(
next(target_model.parameters()).device)
self._scheduler = BaseCompressionScheduler()
self.sparsified_module_info = sparsified_module_info
def __init__(self, target_model: NNCFNetwork, config: NNCFConfig):
super().__init__(target_model)
self._loss = ZeroCompressionLoss(
next(target_model.parameters()).device)
scheduler_cls = QUANTIZATION_SCHEDULERS.get("staged")
algo_config = extract_algo_specific_config(config, "binarization")
self._scheduler = scheduler_cls(self, algo_config.get("params", {}))
from nncf.torch.utils import is_main_process
if is_main_process():
self._compute_and_display_flops_binarization_rate()
def _binarize_weights_and_module_inputs(
self, target_model: NNCFNetwork) -> List[PTInsertionCommand]:
device = next(target_model.parameters()).device
module_nodes = target_model.get_weighted_original_graph_nodes(
nncf_module_names=self.compressed_nncf_module_names)
insertion_commands = []
for module_node in module_nodes:
if not self._should_consider_scope(module_node.node_name):
nncf_logger.info(
"Ignored adding binarizers in scope: {}".format(
module_node.node_name))
continue
nncf_logger.info("Adding Weight binarizer in scope: {}".format(
module_node.node_name))
op_weights = self.__create_binarize_module().to(device)
nncf_logger.info("Adding Activation binarizer in scope: {}".format(
module_node.node_name))
compression_lr_multiplier = self.config.get_redefinable_global_param_value_for_algo(
'compression_lr_multiplier', self.name)
op_inputs = UpdateInputs(
ActivationBinarizationScaleThreshold(
module_node.layer_attributes.get_weight_shape(),
compression_lr_multiplier=compression_lr_multiplier)).to(
device)
ip_w = PTTargetPoint(TargetType.OPERATION_WITH_WEIGHTS,
target_node_name=module_node.node_name)
insertion_commands.append(
PTInsertionCommand(
ip_w, op_weights,
TransformationPriority.QUANTIZATION_PRIORITY))
ip_i = PTTargetPoint(TargetType.PRE_LAYER_OPERATION,
target_node_name=module_node.node_name,
input_port_id=0)
insertion_commands.append(
PTInsertionCommand(
ip_i, op_inputs,
TransformationPriority.QUANTIZATION_PRIORITY))
return insertion_commands
def __init__(self, target_model: NNCFNetwork, prunable_types: List[str],
pruned_module_groups_info: Clusterization[PrunedModuleInfo],
config: NNCFConfig):
super().__init__(target_model)
self._loss = ZeroCompressionLoss(
next(target_model.parameters()).device)
self._prunable_types = prunable_types
self.config = config
self.pruning_config = extract_algo_specific_config(
config, 'filter_pruning')
params = self.pruning_config.get('params', {})
self.pruned_module_groups_info = pruned_module_groups_info
self.prune_batch_norms = params.get('prune_batch_norms', True)
self.prune_first = params.get('prune_first_conv', False)
self.prune_downsample_convs = params.get('prune_downsample_convs',
False)
self.prune_flops = False
self.check_pruning_level(params)
self._hooks = []
def _prune_weights(self, target_model: NNCFNetwork):
target_model_graph = target_model.get_original_graph()
groups_of_nodes_to_prune = self.pruning_node_selector.create_pruning_groups(
target_model_graph)
device = next(target_model.parameters()).device
insertion_commands = []
self.pruned_module_groups_info = Clusterization[PrunedModuleInfo](
lambda x: x.node_name)
for i, group in enumerate(groups_of_nodes_to_prune.get_all_clusters()):
group_minfos = []
for node in group.elements:
node_name = node.node_name
module = target_model.get_containing_module(node_name)
module_scope = target_model_graph.get_scope_by_node_name(
node_name)
# Check that we need to prune weights in this op
assert self._is_pruned_module(module)
nncf_logger.info(
"Adding Weight Pruner in scope: {}".format(node_name))
pruning_block = self.create_weight_pruning_operation(
module, node_name)
# Hook for weights and bias
hook = UpdateWeightAndBias(pruning_block).to(device)
insertion_commands.append(
PTInsertionCommand(
PTTargetPoint(TargetType.PRE_LAYER_OPERATION,
target_node_name=node_name), hook,
TransformationPriority.PRUNING_PRIORITY))
group_minfos.append(
PrunedModuleInfo(
node_name=node_name,
module_scope=module_scope,
module=module,
operand=pruning_block,
node_id=node.node_id,
is_depthwise=is_prunable_depthwise_conv(node)))
cluster = Cluster[PrunedModuleInfo](
i, group_minfos, [n.node_id for n in group.elements])
self.pruned_module_groups_info.add_cluster(cluster)
# Propagate masks to find norm layers to prune
init_output_masks_in_graph(
target_model_graph, self.pruned_module_groups_info.get_all_nodes())
MaskPropagationAlgorithm(
target_model_graph, PT_PRUNING_OPERATOR_METATYPES,
PTNNCFPruningTensorProcessor).mask_propagation()
# Adding binary masks also for Batch/Group Norms to allow applying masks after propagation
types_to_apply_mask = ['group_norm']
if self.prune_batch_norms:
types_to_apply_mask.append('batch_norm')
all_norm_layers = target_model_graph.get_nodes_by_types(
types_to_apply_mask)
for node in all_norm_layers:
if node.data['output_mask'] is None:
# Skip elements that will not be pruned
continue
node_name = node.node_name
module = target_model.get_containing_module(node_name)
pruning_block = self.create_weight_pruning_operation(
module, node_name)
# Hook for weights and bias
hook = UpdateWeightAndBias(pruning_block).to(device)
insertion_commands.append(
PTInsertionCommand(
PTTargetPoint(TargetType.PRE_LAYER_OPERATION,
target_node_name=node_name), hook,
TransformationPriority.PRUNING_PRIORITY))
self._pruned_norms_operators.append((node, pruning_block, module))
return insertion_commands
