After executing the neural style transfer training process, the resulting synthesized image visually integrates the primary characteristics of its source images. It successfully retains the global scenery and objects from the content image while transferring the distinct color palettes and stylistic attributes from the style image. Often, the synthesized output even captures fine, subtle textures inherent to the style, such as distinct brush strokes or specific blocks of color.

Qualitative Evaluation of Synthesized Image in Style Transfer

To execute the style transfer training, the content and style images are first rescaled to a target resolution (e.g., $$300 \times 450$$ pixels). The synthesized image is typically initialized using the content image. The optimization process then runs for a specified number of epochs, utilizing the predefined training loop to minimize the combined loss.

```python
# PyTorch
device, image_shape = d2l.try_gpu(), (300, 450)  # PIL Image (h, w)
net = net.to(device)
content_X, contents_Y = get_contents(image_shape, device)
_, styles_Y = get_styles(image_shape, device)
output = train(content_X, contents_Y, styles_Y, device, 0.3, 500, 50)
```

Claude

The training loop for CNN-based style transfer continuously updates the synthesized image to minimize the combined loss. In each training epoch, the model extracts the current content and style features from the synthesized image, computes the total loss (a weighted sum of content, style, and total variation losses), and performs backpropagation to update the image pixels using an optimizer and a learning rate scheduler.

```python
# PyTorch
def train(X, contents_Y, styles_Y, device, lr, num_epochs, lr_decay_epoch):
    X, styles_Y_gram, trainer = get_inits(X, device, lr, styles_Y)
    scheduler = torch.optim.lr_scheduler.StepLR(trainer, lr_decay_epoch, 0.8)
    animator = d2l.Animator(xlabel='epoch', ylabel='loss',
                            xlim=[10, num_epochs],
                            legend=['content', 'style', 'TV'],
                            ncols=2, figsize=(7, 2.5))
    for epoch in range(num_epochs):
        trainer.zero_grad()
        contents_Y_hat, styles_Y_hat = extract_features(
            X, content_layers, style_layers)
        contents_l, styles_l, tv_l, l = compute_loss(
            X, contents_Y_hat, styles_Y_hat, contents_Y, styles_Y_gram)
        l.backward()
        trainer.step()
        scheduler.step()
        if (epoch + 1) % 10 == 0:
            animator.axes[1].imshow(postprocess(X))
            animator.add(epoch + 1, [float(sum(contents_l)),
                                     float(sum(styles_l)), float(tv_l)])
    return X
```

Learn Before

Related

Learn After