def save_crisp_states():
DATA_PARTITION_SIZE = 10
try:
os.makedirs(EXP_FOLDER)
os.makedirs(DATA_FOLDER)
except OSError:
pass
# prepare data
data_train = DataContainer(
'/home/ira/code/projects/nn-play/experiments/0__well_done/17-11-30_09:05-wp_1b_1l_small_deter/data/train.pt',
batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
data_train.populate_images()
pae = PredictiveAutoencoder(v_size=V_SIZE).cuda()
pae.load_state_dict(torch.load("%s/autencoder_epoch_4.pth" % (EXP_FOLDER)))
ims = data_train.images
ims = ims.transpose((1, 0, 4, 2, 3))
x = Variable(torch.FloatTensor(DATA_PARTITION_SIZE, *ims.shape[1:]).cuda())
real_states = []
for i in range(ims.shape[0] // DATA_PARTITION_SIZE):
begin = i * DATA_PARTITION_SIZE
end = (i+1) * DATA_PARTITION_SIZE
im_slice = ims[begin:end, ...]
x.data.copy_(torch.FloatTensor(im_slice))
state_slice = pae.bs_prop(x).view((-1, BS_SIZE)).data.cpu().numpy()
real_states.append(state_slice)
real_states = np.concatenate(real_states, axis=0)
np.save("{}/crisp_states.npy".format(DATA_FOLDER), real_states)
def test_autoencoder():
try:
os.makedirs(EXP_FOLDER)
except OSError:
pass
data_test = DataContainer('data-balls/pass-train.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
data_test.populate_images()
net = Autoencoder()
criterion = nn.MSELoss()
x = torch.FloatTensor(BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH)
net = net.cuda()
criterion = criterion.cuda()
x = x.cuda()
x = Variable(x)
optimiser = optim.Adam(net.parameters(), lr=0.0005)
for epoch in range(EPOCHS):
for update in range(UPDATES_PER_EPOCH):
batch = data_test.get_n_random_images(BATCH_SIZE)
batch = batch.transpose((0, 3, 1, 2))
batch = torch.FloatTensor(batch)
net.zero_grad()
x.data.resize_(batch.size()).copy_(batch)
recon = net(x)
err = criterion(recon, x)
err.backward()
optimiser.step()
print('[%d/%d][%d/%d] Recon loss: %.4f'
% (epoch, EPOCHS, update, UPDATES_PER_EPOCH,
err.data[0]))
if update % 100 == 0:
vutils.save_image(recon.data,
'%s/reconstruction_epoch_%03d.png' % (EXP_FOLDER, epoch),
normalize=True)
# do checkpointing
torch.save(net.state_dict(), '%s/autencoder_epoch_%d.pth' % (EXP_FOLDER, epoch))
def generate_data(self):
print('Generating data')
rec = Record(**self.train_config)
rec.run()
fpath_train = '{}/train.pt'.format(self.folder_data)
rec.write(fpath_train)
self.train_box = DataContainer(fpath_train,
batch_size=BATCH_SIZE,
ep_len_read=EP_LEN)
self.train_box.populate_images()
rec = Record(**self.valid_config)
rec.run()
fpath_valid = '{}/test.pt'.format(self.folder_data)
rec.write(fpath_valid)
self.valid_box = DataContainer(fpath_valid,
batch_size=BATCH_SIZE,
ep_len_read=EP_LEN)
self.valid_box.populate_images()
if use_cuda:
assert torch.cuda.is_available() is True
if not os.path.exists(args.output_dir):
torch_utils.make_dir_tree(args.output_dir)
# prepare data
sim_config = None
obs_shape = None
train_getter = None
valid_getter = None
if args.dataset_type == 'balls':
sim_config = torch.load('{}/train.conf'.format(args.data_dir))
obs_shape = BALLS_OBS_SHAPE
train_container = DataContainer('{}/train.pt'.format(args.data_dir),
batch_size=PAE_BATCH_SIZE)
# train_container = DataContainer('{}/valid.pt'.format(args.data_dir), batch_size=PAE_BATCH_SIZE)
valid_container = DataContainer('{}/valid.pt'.format(args.data_dir),
batch_size=PAE_BATCH_SIZE)
sim_config = torch.load(
open('{}/train.conf'.format(args.data_dir), 'rb'))
train_container.populate_images()
valid_container.populate_images()
train_getter = train_container.get_batch_episodes
valid_getter = valid_container.get_batch_episodes
else:
raise ValueError('Failed to load data. Wrong dataset type {}'.format(
args.dataset_type))
def train_predictive_autoencoder():
try:
os.makedirs(EXP_FOLDER)
except OSError:
pass
data_train = DataContainer('/home/ira/code/projects/nn-play/experiments/0__well_done/17-11-30_09:05-wp_1b_1l_small_deter/data/train.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
data_test = DataContainer('/home/ira/code/projects/nn-play/experiments/0__well_done/17-11-30_09:05-wp_1b_1l_small_deter/data/test.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
data_train.populate_images()
data_test.populate_images()
net = PredictiveAutoencoder(v_size=V_SIZE)
criterion = nn.MSELoss()
x = torch.FloatTensor(EP_LEN, BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH)
y = torch.FloatTensor(EP_LEN, BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH)
net = net.cuda()
criterion = criterion.cuda()
x = x.cuda()
y = y.cuda()
x = Variable(x)
y = Variable(y)
optimiser = optim.Adam(net.parameters(), lr=0.0002)
start_at_epoch = 5
net.load_state_dict(torch.load("%s/autencoder_epoch_%d.pth" % (EXP_FOLDER, start_at_epoch - 1)))
postfix = {}
for epoch in range(start_at_epoch, EPOCHS):
bar = trange(UPDATES_PER_EPOCH)
postfix['epoch'] = '[%d/%d]' % (epoch, EPOCHS)
for update in bar:
batch = data_train.get_batch_episodes()
masked = mask_percepts(batch, p=0.98)
batch = batch.transpose((1, 0, 4, 2, 3))
masked = masked.transpose((1, 0, 4, 2, 3))
batch = torch.FloatTensor(batch)
masked = torch.FloatTensor(masked)
net.zero_grad()
x.data.copy_(masked)
y.data.copy_(batch)
recon = net(x)
err = criterion(recon, y)
err.backward()
optimiser.step()
postfix['train loss'] = err.data[0]
if update % 500 == 0:
recon_ims = recon.data.cpu().numpy()
target_ims = y.data.cpu().numpy()
joint = np.concatenate((target_ims, recon_ims), axis=-2)
my_utils.batch_to_sequence(joint, fpath='%s/training_recon_%03d.gif' % (EXP_FOLDER, epoch))
if update % 10 == 0:
batch = data_test.get_batch_episodes()
masked = mask_percepts(batch, p=1.0)
masked = masked.transpose((1, 0, 4, 2, 3))
masked = torch.FloatTensor(masked)
x.data.copy_(masked)
batch = batch.transpose((1, 0, 4, 2, 3))
batch = torch.FloatTensor(batch)
y.data.copy_(batch)
recon = net(x)
err = criterion(recon, y)
postfix['valid loss'] = err.data[0]
if update % 500 == 0:
recon_ims = recon.data.cpu().numpy()
target_ims = y.data.cpu().numpy()
joint = np.concatenate((target_ims, recon_ims), axis=-2)
my_utils.batch_to_sequence(joint, fpath='%s/valid_recon_%03d.gif' % (EXP_FOLDER, epoch))
bar.set_postfix(**postfix)
# do checkpointing
torch.save(net.state_dict(), '%s/autencoder_epoch_%d.pth' % (EXP_FOLDER, epoch))
def train_PAEGAN(start_at_epoch=0, train_gan=True, train_av=True, n_epochs=EPOCHS):
try:
os.makedirs(EXP_FOLDER)
except OSError:
pass
data_train = DataContainer('/home/ira/code/projects/nn-play/experiments/0__well_done/17-11-30_09:05-wp_1b_1l_small_deter/data/train.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
data_test = DataContainer('/home/ira/code/projects/nn-play/experiments/0__well_done/17-11-30_09:05-wp_1b_1l_small_deter/data/test.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
data_train.populate_images()
data_test.populate_images()
if torch.cuda.is_available():
net = VisualPAEGAN(v_size=V_SIZE, bs_size=BS_SIZE, n_size=N_SIZE, g_size=G_SIZE).cuda()
criterion_pae = nn.MSELoss().cuda()
criterion_gan = nn.BCELoss().cuda()
# criterion_gan = nn.MSELoss().cuda()
criterion_gen_averaged = nn.MSELoss().cuda()
obs_in = Variable(torch.FloatTensor(EP_LEN, BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH).cuda())
obs_out = Variable(torch.FloatTensor(EP_LEN, BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH).cuda())
averaging_noise = Variable(torch.FloatTensor(AVERAGING_BATCH_SIZE, N_SIZE).cuda())
noise = Variable(torch.FloatTensor(GAN_BATCH_SIZE, N_SIZE).cuda())
fixed_noise = Variable(torch.FloatTensor(GAN_BATCH_SIZE, N_SIZE).normal_(0, 1).cuda())
fixed_bs_noise = Variable(torch.FloatTensor(GAN_BATCH_SIZE, BS_SIZE).uniform_(-1, 1).cuda())
label = Variable(torch.FloatTensor(GAN_BATCH_SIZE, 1).cuda())
else:
net = VisualPAEGAN(v_size=V_SIZE, bs_size=BS_SIZE, n_size=N_SIZE, g_size=G_SIZE)
criterion_pae = nn.MSELoss()
criterion_gan = nn.BCELoss()
# criterion_gan = nn.MSELoss()
criterion_gen_averaged = nn.MSELoss()
obs_in = Variable(torch.FloatTensor(EP_LEN, BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH))
obs_out = Variable(torch.FloatTensor(EP_LEN, BATCH_SIZE, IM_CHANNELS, IM_WIDTH, IM_WIDTH))
averaging_noise = Variable(torch.FloatTensor(AVERAGING_BATCH_SIZE, N_SIZE))
noise = Variable(torch.FloatTensor(GAN_BATCH_SIZE, N_SIZE))
fixed_noise = Variable(torch.FloatTensor(GAN_BATCH_SIZE, N_SIZE).normal_(0, 1))
fixed_bs_noise = Variable(torch.FloatTensor(GAN_BATCH_SIZE, BS_SIZE).uniform_(-1, 1))
label = Variable(torch.FloatTensor(GAN_BATCH_SIZE, 1))
real_label = 1
fake_label = 0
optimiser_pae = optim.Adam([{'params': net.bs_prop.parameters()},
{'params': net.decoder.parameters()}],
lr=0.0004)
# optimiser_g = optim.Adam([{'params': net.bs_prop.parameters(), 'lr': 0.0001},
# {'params': net.G.parameters(), 'lr': 0.0002}])
optimiser_g = optim.Adam(net.G.parameters(), lr=0.0002)
optimiser_sum = optim.Adam(net.G.parameters(), lr=0.0002)
optimiser_d = optim.Adam(net.D.parameters(), lr=0.0002)
if start_at_epoch > 0:
net.load_state_dict(torch.load("%s/paegan_epoch_%d.pth" % (EXP_FOLDER, start_at_epoch - 1)))
postfix = {}
for epoch in range(start_at_epoch, n_epochs):
bar = trange(UPDATES_PER_EPOCH)
postfix['epoch'] = '[%d/%d]' % (epoch, EPOCHS)
for update in bar:
batch = data_train.get_batch_episodes()
masked = mask_percepts(batch, p=P_NO_OBS)
batch = batch.transpose((1, 0, 4, 2, 3))
masked = masked.transpose((1, 0, 4, 2, 3))
batch = torch.FloatTensor(batch)
masked = torch.FloatTensor(masked)
net.zero_grad()
obs_in.data.copy_(masked)
obs_out.data.copy_(batch)
# generate beliefs states
states = net.bs_prop(obs_in)
states = states.view(EP_LEN * BATCH_SIZE, -1)
# generate observation expectations, compute pae gradients, update
obs_expectation = net.decoder(states)
obs_expectation = obs_expectation.view(obs_in.size())
err_pae = criterion_pae(obs_expectation, obs_out)
err_pae.backward(retain_graph=True)
optimiser_pae.step()
postfix['pae train loss'] = err_pae.data[0]
if train_gan is True:
net.zero_grad()
# # flip labels
# if update % 2000 == 0:
# if real_label == 1:
# real_label = 0
# fake_label = 1
# else:
# real_label = 1
# fake_label = 0
# train discriminator with real data
label.data.fill_(real_label)
obs_out_non_ep = obs_out.view(EP_LEN * BATCH_SIZE,
obs_out.size(2), obs_out.size(3), obs_out.size(4))
obs_out_non_ep = obs_out_non_ep.unfold(0, 1, (EP_LEN*BATCH_SIZE)//GAN_BATCH_SIZE).squeeze(-1)
states_non_ep = states.unfold(0, 1, (EP_LEN*BATCH_SIZE)//GAN_BATCH_SIZE).squeeze(-1)
out_D_real = net.D(obs_out_non_ep)
err_D_real = criterion_gan(out_D_real, label)
err_D_real.backward()
# D_x = out_D_real.data.mean()
# print('out_D_real', out_D_real.data)
# print('err_D_real', err_D_real.data[0])
# train discriminator with fake data
noise.data.normal_(0, 1)
obs_sample = net.G(noise, states_non_ep)
obs_sample = net.decoder(obs_sample)
label.data.fill_(fake_label)
out_D_fake = net.D(obs_sample.detach())
err_D_fake = criterion_gan(out_D_fake, label)
err_D_fake.backward()
# D_G_z1 = out_D_fake.data.mean()
# print('out_D_fake', out_D_fake.data)
# print('err_D_fake', err_D_fake.data[0])
err_D = (err_D_fake + err_D_real)/2
optimiser_d.step()
# train generator using discriminator
net.zero_grad()
batch = data_train.get_batch_episodes()
masked = mask_percepts(batch, p=P_NO_OBS)
batch = batch.transpose((1, 0, 4, 2, 3))
masked = masked.transpose((1, 0, 4, 2, 3))
batch = torch.FloatTensor(batch)
masked = torch.FloatTensor(masked)
obs_in.data.copy_(masked)
obs_out.data.copy_(batch)
# generate beliefs states
states = net.bs_prop(obs_in)
states = states.view(EP_LEN * BATCH_SIZE, -1)
states_non_ep = states.unfold(0, 1, (EP_LEN*BATCH_SIZE)//GAN_BATCH_SIZE).squeeze(-1)
noise.data.normal_(0, 1)
obs_sample = net.G(noise, states_non_ep)
obs_sample = net.decoder(obs_sample)
label.data.fill_(real_label)
out_D_fake = net.D(obs_sample)
# print('out d fake', out_D_fake)
err_G = criterion_gan(out_D_fake, label)
err_G.backward()
# D_G_z2 = out_D_fake.data.mean()
optimiser_g.step()
postfix['g train loss'] = err_G.data[0]
postfix['d train loss'] = err_D.data[0]
if update % 500 == 0:
vutils.save_image(obs_out_non_ep.data,
'%s/real_samples.png' % EXP_FOLDER,
normalize=True)
obs_sample = net.G(fixed_noise, fixed_bs_noise)
obs_sample = net.decoder(obs_sample)
vutils.save_image(obs_sample.data,
'%s/fake_samples_epoch_%03d.png' % (EXP_FOLDER, epoch),
normalize=False)
obs_recon = net.decoder(fixed_bs_noise)
vutils.save_image(obs_recon.data,
'%s/expectation_samples_epoch_%03d.png' % (EXP_FOLDER, epoch),
normalize=False)
if train_av is True:
net.zero_grad()
# train generator using averaging
# pull a 50th state from 0th episode in the last batch
state = states[50:51, ...]
# print('state size', state.size())
state = state.expand(AVERAGING_BATCH_SIZE, -1)
# print('state size', state.size())
# get corresponding observation expectation
obs_exp = obs_expectation[50:51, 0, ...]
# print('obs size', obs_exp.size())
# generate samples from state
averaging_noise.data.normal_(0, 1)
n_samples = net.G(averaging_noise, state.detach())
# print('samples size', n_samples.size())
sample_av = n_samples.mean(dim=0)
sample_av = sample_av.unsqueeze(0)
# print('samples av size', sample_av.size())
# print('obs_exp size', obs_exp.size())
err_sum = criterion_gen_averaged(sample_av, obs_exp.detach())
err_sum.backward()
optimiser_sum.step()
postfix['sum train loss'] = err_sum.data[0]
if update % 100 == 0:
sample_mixture = sample_av.data.cpu().numpy()
observation_belief = obs_exp.data.cpu().numpy()
joint = np.concatenate((observation_belief, sample_mixture), axis=-2)
joint = np.expand_dims(joint, axis=0)
my_utils.batch_to_sequence(joint, fpath='%s/training_sum_%03d.gif' % (EXP_FOLDER, epoch))
if update % 500 == 0:
recon_ims = obs_expectation.data.cpu().numpy()
target_ims = obs_out.data.cpu().numpy()
joint = np.concatenate((target_ims, recon_ims), axis=-2)
my_utils.batch_to_sequence(joint, fpath='%s/training_recon_%03d.gif' % (EXP_FOLDER, epoch))
if update % 100 == 0:
batch = data_test.get_batch_episodes()
masked = mask_percepts(batch, p=P_NO_OBS)
# masked = mask_percepts(batch, p=1)
masked = masked.transpose((1, 0, 4, 2, 3))
masked = torch.FloatTensor(masked)
obs_in.data.copy_(masked)
batch = batch.transpose((1, 0, 4, 2, 3))
batch = torch.FloatTensor(batch)
obs_out.data.copy_(batch)
states = net.bs_prop(obs_in)
obs_expectation = net.decoder(states.view(EP_LEN * BATCH_SIZE, -1))
obs_expectation = obs_expectation.view(obs_in.size())
err_pae = criterion_pae(obs_expectation, obs_out)
postfix['pae valid loss'] = err_pae.data[0]
if update % 500 == 0:
recon_ims = obs_expectation.data.cpu().numpy()
target_ims = obs_out.data.cpu().numpy()
joint = np.concatenate((target_ims, recon_ims), axis=-2)
my_utils.batch_to_sequence(joint, fpath='%s/valid_recon_%03d.gif' % (EXP_FOLDER, epoch))
bar.set_postfix(**postfix)
# do checkpointing
torch.save(net.state_dict(), '%s/paegan_epoch_%d.pth' % (EXP_FOLDER, epoch))
class Experiment(object):
def __init__(self, ctrl_var, var_vals, exp_name):
self.date = datetime.datetime.now().strftime('%y-%m-%d_%H:%M')
self.sim_conf = sim_config
self.train_scheme = train_scheme
self.train_config = train_config
self.valid_config = valid_config
self.ctrl_var = ctrl_var
self.var_vals = var_vals
self.exp_name = exp_name
# folders
self.folder_top = '{}/{}-{}/'.format(FOLDER_EXPS, self.date,
self.exp_name)
self.folder_data = '{}/{}-{}/data/'.format(FOLDER_EXPS, self.date,
self.exp_name)
self.folder_gifs = '{}/{}-{}/gifs/'.format(FOLDER_EXPS, self.date,
self.exp_name)
self.folder_modules = '{}/{}-{}/modules/'.format(
FOLDER_EXPS, self.date, self.exp_name)
self.folder_numerical = '{}/{}-{}/nums/'.format(
FOLDER_EXPS, self.date, self.exp_name)
self.folder_plots = '{}/{}-{}/plots/'.format(FOLDER_EXPS, self.date,
self.exp_name)
self.folder_base_models = 'base_models/'
self.folders = [
self.folder_modules, self.folder_data, self.folder_base_models,
self.folder_gifs, self.folder_numerical, self.folder_plots
]
self.make_folders()
self.train_box = None
self.valid_box = None
self.net = None
self.x = []
self.train_errors = []
self.valid_errors = []
def make_folders(self):
for folder in self.folders:
if not os.path.exists(folder):
os.makedirs(folder)
def run(self):
for i, val in enumerate(self.var_vals):
self.run_single(val, i)
def run_single(self, val, i):
print('Setting {} to {}'.format(ctrl_var, val))
if self.ctrl_var in self.sim_conf.keys():
self.sim_conf[self.ctrl_var] = val
self.train_config['sim_config'] = self.sim_conf
self.valid_config['sim_config'] = self.sim_conf
self.generate_data()
elif self.ctrl_var == 'v_size':
self.train_scheme[self.ctrl_var] = val
if self.train_box is None:
self.generate_data()
else:
raise ValueError('Bad ctrl_var {}'.format(self.ctrl_var))
v_size = self.train_scheme['v_size']
self.net = HydraNet(**self.train_scheme)
# print('Loading base models')
# tag = 'base-{}'.format(v_size)
# self.net.load_modules(self.folder_base_models, tag=tag)
print('Starting training')
self.net.execute_scheme(self.train_box.get_batch_episodes,
self.valid_box.get_batch_episodes)
self.net.save_modules(self.folder_modules, tag='{}'.format(v_size))
print('Saving base models')
tag = 'base-{}'.format(v_size)
self.net.save_modules(self.folder_base_models, tag=tag)
print('Recording videos')
pae_losseses = []
pf_losseses = []
for j in range(GIFS_NO):
losses = self.net.draw_pred_gif(
self.valid_box.get_n_random_episodes_full,
p=1.0,
use_stepper=False,
use_pf=True,
sim_config=sim_config,
folder_plots=self.folder_gifs,
tag='{}-{}'.format(val, j),
normalize=True)
pae_losseses.append(losses['pae_losses'])
pf_losseses.append(losses['pf_losses'])
baseline_level = self.net.plot_losses(
folder_plots=self.folder_plots,
tag=val,
image_getter=self.valid_box.get_batch_episodes)
av_pae_losses = np.mean(np.array(pae_losseses), axis=0)
av_pf_losses = np.mean(np.array(pf_losseses), axis=0)
self.write_av_losses(av_pae_losses, av_pf_losses, baseline_level, val)
# get numericals
self.x.append(val)
self.train_errors.append(
self.get_errors(self.train_box.get_batch_episodes))
self.valid_errors.append(
self.get_errors(self.valid_box.get_batch_episodes))
def write_av_losses(self, pae_loss, pf_loss, baseline_level, tag):
plt.clf()
plt.plot(pae_loss)
plt.plot(pf_loss)
baseline = np.ones(len(pae_loss)) * baseline_level
plt.plot(baseline, 'g--')
plt.title('Loss')
plt.ylabel('loss')
plt.xlabel('timestep')
plt.legend(['PAE', 'PF', 'baseline'])
fpath = '{}/av_time_losses-{}.png'.format(self.folder_plots, tag)
plt.savefig(fpath)
def write_losses(self):
plt.clf()
results = pd.DataFrame({
self.ctrl_var: self.x,
'train_error': self.train_errors,
'valid_error': self.valid_errors
})
fpath = '{}/errors.csv'.format(self.folder_numerical)
results.to_csv(fpath)
plt.scatter(self.x, self.train_errors)
plt.scatter(self.x, self.valid_errors)
plt.title('Loss')
plt.ylabel('loss')
plt.xlabel(self.ctrl_var)
plt.legend(['train', 'valid'])
fpath = '{}/run-summary.png'.format(self.folder_plots)
plt.savefig(fpath)
def get_errors(self, data_getter, test_iters=20):
error_cum = 0
for j in range(test_iters):
error_cum += self.net.train_batch_pred_ae(data_getter,
p=1.0,
test=True)
error = error_cum / test_iters
return error
def generate_data(self):
print('Generating data')
rec = Record(**self.train_config)
rec.run()
fpath_train = '{}/train.pt'.format(self.folder_data)
rec.write(fpath_train)
self.train_box = DataContainer(fpath_train,
batch_size=BATCH_SIZE,
ep_len_read=EP_LEN)
self.train_box.populate_images()
rec = Record(**self.valid_config)
rec.run()
fpath_valid = '{}/test.pt'.format(self.folder_data)
rec.write(fpath_valid)
self.valid_box = DataContainer(fpath_valid,
batch_size=BATCH_SIZE,
ep_len_read=EP_LEN)
self.valid_box.populate_images()
def generate_report(self):
html_doc = "<html><head><title>{0}</title></head>\n<body>\n".format(
self.exp_name)
html_doc += "<h2>{0}</h2>\n".format(self.exp_name)
html_doc += "Simulation configuration: {0}\n".format(self.sim_conf)
html_doc += "Controlled variable: {0}\n".format(self.ctrl_var)
html_doc += "Range: {0}\n".format(self.var_vals)
html_doc += "<h3>Loss for different values of {}</h3>\n".format(
self.ctrl_var)
html_doc += "<center><img src=\"plots/run-summary.png\" width=\"800\"></center>".format(
self.folder_plots)
for val in self.var_vals:
html_doc += "<h3>{0} set to {1}</h3>\n".format(self.ctrl_var, val)
html_doc += "<center><img src=\"plots/loss-{}.png\" width=\"800\"></center>\n".format(
val)
html_doc += "<h3>Loss over time for {} set to {}</h3>\n".format(
self.ctrl_var, val)
html_doc += "<center><img src=\"plots/av_time_losses-{}.png\" width=\"800\"></center>\n".format(
val)
table = "<center><table style=\"text-align: center;\" style=\"margin: 0px auto;\" border=\"1\">" \
"<tr>" \
"<td>{0}</td>" \
"<td>percept</td>" \
"<td>ground truth</td>" \
"<td>prediction</td>" \
"<td>particle filter</td>" \
"</tr>\n".format(self.ctrl_var)
for i in range(GIFS_NO):
new_row = "<tr>" \
"<td>{2}</td>" \
"<td><img src=\"gifs/percepts-{2}-{3}.gif\" width=\"140\"></td>" \
"<td><img src=\"gifs/truths-{2}-{3}.gif\" width=\"140\"></td>" \
"<td><img src=\"gifs/pae_preds-{2}-{3}.gif\" width=\"140\"></td>" \
"<td><img src=\"gifs/pf_preds-{2}-{3}.gif\" width=\"140\"></td>" \
"</tr>\n".format(self.ctrl_var, self.folder_gifs, val, i)
table += new_row
table += "</table></center>\n"
html_doc += table
html_doc += "</body>"
rep = open('{}/report.html'.format(self.folder_top), 'w')
rep.write(html_doc)
frame = np.concatenate(table, axis=1)
# print(frame.shape)
width = frame.shape[1]
row = np.ones((1, width))
frame = np.concatenate([header, frame, row], axis=0)
frames.append(frame)
fpath = '{}/predictions-{}.gif'.format(folder_plots, tag)
imageio.mimsave(fpath, frames)
if __name__ == '__main__':
# train_box = DataContainer('data-balls/pass-train.pt', batch_size=32, ep_len_read=EP_LEN)
# test_box = DataContainer('data-balls/pass-valid.pt', batch_size=32, ep_len_read=EP_LEN)
# train_box = DataContainer('data-balls/mixed-train.pt', batch_size=32, ep_len_read=EP_LEN)
# test_box = DataContainer('data-balls/mixed-valid.pt', batch_size=32, ep_len_read=EP_LEN)
train_box = DataContainer('data-balls/bounce-train.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
test_box = DataContainer('data-balls/bounce-valid.pt', batch_size=BATCH_SIZE, ep_len_read=EP_LEN)
train_box.populate_images()
test_box.populate_images()
hydra = HydraNet()
# hydra.load_modules()
hydra.load_modules(tag='base')
hydra.execute_scheme(train_box.get_batch_episodes, test_box.get_batch_episodes)
hydra.plot_losses()
hydra.draw_pred_gif(test_box.get_n_random_episodes_full, use_stepper=False, use_pf=False)
def batch_to_sequence(batch_eps, fpath, normalise=False):
"""
:param batch_eps: in format (timesteps, batchs_size, im_channels, im_height, im_width)
:param fpath:
:return:
"""
batch_eps = [batch_eps[:, i, ...] for i in range(batch_eps.shape[1])]
batch_eps = np.concatenate(batch_eps, axis=-1)
im_seq = []
for i in range(batch_eps.shape[0]):
im_seq.append(batch_eps[i, 0, :, :])
imageio.mimsave(fpath, im_seq)
if __name__ == "__main__":
data_test = DataContainer('data-balls/simple-test.pt',
batch_size=16,
ep_len_read=40)
data_test.populate_images()
batch_eps = data_test.get_batch_episodes()
print(batch_eps.shape)
batch_eps = batch_eps.transpose((1, 0, 4, 2, 3))
batch_to_sequence(batch_eps, 'test.gif')
input = Variable(input)
label = Variable(label)
noise = Variable(noise)
fixed_noise = Variable(fixed_noise)
# setup optimizer
optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
# data_train = DataContainer('data-balls/bounce-train.pt', batch_size=opt.batchSize, ep_len_read=EP_LEN)
# data_train.populate_images()
if __name__ == "__main__":
data_test = DataContainer('data-balls/bounce-valid.pt',
batch_size=opt.batchSize,
ep_len_read=EP_LEN)
data_test.populate_images()
for epoch in range(opt.niter):
for i in range(1000):
x = data_test.get_n_random_images(opt.batchSize)
x = x.transpose((0, 3, 1, 2))
x = torch.FloatTensor(x)
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
# train with real
netD.zero_grad()
real_cpu = x