def main(): """ Main function wrapper for demo script """ random.seed(args["SEED"]) np.random.seed(args["SEED"]) torch.manual_seed(args["SEED"]) if torch.cuda.is_available(): device = torch.device("cuda") else: device = torch.device("cpu") if args["TRAINED_WEIGHTS_FILE"] is not None: print("Trained Weights File: %s" % (args["TRAINED_WEIGHTS_FILE"])) print("Demo Directory: %s" % (args["DEMO_DIRECTORY"])) model = MyNet() model.load_state_dict( torch.load( args["CODE_DIRECTORY"] + args["TRAINED_WEIGHTS_FILE"], map_location=device, )) model.to(device) print("Running Demo ....") for root, dirs, files in os.walk(args["DEMO_DIRECTORY"]): for file in files: sampleFile = os.path.join(root, file) preprocess_sample(sampleFile) inp, _ = prepare_input(sampleFile) inputBatch = torch.unsqueeze(inp, dim=0) inputBatch = (inputBatch.float()).to(device) model.eval() with torch.no_grad(): outputBatch = model(inputBatch) predictionBatch = decode(outputBatch) pred = predictionBatch[0][:] print("File: %s" % (file)) print("Prediction: %s" % (pred)) print("\n") print("Demo Completed.") else: print("Path to trained weights file not specified.") return
def __init__(self, hparams): super(MyModel, self).__init__() self.hparams = hparams self.batch_size = hparams.batch_size self._create_dataset() # self.model = MyNet(len(self.dx_voc.word2idx)+len( # self.rx_voc.word2idx), hparams.h_dim, hparams.heads, hparams.has_attn, hparams.has_hidden_attn) self.model = MyNet( len(self.dx_voc.word2idx) + len(self.rx_voc.word2idx) + 1, hparams.h_dim)
def __init__(self, hparams): super(MyModel, self).__init__() self.hparams = hparams self.batch_size = hparams.batch_size self._create_dataset() self.model = MyNet(len(self.dx_voc.word2idx) + len(self.rx_voc.word2idx), hparams.h_dim, n_layers=hparams.n_layers, only_rnn=hparams.only_rnn, is_multi=hparams.is_multi)
def load_model(self): """ :return: """ # TODO 1 加载模型 use_cuda = self.use_cuda if self.o_net_path is not None: print('=======> loading') net = MyNet(use_cuda=False) net.load_state_dict(torch.load(self.o_net_path)) if (use_cuda): net.to('cpu') net.eval() # TODO 2 准备好数据 img_list = os.listdir(self.image_dir) for idx, item in enumerate(img_list): _img = Image.open(os.path.join(self.image_dir, item)) parse_result = self.parse_image_name(item) landmark_and_format = parse_result['landmark_and_format'] name = parse_result['name'] img = self.transforms(_img) img = img.unsqueeze(0) pred = net(img) pred = pred * 192 # pred = pred.detach().numpy() print('the pred landmark is :', pred) print("=" * 20) # # print(pred.shape) # # print(landmark) # try: self.save_pred(_img, name, landmark_and_format, pred.detach().numpy()) # self.visualize(_img, np.array(landmark)) # self.visualize(_img, pred.detach().numpy()) # # print(pred) except: print('Error:', item)
def main(): """ Main function wrapper for testing script. """ random.seed(args["SEED"]) np.random.seed(args["SEED"]) torch.manual_seed(args["SEED"]) if torch.cuda.is_available(): device = torch.device("cuda") kwargs = {"num_workers": args["NUM_WORKERS"], "pin_memory": True} else: device = torch.device("cpu") kwargs = {} if args["TRAINED_WEIGHTS_FILE"] is not None: testData = MyDataset("test", datadir=args["DATA_DIRECTORY"]) testLoader = DataLoader(testData, batch_size=args["BATCH_SIZE"], shuffle=True, **kwargs) print("Trained Weights File: %s" % (args["TRAINED_WEIGHTS_FILE"])) model = MyNet() model.load_state_dict( torch.load( args["CODE_DIRECTORY"] + args["TRAINED_WEIGHTS_FILE"], map_location=device, )) model.to(device) criterion = MyLoss() regularizer = L2Regularizer(lambd=args["LAMBDA"]) print("Testing the trained model ....") testLoss, testMetric = evaluate(model, testLoader, criterion, regularizer, device) print("| Test Loss: %.6f || Test Metric: %.3f |" % (testLoss, testMetric)) print("Testing Done.") else: print("Path to the trained weights file not specified.") return
def main(): # Load dataset print('Loading dataset ...\n') dataset_train = Dataset(train=True) dataset_val = Dataset(train=False) loader_train = DataLoader(dataset=dataset_train, num_workers=4, batch_size=opt.batchSize, shuffle=True) print("# of training samples: %d\n" % int(len(dataset_train))) # Build model # net = DnCNN(channels=1, num_of_layers=opt.num_of_layers) net = MyNet() # net.apply(weights_init_kaiming) s = MS_SSIM(data_range=1., channel=1) criterion = nn.L1Loss() # Move to GPU device_ids = [0] model = nn.DataParallel(net, device_ids=device_ids).cuda() criterion.cuda() summary(model, (1, 96, 96)) # Optimizer optimizer = optim.Adam(model.parameters(), lr=opt.lr) # training writer = SummaryWriter(opt.outf) step = 0 noiseL_B = [0, 55] # ignored when opt.mode=='S' for epoch in range(opt.epochs): current_lr = opt.lr * (0.5**(epoch // opt.step)) # set learning rate for param_group in optimizer.param_groups: param_group["lr"] = current_lr print('learning rate %f' % current_lr) # train for i, data in enumerate(loader_train, 0): # training step model.train() model.zero_grad() optimizer.zero_grad() img_train = data if opt.mode == 'S': noise = torch.FloatTensor(img_train.size()).normal_( mean=0, std=opt.noiseL / 255.) if opt.mode == 'B': noise = torch.zeros(img_train.size()) stdN = np.random.uniform(noiseL_B[0], noiseL_B[1], size=noise.size()[0]) for n in range(noise.size()[0]): sizeN = noise[0, :, :, :].size() noise[n, :, :, :] = torch.FloatTensor(sizeN).normal_( mean=0, std=stdN[n] / 255.) imgn_train = img_train + noise img_train, imgn_train = Variable(img_train.cuda()), Variable( imgn_train.cuda()) noise = Variable(noise.cuda()) out_train = model(imgn_train) # loss = criterion(out_train, noise) / (imgn_train.size()[0]*2) loss = criterion(out_train, img_train) loss.backward() # clip = 0.01 / current_lr # nn.utils.clip_grad_norm(model.parameters(), clip) optimizer.step() # results model.eval() # out_train = torch.clamp(imgn_train-model(imgn_train), 0., 1.) out_train = torch.clamp(model(imgn_train), 0., 1.) psnr_train = batch_PSNR(out_train, img_train, 1.) ''' print("[epoch %d][%d/%d] loss: %.4f PSNR_train: %.4f" % (epoch+1, i+1, len(loader_train), loss.item(), psnr_train)) ''' # if you are using older version of PyTorch, you may need to change loss.item() to loss.data[0] if i % int(len(loader_train) // 1) == 0: # the end of each epoch model.eval() # validate psnr_val = 0 for k in range(len(dataset_val)): img_val = torch.unsqueeze(dataset_val[k], 0) noise = torch.FloatTensor(img_val.size()).normal_( mean=0, std=opt.val_noiseL / 255.) imgn_val = img_val + noise with torch.no_grad(): img_val, imgn_val = Variable(img_val.cuda()), Variable( imgn_val.cuda()) # out_val = torch.clamp(imgn_val-model(imgn_val), 0., 1.) out_val = torch.clamp(model(imgn_val), 0., 1.) psnr_val += batch_PSNR(out_val, img_val, 1.) psnr_val /= len(dataset_val) # print("\n[epoch %d] PSNR_val: %.4f" % (epoch+1, psnr_val)) print("[epoch %d][%d/%d] loss: %.4f PSNR_val: %.4f" % (epoch + 1, i + 1, len(loader_train), loss.item(), psnr_val)) torch.save( model.state_dict(), os.path.join(opt.outf, 'net_' + str(round(psnr_val, 4)) + '.pth')) # Log the scalar values writer.add_scalar('loss', loss.item(), step) writer.add_scalar('PSNR on training data', psnr_train, step) step += 1 '''
def main(): """ Main function wrapper for training script. """ matplotlib.use("Agg") random.seed(args["SEED"]) np.random.seed(args["SEED"]) torch.manual_seed(args["SEED"]) if torch.cuda.is_available(): device = torch.device("cuda") kwargs = {"num_workers": args["NUM_WORKERS"], "pin_memory": True} else: device = torch.device("cpu") kwargs = {} trainData = MyDataset("train", datadir=args["DATA_DIRECTORY"]) valSize = int(args["VALIDATION_SPLIT"] * len(trainData)) trainSize = len(trainData) - valSize trainData, valData = random_split(trainData, [trainSize, valSize]) trainLoader = DataLoader( trainData, batch_size=args["BATCH_SIZE"], shuffle=True, **kwargs ) valLoader = DataLoader( valData, batch_size=args["BATCH_SIZE"], shuffle=True, **kwargs ) model = MyNet() model.to(device) optimizer = optim.Adam( model.parameters(), lr=args["LEARNING_RATE"], betas=(args["MOMENTUM1"], args["MOMENTUM2"]), ) scheduler = optim.lr_scheduler.ExponentialLR( optimizer, gamma=args["LR_DECAY"] ) criterion = MyLoss() regularizer = L2Regularizer(lambd=args["LAMBDA"]) if os.path.exists(args["CODE_DIRECTORY"] + "/checkpoints"): while True: char = input( "Continue and remove the 'checkpoints' directory? y/n: " ) if char == "y": break if char == "n": sys.exit() else: print("Invalid input") shutil.rmtree(args["CODE_DIRECTORY"] + "/checkpoints") os.mkdir(args["CODE_DIRECTORY"] + "/checkpoints") os.mkdir(args["CODE_DIRECTORY"] + "/checkpoints/plots") os.mkdir(args["CODE_DIRECTORY"] + "/checkpoints/weights") if args["PRETRAINED_WEIGHTS_FILE"] is not None: print( "Pretrained Weights File: %s" % (args["PRETRAINED_WEIGHTS_FILE"]) ) print("Loading the pretrained weights ....") model.load_state_dict( torch.load( args["CODE_DIRECTORY"] + args["PRETRAINED_WEIGHTS_FILE"], map_location=device, ) ) model.to(device) print("Loading Done.") trainingLossCurve = list() validationLossCurve = list() trainingMetricCurve = list() validationMetricCurve = list() numTotalParams, numTrainableParams = num_params(model) print("Number of total parameters in the model = %d" % (numTotalParams)) print( "Number of trainable parameters in the model = %d" % (numTrainableParams) ) print("Training the model ....") for epoch in range(1, args["NUM_EPOCHS"] + 1): trainingLoss, trainingMetric = train( model, trainLoader, optimizer, criterion, regularizer, device ) trainingLossCurve.append(trainingLoss) trainingMetricCurve.append(trainingMetric) validationLoss, validationMetric = evaluate( model, valLoader, criterion, regularizer, device ) validationLossCurve.append(validationLoss) validationMetricCurve.append(validationMetric) print( ( "| Epoch: %03d |" "| Tr.Loss: %.6f Val.Loss: %.6f |" "| Tr.Metric: %.3f Val.Metric: %.3f |" ) % ( epoch, trainingLoss, validationLoss, trainingMetric, validationMetric, ) ) scheduler.step() if epoch % args["SAVE_FREQUENCY"] == 0: savePath = ( args["CODE_DIRECTORY"] + "/checkpoints/weights/epoch_{:04d}-metric_{:.3f}.pt" ).format(epoch, validationMetric) torch.save(model.state_dict(), savePath) plt.figure() plt.title("Loss Curves") plt.xlabel("Epoch No.") plt.ylabel("Loss value") plt.plot( list(range(1, len(trainingLossCurve) + 1)), trainingLossCurve, "blue", label="Train", ) plt.plot( list(range(1, len(validationLossCurve) + 1)), validationLossCurve, "red", label="Validation", ) plt.legend() plt.savefig( ( args["CODE_DIRECTORY"] + "/checkpoints/plots/epoch_{:04d}_loss.png" ).format(epoch) ) plt.close() plt.figure() plt.title("Metric Curves") plt.xlabel("Epoch No.") plt.ylabel("Metric") plt.plot( list(range(1, len(trainingMetricCurve) + 1)), trainingMetricCurve, "blue", label="Train", ) plt.plot( list(range(1, len(validationMetricCurve) + 1)), validationMetricCurve, "red", label="Validation", ) plt.legend() plt.savefig( ( args["CODE_DIRECTORY"] + "/checkpoints/plots/epoch_{:04d}_metric.png" ).format(epoch) ) plt.close() print("Training Done.") return
def train(**kwargs): # 1. configure model cfg._parse(kwargs) model = MyNet() if cfg.load_model_path: model.load_state_dict(torch.load(cfg.load_model_path)) if cfg.multi_gpu: model = parallel.DataParallel(model) if cfg.use_gpu: model.cuda() # 2. prepare data train_data = SN(root=cfg.train_data_root, crop_size=cfg.crop_size) train_loader = DataLoader(train_data, batch_size=cfg.batch_size, shuffle=True) # 3. criterion (already imported) and optimizer lr = cfg.lr # optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=cfg.weight_decay) optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=cfg.momentum) # 4. meters loss_meter = meter.AverageValueMeter() previous_loss = 1e10 # train for epoch in range(cfg.max_epoch): print('epoch %s: ===========================' % epoch) loss_meter.reset() for ii, (data, label_group) in tqdm(enumerate(train_loader)): # train model if cfg.use_gpu: data = data.cuda() label_group = [label.cuda() for label in label_group] data = Variable(data).float() label_group = [Variable(label) for label in label_group] optimizer.zero_grad() score = model(data) # for item in score: # print(item) loss = criterion(score, label_group, batch_size=cfg.batch_size, neg_pos_ratio=cfg.neg_pos_ratio) loss.backward() optimizer.step() # meters update and print loss_meter.add(loss.item()) if (ii + 1) % cfg.print_freq == 0: print(loss_meter.value()[0]) if (epoch + 1) % cfg.save_freq == 0: torch.save(model.module.state_dict(), f'./checkpoints/last.pth') # update learning rate if loss_meter.value()[0] > previous_loss: lr = lr * cfg.lr_decay # 第二种降低学习率的方法:不会有moment等信息的丢失 for param_group in optimizer.param_groups: param_group['lr'] = lr previous_loss = loss_meter.value()[0]
def visualize_net(): x = torch.rand((1, 3, 768, 1024)) model = MyNet() with SummaryWriter(comment='MyNet') as w: w.add_graph(model, (x, ))
G = tg.utils.to_networkx(graph_dataset[0]) # G = nx.relabel_nodes(G, graph_dataset.dataset_.country_by_idx) nx.draw(G, pos=graph_dataset.dataset_.location_getter(), labels=dataset.country_by_idx, with_labels=True) plt.show() pca = PCA(n_components=16) data = dataset.df[[ c for c in dataset.df.columns if isinstance(c, dt.datetime) ]].astype(float).T pca.fit(data) animator = AnimPlot('train loss', 'test loss') my_net = MyNet() optimizer = torch.optim.Adam(my_net.parameters(), lr=0.0001) train_loader = torch.utils.data.DataLoader(train, 64) test_loader = torch.utils.data.DataLoader(test, 10) for epoch_no in range(10000): with torch.no_grad(): test_loss = 0.0 for X, target in test_loader: transformed = torch.tensor(pca.transform(X), dtype=torch.float32) predicted = my_net(transformed)