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