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_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