def run(constant_overwrites): x_train, y_train, x_val, y_val, x_test, y_test = load_mnist_dataset( flatten=True) plt.figure(figsize=[6, 6]) for i in range(4): plt.subplot(2, 2, i + 1) plt.title('Label: %i' % y_train[i]) plt.imshow(x_train[i].reshape([28, 28]), cmap='gray') constants = merge_dict(get_constants(), constant_overwrites) n_classes = constants['n_classes'] data = { 'X_train': x_train, 'y_train': one_hot_encode(y_train, n_classes), 'X_val': x_val, 'y_val': one_hot_encode(y_val, n_classes), 'X_test': x_test, 'y_test': one_hot_encode(y_test, n_classes) } input_x, input_y = get_inputs(constants) parameters = get_parameters(constants) optimizer, loss_op, model, y_ = model_builder(network_builder, input_x, input_y, parameters, constants) train(data, constants, (input_x, input_y), optimizer, loss_op, model, y_, minibatch=True)
def denoising_autoencoder(constant_overwrites): img_shape, attr, x_train, x_test = load_faces_dataset() constants = merge_dict(get_constants(), constant_overwrites) constants['img_shape'] = img_shape constants['code_size'] = 512 autoencoder, encoder, decoder = model_builder(network_builder, constants) reset_tf_session() iterations = 25 for i in range(iterations): print('Epoch %i/%i, Generating corrupted samples...' % (i + 1, iterations)) x_train_noise = apply_gaussian_noise(x_train) x_test_noise = apply_gaussian_noise(x_test) # continue to train model with new noise-augmented data autoencoder.fit(x=x_train_noise, y=x_train, epochs=1, validation_data=[x_test_noise, x_test], callbacks=[TQDMProgressCallback()], verbose=0) x_test_noise = apply_gaussian_noise(x_test) denoising_mse = autoencoder.evaluate(x_test_noise, x_test, verbose=0) print('Denoising MSE:', denoising_mse) for i in range(5): img = x_test_noise[i] visualize(img, encoder, decoder)
def run(constant_overwrites): env = gym.make('CartPole-v0') state_size = env.observation_space.shape[0] action_size = env.action_space.n constants = merge_dict(get_constants(), constant_overwrites) if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) agent = DQNAgent(state_size, action_size, constants) n_episodes = constants['n_episodes'] batch_size = constants['batch_size'] for e in range(n_episodes): state = env.reset() state = np.reshape(state, [1, state_size]) for time in range(5000): env.render() action = agent.act(state) next_state, reward, done, _ = env.step(action) reward = reward if not done else -10 next_state = np.reshape(next_state, [1, state_size]) agent.remember(state, action, reward, next_state, done) state = next_state if done: print('episode: {}/{}, score: {}, e: {:.2}'.format(e, n_episodes, time, agent.epsilon)) break if len(agent.memory) > batch_size: agent.replay(batch_size) if e % 50 == 0: agent.save(OUTPUT_DIR + 'weights_' + '{:04d}'.format(e) + '.hdf5')
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) env = GameEnvironment(partial=False, size=5) n_hidden = constants['n_hidden'] start_epsilon = constants['start_epsilon'] end_epsilon = constants['end_epsilon'] annealing_steps = constants['annealing_steps'] tau = constants['tau'] gamma = constants['gamma'] learning_rate = constants['learning_rate'] save_path = constants['save_path'] load_model = constants['load_model'] n_episodes = constants['n_episodes'] batch_size = constants['batch_size'] max_episode_length = constants['max_episode_length'] n_pretrain_steps = constants['n_pretrain_steps'] update_freq = constants['update_freq'] rewards, _ = train(env, n_hidden, start_epsilon, end_epsilon, annealing_steps, tau, gamma, learning_rate, save_path, load_model, n_episodes, batch_size, max_episode_length, n_pretrain_steps, update_freq) # Check network learning # mean reward over time reward_mat = np.resize(np.array(rewards), [len(rewards) // 100, 100]) mean_reward = np.average(reward_mat, 1) plt.plot(mean_reward) plt.show()
def run(constant_overwrites): tokens_train, tags_train, tokens_val, tags_val, tokens_test, tags_test = load_twitter_entities_dataset() special_tokens = ['<UNK>', '<PAD>'] special_tags = ['O'] tok2idx, idx2tok = build_dict(tokens_train + tokens_val, special_tokens) tag2idx, idx2tag = build_dict(tags_train, special_tags) constants = merge_dict(get_constants(), constant_overwrites) vocab_size = len(tok2idx.keys()) n_tags = len(tag2idx.keys()) pad_idx = tok2idx[PAD_TOKEN] print('vocab_size:', vocab_size) print('n_tags:', n_tags) print('pad_idx:', pad_idx) tf.reset_default_graph() model = BiLSTMModel(vocab_size, n_tags, constants['embedding_dim'], constants['n_hidden'], pad_idx) sess = tf.Session() train(model, sess, tokens_train, tags_train, tokens_val, tags_val, tok2idx, tag2idx, idx2tok, idx2tag, constants) print('-' * 20 + ' Train set quality: ' + '-' * 20) eval_conll(model, sess, tokens_train, tags_train, tok2idx, tag2idx, idx2tok, idx2tag) print('-' * 20 + ' Validation set quality: ' + '-' * 20) eval_conll(model, sess, tokens_val, tags_val, tok2idx, tag2idx, idx2tok, idx2tag) print('-' * 20 + ' Test set quality: ' + '-' * 20) eval_conll(model, sess, tokens_test, tags_test, tok2idx, tag2idx, idx2tok, idx2tag)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) config = namedtuple('Config', constants.keys())(*constants.values()) with tf.device('/cpu:0'), tf.Session() as sess: try: task = importlib.import_module('tasks.%s' % config.task) except ImportError: print("task '%s' does not have implementation" % config.task) raise if config.is_train: cell, ntm = create_ntm(config, sess) task.train(ntm, config, sess) else: cell, ntm = create_ntm(config, sess, forward_only=True) ntm.load(config.checkpoint_dir, config.task) if config.task == 'copy': task.run(ntm, int(config.test_max_length * 1 / 3), sess) print() task.run(ntm, int(config.test_max_length * 2 / 3), sess) print() task.run(ntm, int(config.test_max_length * 3 / 3), sess) else: task.run(ntm, int(config.test_max_length), sess)
def run(constant_overwrites): x_train, y_train, x_val, y_val, x_test, y_test = load_mnist_dataset( flatten=True) plt.figure(figsize=[6, 6]) for i in range(4): plt.subplot(2, 2, i + 1) plt.title('Label: %i' % y_train[i]) plt.imshow(x_train[i].reshape([28, 28]), cmap='gray') plt.pause(1) # block to show sample image constants = merge_dict(get_constants(), constant_overwrites) # using estimator does not require labels to be one-hot encoded first data = { 'X_train': x_train, 'y_train': y_train, 'X_val': x_val, 'y_val': y_val, 'X_test': x_test, 'y_test': y_test } metrics = train_using_estimator(data, model_builder, constants) print('') print('Test accuracy:', metrics['accuracy'])
def run(constant_overwrites): allowed_operators = ['+', '-'] dataset_size = 100000 data = generate_equations(allowed_operators, dataset_size, min_value=0, max_value=9999) train_set, test_set = train_test_split(data, test_size=0.2, random_state=42) word2id, id2word = get_symbol_to_id_mappings() # Special symbols start_symbol = '^' # indicate the beginning of the decoding procedure end_symbol = '$' # indicate the end of a string, both for input and output sequences # padding_symbol = '#' # a padding character to make lengths of all strings equal within one training batch config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) model = Seq2SeqModel(vocab_size=len(word2id), embeddings_size=constants['embeddings_size'], hidden_size=constants['n_hidden'], max_iter=constants['max_iter'], start_symbol_id=word2id[start_symbol], end_symbol_id=word2id[end_symbol]) sess = tf.Session() all_ground_truth, all_model_predictions, invalid_number_prediction_counts = \ train(sess, model, train_set, test_set, word2id, id2word, constants) evaluate_results(all_ground_truth, all_model_predictions, invalid_number_prediction_counts)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) data_generator = ImageDataGenerator(rescale=1/255, rotation_range=90, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True) print('Load', constants['module_spec']) module_spec = hub.load_module_spec(constants['module_spec']) image_size, _ = hub.get_expected_image_size(module_spec) # n_channels = hub.get_num_image_channels(module_spec) # project_dir = 'tmp/semihard_full_' + 'time:' + str(int(time()))[-3:] +\ # '/top:lambda:' + str(constants['lambda_reg']) +\ # 'margin:' + str(constants['tl_margin']) project_dir = '/Users/d777710/src/DeepLearning/vision' print('Project dir:', project_dir) _, _, bottleneck_config = get_bottleneck_config(os.path.join(project_dir, constants['bottleneck_dir']), os.path.join(project_dir, constants['splits_dir'])) bottleneck_flow_gen = ImageFlowGenerator(bottleneck_config, mode='bottleneck') constants.update({ 'train_dir': os.path.join(project_dir, constants['train_subdir']), 'top_model_dir': os.path.join(project_dir, constants['top_model_subdir']), 'val_dir': os.path.join(project_dir, constants['val_subdir']), 'top_model_val_dir': os.path.join(project_dir, constants['top_model_val_subdir']), 'data_flow_gen': bottleneck_flow_gen, 'eval_every_n_steps': 5, 'generator': data_generator, 'image_size': image_size }) model = SemiHardModel(constants, train_top_only=True) run_training(model, constants)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) learning_rate = constants['learning_rate'] n_episodes = constants['n_episodes'] epsilon = constants['epsilon'] tf.reset_default_graph() bandit = ContextualBandit() agent = Agent(learning_rate=learning_rate, state_dim=bandit.n_bandits, n_actions=bandit.n_actions) w = tf.trainable_variables()[0] sess = tf.Session() _, w1 = train(bandit, agent, w, sess, n_episodes=n_episodes, epsilon=epsilon) for i in range(bandit.n_bandits): print( 'The agent thinks action %s for bandit %i is the most promising' % (str(np.argmax(w1[i]) + 1), i + 1)) if np.argmax(w1[i]) == np.argmin(bandit.bandits[i]): print('and it is right!') else: print('and it is wrong!') print('')
def run(constant_overwrites): x_train, y_train, x_val, y_val, x_test, y_test = load_mnist_dataset( flatten=True) plt.figure(figsize=[6, 6]) for i in range(4): plt.subplot(2, 2, i + 1) plt.title('Label: %i' % y_train[i]) plt.imshow(x_train[i].reshape([28, 28]), cmap='gray') constants = merge_dict(get_constants(), constant_overwrites) network = network_builder(x_train, constants) train_log = [] val_log = [] for epoch in range(constants['n_epochs']): for x_batch, y_batch in iterate_minibatches( x_train, y_train, batch_size=constants['batch_size'], shuffle=True): train(network, x_batch, y_batch) train_log.append(np.mean(predict(network, x_train) == y_train)) val_log.append(np.mean(predict(network, x_val) == y_val)) clear_output() print('Epoch', epoch) print('Train accuracy:', train_log[-1]) print('Val accuracy:', val_log[-1]) if len(train_log) > 1: plt.figure() plt.plot(train_log, label='train accuracy') plt.plot(val_log, label='val accuracy') plt.legend(loc='best') plt.grid() plt.show()
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) x_train, y_train, x_val, y_val, classes = load_datasets() model = LogisticRegressionModel(x_train, y_train) def print_prediction(sample_idx): utterance = x_val[sample_idx] print('Utterance:', utterance) print('Actual:', classes[y_val[sample_idx]]) print('Predicted:', classes[model.predict(utterance)]) print('\nSample predictions:') samples = np.random.choice(x_val.index, size=constants['n_samples']) for i in samples: print_prediction(i) print() y_pred = [model.predict(utterance) for utterance in x_val] train_df = pd.DataFrame({'utterance': x_train, 'label': y_train}) counts_by_label = train_df.groupby('label').utterance.count() stats = perf_by_label(y_val, y_pred, classes, counts_by_label) print('\nBest / Worst classes:') print_best_worst(stats, rounded=2, sort_column='f1_score', top_n=5, max_name_len=40)
def image_retrieval(constant_overwrites): img_shape, attr, x_train, x_test = load_faces_dataset() constants = merge_dict(get_constants(), constant_overwrites) constants['img_shape'] = img_shape encoder_filename = constants['encoder_filename'] decoder_filename = constants['decoder_filename'] reset_tf_session() autoencoder, encoder, decoder = model_builder(network_builder, constants) if os.path.exists(encoder_filename) and not constants['retrain']: encoder.load_weights(encoder_filename) else: data = {'X_train': x_train, 'X_test': x_test} train(autoencoder, data, constants) encoder.save_weights(encoder_filename) decoder.save_weights(decoder_filename) images = x_train codes = encoder.predict(images) assert len(codes) == len(images) nei_clf = NearestNeighbors(metric="euclidean") nei_clf.fit(codes) # Cherry-picked examples: # smiles show_similar(x_test[247], nei_clf, encoder, images) # ethnicity show_similar(x_test[56], nei_clf, encoder, images) # glasses show_similar(x_test[63], nei_clf, encoder, images)
def run(constant_overwrites): x_train, y_train, x_test, y_test = load_cifar10_dataset() # n_classes = 10 classes = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] print('') print('original:') print('X_train shape:', x_train.shape) print('y_train shape:', y_train.shape) print(y_train[:3]) # not required when using `tfms_from_model` below # x_train = x_train.reshape(x_train.shape[0], -1) x_train = x_train.astype( np.float32) # WTF? float/float64 (default) raises error y_train = np.where(y_train == 1)[1] y_train = y_train.astype(np.int) # uint8 is causing error # x_test = x_test.reshape(x_test.shape[0], -1) x_test = x_test.astype(np.float32) # as above y_test = np.where(y_test == 1)[1] y_test = y_test.astype(np.int) # as above # sample to test on CPU x_train = x_train[:800] y_train = y_train[:800] x_test = x_test[:200] y_test = y_test[:200] print('') print('reshaped:') print('X_train shape:', x_train.shape) print('y_train shape:', y_train.shape) print(y_train[:3]) print('X_train dtype:', x_train.dtype) print('y_train dtype:', y_train.dtype) constants = merge_dict(get_constants(), constant_overwrites) constants['img_shape'] = x_train.shape[1:] arch = resnet34 data = ImageClassifierData.from_arrays(OUTPUT_DIR, trn=(x_train, y_train), val=(x_test, y_test), classes=classes, tfms=tfms_from_model( arch, constants['image_size'])) learn = ConvLearner.pretrained(arch, data, precompute=True) # lrf = learn.lr_find() learn.fit(constants['learning_rate'], constants['n_epochs']) learn.sched.plot_loss() log_preds = learn.predict() preds = np.argmax(log_preds, axis=1) print('Finished')
def run(constant_overwrites): constants = merge_dict(get_constants(), constant_overwrites) tar_filename = constants['tar_filename'] img_size = constants['img_size'] train_files, test_files, train_labels, test_labels, n_classes = \ load_flowers(os.path.dirname(os.path.abspath(__file__))) data = { 'train_files': train_files, 'train_labels': train_labels, 'test_files': test_files, 'test_labels': test_labels, 'n_classes': n_classes } # test cropping raw_bytes = read_raw_from_tar(tar_filename, 'jpg/image_00001.jpg') img = decode_image_from_raw_bytes(raw_bytes) print('') print('original image shape:', img.shape) print('') plt.imshow(img) plt.show() img = prepare_raw_bytes_for_model(raw_bytes, img_size, normalize_for_model=False) print('') print('cropped image shape:', img.shape) print('') plt.imshow(img) plt.show() # remember to clear session if you start building graph from scratch! # don't call K.set_learning_phase() !!! (otherwise will enable dropout # in train/test simultaneously) _ = reset_tf_session() # returns session model = model_builder(n_classes, constants) print('') print(model.summary()) print('') compile_model(model, constants) # model_file_exists = any(f.startswith('flowers') for f in os.listdir('.') if os.path.isfile(f)) last_finished_epoch = constants['last_finished_epoch'] if last_finished_epoch: model = load_model(constants['model_filename'].format(last_finished_epoch)) train(model, data, constants) # Accuracy on test set test_accuracy = model.evaluate_generator( train_generator(tar_filename, test_files, test_labels, n_classes, constants), len(test_files) // constants['batch_size'] // 2 )[1] print('\nTest accuracy: %.5f' % test_accuracy)
def run(constant_overwrites): constants = merge_dict(get_constants(), constant_overwrites) data, all_tags = load_tagged_sentences() draw(data[11]) draw(data[10]) draw(data[7]) all_words, word_counts = get_word_counts(data) # let's measure what fraction of data words are in the dictionary coverage = float(sum(word_counts[w] for w in all_words)) / sum(word_counts.values()) print('Coverage = %.5f' % coverage) # Build a mapping from tokens to integer ids. Our model operates on a word level, # processing one word per RNN step. This means we'll have to deal with far larger # vocabulary. # Luckily for us, we only receive those words as input, i.e. we don't have to # predict them. This means we can have a large vocabulary for free by using word # embeddings. word_to_id = defaultdict(lambda: 1, {word: i for i, word in enumerate(all_words)}) tag_to_id = {tag: i for i, tag in enumerate(all_tags)} batch_words, batch_tags = zip(*[zip(*sentence) for sentence in data[-3:]]) print('word ids:') print(to_matrix(batch_words, word_to_id)) print('tag ids:') print(to_matrix(batch_tags, tag_to_id)) train_data, test_data = train_test_split(data, test_size=0.25, random_state=42) if constants['bidirectional']: model = bidirectional_model_builder(all_words, all_tags, constants) else: model = model_builder(all_words, all_tags, constants) print('') print(model.summary()) print('') train(model, train_data, test_data, all_tags, word_to_id, tag_to_id, constants) # Measure final accuracy on the whole test set. acc = compute_test_accuracy(model, test_data, word_to_id, tag_to_id) print('\n\nFinal accuracy: %.5f' % acc) assert acc > 0.94, 'Accuracy should be better than that'
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), '../src', 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) build_dataset_splits(images_dir=constants['images_dir'], splits_dir=constants['splits_dir'], external_dir=constants['images_dir'], min_test=constants['min_test'], val_ratio=constants['val_ratio'], test_ratio=constants['test_ratio'], rebuild=constants['rebuild'])
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) env = gym.make('Taxi-v2') n_actions = env.action_space.n agent = QLearningAgent(alpha=constants['alpha'], epsilon=constants['epsilon'], discount=constants['discount'], get_legal_actions=lambda s: range(n_actions)) train(env, agent, constants['n_epochs'])
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) train_df, val_df, test_df, classes = load_data( dirname=constants['data_dir']) train_df = remove_classes_with_too_few_examples(clean_data(train_df)) val_df = remove_classes_with_too_few_examples(clean_data(val_df)) n_classes = len(classes) batch_size = constants['batch_size'] allow_soft_placement = constants['allow_soft_placement'] log_device_placement = constants['log_device_placement'] if constants['test']: print('\nTesting...') x_raw = val_df.utterance.values checkpoint_dir = constants['checkpoint_dir'] vocab_path = os.path.join(checkpoint_dir, '..', 'vocab') vocab_processor = learn.preprocessing.VocabularyProcessor.restore( vocab_path) x_test = np.array(list(vocab_processor.transform(x_raw))) # y_test = one_hot_encode(val_df.label.values, n_classes) y_test = val_df.label.values preds = test(x_test, batch_size, checkpoint_dir, allow_soft_placement, log_device_placement, y_test) save_eval_to_csv(x_raw, preds, checkpoint_dir) else: print('\nTraining...') x_train, y_train, x_val, y_val, vocab_processor = preprocess( train_df, val_df, n_classes) # model = TextCNN(seq_len=x_train.shape[1], n_classes=y_train.shape[1], # vocab_size=len(vocab_processor.vocabulary_), # embed_size=constants['embed_size'], # filter_sizes=constants['filter_sizes'], # n_filters=constants['n_filters'], # l2_reg_lambda=constants['l2_reg_lambda']) train(x_train, y_train, x_val, y_val, vocab_processor, model=None, learning_rate=constants['learning_rate'], n_checkpoints=constants['n_checkpoints'], keep_prob=constants['keep_prob'], batch_size=batch_size, n_epochs=constants['n_epochs'], evaluate_every=constants['evaluate_every'], checkpoint_every=constants['checkpoint_every'], allow_soft_placement=allow_soft_placement, log_device_placement=log_device_placement, constants=constants)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) train_df, val_df, test_df, classes = load_data() train_df = remove_classes_with_too_few_examples(clean_data(train_df)) val_df = remove_classes_with_too_few_examples(clean_data(val_df)) features, labels, tfidf, _ = generate_tfidf_features( train_df, val_df, cutoff=constants['cutoff'], ngram_range=constants['ngram_range']) print('Number Utterances: {}, Features: {}'.format(*features.shape)) show_relevant_terms(features, labels, tfidf, classes, every=20)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) if constants['play']: if 'folder' in constants: folder = constants['folder'] with open(folder + '/hyperparams.json') as f: constants = merge_dict(constants, json.load(f)) # check for slash at end experiment = folder if folder[-1] == '/' else folder + '/' constants['experiment'] = experiment if 'traffic_folder' in constants: if constants['traffic'] == 'dir:': constants['traffic'] += constants['traffic_folder'] play(constants, is_training=False) else: print('Folder must be specific to play') else: constants['experiment'] = setup_experiment() play(constants, is_training=True)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) env = WithSnapshots(gym.make('CartPole-v0')) root_observation = env.reset() root_snapshot = env.get_snapshot() n_actions = env.action_space.n root = Root(env, n_actions, root_snapshot, root_observation) plan_mcts(root, n_iters=constants['n_iters']) test_env = loads(root_snapshot) train(root, test_env, show=False)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) env = make_env() obs_shape = env.observation_space.shape n_actions = env.action_space.n print('\nPrint game info:') print('observation shape:', obs_shape) print('n_actions:', n_actions) print('action names:', env.env.env.get_action_meanings()) # Print game images: s = env.reset() for _ in range(100): s, _, _, _ = env.step(env.action_space.sample()) plt.title('Game image') plt.imshow(env.render('rgb_array')) plt.show() plt.title('Agent observation (4-frame buffer') plt.imshow(s.transpose([0, 2, 1]).reshape([42, -1])) plt.show() tf.reset_default_graph() sess = tf.Session() agent = Agent('agent', obs_shape, n_actions) sess.run(tf.global_variables_initializer()) env_monitor = Monitor(env, directory='videos', force=True) game_rewards = evaluate(agent, env, sess, n_games=constants['n_sessions']) env_monitor.close() print('Game rewards:', game_rewards) # Train on parallel games - test env_batch = EnvBatch(10) batch_states = env_batch.reset() batch_actions = sample_actions(agent.step(sess, batch_states)) batch_next_states, batch_rewards, batch_done, _ = env_batch.step( batch_actions) print('State shape:', batch_states.shape) print('Actions:', batch_actions[:3]) print('Rewards:', batch_rewards[:3]) print('Done:', batch_done[:3]) # Train for real model = ActorCritic(obs_shape, n_actions, agent) train(agent, model, env, sess)
def run(constant_overwrites): # if using a GPU # os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' # # os.environ['CUDA_VISIBLE_DEVICES'] = '' # os.environ['CUDA_VISIBLE_DEVICES'] = '1' constants = merge_dict(get_constants(), constant_overwrites) file_path = load_quickdraw_dataset('apple', DATA_DIR) data = np.load( file_path ) # 28x28 grayscale bitmap in numpy format, images are centered print('') print('data.shape:', data.shape) # normalize and reshape data = data / 255 data = np.reshape(data, (data.shape[0], 28, 28, 1)) img_w, img_h = data.shape[1:3] # Sample image random_idx = np.random.randint(data.shape[0]) plt.imshow(data[random_idx, :, :, 0], cmap='Greys') plt.show() generator = generator_builder(constants) discriminator = get_discriminator(img_w, img_h, constants) adversarial_model = adversarial_builder(generator, discriminator, constants) a_metrics_complete, d_metrics_complete = train(generator, discriminator, adversarial_model, data, constants) df0 = pd.DataFrame({ 'Generative Loss': [metric[0] for metric in a_metrics_complete], 'Discriminative Loss': [metric[0] for metric in d_metrics_complete], }) ax0 = df0.plot(title='Training Loss', logy=True) ax0.set_xlabel('Epochs') ax0.set_ylabel('Loss') df1 = pd.DataFrame({ 'Generative Loss': [metric[1] for metric in a_metrics_complete], 'Discriminative Loss': [metric[1] for metric in d_metrics_complete], }) ax1 = df1.plot(title='Training Accuracy') ax1.set_xlabel('Epochs') ax1.set_ylabel('Loss')
def run(constant_overwrites): # nltk.download('stopwords') constants = merge_dict(get_constants(), constant_overwrites) x_train, y_train, x_val, y_val, x_test = load_stack_overflow_dataset() x_train = [clean_text(text) for text in x_train] x_val = [clean_text(text) for text in x_val] x_test = [clean_text(text) for text in x_test] dict_size = constants['dict_size'] train_and_test(x_train, y_train, x_val, y_val, x_test, dict_size, print_metrics=True)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) env = gym.make('CartPole-v0') env.reset() n_actions = env.action_space.n state_dim = env.observation_space.shape sess = tf.Session() agent = PolicyEstimator(state_dim, n_actions) train(env, agent, n_actions, sess, constants['n_epochs'], constants['n_iters']) record_sessions(env.spec.id, agent, n_actions, sess) env.close()
def run(constant_overwrites): constants = merge_dict(get_constants(), constant_overwrites) dataset = constants['dataset'] if dataset == 'twitter': print('Loading twitter dataset') tokens_train, tags_train, tokens_val, tags_val, tokens_test, tags_test = load_twitter_entities_dataset() elif dataset == 'nvd': print('Loading NVD dataset') tokens_train, tags_train, tokens_val, tags_val, tokens_test, tags_test, _, _, _ = load_nvd_corpus() else: print('ERR - invalid dataset') return special_tokens = ['<UNK>', '<PAD>'] special_tags = ['O'] tok2idx, idx2tok = build_dict(tokens_train + tokens_val, special_tokens) tag2idx, idx2tag = build_dict(tags_train, special_tags) vocab_size = len(tok2idx.keys()) n_tags = len(tag2idx.keys()) embedding_dim = constants['embedding_dim'] n_hidden = constants['n_hidden'] print('') print('Hyperparameters') print('---------------') print('vocab_size:', vocab_size) print('n_tags:', n_tags) print('embedding_dim:', embedding_dim) print('n_hidden:', n_hidden) tf.reset_default_graph() model = BiLSTMCRFModel(vocab_size, n_tags, embedding_dim, n_hidden) sess = tf.Session() train(model, sess, tokens_train, tags_train, tokens_val, tags_val, tok2idx, tag2idx, idx2tok, idx2tag, constants) print('-' * 20 + ' Train set quality: ' + '-' * 20) eval_conll(model, sess, tokens_train, tags_train, tok2idx, tag2idx, idx2tok, idx2tag) print('-' * 20 + ' Validation set quality: ' + '-' * 20) eval_conll(model, sess, tokens_val, tags_val, tok2idx, tag2idx, idx2tok, idx2tag) print('-' * 20 + ' Test set quality: ' + '-' * 20) eval_conll(model, sess, tokens_test, tags_test, tok2idx, tag2idx, idx2tok, idx2tag)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) env = gym.make('FrozenLake-v0') # initialize table with all zeros q_table = np.zeros([env.observation_space.n, env.action_space.n]) learning_rate = constants['learning_rate'] gamma = constants['gamma'] n_episodes = constants['n_episodes'] rewards = train(env, q_table, n_episodes, learning_rate, gamma) print('Score over time:', str(sum(rewards) / n_episodes)) print('Final Q-Table values:') print(q_table)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) if constants['train']: logging.info('Training the model...') x, y, vocab, vocab_inv, df, labels = load_crime_dataset() train(x, y, vocab, vocab_inv, labels, constants) else: logging.info('Making predictions...') trained_dir = constants['trained_dir'] if not trained_dir.endswith('/'): trained_dir += '/' params, words_index, labels, embedding_mat = load_trained_params( trained_dir) x, y, df = load_crime_test_dataset(labels) predict(x, y, df, params, words_index, labels, embedding_mat, trained_dir)
def run(constant_overwrites): tokens_train, tags_train, tokens_val, tags_val, tokens_test, tags_test = load_twitter_entities_dataset() sents_train = build_sentences(tokens_train, tags_train) sents_val = build_sentences(tokens_val, tags_val) sents_test = build_sentences(tokens_test, tags_test) x_train = [sentence_features(sent) for sent in sents_train] y_train = [sentence_labels(sent) for sent in sents_train] x_val = [sentence_features(sent) for sent in sents_val] y_val = [sentence_labels(sent) for sent in sents_val] x_test = [sentence_features(sent) for sent in sents_test] y_test = [sentence_labels(sent) for sent in sents_test] constants = merge_dict(get_constants(), constant_overwrites) algorithm = constants['algorithm'] c1 = constants['c1'] c2 = constants['c2'] max_iterations = constants['max_iterations'] all_possible_transitions = constants['all_possible_transitions'] print('') print('Hyperparameters') print('---------------') print('algorithm:', algorithm) print('c1:', c1) print('c2:', c2) print('max_iterations:', max_iterations) print('all_possible_transitions:', all_possible_transitions) # Build the CRF Model model = CRF(algorithm=algorithm, c1=c1, c2=c2, max_iterations=max_iterations, all_possible_transitions=all_possible_transitions) model.fit(x_train, y_train) print('-' * 20 + ' Train set quality: ' + '-' * 20) evaluate(model, x_train, y_train, short_report=False) print('-' * 20 + ' Validation set quality: ' + '-' * 20) evaluate(model, x_val, y_val, short_report=False) print('-' * 20 + ' Test set quality: ' + '-' * 20) evaluate(model, x_test, y_test, short_report=False)