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()))