def train(model, optimizer, train_loader, val_loader, epochs=10):
global device
train_loss = 0
train_correct = 0
for e in range(epochs):
model.train()
for batch_idx, (data, labels) in enumerate(train_loader):
data, labels = data.to(device), labels.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(input=output, target=labels)
loss.backward()
optimizer.step()
train_loss += loss.item()
pred = output.max(
dim=1,
keepdim=True)[1] # get the index of the max log-probability
train_correct += pred.eq(labels.view_as(pred)).cpu().sum().item()
train_loss /= len(train_loader.dataset)
train_correct /= len(train_loader.dataset)
if val_loader:
val_loss, val_acc = test(model=model, loader=val_loader)
else:
val_loss, val_acc = None, None
print(
f'Epoch: {e + 1} [{(e + 1)}/{epochs}] Train Loss: {train_loss:.3f}, Val Loss: {val_loss:.3f}'
)
print(
f'Epoch: {e + 1} [{(e + 1)}/{epochs}] Train ACC: {train_correct:.3f}, Val ACC: {val_acc:.3f}'
)
def model_testing(model,
device,
test_dataloader,
test_acc,
test_losses,
misclassified=[]):
model.load_state_dict(torch.load(model_dir)) # Loading the saved model
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for index, (data, target) in enumerate(test_dataloader):
data, target = data.to(device), target.to(device)
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
for d, i, j in zip(data, pred, target):
if i != j:
misclassified.append([d.cpu(), i[0].cpu(), j.cpu()])
test_loss += F.nll_loss(output, target, reduction='sum').item()
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_dataloader.dataset)
test_losses.append(test_loss)
print(
'\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
test_loss, correct, len(test_dataloader.dataset),
100. * correct / len(test_dataloader.dataset)))
test_acc.append(100. * correct / len(test_dataloader.dataset))
return misclassified
def validation_step(self, batch, batch_num):
x, target = batch
output = self.forward(x)
loss = F.nll_loss(output, target)
logger = {'val_loss': loss}
return {'val_loss': loss, 'log': logger}
def training_step(self, batch, batch_num):
x, target = batch
output = self.forward(x)
loss = F.nll_loss(output, target)
logger = {'train_loss': loss}
return {'loss': loss, 'log': logger}
def training_step(self, batch: Tuple[Tensor, Tensor]) -> List[Parameter]:
"""Forward and backward pass"""
features, target = batch
features, target = features.to(config.device), target.to(config.device)
self.optimizer.zero_grad()
pred = self.model(features)
loss: Tensor = F.nll_loss(pred, target)
loss.backward()
self.optimizer.step()
def model_testing(model,
device,
test_dataloader,
test_acc,
test_losses,
misclassified=[]):
# model.load_state_dict(torch.load(model_dir)) # Loading the saved model
model.eval()
test_loss = 0
correct = 0
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
# label = 0
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
with torch.no_grad():
for index, (data, target) in enumerate(test_dataloader):
data, target = data.to(device), target.to(device)
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
# c = (pred == target).squeeze()
# print(c.shape, c[0])
for d, i, j in zip(data, pred, target):
if i != j:
misclassified.append([d.cpu(), i[0].cpu(), j.cpu()])
# for i in range(4):
# label = target[i]
# print(label)
# class_correct[label] += c[i].item()
# class_total[label] += 1
# for i in range(10):
# print('Accuracy of %5s : %2d %%' % (
# classes[i], 100 * class_correct[i] / class_total[i]))
test_loss += F.nll_loss(output, target, reduction='sum').item()
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_dataloader.dataset)
test_losses.append(test_loss)
print(
'\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
test_loss, correct, len(test_dataloader.dataset),
100. * correct / len(test_dataloader.dataset)))
test_acc.append(100. * correct / len(test_dataloader.dataset))
return misclassified
def model_training(model,
device,
train_dataloader,
optimizer,
train_acc,
train_losses,
l1_loss=False):
model.train()
pbar = tqdm(train_dataloader)
correct = 0
processed = 0
running_loss = 0.0
for batch_idx, (data, target) in enumerate(pbar):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
y_pred = model(data)
loss = F.nll_loss(y_pred, target)
# IF L1 Loss
if l1_loss:
lambda_l1 = 0.0001
l1 = 0
for p in model.parameters():
l1 = l1 + p.abs().sum()
loss = loss + lambda_l1 * l1
train_losses.append(loss)
loss.backward()
optimizer.step()
pred = y_pred.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
processed += len(data)
# print statistics
running_loss += loss.item()
# if batch_idx % 500 == 499: # print every 2000 mini-batches
# # print('[%d, %5d] loss: %.3f' %
# # (epoch + 1, i + 1, running_loss / 2000))
pbar.set_description(
desc=
f'Loss={loss.item()} Batch_id={batch_idx} Accuracy={100*correct/processed:0.2f}'
)
# running_loss = 0.0
train_acc.append(100 * correct / processed)
def test(model, loader):
global device
model.eval()
loss = 0
correct = 0
with torch.no_grad():
for data, target in loader:
data, target = data.to(device), target.to(device)
output = model(data)
loss += F.nll_loss(output, target,
reduction='sum').item() # sum up batch loss
pred = output.max(
dim=1,
keepdim=True)[1] # get the index of the max log-probability
correct += pred.eq(target.view_as(pred)).cpu().sum().item()
loss /= len(loader.dataset)
return loss, correct / len(loader.dataset)
def model_training(model,
device,
train_dataloader,
optimizer,
train_acc,
train_losses,
l1_loss=False):
model.train()
pbar = tqdm(train_dataloader)
correct = 0
processed = 0
for batch_idx, (data, target) in enumerate(pbar):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
y_pred = model(data)
loss = F.nll_loss(y_pred, target)
# IF L1 Loss
if l1_loss:
lambda_l1 = 0.0001
l1 = 0
for p in model.parameters():
l1 = l1 + p.abs().sum()
loss = loss + lambda_l1 * l1
train_losses.append(loss)
loss.backward()
optimizer.step()
pred = y_pred.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
processed += len(data)
pbar.set_description(
desc=
f'Loss={loss.item()} Batch_id={batch_idx} Accuracy={100*correct/processed:0.2f}'
)
train_acc.append(100 * correct / processed)
torch.save(model.state_dict(), model_dir)
def test(network, testloader, writer, epoch, i):
network.eval()
test_loss = 0
correct = 0
test_losses = []
with torch.no_grad():
for data, target in testloader:
data = data.to(network.device).cuda(network.device)
target = target.to(network.device).cuda(network.device)
output = network(data)
test_loss += F.nll_loss(output, target, size_average=False).item()
pred = output.data.max(1, keepdim=True)[1]
correct += pred.eq(target.data.view_as(pred)).sum()
test_loss /= len(testloader.dataset)
writer.add_scalar('Test loss', test_loss, epoch * len(testloader) + i)
test_losses.append(test_loss)
print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.
format(test_loss, correct, len(testloader.dataset),
100. * correct / len(testloader.dataset)))
return
