def test_model(device, model, testloader):
'''
Test a trained model.
'''
with active_session():
#test phase
accuracy = 0
with torch.no_grad():
print('\n### Start of network test! ###')
model.eval()
for image, label in testloader:
image, label = image.to(device), label.to(device)
test_log_ps = model(image)
test_ps = torch.exp(test_log_ps)
top_p, top_class = test_ps.topk(1, dim=1)
equals = top_class == label.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor))
average_accuracy = accuracy / len(testloader)
print('\tAverage Test Set Accuracy: {:.2f}%'.format(average_accuracy.item()*100))
print('### End of network test! ###\n')
def main():
parser = argparse.ArgumentParser()
parser.add_argument('data_dir', help='Path to image files.', type=str)
parser.add_argument('--save_dir', dest="save_dir", type=str, action="store",
default="./", help="Directory to save checkpoints")
parser.add_argument('--arch', dest="arch", type=str, action="store",
default="densenet121", help="Architecture type default is densenet121")
parser.add_argument('--learning_rate', dest="learning_rate", type=float, action="store", default=0.003)
parser.add_argument('--epochs', dest="epochs", type=int, action="store", default=5)
parser.add_argument('--hidden_units', dest="hidden_units", type=int, nargs='+', action="store", default=[512])
parser.add_argument('--gpu', action='store_true')
num_outputs = 102
args = parser.parse_args()
device = utils.get_device(args.gpu)
dataloaders, class_to_idx = utils.get_dataloaders(args.data_dir)
model, optimizer, hidden_layers = utils.get_model_and_optimizer(
args.arch, args.learning_rate,
num_outputs, device, args.hidden_units
)
if not model:
return
model.class_to_idx = class_to_idx
with active_session():
utils.train_model(
model, optimizer, dataloaders, device,
epochs=args.epochs, print_every=20
)
utils.save_model(model, args.learning_rate, args.epochs, optimizer, num_outputs, args.hidden_units, args.save_dir)
def main():
#import json
with open('cat_to_name.json', 'r') as f:
cat_to_name = json.load(f)
if args.arch.lower() == 'vgg11':
model = models.vgg11(pretrained=True)
# Freeze parameters so we don't backprop through them
for param in model.parameters():
param.requires_grad = False
model.classifier = nn.Sequential(
nn.Linear(25088, args.hidden_units), nn.ReLU(), nn.Dropout(0.2),
nn.Linear(args.hidden_units, args.hidden_units // 3), nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(args.hidden_units // 3, args.hidden_units // 9),
nn.ReLU(), nn.Dropout(0.2), nn.Linear(args.hidden_units // 9, 102),
nn.LogSoftmax(dim=1))
elif args.arch.lower() == 'alexnet':
model = models.alexnet(pretrained=True)
# Freeze parameters so we don't backprop through them
for param in model.parameters():
param.requires_grad = False
model.classifier = nn.Sequential(
nn.Linear(9216, args.hidden_units), nn.ReLU(), nn.Dropout(0.2),
nn.Linear(args.hidden_units, args.hidden_units // 3), nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(args.hidden_units // 3, args.hidden_units // 9),
nn.ReLU(), nn.Dropout(0.2), nn.Linear(args.hidden_units // 9, 102),
nn.LogSoftmax(dim=1))
else:
print('Please choose your model architecture to be vgg11 or alexnet')
# Only train the classifier parameters, feature parameters are frozen
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.classifier.parameters(),
lr=args.learning_rate,
momentum=0.9)
model.to(device)
with active_session():
# do long-running work here
model = train_model(model,
criterion,
optimizer,
num_epochs=args.epochs)
# Save the checkpoint
model.class_to_idx = image_datasets['train'].class_to_idx
checkpoint = {
'epochs': args.epochs,
'class_to_idx': model.class_to_idx,
'state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict()
}
torch.save(checkpoint, args.save_dir)
def train_model(model, train_dataloader, criterion, optimizer,
validation_dataloader, last_epoch):
steps = 0
running_loss = 0
PRINT_EVERY = 20
first_epoch = model.next_epoch
with active_session():
for epoch in range(first_epoch, last_epoch + 1):
for inputs, labels in train_dataloader:
steps += 1
# Move input and label tensors to the default device
inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % PRINT_EVERY == 0:
validation_loss, validation_accuracy = evaluate_model(
model, validation_dataloader, criterion)
print(f"Epoch {epoch}/{last_epoch}.. "
f"Train loss: {running_loss/PRINT_EVERY:.3f}.. "
f"Validation loss: {validation_loss:.3f}.. "
f"Validation accuracy: {validation_accuracy:.3f}")
running_loss = 0
model.train()
model.next_epoch = last_epoch + 1
return model, optimizer
def train_model(model, criterion, optimizer, epoch):
'''train the model, then keep the model with the best accuracy with the copy module'''
with active_session(): #for computations lasting more than 30 minutes, put code indented into this to keep session open
if args.gpu:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if (torch.cuda.is_available() == False):
print ("CUDA not available, proceeding with CPU instead")
else:
device = torch.device("cpu")
epochs = epoch
steps = 0
running_loss = 0
print_every = 5
model.to(device);
top_model = copy.deepcopy(model.state_dict())
top_accuracy = 0.
for epoch in range(epochs): #train the model with training set over x epochs
for inputs, labels in trainloader:
steps += 1
# Move input and label tensors to the default device
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0: #every x steps, use validation set to check that model is learning
valid_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for vinputs, vlabels in validloader:
vinputs, vlabels = vinputs.to(device), vlabels.to(device)
vlogps = model.forward(vinputs)
batch_loss = criterion(vlogps, vlabels)
valid_loss += batch_loss.item()
# Calculate accuracy
ps = torch.exp(vlogps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == vlabels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
if accuracy > top_accuracy: #if new best model: copy it
top_accuracy = accuracy
top_model = copy.deepcopy(model.state_dict())
print(f"Epoch {epoch+1}/{epochs}.. "
f"Train loss: {running_loss/print_every:.3f}.. "
f"Validation loss: {valid_loss/len(validloader):.3f}.. "
f"Validation accuracy: {accuracy/len(validloader):.3f}")
running_loss = 0
model.train()
model.load_state_dict(top_model)
model.to('cpu')
def train_classifier(model, optimizer, criterion, trainloader, testloader, device, arg_epochs):
with active_session():
epochs = arg_epochs
steps = 0
print_every = 40
model.to(device);
for epoch in range(epochs):
model.train()
running_loss = 0
for images, labels in iter(trainloader):
steps +=1
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
output = model.forward(images)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
model.eval()
#Turn off gradients for validation
with torch.no_grad():
test_loss = 0
accuracy = 0
for images, labels in iter(testloader):
images, labels = images.to(device), labels.to(device)
output = model.forward(images)
batch_loss = criterion(output, labels)
test_loss += batch_loss.item()
#Calculate accuracy
ps = torch.exp(output)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
print("Epoch {}/{}".format(epoch+1, epochs),
"Train loss: {:.3f}".format(running_loss/print_every),
"Test loss: {:.3f} ".format(test_loss/len(testloader)),
"Test accuracy: {:.3f}".format(accuracy/len(testloader)))
running_loss = 0
model.train()
def start_pipeline(args):
dataloaders = read_data(args.data_directory)
device = torch.device("cuda:0" if (
torch.cuda.is_available() and args.use_gpu) else "cpu")
print("Device being used: {}".format(device))
print(
"Hyperparameters of network:\n Architecture: %s, Hidden Units in Classifier: %d, Learning Rate = %f, Epochs = %d"
% (args.architecture, args.hidden_units, args.learning_rate,
args.epochs))
with active_session():
model, optimizer, best_epoch_num, criterion = build_model(
device, dataloaders, args.architecture, args.hidden_units,
args.learning_rate, args.epochs)
valid_loss, valid_accuracy = get_loss_and_accuracy(
model, dataloaders["validation"], criterion, device)
print('Validation Loss: %.6f Validation Accuracy: %.2f %%' %
(valid_loss, valid_accuracy))
test_loss, test_accuracy = get_loss_and_accuracy(model,
dataloaders["test"],
criterion, device)
print('Test Loss: %.6f Test Accuracy: %.2f %%' %
(test_loss, test_accuracy))
model.class_to_idx = dataloaders['train'].dataset.class_to_idx
save_model(args.save_file_path, model, args.architecture, optimizer,
best_epoch_num)
return model, optimizer
def testing_accuracy(model, optimizer, criterion, test_loader):
# Find testing accuracy
try:
steps = 0
accuracy = 0
cuda = torch.cuda.is_available()
if cuda:
model.cuda()
else:
model.cpu()
with active_session():
for inputs, labels in iter(test_loader):
steps += 1
# Move input and label tensors to the default device
if cuda == True:
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
else:
inputs, labels = Variable(inputs), Variable(labels)
output = model.forward(inputs)
ps = torch.exp(output).data
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
print("\Testing Accuracy: {:.3f}".format(accuracy/steps))
except ValueError as e:
print("Exception occurred: {}".format(e))
print('-'*40)
return model
def main():
"""Program main function"""
args = read_args() # Read command line arguments
# Get the data loaders
train_loader, valid_loader, class_to_idx = get_data_loaders(args.data_dir)
# Get the pretrained model and the model features output size
model, input_size = get_arch_model(args.arch)
hidden_layers = get_hidden_layers(args.hidden_layers)
# Replace the model classifier with our network
# 102 is the number of different flower category
model.classifier = ClassifierModel(input_size, 102, hidden_layers)
# Checks if user wants to use GPU and if the system is capable to use it
device = torch.device("cuda:0" if (
torch.cuda.is_available() and args.gpu) else "cpu")
print("{} will be used to train the network".format(device))
# Train the model
with active_session():
model = train_model(model, train_loader, valid_loader,
args.learning_rate, device, args.epochs)
# Save the model to the filesystem
save_model(model, input_size, 102, hidden_layers, class_to_idx,
args.save_dir, args.arch)
def main():
#Retrieve command line arguments
in_arg = get_input_args()
# Use gpu if it's available and command line argument for gpu is gpu
device = torch.device("cuda" if torch.cuda.is_available() and in_arg.gpu=='gpu' else "cpu")
# Define transforms, datasets and dataloaders
data_transforms, image_datasets, dataloaders = load_data(in_arg.dir)
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'valid']}
#Build the network
model, classifier = build_model(in_arg.arch, in_arg.hidden_units)
# Train the network
with active_session():
model_ft = train_model(model.to(device), in_arg.lr, in_arg.epochs, dataloaders, device, dataset_sizes)
# Calculate accuracy on the test set
acc = calculate_accuracy(model_ft, dataloaders, device)
# Save the checkpoint
checkpoint_name = "/checkpoint{:.4f}_{}_lr{}_ep{}.pth".format(acc, in_arg.arch, in_arg.lr, in_arg.epochs)
save_checkpoint(model_ft, in_arg.arch, classifier, image_datasets, in_arg.save_dir+checkpoint_name)
def predict(image_path, model, topk=5, device='cpu'):
'''Predict the class (or classes) of an image using a trained deep learning model.
'''
print(f"Inferring using '{device}'...")
model.to(device)
# Retrieve file and covert to tensor
input_im = torch.tensor(process_image(image_path)).type(torch.FloatTensor)
# Retrieve label from input image path
label_class = Path(image_path).parts[2]
# Switch class mapping for convenience
idx_to_class = {d:k for k,d in model.class_to_idx.items()}
model.eval()
with active_session():
with torch.no_grad():
input_im = input_im.to(device)
logps = model(input_im.unsqueeze_(0))
ps = torch.exp(logps)
# Get top probabilities, indices
top_p, top_idx = ps.topk(topk, dim=1)
# Convert top indices to classes
top_class = [idx_to_class[k] for k in top_idx.tolist()[0]]
model.train()
input_im = input_im.squeeze().cpu()
# Return top probabilities, corresponding classes, input image tensor, and correct label class
return top_p.tolist()[0], top_class, input_im, label_class
def validation_on_test_set(model, test_loader, device, criterion):
# TODO: Do validation on the test set
with active_session():
epochs = 3
steps = 0
model.to(device)
for epoch in range(epochs):
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in test_loader:
steps += 1
# Move input and label tensors to the default device
inputs, labels = inputs.to(device), labels.to(device)
logps = model.forward(inputs)
loss = criterion(logps, labels)
test_loss += loss.item()
# Calculate accuracy
ps = torch.exp(logps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(
torch.FloatTensor)).item()
print(f"Epoch {epoch+1}/{epochs}.. "
f"Test loss: {test_loss/len(test_loader):.3f}.. "
f"Test accuracy: {accuracy/len(test_loader):.3f}")
model.train()
return ("this is the result")
def main():
args = arg_parser()
data_dir = 'flowers'
train_dir = data_dir + '/train'
valid_dir = data_dir + '/valid'
test_dir = data_dir + '/test'
train_data = train_transforms(train_dir)
valid_data = valid_transforms(valid_dir)
test_data = test_transforms(test_dir)
trainloader = train_loader(train_data)
validloader = valid_loader(valid_data)
testloader = test_loader(test_data)
model = load_model(args.arch)
model.classifier = build_classifier(model, args.hidden_units, args.dropout)
device = check_gpu(args.gpu)
model.to(device)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=args.lr)
with active_session():
trained_model = train_network(model, criterion, optimizer, args.epochs, device, trainloader, validloader)
test_model(model, criterion, testloader, device)
save_checkpoint(model, args.arch, args.save_dir, train_data)
def train_model(model, epochs, train_loader, validation_loader, criterion,
optimizer, device):
model.to(device)
steps = 0
running_loss = 0
print_every = 20
# training_losses, validation_losses = [], []
with active_session():
# Train the network
for epoch in range(epochs):
for inputs, labels in train_loader:
steps += 1
# Move parameters to the current device
inputs, labels = inputs.to(device), labels.to(device)
# Make sure previous gradients are erased
optimizer.zero_grad()
# Forward and backward pass
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
# Perform validation
if steps % print_every == 0:
validation_loss = 0
accuracy = 0
# Set model to evaluation mode
model.eval()
# Turn off requires_grad
with torch.no_grad():
validation_loss, accuracy = validator(
model, validation_loader, criterion, device)
# training_losses.append(running_loss / len(validation_loader))
# validation_losses.append(validation_loss / len(train_loader))
print(
f"Epoch {epoch + 1}/{epochs}.. "
f"Train loss: {running_loss / print_every:.3f}.. "
f"Validation loss: {validation_loss / len(validation_loader):.3f}.. "
f"Validation accuracy: {accuracy / len(validation_loader):.3f}"
)
running_loss = 0
# Set model back to train mode
model.train()
print("\nModel: I am ready to predict")
return model, optimizer
def main():
if len(sys.argv) == 3:
database_filepath, model_filepath = sys.argv[1:]
print('Loading data...\n DATABASE: {}'.format(database_filepath))
X, Y, category_names = load_data(database_filepath)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)
print('Building model...')
model = build_model()
print('Training model...')
from workspace_utils import active_session
with active_session():
model.fit(X_train, Y_train)
print('Evaluating model...')
evaluate_model(model, X_test, Y_test, category_names)
print('Saving model...\n MODEL: {}'.format(model_filepath))
save_model(model, model_filepath)
print('Trained model saved!')
else:
print('Please provide the filepath of the disaster messages database '\
'as the first argument and the filepath of the pickle file to '\
'save the model to as the second argument. \n\nExample: python '\
'train_classifier.py ../data/DisasterResponse.db classifier.pkl')
def train_network(model,
criterion,
device,
train_loaders,
valid_loaders,
epochs=14,
learningr=0.001):
optimizer = optim.Adam(model.classifier.parameters(), lr=learningr)
steps = 0
train_losses, valid_losses = [], []
with active_session():
for epoch in range(epochs):
running_loss = 0
for inputs, labels in train_loaders:
steps += 1
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % 60 == 0:
valid_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for images, labels in valid_loaders:
images, labels = images.to(device), labels.to(
device)
logps = model(images)
batch_loss = criterion(logps, labels)
valid_loss += batch_loss.item()
ps = torch.exp(logps)
top_prob, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(
equals.type(torch.FloatTensor))
train_losses.append(running_loss / len(train_loaders))
valid_losses.append(valid_loss / len(valid_loaders))
model.train()
print(
"Epoch: {}/{}.. ".format(epoch + 1, epochs),
"Training Loss: {:.3f}.. ".format(running_loss /
len(train_loaders)),
"Valid Loss: {:.3f}.. ".format(valid_loss /
len(valid_loaders)),
"Valid Accuracy: {:.3f}".format(accuracy /
len(valid_loaders)))
return model, optimizer
def main():
parser = argparse.ArgumentParser(description='Neural Network Trainer')
parser.add_argument('data_directory',
help="Choose where to pull the data from")
parser.add_argument('--save_dir',
default='checkpoint.pth',
help="Choose where to save the checkpoint to")
parser.add_argument('--arch',
default='vgg16',
help="Choose an architecture")
parser.add_argument(
'--learning_rate',
default=0.003,
help="Choose the learning rate of the training algorithm")
parser.add_argument(
'--hidden_units',
default=4096,
help="Choose the number of hidden units the neural network will have")
parser.add_argument('--epochs',
default=5,
help="Choose the number of epochs")
parser.add_argument('--gpu',
action='store_true',
help="Choose whether the gpu will be enabled or not")
args = parser.parse_args()
with active_session():
train_network(args.arch, float(args.learning_rate),
int(args.hidden_units), int(args.epochs), args.gpu,
args.save_dir, args.data_directory)
def train_model(model, train_loader, valid_loader, learning_rate, epochs, gpu):
# Criterion and optimizer
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
# Train the classifier layers using backpropagation using the pre-trained network to get the features
device = torch.device("cuda" if gpu else "cpu")
print(type(model))
model.to(device)
print_every = 50
steps = 0
running_loss = 0
train_accuracy = 0
print(
f'Training with {learning_rate} learning rate, {epochs} epochs, and {(gpu)*"gpu" + (not gpu)*"cpu"} computing.'
)
with active_session():
for e in range(epochs):
model.train()
for images, labels in iter(train_loader):
images, labels = images.to(device), labels.to(
device) # Move input and label tensors to the GPU
steps += 1
optimizer.zero_grad()
output = model.forward(images)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
ps = torch.exp(
output) # get the class probabilities from log-softmax
equality = (labels.data == ps.max(dim=1)[1])
train_accuracy += equality.type(torch.FloatTensor).mean()
if steps % print_every == 0:
model.eval(
) # Make sure network is in eval mode for inference
with torch.no_grad():
valid_loss, valid_accuracy = validation(
model, valid_loader, criterion, device)
print(
"Epoch: {}/{}.. ".format(e + 1, epochs),
"Training Loss: {:.3f}.. ".format(running_loss /
print_every),
"Training Accuracy: {:.3f}".format(train_accuracy /
print_every),
"Validation Loss: {:.3f}.. ".format(valid_loss /
len(valid_loader)),
"Validation Accuracy: {:.3f}".format(
valid_accuracy / len(valid_loader)))
running_loss = 0
train_accuracy = 0
model.train() # Make sure training is back on
print("\nTraining completed!")
return model, optimizer, criterion
def main():
args = args_parse()
data_dir = 'flowers'
train_dir = data_dir + '/train'
valid_dir = data_dir + '/valid'
test_dir = data_dir + '/test'
train_data = train_transformer(train_dir)
valid_data, test_data = test_transformer(valid_dir, test_dir)
trainloader = data_load(train_data)
validloader = data_load(train_data, train=False)
testloader = data_load(train_data, train=False)
model_arch = arch_of_classifier(architecture=args.arch)
model = model_classifier(model_arch, args.hidden_units)
device = check_gpu(gpu=args.gpu)
model.to(device)
if type(args.learning_rate) == type(None):
learning_rate == 0.002
else:
learning_rate = args.learning_rate
optimizer = optim.Adam(model.classifier.parameters(), learning_rate)
criterion = nn.NLLLoss()
epochs = args.epochs
with active_session():
trained_model = train_model(trainloader, validloader, device, epochs,
learning_rate, model, optimizer, criterion)
print("training is done")
with active_session():
valid(testloader, device, trained_model)
print("inference is complete")
save_checkpoint(args.save_dir, trained_model, train_data)
print("model is saved")
def train_model(model, dataloaders, lr, epochs, gpu):
if gpu:
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
else:
device = torch.device('cpu')
criterion = nn.NLLLoss()
optimizer = optim.SGD(model.classifier.parameters(), lr=0.01, momentum=0.9)
model.to(device)
with active_session():
times = []
i = 0
for e in range(epochs):
try:
running_loss = 0
start = time.time()
btimes = []
j = 0
i += 1
for inputs, labels in dataloaders['train']:
j += 1
bstart = time.time()
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
out = model.forward(inputs)
loss = criterion(out, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if j % 10 == 0:
perc, bleft, running_test_loss, accuracy = validate(
j, btimes, model, dataloaders, device, criterion)
print(
f'{perc}% done with batch, {np.round(bleft, 2)} minutes left'
)
print(
f'Train loss: {running_loss/10},',
f'Test loss: {running_test_loss/len(dataloaders["valid"])}',
f'Test accuracy: {accuracy/len(dataloaders["valid"])}'
)
running_loss = 0
model.train()
btimes.append(time.time() - bstart)
times.append(time.time() - start)
left = (epochs - e - 1) * (sum(times) / len(times)) / 60
print(f'\nDone with epoch {e+1}, time left: {left}')
except KeyboardInterrupt:
break
return model, optimizer, e + 1, running_loss
def train_model(model,
criterion,
optimizer,
trainloader,
validloader,
epochs=2,
print_interval=1):
if torch.cuda.is_available():
model.cuda()
print("Cuda Used")
step = 0
with active_session():
for epoch in range(epochs):
model.train()
loss = 0
match = 0
allitems = 0
for ct, (images, labels) in enumerate(trainloader):
model.train()
if torch.cuda.is_available():
images, labels = images.to("cuda"), labels.to("cuda")
else:
images, labels = images.to("cpu"), labels.to("cpu")
# images = Variable(images, requires_grad = False)
# labels = Variable(labels, requires_grad = False)
# with torch.no_grad():
step += 1
optimizer.zero_grad()
outputs = model.forward(images)
tloss = criterion(outputs, labels)
_, predicted = torch.max(outputs.data, 1)
allitems += labels.size(0)
match += (predicted == labels).sum().item()
# print(tloss)
tloss.backward()
optimizer.step()
loss += tloss.item()
if step % print_interval == 0:
taccuracy = (100 * match / allitems)
validation = validate_model(model, criterion, validloader)
# print(validation)
print(
f"Epoch: {epoch+1}/{epochs} ",
"Training Loss: {:.3f}.. ".format(loss /
print_interval),
"Training Accuracy: {:.2f}%.. ".format(taccuracy),
"Valid Loss: {:.3f}.. ".format(validation['loss']),
"Valid Accuracy: {:.3f}".format(
validation['accuracy']),
"Valid Accuracy: {:.3f}%".format(validation['nacc']))
def _train_model(model, train_loader, test_loader, gpu, epochs, learning_rate):
# print("_train_model entered : ", gpu, epochs, learning_rate)
#device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device = torch.device("cuda" if (
gpu == True) and torch.cuda.is_available() else "cpu")
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
model.to(device)
running_loss = 0
print_every = 5
steps = 0
with active_session():
for epoch in range(epochs):
for inputs, labels in train_loader:
steps += 1
# Move input and label tensors to the GPU
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in test_loader:
inputs, labels = inputs.to(device), labels.to(
device)
logps = model.forward(inputs)
batch_loss = criterion(logps, labels)
test_loss += batch_loss.item()
# Calculate accuracy
ps = torch.exp(logps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(
equals.type(torch.FloatTensor)).item()
print(f"Epoch {epoch+1}/{epochs}.. "
f"Train loss: {running_loss/print_every:.3f}.. "
f"Test loss: {test_loss/len(test_loader):.3f}.. "
f"Test accuracy: {accuracy/len(test_loader):.3f}")
running_loss = 0
model.train()
return model, optimizer
def train_model(model,
criterion,
optimizer,
trainloader,
validloader,
epochs=3,
print_interval=40,
device='cpu'):
# if args.gpu and torch.cuda.is_available():
# model.cuda()
model.to(device=device)
step = 0
with active_session():
for epoch in range(epochs):
model.train()
loss = 0
match = 0
allitems = 0
for ct, (images, labels) in enumerate(trainloader):
model.train()
# if args.gpu and torch.cuda.is_available():
# images, labels = images.to("cuda"), labels.to("cuda")
# else:
# images, labels = images.to("cpu"), labels.to("cpu")
images, labels = images.to(device=device), labels.to(
device=device)
step += 1
optimizer.zero_grad()
outputs = model.forward(images)
tloss = criterion(outputs, labels)
_, predicted = torch.max(outputs.data, 1)
allitems += labels.size(0)
match += (predicted == labels).sum().item()
tloss.backward()
optimizer.step()
loss += tloss.item()
if step % print_interval == 0:
taccuracy = (100 * match / allitems)
validation = validate_model(model, criterion, validloader,
device)
print(
f"Epoch: {epoch+1}/{epochs} ",
"Training Loss: {:.3f}.. ".format(loss /
print_interval),
"Training Accuracy: {:.2f}%.. ".format(taccuracy),
"Valid Loss: {:.3f}.. ".format(validation['loss']),
"Valid Accuracy: {:.3f}".format(
validation['accuracy']),
"Valid Accuracy: {:.3f}%".format(validation['nacc']))
def train_and_save(model):
with active_session():
data_dir = args.data_directory
data_transforms = {'train': transforms.Compose([transforms.RandomRotation(30),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
'test': transforms.Compose([transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
'valid': transforms.Compose([transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
])
}
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'test', 'valid']}
dataloaders_dict = {x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=8, shuffle=True,
num_workers=4) for x in ['train', 'valid']}
feature_extract = True
params_to_update = model.parameters()
print("Params to learn:")
if feature_extract:
params_to_update = []
for name, param in model.named_parameters():
if param.requires_grad == True:
params_to_update.append(param)
print("\t", name)
else:
for name, param in model.named_parameters():
if param.requires_grad == True:
print("\t", name)
optimizer_ft = optim.SGD(params_to_update, lr=args.learning_rate, momentum=0.9)
criterion = nn.CrossEntropyLoss()
model, hist = train_model(model, dataloaders_dict,
num_epochs=args.epochs,
criterion=criterion,
optimizer=optimizer_ft)
# Uncomment this to save the model during an unattended run
torch.save(model, f'{args.save_dir}/cli_checkpoint.pth')
def __train_model(self):
from workspace_utils import active_session
import torch
from torchvision import datasets, transforms, models
with active_session():
# Do long-running work here
steps = 0
running_loss = 0
print_every = 10
for epoch in range(self.__epochs):
for inputs, labels in self.__trainloaders:
steps += 1
inputs, labels = inputs.to(self.__device), labels.to(
self.__device)
self.__optimizer.zero_grad()
logps = self.__model.forward(inputs)
loss = self.__criterion(logps, labels)
loss.backward()
self.__optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
valid_loss = 0
accuracy = 0
self.__model.eval()
with torch.no_grad():
for inputs, labels in self.__validloaders:
inputs, labels = inputs.to(
self.__device), labels.to(
self.__device)
logps = self.__model.forward(inputs)
batch_loss = self.__criterion(
logps, labels)
valid_loss += batch_loss.item()
# Calculate accuracy
ps = torch.exp(logps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(
*top_class.shape)
accuracy += torch.mean(
equals.type(torch.FloatTensor)).item()
print(
f"Epoch {self.__epochs+1}/{self.__epochs}.. "
f"Train loss: {running_loss/print_every:.3f}.. "
f"Valid loss: {valid_loss/len(self.__validloaders):.3f}.. "
f"Valid accuracy: {accuracy/len(self.__validloaders):.3f}"
)
running_loss = 0
self.__model.train()
def start_training(train_loader, test_loader, valid_loader, model, epochs,
device, criterion, optimizer, learning_rate, arch):
model.to(device)
steps = 0
print_every = 5
# start the trainig and keep an active session
# print a statement to show the start of the training along with the number of epochs
print(
"............................\nstatinng the training with:\n",
"epochs: {}\ndevice: {}\nlearning rate: {}\narchitecture: {}\n".format(
epochs, device, learning_rate,
arch), "............................")
with active_session():
for e in range(epochs):
steps += 1
running_loss = 0
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
log_d = model(inputs)
loss = criterion(log_d, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
# print the progress every 5 epochs
if steps % print_every == 0:
test_loss = 0
accuracy = 0
with torch.no_grad():
model.eval()
for inputs, labels in test_loader:
inputs, labels = inputs.to(device), labels.to(device)
log_d = model(inputs)
loss = criterion(log_d, labels)
test_loss += loss
ps = torch.exp(log_d)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor))
print(
'Epoch: {}/{}..'.format(e + 1, epochs),
'Running loss: {:.3f}..'.format(running_loss /
len(train_loader)),
'Test loss: {:.3f}..'.format(test_loss /
len(test_loader)),
'accuracy: {:.2f}%'.format(accuracy.item() /
len(test_loader) * 100))
# set the model to training mode
model.train()
def train_network(epochs, device, learning_rate, trainloader, validloader, model):
model.to(device)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
epochs = epochs
steps = 0
running_loss = 0
print_frequency = 5
start_time = time.time()
with active_session():
for epoch in range(epochs):
for inputs, labels in trainloader:
steps += 1
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
log_outputs = model.forward(inputs)
loss = criterion(log_outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_frequency == 0:
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in validloader:
inputs, labels = inputs.to(device), labels.to(device)
log_outputs = model.forward(inputs)
batch_loss = criterion(log_outputs, labels)
test_loss += batch_loss.item()
# Calculate accuracy
outputs = torch.exp(log_outputs)
top_p, top_class = outputs.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
print(f"Epoch {epoch+1}/{epochs}.. "
f"Train loss: {running_loss/print_frequency:.3f}.. "
f"validation loss: {test_loss/len(validloader):.3f}.. "
f"Validation accuracy: {accuracy/len(validloader):.3f}")
running_loss = 0
model.train()
final_time = time.time() - start_time
print('finished training in {:.0f}m {:.7f}s'.format(final_time // 60, final_time % 60))
return optimizer
def train_model(data_loaders,
model,
criterion,
optimizer,
device,
epochs_nb=10):
model.to(device)
with wu.active_session():
steps = 0
running_loss = 0
print_every = 5
for epoch in range(epochs_nb):
for inputs, labels in data_loaders['train']:
steps += 1
# Move input and label tensors to the default device
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
valid_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in data_loaders['valid']:
inputs, labels = inputs.to(device), labels.to(
device)
logps = model.forward(inputs)
batch_loss = criterion(logps, labels)
valid_loss += batch_loss.item()
# Calculate accuracy
ps = torch.exp(logps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(
equals.type(torch.FloatTensor)).item()
print(
f"Epoch {epoch+1}/{epochs_nb}.. "
f"Step {steps}.. "
f"Train loss: {running_loss/print_every:.3f}.. "
f"Valid loss: {valid_loss/len(data_loaders['valid']):.3f}.. "
f"Valid accuracy: {accuracy/len(data_loaders['valid']):.3f}"
)
running_loss = 0
model.train()
return model
def train_network(model, trainloader, validloader, optimizer, criterion,
epochs, device):
print_every = 20
steps = 0
# Make sure that the session stays active
with active_session():
for e in range(epochs):
running_loss = 0
model.train()
for ii, (inputs, labels) in enumerate(trainloader):
steps += 1
# Load to cuda if available
inputs, labels = inputs.to(device), labels.to(device)
# Make sure to zero the gradient
optimizer.zero_grad()
# Forward pass through the network
output = model.forward(inputs)
# Calculate the loss
loss = criterion(output, labels)
# Backpropagation
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
# Make sure that the model is in eval mode
model.eval()
# Validate the network
validation_loss, validation_accuracy = validation(
model, validloader, criterion, device)
print(
"Epoch: {}/{}... ".format(e + 1, epochs),
"Training Loss: {:.4f}".format(running_loss /
print_every),
"Validation Loss: {:.3f}.. ".format(validation_loss /
len(validloader)),
"Validation Accuracy: {:.3f}".format(
validation_accuracy / len(validloader)))
# Make sure that the network is in training mode
model.train()
running_loss = 0
return model
def train_classifier(model, optimizer, criterion, arg_epochs, train_loader,
validate_loader, gpu):
with active_session():
epochs = arg_epochs
steps = 0
print_every = 40
model.to(gpu)
for e in range(epochs):
model.train()
running_loss = 0
for images, labels in iter(train_loader):
steps += 1
images, labels = images.to(gpu), labels.to(gpu)
optimizer.zero_grad()
output = model.forward(images)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
model.eval()
# Turn off gradients for validation, saves memory and computations
with torch.no_grad():
validation_loss, accuracy = validation(
model, validate_loader, criterion, gpu)
print(
"Epoch: {}/{}.. ".format(e + 1, epochs),
"Training Loss: {:.3f}.. ".format(running_loss /
print_every),
"Validation Loss: {:.3f}.. ".format(
validation_loss / len(validate_loader)),
"Validation Accuracy: {:.3f}".format(
accuracy / len(validate_loader)))
running_loss = 0
model.train()
