def train(opts):
"""
:param inputs: n x t x d input matrix
:param labels: n x t x d label matrix
:return:
"""
n_epoch = opts.epoch
save_path = opts.save_path
n_batch_per_epoch = opts.n_input // opts.batch_size
with tf.Graph().as_default() as graph:
if not os.path.exists(opts.save_path):
os.makedirs(opts.save_path)
X, Y = inputs.create_inputs(opts)
X_pl, Y_pl = create_placeholders(opts)
train_iter, next_element = create_tf_dataset(X_pl, Y_pl,
opts.batch_size)
model = RNN(next_element[0], next_element[1], opts, training=True)
logger = defaultdict(list)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
sess.run(train_iter.initializer, feed_dict={X_pl: X, Y_pl: Y})
if opts.load_checkpoint:
model.load()
else:
rnn_helper.initialize_weights(opts)
for ep in range(n_epoch):
for b in range(n_batch_per_epoch):
cur_loss, xe_loss, weight_loss, activity_loss, _ = sess.run(
[
model.total_loss, model.xe_loss, model.weight_loss,
model.activity_loss, model.train_op
])
if (ep % 1 == 0 and ep > 0): #save to loss file
logger['epoch'] = ep
logger['loss'].append(cur_loss)
logger['xe_loss'].append(xe_loss)
logger['activity_loss'].append(activity_loss)
logger['weight_loss'].append(weight_loss)
if (ep % 25 == 0 and ep > 0): #display in terminal
print(
'[*] Epoch %d total_loss=%.2f xe_loss=%.2f a_loss=%.2f, w_loss=%.2f'
% (ep, cur_loss, xe_loss, activity_loss, weight_loss))
#save latest
model.save()
utils.save_parameters(opts,
os.path.join(save_path, opts.parameter_name))
model.save_weights()
save_activity(model, next_element[0], next_element[1])
with open(os.path.join(save_path, opts.log_name + '.pkl'),
'wb') as f:
pkl.dump(logger, f)
def main():
args = parser.parse_args()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
hyperparams = load_parameters(args.hyperparameter_path)
orion_hp_string, hyperparams = prep_orion(args, hyperparams)
save_loc, hyperparams = generate_save_loc(args, hyperparams, orion_hp_string)
save_parameters(save_loc, hyperparams)
if not os.path.exists(save_loc):
os.makedirs(save_loc)
data_dict = read_data(args.data_path)
train_dl, valid_dl, plotter, model, objective = prep_model(model_name = args.model,
data_dict = data_dict,
data_suffix = args.data_suffix,
batch_size = args.batch_size,
device = device,
hyperparams = hyperparams)
print_model_description(model)
transforms = trf.Compose([])
optimizer, scheduler = prep_optimizer(model, hyperparams)
if args.use_tensorboard:
writer, rm_plotter = prep_tensorboard(save_loc, plotter, args.restart)
else:
writer = None
rm_plotter = None
run_manager = RunManager(model = model,
objective = objective,
optimizer = optimizer,
scheduler = scheduler,
train_dl = train_dl,
valid_dl = valid_dl,
transforms = transforms,
writer = writer,
plotter = rm_plotter,
max_epochs = args.max_epochs,
save_loc = save_loc,
do_health_check = args.do_health_check,
detect_local_minima = args.detect_local_minima,
load_checkpoint=(not args.restart))
run_manager.run()
save_figs(save_loc, run_manager.model, run_manager.valid_dl, plotter)
pickle.dump(run_manager.loss_dict, open(save_loc+'/loss.pkl', 'wb'))
def main_train():
train_data = TRAIN
dev_data = DEV
params = create_classifier([len(F2I), 800, 400, 200, 50, len(L2I)])
num_iterations = 100
learning_rate = 10**-4
trained_params = train_classifier(train_data, dev_data, num_iterations,
learning_rate, params)
save_parameters(trained_params)
def main():
# np.random.seed(2)
# tf.set_random_seed(2) # reproducible
y_axis_ticks = [-25, -20, -15, -10, -5, 0]
weights_path = './logs/weights/'
data_path = './logs/data/'
hp = Hyperparameters()
gpu_options = tf.GPUOptions(allow_growth=True)
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
# self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True))
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# env_name = 'Pong-ram-v0'
env_name = 'Pong-v0'
# env_name = 'PongNoFrameskip-v4'
env = gym.make(env_name)
env.seed(1) # reproducible
env = env.unwrapped
if env_name == 'Pong-ram-v0':
actor = Actor(sess, n_features=128, n_actions=hp.N_A, lr=hp.LR_A, ram=True)
# we need a good teacher, so the teacher should learn faster than the actor
critic = Critic(sess, n_features=128, lr=hp.LR_C, discount=hp.GAMMA, ram=True)
else:
actor = Actor(sess, n_features=hp.N_F, n_actions=hp.N_A, lr=hp.LR_A)
# we need a good teacher, so the teacher should learn faster than the actor
critic = Critic(sess, n_features=hp.N_F, lr=hp.LR_C, discount=hp.GAMMA)
sess.run(tf.global_variables_initializer())
if hp.OUTPUT_GRAPH:
tf.summary.FileWriter("./logs/", sess.graph)
episodes = []
episode_rewards = []
running_rewards = []
total_steps = 0
saver, load_episode = restore_parameters(sess, weights_path)
probs_path = data_path + 'probs_' + str(0) + '.txt'
td_exp_path = data_path + 'td_exp_' + str(0) + '.txt'
# write_file(probs_path, 'probs\n', True)
# write_file(td_exp_path, 'td_exp\n', True)
for i_episode in range(hp.MAX_EPISODE):
s = env.reset()
if env_name != 'Pong-ram-v0':
s = preprocess_image(s, hp.N_F)
# show_gray_image(s)
# assert to check: whether there is nan in s.
assert np.isnan(np.min(s.ravel())) == False
episode_steps = 0
track_r = []
while True:
# if hp.RENDER:
# env.render()
env.render()
a, probs = actor.choose_action(s)
probs = np.around(probs, decimals=4)
# content = str([i_episode, total_steps]) + ' ' + str(probs.tolist()) + '\n'
# write_file(probs_path, content, False)
# print('------------------------------------', probs)
if episode_steps % 50 == 0: # episode_steps % 10 --> reserve the ball.
a = 1
# a = np.random.random_integers(0, 3)
s_, r, done, info = env.step(a)
if env_name != 'Pong-ram-v0':
s_ = preprocess_image(s_, hp.N_F)
# show_gray_image(s)
assert np.isnan(np.min(s_.ravel())) == False
if done:
r = -2
track_r.append(r)
td_error = critic.learn(s, r, s_) # gradient = grad[r + gamma * V(s_) - V(s)]
exp_v = actor.learn(s, a, td_error) # true_gradient = grad[logPi(s,a) * td_error]
# # debug mode # #
# exp_v, act_prob, log_prob, l1 = actor.learn(s, a, td_error)
# # debug mode # #
# content = str([i_episode, total_steps]) + ' ' + str(td_error) + ' ' + str(exp_v) + '\n'
# write_file(td_exp_path, content, False)
s = s_
episode_steps += 1
total_steps += 1
if done:
# print(episode_steps)
ep_rs_sum = sum(track_r)
aa = track_r.count(1)
if 'running_reward' not in globals() and 'running_reward' not in locals():
running_reward = ep_rs_sum
else:
running_reward = running_reward * 0.95 + ep_rs_sum * 0.05
running_rewards.append(running_reward)
# print(len(running_rewards))
if len(running_rewards) % hp.SAVED_INTERVAL == 0:
# write_file(data_path + 'rewards_' + str(i_episode) + '.txt', running_rewards, True)
plot_rewards(running_rewards, y_axis_ticks, data_path)
if i_episode % hp.SAVED_INTERVAL_NET == 0 and i_episode != 0:
save_parameters(sess, weights_path, saver,
weights_path + '-' + str(load_episode + i_episode))
if i_episode % hp.SAVED_INTERVAL == 0 and i_episode != 0:
probs_path = data_path + 'probs_' + str(i_episode) + '.txt'
exp_v_path = data_path + 'td_exp_' + str(i_episode) + '.txt'
# if running_reward > hp.DISPLAY_REWARD_THRESHOLD:
# hp.RENDER = True # rendering
# if 0 <= i_episode % 2000 < 50:
# hp.RENDER = True # periodical rendering
# if i_episode % 2000 == 50:
# hp.RENDER = False # periodical rendering
# # debug mode # #
# print('\naction:', a, 'td_error:', td_error, 'exp_v:', exp_v, 'act_prob:', act_prob, 'log_prob:',
# log_prob, 'l1:', l1)
# # debug mode # #
print("episode: {0}, running reward: {1:.4f}, episode reward: {2}, td error: {3}, exp_v: {4}".
format(i_episode, running_reward, ep_rs_sum, td_error, exp_v))
break
def save(self, path):
save_parameters(path + "/parameters.pkl", self.params)
save_parameters(path + "/m.pkl", self.m)
save_parameters(path + "/v.pkl", self.v)
def main():
env = gym.make('Breakout-v0')
# env.seed(1) # reproducible
# env = env.unwrapped
gpu_options = tf.GPUOptions(allow_growth=True)
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
# self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True))
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
actor = Actor(sess, crop_size=CROP_SIZE, n_actions=N_A, lr=LR_A)
critic = Critic(sess, crop_size=CROP_SIZE, lr=LR_C)
sess.run(tf.global_variables_initializer())
if OUTPUT_GRAPH:
tf.summary.FileWriter("logs/Breakout/", sess.graph)
episodes = []
episode_rewards = []
running_rewards = []
total_steps = 0
running_reward = -10
saver, load_episode = restore_parameters(sess, weights_path)
write_file(data_path + 'probs.txt', 'probs\n', True)
for i_episode in range(MAX_EPISODE):
s = env.reset()
s = preprocess_image(s)
episode_steps = 0
track_r = []
while True:
# if RENDER:
# env.render()
a, probs = actor.choose_action(s)
print(probs)
probs = np.around(probs, decimals=4)
write_file(
data_path + 'probs.txt',
str([i_episode, total_steps]) + ' ' + str(probs.tolist()) +
'\n', False)
# if episode_steps % 20 == 0: # episode_steps % 10 --> reserve the ball.
# a = 1
# a = np.random.random_integers(0, 3)
s_, r, done, info = env.step(a)
s_ = preprocess_image(s_)
if done:
r = -10 # -20
track_r.append(r)
td_error = critic.learn(
s, r, s_) # gradient = grad[r + gamma * V(s_) - V(s)]
actor.learn(
s, a, td_error) # true_gradient = grad[logPi(s,a) * td_error]
s = s_
episode_steps += 1
total_steps += 1
if done:
ep_rs_sum = sum(track_r)
episodes.append(episodes)
episode_rewards.append(ep_rs_sum)
running_reward = running_reward * 0.95 + ep_rs_sum * 0.05
running_rewards.append(running_reward)
if len(running_rewards) % SAVED_INTERVAL == 0:
write_file(
data_path + 'rewards_' + str(i_episode) + '.txt',
running_rewards, True)
plot_rewards(running_rewards, y_axis_ticks, data_path)
if i_episode % SAVED_INTERVAL == 0 and i_episode != 0:
save_parameters(
sess, weights_path, saver,
weights_path + '-' + str(load_episode + i_episode))
# if running_reward > DISPLAY_REWARD_THRESHOLD:
# RENDER = True # rendering
print(
"---------------------------------------------------------------episode:",
i_episode, " episode reward:", ep_rs_sum,
" running reward:", round(running_reward, 4))
# time.sleep(0.5)
break
def train(opts, seed=False):
"""
:param inputs: n x t x d input matrix
:param labels: n x t x d label matrix
:return:
"""
n_epoch = opts.epoch
print('n epoch', n_epoch)
save_path = opts.save_path
n_batch_per_epoch = opts.n_input // opts.batch_size
tf.reset_default_graph()
# with tf.Graph().as_default() as graph:
if not os.path.exists(save_path):
os.makedirs(save_path)
if seed:
seednum = 2
np.random.seed(seednum)
tf.set_random_seed(seednum)
X, Y, N, _ = inputs.create_inputs(opts)
X_pl, Y_pl, N_pl = create_placeholders(X.shape[-1], Y.shape[-1], opts.rnn_size, X.shape[1])
train_iter, next_element = create_tf_dataset(X_pl, Y_pl, N_pl, opts.batch_size)
model = RNN(next_element, opts, training=True)
logger = defaultdict(list) # return an empty list for keys not present, set those keys to a value of empty list
print('starting')
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
sess.run(train_iter.initializer, feed_dict={X_pl: X, Y_pl: Y, N_pl: N})
if opts.load_checkpoint:
model.load()
t = time.perf_counter()
for ep in range(n_epoch):
for b in range(n_batch_per_epoch):
cur_loss, error_loss, weight_loss, activity_loss, states, _ = sess.run(
[model.total_loss, model.error_loss, model.weight_loss,
model.activity_loss, model.states, model.train_op])
# grads_and_vars = sess.run(model.grad)[0]
# grad, var = grads_and_vars
# print(grad)
# print(Whh,'\n',Wxh,'\n',Wout)
assert not np.isnan(error_loss), "Error is NaN, retry"
if (ep % 1 == 0 and ep>0): # save to loss file
logger['epoch'] = ep
logger['loss'].append(cur_loss)
logger['error_loss'].append(error_loss)
logger['activity_loss'].append(activity_loss)
logger['weight_loss'].append(weight_loss)
# if (ep+1) % 25 == 0: #display in terminal
# if (ep+1) % 10 == 0:
# print('[*] Epoch %d total_loss=%.2f error_loss=%.2f a_loss=%.2f, w_loss=%.2f'
# % (ep+1, cur_loss, error_loss, activity_loss, weight_loss))
print('[*] Epoch %d total_loss=%.2f error_loss=%.2f a_loss=%.2f, w_loss=%.2f'
% (ep, cur_loss, error_loss, activity_loss, weight_loss))
# Whh, Wxh, Wout = sess.run([model.Whh, model.Wxh, model.Wout])
# print(Whh)
# print(states[0,:10,:])
tnew = time.perf_counter()
print(f'{tnew - t} seconds elapsed')
t = tnew
model.save(save_path)
model.save_weights(save_path)
with open(os.path.join(save_path, opts.log_name + '.pkl'), 'wb') as f:
pkl.dump(logger, f)
data = {'X': X, 'Y': Y, 'N': N}
train_path = os.path.join(save_path, 'training_set.pkl')
with open(train_path, 'wb') as f:
pkl.dump(data, f)
save_name = os.path.join(save_path, opts.parameter_name)
utils.save_parameters(opts, save_name)
return opts, save_name
if __name__ == "__main__":
mnist_path = '../data/mnist.pkl'
lfw_path = '../data/lfw_grayscaled_64_64'
parameters_path = '../data/rbm_lfw/parameters_500_epochs.hdf5'
sampler = Sampler(mode='cpu')
# data_loader = MNISTLoader(mnist_path)
data_loader = LFWLoaderInMemory(lfw_path)
nb_visible = 64 ** 2
nb_hidden = 1024
n_samples = 10
img_size = 64
lr = 0.01
rbm = BinaryRBM(nb_visible, nb_hidden, learning_rate=lr, momentum_factor=0, persistent=True, batch_size=128, k=20)
rbm.train(data_loader, nb_epochs=20)
save_parameters(rbm.parameters, parameters_path)
# find out the number of test samples
number_of_test_samples = data_loader.test_x.shape[0]
# pick random test examples, with which to initialize the persistent chain
n_chains = 20
rng = rng = np.random.RandomState(123)
test_idx = rng.randint(number_of_test_samples - n_chains)
persistent_vis_chain = theano.shared(
np.asarray(
data_loader.test_x[test_idx:test_idx + n_chains],
dtype=theano.config.floatX
)
)
# end-snippet-6 start-snippet-7
def main():
device = 'cuda' if torch.cuda.is_available() else 'cpu'; print('Using device: %s'%device, flush=True)
args = parser.parse_args()
data_name = args.data_path.split('/')[-1]
_, system_name, model_name = args.parameter_path.split('/')[-1].split('.')[0].split('_')
# Load hyperparameters
hyperparams = load_parameters(args.parameter_path)
# Alter run name to describe seed, parameter settings and date of model run
hyperparams['run_name'] += '_%s'%data_name
hyperparams['run_name'] += '_f%i_g1%i_eg1%i_u%i'%(hyperparams['factors_dim'], hyperparams['g_dim'], hyperparams['g0_encoder_dim'], hyperparams['u_dim'])
if hyperparams['u_dim'] > 0:
hyperparams['run_name'] += '_c1%i_ec1%i'%(hyperparams['c_controller_dim'], hyperparams['c_encoder_dim'])
if model_name == 'ladder':
hyperparams['run_name'] += '_g2%i_c2%i_eg2%i_ec2%i'%(hyperparams['h_dim'], hyperparams['a_controller_dim'],
hyperparams['h0_encoder_dim'], hyperparams['a_encoder_dim'])
elif model_name in ['gaussian', 'edgeworth']:
hyperparams['run_name'] += '_k%i'%hyperparams['kernel_dim']
hyperparams['run_name'] += '_%s'%time.strftime('%y%m%d')
save_parameters(hyperparams, output=args.output)
# Load data
data_dict = read_data(args.data_path)
datatype = model_name if model_name in ['spikes', 'oasis'] else 'fluor'
train_data = torch.Tensor(data_dict['train_spikes']).to(device)
valid_data = torch.Tensor(data_dict['valid_spikes']).to(device)
train_truth = {'rates' : data_dict['train_rates']}
valid_truth = {'rates' : data_dict['valid_rates']}
if model_name == 'ladder':
train_truth['spikes'] = data_dict['train_spikes']
valid_truth['spikes'] = data_dict['valid_spikes']
if 'train_latent' in data_dict.keys():
train_truth['latent'] = data_dict['train_latent']
if 'valid_latent' in data_dict.keys():
valid_truth['latent'] = data_dict['valid_latent']
train_ds = torch.utils.data.TensorDataset(train_data)
valid_ds = torch.utils.data.TensorDataset(valid_data)
num_trials, num_steps, num_cells = train_data.shape;
print('Data dimensions: N=%i, T=%i, C=%i'%train_data.shape, flush=True);
print('Number of datapoints = %s'%train_data.numel(), flush=True)
# Initialize Network
Net = LFADS if model_name in ['spikes', 'oasis'] else MomentLFADS if model_name in ['gaussian', 'edgeworth'] else LadderLFADS
model = Net(inputs_dim = num_cells, T = num_steps, dt = float(data_dict['dt']), device=device,
model_hyperparams=hyperparams).to(device)
# Train Network
if args.batch_size:
batch_size = args.batch_size
else:
batch_size = int(num_trials/25)
total_params = 0
for ix, (name, param) in enumerate(model.named_parameters()):
print(ix, name, list(param.shape), param.numel(), param.requires_grad)
total_params += param.numel()
print('Total parameters: %i'%total_params)
model.fit(train_dataset=train_ds, valid_dataset=valid_ds,
train_truth=train_truth, valid_truth=valid_truth,
max_epochs=args.max_epochs, batch_size=batch_size,
use_tensorboard=False, health_check=False, home_dir=args.output)
y = L2I[label] # convert the label to number if needed.
loss, grads = loss_and_gradients(x, y, params)
cum_loss += loss
for i, grad in enumerate(grads):
params[i] -= (learning_rate * grad)
train_loss = cum_loss / len(train_data)
train_accuracy = accuracy_on_dataset(train_data, params)
dev_accuracy = accuracy_on_dataset(dev_data, params)
print(e_i, train_loss, train_accuracy, dev_accuracy)
return params
if __name__ == '__main__':
# for xor
# from xor_data import data
# train_data = data
# dev_data = data
# xor learning rate
# learning_rate = 10**-1
train_data = TRAIN
dev_data = DEV
params = create_classifier(len(F2I), 1000, len(L2I))
num_iterations = 100
learning_rate = 10**-4
trained_params = train_classifier(train_data, dev_data, num_iterations,
learning_rate, params)
save_parameters(trained_params)
def main():
# np.random.seed(2)
# tf.set_random_seed(2) # reproducible
y_axis_ticks = [-25, -20, -15, -10, -5, 0]
weights_path = './logs/weights/'
data_path = './logs/data/'
hp = Hyperparameters()
gpu_options = tf.GPUOptions(allow_growth=True)
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
# self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True))
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
env_name = 'Pong-v0'
env = gym.make(env_name)
env.seed(1) # reproducible
env = env.unwrapped
net = build_network(n_features=hp.N_F,
n_actions=hp.N_A,
a_lr=hp.LR_A,
c_lr=hp.LR_C,
discount=hp.GAMMA)
actor = Actor(sess, net[0])
critic = Critic(sess, net[1])
sess.run(tf.global_variables_initializer())
if hp.OUTPUT_GRAPH:
tf.summary.FileWriter("./logs/", sess.graph)
episodes = []
episode_rewards = []
running_rewards = []
total_steps = 0
saver, load_episode = restore_parameters(sess, weights_path)
# probs_path = data_path + 'probs_' + str(0) + '.txt'
# td_exp_path = data_path + 'td_exp_' + str(0) + '.txt'
# write_file(probs_path, 'probs\n', True)
# write_file(td_exp_path, 'td_exp\n', True)
for i_episode in range(hp.MAX_EPISODE):
s = env.reset()
s = preprocess_image(s, hp.N_F)
# assert to check: whether there is nan in s.
assert np.isnan(np.min(s.ravel())) == False
episode_steps = 0
track_r = []
while True:
# if hp.RENDER:
# env.render()
# env.render()
a, probs = actor.choose_action(s)
probs = np.around(probs, decimals=4)
# content = str([i_episode, total_steps]) + ' ' + str(probs.tolist()) + '\n'
# write_file(probs_path, content, False)
# print('------------------------------------', probs)
s_, r, done, info = env.step(a)
s_ = preprocess_image(s_, hp.N_F)
# assert to check: whether there is nan in s_.
assert np.isnan(np.min(s_.ravel())) == False
if done:
r = -2
track_r.append(r)
td_error = critic.learn(
s, r, s_) # gradient = grad[r + gamma * V(s_) - V(s)]
exp_v = actor.learn(
s, a, td_error) # true_gradient = grad[logPi(s,a) * td_error]
s = s_
episode_steps += 1
total_steps += 1
if done:
# print(episode_steps)
ep_rs_sum = sum(track_r)
aa = track_r.count(1)
if 'running_reward' not in globals(
) and 'running_reward' not in locals():
running_reward = ep_rs_sum
else:
running_reward = running_reward * 0.95 + ep_rs_sum * 0.05
running_rewards.append(running_reward)
# print(len(running_rewards))
if len(running_rewards) % hp.SAVED_INTERVAL == 0:
# write_file(data_path + 'rewards_' + str(i_episode) + '.txt', running_rewards, True)
plot_rewards(running_rewards, y_axis_ticks, data_path)
if i_episode % hp.SAVED_INTERVAL_NET == 0 and i_episode != 0:
save_parameters(
sess, weights_path, saver,
weights_path + '-' + str(load_episode + i_episode))
print(
"episode: {0}, running reward: {1:.4f}, episode reward: {2}, td error: {3}, exp_v: {4}"
.format(i_episode, running_reward, ep_rs_sum, td_error,
exp_v))
break
def train(opts):
"""
:param inputs: n x t x d input matrix
:param labels: n x t x d label matrix
:return:
"""
n_epoch = opts.epoch
save_path = opts.save_path
# n_batch_per_epoch = opts.n_inputs // opts.batch_size
tf.reset_default_graph()
if not os.path.exists(save_path):
os.makedirs(save_path)
X, Y, N = inputs.create_inputs(opts)
# X, Y, N = inputs.create_debug_inputs(opts)
n_inputs, T, D = X.shape
# opts.time_loss_start = T-5
# opts.time_loss_end = T
opts.batch_size = min(opts.batch_size, n_inputs)
n_batch_per_epoch = n_inputs // opts.batch_size
X_pl, Y_pl, N_pl = create_placeholders(X.shape[-1], Y.shape[-1],
opts.rnn_size, X.shape[1])
train_iter, next_element = create_tf_dataset(X_pl, Y_pl, N_pl,
opts.batch_size)
if opts.multilayer:
model = MultilayerRNN(next_element, opts, training=True)
else:
model = RNN(next_element, opts, training=True)
# print('next element', next_element)
logger = defaultdict(
list
) # return an empty list for keys not present, set those keys to a value of empty list
print('Initializing variables...')
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# sess.run(tf.local_variables_initializer())
sess.run(train_iter.initializer, feed_dict={X_pl: X, Y_pl: Y, N_pl: N})
# if opts.load_checkpoint:
# model.load()
print('Running')
t = time.perf_counter()
for ep in range(n_epoch):
for b in range(n_batch_per_epoch):
# cur_loss, mse_loss, weight_loss, activity_loss, _ = \
# sess.run([model.total_loss, model.mse_loss, model.weight_loss,
# model.activity_loss, model.train_op])
states, error_loss, _ = sess.run(
[model.states, model.error_loss, model.train_op])
# print('error_loss=%.2f' % (error_loss))
if np.isnan(error_loss):
assert not np.isnan(error_loss), "Error is NaN, retry"
# if (ep % 1 == 0 and ep>0): # save to loss file
# logger['epoch'] = ep
# logger['loss'].append(cur_loss)
# logger['mse_loss'].append(mse_loss)
# logger['activity_loss'].append(activity_loss)
# logger['weight_loss'].append(weight_loss)
# if (ep+1) % 25 == 0: #display in terminal
# print('[*] Epoch %d total_loss=%.2f mse_loss=%.2f a_loss=%.2f, w_loss=%.2f'
# % (ep, cur_loss, mse_loss, activity_loss, weight_loss))
print('[*] Epoch %d error_loss=%.2f' % (ep, error_loss))
# Whh, Wxh, Wout = sess.run([model.Whh, model.Wxh, model.Wout])
# print('Whh',np.mean((Whh-Whh_prev)**2))
# print('Wxh',np.mean((Wxh-Wxh_prev)**2))
# Whh_prev, Wxh_prev, Wout_prev = Whh, Wxh, Wout
if (ep + 1) % 100 == 0:
if isinstance(states, list):
f, ax = plt.subplots(len(states), 1)
for i, s in enumerate(states):
ax[i].plot(s[0])
else:
plt.plot(states[0])
plt.show()
# print('max_states', np.amax(states[0], axis=1))
# print('pred', pred[0, opts.time_loss_start:opts.time_loss_end, :])
# print('lab', labels[0, opts.time_loss_start:opts.time_loss_end, :])
# print('pred', pred[0, -5:, :])
# print('lab', labels[0, -5:, :])
tnew = time.perf_counter()
print(f'{tnew - t} seconds elapsed')
t = tnew
#save latest
model.save(save_path)
model.save_weights(save_path)
with open(os.path.join(save_path, opts.log_name + '.pkl'), 'wb') as f:
pkl.dump(logger, f)
# opts.save_path = save_path
data = {'X': X, 'Y': Y, 'N': N}
train_path = os.path.join(save_path, 'training_set.pkl')
with open(train_path, 'wb') as f:
pkl.dump(data, f)
save_name = os.path.join(save_path, opts.parameter_name)
utils.save_parameters(opts, save_name)
return opts, save_name
def main():
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"]=str(args.gpu)
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = 'cpu'
hyperparams = load_parameters(args.hyperparameter_path)
orion_hp_string, hyperparams = prep_orion(args, hyperparams)
save_loc, hyperparams = generate_save_loc(args, hyperparams, orion_hp_string)
save_parameters(save_loc, hyperparams)
if not os.path.exists(save_loc):
os.makedirs(save_loc)
data_dict = read_data(args.data_path)
train_dl, valid_dl, plotter, model, objective = prep_model(model_name = args.model,
data_dict = data_dict,
data_suffix = args.data_suffix,
batch_size = args.batch_size,
device = device,
hyperparams = hyperparams)
print_model_description(model)
if args.model == 'conv3d_lfads':
model = _CustomDataParallel(model).to(device)
transforms = trf.Compose([])
optimizer, scheduler = prep_optimizer(model, hyperparams)
if args.use_tensorboard:
writer, rm_plotter = prep_tensorboard(save_loc, plotter, args.restart)
else:
writer = None
rm_plotter = None
run_manager = RunManager(model = model,
objective = objective,
optimizer = optimizer,
scheduler = scheduler,
train_dl = train_dl,
valid_dl = valid_dl,
transforms = transforms,
writer = writer,
plotter = rm_plotter,
max_epochs = args.max_epochs,
save_loc = save_loc,
do_health_check = args.do_health_check,
detect_local_minima = args.detect_local_minima)
run_manager.run()
if args.model == 'conv3d_lfads':
model_to_plot = load_model(save_loc, hyperparams, model_name = args.model, input_dims = run_manager.model.input_dims)
save_figs(save_loc, model_to_plot, run_manager.valid_dl, plotter, mode='video')
else:
save_figs(save_loc, run_manager.model, run_manager.valid_dl, plotter, mode='traces')
def train(lr, units):
# Read data.
train_data, train_label, test_data, test_label = read_data(data_path)
train_label = np.eye(3)[train_label.reshape(-1)]
test_label = np.eye(3)[test_label.reshape(-1)]
features, labels, out_softmax, train_op, loss, accuracy = build_model(
lr, units)
train_acc = []
test_acc = []
gpu_options = tf.GPUOptions(allow_growth=True)
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
# self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True))
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
saver = tf.train.Saver(max_to_keep=8)
sess.run(tf.global_variables_initializer())
print('Training start ...')
print('---------------------------------------')
for epoch_i in range(MAX_EPOCH):
loss_epoch = 0
for batch_i in range(10):
batch_train_data, batch_train_label = train_data[batch_i*50:(batch_i+1)*50], \
train_label[batch_i*50:(batch_i+1)*50]
_, loss_step = sess.run([train_op, loss],
feed_dict={
features: batch_train_data,
labels: batch_train_label
})
loss_epoch += loss_step
if epoch_i % 100 == 0:
train_accuracy = sess.run(accuracy,
feed_dict={
features: train_data,
labels: train_label
})
content = 'epoch: {0} | training accuracy: {1:.4%}'.format(
epoch_i, train_accuracy)
print(content)
test_accuracy = sess.run(accuracy,
feed_dict={
features: test_data,
labels: test_label
})
train_acc.append(train_accuracy)
test_acc.append(test_accuracy)
# Test trained model
final_accuracy = sess.run(accuracy,
feed_dict={
features: test_data,
labels: test_label
})
print('---------------------------------------')
print('accuracy on the test data set= %10.4f' % final_accuracy)
save_path = '{}weights/'.format(log_path)
save_parameters(sess, save_path, saver, '{0}-{1}'.format(lr, units))
write_to_file(log_path + 'accuracy_{}_{}.txt'.format(lr, units),
'{}\n{}'.format(train_acc, test_acc), True)
return final_accuracy
def save(self, path):
save_parameters(path + "/parameters.pkl", self.params)
save_parameters(path + "/m.pkl", self.m)
save_parameters(path + "/v.pkl", self.v)
def save_parameters(self):
utils.save_parameters(self.save_path)
plt.show()
# Show example ground truth firing rates
plt.figure(figsize=(12, 12))
plt.imshow(data_dict['train_rates'][0].T, cmap=plt.cm.plasma)
plt.xticks(np.linspace(0, 100, 6),
['%.1f' % i for i in np.linspace(0, 1, 6)])
plt.xlabel('Time (s)')
plt.ylabel('Cell #')
plt.colorbar(orientation='horizontal', label='Firing Rate (Hz)')
plt.title('Example trial')
plt.show()
# Load model hyperparameters
hyperparams = load_parameters('./parameters_demo.yaml')
save_parameters(hyperparams)
# Instantiate model
model = LFADS_Net(inputs_dim=num_cells,
T=num_steps,
dt=0.01,
device=device,
model_hyperparams=hyperparams).to(device)
# Fit model
#model.fit(train_ds, valid_ds, max_epochs=200, batch_size=200, use_tensorboard=True,
# train_truth=train_truth, valid_truth=valid_truth)
# Load checkpoint with lowest validation error
model.load_checkpoint('best')
# Plot results summary
