def __init__(self, input_channels, n_classes): super(SCNN, self).__init__() self.input_channels = input_channels self.n_classes = n_classes self.features_size = 256 * 15 * 15 # 512*13*13 self.loss_func = nn.CrossEntropyLoss() self.train_accuracy = torchmetrics.Accuracy() self.val_accuracy = torchmetrics.Accuracy() # self.auroc = torchmetrics.AUROC(num_classes=n_classes) self.conv1 = nn.Sequential(nn.Conv2d(1, 96, (6, 6), stride=(2, 2)), nn.BatchNorm2d(96), nn.LeakyReLU(), nn.MaxPool2d((2, 2))) self.conv2 = nn.Sequential(nn.Conv2d(96, 256, (3, 3), stride=(2, 2)), nn.BatchNorm2d(256), nn.LeakyReLU(), nn.MaxPool2d((2, 2))) self.conv3 = nn.Sequential(nn.Conv2d(256, 512, (3, 3), stride=(1, 1)), nn.LeakyReLU()) self.fc = nn.Sequential(nn.Linear(self.features_size, 1024), nn.LeakyReLU(), nn.Dropout(p=0.5), nn.Linear(1024, self.n_classes)) self.apply(self.weight_init)
def __init__(self, pretrained_bert=None, target_classes={}, steps_train=None, weights=None): super().__init__() self.steps_train = steps_train self.target_classes = target_classes # key: name of the target layer, value: number of classes for the target self.weights = weights self.bert = transformers.BertModel.from_pretrained( pretrained_bert, output_hidden_states=True, return_dict=True) self.tokenizer = transformers.BertTokenizerFast.from_pretrained( pretrained_bert) # layers for different label_sets (upos, feats ...) self.prediction_layers = torch.nn.ModuleDict() self.accuracies = torch.nn.ModuleDict() self.val_accuracies = torch.nn.ModuleDict() for target_name, num_classes in self.target_classes.items(): logging.info( f"Creating prediction layer for '{target_name}' with {num_classes} classes" ) self.prediction_layers[target_name] = TaggerOutput( self.bert.config.hidden_size, num_classes) self.accuracies[target_name] = torchmetrics.Accuracy() self.val_accuracies[target_name] = torchmetrics.Accuracy()
def __init__(self, input_channels, n_classes): super(SSNet, self).__init__() self.input_channels = input_channels self.n_classes = n_classes self.features_size = 8000 self.loss_func = nn.CrossEntropyLoss() self.train_accuracy = torchmetrics.Accuracy() self.val_accuracy = torchmetrics.Accuracy() self.conv1 = nn.Sequential(nn.Conv3d(1, 8, (7, 3, 3), stride=1), nn.LeakyReLU(), nn.MaxPool3d(2)) self.conv2 = nn.Sequential(nn.Conv3d(8, 16, (5, 3, 3), stride=1), nn.LeakyReLU(), nn.MaxPool3d(2)) self.conv3 = nn.Sequential(nn.Conv3d(16, 32, (3, 3, 3), stride=1), nn.LeakyReLU(), nn.AdaptiveMaxPool3d((10, 5, 5))) # self.conv4 = nn.Sequential( # nn.Conv2d(32, 64, (3, 3), stride=1), # nn.LeakyReLU()) self.fc1 = nn.Sequential(nn.Linear(self.features_size, 256), nn.LeakyReLU(), nn.Dropout(0.5)) self.fc2 = nn.Sequential(nn.Linear(256, 128), nn.LeakyReLU(), nn.Dropout(0.5), nn.Linear(128, self.n_classes))
def _set_metrics(self): num_classes = self.num_classes # Train self.train_acc = torchmetrics.Accuracy() self.train_precision = torchmetrics.Precision() self.train_recall = torchmetrics.Recall() self.train_f1 = torchmetrics.F1( num_classes=num_classes) if num_classes else None self.train_auc = torchmetrics.AUROC( num_classes=num_classes) if num_classes else None # Validation self.validation_acc = torchmetrics.Accuracy() self.validation_precision = torchmetrics.Precision() self.validation_recall = torchmetrics.Recall() self.validation_f1 = torchmetrics.F1( num_classes=num_classes) if num_classes else None self.validation_auc = torchmetrics.AUROC( num_classes=num_classes) if num_classes else None # Test self.test_acc = torchmetrics.Accuracy() self.test_precision = torchmetrics.Precision() self.test_recall = torchmetrics.Recall() self.test_f1 = torchmetrics.F1( num_classes=num_classes) if num_classes else None self.test_auc = torchmetrics.AUROC( num_classes=num_classes) if num_classes else None
def __init__( self, encoder: nn.Module, clf: nn.Module, lr: float, weight_decay: float, fairness: FairnessType, mixup_lambda: Optional[float] = None, alpha: float = 1.0, lr_initial_restart: int = 10, lr_restart_mult: int = 2, lr_sched_interval: TrainingMode = TrainingMode.epoch, lr_sched_freq: int = 1, ) -> None: super().__init__( lr=lr, weight_decay=weight_decay, lr_initial_restart=lr_initial_restart, lr_restart_mult=lr_restart_mult, lr_sched_interval=lr_sched_interval, lr_sched_freq=lr_sched_freq, ) self.encoder = encoder self.clf = clf self.net = nn.Sequential(self.encoder, self.clf) self.fairness = fairness self.mixup_lambda = mixup_lambda self.alpha = alpha self._loss_fn = CrossEntropyLoss(reduction=ReductionType.mean) self.test_acc = torchmetrics.Accuracy() self.train_acc = torchmetrics.Accuracy() self.val_acc = torchmetrics.Accuracy()
def __init__(self, config_backbone, config_training, num_classes, learning_rate=None): super().__init__() self.config_training = config_training if learning_rate: self.learning_rate = learning_rate else: self.learning_rate = self.config_training.lr in_features = self.get_in_features(config_backbone.name) self.feature_extractor = timm.create_model(config_backbone.name, pretrained=True, num_classes=0) self.classifier = nn.Sequential( nn.Dropout(0.3), nn.Linear(in_features, num_classes), ) self.train_accuracy = torchmetrics.Accuracy() self.val_accuracy = torchmetrics.Accuracy() self.test_accuracy = torchmetrics.Accuracy()
def __init__(self, batch_size, lr_scheduler_milestones, lr_gamma, nclass, nfeatures, length, lr=1e-2, L2_reg=1e-3, top_acc=1, loss=torch.nn.CrossEntropyLoss()): super().__init__() self.batch_size = batch_size self.nclass = nclass self.nfeatures = nfeatures self.length = length self.loss = loss self.lr = lr self.lr_scheduler_milestones = lr_scheduler_milestones self.lr_gamma = lr_gamma self.L2_reg = L2_reg # Log hyperparams (all arguments are logged by default) self.save_hyperparameters( 'length', 'nfeatures', 'L2_reg', 'lr', 'lr_gamma', 'lr_scheduler_milestones', 'batch_size', 'nclass' ) # Metrics to log if not top_acc < nclass: raise ValueError('`top_acc` must be strictly smaller than `nclass`.') self.train_acc = torchmetrics.Accuracy(top_k=top_acc) self.val_acc = torchmetrics.Accuracy(top_k=top_acc) self.train_f1 = torchmetrics.F1(nclass, average='macro') self.val_f1 = torchmetrics.F1(nclass, average='macro') self.features = nn.Sequential( nn.Conv2d(in_channels=1, out_channels=20, kernel_size=(3,5), stride=1, padding=(1,2)), nn.BatchNorm2d(20), nn.ReLU(True), nn.Conv2d(in_channels=20, out_channels=20, kernel_size=(3,5), stride=1, padding=(1,2)), nn.BatchNorm2d(20), nn.ReLU(True), nn.Conv2d(in_channels=20, out_channels=20, kernel_size=(3,5), stride=1, padding=(1,2)), nn.BatchNorm2d(20), nn.ReLU(True), nn.Conv2d(in_channels=20, out_channels=20, kernel_size=(3,5), stride=1, padding=(1,2)), nn.BatchNorm2d(20), nn.ReLU(True), nn.Conv2d(in_channels=20, out_channels=20, kernel_size=(3,3), stride=1, padding=(1,1)), nn.BatchNorm2d(20), nn.ReLU(True), nn.Conv2d(in_channels=20, out_channels=nfeatures, kernel_size=(3,3), stride=1, padding=(1,1)), nn.BatchNorm2d(nfeatures), nn.ReLU(True) ) self.pool = nn.AvgPool2d(kernel_size=(2, self.length)) self.classifier = nn.Sequential( nn.Linear(1*nfeatures, nclass), # 1 because global pooling reduce length of features to 1 #nn.Softmax(1) # Already included in nn.CrossEntropy )
def __init__(self, num_classes, lr, lr_milestones): super().__init__() self.save_hyperparameters() self.model = torchvision.models.resnet18(pretrained=False, num_classes=num_classes) self.train_acc = torchmetrics.Accuracy() self.val_acc = torchmetrics.Accuracy()
def __init__(self, cfg, *args, **kwargs): super().__init__() self.cfg = cfg self.save_hyperparameters(cfg) self.model = srn.resnet18(False, False, num_classes=cfg.model.n_classes) self.criterion = nn.CrossEntropyLoss() self.train_accuracy = torchmetrics.Accuracy() self.val_accuracy = torchmetrics.Accuracy()
def __init__(self, model, lr: float = 1e-4, augmentations: Optional[nn.Module] = None): super().__init__() self.model = model self.arch = self.model.arch self.num_classes = self.model.num_classes self.train_accuracy = torchmetrics.Accuracy() self.train_f1_score = torchmetrics.F1(self.num_classes, average='weighted') self.val_accuracy = torchmetrics.Accuracy() self.val_f1_score = torchmetrics.F1(self.num_classes, average='weighted') self.learn_rate = lr self.aug = augmentations
def __init__(self, backbone, final_layer): super().__init__() # lightning modules are best structured as systems self.backbone = backbone self.linear = final_layer self.save_hyperparameters() # torchmetrics stuff self.train_acc = torchmetrics.Accuracy() self.valid_acc = torchmetrics.Accuracy()
def __init__(self, backbone, num_classes): super().__init__() self.backbone = backbone output = self.backbone(torch.Tensor(1, 3, 64, 64)) linear_inplanes = output.shape[1] self.adaptive_pool = nn.AdaptiveAvgPool2d(1) self.flatten = nn.Flatten() self.dropout = nn.Dropout(0.2) self.linear = nn.Linear(linear_inplanes, num_classes) self.loss = nn.CrossEntropyLoss() self.train_accuracy = torchmetrics.Accuracy() self.val_accuracy = torchmetrics.Accuracy()
def __init__(self, model: nn.Module, num_classes: int = 2, lr: float = 1e-4, **kwargs): super().__init__() self.model = model self.lr = lr self.loss = CrossEntropyLoss() self.train_acc = torchmetrics.Accuracy() self.val_acc = torchmetrics.Accuracy() self.save_hyperparameters()
def valid_epoch(model, valid_loader, criterion, epoch): model.eval() total_loss = AverageMeter() manual_top1 = AverageMeter() manual_top5 = AverageMeter() torch_top1 = torchmetrics.Accuracy() torch_top5 = torchmetrics.Accuracy(top_k=5) torch_f1 = torchmetrics.F1(num_classes=312) with torch.no_grad(): for batch in tqdm(valid_loader): images = batch["image"].to(device) elas = batch["ela"].to(device) target_labels = batch["label"].to(device) out_logits, _ = model(images, elas) loss = criterion(out_logits, target_labels) #---------------------Batch Loss Update------------------------- total_loss.update(loss.item(), valid_loader.batch_size) # Metric with torch.no_grad(): out_logits = out_logits.cpu().detach() target_labels = target_labels.cpu().detach() topk = topk_accuracy(out_logits, target_labels, topk=(1,5)) manual_top1.update(topk[0].item(), valid_loader.batch_size) manual_top5.update(topk[1].item(), valid_loader.batch_size) torch_top1.update(torch.softmax(out_logits, dim=-1), target_labels) torch_top5.update(torch.softmax(out_logits, dim=-1), target_labels) torch_f1.update(torch.softmax(out_logits, dim=-1), target_labels) valid_metrics = { "valid_loss": total_loss.avg, "valid_acc1_manual": manual_top1.avg, "valid_acc5_manual": manual_top5.avg, "valid_acc1_torch": torch_top1.compute().item(), "valid_acc_5_torch": torch_top5.compute().item(), "valid_f1": torch_f1.compute().item(), "epoch": epoch } wandb.log(valid_metrics) return valid_metrics
def __init__( self, model, loss_fn=nn.CrossEntropyLoss(), train_acc=torchmetrics.Accuracy(), valid_acc=torchmetrics.Accuracy(), lr: float = 0.001, ): super(ClassificationEngine, self).__init__() self.model = model self.scaler = None self.loss_function = loss_fn self.train_acc = train_acc self.valid_acc = valid_acc self.lr = lr
def train(model, dataloader, optimizer, loss_func, device, start_epoch, scheduler, e): print(f'EPOCH[{e+1}/{start_epoch+opt.epoch}] Training....') model.train() iter_loss = [] corrects = 0 data_size = 0 train_acc1 = torchmetrics.Accuracy(num_classes=10).to(device) train_acc5 = torchmetrics.Accuracy(num_classes=10, top_k=5).to(device) # train_precision = torchmetrics.Precision(num_classes=10, multiclass=True).to(device) # train_recall = torchmetrics.Recall(num_classes=10, multiclass=True).to(device) for i, (images, labels) in enumerate(dataloader): start = time.time() images, labels = images.to(device), labels.to(device) data_size += images.shape[0] optimizer.zero_grad() outputs = model(images) loss = loss_func(outputs, labels) loss.backward() optimizer.step() train_acc1(outputs, labels) train_acc5(outputs, labels) # train_precision(outputs, labels) # train_recall(outputs, labels) iter_loss.append(loss.item()) corrects += sum(outputs.argmax(axis=1) == labels).item() end = time.time() if ((i + 1) % 40 == 0) or ((i + 1) == len(dataloader)): times = (end - start) * 40 if not ( i + 1) == len(dataloader) else (end - start) * i print(f'Iter[{i+1}/{len(dataloader)}]'\ f'--- Loss: {sum(iter_loss)/data_size:0.4f}'\ # f' --- Accuracy: {corrects/data_size:0.2f}'\ f' --- Accuracy1: {train_acc1.compute():0.2f}'\ f' --- Accuracy5: {train_acc5.compute():0.2f}'\ # f' --- Precision: {train_precision.compute():0.2f}'\ # f' --- Recall: {train_recall.compute():0.2f}'\ f'--- Time:{strftime("%H:%M:%S", gmtime(times))}'\ f'--- LR: {scheduler.get_lr()[0]:0.4f}') return [sum(iter_loss) / data_size, train_acc1.compute().cpu()]
def test(model, dataloader, loss_func, device, start_epoch, e): print(f'EPOCH[{e+1}/{start_epoch+opt.epoch}] Teseting....') model.eval() iter_loss = [] corrects = 0 test_metrics = torchmetrics.Accuracy(num_classes=opt.num_classes).to(device) with torch.no_grad(): data_size = 0 for i, (images, labels) in enumerate(dataloader): images, labels = images.to(device), labels.to(device) data_size += images.shape[0] outputs = model(images) loss = loss_func(outputs, labels) test_metrics(outputs, labels) iter_loss.append(loss.item()) corrects += sum(outputs.argmax(axis=1) == labels).item() print(f'Iter[{i+1}/{len(dataloader)}]' \ f'--- Loss: {sum(iter_loss)/data_size:0.4}'\ # f'--- Accuracy: {corrects/data_size:0.2}'\ f'--- Accuracy: {test_metrics.compute():0.4f}') return [sum(iter_loss)/data_size, test_metrics.compute().cpu()]
def __init__(self): super().__init__() self.model = models.resnet18(pretrained=True) for param in self.model.parameters(): param.requires_grad = False self.model.fc = nn.Linear(512, 17) self.acc = torchmetrics.Accuracy()
def __init__(self, model: t.nn.Module, cfg: DictConfig) -> None: """Create a LitModuleWrapper. Args: model: Your model to be quantized. It should be a general torch.nn.Module. cfg: The top-level user configuration object. """ super().__init__() self.model = model self.cfg = cfg self.criterion = t.nn.CrossEntropyLoss() self.train_acc = tm.Accuracy() self.val_acc = tm.Accuracy(dist_sync_on_step=True) self.val_acc5 = tm.Accuracy(dist_sync_on_step=True, top_k=5)
def __init__(self, hidden_size=64, learning_rate=2e-4): super().__init__() # Set our init args as class attributes self.hidden_size = hidden_size self.learning_rate = learning_rate # Initialize PyTorch Lightning accuracy function self.accuracy = torchmetrics.Accuracy() # Hardcode some dataset specific attributes self.num_classes = 10 self.dims = (1, 28, 28) channels, width, height = self.dims self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # Define PyTorch model self.model = nn.Sequential( nn.Flatten(), nn.Linear(channels * width * height, hidden_size), nn.ReLU(), nn.Dropout(0.1), nn.Linear(hidden_size, hidden_size), nn.ReLU(), nn.Dropout(0.1), nn.Linear(hidden_size, self.num_classes) )
def __init__(self, num_classes=5): super().__init__() self.save_hyperparameters() self.hparams.l2_norm = l2_norm self.hparams.lr = learning_rate self.ce = nn.CrossEntropyLoss() # Define model # self.model = models.resnext50_32x4d(pretrained=True) self.model = models.resnet18(pretrained=True) self.model.fc = torch.nn.Linear(self.model.fc.in_features, num_classes) # Define extra metrics self.train_accuracy = torchmetrics.Accuracy() self.validation_accuracy = torchmetrics.Accuracy()
def __init__(self, model_name_or_path: str, num_labels: int, learning_rate: float, adam_epsilon: float, weight_decay: float, max_len: int, warmup_steps: int, gpus: int, max_epochs: int, accumulate_grad_batches: int): super().__init__() self.model_name_or_path = model_name_or_path self.num_labels = num_labels self.save_hyperparameters('learning_rate', 'adam_epsilon', 'weight_decay', 'max_len', 'gpus', 'accumulate_grad_batches', 'max_epochs', 'warmup_steps') self.config = transformers.AutoConfig.from_pretrained( model_name_or_path, num_labels=self.num_labels) self.model = transformers.AutoModelForSequenceClassification.from_pretrained( model_name_or_path, config=self.config) # self.model = nn.Sequential( # OrderedDict( # [ # ('base',transformers.AutoModel.from_pretrained(model_name_or_path)), # ('classifier',nn.Linear(in_features=768,out_features=self.num_labels)), # ('softmax',nn.Softmax()) # ] # ) # ) metrics = torchmetrics.MetricCollection([ torchmetrics.Accuracy(), torchmetrics.F1(num_classes=3, average='macro') ]) self.train_metrics = metrics.clone() self.val_metrics = metrics.clone()
def choose_metric(self): metric_map = { 'acc': torchmetrics.Accuracy(), 'psnr': torchmetrics.image.PSNR(), 'psnr255': torchmetrics.image.PSNR(data_range=255), } return metric_map[self.params['metric'].lower()]
def __init__( self, lr: float, weight_decay: float, lr_gamma: float, disc_steps: int, fairness: str, recon_weight: float, clf_weight: float, adv_weight: float, enc: nn.Module, dec: nn.Module, adv: nn.Module, clf: nn.Module, ): super().__init__() self.enc = enc self.dec = dec self.adv = adv self.clf = clf self.laftr_params = itertools.chain([ *self.enc.parameters(), *self.dec.parameters(), *self.clf.parameters() ]) self.adv_params = self.adv.parameters() self._clf_loss = nn.BCEWithLogitsLoss(reduction="mean") self._recon_loss = nn.L1Loss(reduction="mean") self._adv_clf_loss = nn.L1Loss(reduction="mean") self.disc_steps = disc_steps self.fairness = FairnessType[fairness] self.lr = lr self.lr_gamma = lr_gamma self.weight_decay = weight_decay self.clf_weight = clf_weight self.adv_weight = adv_weight self.recon_weight = recon_weight self.test_acc = torchmetrics.Accuracy() self.train_acc = torchmetrics.Accuracy() self.val_acc = torchmetrics.Accuracy() self._target_name: str = "y"
def __init__( self, *, lr: float, weight_decay: float, disc_steps: int, fairness: FairnessType, recon_weight: float, clf_weight: float, adv_weight: float, enc: nn.Module, dec: nn.Module, adv: nn.Module, clf: nn.Module, lr_initial_restart: int = 10, lr_restart_mult: int = 2, lr_sched_interval: TrainingMode = TrainingMode.epoch, lr_sched_freq: int = 1, ) -> None: super().__init__( lr=lr, weight_decay=weight_decay, lr_initial_restart=lr_initial_restart, lr_restart_mult=lr_restart_mult, lr_sched_interval=lr_sched_interval, lr_sched_freq=lr_sched_freq, ) self.enc = enc self.dec = dec self.adv = adv self.clf = clf self._clf_loss = CrossEntropyLoss(reduction=ReductionType.mean) self._recon_loss = nn.L1Loss(reduction="mean") self._adv_clf_loss = nn.L1Loss(reduction="none") self.disc_steps = disc_steps self.fairness = fairness self.clf_weight = clf_weight self.adv_weight = adv_weight self.recon_weight = recon_weight self.test_acc = torchmetrics.Accuracy() self.train_acc = torchmetrics.Accuracy() self.val_acc = torchmetrics.Accuracy()
def __init__(self, cfg, *args, **kwargs): super().__init__() self.cfg = cfg self.save_hyperparameters(cfg) self.model = models.resnet18(pretrained=cfg.model.pre_trained) for param in self.model.parameters(): param.requires_grad = False self.model.fc = nn.Linear(self.model.fc.in_features, cfg.model.n_classes) self.criterion = nn.CrossEntropyLoss() self.train_accuracy = torchmetrics.Accuracy() self.val_accuracy = torchmetrics.Accuracy()
def get_metric( metric_name: str, num_classes: Optional[int] = None, pos_label: Optional[int] = None, ): """ Obtain a torchmerics.Metric from its name. Define a customized metric function in case that torchmetrics doesn't support some metric. Parameters ---------- metric_name Name of metric. num_classes Number of classes. pos_label The label (0 or 1) of binary classification's positive class, which is used in some metrics, e.g., AUROC. Returns ------- torchmetrics.Metric A torchmetrics.Metric object. custom_metric_func A customized metric function. """ metric_name = metric_name.lower() if metric_name in [ACC, ACCURACY]: return torchmetrics.Accuracy(), None elif metric_name in [RMSE, ROOT_MEAN_SQUARED_ERROR]: return torchmetrics.MeanSquaredError(squared=False), None elif metric_name == R2: return torchmetrics.R2Score(), None elif metric_name == QUADRATIC_KAPPA: return ( torchmetrics.CohenKappa(num_classes=num_classes, weights="quadratic"), None, ) elif metric_name == ROC_AUC: return torchmetrics.AUROC(pos_label=pos_label), None elif metric_name == AVERAGE_PRECISION: return torchmetrics.AveragePrecision(pos_label=pos_label), None elif metric_name in [LOG_LOSS, CROSS_ENTROPY]: return torchmetrics.MeanMetric(), functools.partial(F.cross_entropy, reduction="none") elif metric_name == COSINE_EMBEDDING_LOSS: return torchmetrics.MeanMetric(), functools.partial( F.cosine_embedding_loss, reduction="none") elif metric_name == PEARSONR: return torchmetrics.PearsonCorrCoef(), None elif metric_name == SPEARMANR: return torchmetrics.SpearmanCorrCoef(), None elif metric_name == F1: return CustomF1Score(num_classes=num_classes, pos_label=pos_label), None else: raise ValueError(f"Unknown metric {metric_name}")
def __init__(self, pretrained=True, num_classes=2, lr=0.005, **kwargs): super().__init__() self.pretrained: bool = pretrained self.num_classes: int = num_classes self.learning_rate: float = lr self.model: nn.Module = self._load_mobile_net(pretrained=pretrained, num_classes=num_classes) self.trn_acc: torchmetrics.Accuracy = torchmetrics.Accuracy() self.trn_loss: torchmetrics.AverageMeter = torchmetrics.AverageMeter() self.val_acc: torchmetrics.Accuracy = torchmetrics.Accuracy() self.val_loss: torchmetrics.AverageMeter = torchmetrics.AverageMeter() self.criterion = nn.CrossEntropyLoss() self.save_hyperparameters() self.save_hyperparameters(kwargs)
def __init__(self, learning_rate: float = 1e-1, learning_rate_min: float = 1e-4, lr_max_epochs: int = -1, freeze: bool = True, *args: Any, **kwargs: Any) -> None: """ Constructor for QuackDenseNet. Parameters ---------- learning_rate: float Hyperparameter passed to pt.optim.lr_scheduler.CosineAnnealingLR learning_rate_min: float Hyperparameter passed to pt.optim.lr_scheduler.CosineAnnealingLR lr_max_epochs: int Hyperparameter passed to pt.optim.lr_scheduler.CosineAnnealingLR freeze: bool Should the image analyzing layers of the pre-trained Densenet be frozen? args: Any Passed to the parent constructor. kwargs: Any Passed to the parent constructor. """ super().__init__(*args, **kwargs) # Load the pre-trained densenet pre_trained = models.densenet121(pretrained=True) if freeze: # Freeze the existing gradients. pre_trained.requires_grad_(False) # We want to replace the classifier. New instances of models have # requires_grad = True by default. classifier_features_in = pre_trained.classifier.in_features pre_trained.classifier = nn.Linear(classifier_features_in, 1) self.__densenet = pre_trained self.__to_probability = nn.Sigmoid() self.__learning_rate_init = learning_rate self.__learning_rate_min = learning_rate_min self.__lr_max_epochs = lr_max_epochs self.__train_acc = tm.Accuracy() self.__train_f1 = tm.F1Score(num_classes=2) self.__val_acc = tm.Accuracy() self.__val_f1 = tm.F1Score(num_classes=2) self.__test_acc = tm.Accuracy() self.__test_f1 = tm.F1Score(num_classes=2) self.__loss_module = nn.BCEWithLogitsLoss() # For tuning. self.batch_size = 2
def __init__(self, hparams): """Defines overall computations""" super().__init__() self.hparams = hparams self.save_hyperparameters() # A dictionary informs of the model of the input size, number of # target classes, and learning rate. self.fc1 = nn.Linear(self.hparams["input_size"], 420) self.fc2 = nn.Linear(420, 420) self.fc3 = nn.Linear(420, 420) self.fc4 = nn.Linear(420, self.hparams["targets"]) self.dropout = nn.Dropout(0.4) # Instantiate accuracy metrics for each phase self.train_acc = torchmetrics.Accuracy() self.valid_acc = torchmetrics.Accuracy() self.test_acc = torchmetrics.Accuracy()