def __init__(
self,
params: Union[str, List[str]],
init_sparsity: float,
final_sparsity: float,
start_epoch: float,
end_epoch: float,
update_frequency: float,
inter_func: str = "cubic",
log_types: Union[str, List[str]] = ALL_TOKEN,
mask_type: Union[str, List[int]] = "unstructured",
leave_enabled: bool = True,
**kwargs,
):
kwargs["min_frequency"] = kwargs.get("min_frequency", -1.0)
super().__init__(
log_types=log_types,
start_epoch=start_epoch,
end_epoch=end_epoch,
update_frequency=update_frequency,
**kwargs,
)
self._params = validate_str_iterable(params, "{} for params".format(
self.__class__.__name__)) # type: List[str]
self._init_sparsity = init_sparsity
self._final_sparsity = final_sparsity
self._leave_enabled = convert_to_bool(leave_enabled)
self._inter_func = inter_func
self._mask_type = mask_type
self._leave_enabled = convert_to_bool(leave_enabled)
self.validate()
def __init__(self, log_types: Union[str, List[str]] = ALL_TOKEN, **kwargs):
super().__init__(**kwargs)
self._log_types = (validate_str_iterable(
log_types, "log_types for {}".format(self.__class__.__name__))
if log_types else None)
self._initialized = False
self._enabled = True
def __init__(
self,
params: Union[str, List[str]],
start_epoch: float = -1.0,
min_start: float = -1.0,
end_epoch: float = -1.0,
min_end: float = -1.0,
end_comparator: Union[int, None] = 0,
update_frequency: float = -1.0,
min_frequency: float = -1.0,
log_types: Union[str, List[str]] = None,
):
super().__init__(
log_types=log_types,
start_epoch=start_epoch,
min_start=min_start,
end_epoch=end_epoch,
min_end=min_end,
end_comparator=end_comparator,
update_frequency=update_frequency,
min_frequency=min_frequency,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__)
)
self._module_masks = None # type: Optional[ModuleParamPruningMask]
self._analyzers = None # type: Optional[List[ModulePruningAnalyzer]]
self._last_logged_epoch = None
def layers(self, value: Union[str, List[str]]):
"""
:param value: str or list of str for the layers to apply the AS modifier to
can also use the token __ALL__ to specify all layers
"""
self._layers = validate_str_iterable(
value, "{} for layers".format(self.__class__.__name__))
def params(self, value: Union[str, List[str]]):
"""
:param value: A list of full parameter names or regex patterns of names to apply
pruning to. Regex patterns must be specified with the prefix 're:'. __ALL__
will match to all parameters.
"""
self._params = validate_str_iterable(
value, "{} for params".format(self.__class__.__name__))
def params(self, value: Union[str, List[str]]):
"""
:param value: List of str for the variable names or regex patterns of names
to apply the pruning modifier to. Regex patterns must be specified with
the prefix 're:'.
"""
self._params = validate_str_iterable(
value, "{} for params".format(self.__class__.__name__))
def __init__(
self,
params: Union[str, List[str]],
start_epoch: float = -1.0,
min_start: float = -1.0,
end_epoch: float = -1.0,
min_end: float = -1.0,
end_comparator: Union[int, None] = 0,
update_frequency: float = -1.0,
min_frequency: float = -1.0,
log_types: Union[str, List[str]] = None,
global_sparsity: bool = False,
allow_reintroduction: bool = False,
parent_class_kwarg_names: Optional[List[str]] = None,
leave_enabled: bool = False,
**kwargs,
):
if parent_class_kwarg_names is not None:
# filter kwargs only for ones that should be propagated
# parent_class_kwarg_names = ["params", "init_sparsity", "iterpolation",...]
kwargs = {
k: v
for k, v in kwargs.items() if k in parent_class_kwarg_names
}
if "params" in parent_class_kwarg_names:
kwargs["params"] = params
super().__init__(
log_types=log_types,
start_epoch=start_epoch,
min_start=min_start,
end_epoch=end_epoch,
min_end=min_end,
end_comparator=end_comparator,
update_frequency=update_frequency,
min_frequency=min_frequency,
**kwargs,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__))
self._module_masks = None # type: Optional[ModuleParamPruningMask]
self._analyzers = None # type: Optional[List[ModulePruningAnalyzer]]
self._last_logged_epoch = None
self._scorer = None # type: PruningParamsScorer
self._mask_creator = None # type: PruningMaskCreator
self._global_sparsity = global_sparsity
self._allow_reintroduction = allow_reintroduction
self._leave_enabled = leave_enabled
self._applied_sparsity = None
self._pre_step_completed = False
self._sparsity_applied = False
def params(self, value: Union[str, List[str], None]):
"""
:params value: A list of full parameter names or regex patterns of names to
apply pruning to.
Regex patterns must be specified with the prefix 're:'. __ALL__
will match to all parameters. __ALL_PRUNABLE__ will match to all ConvNd
and Linear layers' weights
"""
self._params_orig = value
params, self._final_sparsity = self._get_params_and_final_sparsity(
self._params_orig, self._final_sparsity_orig)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__))
def __init__(
self,
params: Union[str, List[str]],
init_val: Any,
final_val: Any,
start_epoch: float,
end_epoch: float,
update_frequency: float,
inter_func: str = "linear",
params_strict: bool = True,
):
"""
:param params: A list of full parameter names or regex patterns of names
to apply pruning to.
Regex patterns must be specified with the prefix 're:'. __ALL__
will match to all parameters.
:param init_val: The initial value to set for the given param in the
given layers at start_epoch
:param final_val: The final value to set for the given param in the
given layers at end_epoch
:param start_epoch: The epoch to start the modifier at
:param end_epoch: The epoch to end the modifier at
:param update_frequency: The number of epochs or fraction of epochs to
update at between start and end
:param inter_func: the type of interpolation function to use:
[linear, cubic, inverse_cubic]; default is linear
:param params_strict: True if every regex pattern in params must match at least
one parameter name in the module
False if missing params are ok -- will not raise an err
"""
super().__init__(
start_epoch=start_epoch,
end_epoch=end_epoch,
update_frequency=update_frequency,
min_end=0.0,
end_comparator=1,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__)
)
self._init_val = init_val
self._final_val = final_val
self._init_val_tens = None
self._final_val_tens = None
self._inter_func = inter_func
self._params_strict = params_strict
self._module_params = [] # type: List[Parameter]
self.validate()
def __init__(
self,
params: Union[str, List[str]],
start_epoch: float = -1,
end_epoch: float = -1,
log_types: Union[str, List[str]] = ALL_TOKEN,
**kwargs,
):
kwargs["end_comparator"] = kwargs.get("end_comparator", None)
super().__init__(log_types=log_types,
start_epoch=start_epoch,
end_epoch=end_epoch,
**kwargs)
self._params = validate_str_iterable(params, "{} for params".format(
self.__class__.__name__)) # type: List[str]
def __init__(
self,
params: Union[str, List[str]],
val: Any,
params_strict: bool = True,
start_epoch: float = 0.0,
end_epoch: float = -1.0,
):
super().__init__(start_epoch=start_epoch,
end_epoch=end_epoch,
end_comparator=None)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__))
self._val = val
self._params_strict = params_strict
self._module_params = [] # type: List[Parameter]
def __init__(
self,
params: Union[str, List[str]],
start_epoch: float = -1.0,
end_epoch: float = -1.0,
log_types: Union[str, List[str]] = ALL_TOKEN,
):
super().__init__(
log_types=log_types,
start_epoch=start_epoch,
end_epoch=end_epoch,
end_comparator=-1,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__))
self._module_masks = None # type: ModuleParamPruningMask
self._analyzers = None
self._last_logged_epoch = None
def __init__(
self,
params: Union[str, List[str]],
trainable: bool,
params_strict: bool = True,
start_epoch: float = -1.0,
end_epoch: float = -1.0,
):
super().__init__(start_epoch=start_epoch,
end_epoch=end_epoch,
end_comparator=-1)
self._start_epoch = start_epoch
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__))
self._trainable = convert_to_bool(trainable)
self._params_strict = convert_to_bool(params_strict)
self._module_params = [] # type: List[Parameter]
self._original = []
def __init__(
self,
params: Union[str, List[str]],
start_epoch: float = -1,
end_epoch: float = -1,
log_types: Union[str, List[str]] = ALL_TOKEN,
):
super(ConstantPruningModifier, self).__init__(
log_types=log_types,
start_epoch=start_epoch,
end_epoch=end_epoch,
end_comparator=None,
)
self._params = validate_str_iterable(params, "{} for params".format(
self.__class__.__name__)) # type: List[str]
self._prune_op_vars = None
self._update_ready = None
self._sparsity = None
def __init__(
self,
params: Union[str, List[str]],
init_sparsity: float,
final_sparsity: float,
start_epoch: float,
end_epoch: float,
update_frequency: float,
inter_func: str = "cubic",
log_types: Union[str, List[str]] = ALL_TOKEN,
mask_type: Union[str, List[int], PruningMaskCreator] = "unstructured",
leave_enabled: bool = True,
):
super(GMPruningModifier, self).__init__(
log_types=log_types,
start_epoch=start_epoch,
min_start=-1.0,
end_epoch=end_epoch,
min_end=0.0,
end_comparator=1,
update_frequency=update_frequency,
min_frequency=-1.0,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__)
) # type: List[str]
self._layer_names = [get_layer_name_from_param(p) for p in self._params]
self._init_sparsity = init_sparsity
self._final_sparsity = final_sparsity
self._leave_enabled = convert_to_bool(leave_enabled)
self._inter_func = inter_func
self._mask_type = mask_type
self._mask_creator = mask_type
self._leave_enabled = convert_to_bool(leave_enabled)
if not isinstance(mask_type, PruningMaskCreator):
self._mask_creator = load_mask_creator(mask_type)
self._prune_op_vars = None
self._update_ready = None
self._sparsity = None
self._mask_initializer = None
self._masked_layers = []
self.validate()
def __init__(
self,
init_sparsity: float,
final_sparsity: float,
start_epoch: float,
end_epoch: float,
update_frequency: float,
params: Union[str, List[str]],
leave_enabled: bool = True,
inter_func: str = "cubic",
log_types: Union[str, List[str]] = ALL_TOKEN,
mask_type: Union[str, List[int], PruningMaskCreator] = "unstructured",
global_sparsity: bool = False,
):
super().__init__(
log_types=log_types,
start_epoch=start_epoch,
end_epoch=end_epoch,
update_frequency=update_frequency,
min_end=0.0,
end_comparator=1,
)
self._init_sparsity = init_sparsity
self._final_sparsity = final_sparsity
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__)
)
self._leave_enabled = convert_to_bool(leave_enabled)
self._inter_func = inter_func
self._mask_type = mask_type
self._mask_creator = mask_type
if not isinstance(mask_type, PruningMaskCreator):
self._mask_creator = load_mask_creator(mask_type)
self._global_sparsity = global_sparsity
self._module_masks = None # type: ModuleParamPruningMask
self._applied_sparsity = None
self._last_logged_sparsity = None
self._last_logged_epoch = None
self._analyzers = None
self._non_serializable_props = {}
self.validate()
def __init__(
self,
params: Union[str, List[str]],
start_epoch: float = -1,
end_epoch: float = -1,
log_types: Union[str, List[str]] = ALL_TOKEN,
):
super(ConstantPruningModifier, self).__init__(
log_types=log_types,
start_epoch=start_epoch,
end_epoch=end_epoch,
end_comparator=None,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__)
) # type: List[str]
self._layer_names = [get_layer_name_from_param(p) for p in self._params]
self._masked_layers = []
self._sparsity_scheduler = None
self._mask_creator = load_mask_creator("unstructured")
def __init__(
self,
layers: Union[str, List[str]],
alpha: Union[float, List[float]],
layer_normalized: bool = False,
reg_func: str = "l1",
reg_tens: str = "inp",
start_epoch: float = -1.0,
end_epoch: float = -1.0,
):
super().__init__(start_epoch=start_epoch,
end_epoch=end_epoch,
end_comparator=-1)
self._layers = validate_str_iterable(
layers, "{} for layers".format(self.__class__.__name__))
self._alpha = alpha
self._layer_normalized = convert_to_bool(layer_normalized)
self._reg_func = reg_func
self._reg_tens = reg_tens
self._trackers = [] # type: List[ASLayerTracker]
self.validate()
def __init__(
self,
params: Union[str, List[str]],
trainable: bool,
params_strict: bool = True,
start_epoch: float = -1.0,
end_epoch: float = -1.0,
**kwargs,
):
kwargs["end_comparator"] = kwargs.get("end_comparator", -1)
super(TrainableParamsModifier, self).__init__(
start_epoch=start_epoch,
end_epoch=end_epoch,
**kwargs,
)
self._params = validate_str_iterable(
params, "{} for params".format(self.__class__.__name__)
)
self._trainable = convert_to_bool(trainable)
self._params_strict = convert_to_bool(params_strict)
self._vars_to_trainable_orig = {}
self.validate()
def test_validate_str_iterable(test_list, output):
validated = validate_str_iterable(test_list, "")
assert validated == output
def test_validate_str_iterable_negative():
with pytest.raises(ValueError):
validate_str_iterable("will fail", "")