if param.requires_grad ] optimizer = self.optim_cls(learnable_params, **params) if distributed: optimizer = hvd.DistributedOptimizer( optimizer, named_parameters=model.named_parameters(), compression=hvd.Compression.none) elif vega.is_tf_backend(): lr_scheduler.step(epoch) params['learning_rate'] = lr_scheduler.get_lr()[0] optimizer = self.optim_cls(**params) if distributed: optimizer = hvd.DistributedOptimizer(optimizer) if vega.is_gpu_device() else \ NPUDistributedOptimizer(optimizer) return optimizer except Exception as ex: logging.error("Failed to call Optimizer name={}, params={}".format( self.optim_cls.__name__, params)) raise ex if vega.is_torch_backend(): import torch.optim as torch_opt ClassFactory.register_from_package(torch_opt, ClassType.OPTIM) elif vega.is_tf_backend(): import tensorflow.train as tf_train ClassFactory.register_from_package(tf_train, ClassType.OPTIM)
if self._cls.__name__ == "CosineAnnealingLR": if params.get("T_max", -1) == -1: if params.get("by_epoch", True): params["T_max"] = epochs else: params["T_max"] = epochs * steps if self._cls.__name__ == "WarmupScheduler": params["epochs"] = epochs params["steps"] = steps try: if params and optimizer: return self._cls(optimizer, **params) elif optimizer: return self._cls(optimizer) else: return self._cls(**params) except Exception as ex: logging.error( "Failed to call LrScheduler name={}, params={}".format( self._cls.__name__, params)) raise ex if vega.is_torch_backend(): import torch.optim.lr_scheduler as torch_lr ClassFactory.register_from_package(torch_lr, ClassType.LR_SCHEDULER)
loss_name = self.config.type self._cls = ClassFactory.get_cls(ClassType.LOSS, loss_name) def __call__(self): """Call loss cls.""" params = obj2config(self.config).get("params", {}) logging.debug("Call Loss. name={}, params={}".format(self._cls.__name__, params)) try: if params: cls_obj = self._cls(**params) if isclass(self._cls) else partial(self._cls, **params) else: cls_obj = self._cls() if isclass(self._cls) else partial(self._cls) if vega.is_torch_backend() and TrainerConfig().cuda: cls_obj = cls_obj.cuda() return cls_obj except Exception as ex: logging.error("Failed to call Loss name={}, params={}".format(self._cls.__name__, params)) raise ex if vega.is_torch_backend(): import torch.nn as torch_nn import timm.loss as timm_loss ClassFactory.register_from_package(torch_nn, ClassType.LOSS) ClassFactory.register_from_package(timm_loss, ClassType.LOSS) elif vega.is_tf_backend(): import tensorflow.losses as tf_loss ClassFactory.register_from_package(tf_loss, ClassType.LOSS)
return pfms def reset(self): """Reset states for new evaluation after each epoch.""" for val in self.mdict.values(): val.reset() @property def results(self): """Return metrics results.""" res = {} for name, metric in self.mdict.items(): res.update(metric.result) return res @property def objectives(self): """Return objectives results.""" return {name: self.mdict.get(name).objective for name in self.mdict} def __getattr__(self, key): """Get a metric by key name. :param key: metric name :type key: str """ return self.mdict[key] ClassFactory.register_from_package(metrics, ClassType.METRIC)