from qelos_core.scripts.convai.preproc import run as run_preproc
run_preproc()
else:
tt = q.ticktock("script")
tt.tick("loading data")
train_dataset, valid_dataset = load_datasets()
tt.tock("loaded data")
print(
"{} unique words, {} training examples, {} valid examples".format(
len(train_dataset.D), len(train_dataset), len(valid_dataset)))
trainloader = q.dataload(train_dataset,
shuffle=True,
batch_size=batsize)
validloader = q.dataload(valid_dataset,
shuffle=True,
batch_size=batsize)
# test
if test:
testexample = train_dataset[10]
trainloader_iter = iter(trainloader)
tt.tick("getting 1000 batches")
for i in range(1000):
batch = next(iter(trainloader))
tt.tock("got 1000 batches")
print("done")
if __name__ == "__main__":
q.argprun(run)
# region train
optimizer = torch.optim.Adam(q.params_of(model), lr=lr)
trainer = q.trainer(model).on(data).loss(torch.nn.CrossEntropyLoss(), q.Accuracy())\
.optimizer(optimizer).hook(q.ClipGradNorm(5.)).device(device)
validator = q.tester(model).on(valid_data).loss(
q.Accuracy()).device(device)
q.train(trainer, validator).run(epochs=epochs)
# endregion
# region check attention #TODO
# feed a batch
inpd = torch.tensor(sm.matrix[400:410])
outd, att = model(inpd, with_att=True)
outd = torch.max(outd, 1)[1].cpu().detach().numpy()
inpd = inpd.cpu().detach().numpy()
att = att.cpu().detach().numpy()
rD = {v: k for k, v in sm.D.items()}
roD = {v: k for k, v in D.items()}
for i in range(len(att)):
inpdi = " ".join([rD[x] for x in inpd[i]])
outdi = roD[outd[i]]
print("input: {}\nprediction: {}\nattention: {}".format(
inpdi, outdi, " ".join(["{:.1f}".format(x) for x in att[i]])))
# endregion
if __name__ == '__main__':
q.argprun(run_classify)
from qelos_core.scripts.query.wikisql_clean import run_seq2seq_oracle_df as runf
import qelos_core as q
if __name__ == "__main__":
q.argprun(runf)
SeqGAN = SeqGAN_Base if usebase else SeqGAN_DCL
disc_model = SeqGAN(discriminator, generator, gan_mode=q.gan.GAN.DISC_TRAIN, accumulate=not noaccumulate)
gen_model = SeqGAN(discriminator, generator, gan_mode=q.gan.GAN.GEN_TRAIN, accumulate=not noaccumulate)
disc_optim = torch.optim.Adam(q.params_of(discriminator), lr=lr)
gen_optim = torch.optim.Adam(q.params_of(generator), lr=lr)
disc_trainer = q.trainer(disc_model).on(disc_data).optimizer(disc_optim).loss(q.no_losses(2))
gen_trainer = q.trainer(gen_model).on(gen_data).optimizer(gen_optim).loss(q.no_losses(2))
gan_trainer = q.gan.GANTrainer(disc_trainer, gen_trainer)
gan_trainer.run(epochs, disciters=5, geniters=1, burnin=500)
# print some predictions:
with torch.no_grad():
rvocab = {v: k for k, v in vocab.items()}
q.batch_reset(generator)
eval_z = torch.randn(50, z_dim)
eval_y, _ = generator(eval_z)
for i in range(len(eval_y)):
prow = "".join([rvocab[mij] for mij in eval_y[i].numpy()])
print(prow)
print("done")
if __name__ == "__main__":
q.argprun(run_cond_toy)
return self.orig[index][0]
def __len__(self):
return len(self.orig)
cifar = dset.CIFAR10(root='../datasets/cifar/',
download=True,
train=True,
transform=transforms.Compose([
transforms.Scale(32),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
]))
device = torch.device("cpu") if not cuda else torch.device("cuda", gpu)
print(device, cuda)
cifar = IgnoreLabelDataset(cifar)
cifar_loader = q.dataload(cifar, batch_size=batsize)
scorer = q.gan.FIDandIS(device=device)
print(scorer.inception.training)
scorer.set_real_stats_with(cifar_loader)
print("Calculating FID and IS ... ")
scores = scorer.get_scores(cifar_loader)
print(scores)
if __name__ == '__main__':
q.argprun(tst_inception_cifar10)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
model = Net()
optim = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum)
trainer = q.trainer(model).on(train_loader)\
.loss(torch.nn.NLLLoss(), q.Accuracy())\
.optimizer(optim).cuda(cuda)
validator = q.tester(model).on(test_loader)\
.loss(torch.nn.NLLLoss(), q.Accuracy())\
.cuda(cuda)
logger.loglosses(trainer, "train.losses")
logger.loglosses(validator, "valid.losses")
q.train(trainer, validator).run(epochs)
if __name__ == "__main__":
q.argprun(run_sound)
core_out = self.core(core_inp)
out = self.out(core_out)
return out
decoder_cell = DecoderCell(decoder_emb, decoder_lstm, decoder_outlin)
decoder = q.TFDecoder(decoder_cell)
# endregion
likelihood = Likelihood()
vae = SeqVAE(encoder, decoder, likelihood)
x = torch.randint(0, vocsize, (batsize, seqlen), dtype=torch.int64)
ys = vae(x)
optim = torch.optim.Adam(q.params_of(vae), lr=lr)
x = torch.randint(0, vocsize, (batsize * 100, seqlen), dtype=torch.int64)
dataloader = q.dataload(x, batch_size=batsize, shuffle=True)
trainer = q.trainer(vae).on(dataloader).optimizer(optim).loss(4).epochs(
epochs)
trainer.run()
print("done \n\n")
if __name__ == "__main__":
# q.argprun(run_seqvae_toy)
q.argprun(run_normal_seqvae_toy)
