def main(): best_prec1 = 0 model = MVConv() if use_gpu: model.cuda() print(model) # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() print(lr, weight_decay) optimizer = torch.optim.SGD(model.parameters(), lr, weight_decay=weight_decay) cudnn.benchmark = True transformed_train_dataset = ModelNetDataset(root_dir=train_data_root, phase='train', transform=transforms.Compose( [ToTensor()])) transformed_valid_dataset = ModelNetDataset(root_dir=train_data_root, phase='test', transform=transforms.Compose( [ToTensor()])) # Loading dataset into dataloader train_loader = torch.utils.data.DataLoader(transformed_train_dataset, batch_size=train_batch_size, shuffle=True, num_workers=num_workers) val_loader = torch.utils.data.DataLoader(transformed_valid_dataset, batch_size=test_batch_size, shuffle=True, num_workers=num_workers) start_time = time.time() # Train for all epochs between Startepoch, Endepoch for epoch in range(0, epochs): adjust_learning_rate(optimizer, epoch) # train on train dataset train(train_loader, model, criterion, optimizer, epoch) # evaluate on validation set prec1 = validate(val_loader, model, criterion) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint(model.state_dict(), is_best, trained_model_path) end_time = time.time() duration = (end_time - start_time) / 3600 print("Duration:") print(duration)
def get_dataset(directory, img_size, data_size=None): if img_size == None: return Segmentation(directory, 'training.json', \ transform = ToTensor(), data_size=data_size) else: return Segmentation(directory, 'training.json', \ transform = Compose([ \ RandomCrop((img_size, img_size)), \ ToTensor() ]), data_size=data_size)
def __init__(self): self.embedding_size = 512 self.m = 3 self.lambda_min = 5 #lambda下限 self.lambda_max = 1000 #lambda 上限 self.epochs = 20 self.batch_size = 128 self.optimizer = 'sgd' self.momentum = 0.9 self.dampening = 0 self.lr = 1e-1 self.lr_decay = 0 self.wd = 0.00001 self.model_dir = './model/sgd/' self.final_dir = './final_model/sgd/' self.start = None self.resume = self.final_dir + 'net.pth' self.load_it = True self.it = None self.load_optimizer = True self.seed = 123456 self.use_out = True self.use_embedding = True self.test_batch_size = 24 self.transform = transforms.Compose([ TruncatedInput(input_per_file=1), ToTensor(), ])
def __init__(self): self.embedding_size = 1024 self.m = 0.2 self.s = 8 self.samples_per_speaker = 8 #每个说话人采样数 self.epochs = 20 self.batch_size = 128 self.optimizer = 'sgd' self.momentum = 0.9 self.dampening = 0 self.lr = 1e-1 self.lr_decay = 0 self.wd = 0.00001 self.model_dir = './model/sgd/' self.final_dir = './final_model/sgd/' self.start = None self.resume = self.final_dir + 'net.pth' self.load_optimizer = True self.seed = 123456 self.use_out = True self.use_embedding = True self.test_batch_size = 128 self.transform = transforms.Compose([ TruncatedInput(input_per_file=1), ToTensor(), ])
def __init__(self, model_path): self.model = SiameseAlexNet() """服务器部署就改,去掉map_location""" if config.ubuntu: checkpoint = torch.load(model_path) else: checkpoint = torch.load(model_path, map_location="cpu") if "model" in checkpoint.keys(): """服务器部署就改""" if config.ubuntu: self.model.load_state_dict(torch.load(model_path)["model"]) else: self.model.load_state_dict( torch.load(model_path, map_location="cpu")["model"]) else: self.model.load_state_dict(torch.load(model_path)) self.cuda = torch.cuda.is_available() self.device = torch.device('cuda:0,1' if self.cuda else 'cpu') self.model = self.model.to(self.device) self.model.eval() self.transforms = transforms.Compose([ToTensor()]) valid_scope = config.valid_scope self.anchors = generate_anchors(config.total_stride, config.anchor_base_size, config.anchor_scales, config.anchor_ratios, valid_scope) ## np.outer()里面就是汉宁窗了,None增加了最前面的一个通道数量是1 self.windows = np.tile( np.outer(np.hanning(config.score_size), np.hanning(config.score_size))[None, :], [config.anchor_num, 1, 1]).flatten() #从通道0的scope_map开始展开(17,17)
def get_dataset(directory, img_size, data_size=None): """ Unlike the train file, this returns the intact image and label regardless of the img_size option. It is the work of the main function to crop the image and send it as input to the model and stitch back the output """ return Segmentation(directory, 'training.json', \ transform = ToTensor(), data_size=data_size)
def __getitem__(self, index): # print(len(self.gt_box_positive)) patch = self.patches[index] image = _load_image(self.data_images, self.image_files[patch[5]], bits=self.bits_per_channel, mode=self.mode) trsf_crop = CropTransform(patch[0], patch[1], self.patch_size, self.patch_size) trsf_hflip = transforms.RandomHorizontalFlip(p=0.5) trsf_tensor = transforms.ToTensor() \ if self.bits_per_channel == 8 else ToTensor() trsf_normalize = transforms.Normalize(self.mean, self.std) trsf_compose = [trsf_crop] if self.training is True: trsf_compose.append(trsf_hflip) trsf_compose.append(trsf_tensor) trsf_compose.append(trsf_normalize) data_transforms = transforms.Compose(trsf_compose) image = data_transforms(image) bboxes = self.gt_box_positive[index] pad_v = max(patch[3] - self.image_sizes[patch[5]][1], 0) pad_h = max(patch[2] - self.image_sizes[patch[5]][0], 0) mask = np.zeros((self.patch_size, self.patch_size), dtype=np.uint8) if pad_v > 0: mask[self.patch_size - int(pad_v) - 1:self.patch_size, :] = 255 if pad_h > 0: mask[:, self.patch_size - int(pad_h) - 1:self.patch_size] = 255 for b in bboxes: x1, y1, x2, y2, _, _ = self.gt_boxes[b] x1 = max(x1 - patch[0], 0) y1 = max(y1 - patch[1], 0) x2 = min(x2 - patch[0], self.patch_size) y2 = min(y2 - patch[1], self.patch_size) mask[y1:y2, x1:x2] = 127 # to test/visualize mask = Image.fromarray(mask, mode='L') if self.training is True: mask = trsf_hflip(mask) mask = torch.LongTensor(np.array(mask).astype(np.uint8)) print("Image {} with patch grid of {} by {}".format( self.image_files[patch[5]], self.patch_grids[patch[5]][0], self.patch_grids[patch[5]][1])) return image, mask # , patch
def vgg_eval_model(dataset_root_dir, restore_model: str): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("DEVICE WILL BE USED: ", device) net = VggNet(torchvision.models.vgg16_bn(True)) net = net.to(device) classes = ('not hotdog', 'hotdog') if restore_model is not None and len(restore_model) > 0: # original saved file with DataParallel state_dict = torch.load(restore_model, map_location={'cuda:0': 'cpu'}) net.load_state_dict(state_dict) print("Model {} restored".format(restore_model)) else: print("ERROR: no restore model file found!") return #from torch.autograd import Variable #dummy_input = Variable(torch.randn(1, 3, 224, 224), requires_grad=True) # input_names = ["actual_input_1"] + ["learned_%d" % i for i in range(12)] # output_names = ["output1"] #torch.onnx.export(net, dummy_input, "vgg_hot_dog.onnx", export_params=True, verbose=True) #print("SUCCESS") hot_dog_dataset_test = HotDogsDatasetEval( root_dir=dataset_root_dir, transform=transforms.Compose([ Rescale((224, 224)), #normalize, ToTensor(), ])) test_dataloader = DataLoader(hot_dog_dataset_test, batch_size=4, shuffle=True, num_workers=4) for dl, type in zip([test_dataloader], ['test']): correct = 0 total = 0 with torch.no_grad(): for data in dl: images, names = data['image'].float(), data['name'] images = images.to(device) outputs = net(images) total += len(names) for id, prediction in enumerate(outputs.data): res = torch.nn.functional.softmax(prediction, dim=0) _, rid = torch.max(res, 0) print('{} is {}'.format(names[id], classes[rid])) imshow(torchvision.utils.make_grid(images[id]))
def test(n_class=1, in_channel=1, load=False, img_size=None, directory='../Data/train/'): global original, dataset, model original = Segmentation(directory, 'training.json', ToTensor()) if img_size is None: dataset = Segmentation(directory, 'test.json', ToTensor()) else: dataset = Segmentation(directory, 'test.json', T.Compose([\ RandomCrop((img_size, img_size)), ToTensor()])) model = UNet(n_class=n_class, in_channel=in_channel) if load: filename = "unet.pth" map_location = 'cuda:0' if torch.cuda.is_available() else 'cpu' try: checkpoint = torch.load(filename, map_location=map_location) model.load_state_dict(checkpoint['state_dict']) print("Loaded saved model") except: print("Unable to load saved model")
def main(): parser = argparse.ArgumentParser( description='Binary MRI Quality Classification') parser.add_argument('--yaml_path', type=str, metavar='YAML', default="config/acdc_binary_classification.yaml", help='Enter the path for the YAML config') args = parser.parse_args() yaml.add_constructor("!join", yaml_var_concat) yaml_path = args.yaml_path with open(yaml_path, 'r') as f: train_args = yaml.load(f, Loader=yaml.Loader) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") composed = transforms.Compose([ Resize((224, 224)), OneToThreeDimension(), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) acdc_dataset = ACDCDataset(train_args["pos_samps_test"], train_args["neg_samps_test"], transform=composed) dataloader = DataLoader(acdc_dataset, batch_size=train_args["batch_size"], shuffle=False, num_workers=4) dataset_size = len(acdc_dataset) model_ft = get_model(train_args["model"], device, pretrained=train_args["pretrained"]) state = get_most_recent_model(train_args["model"], train_args["model_save_dir"]) model_ft.load_state_dict(state) test(model_ft, dataloader, dataset_size, device=device)
def main(args): device = torch.device(args.device) #we first see if there is a model with needed name in our models folder, model = torch.load(f"{args.model_folder}/{args.model_name}", map_location=device) model.eval() data_transforms = transforms.Compose([ToTensor()]) dataset = Data(args.filename_x, args.filename_y, args.data_root,transform=data_transforms) output = {"Super_resolution": []} for sample in dataset: lores = sample['x'].to(device).float() print(lores.shape) sures = model(lores.unsqueeze(0)).squeeze(0) output["Super_resolution"].append(sures.detach().cpu().data.numpy()) savemat(f"{args.model_folder}/{args.filename_out}", output)
def main(): """ DataLoader """ train_data = PartAffordanceDataset( 'train.csv', transform=transforms.Compose([CenterCrop(), ToTensor(), Normalize()])) test_data = PartAffordanceDataset( 'test.csv', transform=transforms.Compose([CenterCrop(), ToTensor(), Normalize()])) train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=4) test_loader = DataLoader(test_data, batch_size=args.batch_size, shuffle=False, num_workers=4) if args.model == 'FCN8s': model = FCN8s(args.in_channel, args.n_classes) elif args.model == 'SegNetBasic': model = SegNetBasic(args.in_channel, args.n_classes) elif args.model == 'UNet': model = UNet(args.in_channel, args.n_classes) else: print('This model doesn\'t exist in the model directory') sys.exit(1) model.apply(init_weight) """ training """ if args.writer: writer = SummaryWriter(args.result_path) if args.class_weight: criterion = nn.CrossEntropyLoss(weight=class_weight.to(args.device)) else: criterion = nn.CrossEntropyLoss() model.to(args.device) optimizer = optim.Adam(model.parameters(), lr=args.learning_rate) train_losses = [] val_iou = [] mean_iou = [] best_mean_iou = 0.0 for epoch in range(args.max_epoch): model.train() running_loss = 0.0 for i, sample in tqdm.tqdm(enumerate(train_loader), total=len(train_loader)): optimizer.zero_grad() x, y = sample['image'], sample['class'] x = x.to(args.device) y = y.to(args.device) h = model(x) loss = criterion(h, y) loss.backward() optimizer.step() running_loss += loss.item() train_losses.append(running_loss / i) val_iou.append( eval_model(model, test_loader, args.device).to('cpu').float()) mean_iou.append(val_iou[-1].mean().item()) if best_mean_iou < mean_iou[-1]: best_mean_iou = mean_iou[-1] torch.save(model.state_dict(), args.result_path + '/best_mean_iou_model.prm') if writer is not None: writer.add_scalar("train_loss", train_losses[-1], epoch) writer.add_scalar("mean_IoU", mean_iou[-1], epoch) writer.add_scalars( "class_IoU", { 'iou of class 0': val_iou[-1][0], 'iou of class 1': val_iou[-1][1], 'iou of class 2': val_iou[-1][2], 'iou of class 3': val_iou[-1][3], 'iou of class 4': val_iou[-1][4], 'iou of class 5': val_iou[-1][5], 'iou of class 6': val_iou[-1][6], 'iou of class 7': val_iou[-1][7] }, epoch) print('epoch: {}\tloss: {:.5f}\tmean IOU: {:.3f}'.format( epoch, train_losses[-1], mean_iou[-1])) torch.save(model.state_dict(), args.result_path + "/final_model.prm")
import torch from torch import nn from torchvision import transforms, utils from torch.utils.data import DataLoader from dataset import PosterDataset, Resize, ToTensor import numpy as np import warnings warnings.filterwarnings("ignore") bs = 32 transformed_dataset = PosterDataset(csv_file='./data.txt', root_dir='../data/fgsm/FGSM', transform=transforms.Compose( [Resize(), ToTensor()])) data_loader = DataLoader(transformed_dataset, batch_size=bs, shuffle=False) print('train batches: ', len(data_loader)) device = torch.device('cuda') org_model = torch.load('../data/models/origin_model.pkl').cuda() fgsm_model = torch.load('../data/models/fgsm_model.pkl').cuda() pgd_model = torch.load('../data/models/pgd_model.pkl').cuda() def props_to_onehot(props): if isinstance(props, list): props = np.array(props) a = np.argmax(props, axis=1) b = np.zeros((len(a), props.shape[1])) b[np.arange(len(a)), a] = 1 return b
with torch.no_grad(): for i, sample in enumerate(test_loader): image = sample["image"].to(params["device"]).float() pred = model(image) pred = pred.cpu().numpy() prediction_list.append(pred) predictions = np.concatenate(prediction_list, axis=0) return predictions if __name__ == "__main__": if not os.path.isdir(params["checkpoint_dir"]): os.makedirs(params["checkpoint_dir"]) # TODO: change back train_transform = torchvision.transforms.Compose( [ToTensor(), RandomFlip(), RandomRotate()]) test_transform = torchvision.transforms.Compose([ToTensor()]) train_dataset = COVID19Dataset(params["train_data_dir"], transform=train_transform, channels=params["channels"]) test_dataset = COVID19Dataset(params["train_data_dir"], transform=test_transform, channels=params["channels"]) print("train:", params["train_data_dir"], len(train_dataset)) # TODO: change back to True train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=params["batch_size"],
parser.add_argument('--out_dir', type=str, default='models/', help='Folder where to save the model') if __name__ == '__main__': # Parse input arguments args = parser.parse_args() #%% Check device # device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") #%% Create dataset dataset = CSPDataset(size=args.size, k=args.k, n=args.n, alpha=args.alpha,\ r=args.r, p=args.p, transform=ToTensor()) dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True) # retrieving data # n = dataset.csp.n n = dataset.csp.n m = dataset.csp.m n_bad = dataset.csp.n_bad_assgn csp_shape = { 'k': args.k, 'n': n, 'd': dataset.csp.d, 'm': m, 'n_bad': n_bad }
elif args.model == 'UNet': model = UNet(args.in_channel, args.n_classes) else: print('This model doesn\'t exist in the model directory') sys.exit(1) if args.params_path is not None: model.load_state_dict( torch.load(args.params_path, map_location=lambda storage, loc: storage)) """ define DataLoader """ data = PartAffordanceDataset('test.csv', transform=transforms.Compose( [CenterCrop(), ToTensor(), Normalize()])) data_loader = DataLoader(data, batch_size=args.num_images, shuffle=True) for sample in data_loader: model.eval() predict(model, sample, device=args.device) x = sample["image"] x = reverse_normalize(x, mean, std) save_image( x, args.result_path + '/' + 'original_images_with_' + args.model + '.jpg')
def test(data_dir, csv_path, splits_path, output_dir, target='pa', batch_size=1, pretrained=False, min_patients_per_label=100, seed=666, model_type='hemis', architecture='densenet121', misc=None): assert target in ['pa', 'l', 'joint'] print(f"\n\nTesting seed {seed}") torch.manual_seed(seed) np.random.seed(seed) extra = misc.extra name = output_dir.split("/")[-1].format('') + extra output_dir = output_dir.format(seed) splits_path = splits_path.format(seed) if not exists(splits_path): split_dataset(csv_path, splits_path) resultsfile = join(output_dir, '..', 'auc-test.csv') if not isfile(resultsfile): columns = ['expt', 'seed', 'accuracy', 'auc', 'auc_weighted', 'prc', 'prc_weighted'] test_metrics_df = pd.DataFrame(columns=columns) else: test_metrics_df = pd.read_csv(resultsfile) # Save predictions savepreds = {} saveauc = {} predsdir = join(output_dir, '..', 'test_outs') predsfile = join(predsdir, f'preds-{name}{extra}_{seed}-{target}.npz') aucfile = join(predsdir, f'auc-{name}{extra}_{seed}-{target}.npz') if isfile(predsfile): print(f'Loading {predsfile}') _arr = np.load(predsfile, allow_pickle=True) savepreds = {k: _arr[k] for k in _arr.keys()} if isfile(aucfile): print(f'Loading {aucfile}') _arr = np.load(aucfile, allow_pickle=True) saveauc = {k: _arr[k] for k in _arr.keys()} print("Test mode: {}".format(target)) print('Device that will be used is: {0}'.format(DEVICE)) # Load data preprocessing = Compose([Normalize(), ToTensor()]) testset = PCXRayDataset(data_dir, csv_path, splits_path, transform=preprocessing, dataset='test', pretrained=pretrained, min_patients_per_label=min_patients_per_label) testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2) print("{0} patients in test set.".format(len(testset))) # Find best weights metricsdf = pd.read_csv(join(output_dir, f'{target}-metrics.csv')) best_epoch = int(metricsdf.idxmax()['auc']) weights_file = join(output_dir, '{}-e{}.pt'.format(target, best_epoch)) # Create model and load best weights model = create_model(model_type, num_classes=testset.nb_labels, target=target, architecture=architecture, dropout=0.0, otherargs=misc) try: model.load_state_dict(torch.load(weights_file)) except: # Issue in loading weights if trained on multiple GPUs state_dict = torch.load(weights_file, map_location='cpu') for key in list(state_dict.keys()): if 'conv' in key or 'classifier' in key: if '.0.' in key: new_key = key.replace(".0.", '.') state_dict[new_key] = state_dict[key] del state_dict[key] model.load_state_dict(state_dict) model.to(DEVICE) model.eval() # if misc.test_multi: # y_true, y_preds, _ = get_model_preds(model, dataloader=testloader, target=target, model_type=model_type, # vote_at_test=misc.vote_at_test, progress_bar=True) # metrics, per_label_auc, per_label_prc = get_metrics(y_true, y_preds) # row = {'expt': name, 'seed': seed, **metrics} # print(row) # # test_metrics_df = test_metrics_df.append(row, ignore_index=True) # test_metrics_df.to_csv(resultsfile, index=False) # # savepreds = {'y_true': y_true, 'y_preds': y_preds, 'meta': row} # saveauc = {'auc': per_label_auc, 'prc': per_label_prc, 'meta': row} for view in misc.test_on: print(f"Testing on only {view}") if view == 'pa': model.test_only_one = 0 elif view == 'l': model.test_only_one = 1 else: model.test_only_one = None y_true, y_preds, _ = get_model_preds(model, dataloader=testloader, target=target, test_on=view, model_type=model_type, vote_at_test=misc.vote_at_test, progress_bar=True) metrics, per_label_auc, per_label_prc = get_metrics(y_true, y_preds) row = {'expt': name + f'{view}_view', 'seed': seed, **metrics} print(row) test_metrics_df = test_metrics_df.append(row, ignore_index=True) savepreds[f'y_true_{view}_view'] = y_true savepreds[f'y_preds_{view}_view'] = y_preds savepreds[f'meta_{view}_view'] = row saveauc[f'auc_{view}_view'] = per_label_auc saveauc[f'prc_{view}_view'] = per_label_prc saveauc[f'meta_{view}_view'] = row test_metrics_df.to_csv(resultsfile, index=False) np.savez(join(predsdir, f'preds-{name}{extra}_{seed}-{target}'), **savepreds) np.savez(join(predsdir, f'auc-{name}{extra}_{seed}-{target}'), **saveauc)
def main(): # Training settings parser = argparse.ArgumentParser(description='PyTorch') parser.add_argument('--batch-size', type=int, default=16, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=100, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.001, metavar='LR', help='learning rate (default: 0.001)') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--randam-batch', action='store_true', default=False, help='if true, randamly sample batch') parser.add_argument( '--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') args = parser.parse_args() torch.manual_seed(args.seed) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") kwargs = { 'num_workers': 1, 'pin_memory': True, 'worker_init_fn': init_worker_seed } train_loader = torch.utils.data.DataLoader(ObjectDataset( os.path.dirname(os.path.abspath(__file__)) + '/../kitti', 'train', transform=transforms.Compose([ToTensor(), RandomHorizontalFlip()])), batch_size=args.batch_size, shuffle=args.randam_batch, **kwargs) test_loader = torch.utils.data.DataLoader(ObjectDataset( os.path.dirname(os.path.abspath(__file__)) + '/../kitti', 'val', transform=transforms.Compose([ToTensor()])), batch_size=args.batch_size, shuffle=False, **kwargs) model = Network(3).to(device) # criterion = nn.CrossEntropyLoss() criterion = F.nll_loss optimizer = optim.Adam(model.parameters(), lr=args.lr) print('output log file to', log_directory) for epoch in range(1, args.epochs + 1): train(args, model, device, train_loader, optimizer, criterion, epoch) validation(args, model, device, test_loader, criterion) if (args.save_model): torch.save(model.state_dict(), "object_recognition.pt") train_writer.close() validation_writer.close()
def train(data_dir, csv_path, splits_path, output_dir, target='pa', nb_epoch=100, lr=(1e-4, ), batch_size=1, optim='adam', dropout=None, min_patients_per_label=50, seed=666, data_augmentation=True, model_type='hemis', architecture='densenet121', misc=None): assert target in ['pa', 'l', 'joint'] torch.manual_seed(seed) np.random.seed(seed) output_dir = output_dir.format(seed) splits_path = splits_path.format(seed) logger.info(f"Training mode: {target}") if not exists(output_dir): os.makedirs(output_dir) if not exists(splits_path): split_dataset(csv_path, splits_path, seed=seed) # Find device logger.info(f'Device that will be used is: {DEVICE}') # Load data val_transfo = [Normalize(), ToTensor()] if data_augmentation: train_transfo = [Normalize(), ToPILImage()] if 'rotation' in misc.transforms: train_transfo.append(RandomRotation(degrees=misc.rotation_degrees)) if 'translation' in misc.transforms: train_transfo.append(RandomTranslate(translate=misc.translate)) train_transfo.append(ToTensor()) if 'noise' in misc.transforms: train_transfo.append(GaussianNoise()) else: train_transfo = val_transfo dset_args = { 'datadir': data_dir, 'csvpath': csv_path, 'splitpath': splits_path, 'max_label_weight': misc.max_label_weight, 'min_patients_per_label': min_patients_per_label, 'flat_dir': misc.flatdir } loader_args = { 'batch_size': batch_size, 'shuffle': True, 'num_workers': misc.threads, 'pin_memory': True } trainset = PCXRayDataset(transform=Compose(train_transfo), **dset_args) valset = PCXRayDataset(transform=Compose(val_transfo), dataset='val', **dset_args) trainloader = DataLoader(trainset, **loader_args) valloader = DataLoader(valset, **loader_args) n_pts = f"{len(trainset)} train," if misc.use_extended: ext_args = dset_args.copy() ext_args['splitpath'] = None ext_args['csvpath'] = misc.csv_path_ext extset = PCXRayDataset(transform=Compose(train_transfo), mode='pa_only', use_labels=trainset.labels, **ext_args) extset.labels_count = trainset.labels_count extset.labels_weights = trainset.labels_weights extloader = DataLoader(extset, **loader_args) n_pts += f" {len(extset)} ext_train," logger.info(f"Number of patients: {n_pts} {len(valset)} valid.") logger.info( f"Predicting {len(trainset.labels)} labels: \n{trainset.labels}") logger.info(trainset.labels_weights) # Load model model = create_model(model_type, num_classes=trainset.nb_labels, target=target, architecture=architecture, dropout=dropout, otherargs=misc) model.to(DEVICE) logger.info(f'Created {model_type} model') evaluator = ModelEvaluator(output_dir=output_dir, target=target, logger=logger) criterion = nn.BCEWithLogitsLoss( pos_weight=trainset.labels_weights.to(DEVICE)) loss_weights = [1.0] + list(misc.loss_weights) if len(misc.mt_task_prob) == 1: _mt_task_prob = misc.mt_task_prob[0] task_prob = [1 - _mt_task_prob, _mt_task_prob / 2., _mt_task_prob / 2.] else: _pa_prob, _l_prob = misc.mt_task_prob _jt_prob = 1 - (_pa_prob + _l_prob) task_prob = [_jt_prob, _pa_prob, _l_prob] if model_type in ['singletask', 'multitask', 'dualnet'] and len(lr) > 1: # each branch has custom learning rate optim_params = [{ 'params': model.frontal_model.parameters(), 'lr': lr[0] }, { 'params': model.lateral_model.parameters(), 'lr': lr[1] }, { 'params': model.classifier.parameters(), 'lr': lr[2] }] else: # one lr for all optim_params = [{'params': model.parameters(), 'lr': lr[0]}] if misc.learn_loss_coeffs: temperature = torch.ones(size=(3, ), requires_grad=True, device=DEVICE).float() temperature_lr = lr[-1] if len(lr) > 3 else lr[0] optim_params.append({'params': temperature, 'lr': temperature_lr}) # Optimizer optimizer, scheduler = create_opt_and_sched(optim=optim, params=optim_params, lr=lr[0], other_args=misc) start_epoch = 1 # Resume training if possible latest_ckpt_file = join(output_dir, f'{target}-latest.tar') if isfile(latest_ckpt_file): checkpoint = torch.load(latest_ckpt_file) model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) scheduler.load_state_dict(checkpoint['scheduler_state_dict']) del checkpoint evaluator.load_saved() start_epoch = int(evaluator.eval_df.epoch.iloc[-1]) logger.info(f"Resumed at epoch {start_epoch}") # Training loop for epoch in range(start_epoch, nb_epoch + 1): # loop over the dataset multiple times model.train() running_loss = torch.zeros(1, requires_grad=False, dtype=torch.float).to(DEVICE) train_preds, train_true = [], [] for i, data in enumerate(trainloader, 0): if target == 'joint': *images, label = data['PA'].to(DEVICE), data['L'].to( DEVICE), data['encoded_labels'].to(DEVICE) if model_type == 'stacked': images = torch.cat(images, dim=1) else: images, label = data[target.upper()].to( DEVICE), data['encoded_labels'].to(DEVICE) # Forward output = model(images) optimizer.zero_grad() if model_type == 'multitask': # order of returned logits is joint, frontal, lateral if misc.learn_loss_coeffs: loss_weights = temperature.pow(-2) all_task_losses, weighted_task_losses = [], [] for idx, _logit in enumerate(output): task_loss = criterion(_logit, label) all_task_losses.append(task_loss) weighted_task_losses.append(task_loss * loss_weights[idx]) losses_dict = { 0: sum(weighted_task_losses), 1: all_task_losses[1], 2: all_task_losses[2] } select = np.random.choice([0, 1, 2], p=task_prob) loss = losses_dict[select] # mixing this temp seems bad if misc.learn_loss_coeffs: loss += temperature.log().sum() output = output[0] else: loss = criterion(output, label) # Backward loss.backward() optimizer.step() # Save predictions train_preds.append(torch.sigmoid(output).detach().cpu().numpy()) train_true.append(label.detach().cpu().numpy()) # print statistics running_loss += loss.detach() print_every = max(1, len(trainset) // (20 * batch_size)) if (i + 1) % print_every == 0: running_loss = running_loss.cpu().detach().numpy().squeeze( ) / print_every logger.info('[{0}, {1:5}] loss: {2:.5f}'.format( epoch, i + 1, running_loss)) evaluator.store_dict['train_loss'].append(running_loss) running_loss = torch.zeros(1, requires_grad=False).to(DEVICE) del output, images, data if misc.use_extended: # Train with only PA images from extended dataset for i, data in enumerate(extloader, 0): if target == 'joint': *images, label = data['PA'].to(DEVICE), data['L'].to( DEVICE), data['encoded_labels'].to(DEVICE) else: images, label = data[target.upper()].to( DEVICE), data['encoded_labels'].to(DEVICE) # Forward output = model(images) optimizer.zero_grad() if model_type == 'multitask': # only use PA loss output = output[1] loss = criterion(output, label) # Backward loss.backward() optimizer.step() # Save predictions train_preds.append( torch.sigmoid(output).detach().cpu().numpy()) train_true.append(label.detach().cpu().numpy()) # print statistics running_loss += loss.detach() print_every = max(1, len(trainset) // (20 * batch_size)) if (i + 1) % print_every == 0: running_loss = running_loss.cpu().detach().numpy().squeeze( ) / print_every logger.info( '[{0}, {1:5}] Extended dataset loss: {2:.5f}'.format( epoch, i + 1, running_loss)) evaluator.store_dict['train_loss'].append(running_loss) running_loss = torch.zeros(1, requires_grad=False).to(DEVICE) del output, images, data train_preds = np.vstack(train_preds) train_true = np.vstack(train_true) model.eval() val_true, val_preds, val_runloss = get_model_preds( model, dataloader=valloader, loss_fn=criterion, target=target, model_type=model_type, vote_at_test=misc.vote_at_test) val_runloss /= (len(valset) / batch_size) logger.info(f'Epoch {epoch} - Val loss = {val_runloss:.5f}') val_auc, _ = evaluator.evaluate_and_save(val_true, val_preds, epoch=epoch, train_true=train_true, train_preds=train_preds, runloss=val_runloss) if 'reduce' in misc.sched: scheduler.step(metrics=val_auc, epoch=epoch) else: scheduler.step(epoch=epoch) _states = { 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict() } torch.save(_states, latest_ckpt_file) torch.save(model.state_dict(), join(output_dir, '{}-e{}.pt'.format(target, epoch))) # Remove all batches weights weights_files = glob( join(output_dir, '{}-e{}-i*.pt'.format(target, epoch))) for file in weights_files: os.remove(file)
train_via = { key: via[key] for i, key in enumerate(keys) if (i % args.k) != args.fold } else: train_via = via if args.special: trainset = VIADataset(train_via, args.path, shuffle=True, size=None) trainset = RandomTranspose(trainset) else: trainset = VIADataset(train_via, args.path, shuffle=True, alt=1) trainset = Scale(trainset, args.scale) if args.scale > 1 else trainset trainset = RandomTranspose(RandomFilter(ColorJitter(trainset))) trainset = ToTensor(trainset) print('Training size = {}'.format(len(trainset))) # Dataloaders trainloader = DataLoader(trainset, batch_size=args.batch, pin_memory=True) # Model if args.model == 'unet': if args.multitask: model = MultiTaskUNet(3, 1, R=5) else: model = UNet(3, 1) elif args.model == 'segnet': if args.multitask: model = MultiTaskSegNet(3, 1, R=5)
flame_proj_lmks.append(flame_proj_lmk) shape_norms += torch.norm(shape_params) exp_norms += torch.norm(exp_params) def weight_init(m): if isinstance(m, nn.Linear): nn.init.xavier_normal_(m.weight) if __name__ == '__main__': need_evaluate = False composed_transforms = transforms.Compose( [ScaleAndCrop(config_img_size), ToTensor()]) dataset = NoWDataset( dataset_path=os.path.join('.', 'training_set', 'NoW_Dataset', 'final_release_version'), data_folder='iphone_pictures', bounding_box_folder='detected_face', facepos_folder='openpose', # id_txt = 'subjects_idst.txt', id_txt='subjects_id.txt', R=6, transform=composed_transforms) if need_evaluate: resnet50 = torch.load("./resnet50.pkl") else: resnet50 = models.resnet50(pretrained=True)
path = "/home/lgraha07/scratch/Paper2021/data/" trainpath = path + traindir testpath = path + testdir validpath = path + validdir filename = "fracdata.dat" trainfile = trainpath + filename testfile = testpath + filename validfile = validpath + filename train_set = FractalDataset(filename=trainfile, root_dir=trainpath, transform=ToTensor()) test_set = FractalDataset(filename=testfile, root_dir=testpath, transform=ToTensor()) valid_set = FractalDataset(filename=validfile, root_dir=validpath, transform=ToTensor()) # Put each dataset into a pytorch data loader which divides it into batches frac_train_loader = data_utils.DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=num_workers) frac_test_loader = data_utils.DataLoader(test_set, batch_size=batch_size, shuffle=False,
suffix = utils.build_suffix(args.structure) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(torch.cuda.is_available()) if args.train_set is not None: train_set_file = args.train_set else: train_set_file = "data/labels/train_labels_frame_patches30.csv" train_set = FoADataset(train_set_file, "data/inputs", transform=transforms.Compose([ RandomTranslation(), RandomPermutations(), Normalization(), ToTensor() ])) if args.test_set is not None: test_set_file = args.test_set else: test_set_file = "data/labels/test_labels_frame_patches30.csv" test_set = FoADataset(test_set_file, "data/inputs", transform=transforms.Compose( [Normalization(), ToTensor()])) train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True,
torch.save(net, model_name) eval(valloader, model_name) print('Finished Training') if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument('path') args = parser.parse_args() traindataset = PhoneDataset(label_path='labels_train.txt', root_dir=args.path, transform=transforms.Compose( [Rescale((224, 224)), ToTensor()])) trainloader = torch.utils.data.DataLoader( traindataset, batch_size=4, shuffle=False, ) valdataset = PhoneDataset(label_path='labels_val.txt', root_dir=args.path, transform=transforms.Compose( [Rescale((224, 224)), ToTensor()])) valloader = torch.utils.data.DataLoader( traindataset, batch_size=1, shuffle=False,
def main(): global args global sv_name_eval # save configuration to file sv_name = datetime.strftime(datetime.now(), '%Y%m%d_%H%M%S') sv_name_eval = sv_name print('saving file name is ', sv_name) write_arguments_to_file(args, os.path.join(logs_dir, sv_name + '_arguments.txt')) # ----------------------------------- data # define mean/std of the training set (for data normalization) label_type = args.label_type use_s1 = (args.sensor_type == 's1') | (args.sensor_type == 's1s2') use_s2 = (args.sensor_type == 's2') | (args.sensor_type == 's1s2') dataset = args.dataset data_dir = os.path.join("data", dataset, "data") bands_mean = {} bands_std = {} train_dataGen = None val_dataGen = None test_dataGen = None print(f"Using {dataset} dataset") if dataset == 'sen12ms': bands_mean = { 's1_mean': [-11.76858, -18.294598], 's2_mean': [ 1226.4215, 1137.3799, 1139.6792, 1350.9973, 1932.9058, 2211.1584, 2154.9846, 2409.1128, 2001.8622, 1356.0801 ] } bands_std = { 's1_std': [4.525339, 4.3586307], 's2_std': [ 741.6254, 740.883, 960.1045, 946.76056, 985.52747, 1082.4341, 1057.7628, 1136.1942, 1132.7898, 991.48016 ] } elif dataset == 'bigearthnet': # THE S2 BAND STATISTICS WERE PROVIDED BY THE BIGEARTHNET TEAM # Source: https://git.tu-berlin.de/rsim/bigearthnet-models-tf/-/blob/master/BigEarthNet.py bands_mean = { 's1_mean': [-12.619993, -19.290445], 's2_mean': [ 340.76769064, 429.9430203, 614.21682446, 590.23569706, 950.68368468, 1792.46290469, 2075.46795189, 2218.94553375, 2266.46036911, 2246.0605464, 1594.42694882, 1009.32729131 ] } bands_std = { 's1_std': [5.115911, 5.464428], 's2_std': [ 554.81258967, 572.41639287, 582.87945694, 675.88746967, 729.89827633, 1096.01480586, 1273.45393088, 1365.45589904, 1356.13789355, 1302.3292881, 1079.19066363, 818.86747235 ] } else: raise NameError(f"unknown dataset: {dataset}") # load datasets imgTransform = transforms.Compose( [ToTensor(), Normalize(bands_mean, bands_std)]) if dataset == 'sen12ms': train_dataGen = SEN12MS(data_dir, args.label_split_dir, imgTransform=imgTransform, label_type=label_type, threshold=args.threshold, subset="train", use_s1=use_s1, use_s2=use_s2, use_RGB=args.use_RGB, IGBP_s=args.simple_scheme, data_size=args.data_size, sensor_type=args.sensor_type, use_fusion=args.use_fusion) val_dataGen = SEN12MS(data_dir, args.label_split_dir, imgTransform=imgTransform, label_type=label_type, threshold=args.threshold, subset="val", use_s1=use_s1, use_s2=use_s2, use_RGB=args.use_RGB, IGBP_s=args.simple_scheme, data_size=args.data_size, sensor_type=args.sensor_type, use_fusion=args.use_fusion) if args.eval: test_dataGen = SEN12MS(data_dir, args.label_split_dir, imgTransform=imgTransform, label_type=label_type, threshold=args.threshold, subset="test", use_s1=use_s1, use_s2=use_s2, use_RGB=args.use_RGB, IGBP_s=args.simple_scheme, sensor_type=args.sensor_type, use_fusion=args.use_fusion) else: # Assume bigearthnet train_dataGen = BigEarthNet(data_dir, args.label_split_dir, imgTransform=imgTransform, label_type=label_type, threshold=args.threshold, subset="train", use_s1=use_s1, use_s2=use_s2, use_RGB=args.use_RGB, CLC_s=args.simple_scheme, data_size=args.data_size, sensor_type=args.sensor_type, use_fusion=args.use_fusion) val_dataGen = BigEarthNet(data_dir, args.label_split_dir, imgTransform=imgTransform, label_type=label_type, threshold=args.threshold, subset="val", use_s1=use_s1, use_s2=use_s2, use_RGB=args.use_RGB, CLC_s=args.simple_scheme, data_size=args.data_size, sensor_type=args.sensor_type, use_fusion=args.use_fusion) if args.eval: test_dataGen = BigEarthNet(data_dir, args.label_split_dir, imgTransform=imgTransform, label_type=label_type, threshold=args.threshold, subset="test", use_s1=use_s1, use_s2=use_s2, use_RGB=args.use_RGB, CLC_s=args.simple_scheme, sensor_type=args.sensor_type, use_fusion=args.use_fusion) # number of input channels n_inputs = train_dataGen.n_inputs print('input channels =', n_inputs) wandb.config.update({"input_channels": n_inputs}) # set up dataloaders train_data_loader = DataLoader(train_dataGen, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=True, pin_memory=True) val_data_loader = DataLoader(val_dataGen, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False, pin_memory=True) if args.eval: test_data_loader = DataLoader(test_dataGen, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False, pin_memory=True) # -------------------------------- ML setup # cuda use_cuda = torch.cuda.is_available() if use_cuda: torch.backends.cudnn.enabled = True cudnn.benchmark = True # define number of classes if dataset == 'sen12ms': if args.simple_scheme: numCls = 10 ORG_LABELS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'] else: numCls = 17 ORG_LABELS = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17' ] else: if args.simple_scheme: numCls = 19 ORG_LABELS = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19' ] else: numCls = 43 ORG_LABELS = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43' ] print('num_class: ', numCls) wandb.config.update({"n_class": numCls}) # define model if args.model == 'VGG16': model = VGG16(n_inputs, numCls) elif args.model == 'VGG19': model = VGG19(n_inputs, numCls) elif args.model == 'Supervised': model = ResNet50(n_inputs, numCls) elif args.model == 'Supervised_1x1': model = ResNet50_1x1(n_inputs, numCls) elif args.model == 'ResNet101': model = ResNet101(n_inputs, numCls) elif args.model == 'ResNet152': model = ResNet152(n_inputs, numCls) elif args.model == 'DenseNet121': model = DenseNet121(n_inputs, numCls) elif args.model == 'DenseNet161': model = DenseNet161(n_inputs, numCls) elif args.model == 'DenseNet169': model = DenseNet169(n_inputs, numCls) elif args.model == 'DenseNet201': model = DenseNet201(n_inputs, numCls) # finetune moco pre-trained model elif args.model.startswith("Moco"): pt_path = os.path.join(args.pt_dir, f"{args.pt_name}.pth") print(pt_path) assert os.path.exists(pt_path) if args.model == 'Moco': print("transfer backbone weights but no conv 1x1 input module") model = Moco(torch.load(pt_path), n_inputs, numCls) elif args.model == 'Moco_1x1': print("transfer backbone weights and input module weights") model = Moco_1x1(torch.load(pt_path), n_inputs, numCls) elif args.model == 'Moco_1x1RND': print( "transfer backbone weights but initialize input module random with random weights" ) model = Moco_1x1(torch.load(pt_path), n_inputs, numCls) else: # Assume Moco2 at present raise NameError("no model") else: raise NameError("no model") print(model) # move model to GPU if is available if use_cuda: model = model.cuda() # define loss function if label_type == 'multi_label': lossfunc = torch.nn.BCEWithLogitsLoss() else: lossfunc = torch.nn.CrossEntropyLoss() # set up optimizer optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.decay) best_acc = 0 start_epoch = 0 if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) checkpoint_nm = os.path.basename(args.resume) sv_name = checkpoint_nm.split('_')[0] + '_' + checkpoint_nm.split( '_')[1] print('saving file name is ', sv_name) if checkpoint['epoch'] > start_epoch: start_epoch = checkpoint['epoch'] best_acc = checkpoint['best_prec'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) # set up tensorboard logging # train_writer = SummaryWriter(os.path.join(logs_dir, 'runs', sv_name, 'training')) # val_writer = SummaryWriter(os.path.join(logs_dir, 'runs', sv_name, 'val')) # ----------------------------- executing Train/Val. # train network # wandb.watch(model, log="all") scheduler = None if args.use_lr_step: # Ex: If initial Lr is 0.0001, step size is 25, and gamma is 0.1, then lr will be changed for every 20 steps # 0.0001 - first 25 epochs # 0.00001 - 25 to 50 epochs # 0.000001 - 50 to 75 epochs # 0.0000001 - 75 to 100 epochs # https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_step_gamma) for epoch in range(start_epoch, args.epochs): if args.use_lr_step: scheduler.step() print('Epoch {}/{} lr: {}'.format(epoch, args.epochs - 1, optimizer.param_groups[0]['lr'])) else: print('Epoch {}/{}'.format(epoch, args.epochs - 1)) print('-' * 25) train(train_data_loader, model, optimizer, lossfunc, label_type, epoch, use_cuda) micro_f1 = val(val_data_loader, model, optimizer, label_type, epoch, use_cuda) is_best_acc = micro_f1 > best_acc best_acc = max(best_acc, micro_f1) save_checkpoint( { 'epoch': epoch, 'arch': args.model, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'best_prec': best_acc }, is_best_acc, sv_name) wandb.log({'epoch': epoch, 'micro_f1': micro_f1}) print("=============") print("done training") print("=============") if args.eval: eval(test_data_loader, model, label_type, numCls, use_cuda, ORG_LABELS)
out=n_classes, dropout=args.dropout) elif args.encoder == 'resnet34': encoder = models.resnet34() model = GDVM_ResNet(encoder, latent=args.size_latent, out=n_classes, dropout=args.dropout) n_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print(model) print('Total number of params in model: {}'.format(n_params)) model.cuda() optimizer = optim.Adam(model.parameters(), lr=args.lr) poses = [0, 1, 2, 3, 4, 5, 6, 7, 8] eval_thresholds = np.arange(0.05, 1, 0.05) tsfm = ToTensor() oname = 'gdvm_' + args.criterion + args.aus + '_encoder_' + args.encoder + '_alpha_' + \ str(args.alpha) + '_beta_' + \ str(args.beta) + '_latent_' + \ str(args.size_latent) + '_lr_' + str(args.lr) print(oname) scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer, factor=0.1, patience=10, verbose=True, threshold=0.01) logger = Logger('./logs/post_final/'+oname+'/') ''' If just quick test reduce the training/test subjcets and poses to minimum ''' (t_subs_tr, t_subs_te) = (['F001', 'F002', 'F003'], ['F007'] ) if args.quick_test else (None, None)
def main(): """Run training.""" config = yaml.safe_load(open("config.yml")) #training hyperparameters num_epochs = config['num_epochs'] learning_rate = config['learning_rate'] batch_size = config['batch_size'] valid_period = config['valid_period'] #data hyperparameters #extract sample (input sequences with length = stride_len) #for RNN from the givent full trajectory window_len = config['window_len'] stride_len = config['stride_len'] n_times = config['n_times'] x_train, y_train, x_dev, y_dev, x_test, y_test = read_data( window_len, stride_len, n_times) print('Dataset:', x_train.shape, y_train.shape, x_dev.shape, y_dev.shape, x_test.shape, y_test.shape) #create dataset transformed_control_dataset_train = ControlDataset( x_train, y_train, transform=transforms.Compose([ToTensor()])) transformed_control_dataset_dev = ControlDataset( x_dev, y_dev, transform=transforms.Compose([ToTensor()])) #transformed_control_dataset_test = ControlDataset(x_test, y_test, #transform=transforms.Compose([ToTensor()])) # create batch data_train = DataLoader(transformed_control_dataset_train, batch_size=batch_size, shuffle=True, num_workers=1, drop_last=True) data_dev = DataLoader(transformed_control_dataset_dev, batch_size=batch_size, shuffle=False, num_workers=1, drop_last=True) #data_test = DataLoader(transformed_control_dataset_test, batch_size=1, #shuffle=False, num_workers=1, drop_last=True) # Device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print('Device:', device) # save model save_model_name = config['model_name'] print('Save Model name: ', save_model_name) model_save_path = '../checkpoints/' + save_model_name #+ '.pt' ## not pth #test/train mode = int(sys.argv[1]) if mode == 0: #train mode # Model preparation model = SeRNN_FWXX(batch_size, device) print('Model: ', model) model.to(device) pytorch_total_params = sum(p.numel() for p in model.parameters()) print('# of params: ', pytorch_total_params) # multiple GPUs if torch.cuda.device_count() > 1: print("Model uploaded. Number of GPUs: ", torch.cuda.device_count()) #model = nn.DataParallel(model) #set the training loss and optimizer criterion = nn.MSELoss() optimizer = optim.RMSprop(model.parameters(), lr=learning_rate) train_model(model, device, data_train, data_dev, x_dev, y_dev, optimizer, criterion, num_epochs, model_save_path, window_len, stride_len, valid_period) else: # test mode # upload saved model print('Saved Model evaluation with test set') model = torch.jit.load(model_save_path) test_model(model, device, x_test, y_test, 'True', window_len, stride_len)
def main(): args = get_arguments() # configuration CONFIG = Dict(yaml.safe_load(open(args.config))) """ DataLoader """ test_data = PartAffordanceDataset(CONFIG.test_data, config=CONFIG, transform=transforms.Compose([ CenterCrop(CONFIG), ToTensor(), Normalize() ])) test_loader = DataLoader(test_data, batch_size=4, shuffle=True, num_workers=1) test_iter = iter(test_loader) model = models.vgg16_bn(pretrained=False) model.classifier[6] = nn.Linear(in_features=4096, out_features=7, bias=True) model.load_state_dict( torch.load('./result/best_accuracy_model.prm', map_location=lambda storage, loc: storage)) model.to(args.device) while True: sample = test_iter.next() image, label = sample['image'], sample['label'] # show images show_img(torchvision.utils.make_grid(image)) # print labels print('True labels') print(label) with torch.no_grad(): image = image.to(args.device) label = label.to(args.device) h = model(image) h = torch.sigmoid(h) h[h > 0.5] = 1 h[h <= 0.5] = 0 total_num = 7 * len(label) acc_num = torch.sum(h == label) accuracy = float(acc_num) / total_num print('\nPredicted labels') print(h) print('\naccuracy\t{:.3f}'.format(accuracy)) print('\nIf you want to look at more images, input \"c\"') s = input() if s == 'c': continue else: break
sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) train_tfLogger = TFLogger(osp.join(args.logs_dir, 'train')) eval_tfLogger = TFLogger(osp.join(args.logs_dir, 'eval')) # t = [ToTensor()] # train_data = DatasetSyn(args.train_data, "train", transform=Compose(t), sample_shape=args.sample_shape) # train_data.reset_Sample() # train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, # num_workers=args.num_workers) # eval_data = DatasetSyn(args.eval_data, "eval", transform=Compose(t), sample_shape=args.sample_shape) # eval_data.reset_Sample() # eval_loader = DataLoader(eval_data, batch_size=args.batch_size, shuffle=True, # num_workers=args.num_workers) t = [ToTensor()] train_data = DatasetReal(REAL_DATA_PATH, mode="train", transform=Compose(t), sample_shape=args.sample_shape) train_data.reset_Sample() train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers) eval_data = DatasetReal(REAL_DATA_PATH, mode="eval", transform=Compose(t), sample_shape=args.sample_shape) eval_data.reset_Sample()
def train(args): yolo_dataset = YoloDataset(DATASET, "faces.csv", input_size=208, transform=transforms.Compose([ToTensor()])) dataset_indices = set([i for i in range(len(yolo_dataset))]) test_indices = random.sample(dataset_indices, int(args.test_size * len(yolo_dataset))) train_indices = list(dataset_indices - set(test_indices)) trainset = Subset(yolo_dataset, train_indices) testset = Subset(yolo_dataset, train_indices) trainloader = torch.utils.data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=4) validloader = torch.utils.data.DataLoader(testset, batch_size=args.batch_size, shuffle=True, num_workers=4) dataloaders = {TRAIN: trainloader, VALID: validloader} model = MyResnet() if CUDA: model.cuda() optimizer = optim.Adam(model.conv_addition.parameters(), lr=args.lr) saver = CheckpointSaver(args.save_dir_name, max_checkpoints=3) scheduler = lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5) # writer = SummaryWriter(os.path.join(args.save_dir_name, "log")) train_losses, test_losses = [], [] for epoch in range(args.epochs): for phase in dataloaders: if phase == TRAIN: scheduler.step() model.train() else: model.eval() epoch_avg = AVG() logger.info(f"-----------------{phase.upper()}-----------------") for i, data in enumerate(dataloaders[phase]): img, y = data['img'], data['y'] if CUDA: img = img.cuda() y = y.cuda() optimizer.zero_grad() with torch.set_grad_enabled(phase == TRAIN): pred = model(img) y_ = pred.permute((0, 2, 3, 1)) y = y.permute((0, 2, 3, 1)) loss = loss_function(y_, y) epoch_avg.add(loss.item()) # backward + optimize only if in training phase if phase == 'train': loss.backward() optimizer.step() logger.info(f"Epoch: {epoch}, batch: {i}, loss {loss.item()}") logger.info(f"Epoch: {epoch}, average loss: {epoch_avg}") if phase == TRAIN: train_losses.append(str(epoch_avg)) else: test_losses.append(str(epoch_avg)) # writer.add_scalar(f'{phase}_data/average_loss', str(epoch_avg), epoch) if epoch % 20 == 0: saver.save(model, optimizer, epoch) with open(os.path.join(args.save_dir_name, "losses.txt"), 'w') as file: file.write(str(train_losses)) file.write(str(test_losses))