예제 #1
0
def anneal_ringer(code):
    f = lambda (x): -log(fitness(code, x))
    mu = 0.1
    prop = lambda (bd, sites): (mutate_bd(bd, mu), [mutate_site(sites[0], mu)]
                                * n)
    x0 = sample_species()
    ring = anneal(f, prop, x0, return_trajectory=False, k=0.001)
    return ring
예제 #2
0
 def train(self, loader, epoch, args):
     """Train for a single epoch using batched gradient descent."""
     model, optimizer = self.model, self.optimizer
     model.train()
     data_num, loss = 0, 0.0
     rec_mults = dict(args.rec_mults)
     # Iterate over batches
     for b_num, (targets, mask, lengths, _) in enumerate(loader):
         # Anneal KLD loss multipliers
         b_tot = b_num + epoch * len(loader)
         kld_mult =\
             anneal(0.0, args.kld_mult, b_tot, args.kld_anneal*len(loader))
         # Send to device
         mask = mask.to(args.device)
         for m in targets.keys():
             targets[m] = targets[m].to(args.device)
         # Introduce burst deletions to improve interpolation
         inputs = mseq.burst_delete(targets, args.burst_frac, lengths)
         # Compute batch loss
         b_loss = model.step(inputs,
                             mask,
                             kld_mult,
                             rec_mults,
                             targets=targets,
                             lengths=lengths,
                             **args.train_args)
         loss += b_loss
         # Average over number of datapoints before stepping
         b_loss /= sum(lengths)
         b_loss.backward()
         # Plot gradients
         if args.gradients:
             plot_grad_flow(model.named_parameters())
         # Gradient clipping
         if args.clip_grad is not None and args.clip_grad > 0:
             clip_grad_norm_(model.parameters(), args.clip_grad)
         # Step, then zero gradients
         optimizer.step()
         optimizer.zero_grad()
         # Keep track of total number of time-points
         data_num += sum(lengths)
         print('Batch: {:5d}\tLoss: {:10.1f}'.\
               format(b_num, loss/data_num))
     # Average losses and print
     loss /= data_num
     print('---')
     print('Epoch: {}\tLoss: {:10.1f}\tKLD-Mult: {:0.3f}'.\
           format(epoch, loss, kld_mult))
     return loss
예제 #3
0
def mr_system_sa(alphas,init_system=None,G=100000.0,n=16,L=10,
              sse_epsilon=0.0001,proposal=propose,scale=1000,
              iterations=10000,return_trajectory=False):
    if init_system is None:
        matrix = [[0,0,0,0] for i in range(L)]
        motif = [random_site(L) for i in range(n)]
    else:
        matrix,motif = init_system
    scaled_sse = lambda(matrix,motif):sse(matrix,motif,alphas,G,n)*scale
    return anneal(scaled_sse,
                  lambda(matrix,motif):proposal(matrix,motif),
                  (matrix,motif),
                  iterations=iterations,
                  stopping_crit = sse_epsilon*scale,
                  return_trajectory=return_trajectory)
예제 #4
0
파일: main.py 프로젝트: suzyahyah/rnn-vae
def train_(train_dataloader, log_train, steps, model, optimizer, ix2w, epoch,
           args):
    lossD = get_loss_D()

    # for each batch
    for i, (xx, x_lens, ey, ye, y_lens) in enumerate(train_dataloader):
        steps += 1
        # i only drop words on train.
        ey = utils.drop_words(ey, y_lens, args.word_dropout)

        x_recon, z, q_mu, q_logvar = model(xx, x_lens, ey, y_lens)
        bce, kld = model.loss_fn(ye, y_lens, x_recon, q_mu, q_logvar)

        loss = bce

        if args.framework == "vae":
            lossD['kld'].append(kld.item())
            kl_weight = utils.anneal(steps, args.kl_anneal_steps)
            loss += (kld * kl_weight)

        if args.bow:
            bow_loss = model.loss_bow(ye, z)
            loss += bow_loss
            lossD['bow'].append(bow_loss.item())

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        lossD['running'].append(loss.item())
        lossD['bce'].append(bce.item())
        #lossD['ppl'].append(np.exp(bce.item()))

    out = print_loss(log_train, lossD)
    print("--TRAIN--" + out)

    #### Reconstructions
    model.eval()
    input0 = model.embedding(torch.LongTensor([0]).to(device))
    z = torch.randn(5, args.z_dim)
    vis.sample_reconstruct(log_sample, epoch, model, input0, z, ix2w)
    vis.input_reconstruct(log_sample, model, x_lens[0:5], xx[0:5], input0,
                          ix2w, device)
    vis.train_reconstruct(log_sample, x_lens[0:5], xx[0:5], x_recon[0:5], ix2w)
    ####
    return steps
예제 #5
0
def mr_system(alphas,init_system=None,G=100000.0,n=16,L=10,
              sse_epsilon=0.00000001,use_annealing=True,scale=1000,
              iterations=10000,motif_prob=0.5,verbose=False):
    proposal = lambda matrix,motif:propose(matrix,motif,motif_prob=motif_prob)
    if init_system is None:
        matrix = [[0,0,0,0] for i in range(L)]
        motif = [random_site(L) for i in range(n)]
    else:
        matrix,motif = init_system
    if use_annealing:
        scaled_sse = lambda(matrix,motif):((sse(matrix,motif,alphas,G,n))*scale)
        return anneal(scaled_sse,
                      lambda(matrix,motif):proposal(matrix,motif),
                      (matrix,motif),
                      iterations=iterations,
                      stopping_crit = sse_epsilon*scale,verbose=verbose)
    else:
        scaled_sse = lambda(matrix,motif):exp((sse(matrix,motif,alphas,G,n))*-scale)
        return mh(scaled_sse,
                  lambda(matrix,motif):proposal(matrix,motif),
                  (matrix,motif),
                  iterations=iterations,
                  every=100,verbose=True)
def train_vae(cfgv, model, dataset):
    print('Training base vae ...')
    trainer = optim.Adam(model.vae_params(), lr=cfgv.lr)

    for it in tqdm(range(cfgv.s_iter, cfgv.s_iter + cfgv.n_iter + 1),
                   disable=None):
        if it % cfgv.cheaplog_every == 0 or it % cfgv.expsvlog_every == 0:

            def tblog(k, v):
                log_value('train_' + k, v, it)
        else:
            tblog = lambda k, v: None

        inputs = dataset.next_batch('train_vae')
        beta = utils.anneal(cfgv.beta, it)
        (z_mu, z_logvar), (z, c), dec_logits = model(inputs.text,
                                                     q_c='prior',
                                                     sample_z=1)
        recon_loss = losses.recon_dec(inputs.text, dec_logits)
        kl_loss = losses.kl_gaussianprior(z_mu, z_logvar)
        wae_mmd_loss = losses.wae_mmd_gaussianprior(z, method='full_kernel')
        wae_mmdrf_loss = losses.wae_mmd_gaussianprior(z, method='rf')
        z_regu_losses = {
            'kl': kl_loss,
            'mmd': wae_mmd_loss,
            'mmdrf': wae_mmdrf_loss
        }
        z_regu_loss = z_regu_losses[cfgv.z_regu_loss]
        z_logvar_L1 = z_logvar.abs().sum(1).mean(
            0)  # L1 in z-dim, mean over mb.
        z_logvar_KL_penalty = losses.kl_gaussian_sharedmu(z_mu, z_logvar)
        loss = recon_loss + beta * z_regu_loss \
               + cfgv.lambda_logvar_L1 * z_logvar_L1 \
               + cfgv.lambda_logvar_KL * z_logvar_KL_penalty

        trainer.zero_grad()
        loss.backward()
        grad_norm = torch.nn.utils.clip_grad_norm_(model.vae_params(),
                                                   cfgv.clip_grad)
        trainer.step()

        tblog('z_mu_L1', z_mu.data.abs().mean().item())
        tblog('z_logvar', z_logvar.data.mean().item())
        tblog('z_logvar_L1', z_logvar_L1.item())
        tblog('z_logvar_KL_penalty', z_logvar_KL_penalty.item())
        tblog('L_vae', loss.item())
        tblog('L_vae_recon', recon_loss.item())
        tblog('L_vae_kl', kl_loss.item())
        tblog('L_wae_mmd', wae_mmd_loss.item())
        tblog('L_wae_mmdrf', wae_mmdrf_loss.item())
        tblog('beta', beta)

        if it % cfgv.cheaplog_every == 0 or it % cfgv.expsvlog_every == 0:
            tqdm.write(
                'ITER {} TRAINING (phase 1). loss_vae: {:.4f}; loss_recon: {:.4f}; loss_kl: {:.4f}; loss_mmd: {:.4f}; '
                'Grad_norm: {:.4e} '.format(it, loss.item(), recon_loss.item(),
                                            kl_loss.item(),
                                            wae_mmd_loss.item(), grad_norm))

            log_sent, _, _ = model.generate_sentences(
                1, sample_mode='categorical')
            tqdm.write('Sample (cat T=1.0): "{}"'.format(
                dataset.idx2sentence(log_sent.squeeze())))
            sys.stdout.flush()
        if it % cfgv.expsvlog_every == 0 and it > 0:
            save_model(model, cfgv.chkpt_path.format(it))
            # Sample 5k sentences from prior/heldout recon/.. to compute external metrics. sample_kwargs from config
            # start and end of training: do expensive evals too.
            tier = 3 if it == cfgv.s_iter or it == cfgv.s_iter + cfgv.n_iter else 2