def main(args):
# load model
if 'full' in args.model:
model = LFADS_full.load(args.model)
else:
model = LFADS.load(args.model)
if args.gpu is not None:
cuda.get_device(args.gpu).use()
model.to_gpu(args.gpu)
xp = cuda.cupy
else:
xp = np
# generate completely new samples
print("generate completely new samples from prior distribution...")
# sample initial condition (g0)
mus = xp.zeros((args.batch_size, model.generator.g_dims), dtype=xp.float32)
sigmas = xp.ones((args.batch_size, model.generator.g_dims),
dtype=xp.float32)
g0_bxd = F.gaussian(Variable(mus), Variable(sigmas))
# inffered inputs are sampled from a Gaussian autoregressive prior
xs = []
for i in range(args.nsample):
print("now generating %d'th sample among %d" % (i, args.nsample))
if i == 0:
u_i_bxd = model.generator.sample_u_1(xp.ndarray(None),
batch_size=args.batch_size,
prior_sample=True)
g_i_bxd = model.generator(u_i_bxd, hx=g0_bxd)
else:
u_i_bxd = model.generator.sample_u_i(xp.ndarray(None),
u_i_bxd,
batch_size=args.batch_size,
prior_sample=True)
g_i_bxd = model.generator(u_i_bxd, hx=g_i_bxd)
f_i = model.generator.l_f(g_i_bxd)
x_i = model.generator.sample_x_hat(f_i, calc_rec_loss=False)
xs.append(cuda.to_cpu(x_i.data))
# save
data_dict = {'xs': xs}
data_fname = args.model + '_prior_sampling.h5'
with h5py.File(data_fname, 'w') as hf:
for k, v in data_dict.items():
hf.create_dataset(k, data=v, compression=False)
if hps.num_steps_for_gen_ic > hps.num_steps: hps.num_steps_for_gen_ic = hps.num_steps
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)) as session:
#####################################################################################
# train
#####################################################################################
#####################################################################################
# build_model(hps, kind='train', datasets = datasets)
#####################################################################################
with tf.variable_scope("LFADS", reuse=None):
model = LFADS(hps, kind='train', datasets=datasets)
tf.global_variables_initializer().run()
session.run(model.learning_rate.initializer)
#####################################################################################
# model.train_model(datasets)
#####################################################################################
lr = session.run(model.learning_rate)
lr_stop = hps.learning_rate_stop
train_costs = []
valid_costs = []
learning_rates = []
def main(args):
# load data
print >> sys.stderr, 'Loading data...'
dataset = util.read_datasets(args.data_path, args.data_fname_stem)
train_data = dataset["train_data"]
test_data = dataset["valid_data"]
# load model
if 'full' in args.model:
model = LFADS_full.load(args.model)
else:
model = LFADS.load(args.model)
if args.gpu is not None:
cuda.get_device(args.gpu).use()
model.to_gpu(args.gpu)
# posterior sampling
# encoder
ndata = train_data.shape[0]
x_hat_all = []
f_all = []
for i in range(ndata):
print("now %d'th data among %d" % (i, ndata))
x_data = train_data[i, :, :].astype(np.float32)
x_data = x_data[np.newaxis, :, :]
x_data = np.tile(x_data, (args.nsample, 1, 1))
# copy data to GPU
if args.gpu is not None:
x_data = cuda.to_gpu(x_data)
# create variable
xs = []
[xs.append(Variable(x.astype(np.float32))) for x in x_data]
# encoder
_, h_bxtxd = model.encoder(xs)
h_bxtxd = F.stack(h_bxtxd, 0)
d_dims = h_bxtxd.data.shape[2]
# generator
g0_bxd, _ = model.generator.sample_g0(
F.concat(
[h_bxtxd[:, 0, -d_dims / 2:], h_bxtxd[:, -1, :d_dims / 2]],
axis=1))
f0_bxd = model.generator.l_f(g0_bxd)
# sampling
x_hat = []
f_trial = []
for j in range(0, h_bxtxd[0].data.shape[0]):
if j == 0:
if 'full' in args.model:
con_i = model.controller(
F.concat((f0_bxd, h_bxtxd[:, j, :d_dims / 2],
h_bxtxd[:, j, d_dims / 2:]),
axis=1))
u_i_bxd, _ = model.generator.sample_u_1(con_i)
g_i_bxd = model.generator(u_i_bxd, hx=g0_bxd)
else:
g_i_bxd = model.generator(F.concat([
h_bxtxd[:, j, :d_dims / 2], h_bxtxd[:, j, d_dims / 2:]
],
axis=1),
hx=g0_bxd)
else:
if 'full' in args.model:
con_i = model.controller(F.concat([
f_i, h_bxtxd[:, j, :d_dims / 2], h_bxtxd[:, j,
d_dims / 2:]
],
axis=1),
hx=con_i)
u_i_bxd, _ = model.generator.sample_u_i(con_i, u_i_bxd)
g_i_bxd = model.generator(u_i_bxd, hx=g_i_bxd)
else:
g_i_bxd = model.generator(F.concat([
h_bxtxd[:, j, :d_dims / 2], h_bxtxd[:, j, d_dims / 2:]
],
axis=1),
hx=g_i_bxd)
f_i = model.generator.l_f(g_i_bxd)
x_hat_i = model.generator.sample_x_hat(f_i,
xs=Variable(x_data[:,
j, :]),
nrep=1,
calc_rec_loss=False)
f_i = F.mean(f_i, axis=0)
x_hat.append(cuda.to_cpu(x_hat_i.data))
f_trial.append(cuda.to_cpu(f_i.data))
x_hat_all.append(x_hat)
f_all.append(f_trial)
# save
data_dict = {'x_hat_all': x_hat_all, 'f_all': f_all}
data_fname = args.model + '_posterior_sampling.h5'
with h5py.File(data_fname, 'w') as hf:
for k, v in data_dict.items():
hf.create_dataset(k, data=v, compression=False)
def build_model(hps, kind="train", datasets=None):
"""Builds a model from either random initialization, or saved parameters.
Args:
hps: The hyper parameters for the model.
kind: (optional) The kind of model to build. Training vs inference require
different graphs.
datasets: The datasets structure (see top of lfads.py).
Returns:
an LFADS model.
"""
build_kind = kind
if build_kind == "write_model_params":
build_kind = "train"
with tf.variable_scope("LFADS", reuse=None):
model = LFADS(hps, kind=build_kind, datasets=datasets)
if not os.path.exists(hps.lfads_save_dir):
print("Save directory %s does not exist, creating it." %
hps.lfads_save_dir)
os.makedirs(hps.lfads_save_dir)
cp_pb_ln = hps.checkpoint_pb_load_name
cp_pb_ln = 'checkpoint' if cp_pb_ln == "" else cp_pb_ln
if cp_pb_ln == 'checkpoint':
print("Loading latest training checkpoint in: ", hps.lfads_save_dir)
saver = model.seso_saver
elif cp_pb_ln == 'checkpoint_lve':
print("Loading lowest validation checkpoint in: ", hps.lfads_save_dir)
saver = model.lve_saver
else:
print("Loading checkpoint: ", cp_pb_ln, ", in: ", hps.lfads_save_dir)
saver = model.seso_saver
ckpt = tf.train.get_checkpoint_state(hps.lfads_save_dir,
latest_filename=cp_pb_ln)
session = tf.get_default_session()
print("ckpt: ", ckpt)
if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):
print("Reading model parameters from %s" % ckpt.model_checkpoint_path)
saver.restore(session, ckpt.model_checkpoint_path)
else:
print("Created model with fresh parameters.")
if kind in [
"posterior_sample_and_average", "prior_sample",
"write_model_params"
]:
print("Possible error!!! You are running ", kind, " on a newly \
initialized model!")
print("Are you sure you sure ", ckpt.model_checkpoint_path,
" exists?")
tf.global_variables_initializer().run()
if ckpt:
train_step_str = re.search('-[0-9]+$',
ckpt.model_checkpoint_path).group()
else:
train_step_str = '-0'
fname = 'hyperparameters' + train_step_str + '.txt'
hp_fname = os.path.join(hps.lfads_save_dir, fname)
hps_for_saving = jsonify_dict(hps)
utils.write_data(hp_fname, hps_for_saving, use_json=True)
return model
def main(args):
if args.gpu is not None:
cuda.get_device(args.gpu).use()
xp = cuda.cupy
else:
xp = np
try:
os.makedirs(args.model)
except:
pass
# set up logger
logger = logging.getLogger()
logging.basicConfig(level=logging.INFO)
log_path = os.path.join(args.model, 'log')
file_handler = logging.FileHandler(log_path)
fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
file_handler.setFormatter(fmt)
logger.addHandler(file_handler)
# load data
logger.info('Loading data...')
dataset = util.read_datasets(args.data_path, args.data_fname_stem)
# save hyperparameters
with open(os.path.join(args.model, 'params'), 'w') as f:
for k, v in vars(args).items():
print >> f, '{}\t{}'.format(k, v)
# create test set
input_dims = dataset["train_data"].shape[2]
# set NN
# encoder
encoder = GaussianEncoder(args.enc_n_layer, input_dims, args.enc_h_dims,
args.enc_dropout)
# controller (set only if used)
if args.con_h_dims > 0:
con_input_dims = args.gen_f_dims + (args.enc_h_dims * 2)
controller = GaussianController(con_input_dims, args.con_h_dims)
# generator
if args.con_h_dims > 0:
gen_u_dims = args.con_h_dims
else:
gen_u_dims = args.enc_h_dims * 2
generator = GaussianGenerator(gen_u_dims, args.gen_h_dims, args.gen_f_dims,
args.gen_g_dims, input_dims, args.ar_tau,
args.ar_noise_variance, args.batch_size, xp)
if args.con_h_dims > 0:
lfads = LFADS_full(encoder, controller, generator)
else:
lfads = LFADS(encoder, generator)
lfads.save_model_def(args.model)
train_lfads.train(lfads,
dataset,
args.optim,
dest_dir=args.model,
batch_size=args.batch_size,
max_epoch=args.epoch,
gpu=args.gpu,
save_every=args.save_every,
test_every=args.test_every,
alpha_init=args.alpha_init,
alpha_delta=args.alpha_delta,
l2_weight_con=args.l2_weight_con,
l2_weight_gen=args.l2_weight_gen)
