def __init__(self,
line_sep="\n",
field_sep=r"(?:[\,:\-]\s*)|(?:\s+)",
ints=True,
skip_last=True,
trim_blank=True):
store_attr()
def __init__(
self,
input_shape: ShapeSpec,
num_classes: int,
pool_type: str = "avg",
drop_rate: float = 0.0,
use_conv: bool = False,
lr: float = 2e-03,
wd: float = 0,
filter_wd: bool = False,
):
super(FullyConnectedHead, self).__init__()
self.drop_rate = drop_rate
in_planes = input_shape.channels
# fmt: off
self.global_pool, num_pooled_features = _create_pool(in_planes,
num_classes,
pool_type,
use_conv=use_conv)
# fmt: on
self.fc = _create_fc(num_pooled_features,
num_classes,
use_conv=use_conv)
self.flatten_after_fc = use_conv and pool_type
store_attr("lr, wd, filter_wd")
def __call__(self,
inputs: torch.Tensor,
targets: torch.Tensor,
model: Module = None,
*args,
**kwargs):
"calls function"
store_attr()
if self.num_iters is not None:
if self._check_has_ended():
self._is_active = False
else:
if self._curr_iter < self.num_iters:
outputs = self.call(inputs, targets=targets, model=model)
inputs, self.lam_a, self.lam_b, self.target_a, self.target_b = outputs
else:
self._is_active = False
if self._check_has_ended():
if not self._done_logging:
self._done_logging = True
self._is_active = False
else:
if self._check_has_ended():
if not self._done_logging:
self._done_logging = True
self._is_active = False
else:
outputs = self.call(inputs, targets=targets, model=model)
inputs, self.lam_a, self.lam_b, self.target_a, self.target_b = outputs
return inputs
def __init__(self, day, year=2020, reader=read, parser={}):
self.f_reader = (lambda x: x)
self.fn_part1 = {}
self.fn_part2 = {}
self.f_reader = reader
self.f_parser = parser
self.f_transformer = (lambda x: x)
store_attr(but='reader,parser')
def __init__(
self,
eps: float = 0.1,
reduction: str = "mean",
weight: Optional[Tensor] = None,
):
super(LabelSmoothingCrossEntropy, self).__init__()
store_attr("eps, reduction, weight")
def __init__(
self,
alpha: float = -1,
gamma: float = 2,
reduction: str = "mean",
):
super(BinarySigmoidFocalLoss, self).__init__()
store_attr("alpha, gamma, reduction")
def __init__(self,
alpha: float = 0.5,
conf_prob: float = 1.0,
num_iters: int = None,
**kwargs):
store_attr()
if self.alpha > 0.0:
self.distrib = np.random.beta(self.alpha, self.alpha)
else:
self.distrib = 1
def __init__(self,
df,
fn_col,
label_col=None,
transform=None,
train: bool = True,
backend="torchvision"):
store_attr("df, fn_col, label_col, transform, train, backend")
self.df = df.copy()
self._setup_loader()
def __init__(
self,
alpha: float = 1,
gamma: float = 2,
reduction: str = "mean",
eps: float = 1e-8,
):
super(FocalLoss, self).__init__()
store_attr("alpha, gamma, reduction, eps")
def __init__(
self,
input_shape: ShapeSpec,
num_classes: int,
act: str = "ReLU",
lin_ftrs: Optional[List] = None,
ps: Union[List, int] = 0.5,
concat_pool: bool = True,
first_bn: bool = True,
bn_final: bool = False,
lr: float = 2e-03,
wd: float = 0,
filter_wd: bool = False,
):
super(FastaiHead, self).__init__()
in_planes = input_shape.channels
pool = "catavgmax" if concat_pool else "avg"
pool, nf = _create_pool(in_planes, num_classes, pool, use_conv=False)
# fmt: off
lin_ftrs = [nf, 512, num_classes
] if lin_ftrs is None else [nf] + lin_ftrs + [num_classes]
# fmt: on
bns = [first_bn] + [True] * len(lin_ftrs[1:])
ps = L(ps)
if len(ps) == 1:
ps = [ps[0] / 2] * (len(lin_ftrs) - 2) + ps
act = ifnone(act, "ReLU")
# fmt: off
actns = [ACTIVATION_REGISTRY.get(act)
(inplace=True)] * (len(lin_ftrs) - 2) + [None]
if bn_final:
actns[-1] = ACTIVATION_REGISTRY.get(act)(inplace=True)
# fmt: on
self.layers = [pool]
for ni, no, bn, p, actn in zip(lin_ftrs[:-1], lin_ftrs[1:], bns, ps,
actns):
self.layers += nn.Sequential(nn.BatchNorm1d(ni), nn.Dropout(p),
nn.Linear(ni, no, bias=not bns), actn)
if bn_final:
self.layers.append(nn.BatchNorm1d(lin_ftrs[-1], momentum=0.01))
self.layers = nn.Sequential(*[l for l in self.layers if l is not None])
store_attr("lr, wd, filter_wd")
def __init__(
self,
model_name: str,
input_shape: ShapeSpec,
act: str = None,
lr: float = 1e-03,
wd: float = 1e-02,
lr_div: float = 100,
freeze_at: int = 0,
freeze_bn: bool = False,
**kwargs,
):
super(ResNetBackbone, self).__init__()
store_attr("freeze_at, wd, lr, lr_div, input_shape, freeze_bn")
if act is not None:
act = ACTIVATION_REGISTRY.get(act)
model = timm.create_model(
model_name,
act_layer=act,
global_pool="",
num_classes=0,
in_chans=input_shape.channels,
**kwargs,
)
assert isinstance(model, ResNet), "ResNetBackbone supports only ResNet models"
# save some of the input information from timm models
self.num_features = model.num_features
self.timm_model_cfg = model.default_cfg
# break up the model
# the stem for the resnet model consists of a convolutional block, norm, act, pool
stem = nn.Sequential(model.conv1, model.bn1, model.act1, model.maxpool)
# stages will consisit of the remaining 4 layers
stages = [model.layer1, model.layer2, model.layer3, model.layer4]
stages = nn.Sequential(*stages)
# creat the module
self.resnet = nn.Sequential(stem, stages)
self.prepare_model(self.resnet)
def __init__(
self,
model_name: str,
input_shape: ShapeSpec,
act: str = None,
lr: float = 1e-03,
wd: float = 0,
freeze_bn: bool = False,
freeze_at: int = False,
filter_wd: bool = False,
**kwargs,
):
super(TimmBackboneBase, self).__init__()
store_attr("lr, wd, filter_wd, input_shape")
if act is not None:
act = ACTIVATION_REGISTRY.get(act)
model = timm.create_model(
model_name,
act_layer=act,
global_pool="",
num_classes=0,
in_chans=input_shape.channels,
**kwargs,
)
# save some of information from timm models
self.num_features = model.num_features
self.timm_model_cfg = model.default_cfg
self.model = prepare_backbone(model)
if not freeze_at:
self.unfreeze()
else:
self.freeze_to(freeze_at)
if freeze_bn:
set_bn_eval(self.model)
def __init__(self, pypinm, deps=None, import_nm=None, path=None):
store_attr('pypinm,deps')
self.import_nm = ifnone(import_nm, pypinm)
try:
self.ver = str(latest_pypi(pypinm))
except:
raise ValueError(f'package name: {pypinm} not found on pypi.')
self.info = pypi_json(f'{pypinm}/{self.ver}')['info']
self.path = _mkdir(ifnone(path, self.pypinm))
self.meta = {
'package': {
'name': self.pypinm,
'version': self.ver
},
'build': {
'number': 0,
'binary_relocation': False,
'detect_binary_files_with_prefix': False
},
'requirements': {
'host': ['pip', 'python'],
'run': ['python'] + list(L(self.deps))
},
'test': {
'imports': [self.import_nm],
'requires': ['pip']
},
'about': {
'home': self.info['home_page'],
'summary': self.info['summary'],
'license': self.info['license']
},
'extra': {
'recipe-maintainers': ['jph00']
}
}
def __init__(self, *args, **kwargs):
store_attr()
for k, v in kwargs.items():
vars(self)[k] = v
def __init__(self, policy, optimizer, hyperparams):
store_attr()
def __init__(self, f):
store_attr()
def __init__(self, default = _NoMatchError,):
store_attr()
self.cases = L()
self.preprocesses = L()
def __init__(self, alpha: float, epochs: list, total_epochs: int, *args,
**kwargs):
super(MixupWH, self).__init__()
store_attr()
self.device = None
def __init__(self, new_length):
super(_Flatten, self).__init__()
store_attr()
def __init__(self, message):
store_attr()
self.logs = L()
def __init__(
self,
model_name: str,
input_shape: ShapeSpec,
lr: float = 1e-03,
wd: float = 1e-05,
pretrained: bool = True,
freeze_to: Optional[int] = None,
finetune: Optional[bool] = None,
act: Optional[str] = None,
reset_classifier: bool = True,
filter_wd: bool = True,
**kwargs,
):
"""
Arguments:
1. `input_shape` (ShapeSpec): input image shape. For ViT `height=width` and check the above link for avilable model shapes.
2. `model_name` (str): name of the ViT model, check the above link for avilable models.
3. `pretrained` (bool): load weights pretrained on imagenet.
4. `act` (str): name of the activation layer. Must be registerd in `ACTIVATION_REGISTRY`
5. `num_classes` (int): num output classes.
6. `drop_rate` (float): dropout rate.
7. `attn_drop_rate` (float): attention dropout rate.
8. `drop_path_rate` (float): stochastic depth rate.
9. `reset_classifier` (bool): resets the weights of the classifier.
10. `freeze_to` (int): Freeze the param meter groups of the model upto n.
11. `finetune` (bool): Freeze all the layers and keep only the `classifier` trainable.
"""
super(VisionTransformer, self).__init__()
# create model from timm
assert input_shape.height == input_shape.width
in_chans = input_shape.channels
if act is not None:
act = ACTIVATION_REGISTRY.get(act)
self.model = timm.create_model(
model_name, pretrained, in_chans=in_chans, act=act, **kwargs
)
if reset_classifier:
num_cls = kwargs.pop("num_classes")
self.model.reset_classifier(num_cls)
if freeze_to is not None:
self.freeze_to(freeze_to)
if finetune:
if freeze_to is not None and isinstance(freeze_to, int):
msg = "You have sprecified freeze_to along with finetune"
_logger.warning(msg)
_logger.info("Freezing all the model parameters except for the classifier")
self.freeze()
classifier = ["head", "head_dist"]
for name, module in self.model.named_children():
if name in classifier:
for p in module.parameters():
p.requires_grad_(True)
store_attr("wd, lr, filter_wd, input_shape")
