def train_test(tester, arch, enable_gpu):
pin_memory = enable_gpu
dataloaders, class_to_idx = model_helper.get_dataloders(
data_dir, enable_gpu, num_workers, pin_memory)
model, optimizer, criterion = model_helper.create_model(
arch, learning_rate, hidden_units, class_to_idx)
if enable_gpu:
model.cuda()
else:
torch.set_num_threads(num_cpu_threads)
epochs = gpu_epochs if enable_gpu else cpu_epochs
model_helper.train(model, criterion, optimizer, epochs,
dataloaders['training'], dataloaders['validation'],
enable_gpu)
checkpoint_dir = testing_dir + '/gpu' if enable_gpu else '/cpu'
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
checkpoint = checkpoint_dir + '/' + arch + '_checkpoint.pth'
model_helper.save_checkpoint(checkpoint, model, optimizer, arch,
learning_rate, hidden_units, epochs)
def main():
start_time = time()
in_args = get_input_args()
use_gpu = torch.cuda.is_available() and in_args.gpu
print("Training on {} using {}".format("GPU" if use_gpu else "CPU",
in_args.arch))
print(
"Architecture:{}, Learning rate:{}, Hidden Units:{}, Epochs:{}".format(
in_args.arch, in_args.learning_rate, in_args.hidden_units,
in_args.epochs))
dataloaders, class_to_idx = model_helper.get_dataloders(in_args.data_dir)
model, optimizer, criterion = model_helper.create_model(
in_args.arch, in_args.learning_rate, in_args.hidden_units,
class_to_idx)
if use_gpu:
model.cuda()
criterion.cuda()
else:
torch.set_num_threads(in_args.num_threads)
model_helper.train(model, criterion, optimizer, in_args.epochs,
dataloaders['training'], dataloaders['validation'],
use_gpu)
if in_args.save_dir:
if not os.path.exists(in_args.save_dir):
os.makedirs(in_args.save_dir)
file_path = in_args.save_dir + '/' + in_args.arch + '_checkpoint.pth'
else:
file_path = in_args.arch + '_checkpoint.pth'
model_helper.save_checkpoint(file_path, model, optimizer, in_args.arch,
in_args.learning_rate, in_args.hidden_units,
in_args.epochs)
test_loss, accuracy = model_helper.validate(model, criterion,
dataloaders['testing'],
use_gpu)
print("Test Accuracy: {:.3f}".format(accuracy))
end_time = time()
utility.print_elapsed_time(end_time - start_time)
def main():
Input_aruguments = argument_parser()
print("Chosen Learning rate is {}, Hidden Units is {} and Epochs are {}".
format(Input_aruguments.learning_rate, Input_aruguments.hidden_units,
Input_aruguments.epochs))
batch_size = 64
gpu_check = torch.cuda.is_available() and Input_aruguments.gpu
if gpu_check:
print("GPU Device available.")
else:
warnings.warn(
"No GPU found. Please use a GPU to train your neural network.")
print("Data loading started.")
train_dir = Input_aruguments.data_dir + '/train'
valid_dir = Input_aruguments.data_dir + '/valid'
test_dir = Input_aruguments.data_dir + '/test'
data_transforms = {
'training_sets':
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])
]),
'validation_sets':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'testing_sets':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
# Load the datasets with ImageFolder
image_datasets = {
'training_sets':
datasets.ImageFolder(train_dir,
transform=data_transforms['training_sets']),
'validation_sets':
datasets.ImageFolder(valid_dir,
transform=data_transforms['validation_sets']),
'testing_sets':
datasets.ImageFolder(test_dir,
transform=data_transforms['testing_sets'])
}
# Using the image datasets and the transforms, define the dataloaders
dataloaders = {
'training_sets':
torch.utils.data.DataLoader(image_datasets['training_sets'],
batch_size,
shuffle=True),
'validation_sets':
torch.utils.data.DataLoader(image_datasets['validation_sets'],
batch_size,
shuffle=True),
'testing_sets':
torch.utils.data.DataLoader(image_datasets['testing_sets'],
batch_size,
shuffle=True)
}
print("Data loading completed. Model creation in-progress, please wait.")
model, optimizer, criterion = model_helper.create_model(
Input_aruguments.arch, Input_aruguments.hidden_units,
Input_aruguments.learning_rate,
image_datasets['training_sets'].class_to_idx)
print("Model creation completed. Moving to GPU if available, please wait.")
if gpu_check:
model.cuda()
criterion.cuda()
print("Training started, please wait it might take upto 5 mins.")
model_helper.train(model, criterion, optimizer, Input_aruguments.epochs,
dataloaders['training_sets'],
dataloaders['validation_sets'], gpu_check)
print("Training completed. Saving checkpoints, please wait.")
model_helper.save_checkpoint(model, optimizer, batch_size,
Input_aruguments.learning_rate,
Input_aruguments.arch,
Input_aruguments.hidden_units,
Input_aruguments.epochs)
print("Saving checkpoints complete. Validating model, please wait.")
test_loss, accuracy = model_helper.validate(model, criterion,
dataloaders['testing_sets'],
gpu_check)
print("Validation Accuracy: {:.3f}".format(accuracy))
image_path = 'flower_data/test/66/image_05582.jpg'
print("Predication for: {}".format(image_path))
probs, classes = model_helper.predict(image_path, model, gpu_check)
print(probs)
print(classes)
#### Load initial data
_,y_train,_ = load_data(data_path)
#### Load a correction I have done thanks to "clean_sequences" function
train_sent_corrected, test_sent = load_corrected_sentences(data_path)
#### Split training data iun training and validation sets
val_sent, y_val, train_sent, y_train, idxs_select_val = create_train_val_sets(train_sent_corrected, y_train, validation_ratio = 0.2)
print('data loaded')
#### Data augmentation
### with random walk method
#train_sent, y_train = augment_data_random_walk(train_sent, y_train)
#print('random walk augmentation done')
#### Encoding word --> integers
train_seq_encoded,test_seq_encoded,val_seq_encoded, y_train,y_val, word2index = encode_sequences(train_sent,test_sent,val_sent,y_train,y_val,maxlen = 50)
#### Load pre-trained embedding fitted to current dictionary
embeddings,word2embedding = create_embedding(bin_file, word2index)
#visualize_embedding(train_sent_corrected+test_sent_corrected,word2index,embeddings)
#### Training
# Design the model
model = multi_CNN(embeddings, train_embedding = False)
#Train the model
train(model, train_seq_encoded, y_train, val_seq_encoded, y_val, optimizer = 'sgd', batch_size = 64, nb_epochs = 300)
def main():
start_time = time()
in_args = get_input_args()
# Check for GPU
use_gpu = torch.cuda.is_available() and in_args.gpu
# Print parameter information
if use_gpu:
print("Training on GPU{}".format(
" with pinned memory" if in_args.pin_memory else "."))
else:
print("Training on CPU using {} threads.".format(in_args.num_threads))
print("Architecture:{}, Learning rate:{}, Hidden Units:{}, Epochs:{}".format(
in_args.arch, in_args.learning_rate, in_args.hidden_units, in_args.epochs))
# Get dataloaders for training
dataloaders, class_to_idx = model_helper.get_dataloders(in_args.data_dir,
use_gpu,
in_args.num_workers,
in_args.pin_memory)
# Create model
model, optimizer, criterion = model_helper.create_model(in_args.arch,
in_args.learning_rate,
in_args.hidden_units,
class_to_idx)
# Move tensors to GPU if available
if use_gpu:
model.cuda()
criterion.cuda()
else:
torch.set_num_threads(in_args.num_threads)
# Train the network
model_helper.train(model,
criterion,
optimizer,
in_args.epochs,
dataloaders['training'],
dataloaders['validation'],
use_gpu)
# Save trained model
if in_args.save_dir:
# Create save directory if required
if not os.path.exists(in_args.save_dir):
os.makedirs(in_args.save_dir)
# Save checkpoint in save directory
file_path = in_args.save_dir + '/' + in_args.arch + '_checkpoint.pth'
else:
# Save checkpoint in current directory
file_path = in_args.arch + '_checkpoint.pth'
model_helper.save_checkpoint(file_path,
model,
optimizer,
in_args.arch,
in_args.learning_rate,
in_args.hidden_units,
in_args.epochs)
# Get prediction accuracy using test dataset
test_loss, accuracy = model_helper.validate(
model, criterion, dataloaders['testing'], use_gpu)
print("Testing Accuracy: {:.3f}".format(accuracy))
# Computes overall runtime in seconds & prints it in hh:mm:ss format
end_time = time()
utility.print_elapsed_time(end_time - start_time)
def main():
start_time = time()
in_args = get_input_args()
use_gpu = torch.cuda.is_available() and in_args.gpu
print("Training on {} using {}".format("GPU" if use_gpu else "CPU",
in_args.arch))
print("Learning rate:{}, Hidden Units:{}, Epochs:{}".format(
in_args.learning_rate, in_args.hidden_units, in_args.epochs))
if not os.path.exists(in_args.save_dir):
os.makedirs(in_args.save_dir)
training_dir = in_args.data_dir + '/train'
validation_dir = in_args.data_dir + '/valid'
testing_dir = in_args.data_dir + '/test'
data_transforms = {
'training':
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])
]),
'validation':
transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'testing':
transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
dirs = {
'training': training_dir,
'validation': validation_dir,
'testing': testing_dir
}
image_datasets = {
x: datasets.ImageFolder(dirs[x], transform=data_transforms[x])
for x in ['training', 'validation', 'testing']
}
dataloaders = {
x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=64,
shuffle=True)
for x in ['training', 'validation', 'testing']
}
model, optimizer, criterion = model_helper.create_model(
in_args.arch, in_args.hidden_units, in_args.learning_rate,
image_datasets['training'].class_to_idx)
if use_gpu:
model.cuda()
criterion.cuda()
model_helper.train(model, criterion, optimizer, in_args.epochs,
dataloaders['training'], dataloaders['validation'],
use_gpu)
file_path = in_args.save_dir + '/' + in_args.arch + \
'_epoch' + str(in_args.epochs) + '.pth'
model_helper.save_checkpoint(file_path, model, optimizer, in_args.arch,
in_args.hidden_units, in_args.epochs)
test_loss, accuracy = model_helper.validate(model, criterion,
dataloaders['testing'],
use_gpu)
print("Post load Validation Accuracy: {:.3f}".format(accuracy))
image_path = 'flowers/test/28/image_05230.jpg'
print("Predication for: {}".format(image_path))
probs, classes = model_helper.predict(image_path, model, use_gpu)
print(probs)
print(classes)
end_time = time()
utility.print_elapsed_time(end_time - start_time)