type=int, dest="hidden_units", action="store", default=120, help="state the units for fist hidden layer (deafult 120)") pa = parser.parse_args() data_path = pa.data_dir path = pa.save_dir lr = pa.learning_rate structure = pa.arch dropout = pa.dropout hidden_layer1 = pa.hidden_units power = pa.gpu epochs = pa.epochs #load the data - invoke the data_load method from helper trainloader, v_loader, testloader = hp.data_load(data_path) #create the model model, optimizer, criterion = hp.nn_arch(structure, dropout, hidden_layer1, lr, power) #train the neural network hp.train_network(model, optimizer, criterion, epochs, 20, trainloader, power) #save the train network checkpoint hp.save_checkpoint(path, structure, hidden_layer1, dropout, lr) print("The Model is trained")
dest="learning_rate", default=0.001) ap.add_argument('--dropout', type=float, dest="dropout", default=0.5) pa = ap.parse_args() data_dir = pa.data_dir path = pa.save_dir structure = pa.arch power = pa.gpu epochs = pa.epochs hidden_layer = pa.hidden_units lr = pa.learning_rate dropout = pa.dropout # load the 3 dataloaders (takes data_dir as argument) trainloader, validloader, testloader, class_to_idx = helper.load_data(data_dir) # set up model structure (takes structure, dropout, hidden_layer, lr, power) model, optimizer, criterion = helper.nn_setup(structure, dropout, hidden_layer, lr, power) # train and validate the network helper.train_network(model, optimizer, criterion, epochs, 20, trainloader, validloader, power) helper.save_checkpoint(model, path, structure, hidden_layer, dropout, lr, class_to_idx) print("------------Model Trained!------------")
args=parser.parse_args() #correctly sort the data for training, validation, testing data_dir = args.data_dir train_data, valid_data, test_data, trainloader, validloader, testloader = utility.preprocess_img(data_dir) #create model using --arch argument with vgg19 as default model = utility.torch_model(args.arch) for param in model.parameters(): param.requires_grad = False #params are now frozen so that we do not backprop thru them again #calculate input size into the network classifier input_size = utility.get_input_size(model, args.arch) model.classifier = helper.NeuralNetwork(input_size, args.output_size, [args.hidden_units], drop_p=0.35) #define the loss function and the optimization parameters criterion = nn.NLLLoss() #want nllloss because we do the logsoftmax as our output activation optimizer = optim.Adam(model.classifier.parameters(), lr=args.learning_rate) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=0.1) #train model helper.train_network(model, trainloader,validloader,args.epochs, 40, criterion,optimizer,scheduler,args.gpu) #test model test_accuracy, test_loss = helper.loss_accuracy(model, testloader, criterion, args.gpu) print("\n ---\n Test Accuracy: {:.2f} %".format(test_accuracy*100), "Test Loss: {}".format(test_loss)) #save network to checkpoint utility.save_checkpoint(model, train_data, optimizer, args.save_dir, args.arch)
dest="fc2", action="store", default=1024, help="state the units for fc2") pa = parser.parse_args() data_path = pa.data_dir filepath = pa.save_dir learn_r = pa.learn_r architecture = pa.architecture dropout = pa.dropout fc2 = pa.fc2 gpu_cpu = pa.gpu_cpu epoch_num = pa.epoch_num # load the data - data_load() from help.py trainloader, validationloader, testloader = hp.load_data(data_path) # build model model, optimizer, criterion = hp.nn_architecture(architecture, dropout, fc2, learn_r) # train model hp.train_network(model, criterion, optimizer, trainloader, validationloader, epoch_num, 20, gpu_cpu) # checkpoint the model hp.save_checkpoint(filepath, architecture, dropout, learn_r, fc2, epoch_num) print("model has been successfully trained")
arg = argparse.ArgumentParser(description='Train.py') # Command Line ardguments arg.add_argument('data_dir', nargs='*', action="store", default="./flowers/") arg.add_argument('--gpu', dest="gpu", action="store", default='device') arg.add_argument('--save_dir', dest="save_dir", action="store", default="./checkpoint.pth") arg.add_argument('--learning_rate', dest="learning_rate", action="store", default=0.003) arg.add_argument('--dropout', dest = "dropout", action = "store", default = 0.2) arg.add_argument('--epochs', dest="epochs", action="store", type=int, default=4) arg.add_argument('--arc', dest="arc", action="store", default="resnet50", type = str) arg.add_argument('--hidden_units', type=int, dest="hidden_units", action="store", default=512) pa_arg = arg.parse_args() from_loc = pa_arg.data_dir checkpoint = pa_arg.save_dir lr = pa_arg.learning_rate structure = pa_arg.arc dropout = pa_arg.dropout dev = pa_arg.gpu epochs = pa_arg.epochs hidden_units = pa_arg.hidden_units trainloader , testloader, validationloader,train_data = helper.load_data(from_loc) model, criterion, optimizer = helper.netwk_setup(structure, dropout, lr,hidden_units) helper.train_network(model,criterion,optimizer,trainloader,testloader,epochs) helper.validation_data_set(model,validationloader,criterion) helper.save_checkpoint(model,structure,hidden_units,dropout,lr,epochs,optimizer,checkpoint,from_loc)