Exemplo n.º 1
0
 def mask(self, res):
     import mask
     lines = [(self[i][0] * res, self[i][1] * res,
               self[(i + 1) % len(self)][0] * res,
               self[(i + 1) % len(self)][1] * res)
              for i in range(len(self))]
     return mask.make_mask(lines)
Exemplo n.º 2
0
def test(image, char=None):
    classifications = MaskClassifications()
    m1 = make_mask(image, width=mask_table.width, height=mask_table.height)
    for c, m2 in mask_table.masks.items():
        s = cmp_masks(m1, m2)
        classifications.add(c, s)

    return classifications
Exemplo n.º 3
0
    def mask(self, res):
        import mask

        lines = []

        for points in self.triangles():
            points = [(x * res, y * res) for x, y, z in points]
            points = points + [points[0]]

            area = 0.0
            for i in range(len(points) - 1):
                area += ((points[i + 1][0] - points[i][0]) *
                         (points[i + 1][1] + points[i][1]) * 0.5)
            if area > 0.0:
                points = points[::-1]
            for i in range(len(points) - 1):
                lines.append(points[i] + points[i + 1])

        return mask.make_mask(lines)
Exemplo n.º 4
0
 def mask(self, res):
     import mask
     
     lines = [ ]
     
     for points in self.triangles():
         points = [ (x*res,y*res) for x,y,z in points ]
         points = points + [ points[0] ]
         
         area = 0.0
         for i in range(len(points)-1):
             area += (
                 (points[i+1][0]-points[i][0])*
                 (points[i+1][1]+points[i][1])*0.5
             )
         if area > 0.0: 
             points = points[::-1]
         for i in range(len(points)-1):
             lines.append( points[i]+points[i+1] )
         
     return mask.make_mask(lines)
Exemplo n.º 5
0
def train(args, dataset, gen, dis, g_ema, device):
    if args.distributed:
        g_module = gen.module
        d_module = dis.module

    else:
        g_module = gen
        d_module = dis

    vgg = VGGFeature("vgg16", [4, 9, 16, 23, 30],
                     use_fc=True).eval().to(device)
    requires_grad(vgg, False)

    g_optim = optim.Adam(gen.parameters(), lr=1e-4, betas=(0, 0.999))
    d_optim = optim.Adam(dis.parameters(), lr=1e-4, betas=(0, 0.999))

    loader = data.DataLoader(
        dataset,
        batch_size=args.batch,
        num_workers=4,
        sampler=dist.data_sampler(dataset,
                                  shuffle=True,
                                  distributed=args.distributed),
        drop_last=True,
    )

    loader_iter = sample_data(loader)

    pbar = range(args.start_iter, args.iter)

    if dist.get_rank() == 0:
        pbar = tqdm(pbar, initial=args.start_iter, dynamic_ncols=True)

    eps = 1e-8

    for i in pbar:
        real, class_id = next(loader_iter)

        real = real.to(device)
        class_id = class_id.to(device)

        masks = make_mask(real.shape[0], device, args.crop_prob)
        features, fcs = vgg(real)
        features = features + fcs[1:]

        requires_grad(dis, True)
        requires_grad(gen, False)

        real_pred = dis(real, class_id)

        z = torch.randn(args.batch, args.dim_z, device=device)

        fake = gen(z, class_id, features, masks)

        fake_pred = dis(fake, class_id)

        d_loss = d_ls_loss(real_pred, fake_pred)

        d_optim.zero_grad()
        d_loss.backward()
        d_optim.step()

        z1 = torch.randn(args.batch, args.dim_z, device=device)
        z2 = torch.randn(args.batch, args.dim_z, device=device)

        requires_grad(gen, True)
        requires_grad(dis, False)

        masks = make_mask(real.shape[0], device, args.crop_prob)

        if args.distributed:
            gen.broadcast_buffers = True

        fake1 = gen(z1, class_id, features, masks)

        if args.distributed:
            gen.broadcast_buffers = False

        fake2 = gen(z2, class_id, features, masks)

        fake_pred = dis(fake1, class_id)

        a_loss = g_ls_loss(None, fake_pred)

        features_fake, fcs_fake = vgg(fake1)
        features_fake = features_fake + fcs_fake[1:]

        r_loss = recon_loss(features_fake, features, masks)
        div_loss = diversity_loss(z1, z2, fake1, fake2, eps)

        g_loss = a_loss + args.rec_weight * r_loss + args.div_weight * div_loss

        g_optim.zero_grad()
        g_loss.backward()
        g_optim.step()

        accumulate(g_ema, g_module)

        if dist.get_rank() == 0:
            pbar.set_description(
                f"d: {d_loss.item():.4f}; g: {a_loss.item():.4f}; rec: {r_loss.item():.4f}; div: {div_loss.item():.4f}"
            )

            if i % 100 == 0:
                utils.save_image(
                    fake1,
                    f"sample/{str(i).zfill(6)}.png",
                    nrow=int(args.batch**0.5),
                    normalize=True,
                    range=(-1, 1),
                )

            if i % 10000 == 0:
                torch.save(
                    {
                        "args": args,
                        "g_ema": g_ema.state_dict(),
                        "g": g_module.state_dict(),
                        "d": d_module.state_dict(),
                    },
                    f"checkpoint/{str(i).zfill(6)}.pt",
                )
Exemplo n.º 6
0
 def mask(self, res):
     import mask
     lines = [ (self[i][0]*res,self[i][1]*res,
                self[(i+1)%len(self)][0]*res,self[(i+1)%len(self)][1]*res)
               for i in range(len(self)) ]
     return mask.make_mask(lines)
Exemplo n.º 7
0
 def add(self, char, image):
     mask = make_mask(image, width=self._w, height=self._h)
     self._masks[char] = mask