def main():
# Create parser object
parser = argparse.ArgumentParser(description="Neural Network Image Classifier Training")
# Define argument for parser object
parser.add_argument('--save_dir', type=str, help='Define save directory for checkpoints model as a string')
parser.add_argument('--arch', dest='arch', action ='store', type = str, default = 'densenet', help='choose a tranfer learning model or architechture')
parser.add_argument('--learning_rate', dest = 'learning_rate', action='store', type=float, default=0.001, help='Learning Rate for Optimizer')
parser.add_argument('--hidden_units', dest = 'hidden_units', action='store', type=int, default=512, help='Define number of hidden unit')
parser.add_argument('--epochs', dest = 'epochs', action='store', type=int, default=1, help='Number of Training Epochs')
parser.add_argument('--gpu', dest = 'gpu', action='store_true', default = 'False', help='Use GPU if --gpu')
parser.add_argument('--st', action = 'store_true', default = False, dest = 'start', help = '--st to start predicting')
# Parse the argument from standard input
args = parser.parse_args()
# Print out the passing/default parameters
print('-----Parameters------')
print('gpu = {!r}'.format(args.gpu))
print('epoch(s) = {!r}'.format(args.epochs))
print('arch = {!r}'.format(args.arch))
print('learning_rate = {!r}'.format(args.learning_rate))
print('hidden_units = {!r}'.format(args.hidden_units))
print('start = {!r}'.format(args.start))
print('----------------------')
if args.start == True:
class_labels, trainloaders, testloaders, validloaders = helper.load_image()
model = helper.load_pretrained_model(args.arch, args.hidden_units)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr = args.learning_rate)
helper.train_model(model, args.learning_rate, criterion, trainloaders, validloaders, args.epochs, args.gpu)
helper.test_model(model, testloaders, args.gpu)
model.to('cpu')
# saving checkpoints
helper.save_checkpoint({
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'hidden_units': args.hidden_units,
'class_labels': class_labels
})
print('model checkpoint saved')
dest="arch",
action="store",
default="resnet50",
type=str)
arg.add_argument('--hidden_unit',
type=int,
dest="hidden_units",
action="store",
default=768)
arg.add_argument('--compute', dest="compute", action="store", default="cuda")
parser = arg.parse_args()
loc = parser.get_data
filepath = parser.save_model
lr = parser.learning_rate
architecture = parser.arch
dropout = parser.dropout
first_hidden_layer = parser.hidden_units
epochs = parser.epochs
compute = parser.compute
trainloader, validloader, testloader, class_to_idx = helper.get_data(loc)
model, criterion, optimizer = helper.model_setup(architecture, dropout,
first_hidden_layer, lr,
compute)
helper.train_model(model, criterion, optimizer, epochs, compute, trainloader,
validloader)
helper.save_checkpoint(filepath, architecture, first_hidden_layer, lr, dropout,
model, class_to_idx)
print("Done")
# Load data set
X_train, y_train = helper.load_data_set(root, file_name)
# Obtain the shape of input
input_shape = X_train[0].shape
print('>> Data set size: {0}'.format(len(y_train)))
print('>> Image shape: {0}'.format(input_shape))
# Build the models
idx = 1
model = \
helper.lenet_model(input_shape=input_shape) if idx==0 \
else helper.nvidia_model(input_shape=input_shape)
model_names = ['lenet_model', 'nvidia_model']
model_name = model_names[idx]
print('\n\n ')
print('+-------------------------------------------------+')
print('| {0:12s} |'.format(model_name))
print('+-------------------------------------------------+')
# Train and save the model
history_object = helper.train_model(
model, model_name, X_train, y_train,
loss='mse', lr=0.001,
valid_split=0.2, epochs = 10)
# Produce and save visualization
helper.produce_visualization(history_object, model_name)
import argparse
import helper
parser = argparse.ArgumentParser()
parser.add_argument('data_dir',nargs = '?',type = str, default = './flowers/')
parser.add_argument('--gpu',dest = 'gpu',action = 'store_true',default = False)
parser.add_argument('--save_dir',dest = 'save_dir',action = 'store',default = './checkpoint.pth')
parser.add_argument('--arch',dest = 'arch',action = 'store',default ='vgg16')
parser.add_argument('--learning_rate',dest ='learning_rate',action = 'store',default = 0.001,type = float)
parser.add_argument('--hidden_units',dest = 'hidden_units',action = 'store',default = 1024, type = int )
parser.add_argument('--epochs',dest = 'epochs',action = 'store',default = 20,type = int)
args = parser.parse_args()
# load data
train_data,trainloader, testloader,validloader = helper.load_data()
# build model
print(args.gpu)
print(args.arch)
print(type(args.hidden_units))
print(type(args.learning_rate))
model,device,criterion,optimizer = helper.build_model(args.gpu,args.arch,args.hidden_units,args.learning_rate)
# train model
helper.train_model(args.epochs,trainloader,validloader,model,device,criterion,optimizer)
# save the trained model
helper.save_checkpoint(model,args.epochs,args.arch,optimizer,train_data)
type=int)
parser.add_argument('--epochs',
help="Amount of epochs the network is trained (default=5)",
default=5,
type=int)
parser.add_argument('--gpu',
help="Use the gpu to accelerate training",
action='store_true')
args = parser.parse_args()
train_dir = args.data_directory[0] + '/train'
valid_dir = args.data_directory[0] + '/valid'
(trainloader, validationloader,
class_to_idx) = helper.get_dataloaders(train_dir, valid_dir)
if not torch.cuda.is_available() and args.gpu:
raise (
"No gpu available to train the network. Please remove the --gpu argument to train using the cpu"
)
device = ('cuda' if args.gpu else 'cpu')
(model, optimizer) = helper.get_model(args.arch, args.learning_rate,
args.hidden_units)
helper.train_model(model, trainloader, validationloader, optimizer, device,
args.epochs)
if args.save_dir != None:
model.class_to_idx = class_to_idx
torch.save(model, args.save_dir)
def main():
ap = argparse.ArgumentParser(description='train.py')
ap.add_argument('data_dir', nargs='*', action="store", default="./flowers")
ap.add_argument('--save_dir',
dest="save_dir",
action="store",
default="./checkpoint.pth")
ap.add_argument('--number_epochs',
dest="number_epochs",
action="store",
type=int,
default=1)
ap.add_argument('--model_type',
dest="model_type",
action="store",
default="vgg16",
type=str)
ap.add_argument('--hidden_units',
type=int,
dest="hidden_units",
default=760,
action="store")
ap.add_argument('--learning_rate',
dest="learning_rate",
action="store",
default=0.001,
type=float)
ap.add_argument('--dropout', dest="dropout", action="store", default=0.5)
ap.add_argument('--gpu', dest="gpu", action='store_true', default=False)
args = ap.parse_args()
train_dir = args.data_dir + '/train'
valid_dir = args.data_dir + '/valid'
test_dir = args.data_dir + '/test'
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
batch_size = 64
output_class = 102
trainloader, traindata = helper.train_data_loader(train_dir, mean, std,
batch_size)
validloader = helper.test_data_loader(valid_dir, mean, std, batch_size)
testloader = helper.test_data_loader(test_dir, mean, std, batch_size)
model, criterion, optimizer = helper.build_network(
args.model_type,
hidden_units=args.hidden_units,
output_class=output_class,
dropout=args.dropout,
lr=args.learning_rate)
model = helper.train_model(model,
criterion,
optimizer,
trainloader,
validloader,
number_epochs=args.number_epochs,
print_every=10,
gpu=args.gpu)
helper.save_model(args.save_dir, model, traindata, args.model_type,
args.hidden_units, output_class, args.dropout,
args.learning_rate)
epochs = 1
runs = 1500
start = datetime.datetime.now()
for i in range(runs):
clf = DecisionTreeRegressor()
num_feat = random.randint(1, 76)
features, train, test, y_train, y_test = helper.split_train_test(
training_set,
training_target,
num_feat,
i,
)
train_encoded, test_encoded = helper.encode(train, test)
helper.train_model(clf, train_encoded, y_train, epochs)
y_predicted = clf.predict(train_encoded[0:10])
test_score = helper.rsme_eval(clf, y_test, test_encoded)
if test_score < scores or scores == -999:
bfeatures = features
scores = test_score
seed = i
number_of_feat = num_feat
approx = ((((datetime.datetime.now() - start).seconds) /
(i + 1)) * runs) - (datetime.datetime.now() - start).seconds
print("time left: %s | %s/%s | best score: %s" %
(str(datetime.timedelta(seconds=approx)), i + 1, runs, scores),
end='\r')
results = parser.parse_args()
print('---------Parameters----------')
print('gpu = {!r}'.format(results.gpu))
print('epoch(s) = {!r}'.format(results.epochs))
print('arch = {!r}'.format(results.arch))
print('learning_rate = {!r}'.format(results.learning_rate))
print('hidden_units = {!r}'.format(results.hidden_units))
print('start = {!r}'.format(results.start))
print('-----------------------------')
if results.start == True:
class_labels, trainloader, testloader, validloader = helper.load_img()
model = helper.load_pretrained_model(results.arch, results.hidden_units)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(),
lr=results.learning_rate)
helper.train_model(model, results.learning_rate, criterion, trainloader,
validloader, results.epochs, results.gpu)
helper.test_model(model, testloader, results.gpu)
model.to('cpu')
# Save Checkpoint for predection
helper.save_checkpoint({
'arch': results.arch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'hidden_units': results.hidden_units,
'class_labels': class_labels
})
print('Checkpoint has been saved.')
sys.path.append(cwd)
from miniNN import Sequential, Linear, MSELoss, Relu, Tanh
from helper import data_generator, train_model
# Setting up hyperparameters
lr = 1e-2
mini_batch_size = 200
nb_epochs = 250
# Define Network
modules = [
Linear(2, 25),
Relu(),
Linear(25, 25),
Relu(),
Linear(25, 25),
Relu(),
Linear(25, 2),
Tanh()
]
model = Sequential(modules)
criterion = MSELoss()
# Generate train set and test set
train_input, train_target, test_input, test_target = data_generator(
ratio=0.8, normalized=True)
# Train model
train_model(model, criterion, train_input, train_target, test_input,
test_target, nb_epochs, lr, mini_batch_size)
X_train, y_train = helper.load_data_set(root, file_name)
# Obtain the shape of input
input_shape = X_train[0].shape
print('>> Data set size: {0}'.format(len(y_train)))
print('>> Image shape: {0}'.format(input_shape))
# Build the models
idx = 1
model = \
helper.lenet_model(input_shape=input_shape) if idx==0 \
else helper.nvidia_model(input_shape=input_shape)
model_names = ['lenet_model', 'nvidia_model']
model_name = model_names[idx]
print('\n\n ')
print('+-------------------------------------------------+')
print('| {0:12s} |'.format(model_name))
print('+-------------------------------------------------+')
# Train and save the model
history_object = helper.train_model(model,
model_name,
X_train,
y_train,
loss='mse',
lr=0.001,
valid_split=0.2,
epochs=10)
# Produce and save visualization
helper.produce_visualization(history_object, model_name)
xgb_v1_1 = get_v1() xgb_v1_2 = get_v1() xgb_v1_3 = get_v1() xgb_v2_1 = get_v2() xgb_v2_2 = get_v2() xgb_v2_3 = get_v2() train1, test1, y_train1, y_test1 = helper.evaluate_split_train_test(training_set, training_target, feature_set_1) train2, test2, y_train2, y_test2 = helper.evaluate_split_train_test(training_set, training_target, feature_set_2) train3, test3, y_train3, y_test3 = helper.evaluate_split_train_test(training_set, training_target, feature_set_3) train_encoded1, test_encoded1 = helper.encode(train1, test1) train_encoded2, test_encoded2 = helper.encode(train2, test2) train_encoded3, test_encoded3 = helper.encode(train3, test3) helper.train_model(xgb_v1_1, train_encoded1, y_train1, 1) helper.train_model(xgb_v1_2, train_encoded2, y_train2, 1) helper.train_model(xgb_v1_3, train_encoded3, y_train3, 1) helper.train_model(xgb_v2_1, train_encoded1, y_train1, 1) helper.train_model(xgb_v2_2, train_encoded2, y_train2, 1) helper.train_model(xgb_v2_3, train_encoded3, y_train3, 1) rsme = [] rsme.append(helper.rsme_eval(xgb_v1_1, y_test1, test_encoded1)) rsme.append(helper.rsme_eval(xgb_v1_2, y_test2, test_encoded2)) rsme.append(helper.rsme_eval(xgb_v1_3, y_test3, test_encoded3)) rsme.append(helper.rsme_eval(xgb_v2_1, y_test1, test_encoded1)) rsme.append(helper.rsme_eval(xgb_v2_2, y_test2, test_encoded2)) rsme.append(helper.rsme_eval(xgb_v2_3, y_test3, test_encoded3)) helper.run_predictions(get_v1(), feature_set_1, 1,"xgb_v1_f1_predictions.csv", training_set, test_set, training_target, test_ids)
# Initialize the model for this fold
fold_model, _ = initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True)
fold_model = fold_model.to(device)
# fold_optimizer = optim.Adam(fold_model.parameters(), lr=0.0001, weight_decay=0.0001)
fold_optimizer = optim.Adam(fold_model.parameters(), lr=base_lr)
# Setup the loss fxn
fold_criterion = nn.CrossEntropyLoss()
# Run Training and Validation Step
_, hist, best_acc = train_model(fold_model,
dataloaders_dict,
fold_criterion,
fold_optimizer,
device,
checkpoint_save_path,
num_epoch_to_stop_if_no_better,
fold_idx=i,
num_epochs=num_epochs,
is_inception=(model_name == "inception"),
is_resume=False)
list_hist.append(hist)
list_best_acc.append(best_acc.cpu().numpy())
print('Best averaged acc of all folds ', np.mean(list_best_acc))
with open('list_hist.pkl', 'wb') as f:
pickle.dump(list_hist, f)
type=int,
default=1,
dest='epochs',
help='pick number of epochs (default: %(default)s)')
parser.add_argument('--gpu',
action='store_true',
default=False,
dest='gpu_t',
help='set gpu to true')
args = parser.parse_args()
# Load and preprocess data
dataloaders, class_to_idx = utility.load_data(args.data_directory)
# Load pretrained model and add custom classifier
model, criterion, optimizer = helper.make_model(args.arch,
hidden_units=args.hidden_units,
dropout=args.dropout,
learn_rate=args.learning_rate)
# Add attribute to model for category to index lookup
model.class_to_idx = class_to_idx
# Train model
model = helper.train_model(model, criterion, optimizer, dataloaders['train'],
dataloaders['validate'], args.epochs, True)
# Save Model
if args.save_dir:
helper.save_model(model, args.save_dir, args.arch, args.hidden_units,
args.dropout, args.learning_rate)
data_dir = parser.data_directory
save_dir = parser.save_dir
arch = parser.arch
learning_rate = parser.learning_rate
hidden_units = parser.hidden_units
epochs = parser.epochs
gpu = parser.gpu
# 1) Load Data
image_datasets, trainloader, testloader, validloader = helper.loadData(
data_dir)
# 2) Build Model
model = helper.build_model(arch, hidden_units)
# 3) Train Model
model, optimizer, criterion = helper.train_model(model, trainloader,
validloader, learning_rate,
epochs, gpu)
# 4) Save the checkpoint
model.to('cpu')
model.class_to_idx = image_datasets['train_data'].class_to_idx
checkpoint = {
'model': model,
'hidden_units': hidden_units,
'optimizer_state_dict': optimizer.state_dict,
'criterion': criterion,
'epochs': epochs,
'state_dict': model.state_dict(),
'class_to_idx': model.class_to_idx
}
torch.save(checkpoint, save_dir + '/checkpoint.pth')
#
#
# Observe that all parameters are being optimized
# optimizer_ft = optim.SGD(params_to_update, lr=0.001, momentum=0.9, weight_decay=0.0001)
optimizer_ft = optim.Adam(model_ft.parameters(), lr=0.001, weight_decay=0.0001)
# Setup the loss fxn
criterion = nn.CrossEntropyLoss()
# Train and evaluate
model_ft, hist = train_model(model_ft,
dataloaders_dict,
criterion,
optimizer_ft,
device,
checkpoint_save_path,
num_epoch_to_stop_if_no_better,
num_epochs=num_epochs,
is_inception=(model_name == "inception"),
is_resume=True)
# Comparison with Model Trained from Scratch
# ------------------------------------------
#
# Just for fun, lets see how the model learns if we do not use transfer
# learning. The performance of finetuning vs. feature extracting depends
# largely on the dataset but in general both transfer learning methods
# produce favorable results in terms of training time and overall accuracy
# versus a model trained from scratch.
#
#
