def main(): args = parse_args() num_classes = 10 if args.dataset == 'CIFAR10' else 100 have_cuda = torch.cuda.is_available() def cast(x): return x.cuda() if have_cuda else x checkpoint = torch.load(args.checkpoint) weights_unpacked = {} for k, w in checkpoint.items(): if w.dtype == torch.uint8: # weights are packed with np.packbits function scale = np.sqrt(2 / (w.shape[1] * w.shape[2] * w.shape[3] * 8)) signed = np.unpackbits(w, axis=1).astype(np.int) * 2 - 1 weights_unpacked[k[7:]] = torch.from_numpy(signed).float() * scale else: weights_unpacked[k[7:]] = w model = WRN_McDonnell(args.depth, args.width, num_classes) model.load_state_dict(weights_unpacked) model = cast(model) model.eval() class_acc = ClassErrorMeter(accuracy=True) for inputs, targets in tqdm(DataLoader(create_dataset(args, train=False), 256)): with torch.no_grad(): class_acc.add(model(cast(inputs)).cpu(), targets) print(class_acc.value())
def validate(val_loader, model, criterion, opt): data_time = TimeMeter(unit=1) losses = AverageValueMeter() errors = ClassErrorMeter(topk=[1]) # switch to evaluate mode if isinstance(model, list): for m in model: m.eval() else: model.eval() with torch.no_grad(): end = time.time() for i, (win_past, inp_pred, labels, min_values) in enumerate(zip(*val_loaders)): win_past = win_past.cuda(opt['g'], non_blocking=True) inp_pred = inp_pred.cuda(opt['g'], non_blocking=True) labels = labels.cuda(opt['g'], non_blocking=True) min_values = min_values.cuda(opt['g'], non_blocking=True) # compute output yh_cl, yh_reg = basik_tasks_model(win_past, win_pred) loss = criterion[0](yh_cl, labels) ctx.losses['cl'].add(loss.item()) loss += opt['lambda'] * criterion[1](output, min_values) # measure accuracy and record loss errors.add(yh_cl.data, targets[0].data) losses['reg'].add(loss.item() - ctx.losses['cl'].value()) losses['tot'].add(loss.item()) errors.add(yh_cl, labels) losses.add(loss.item()) loss = losses['tot'].value()[0] top1 = errors.value()[0] # if i % opt['print_freq'] == 0: # print('[{0}/{1}]\t' # 'Time {time:.3f}\t' # 'Loss {loss:.4f}\t' # 'Err@1 {top1:.3f}\t' # 'Err@5 {top5:.3f}'.format( # i, # len(val_loader), # time=data_time.value(), loss=loss, # top1=top1, top5=top5)) print('Loss {loss:.4f}' ' * Err@1 {top1:.3f}\t' .format(loss=loss, top1=top1)) stats = {'loss': loss, 'top1': top1} ctx.metrics = stats return stats
def train(train_loader, model, criterion, optimizer, epoch, opt): data_time = TimeMeter(unit=1) ctx.losses['cl'] = AverageValueMeter() ctx.losses['reg'] = AverageValueMeter() ctx.losses['tot'] = AverageValueMeter() ctx.errors = ClassErrorMeter(topk=[1]) # switch to train mode if isinstance(model, list): for m in model: m.train() else: model.train() # end = time.time() for i, (win_past, inp_pred, labels, min_values) in enumerate(zip(*train_loaders)): # tmp var (for convenience) ctx.i = i win_past = win_past.cuda(opt['g'], non_blocking=True) inp_pred = inp_pred.cuda(opt['g'], non_blocking=True) labels = labels.cuda(opt['g'], non_blocking=True) min_values = min_values.cuda(opt['g'], non_blocking=True) inputs = (win_past, inp_pred) targets = (labels, min_values) stats = runner(inputs, targets, model, criterion, optimizer) loss = stats['loss'] top1 = stats['top1'] if i % opt['print_freq'] == 0: print('Epoch: [{0}][{1}/{2}]\t' 'Time {time:.3f}\t' 'Loss {loss:.4f}\t' 'Err@1 {top1:.3f}'.format( epoch, i, len(train_loader), time=data_time.value(), loss=loss, top1=top1)) return stats
def main(args): # region -----------------------------------------记录训练日志----------------------------------------- if 0 == len(args.resume): logger = Logger('./logs/' + args.model + '.log') else: logger = Logger('./logs/' + args.model + '.log', True) logger.append(vars(args)) # if args.display: # writer = SummaryWriter() # else: # writer = None writer = SummaryWriter() # endregion # region ----------------------------------------数据预处理配置---------------------------------------- data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } # endregion # region -------------------------------------------数据加载------------------------------------------- train_datasets = datasets.CIFAR10(root="data", train=True, download=True, transform=transforms.ToTensor()) val_datasets = datasets.CIFAR10(root="data", train=False, download=True, transform=transforms.ToTensor()) # train_datasets = datasets.ImageFolder(os.path.join(args.data_root, 't256'), data_transforms['train']) # val_datasets = datasets.ImageFolder(os.path.join(args.data_root, 'v256'), data_transforms['val']) train_dataloaders = torch.utils.data.DataLoader(train_datasets, batch_size=args.batch_size, shuffle=True, num_workers=4) val_dataloaders = torch.utils.data.DataLoader(val_datasets, batch_size=1024, shuffle=False, num_workers=4) # endregion # region --------------------------------------网络无关配置设置---------------------------------------- # 记录日志 if args.debug: x, y = next(iter(train_dataloaders)) logger.append([x, y]) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu is_use_cuda = torch.cuda.is_available() cudnn.benchmark = True # 设置基础网络 if 'resnet50' == args.model.split('_')[0]: my_model = models.resnet50(pretrained=False) elif 'resnet50-cbam' == args.model.split('_')[0]: my_model = resnet_cbam.resnet50_cbam(pretrained=False) elif 'resnet101' == args.model.split('_')[0]: my_model = models.resnet101(pretrained=False) else: raise ModuleNotFoundError # endregion # region --------------------------------------网络训练配置设置---------------------------------------- # 损失函数设定 loss_fn = [nn.CrossEntropyLoss()] # 优化器设置 optimizer = optim.SGD(my_model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4) # 学习率优化函数设置 lr_schedule = lr_scheduler.MultiStepLR(optimizer, milestones=[30, 60], gamma=0.1) # 累计误差TOP5 metric = [ClassErrorMeter([1, 5], True)] # 迭代次数 epoch = int(args.epoch) # 传入训练器 my_trainer = Trainer(my_model, args.model, loss_fn, optimizer, lr_schedule, 500, is_use_cuda, train_dataloaders, val_dataloaders, metric, 0, epoch, args.debug, logger, writer) # 训练 my_trainer.fit() logger.append('训练完毕')
def main(args): if 0 == len(args.resume): logger = Logger('./logs/' + args.model + '.log') else: logger = Logger('./logs/' + args.model + '.log', True) logger.append(vars(args)) if args.display: writer = SummaryWriter() else: writer = None gpus = args.gpu.split(',') data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } train_datasets = datasets.ImageFolder(os.path.join(args.data_root, 't256'), data_transforms['train']) val_datasets = datasets.ImageFolder(os.path.join(args.data_root, 'v256'), data_transforms['val']) train_dataloaders = torch.utils.data.DataLoader( train_datasets, batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=8) val_dataloaders = torch.utils.data.DataLoader(val_datasets, batch_size=1024, shuffle=False, num_workers=8) if args.debug: x, y = next(iter(train_dataloaders)) logger.append([x, y]) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu is_use_cuda = torch.cuda.is_available() cudnn.benchmark = True if 'resnet50' == args.model.split('_')[0]: my_model = models.resnet50(pretrained=False) elif 'resnet101' == args.model.split('_')[0]: my_model = models.resnet101(pretrained=False) elif 'mnasnet' == args.model.split('_')[0]: my_model = mnasnet.MnasNet() elif 'shufflenetv2' == args.model.split('_')[0]: my_model = shufflenetv2.ShuffleNetV2() else: raise ModuleNotFoundError #my_model.apply(fc_init) if is_use_cuda and 1 == len(gpus): my_model = my_model.cuda() elif is_use_cuda and 1 < len(gpus): my_model = nn.DataParallel(my_model.cuda()) loss_fn = [nn.CrossEntropyLoss()] optimizer = optim.SGD(my_model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4) lr_schedule = lr_scheduler.MultiStepLR(optimizer, milestones=[30, 60], gamma=0.1) # metric = [ClassErrorMeter([1, 5], True)] start_epoch = 0 num_epochs = 90 my_trainer = Trainer(my_model, args.model, loss_fn, optimizer, lr_schedule, 500, is_use_cuda, train_dataloaders, \ val_dataloaders, metric, start_epoch, num_epochs, args.debug, logger, writer) my_trainer.fit() logger.append('Optimize Done!')
def main(): # Load iris dataset with total of 150 samples x, y = load_iris(return_X_y=True) y = np.reshape(y, (150, 1)) # concatenate both x and y to shuffle and split data = np.concatenate((x, y), axis=1) dataset = IrisDataset(data) dataset_train, dataset_test = random_split(dataset, [int(len(dataset) * 0.8), int(len(dataset) * 0.2)]) # https://pytorch.org/docs/1.1.0/_modules/torch/utils/data/dataloader.html train_loader = DataLoader( dataset_train, BATCH_SIZE, shuffle=True, drop_last=True, ) test_loader = DataLoader( dataset_test, BATCH_SIZE, shuffle=True, drop_last=True, ) model = nn.Sequential(nn.Linear(INPUT_DIM, 48, bias=True), nn.ReLU(), nn.Linear(48, 24, bias=True), nn.Tanh(), nn.Linear(24, OUTPUT_DIM, bias=True), nn.Softmax(dim=1)) # Training properties l_rate = 1e-3 criterion = LossCrossEntropy() optimizer = torch.optim.Adam(model.parameters(), lr=l_rate) meters = { "train_loss": AverageValueMeter(), "test_loss": AverageValueMeter(), "train_acc": ClassErrorMeter(accuracy=True), "test_acc": ClassErrorMeter(accuracy=True), "train_f1": MetricAccuracyClassification(), "test_f1": MetricAccuracyClassification() } for epoch in range(EPOCHS): # print("\nepoch = ", epoch) # reset meters to default settings before each epoch for k in meters.keys(): meters[k].reset() for loader in [train_loader, test_loader]: if loader == train_loader: # print("\n\ttraining:") meter_prefix = "train" model = model.train() torch.set_grad_enabled(True) else: # print("\n\ttesting:") meter_prefix = "test" # automatically turns off some modules (like DropOut), which are not used during testing model = model.eval() torch.set_grad_enabled(False) for x, y, idx in loader: # print("\t\tbatch = ", idx) # clear grads optimizer.zero_grad() # forward y_prim = model.forward(x.float()) loss = criterion.forward(y_prim, y) # update parameters when training if loader == train_loader: loss.backward() optimizer.step() optimizer.zero_grad() # update metrics meters[f'{meter_prefix}_loss'].add(loss.detach().numpy()) # TODO: acc curve? # # convert from one hot encoding to flower classes # tg = np.argmax(y, axis=1).numpy() # (y_prim.detach().numpy(), target=tg) # TODO: f1 tb.add_scalars( main_tag='learning_curve', tag_scalar_dict={ f'{meter_prefix}_loss': meters[f'{meter_prefix}_loss'].value()[0] }, global_step=epoch ) tb.close()
def __init__(self, sub_class_list: Sequence, class_partition: Sequence[Union[int, Sequence[int]]], positive_class: Sequence[int], val_phases: Dict[bool, str] = None, is_visualize: bool = True, patient_info: SheetCollection = None, patient_pred: CascadedPred = None, port: int = AbstractModelStats.DEFAULT_PORT, env: str = AbstractModelStats.DEFAULT_ENV, previous_preds=None): super().__init__( sub_class_list=sub_class_list, class_partition=class_partition, val_phases=val_phases, is_visualize=is_visualize, port=port, env=env, previous_preds=previous_preds, ) self.patient_info = patient_info self.patient_pred = patient_pred self._positive_class = positive_class self._best_loss = np.inf self._best_stats = dict() # class_list=sub_class_list, # partition=self.class_partition) self._membership: Dict[str, Union[torch.Tensor, np.ndarray]] = dict() self.meter_container.add_meter(DefaultStats.PATCH_ACC, ClassErrorMeter(accuracy=True)) self.meter_container.add_meter( DefaultStats.PATCH_CONF, ConfusionMeter(self.num_classes, normalized=False)) self.meter_container.add_meter(DefaultStats.LOSS_METER, AverageValueMeter()) self.meter_container.add_meter(DefaultStats.PATCH_AUC, MultiAUC(num_class=self.num_classes)) phase_name_list = [ VizLogContainer.mode_to_phase_name(phase) for phase in [True, False] ] plot_opts_by_phase = {'legend': phase_name_list} class_name_cross_phase = [ DefaultStats.class_per_phase(x, y) for x in self.sub_class_list for y in phase_name_list ] plot_opts_by_class_name = {'legend': class_name_cross_phase} if self.patient_pred is not None and self.patient_info is not None: self.meter_container.add_meter( DefaultStats.MULTI_INSTANCE, MultiInstanceMeter( self.patient_info, self.patient_pred, positive_class=MultiInstanceMeter.default_positive( self.class_partition, self._positive_class))) self.vizlog_container.add_logger(VisdomPlotLogger, 'line', DefaultStats.VIZ_MULTI_TRUE_PRED, [DefaultStats.PHASE_COMBINE], opts=plot_opts_by_class_name) self.vizlog_container.add_logger(VisdomPlotLogger, 'line', DefaultStats.VIZ_MULTI_AUC, [DefaultStats.PHASE_COMBINE], opts=plot_opts_by_phase) self.vizlog_container.add_logger(VisdomPlotLogger, 'line', DefaultStats.VIZ_LOSS, [DefaultStats.PHASE_COMBINE], opts=plot_opts_by_phase) self.vizlog_container.add_logger(VisdomPlotLogger, 'line', DefaultStats.VIZ_PATCH_TRUE_PRED, [DefaultStats.PHASE_COMBINE], opts=plot_opts_by_class_name) self.vizlog_container.add_logger(VisdomPlotLogger, 'line', DefaultStats.VIZ_PATCH_AUC, [DefaultStats.PHASE_COMBINE], opts=plot_opts_by_class_name)