def print_training_progress(trainer, mb, frequency): if mb % frequency == 0: training_loss = get_train_loss(trainer) eval_crit = get_train_eval_criterion(trainer) print("Minibatch: {}, Train Loss: {}, Train Evaluation Criterion: {}".format( mb, training_loss, eval_crit))
def print_training_progress(trainer, mb, frequency): if mb % frequency == 0: training_loss = get_train_loss(trainer) eval_crit = get_train_eval_criterion(trainer) print("Minibatch: {}, Train Loss: {}, Train Evaluation Criterion: {}". format(mb, training_loss, eval_crit))
def print_training_progress(trainer, mb, frequency): training_loss = "NA" eval_error = "NA" if mb%frequency == 0: training_loss = get_train_loss(trainer) eval_error = get_train_eval_criterion(trainer) return mb, training_loss, eval_error
def print_training_progress(trainer, mb, frequency): training_loss = "NA" eval_error = "NA" if mb % frequency == 0: training_loss = get_train_loss(trainer) eval_error = get_train_eval_criterion(trainer) return mb, training_loss, eval_error
def print_training_progress(trainer, mb, frequency, verbose=1): training_loss, eval_error = "NA", "NA" if mb % frequency == 0: training_loss = get_train_loss(trainer) eval_error = get_train_eval_criterion(trainer) if verbose: print ("Minibatch: {0}, Loss: {1:.4f}, Error: {2:.2f}".format(mb, training_loss, eval_error)) return mb, training_loss, eval_error
TtrainS = datetime.datetime.now() for epoch in range(1, EPOCH + 1): # Specify the input variables mapping in the model to actual minibatch data for training for i in range(int(len(X_train) / minibatch_size)): #i=0 trainer.train_minibatch({ Xs: X_train[i * minibatch_size:(i + 1) * minibatch_size], ys: y_train[i * minibatch_size:(i + 1) * minibatch_size] }) #trainer.train_minibatch({Xs:X_train, ys: y_train}) if (epoch % SHOW_FREQ == 0): cur_loss = get_train_loss(trainer) acc = get_train_eval_criterion(trainer) print("{}/{}, loss = {}, acc = {}".format(epoch, EPOCH, cur_loss, 1 - acc)) #print("{}/{}, loss = {}".format(epoch, EPOCH, trainer.test_minibatch({Xs : X_train[:20], ys : y_train[:20]}) )) if (epoch % TEST_FREQ == 0): print(1 - trainer.test_minibatch({Xs: X_test1, ys: y_test1})) acc2 = 1 - trainer.test_minibatch({Xs: X_test2, ys: y_test2}) print(acc2) acc_all.append(acc2) if acc2 > max_acc2: max_acc2 = acc2 TtrainE = datetime.datetime.now() plt.figure(figsize=(15, 9)) plt.plot(np.array(range(len(acc_all))) * 20, acc_all, linewidth=1.5)
def train(train_reader, valid_reader, vocab, i2w, model, max_epochs): # do some hooks that we won't need in the future label_sequence = model.find_by_name('label_sequence') decoder_history_hook = model.find_by_name('decoder_history_hook') # Criterion nodes ce = cross_entropy_with_softmax(model, label_sequence) errs = classification_error(model, label_sequence) def clone_and_hook(): # network output for decoder history net_output = hardmax(model) # make a clone of the graph where the ground truth is replaced by the network output return model.clone(CloneMethod.share, {decoder_history_hook.output: net_output.output}) # get a new model that uses the past network output as input to the decoder new_model = clone_and_hook() # Instantiate the trainer object to drive the model training lr_per_sample = learning_rate_schedule(0.007, UnitType.sample) minibatch_size = 72 momentum_time_constant = momentum_as_time_constant_schedule(1100) clipping_threshold_per_sample = 2.3 gradient_clipping_with_truncation = True learner = momentum_sgd( model.parameters, lr_per_sample, momentum_time_constant, gradient_clipping_threshold_per_sample=clipping_threshold_per_sample, gradient_clipping_with_truncation=gradient_clipping_with_truncation) trainer = Trainer(model, ce, errs, learner) # Get minibatches of sequences to train with and perform model training i = 0 mbs = 0 # Set epoch size to a larger number of lower training error epoch_size = 5000 if isFast else 908241 training_progress_output_freq = 100 # bind inputs to data from readers train_bind = { find_arg_by_name('raw_input', model): train_reader.streams.features, find_arg_by_name('raw_labels', model): train_reader.streams.labels } valid_bind = { find_arg_by_name('raw_input', new_model): valid_reader.streams.features, find_arg_by_name('raw_labels', new_model): valid_reader.streams.labels } for epoch in range(max_epochs): loss_numer = 0 metric_numer = 0 denom = 0 while i < (epoch + 1) * epoch_size: # get next minibatch of training data mb_train = train_reader.next_minibatch(minibatch_size, input_map=train_bind) trainer.train_minibatch(mb_train) # collect epoch-wide stats samples = trainer.previous_minibatch_sample_count loss_numer += trainer.previous_minibatch_loss_average * samples metric_numer += trainer.previous_minibatch_evaluation_average * samples denom += samples # every N MBs evaluate on a test sequence to visually show how we're doing; also print training stats if mbs % training_progress_output_freq == 0: print( "Minibatch: {0}, Train Loss: {1:2.3f}, Train Evaluation Criterion: {2:2.3f}" .format(mbs, get_train_loss(trainer), get_train_eval_criterion(trainer))) mb_valid = valid_reader.next_minibatch(minibatch_size, input_map=valid_bind) e = new_model.eval(mb_valid) print_sequences(e, i2w) i += mb_train[find_arg_by_name('raw_labels', model)].num_samples mbs += 1 print("--- EPOCH %d DONE: loss = %f, errs = %f ---" % (epoch, loss_numer / denom, 100.0 * (metric_numer / denom))) return 100.0 * (metric_numer / denom)
lr_schedule = learning_rate_schedule(learning_rate, UnitType.minibatch) learner = sgd(z.parameters, lr_schedule) trainer = Trainer(z, (loss, error), [learner]) # training num_sweeps = 13 minibatch_size = 50 num_train_samples = 60000 num_test_samples = 10000 for i in range(num_sweeps): for j in range(0, num_train_samples, minibatch_size): trainer.train_minibatch({ input: train_features[j:j + minibatch_size, :], label: train_labels[j:j + minibatch_size, :] }) train_error = get_train_eval_criterion(trainer) test_error = 0. for j in range(0, num_test_samples, minibatch_size): test_data = { input: test_features[j:j + minibatch_size, :], label: test_labels[j:j + minibatch_size, :] } test_error = test_error + trainer.test_minibatch(test_data) test_error = test_error / (num_test_samples / minibatch_size) print('sweep {0} train error: {1:.4f} test error: {2:.4f}'.format( i, train_error, test_error), flush=True)
def save_metrics(trainer, filename): training_loss = get_train_loss(trainer) eval_error = get_train_eval_criterion(trainer) f = open(filename, 'w') f.write("Loss: {0:.4f}, Error: {1:.2f}%".format(training_loss, eval_error * 100))