def from_desc(cls, desc):
"""Create Model from desc."""
desc = deepcopy(desc)
module_groups = desc.get('modules', [])
module_type = desc.get('type', 'Sequential')
loss = desc.get('loss')
modules = OrderedDict()
for group_name in module_groups:
module_desc = deepcopy(desc.get(group_name))
if 'modules' in module_desc:
module = cls.from_desc(module_desc)
else:
cls_name = module_desc.get('type')
if not ClassFactory.is_exists(ClassType.NETWORK, cls_name):
raise ValueError("Network {} not exists.".format(cls_name))
module = ClassFactory.get_instance(ClassType.NETWORK,
module_desc)
modules[group_name] = module
if not modules and module_type:
model = ClassFactory.get_instance(ClassType.NETWORK, desc)
else:
if ClassFactory.is_exists(SearchSpaceType.CONNECTIONS,
module_type):
connections = ClassFactory.get_cls(SearchSpaceType.CONNECTIONS,
module_type)
else:
connections = ClassFactory.get_cls(SearchSpaceType.CONNECTIONS,
'Sequential')
model = list(modules.values())[0] if len(
modules) == 1 else connections(modules)
if loss:
model.add_loss(ClassFactory.get_cls(ClassType.LOSS, loss))
return model
def from_desc(cls, desc):
"""Create Model from desc."""
module_groups = desc.get('modules')
module_type = desc.get('type', 'Sequential')
loss = desc.get('loss')
modules = OrderedDict()
for group_name in module_groups:
module_desc = deepcopy(desc.get(group_name))
if 'modules' in module_desc:
module = cls.from_desc(module_desc)
else:
cls_name = module_desc.get('type')
if not ClassFactory.is_exists(ClassType.SEARCH_SPACE,
cls_name):
return None
module = ClassFactory.get_instance(ClassType.SEARCH_SPACE,
module_desc)
modules[group_name] = module
if ClassFactory.is_exists(SearchSpaceType.CONNECTIONS, module_type):
connections = ClassFactory.get_cls(SearchSpaceType.CONNECTIONS,
module_type)
else:
connections = ClassFactory.get_cls(SearchSpaceType.CONNECTIONS,
'Sequential')
model = list(
modules.values())[0] if len(modules) == 1 else connections(modules)
if loss:
model.add_loss(ClassFactory.get_cls(ClassType.LOSS, loss))
return model
def _init_transforms(self):
"""Initialize transforms method.
:return: a list of object
:rtype: list
"""
if "transforms" in self.args.keys():
transforms = list()
if not isinstance(self.args.transforms, list):
self.args.transforms = [self.args.transforms]
for i in range(len(self.args.transforms)):
transform_name = self.args.transforms[i].pop("type")
kwargs = self.args.transforms[i]
if ClassFactory.is_exists(ClassType.TRANSFORM, transform_name):
transforms.append(
ClassFactory.get_cls(ClassType.TRANSFORM,
transform_name)(**kwargs))
else:
transforms.append(
getattr(
importlib.import_module('torchvision.transforms'),
transform_name)(**kwargs))
return transforms
else:
return list()
def _register_models_from_current_module_scope(module):
for _name in dir(module):
if _name.startswith("_"):
continue
_cls = getattr(module, _name)
if isinstance(_cls, ModuleType):
continue
if ClassFactory.is_exists(ClassType.SEARCH_SPACE, 'torchvision_' + _cls.__name__):
continue
ClassFactory.register_cls(_cls, ClassType.SEARCH_SPACE, alias='torchvision_' + _cls.__name__)
def __init__(self, aux_weight, loss_base):
"""Init MixAuxiliaryLoss."""
self.aux_weight = aux_weight
loss_base_cp = loss_base.copy()
loss_base_name = loss_base_cp.pop('type')
if ClassFactory.is_exists('trainer.loss', loss_base_name):
loss_class = ClassFactory.get_cls('trainer.loss', loss_base_name)
else:
loss_class = getattr(importlib.import_module('tensorflow.losses'),
loss_base_name)
self.loss_fn = loss_class(**loss_base_cp['params'])
def _init_loss(self):
"""Init loss."""
if vega.is_torch_backend():
loss_config = self.criterion.copy()
loss_name = loss_config.pop('type')
loss_class = getattr(importlib.import_module('torch.nn'), loss_name)
return loss_class(**loss_config)
elif vega.is_tf_backend():
from inspect import isclass
loss_config = self.config.tf_criterion.copy()
loss_name = loss_config.pop('type')
if ClassFactory.is_exists('trainer.loss', loss_name):
loss_class = ClassFactory.get_cls('trainer.loss', loss_name)
if isclass(loss_class):
return loss_class(**loss_config)
else:
return partial(loss_class, **loss_config)
else:
loss_class = getattr(importlib.import_module('tensorflow.losses'), loss_name)
return partial(loss_class, **loss_config)
def _init_after_scheduler(self):
"""Init after_scheduler with after_scheduler_config."""
if isinstance(self.after_scheduler_config, dict):
scheduler_config = copy.deepcopy(self.after_scheduler_config)
print("after_scheduler_config: {}".format(scheduler_config))
scheduler_name = scheduler_config.pop('type')
if ClassFactory.is_exists(ClassType.LR_SCHEDULER, scheduler_name):
scheduler_class = ClassFactory.get_cls(ClassType.LR_SCHEDULER,
scheduler_name)
else:
scheduler_class = getattr(
importlib.import_module('torch.optim.lr_scheduler'),
scheduler_name)
if scheduler_class.__name__ == "CosineAnnealingLR":
if scheduler_config.get("T_max", -1) == -1:
if scheduler_config.get("by_epoch", True):
scheduler_config["T_max"] = self.epochs
else:
scheduler_config["T_max"] = self.epochs * self.steps
self.after_scheduler = scheduler_class(self.optimizer,
**scheduler_config)
