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): 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): 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): 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) 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 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): 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() 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) 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) 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): 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): 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): 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) alphabet = constants['alphabet'] input_size = constants['input_size'] training_data = Data(train_df.utterance.values, train_df.label.values, alphabet, input_size, n_classes) training_data.load_data() x_train, y_train = training_data.get_all_data() val_data = Data(val_df.utterance.values, val_df.label.values, alphabet, input_size, n_classes) val_data.load_data() x_val, y_val = val_data.get_all_data() model = CharCNN(input_size, alphabet_size=constants['alphabet_size'], embedding_size=constants['embedding_size'], conv_layers=constants['conv_layers'], fully_connected_layers=constants['fully_connected_layers'], n_classes=n_classes, keep_prob=constants['keep_prob'], model_filename=constants['model_filename'], optimizer=constants['optimizer'], loss=constants['loss']) batch_size = constants['batch_size'] if constants['test']: print('Testing...') loss, accuracy = model.test(x_val, y_val, batch_size) print('Loss: {0:.4f}, Accuracy: {1:.0%}'.format(loss, accuracy)) else: print('Training...') model.train(x_train, y_train, x_val, y_val, n_epochs=constants['n_epochs'], batch_size=batch_size ) # , checkpoint_every=constants['checkpoint_every'])
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') # hyperparams learning_rate = constants['learning_rate'] n_hidden = constants['n_hidden'] gamma = constants['gamma'] n_epochs = constants['n_epochs'] agent = Agent(learning_rate=learning_rate, state_dim=4, n_actions=2, n_hidden=n_hidden) tf.reset_default_graph() sess = tf.Session() train(env, agent, sess, gamma=gamma, n_epochs=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) classes_txt = '/Users/d777710/src/DeepLearning/dltemplate/src/text_classification_benchmarks/fastai/classes.txt' classes = np.genfromtxt(classes_txt, dtype=str, delimiter='\t') n_classes = len(classes) vocab_labels_filename = constants['vocab_labels_filename'] if not os.path.exists(vocab_labels_filename): create_vocab_labels_file(vocab_labels_filename, classes) if constants['train']: print('Training...') train(constants['training_data_path'], n_classes, constants['learning_rate'], constants['batch_size'], constants['n_epochs'], constants['decay_steps'], constants['decay_rate'], constants['max_seq_len'], constants['embed_size'], constants['d_model'], constants['d_k'], constants['d_v'], constants['h'], constants['n_layers'], constants['l2_lambda'], constants['keep_prob'], constants['checkpoint_dir'], constants['use_embedding'], vocab_labels_filename, constants['word2vec_filename'], constants['validate_step'], constants['is_multilabel']) else: print('Testing...') result, labels = predict( constants['test_file'], n_classes, constants['learning_rate'], constants['batch_size'], constants['decay_steps'], constants['decay_rate'], constants['max_seq_len'], constants['embed_size'], constants['d_model'], constants['d_k'], constants['d_v'], constants['h'], constants['n_layers'], constants['l2_lambda'], constants['checkpoint_dir'], vocab_labels_filename, constants['word2vec_filename']) intents = [x[1][0] for x in result] preds = [list(classes).index(x) for x in intents] print('labels length:', len(labels), 'preds length:', len(preds)) y_true = [list(classes).index(x) for x in labels] print(y_true) print(preds) stats = perf_summary(y_true, preds) print_perf_summary(stats, rounded=2)
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 = read_opensubs_data('data/opensubs/OpenSubtitles') conversation_steps = [(u.split(), r.split()) for u, r in data] embeddings = load_word2vec_embeddings(limit=10000) _, vocab, vocab_size = get_vocab(conversation_steps) x_train, x_test = train_test_split(conversation_steps, test_size=0.2, random_state=42) word2id, id2word = get_symbol_to_id_mappings(vocab) embeddings_size = constants['embeddings_size'] word_embeddings = get_word_embeddings(embeddings, id2word, vocab_size, embeddings_size) tf.reset_default_graph() model = Seq2SeqModel(hidden_size=constants['n_hidden'], vocab_size=vocab_size, n_encoder_layers=constants['n_encoder_layers'], n_decoder_layers=constants['n_decoder_layers'], max_iter=constants['max_iter'], start_symbol_id=word2id[START_SYMBOL], end_symbol_id=word2id[END_SYMBOL], word_embeddings=word_embeddings, word2id=word2id, id2word=id2word) sess = tf.Session() sess.run(tf.global_variables_initializer()) all_ground_truth, all_model_predictions, invalid_number_prediction_counts = \ train(sess, model, x_train, x_test, embeddings, word2id, id2word, n_epochs=constants['n_epochs'], batch_size=constants['batch_size'], max_len=constants['max_len'], learning_rate=constants['learning_rate'], dropout_keep_prob=constants['dropout_keep_prob']) evaluate_results(all_ground_truth, all_model_predictions, invalid_number_prediction_counts) model.predict(sess, 'What is your name')
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) bandits = [0.2, 0, -0.2, -5] n_bandits = len(bandits) learning_rate = constants['learning_rate'] n_episodes = constants['n_episodes'] epsilon = constants['epsilon'] tf.reset_default_graph() sess = tf.Session() agent = Agent(n_bandits, learning_rate) _, w1 = train(bandits, agent, sess, n_episodes=n_episodes, epsilon=epsilon) print('The agent thinks bandit %s is the most promising' % str(np.argmax(w1) + 1)) if np.argmax(w1) == np.argmax(-np.array(bandits)): print('and it is right') else: print('and it is wrong')
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) outdir = constants['outdir'] run_dir = constants['run_dir'] x_train, y_train, train_lengths, x_val, y_val, val_lengths, max_length, vocab_size, classes = \ load_dataset(outdir, dirname=constants['data_dir'], vocab_name=constants['vocab_name']) if constants['test']: print('\nTesting...') preds = test(x_val, y_val, val_lengths, constants['test_batch_size'], run_dir, constants['checkpoint'], constants['model_name']) # Save all predictions with open(os.path.join(run_dir, 'predictions.csv'), 'w', encoding='utf-8', newline='') as f: csvwriter = csv.writer(f) csvwriter.writerow(['True class', 'Prediction']) for i in range(len(preds)): csvwriter.writerow([y_val[i], preds[i]]) print('Predictions saved to {}'.format( os.path.join(run_dir, 'predictions.csv'))) else: print('\nTraining...') train_data = batch_iter(x_train, y_train, train_lengths, constants['batch_size'], constants['n_epochs']) train(train_data, x_val, y_val, val_lengths, len(classes), vocab_size, constants['n_hidden'], constants['n_layers'], constants['l2_reg_lambda'], constants['learning_rate'], constants['decay_steps'], constants['decay_rate'], constants['keep_prob'], outdir, constants['num_checkpoint'], constants['evaluate_every_steps'], constants['save_every_steps'], constants['summaries_name'], constants['model_name'])
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) max_episode_length = constants['max_episode_length'] gamma = constants['gamma'] s_size = constants['s_size'] a_size = constants['a_size'] load_model = constants['load_model'] model_path = constants['model_path'] tf.reset_default_graph() if not os.path.exists(model_path): os.makedirs(model_path) # Create a directory to save episode playback gifs if not os.path.exists('./frames'): os.makedirs('./frames') with tf.device('/cpu:0'): global_episodes = tf.Variable(0, dtype=tf.int32, name='global_episodes', trainable=False) optimizer = tf.train.AdamOptimizer(learning_rate=1e-4) # Generate global network master_network = ACNetwork(s_size, a_size, 'global', None) if 'n_workers' in constants: n_workers = constants['n_workers'] else: # Set workers to number of available CPU threads n_workers = multiprocessing.cpu_count() workers = [] # Create worker classes for i in range(n_workers): workers.append( Worker(DoomGame(), i, s_size, a_size, optimizer, model_path, global_episodes, is_visible=constants['visible'], is_audible=constants['audible'])) saver = tf.train.Saver(max_to_keep=5) with tf.Session() as sess: coord = tf.train.Coordinator() if load_model: print('Loading model...') ckpt = tf.train.get_checkpoint_state(model_path) saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) # This is where the asynchronous magic happens. # Start the "work" process for each worker in a separate thread worker_threads = [] for worker in workers: work = lambda: worker.work(max_episode_length, gamma, sess, coord, saver) t = threading.Thread(target=work) t.start() sleep(0.5) worker_threads.append(t) coord.join(worker_threads)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) n_sessions = constants['n_sessions'] # sample this many sessions percentile = constants[ 'percentile'] # take this percent of sessions with highest rewards env_id = constants['env_id'] if env_id == 'Taxi-v2': env = gym.make('Taxi-v2') env.reset() n_states = env.observation_space.n n_actions = env.action_space.n print('n_states = %i, n_actions = %i' % (n_states, n_actions)) policy = np.ones((n_states, n_actions)) / n_actions # plot initial reward distribution sample_rewards = [ generate_session(env, policy, n_actions, t_max=1000)[-1] for _ in range(200) ] plt.hist(sample_rewards, bins=20) plt.vlines([np.percentile(sample_rewards, 50)], [0], [100], label="50'th percentile", color='green') plt.vlines([np.percentile(sample_rewards, 90)], [0], [100], label="90'th percentile", color='red') plt.legend() plt.show() learning_rate = constants['learning_rate'] log = [] for i in range(100): sessions = [ generate_session(env, policy, n_actions) for _ in range(n_sessions) ] states_batch, actions_batch, rewards_batch = zip(*sessions) elite_states, elite_actions = select_elites( states_batch, actions_batch, rewards_batch, percentile) new_policy = update_policy(elite_states, elite_actions, n_states, n_actions) policy = learning_rate * new_policy + (1 - learning_rate) * policy show_progress(rewards_batch, log, percentile) elif env_id in ('CartPole-v0', 'MountainCar-v0'): env = gym.make(env_id).env env.reset() n_actions = env.action_space.n agent = agent_builder(constants) # initialize agent to the dimension of state and number of actions agent.fit([env.reset()] * n_actions, range(n_actions)) log = [] for i in range(100): sessions = [ generate_agent_session(env, agent, n_actions) for _ in range(n_sessions) ] states_batch, actions_batch, rewards_batch = map( np.array, zip(*sessions)) elite_states, elite_actions = select_elites( states_batch, actions_batch, rewards_batch, percentile) agent.fit(elite_states, elite_actions) show_progress(rewards_batch, log, percentile)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) transition_probs = { 's0': { 'a0': { 's0': 0.5, 's2': 0.5 }, 'a1': { 's2': 1 } }, 's1': { 'a0': { 's0': 0.7, 's1': 0.1, 's2': 0.2 }, 'a1': { 's1': 0.95, 's2': 0.05 } }, 's2': { 'a0': { 's0': 0.4, 's1': 0.6 }, 'a1': { 's0': 0.3, 's1': 0.3, 's2': 0.4 } } } rewards = {'s1': {'a0': {'s0': +5}}, 's2': {'a1': {'s0': -1}}} mdp = MDP(transition_probs, rewards, initial_state='s0') print('initial state =', mdp.reset()) next_state, reward, done, info = mdp.step('a1') print('next_state = %s, reward = %s, done = %s' % (next_state, reward, done)) # See rl.utils for function to calculate action value, and to get optimal action gamma = constants['gamma'] n_iter = constants['n_iter'] min_difference = constants['min_difference'] # Run baseline scenario # initialize V(s) state_values = {s: 0 for s in mdp.get_all_states()} value_iteration(mdp, None, gamma, n_iter, min_difference) # Measure agent's average reward s = mdp.reset() rewards = [] for _ in range(10000): s, r, done, _ = mdp.step( get_optimal_action(mdp, state_values, s, gamma)) rewards.append(r) print('average reward: ', np.mean(rewards)) # Run Frozen Lake Scenarios print('\n') visualize_frozen_lake_actions(map_name='4x4', slip_chance=0, n_iter=100, gamma=gamma) print('\n') visualize_frozen_lake_value_iteration(map_name='8x8', slip_chance=0, n_iter=30) for slip_chance in [0, 0.1, 0.25]: print('\n') run_frozen_lake(map_name='4x4', slip_chance=slip_chance, n_iter=1000, gamma=gamma) print('\n') run_frozen_lake(map_name='8x8', slip_chance=0.2, n_iter=1000, gamma=gamma)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) mode = constants['mode'] easy_mode = constants['easy_mode'] # max_output_length = 20 if easy_mode else 50 word_to_translation = load_hebrew_to_english_dataset(mode, easy_mode) all_words = np.array(list(word_to_translation.keys())) all_translations = np.array( [ts for all_ts in word_to_translation.values() for ts in all_ts]) # split the dataset train_words, test_words = train_test_split(all_words, test_size=0.1, random_state=42) # build vocab bos = '_' eos = ';' inp_voc = Vocab.from_lines(''.join(all_words), bos=bos, eos=eos, sep='') out_voc = Vocab.from_lines(''.join(all_translations), bos=bos, eos=eos, sep='') # test casting lines into ids and back again batch_lines = all_words[:5] batch_ids = inp_voc.to_matrix(batch_lines) batch_lines_restored = inp_voc.to_lines(batch_ids) print('lines:') print(batch_lines) print('\nwords to ids (0=bos, 1=eos):') print(batch_ids) print('\nback to words:') print(batch_lines_restored) # plot word/translation length distributions to estimate the scope of the task plt.figure(figsize=[8, 4]) plt.subplot(1, 2, 1) plt.title('words') plt.hist(list(map(len, all_words)), bins=20) plt.subplot(1, 2, 2) plt.title('translations') plt.hist(list(map(len, all_translations)), bins=20) model = BasicTranslationModel('model', inp_voc, out_voc, n_embedding=64, n_hidden=128) sess = tf.Session() sess.run(tf.global_variables_initializer()) # test translation input_sequence = tf.placeholder('int32', [None, None]) greedy_translations, logp = model.symbolic_translate(input_sequence, greedy=True) def translate(lines): """ You are given a list of input lines, make your neural network translate them. :param lines: :return: a list of output lines """ # convert lines to a matrix of indices lines_ix = inp_voc.to_matrix(lines) # compute translations in form of indices trans_ix = sess.run(greedy_translations, {input_sequence: lines_ix}) # convert translations back into strings return out_voc.to_lines(trans_ix) print('Sample inputs:', all_words[:3]) print('Dummy translations:', translate(all_words[:3])) assert isinstance(greedy_translations, tf.Tensor) and greedy_translations.dtype.is_integer, \ 'translation must be a tensor of integers (token ids)' assert translate(all_words[:3]) == translate(all_words[:3]), \ 'make sure translation is deterministic (use greedy=True and disable any noise layers)' # assert type(translate(all_words[:3])) is list and \ # (type(translate(all_words[:1])[0]) is str or type(translate(all_words[:1])[0]) is unicode), \ # 'translate(lines) must return a sequence of strings' assert type(translate(all_words[:3])) is list and type(translate(all_words[:1])[0]) is str, \ 'translate(lines) must return a sequence of strings' print('Tests passed!') # initialize optimizer params while keeping model intact initialize_uninitialized(sess) n_epochs = constants['n_epochs'] # report_freq = constants['report_freq'] sup_trainer = SupervisedTrainer(model, out_voc) train(train_words, test_words, word_to_translation, inp_voc, out_voc, translate, sup_trainer, sess, n_epochs, report_freq=5000) evaluate(train_words, test_words, word_to_translation, translate) # Self-critical policy gradient trainer = Trainer(model, inp_voc, out_voc, word_to_translation) initialize_uninitialized(sess) train_policy_gradients(train_words, test_words, word_to_translation, inp_voc, out_voc, translate, trainer, sess, n_epochs=100000, batch_size=32, report_freq=20000) evaluate(train_words, test_words, word_to_translation, translate)
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) activates, negatives, backgrounds = load_raw_audio() # Should be 10,000, since it is a 10 sec clip print('background len:', str(len(backgrounds[0]))) # Maybe around 1000, since an "activate" audio clip is usually around 1 sec (but varies a lot) print('activate[0] len:', str(len(activates[0]))) # Different "activate" clips can have different lengths print('activate[1] len:', str(len(activates[1]))) x = np.load(DATA_DIR + 'XY_train/X.npy') y = np.load(DATA_DIR + 'XY_train/Y.npy') x_dev = np.load(DATA_DIR + 'XY_dev/X_dev.npy') y_dev = np.load(DATA_DIR + 'XY_dev/Y_dev.npy') if constants['retrain']: # number of time steps input to the model from the spectrogram # use tx=1101, ty=272 for 2sec audio input tx = 5511 # number of frequencies input to the model at each time step of the spectrogram n_freq = 101 model = build_model(input_shape=(tx, n_freq)) n_epochs = constants['n_epochs'] learning_rate = constants['learning_rate'] else: # Load pre-trained model # Wake-word detection takes a long time to train. To save time, this model has been # trained for about 3 hours on a GPU using the same architecture and a large training # set of about 4000 examples. model = load_model(DATA_DIR + 'models/tr_model.h5') n_epochs = 1 learning_rate = 0.0001 batch_size = constants['batch_size'] fit(x, y, model, epochs=n_epochs, batch_size=batch_size, learning_rate=learning_rate) chunk_duration = 0.5 # read length in seconds from mic fs = 44100 # sampling rate for mic chunk_samples = int(fs * chunk_duration) # read length in number of samples prob_threshold = 0.5 if constants['live']: # Record audio stream from mic # model input duration in seconds (int) feed_duration = 10 feed_samples = int(fs * feed_duration) assert feed_duration / chunk_duration == int(feed_duration / chunk_duration) # Queue to communicate between the audio callback and main thread q = Queue() listening = True silence_threshold = 100 # Run the demo until timeout timeout = time.time() + 30 # 30 seconds # data buffer for the input waveform data = np.zeros(feed_samples, dtype='int16') # noinspection PyUnusedLocal def callback(data_in, frame_count, time_info, status): nonlocal data, listening, silence_threshold, timeout if time.time() > timeout: listening = False data_ = np.frombuffer(data_in, dtype='int16') if np.abs(data_).mean() < silence_threshold: sys.stdout.write('-') return data_in, pyaudio.paContinue else: sys.stdout.write('.') data = np.append(data, data_) if len(data) > feed_samples: data = data[-feed_samples:] q.put(data) return data_in, pyaudio.paContinue stream = get_audio_input_stream(fs, chunk_samples, callback) stream.start_stream() print('Listening...') try: while listening: data = q.get() spectrum = get_spectrogram(data) predictions = detect_wake_word(model, spectrum) if has_wake_word(predictions, chunk_duration, feed_duration, prob_threshold): sys.stdout.write('1') sys.stdout.flush() except (KeyboardInterrupt, SystemExit): stream.stop_stream() stream.close() timeout = time.time() # listening = False print('\nStopped!') stream.stop_stream() stream.close() elif constants['test_mic']: data = None # noinspection PyUnusedLocal def callback(data_in, frame_count, time_info, status): nonlocal data data = np.frombuffer(data_in, dtype='int16') print('mean:', np.abs(data).mean(), 'max:', np.abs(data).max()) return data_in, pyaudio.paContinue stream = get_audio_input_stream(fs, chunk_samples, callback) stream.start_stream() time.sleep(10) # 10 seconds stream.stop_stream() stream.close() plot_spectrogram(data) else: # Test the model loss, acc = model.evaluate(x_dev, y_dev) print('Dev set accuracy =', acc) chime_threshold = 0.5 filename = DATA_DIR + 'raw_data/dev/1.wav' predictions = detect_wake_word_from_file(model, filename) plot_spectrogram_and_probs_from_file(model, filename) chime_on_activate(filename, predictions, chime_threshold) play(AudioSegment.from_wav('./chime_output.wav')) filename = DATA_DIR + 'audio_examples/my_audio.wav' preprocess_audio(filename) predictions = detect_wake_word_from_file(model, filename) plot_spectrogram_and_probs_from_file(model, filename) chime_on_activate(filename, predictions, chime_threshold) play(AudioSegment.from_wav('./chime_output.wav'))
def run(constant_overwrites): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) # Initializing the Gridworld with True limits the field of view, resulting # in a partially observable MDP. Initializing it with False provides the # agent with the entire environment, resulting in a fully observable MDP. env = GameEnvironment(partial=True, size=9) 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'] trace_length = constants['trace_length'] save_path = constants['save_path'] load_model = constants['load_model'] n_episodes = constants['n_episodes'] max_episode_length = constants['max_episode_length'] n_pretrain_steps = constants['n_pretrain_steps'] batch_size = constants['batch_size'] update_freq = constants['update_freq'] summary_length = constants['summary_length'] time_per_step = constants['time_per_step'] rewards, _ = train(env, n_hidden, start_epsilon, end_epsilon, annealing_steps, tau, gamma, learning_rate, trace_length, save_path, load_model, n_episodes, max_episode_length, n_pretrain_steps, batch_size, update_freq, summary_length, time_per_step) # 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() print('Test the network...') config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.test.yml') constants = merge_dict(constants, load_hyperparams(config_path)) n_hidden = constants['n_hidden'] save_path = constants['save_path'] load_model = constants['load_model'] n_episodes = constants['n_episodes'] max_episode_length = constants['max_episode_length'] summary_length = constants['summary_length'] time_per_step = constants['time_per_step'] epsilon = constants['epsilon'] rewards, _ = test(env, n_hidden, save_path, load_model, n_episodes, max_episode_length, summary_length, time_per_step, epsilon) # 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): config_path = os.path.join(os.path.dirname(__file__), 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) set_experiment_defaults( constants, { 'experiment_name': make_experiment_name(), 'model_name': 'summarization', 'model_description': 'Pointer-generator network for text summarization', 'model_type': 'RNN', 'library': 'TensorFlow', 'library_version': '1.2.1', 'author_username': '******', 'author_uri': 'https://github.com/markmo' }) record_experiment(constants) tf.logging.set_verbosity(tf.logging.INFO) tf.logging.info('Starting seq2seq_attention in %s mode...', constants['mode']) constants['log_root'] = os.path.join(constants['log_root'], constants['experiment_name']) if not os.path.exists(constants['log_root']): if constants['mode'] == 'train': os.makedirs(constants['log_root']) else: raise Exception( "log_root %s doesn't exist. Run in train mode to create it." % constants['log_root']) vocab = Vocab(constants['vocab_path'], constants['vocab_size']) # If in decode mode, set batch_size = beam_size # Reason: in decode mode, we decode one example at a time. # On each step, we have beam_size-many hypotheses in the beam, # so we need to make a batch of these hypotheses. if constants['mode'] == 'decode': constants['batch_size'] = constants['beam_size'] # If single_pass=True, then check we're in decode mode if constants['single_pass'] and constants['mode'] != 'decode': raise Exception( 'The single_pass flag should only be True in decode mode.') # Make a namedtuple `config` with the hyperparameters the model needs hparams = [ 'mode', 'learning_rate', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps', 'coverage', 'cov_loss_wt', 'pointer_gen', 'log_root' ] config_dict = {k: v for k, v in constants.items() if k in hparams} config = namedtuple('Hyperparams', config_dict.keys())(**config_dict) # Create a Batcher object that will create minibatches of data batcher = Batcher(constants['data_path'], vocab, config, single_pass=constants['single_pass']) tf.set_random_seed(111) # noinspection PyUnresolvedReferences if config.mode == 'train': print('Creating model...') model = SummarizationModel(config, vocab) setup_training(model, batcher, constants) elif config.mode == 'eval': model = SummarizationModel(config, vocab) run_eval(model, batcher, constants) elif config.mode == 'decode': # The model is configured with max_dec_steps=1 because we only ever # run one step of the decoder at a time (to do beam search). Note that # the batcher is initialized with max_dec_steps equal to, say 100, # because the batches need to contain the full summaries. # noinspection PyProtectedMember,PyUnresolvedReferences dec_model_conf = config._replace(max_dec_steps=1) model = SummarizationModel(dec_model_conf, vocab) decoder = BeamSearchDecoder(model, batcher, vocab, constants) # decode indefinitely (unless single_pass=True, in which case decode the dataset exactly once.) decoder.decode() else: raise ValueError( "The 'mode' flag must be one of ['train', 'eval', 'decode']")
def run(constant_overwrites): dir_path = os.path.dirname(os.path.realpath(__file__)) config_path = os.path.join(dir_path, 'hyperparams.yml') constants = merge_dict(load_hyperparams(config_path), constant_overwrites) # data subdir expected to exist LM_PATH.mkdir(exist_ok=True) (LM_PATH / 'tmp').mkdir(exist_ok=True) CLAS_PATH.mkdir(exist_ok=True) (CLAS_PATH / 'tmp').mkdir(exist_ok=True) data_path = dir_path + '/train.csv' if not os.path.exists(data_path): train_df, val_df, test_df, x_train, y_train, x_val, y_val, x_test, y_test, classes = preprocess_csv( ) else: train_df = pd.read_csv(dir_path + '/train.csv', header=None, chunksize=CHUNKSIZE) # x_train, y_train = train_df[0].values, train_df[1].values val_df = pd.read_csv(dir_path + '/val.csv', header=None, chunksize=CHUNKSIZE) # x_val, y_val = val_df[0].values, val_df[1].values # test_df = pd.read_csv(dir_path + '/test.csv', header=None, chunksize=CHUNKSIZE) # x_test, y_test = test_df[0].values, test_df[1].values # classes = np.genfromtxt(dir_path + '/classes.txt', dtype=str) # print('Counts x_train: {}, y_train: {}, x_val: {}, y_val: {}, x_test: {}, y_test: {}, classes: {}' # .format(len(x_train), len(y_train), len(x_val), len(y_val), len(x_test), len(y_test), len(classes))) if constants['train_lm']: logging.info('Training LM...') if (LM_PATH / 'tmp' / 'tok_train.npy').exists(): logging.info('Loading tokens...') tok_train = np.load(LM_PATH / 'tmp' / 'tok_train.npy') tok_val = np.load(LM_PATH / 'tmp' / 'tok_val.npy') else: logging.info('Get tokens...') tok_train, labels_train = get_all(train_df, 1) tok_val, labels_val = get_all(val_df, 1) np.save(LM_PATH / 'tmp' / 'tok_train.npy', tok_train) np.save(LM_PATH / 'tmp' / 'tok_val.npy', tok_val) if (LM_PATH / 'tmp' / 'itos.pkl').exists(): train_ids = np.load(LM_PATH / 'tmp' / 'train_ids.npy') val_ids = np.load(LM_PATH / 'tmp' / 'val_ids.npy') itos = pickle.load(open(LM_PATH / 'tmp' / 'itos.pkl', 'rb')) else: freq = collections.Counter(t for ts in tok_train for t in ts) itos = [t for t, k in freq.most_common(MAX_VOCAB) if k > MIN_FREQ] # int idx to str token itos.insert(0, '_pad_') itos.insert(1, '_unk_') stoi = collections.defaultdict( lambda: 0, {t: i for i, t in enumerate(itos)}) # str token to int idx train_ids = np.array([[stoi[t] for t in ts] for ts in tok_train]) val_ids = np.array([[stoi[t] for t in ts] for ts in tok_val]) np.save(LM_PATH / 'tmp' / 'train_ids.npy', train_ids) np.save(LM_PATH / 'tmp' / 'val_ids.npy', val_ids) pickle.dump(itos, open(LM_PATH / 'tmp' / 'itos.pkl', 'wb')) vocab_size = len(itos) emb_dim, n_hidden, n_layers = 400, 1150, 3 pre_path = PATH / 'models' / 'wt103' pre_lm_path = pre_path / 'fwd_wt103.h5' w = torch.load(pre_lm_path, map_location=lambda storage, loc: storage) enc_w = fastai.to_np(w['0.encoder.weight']) row_mean = enc_w.mean(0) itos_model = pickle.load((pre_path / 'itos_wt103.pkl').open('rb')) stoi_model = collections.defaultdict( lambda: -1, {t: i for i, t in enumerate(itos_model)}) new_w = np.zeros((vocab_size, emb_dim), dtype=np.float32) for i, t in enumerate(itos): j = stoi_model[t] new_w[i] = enc_w[j] if j >= 0 else row_mean w['0.encoder.weight'] = fastai.T(new_w) w['0.encoder_with_dropout.embed.weight'] = fastai.T(np.copy(new_w)) w['1.decoder.weight'] = fastai.T(np.copy(new_w)) wd = 1e-7 # weight decay bptt = 70 # backpropagation through time, a.k.a. ngrams batch_size = 52 optimizer_fn = functools.partial(torch.optim.Adam, betas=(0.8, 0.99)) dl_train = ftext.LanguageModelLoader(np.concatenate(train_ids), batch_size, bptt) # data loader dl_val = ftext.LanguageModelLoader(np.concatenate(val_ids), batch_size, bptt) md = ftext.LanguageModelData(PATH, 1, vocab_size, dl_train, dl_val, batch_size=batch_size, bptt=bptt) drops = np.array([0.25, 0.1, 0.2, 0.02, 0.15]) * 0.7 learner = md.get_model(optimizer_fn, emb_dim, n_hidden, n_layers, dropouti=drops[0], dropout=drops[1], wdrop=drops[2], dropoute=drops[3], dropouth=drops[4]) learner.metrics = [fmetrics.accuracy] learner.freeze_to(-1) learner.model.load_state_dict(w) lr = 1e-3 lrs = lr learner.fit(lrs / 2, 1, wds=wd, use_clr=(32, 2), cycle_len=1) learner.save('lm_last_ft') learner.lr_find(start_lr=lrs / 10, end_lr=lrs * 10, linear=True) learner.sched.plot() learner.fit(lrs, 1, wds=wd, use_clr=(20, 10), cycle_len=15) learner.save('lm1') learner.save_encoder('lm1_enc') learner.sched.plot_loss() if (CLAS_PATH / 'tmp' / 'tok_train.npy').exists(): tok_train = np.load(CLAS_PATH / 'tmp' / 'tok_train.npy') tok_val = np.load(CLAS_PATH / 'tmp' / 'tok_val.npy') labels_train = np.load(CLAS_PATH / 'tmp' / 'labels_train.npy') labels_val = np.load(CLAS_PATH / 'tmp' / 'labels_val.npy') else: tok_train, labels_train = get_all(train_df, 1) tok_val, labels_val = get_all(val_df, 1) np.save(CLAS_PATH / 'tmp' / 'tok_train.npy', tok_train) np.save(CLAS_PATH / 'tmp' / 'tok_val.npy', tok_val) np.save(CLAS_PATH / 'tmp' / 'labels_train.npy', labels_train) np.save(CLAS_PATH / 'tmp' / 'labels_val.npy', labels_val) if (CLAS_PATH / 'tmp' / 'itos.pkl').exists(): train_ids = np.load(CLAS_PATH / 'tmp' / 'train_ids.npy') val_ids = np.load(CLAS_PATH / 'tmp' / 'val_ids.npy') itos = pickle.load(open(CLAS_PATH / 'tmp' / 'itos.pkl', 'rb')) else: freq = collections.Counter(t for ts in tok_train for t in ts) itos = [t for t, k in freq.most_common(MAX_VOCAB) if k > MIN_FREQ] # int idx to str token itos.insert(0, '_pad_') itos.insert(1, '_unk_') stoi = collections.defaultdict( lambda: 0, {t: i for i, t in enumerate(itos)}) # str token to int idx train_ids = np.array([[stoi[t] for t in ts] for ts in tok_train]) val_ids = np.array([[stoi[t] for t in ts] for ts in tok_val]) np.save(CLAS_PATH / 'tmp' / 'train_ids.npy', train_ids) np.save(CLAS_PATH / 'tmp' / 'val_ids.npy', val_ids) pickle.dump(itos, open(CLAS_PATH / 'tmp' / 'itos.pkl', 'wb')) vocab_size = len(itos) bptt = 70 # backpropagation through time, a.k.a. ngrams emb_dim, n_hidden, n_layers = 400, 1150, 3 # optimizer_fn = functools.partial(optim.Adam, betas=(0.8, 0.99)) batch_size = 48 min_label = min(labels_train) labels_train -= min_label labels_val -= min_label k = int(max(labels_train)) + 1 ds_train = ftext.TextDataset(train_ids, labels_train) ds_val = ftext.TextDataset(val_ids, labels_val) sampler_train = ftext.SortishSampler(train_ids, key=lambda x: len(train_ids[x]), bs=batch_size // 2) sampler_val = ftext.SortSampler(val_ids, key=lambda x: len(val_ids[x])) dl_train = dataloader.DataLoader(ds_train, batch_size // 2, transpose=True, num_workers=1, pad_idx=1, sampler=sampler_train) dl_val = dataloader.DataLoader(ds_val, batch_size // 2, transpose=True, num_workers=1, pad_idx=1, sampler=sampler_val) md = fdata.ModelData(PATH, dl_train, dl_val) # drops = np.array([0.4, 0.5, 0.05, 0.3, 0.1]) drops = np.array([0.4, 0.5, 0.05, 0.3, 0.4]) * 0.5 model = lm_rnn.get_rnn_classifier(bptt, 20 * 70, k, vocab_size, emb_sz=emb_dim, n_hid=n_hidden, n_layers=n_layers, pad_token=1, layers=[emb_dim * 3, 50, k], drops=[drops[4], 0.1], dropouti=drops[0], wdrop=drops[1], dropoute=drops[2], dropouth=drops[3]) optimizer_fn = functools.partial(torch.optim.Adam, betas=(0.7, 0.99)) # learner = RNN_Learner(md, TextModel(to_gpu(model)), opt_fn=optimizer_fn) learner = ftext.RNN_Learner(md, ftext.TextModel(model), opt_fn=optimizer_fn) learner.reg_fn = functools.partial(lm_rnn.seq2seq_reg, alpha=2, beta=1) learner.clip = 25.0 learner.metrics = [fmetrics.accuracy] # lr = 3e-3 # lrm = 2.6 # lrs = np.array([lr / lrm**4, lr / lrm**3, lr / lrm**2, lr / lrm, lr]) lrs = np.array([1e-4, 1e-4, 1e-4, 1e-3, 1e-2]) # wd = 1e-7 # weight decay wd = 0 learner.load_encoder('lm1_enc') learner.freeze_to(-1) learner.lr_find(lrs / 1000) learner.sched.plot() learner.fit(lrs, 1, wds=wd, cycle_len=1, use_clr=(8, 3)) learner.save('clas_0')