def train_model(dataloader, model, criterion, optimizer, device, num_epochs, dataset_size): model.to(device) since = time.time() best_model_wts = copy.deepcopy(model.state_dict()) best_acc = 0.0 for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs - 1)) print('-' * 10) for phase in ['train', 'test']: if phase == 'train': model.train() else: model.eval() running_loss = 0.0 running_corrects = 0 for inputs, labels in tqdm(dataloaders[phase]): inputs = inputs.to(device) labels = labels.to(device) optimizer.zero_grad() with torch.set_grad_enabled(phase == 'train'): outputs = model(inputs) _, pred = torch.max(outputs, 1) loss = criterion(outputs, labels) if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(pred == labels.data) epoch_loss = running_loss / dataset_size[phase] epoch_acc = running_corrects.double() / dataset_size[phase] print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc)) if phase == 'test' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) torch.save( best_model_wts, osp.join(Config['root_path'], Config['checkpoint_path'], 'model.pth')) print('Model saved at: {}'.format( osp.join(Config['root_path'], Config['checkpoint_path'], 'model.pth'))) time_elapsed = time.time() - since print('Time taken to complete training: {:0f}m {:0f}s'.format( time_elapsed // 60, time_elapsed % 60)) print('Best acc: {:.4f}'.format(best_acc))
def train_model(dataloader, model, optimizer, device, num_epochs, dataset_size): model.to(device) for epoch in range(num_epochs): print('-' * 15) print('Epoch {}/{}'.format(epoch + 1, num_epochs)) for phase in ['train', 'val']: #train and validate every epoch if phase == 'train': model.train() else: model.eval() running_loss = 0.0 for i in tqdm(range(len(dataloader[phase].dataset[0]))): inputs = dataloader[phase].dataset[0][i] #print(inputs.shape) labels = dataloader[phase].dataset[1][i] #print(labels.shape) inputs = inputs.unsqueeze(0) labels = labels.unsqueeze(0) inputs = inputs.to(device) labels = labels.to(device) optimizer.zero_grad() with torch.set_grad_enabled(phase == 'train'): outputs = model(inputs) loss = criterion(outputs, labels) if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) epoch_loss = running_loss / dataset_size[phase] print('{} Loss: {:.4f} '.format(phase, epoch_loss)) # save the model #saved_model = copy.deepcopy(model.state_dict()) with open(osp.join(Config['path'], "my_model.pth"), "wb") as output_file: torch.save(model.state_dict(), output_file)
im_gt = utils.modcrop(im_gt, opt.upscale_factor) # im_l = cv2.imread(opt.test_lr_folder + imname.split('/')[-1].split('.')[0] + 'x' + str(opt.upscale_factor) + ext, cv2.IMREAD_COLOR)[:, :, [2, 1, 0]] # BGR to RGB # im_l = cv2.imread(opt.test_lr_folder + imname.split('/')[-1].split('.')[0] + ext, cv2.IMREAD_COLOR)[:, :, [2, 1, 0]] # BGR to RGB im_l = sio.imread(opt.test_lr_folder + '/' + imname.split('/')[-1]) # RGB if len(im_gt.shape) < 3: im_gt = im_gt[..., np.newaxis] im_gt = np.concatenate([im_gt] * 3, 2) im_l = im_l[..., np.newaxis] im_l = np.concatenate([im_l] * 3, 2) im_input = im_l / 255.0 im_input = np.transpose(im_input, (2, 0, 1)) im_input = im_input[np.newaxis, ...] im_input = torch.from_numpy(im_input).float() if cuda: model = model.to(device) im_input = im_input.to(device) with torch.no_grad(): start.record() out = model(im_input) end.record() torch.cuda.synchronize() time_list[i] = start.elapsed_time(end) # milliseconds out_img = utils.tensor2np(out.detach()[0]) crop_size = opt.upscale_factor cropped_sr_img = utils.shave(out_img, crop_size) cropped_gt_img = utils.shave(im_gt, crop_size) if opt.is_y is True: im_label = utils.quantize(sc.rgb2ycbcr(cropped_gt_img)[:, :, 0])
def train_model(dataloader, model, criterion, optimizer, device, num_epochs, dataset_size): model.to(device) since = time.time() best_model_wts = copy.deepcopy(model.state_dict()) best_acc = 0.0 acc_list = [] loss_list = [] test_acc_list= [] test_loss_list = [] for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs - 1)) print('-' * 10) for phase in ['train', 'test']: if phase=='train': model.train() else: model.eval() running_loss = 0.0 running_corrects = 0 for input1, input2, labels in tqdm(dataloaders[phase], position=0, leave=True): input1 = input1.to(device) input2 = input2.to(device) labels = labels.to(device) optimizer.zero_grad() with torch.set_grad_enabled(phase=='train'): outputs = model(input1, input2) outputs = torch.reshape(outputs, (outputs.shape[0],)) outputs = outputs.type(torch.DoubleTensor) labels = labels.type(torch.DoubleTensor) pred = [] for i in outputs: if i>0.5: pred.append(0) else: pred.append(1) pred = torch.FloatTensor(pred) loss = criterion(outputs,labels) if phase=='train': loss.backward() optimizer.step() running_loss += loss.item() * input1.size(0) running_corrects += torch.sum(pred==labels.data) epoch_loss = running_loss / dataset_size[phase] epoch_acc = running_corrects.double() / dataset_size[phase] if phase=='train': acc_list.append(epoch_acc) loss_list.append(epoch_loss) elif phase=='test': test_acc_list.append(epoch_acc) test_loss_list.append(epoch_loss) print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc)) if phase=='test' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) torch.save(best_model_wts, osp.join(Config['root_path'], Config['checkpoint_path'], 'model.pth')) print('Model saved at: {}'.format(osp.join(Config['root_path'], Config['checkpoint_path'], 'model.pth'))) time_elapsed = time.time() - since print('Time taken to complete training: {:0f}m {:0f}s'.format(time_elapsed // 60, time_elapsed % 60)) print('Best acc: {:.4f}'.format(best_acc)) np.savetxt('acc_list.txt',acc_list) np.savetxt('test_acc_list.txt',test_acc_list) np.savetxt('loss_list.txt',loss_list) np.savetxt('test_loss_list.txt',test_loss_list)
dest='resume_training', required=True, help='whether to resume training or not', choices=['yes', 'no']) parser.add_argument('-p', '--model-path', dest='model_path', help='path to trained model for resuming training') args = vars(parser.parse_args()) print(f"\nSAVING CHECKPOINT EVERY {config.SAVE_EVERY} EPOCHS\n") print(f"LOGGING EVERY {config.LOG_EVERY} EPOCHS\n") epochs = config.EPOCHS model.to(config.DEVICE) # initialie `Trainer` if resuming training if args['resume_training'] == 'yes': if args['model_path'] == None: sys.exit('\nPLEASE PROVIDE A MODEL TO RESUME TRAINING FROM!') trainer = Trainer(model, train_data_loader, train_dataset, valid_data_loader, valid_dataset, config.CLASSES_TO_TRAIN, epochs, config.DEVICE, config.LR, args['resume_training'],
def train_model(model, device, train_data_loader, valid_data_loader, criterion, optimizer, scheduler, num_epochs=5): """ training Parameters -------------- model : DogClassificationModel Network model to be trained. device : device cuda or cpu train_data_loader : dataloader dataloader for training valid_data_loader : dataloader dataloader for validation criterion : Loss function. optimizer : Optimizer. scheduler : Learning rate scheduler. num_epochs : int The number of epochs. Returns -------------- model : DogClassificationModel Trained model. """ since = time.time() model = model.to(device) best_model_wts = copy.deepcopy(model.state_dict()) best_acc = 0.0 for epoch in range(num_epochs): bar = tqdm(total=len(train_data_loader)) bar.set_description("Epoch: {}/{}".format(epoch + 1, num_epochs)) """ Training Phase """ model.train() running_loss = 0.0 running_corrects = 0 for j, (inputs, labels) in enumerate(train_data_loader): optimizer.zero_grad() tmp_loss_item = 0.0 # training with torch.set_grad_enabled(True): outputs = model(inputs.to(device)) torch.cuda.empty_cache() _, preds = torch.max(outputs, 1) loss = criterion(outputs, labels.to(device)) # backward + optimize only if in training phase loss.backward() optimizer.step() tmp_loss_item = loss.item() # statistics running_loss += tmp_loss_item * inputs.size(0) running_corrects += torch.sum(preds.to('cpu') == labels.data) # progress bar bar.update(1) tmp_loss = float(running_loss / (j + 1)) / 32 # 32: mini-batch size tmp_acc = float(running_corrects // (j + 1)) / 32 bar.set_postfix(OrderedDict(loss=tmp_loss, acc=tmp_acc)) # update learning rate scheduler scheduler.step() dataset_size = len(train_data_loader.dataset) epoch_loss = running_loss / dataset_size epoch_acc = running_corrects.double() / dataset_size """ Validation Phase """ model.eval() # Set model to validation mode val_running_loss = 0.0 val_running_corrects = 0 # Iterate over data. for inputs, labels in valid_data_loader: val_inputs = inputs.to(device) val_labels = labels.to(device) # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.no_grad(): val_outputs = model(val_inputs) _, preds = torch.max(val_outputs, 1) loss = criterion(val_outputs, val_labels) # statistics val_running_loss += loss.item() * val_inputs.size(0) val_running_corrects += torch.sum(preds == val_labels.data) dataset_size = len(valid_data_loader.dataset) val_epoch_loss = val_running_loss / dataset_size val_epoch_acc = val_running_corrects.double() / dataset_size print('VALIDATION Loss: {:.4f} Acc: {:.4f}'.format( val_epoch_loss, val_epoch_acc)) print("Elapsed time: {} [sec]".format(time.time() - since)) # deep copy the model if val_epoch_acc > best_acc: best_acc = val_epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) time_elapsed = time.time() - since print('Training complete in {:.0f}m {:.0f}s'.format( time_elapsed // 60, time_elapsed % 60)) print('Best val Acc: {:4f}'.format(best_acc)) # load best model weights model.load_state_dict(best_model_wts) return model
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder( args.data + '/train_images', transform=data_transforms), batch_size=args.batch_size, shuffle=True, num_workers=1) val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( args.data + '/val_images', transform=data_transforms), batch_size=args.batch_size, shuffle=False, num_workers=1) ### Neural Network and Optimizer # We define neural net in model.py so that it can be reused by the evaluate.py script from model import model, optimizer model.to(device) def train(epoch): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step() if batch_idx % args.log_interval == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item()))