def mlp(): """Trains a multilayer perceptron with 1 hidden layer.""" tf.logging.set_verbosity(FLAGS.verbosity) print("Preprocessing data...") tic() train_raw, x_train, y_train, x_test, y_test, _, _, classes = preprocess_data(FLAGS) toc() # Set the output dimension according to the number of classes FLAGS.output_dim = len(classes) # Train and evaluate the MLP model. tic() run_experiment(x_train, y_train, x_test, y_test, bag_of_words_MLP_model, 'train_and_evaluate', FLAGS) toc() # Associate metadata with the word embedding for TensorBoard Projector config = projector.ProjectorConfig() word_embedding = config.embeddings.add() # The name of the embedding tensor was discovered by using TensorBoard. word_embedding.tensor_name = 'MLP/input_layer/words_embedding/embedding_weights' word_embedding.metadata_path = path.join(getcwd(), FLAGS.word_meta_file) writer = tf.summary.FileWriter(FLAGS.model_dir) # Writes projector_config.pbtxt projector.visualize_embeddings(writer, config) # Create metadata for TensorBoard Projector. create_metadata(train_raw, classes, FLAGS)
def run_experiments(expts, func, case, roleouts, episodes, in_cloud, minor=1): experiment = func(case, minor) profile = experiment.profile maxSteps = len(profile) # num profile values na = len(experiment.agents) ni = roleouts * episodes * maxSteps # no. interactions expt_action = zeros((expts, na, ni)) expt_reward = zeros((expts, na, ni)) for expt in range(expts): action, reward, epsilon = \ run_experiment(experiment, roleouts, episodes, in_cloud) expt_action[expt, :, :] = action expt_reward[expt, :, :] = reward experiment = func(case) expt_action_mean = mean(expt_action, axis=0) expt_action_std = std(expt_action, axis=0, ddof=1) expt_reward_mean = mean(expt_reward, axis=0) expt_reward_std = std(expt_reward, axis=0, ddof=1) return expt_action_mean, expt_action_std, \ expt_reward_mean, expt_reward_std, epsilon
def run_years(func, case, roleouts, episodes, in_cloud): experiment = func(case) dynProfile = profile.reshape((364, maxSteps)) # maxSteps = dynProfile.shape[1] na = len(experiment.agents) # ni = roleouts * episodes * maxSteps # no. interactions # expt_reward = zeros((na, ni)) _, reward, epsilon = \ run_experiment(experiment, roleouts, episodes, in_cloud, dynProfile) # expt_reward[expt, :, :] = reward experiment = func(case) reward_mean = zeros((na, maxSteps)) reward_std = zeros((na, maxSteps)) for s in range(maxSteps): reward_mean[:, s] = mean(reward[:, s::maxSteps], axis=1) reward_std[:, s] = std(reward[:, s::maxSteps], axis=1, ddof=1) return reward, (None, None, reward_mean, reward_std, epsilon)
def perceptron(): """Train and evaluate the perceptron model.""" tf.logging.set_verbosity(FLAGS.verbosity) print("Preprocessing data...") tic() train_raw, x_train, y_train, x_test, y_test, _, _, classes = preprocess_data( FLAGS) toc() # Set the output dimension according to the number of classes FLAGS.output_dim = len(classes) # Train and evaluate the model. tic() run_experiment(x_train, y_train, x_test, y_test, bag_of_words_perceptron_model, 'train_and_evaluate', FLAGS) toc()
def rnn(): """Trains a multilayer perceptron with 1 hidden layer. It assumes that the data has already been preprocessed, e.g. by perceptron.py""" tf.logging.set_verbosity(FLAGS.verbosity) print("Preprocessing data...") tic() train_raw, x_train, y_train, x_test, y_test, train_lengths, test_lengths, classes \ = preprocess_data(FLAGS, sequence_lengths=True) toc() # Set the output dimension according to the number of classes FLAGS.output_dim = len(classes) # Train the RNN model. tic() run_experiment(x_train, y_train, x_test, y_test, rnn_model, 'train_and_evaluate', FLAGS, train_lengths, test_lengths) toc() # Create metadata for TensorBoard Projector. create_metadata(train_raw, classes, FLAGS)
def perceptron_example(): """Perceptron example demonstrating online learning, and also evaluation separate from training.""" tf.logging.set_verbosity(FLAGS.verbosity) train_raw, test_raw, classes = get_data(FLAGS.data_dir) # Set the output dimension according to the number of classes FLAGS.output_dim = len(classes) print("\nSplitting the training and test data into two pieces...") # Seeding necessary for reproducibility. np.random.seed(FLAGS.np_seed) # Shuffle data to make the distribution of classes roughly stratified after splitting. train_raw = shuffle(train_raw) test_raw = shuffle(test_raw) train1_raw, train2_raw = np.split(train_raw, 2) test1_raw, test2_raw = np.split(test_raw, 2) print("First split:") x_train1_sentences, y_train1, x_test1_sentences, y_test1 = extract_data( train1_raw, test1_raw) print("\nProcessing the vocabulary...") tic() x_train1, x_test1, _, _, vocab_processor, n_words = process_vocabulary( x_train1_sentences, x_test1_sentences, FLAGS, reuse=False) toc() # Train the model on the first split. tic() run_experiment(x_train1, y_train1, x_test1, y_test1, bag_of_words_perceptron_model, 'train_and_evaluate', FLAGS) toc() # Next we perform incremental training with the 2nd half of the split data. print("\nSecond split extends the vocabulary.") x_train2_sentences, y_train2, x_test2_sentences, y_test2 = extract_data( train2_raw, test2_raw) # Extend vocab_processor with the newly added training vocabulary, and save the vocabulary processor for later use. tic() x_train2, x_test2, _, _, vocab_processor, n_words = process_vocabulary( x_train2_sentences, x_test2_sentences, FLAGS, reuse=False, vocabulary_processor=vocab_processor, extend=True) toc() # Train the model on the second split. tic() run_experiment(x_train2, y_train2, x_test2, y_test2, bag_of_words_perceptron_model, 'train_and_evaluate', FLAGS) toc() # We may be interested in the model performance on the training data # (e.g. to evaluate removable bias). print("\nEvaluation of the model performance on the training data.:") run_experiment(None, None, x_train1, y_train1, bag_of_words_perceptron_model, 'evaluate', FLAGS)