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')
