def train_model(args): """Load the data, train the model, test the model, export / save the model """ torch.manual_seed(args.seed) # Open our dataset train_loader, test_loader = data_utils.load_data(args.test_split, args.batch_size) # Create the model net = model.SonarDNN().double() optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, nesterov=False) # Train / Test the model for epoch in range(1, args.epochs + 1): train(net, train_loader, optimizer, epoch) test(net, test_loader) # Export the trained model torch.save(net.state_dict(), args.model_name) if args.model_dir: # Save the model to GCS data_utils.save_model(args.model_dir, args.model_name)
def build(): print('Starting ...') for i in range(epoch, 100): print('Working on epoch ' + str(i+1)+' ...') for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)): train(trX[start:end], trY[start:end]) test_score = np.mean(np.argmax(teY, axis=1) == predict(teX)) if (i+1) % 1 == 0: save_model(params, epoch=i+1, annotation=annotation, namestub='conv_net', test_score=test_score)
def train_model(args): """Load the data, train the model, test the model, export / save the model """ torch.manual_seed(args.seed) # Open our dataset train_loader, test_loader = data_utils.load_data(args.test_split, args.seed, args.batch_size) # Create the model net = model.SonarDNN().double() optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, nesterov=False) # Train / Test the model latest_accuracy = 0.0 for epoch in range(1, args.epochs + 1): train(net, train_loader, optimizer) latest_accuracy = test(net, test_loader) # The default name of the metric is training/hptuning/metric. # We recommend that you assign a custom name. The only functional # difference is that if you use a custom name, you must set the # hyperparameterMetricTag value in the HyperparameterSpec object in your # job request to match your chosen name. # https://cloud.google.com/ml-engine/reference/rest/v1/projects.jobs#HyperparameterSpec hpt = hypertune.HyperTune() hpt.report_hyperparameter_tuning_metric( hyperparameter_metric_tag='my_accuracy_tag', metric_value=latest_accuracy, global_step=args.epochs) # Export the trained model torch.save(net.state_dict(), args.model_name) if args.job_dir: # Save the model to GCS data_utils.save_model(args.job_dir, args.model_name) else: print('Accuracy: {:.0f}%'.format(latest_accuracy))
def train_model(args): train_features, test_features, train_labels, test_labels = \ data_utils.load_data(args) sonar_model = model.sonar_model() sonar_model.fit(train_features, train_labels, epochs=args.epochs, batch_size=args.batch_size) score = sonar_model.evaluate(test_features, test_labels, batch_size=args.batch_size) print(score) # Export the trained model sonar_model.save(args.model_name) if args.model_dir: # Save the model to GCS data_utils.save_model(args.model_dir, args.model_name)
def train_model(args): """Load the data, train the model, test the model, export / save the model """ torch.manual_seed(args.seed) # Open our dataset train_loader, test_loader = data_utils.load_data( args.test_split, args.seed, args.batch_size) # Create the model net = model.SonarDNN().double() optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, nesterov=False) # Train / Test the model latest_accuracy = 0.0 for epoch in range(1, args.epochs + 1): train(net, train_loader, optimizer) latest_accuracy = test(net, test_loader) # The default name of the metric is training/hptuning/metric. # We recommend that you assign a custom name. The only functional # difference is that if you use a custom name, you must set the # hyperparameterMetricTag value in the HyperparameterSpec object in your # job request to match your chosen name. # https://cloud.google.com/ml-engine/reference/rest/v1/projects.jobs#HyperparameterSpec hpt = hypertune.HyperTune() hpt.report_hyperparameter_tuning_metric( hyperparameter_metric_tag='my_accuracy_tag', metric_value=latest_accuracy, global_step=args.epochs) # Export the trained model torch.save(net.state_dict(), args.model_name) if args.job_dir: # Save the model to GCS data_utils.save_model(args.job_dir, args.model_name) else: print('Accuracy: {:.0f}%'.format(latest_accuracy))
training_cutoff=training_agg_cutoff, validation_cutoff=training_cutoff) _, _, df_train_ret, df_validation_ret = load_data( training_cutoff=validation_cutoff, validation_cutoff=None) #%% Train and Save Models models = [] regions_val = list(set(df_validation[region_col])) dates_val = sorted(list(set(df_validation[date_col]))) validation_predictions = {} if train_bilstm: bilstm = BILSTMModel(**bilstm_params_dict) bilstm.fit(df_train, 'first') models.append('bilstm') save_model(bilstm, bilstm_file.replace(".pickle", "_train.pickle")) if load_bilstm: bilstm = load_model(bilstm_file.replace(".pickle", "_train.pickle")) validation_predictions['bilstm'] = bilstm.predict( regions_val, dates_val, 'first') models.append('bilstm') if train_sir: sir = SIRModel(**sir_params_dict) sir.fit(df_train) save_model(sir, sir_file.replace(".pickle", "_train.pickle")) if load_sir: sir = load_model(sir_file.replace(".pickle", "_train.pickle")) try: validation_predictions['sir'] = sir.predict(regions_val, dates_val)
# Build Tokenizer and turn training documents into integer tokens tok = Tokenizer(num_tokens=None, stop_words=stop_words_custom) tokenized_train = tok.fit_transform(training_documents) # Convert training samples and labels to numpy arrays X = list_to_numpy(tokenized_train, tok) y = np.asarray(training_labels) # Split off developmental data # Fixed random_state = 42 for DEBUG purposes X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=49) # Fit model on training data nb_clf = MultinomialNB() nb_clf.fit(X_train, y_train, alpha=0.9) # Make predictions on developmental data y_pred = nb_clf.predict(X_test) # Print F1 score for each of the four classes, and overall accuracy print(f1_score(y_test, y_pred, average=None)) print(accuracy_score(y_test, y_pred)) # Save model parameters --- priors and conditional probabilities save_model("nbmodel.txt", nb_clf, tok) # Save Tokenizer; will need it for test data with open("tok.pickle", "wb") as g: dill.dump(tok, g)
def train_flair(model_name=''): # Init data train_dataset, val_dataset = prepare_datasets_FLAIR() train_loader = DataLoader(train_dataset, batch_size=10, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=10, shuffle=True) loaders = dict(train=train_loader, val=val_loader) # Init Model if model_name == '': model = UNetFLAIR().cuda() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, amsgrad=True) scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.984) loss_fn = nn.BCELoss() else: model = data_utils.load_model(model_name) epochs = 500 epoch_losses = dict(train=[], val=[]) for epoch in range(epochs): for phase in 'train val'.split(): if phase == 'train': model = model.train() torch.set_grad_enabled(True) else: model = model.eval() torch.set_grad_enabled(False) loader = loaders[phase] running_loss = [] for batch in loader: imgs, masks = batch imgs = imgs.cuda() masks = masks.cuda() outputs = model(imgs) loss = loss_fn(outputs, masks) running_loss.append(loss.item()) if phase == 'train': optimizer.zero_grad() loss.backward() optimizer.step() # End of Epoch print(f'{epoch}) {phase} loss: {np.mean(running_loss)}') visualize_results(loader, model, epoch, phase) if epoch % 10 == 0: results_dir = 'weight_flair/' if not os.path.isdir(results_dir): os.makedirs(results_dir) data_utils.save_model(model, results_dir + f'model_{epoch}.pt') epoch_losses[phase].append(np.mean(running_loss)) if phase == 'val': df = pd.DataFrame(data=epoch_losses) df.to_csv('loss.csv') tensorboard(epoch_losses[phase], phase) if phase == 'train': scheduler.step()
df, df_train, df_validation = load_data( validation_cutoff=validation_cutoff) _, df_train_agg, df_validation_agg = load_data( training_cutoff=training_agg_cutoff, validation_cutoff=training_cutoff) # %% Train and Save Models models = [] regions_val = list(set(df_validation[region_col])) dates_val = list(set(df_validation[date_col])) validation_predictions = {} if train_sir: sir = SIRModel(**sir_params_dict) sir.fit(df_train) save_model(sir, sir_file) if load_sir: sir = load_model(sir_file) try: validation_predictions['sir'] = sir.predict(regions_val, dates_val) except: pass models.append('sir') if train_knn: knn = KNNModel(**knn_params_dict) knn.fit(df_train) models.append('knn') save_model(knn, knn_file) if load_knn:
def test_mlp(learning_rate=0.01, L1_reg=0.00, L2_reg=0.0001, n_epochs=n_epochs_mlp, dataset='mnist.pkl.gz', batch_size=20, n_hidden=500, randomInit=randomInit, logfilename=logfilename, loadparams = loadparams, paramsfilename=paramsfilename, testrun = testrun, add_blurs = add_blurs): """ Demonstrate stochastic gradient descent optimization for a multilayer perceptron This is demonstrated on MNIST. :type learning_rate: float :param learning_rate: learning rate used (factor for the stochastic gradient :type L1_reg: float :param L1_reg: L1-norm's weight when added to the cost (see regularization) :type L2_reg: float :param L2_reg: L2-norm's weight when added to the cost (see regularization) :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type dataset: string :param dataset: the path of the MNIST dataset file from http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz """ print ('loadparams is ' + str(loadparams)) datasets = load_data(dataset) train_set_x, train_set_y = datasets[0] valid_set_x, valid_set_y = datasets[1] test_set_x, test_set_y = datasets[2] # compute number of minibatches for training, validation and testing n_train_batches = train_set_x.get_value(borrow=True).shape[0] // batch_size n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] // batch_size n_test_batches = test_set_x.get_value(borrow=True).shape[0] // batch_size ###################### # BUILD ACTUAL MODEL # ###################### print('... building the model') # allocate symbolic variables for the data index = T.lscalar() # index to a [mini]batch x = T.matrix('x') # the data is presented as rasterized images y = T.ivector('y') # the labels are presented as 1D vector of # [int] labels randgen = 1234 if randomInit: randgen = 3421 rng = numpy.random.RandomState(randgen) # construct the MLP class classifier = MLP( rng=rng, input=x, n_in=28 * 28, n_hidden=n_hidden, n_out=10, randomInit=randomInit, loadparams = loadparams, paramsfilename = paramsfilename ) # start-snippet-4 # the cost we minimize during training is the negative log likelihood of # the model plus the regularization terms (L1 and L2); cost is expressed # here symbolically cost = ( classifier.negative_log_likelihood(y) + L1_reg * classifier.L1 + L2_reg * classifier.L2_sqr ) # end-snippet-4 # compiling a Theano function that computes the mistakes that are made # by the model on a minibatch test_model = theano.function( inputs=[index], outputs=classifier.errors(y), givens={ x: test_set_x[index * batch_size:(index + 1) * batch_size], y: test_set_y[index * batch_size:(index + 1) * batch_size] } ) validate_model = theano.function( inputs=[index], outputs=classifier.errors(y), givens={ x: valid_set_x[index * batch_size:(index + 1) * batch_size], y: valid_set_y[index * batch_size:(index + 1) * batch_size] } ) # start-snippet-5 # compute the gradient of cost with respect to theta (sorted in params) # the resulting gradients will be stored in a list gparams gparams = [T.grad(cost, param) for param in classifier.params] # specify how to update the parameters of the model as a list of # (variable, update expression) pairs # given two lists of the same length, A = [a1, a2, a3, a4] and # B = [b1, b2, b3, b4], zip generates a list C of same size, where each # element is a pair formed from the two lists : # C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)] updates = [ (param, param - learning_rate * gparam) for param, gparam in zip(classifier.params, gparams) ] # compiling a Theano function `train_model` that returns the cost, but # in the same time updates the parameter of the model based on the rules # defined in `updates` train_model = theano.function( inputs=[index], outputs=cost, updates=updates, givens={ x: train_set_x[index * batch_size: (index + 1) * batch_size], y: train_set_y[index * batch_size: (index + 1) * batch_size] } ) # end-snippet-5 ############### # TRAIN MODEL # ############### print('... training') # early-stopping parameters # CCC Commenting out patience for simplicity and transparency's sake # patience = 10000 # look as this many examples regardless # patience_increase = 2 # wait this much longer when a new best is # # found # improvement_threshold = 0.995 # a relative improvement of this much is # considered significant validation_frequency = n_train_batches # CCCmin(n_train_batches, patience // 2) # go through this many # minibatche before checking the network # on the validation set; in this case we # check every epoch best_validation_loss = numpy.inf best_iter = 0 test_score = 0. start_time = timeit.default_timer() epoch = 0 if loadparams: epoch = epoch_from_filename(paramsfilename) done_looping = False while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 for minibatch_index in range(n_train_batches): minibatch_avg_cost = train_model(minibatch_index) # iteration number iter = (epoch - 1) * n_train_batches + minibatch_index if (iter + 1) % validation_frequency == 0: # compute zero-one loss on validation set validation_losses = [validate_model(i) for i in range(n_valid_batches)] this_validation_loss = numpy.mean(validation_losses) print( 'epoch %i, minibatch %i/%i, validation error %f %%' % ( epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100. ) ) # if we got the best validation score until now if this_validation_loss < best_validation_loss: #improve patience if loss improvement is good enough # CCC if ( # this_validation_loss < best_validation_loss * # improvement_threshold # ): # patience = max(patience, iter *patience_increase) best_validation_loss = this_validation_loss best_iter = iter # test it on the test set test_losses = [test_model(i) for i in range(n_test_batches)] test_score = numpy.mean(test_losses) print((' epoch %i, minibatch %i/%i, test error of ' 'best model %f %%') % (epoch, minibatch_index + 1, n_train_batches, test_score * 100.)) # CCC if patience <= iter: # done_looping = True # break if epoch in saveepochs_mlp: # test it on the test set epoch_test_losses = [test_model(i) for i in range(n_test_batches)] epoch_test_score = numpy.mean(epoch_test_losses) print(('epoch %i, test error of ' 'best model %f %%') % (epoch, epoch_test_score * 100.)) save_model(classifier.params, epoch, best_validation_loss, epoch_test_score, '../data/models/best_model_mlp_' , randomInit, add_blurs, testrun, logfilename, endrun = (n_epochs==epoch)) end_time = timeit.default_timer() print(('Optimization complete. Best validation score of %f %% ' 'obtained at iteration %i, with test performance %f %%') % (best_validation_loss * 100., best_iter + 1, test_score * 100.)) # test it on the test set final_test_losses = [test_model(i) for i in range(n_test_batches)] final_test_score = numpy.mean(final_test_losses) print(('The final test score is %f %% ') % (final_test_score * 100.)) print(('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr)
def evaluate_lenet5(learning_rate=0.1, n_epochs=n_epochs_convmlp, dataset='mnist.pkl.gz', nkerns=[20, 50], batch_size=500, thislogfilename = logfilename, loadparams=loadparams, paramsfilename=paramsfilename, randomInit=False, testrun=testrun, add_blurs=add_blurs, blur=blur, rot_angles = rotation_angles, annotation =''): """ Demonstrates lenet on MNIST dataset :type learning_rate: float :param learning_rate: learning rate used (factor for the stochastic gradient) :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type dataset: string :param dataset: path to the dataset used for training /testing (MNIST here) :type nkerns: list of ints :param nkerns: number of kernels on each layer """ loadedparams = [None] * 8 if loadparams: print("Loading params from " + paramsfilename + "...") loadedparams = load_params(paramsfilename) rng = numpy.random.RandomState(23455) datasets = load_data(dataset, add_the_blurs=add_blurs, blur = blur, angles = rot_angles) if len(rot_angles)>0: annotation += '_angles_' for ang in rot_angles: annotation += str(ang)+'_' train_set_x, train_set_y = datasets[0] valid_set_x, valid_set_y = datasets[1] test_set_x, test_set_y = datasets[2] # compute number of minibatches for training, validation and testing n_train_batches = train_set_x.get_value(borrow=True).shape[0] n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] n_test_batches = test_set_x.get_value(borrow=True).shape[0] n_train_batches //= batch_size n_valid_batches //= batch_size n_test_batches //= batch_size # allocate symbolic variables for the data index = T.lscalar() # index to a [mini]batch # start-snippet-1 x = T.matrix('x') # the data is presented as rasterized images y = T.ivector('y') # the labels are presented as 1D vector of # [int] labels ###################### # BUILD ACTUAL MODEL # ###################### print('... building the model') # Reshape matrix of rasterized images of shape (batch_size, 28 * 28) # to a 4D tensor, compatible with our LeNetConvPoolLayer # (28, 28) is the size of MNIST images. layer0_input = x.reshape((batch_size, 1, 28, 28)) # Construct the first convolutional pooling layer: # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24) # maxpooling reduces this further to (24/2, 24/2) = (12, 12) # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12) layer0 = LeNetConvPoolLayer( rng, input=layer0_input, image_shape=(batch_size, 1, 28, 28), filter_shape=(nkerns[0], 1, 5, 5), poolsize=(2, 2), W = loadedparams[6], b=loadedparams[7] ) # Construct the second convolutional pooling layer # filtering reduces the image size to (12-5+1, 12-5+1) = (8, 8) # maxpooling reduces this further to (8/2, 8/2) = (4, 4) # 4D output tensor is thus of shape (batch_size, nkerns[1], 4, 4) layer1 = LeNetConvPoolLayer( rng, input=layer0.output, image_shape=(batch_size, nkerns[0], 12, 12), filter_shape=(nkerns[1], nkerns[0], 5, 5), poolsize=(2, 2), W = loadedparams[4], b = loadedparams[5] ) # the HiddenLayer being fully-connected, it operates on 2D matrices of # shape (batch_size, num_pixels) (i.e matrix of rasterized images). # This will generate a matrix of shape (batch_size, nkerns[1] * 4 * 4), # or (500, 50 * 4 * 4) = (500, 800) with the default values. layer2_input = layer1.output.flatten(2) # construct a fully-connected sigmoidal layer layer2 = HiddenLayer( rng, input=layer2_input, n_in=nkerns[1] * 4 * 4, n_out=500, activation=activation_convmlp, W=loadedparams[2], b=loadedparams[3] ) # classify the values of the fully-connected sigmoidal layer layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10, W=loadedparams[0], b=loadedparams[1]) # the cost we minimize during training is the NLL of the model cost = layer3.negative_log_likelihood(y) # create a function to compute the mistakes that are made by the model test_model = theano.function( [index], layer3.errors(y), givens={ x: test_set_x[index * batch_size: (index + 1) * batch_size], y: test_set_y[index * batch_size: (index + 1) * batch_size] } ) validate_model = theano.function( [index], layer3.errors(y), givens={ x: valid_set_x[index * batch_size: (index + 1) * batch_size], y: valid_set_y[index * batch_size: (index + 1) * batch_size] } ) # create a list of all model parameters to be fit by gradient descent params = layer3.params + layer2.params + layer1.params + layer0.params # create a list of gradients for all model parameters grads = T.grad(cost, params) # train_model is a function that updates the model parameters by # SGD Since this model has many parameters, it would be tedious to # manually create an update rule for each model parameter. We thus # create the updates list by automatically looping over all # (params[i], grads[i]) pairs. updates = [ (param_i, param_i - learning_rate * grad_i) for param_i, grad_i in zip(params, grads) ] train_model = theano.function( [index], cost, updates=updates, givens={ x: train_set_x[index * batch_size: (index + 1) * batch_size], y: train_set_y[index * batch_size: (index + 1) * batch_size] } ) # end-snippet-1 ############### # TRAIN MODEL # ############### print('... training') # early-stopping parameters # CCC Commenting out patience for simplicity and transparency's sake # patience = 10000 # look as this many examples regardless # patience_increase = 2 # wait this much longer when a new best is # # found # improvement_threshold = 0.995 # a relative improvement of this much is # # considered significant validation_frequency = n_train_batches #min(n_train_batches, patience // 2) # go through this many # minibatche before checking the network # on the validation set; in this case we # check every epoch best_validation_loss = numpy.inf best_iter = 0 test_score = 0. start_time = timeit.default_timer() epoch = 0 if loadparams: epoch = epoch_from_filename(paramsfilename) done_looping = False while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 for minibatch_index in range(n_train_batches): iter = (epoch - 1) * n_train_batches + minibatch_index if iter % 100 == 0: print('training @ iter = ', iter) cost_ij = train_model(minibatch_index) if (iter + 1) % validation_frequency == 0: # compute zero-one loss on validation set validation_losses = [validate_model(i) for i in range(n_valid_batches)] this_validation_loss = numpy.mean(validation_losses) print('epoch %i, minibatch %i/%i, validation error %f %%' % (epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100.)) # if we got the best validation score until now if this_validation_loss < best_validation_loss: #improve patience if loss improvement is good enough # CCC if this_validation_loss < best_validation_loss * \ # improvement_threshold: # patience = max(patience, iter * patience_increase) # save best validation score and iteration number best_validation_loss = this_validation_loss best_iter = iter # test it on the test set test_losses = [ test_model(i) for i in range(n_test_batches) ] test_score = numpy.mean(test_losses) print((' epoch %i, minibatch %i/%i, test error of ' 'best model %f %%') % (epoch, minibatch_index + 1, n_train_batches, test_score * 100.)) # CCC if patience <= iter: # done_looping = True # break if epoch in saveepochs_convmlp: # test it on the test set epoch_test_losses = [test_model(i) for i in range(n_test_batches)] epoch_test_score = numpy.mean(epoch_test_losses) print(('epoch %i, test error of ' 'best model %f %%') % (epoch, epoch_test_score * 100.)) save_model(params, epoch, best_validation_loss, epoch_test_score, '../data/models/best_model_convolutional_mlp_' , randomInit, add_blurs, testrun, thislogfilename, endrun = (n_epochs == epoch), annotation = annotation) end_time = timeit.default_timer() print('Optimization complete.') print('Best validation score of %f %% obtained at iteration %i, ' 'with test performance %f %%' % (best_validation_loss * 100., best_iter + 1, test_score * 100.)) print(('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr)