def get_config_runner(expdir: Path, config: Dict):
"""
Imports and creates ConfigRunner instance.
Args:
expdir: experiment directory path
config: dictionary with experiment Config
Returns:
ConfigRunner instance
"""
config_copy = copy.deepcopy(config)
if expdir is not None:
dir_module = import_module(expdir) # noqa: F841
# runner_fn = getattr(dir_module, "Runner", None)
runner_params = config_copy.get("runner", {})
runner_from_config = runner_params.pop("_target_", None)
assert runner_from_config is not None, "You should specify the ConfigRunner."
runner_fn = REGISTRY.get(runner_from_config)
# assert any(
# x is None for x in (runner_fn, runner_from_config)
# ), "Runner is set both in code and config."
# if runner_fn is None and runner_from_config is not None:
# runner_fn = REGISTRY.get(runner_from_config)
runner = runner_fn(config=config_copy, **runner_params)
return runner
def __init__(
self,
metric_key: str,
optimizer_key: str = None,
accumulation_steps: int = 1,
grad_clip_fn: Union[str, Callable] = None,
grad_clip_params: Dict = None,
):
"""Init."""
super().__init__()
self.metric_key = metric_key
self.optimizer_key = optimizer_key
self.optimizer = None
self.criterion = None
if isinstance(grad_clip_fn, str):
self.grad_clip_fn = REGISTRY.get(grad_clip_fn)
else:
self.grad_clip_fn = grad_clip_fn
if grad_clip_params is not None:
self.grad_clip_fn = partial(self.grad_clip_fn, **grad_clip_params)
self.accumulation_steps: int = accumulation_steps
self._accumulation_counter: int = 0
if self.optimizer_key is not None:
self._prefix = f"{self.optimizer_key}"
self._prefix_lr = f"lr/{self._prefix}"
self._prefix_momentum = f"momentum/{self._prefix}"
self._prefix_gradient = f"gradient/{self._prefix}"
else:
self._prefix_lr = "lr"
self._prefix_momentum = "momentum"
self._prefix_gradient = "gradient"
def __init__(
self,
arch: str = "resnet18",
pretrained: bool = True,
frozen: bool = True,
pooling: str = None,
pooling_kwargs: dict = None,
cut_layers: int = 2,
state_dict: Union[dict, str, Path] = None,
):
"""
Args:
arch: Name for resnet. Have to be one of
resnet18, resnet34, resnet50, resnet101, resnet152
pretrained: If True, returns a model pre-trained on ImageNet
frozen: If frozen, sets requires_grad to False
pooling: pooling
pooling_kwargs: params for pooling
state_dict (Union[dict, str, Path]): Path to ``torch.Model``
or a dict containing parameters and persistent buffers.
"""
super().__init__()
resnet = torchvision.models.__dict__[arch](pretrained=pretrained)
if state_dict is not None:
if isinstance(state_dict, (Path, str)):
state_dict = torch.load(str(state_dict))
resnet.load_state_dict(state_dict)
modules = list(resnet.children())[:-cut_layers] # delete last layers
if frozen:
for module in modules:
utils.set_requires_grad(module, requires_grad=False)
if pooling is not None:
pooling_kwargs = pooling_kwargs or {}
pooling_layer_fn = REGISTRY.get(pooling)
pooling_layer = (pooling_layer_fn(
in_features=resnet.fc.in_features, **pooling_kwargs) if "attn"
in pooling.lower() else pooling_layer_fn(
**pooling_kwargs))
modules += [pooling_layer]
if hasattr(pooling_layer, "out_features"):
out_features = pooling_layer.out_features(
in_features=resnet.fc.in_features)
else:
out_features = None
else:
out_features = resnet.fc.in_features
modules += [Flatten()]
self.out_features = out_features
self.encoder = nn.Sequential(*modules)
def __init__(
self,
metric_key: str,
grad_clip_fn: Union[str, Callable] = None,
grad_clip_params: Dict = None,
log_gradient: bool = False,
):
"""Init."""
super().__init__()
self.metric_key = metric_key
if isinstance(grad_clip_fn, str):
self.grad_clip_fn = REGISTRY.get(grad_clip_fn)
else:
self.grad_clip_fn = grad_clip_fn
if grad_clip_params is not None:
self.grad_clip_fn = partial(self.grad_clip_fn, **grad_clip_params)
self._prefix_gradient = f"gradient/{metric_key}"
self._log_gradient = log_gradient
def __init__(
self,
metric_key: str,
model_key: str = None,
optimizer_key: str = None,
accumulation_steps: int = 1,
grad_clip_fn: Union[str, Callable] = None,
grad_clip_params: Dict = None,
):
"""Init."""
super().__init__(order=CallbackOrder.optimizer, node=CallbackNode.all)
self.metric_key = metric_key
self.model_key = model_key
self.optimizer_key = optimizer_key
self.model = None
self.optimizer = None
self.criterion = None
if isinstance(grad_clip_fn, str):
self.grad_clip_fn = REGISTRY.get(grad_clip_fn)
else:
self.grad_clip_fn = grad_clip_fn
self.accumulation_steps: int = accumulation_steps
self._accumulation_counter: int = 0
if self.model_key is not None or self.optimizer_key is not None:
if self.model_key is not None and self.optimizer_key is not None:
self._prefix = f"{self.model_key}_{self.optimizer_key}"
elif self.model_key is not None:
self._prefix = f"{self.model_key}"
elif self.optimizer_key is not None:
self._prefix = f"{self.optimizer_key}"
self._prefix_lr = f"lr/{self._prefix}"
self._prefix_momentum = f"momentum/{self._prefix}"
else:
self._prefix_lr = "lr"
self._prefix_momentum = "momentum"
if grad_clip_params is not None:
self.grad_clip_fn = partial(self.grad_clip_fn, **grad_clip_params)
def __init__(
self,
transform: Union[Callable, str],
scope: str,
input_key: Union[List[str], str] = None,
output_key: Union[List[str], str] = None,
transform_kwargs: Dict[str, Any] = None,
):
"""
Preprocess your batch with specified function.
Args:
transform (Callable, str): Function to apply.
If string will get function from registry.
scope (str): ``"on_batch_end"`` (post-processing model output) or
``"on_batch_start"`` (pre-processing model input).
input_key (Union[List[str], str], optional): Keys in batch dict to apply function.
Defaults to ``None``.
output_key (Union[List[str], str], optional): Keys for output.
If None then will apply function inplace to ``keys_to_apply``.
Defaults to ``None``.
transform_kwargs (Dict[str, Any]): Kwargs for transform.
Raises:
TypeError: When keys is not str or a list.
When ``scope`` is not in ``["on_batch_end", "on_batch_start"]``.
"""
super().__init__(order=CallbackOrder.Internal)
if isinstance(transform, str):
transform = REGISTRY.get(transform)
if transform_kwargs is not None:
transform = partial(transform, **transform_kwargs)
if input_key is not None:
if not isinstance(input_key, (list, str)):
raise TypeError("input key should be str or a list of str.")
elif isinstance(input_key, str):
input_key = [input_key]
self._handle_batch = self._handle_value
else:
self._handle_batch = self._handle_key_value
output_key = output_key or input_key
if output_key is not None:
if input_key is None:
raise TypeError("You should define input_key in "
"case if output_key is not None")
if not isinstance(output_key, (list, str)):
raise TypeError("output key should be str or a list of str.")
if isinstance(output_key, str):
output_key = [output_key]
transform = _tuple_wrapper(transform)
if isinstance(scope,
str) and scope in ["on_batch_end", "on_batch_start"]:
self.scope = scope
else:
raise TypeError(
'Expected scope to be on of the ["on_batch_end", "on_batch_start"]'
)
self.input_key = input_key
self.output_key = output_key
self.transform = transform
def get_collate_fn(self):
data_params = self._config["data_params"]
collate_fn = REGISTRY.get(data_params["collate_fn"])
return collate_fn