def scale_by(self, f): image = to_image(self.image).scale_by(f) sem_style = to_image(self.semantic_style_image).scale_by( f, resample=NEAREST) sem_cont = to_image(self.semantic_content_image).scale_by( f, resample=NEAREST) return SemanticStyle(image=self.image, layer_ids=self.layer_ids, layer_weights=self.layer_weights, lambda_loss=self.lambda_loss, k=self.k, s=self.s, semantic_style_image=sem_style, semantic_content_image=sem_cont, gamma=self.gamma, gamma_scale=self.gamma_scale)
def generate(self, style, content=None, seed=None, lambda_tv=5e-5, lr=1e-2, niter=200, yield_every=0, disable_progress=False, plugins=None, alpha=1.0): '''Generate an image by minimizing style and content losses. Params ------ style : style.losses.LossProvider A method that provides style losses. Currently one can choose between global GramStyle, PatchStyle and SemanticStyle. Kwargs ------ content : style.losses.LossProvider Provides content loss. If None does not compute a content loss. seed : image Initial values of image to be generated. If None, initializes with a white noise image of size equal to content. If content is not available, defaults to white noise of size (256,256,3) lambda_tv : scalar Strengthness of total variation regularization used to avoid noise artefacts in generated image. lr : scalar Learning rate niter : number Number of iterations yield_every : number Yields intermediate results every so often. disable_progress : boolean Disables progress messages. plugins : list, None A optional list of optimization plugins to be invoked during various steps of optimization. ''' content = content or Content(layer_id=8) plugins = plugins or [] x = self._get_or_create_seed(content, style, seed) opt = optim.Adam([x], lr=lr) scheduler = sched.ReduceLROnPlateau(opt, 'min', threshold=1e-3, patience=20, cooldown=50, min_lr=1e-4) net = self.backbone.trimmed_net( max(content.layer_ids + style.layer_ids)) with content.create_loss(net, self.backbone.dev) as cl, style.create_loss( net, self.backbone.dev) as sl: [plugin.prepare(cl, sl, x, niter=niter) for plugin in plugins] losses = None with tqdm(total=niter, disable=disable_progress) as t: for idx in range(niter): opt.zero_grad() net(x) closs = cl() * content.lambda_loss sloss = sl() * style.lambda_loss tvloss = priors.tv_prior(x) * lambda_tv loss = closs + alpha * (sloss + tvloss) for plugin in plugins: loss = plugin.after_loss(x, loss) loss.backward() [plugin.after_backward(x) for plugin in plugins] opt.step() [plugin.after_step(x) for plugin in plugins] losses = np.array((loss.item(), closs.item(), sloss.item(), tvloss.item())) t.set_postfix(loss=np.array_str(losses, precision=3), lr=self._max_lr(opt)) t.update() scheduler.step(loss) # Projected gradient descent x.data.clamp_(0, 1) if yield_every > 0 and idx % yield_every == 0: yield image.to_image(x) yield image.to_image(x)
def scale_by(self, f): image = None if self.image is not None: image = to_image(self.image).scale_by(f) return Content(image, self.layer_ids[0], self.lambda_loss)
def scale_by(self, f): image = to_image(self.image).scale_by(f) return PatchStyle(image, self.layer_ids, self.layer_weights, self.lambda_loss, self.k, self.s)