Neural Style Transfer : Guide complet — Transfert de Style Artistique

Résumé — Le Neural Style Transfer (NST), popularisé par Gatys, Ecker et Bethge en 2015, est une technique fascinante qui combine le contenu d’une image avec le style artistique d’une autre. En exploitant les représentations hiérarchiques d’un réseau de neurones pré-entraîné (VGG-19), le NST sépare le contenu sémantique (les objets, formes et structures) du style (textures, couleurs, coups de pinceau). Cette approche a démontré que les réseaux profonds encodent explicitement ces deux dimensions de manière distincte, ouvrant la voie à de nouvelles applications créatives et artistiques.

Principe mathématique

Le Neural Style Transfer reformule le problème artistique comme une optimisation d’image. Au lieu d’entraîner un réseau, on optimise directement les pixels d’une image générée pour minimiser une fonction de coût composite.

1. Loss de contenu

La loss de contenu mesure la différence entre les features extraites de l’image générée I et de l’image de contenu P à une couche l du réseau VGG :

L_content = ||F_l(I) - F_l(P)||²

Où F_l représente l’activation de la couche l du réseau VGG-19. Typiquement, on utilise conv4_2 car elle capture les structures à haut niveau (objets, visages) sans être trop abstraite.

2. Loss de style — Gram Matrix

Le style est capturé par la Gram matrix, qui mesure les corrélations entre les filtres d’une couche :

G_l = F_l^T · F_l
G_l(f1, f2) = sommaire F_l(f1, x, y) · F_l(f2, x, y)  pour tout x, y

La Gram matrix ne conserve pas l’information spatiale mais capture les textures et motifs visuels : quels types de filtres s’activent ensemble et avec quelle intensité.

La loss de style est la somme des différences de Gram matrix entre l’image générée I et l’image de style A, sur plusieurs couches :

L_style = sommaire wl · ||G_l(I) - G_l(A)||²

Où wl sont les poids de chaque couche. En pratique, on utilise conv1_1, conv2_1, conv3_1, conv4_1, conv5_1 — les couches 1 captent les textures fines, les couches 5 les motifs à grande échelle.

3. Loss totale

L_total = alpha · L_content + beta · L_style

Le ratio alpha/beta contrôle le compromis contenu/style : un ratio élevé favorise la fidélité au contenu, un ratio faible favorise l’expression artistique.

4. Variation Totale

Pour réduire le bruit haute fréquence dans l’image générée, on ajoute une régularisation de variation totale :

L_tv = sommaire |I(x+1,y) - I(x,y)| + |I(x,y+1) - I(x,y)|

Intuition

Le Neural Style Transfer pose deux questions séparées à un réseau VGG pré-entraîné :

1. “Qu’est-ce que cette image montre ?” (contenu) — Les couches profondes du réseau, comme conv4_2, répondent à cette question en codant les objets et leur disposition spatiale.
2. “À quoi ressemble cette image ?” (style) — Les couches superficielles, via la Gram matrix, capturent les textures, les couleurs dominantes et les motifs récurrents sans se soucier de leur position dans l’image.

Le NST fusionne ces deux réponses en une seule image : un paysage parisien (contenu) peint avec les coups de pinceau tourbillonnants de Van Gogh (style).

C’est comme si un photographe et un peintre travaillaient ensemble : le photographe fournit la composition et les formes, le peintre applique sa technique et ses couleurs. Le résultat n’est ni une photo ni un tableau, mais quelque chose de fondamentalement nouveau.

Implémentation Python

1. Neural Style Transfer avec PyTorch et VGG-19

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
import torchvision.transforms as transforms
from PIL import Image

# Chargement du VGG-19 pre-entraine
vgg = models.vgg19(weights=models.VGG19_Weights.IMAGENET1K_V1).features
# Geler tous les parametres
for param in vgg.parameters():
    param.requires_grad_(False)
vgg = vgg.eval()

class VGGFeatures(nn.Module):
    def __init__(self, vgg_model, content_layers, style_layers):
        super().__init__()
        self.vgg = vgg_model
        self.content_layers = content_layers
        self.style_layers = style_layers

    def forward(self, x):
        content_features = []
        style_features = []
        h = x
        for i, layer in enumerate(self.vgg):
            h = layer(h)
            name = f'conv_{i}'
            if name in self.content_layers:
                content_features.append(h)
            if name in self.style_layers:
                style_features.append(h)
        return content_features, style_features

def gram_matrix(tensor):
    """Calcule la Gram matrix pour capturer le style."""
    b, c, height, width = tensor.size()
    features = tensor.view(b * c, height * width)
    G = torch.mm(features, features.t())
    return G.div(b * c * height * width)

# Preparer les images
transform = transforms.Compose([
    transforms.Resize((512, 512)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.224])
])

content_img = transform(Image.open('content.jpg')).unsqueeze(0)
style_img = transform(Image.open('style.jpg')).unsqueeze(0)

# Image generee initialisee avec le bruit gaussien
generated = torch.randn_like(content_img, requires_grad=True)

# Hyperparametres
content_weight = 1.0
style_weight = 1e6
num_iterations = 300

# Optimiseur LBFGS (original de Gatys et al.)
optimizer = optim.LBFGS([generated], max_iter=20, history_size=500)

content_layers_list = ['conv_23']  # conv4_2
style_layers_list = ['conv_1', 'conv_6', 'conv_11', 'conv_20', 'conv_29']

extractor = VGGFeatures(vgg, content_layers_list, style_layers_list)
content_features_target = extractor(content_img)[0]
style_features_target = extractor(style_img)[1]

for step in range(num_iterations):
    def closure():
        optimizer.zero_grad()
        content_feat, style_feat = extractor(generated)

        # Loss de contenu
        content_loss = nn.functional.mse_loss(content_feat[0],
                                              content_features_target[0])

        # Loss de style
        style_loss = 0
        for sf, sf_target in zip(style_feat, style_features_target):
            G = gram_matrix(sf)
            G_target = gram_matrix(sf_target)
            style_loss += nn.functional.mse_loss(G, G_target)

        loss = content_weight * content_loss + style_weight * style_loss
        loss.backward()

        if step % 50 == 0:
            print(f'Step {step} | Loss: {loss.item():.1f} | '
                  f'Content: {content_loss.item():.1f} | '
                  f'Style: {style_loss.item():.1f}')
        return loss

    optimizer.step(closure)

# Sauvegarder l'image generee
print('Image sauvegardee avec succes!')

2. Fast Neural Style Transfer (entraînement d’un modèle)

# Pour un usage en production, on entraine un reseau de transformation
# qui genere le style en une seule passe (feed-forward)
class ResidualBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.conv = nn.Sequential(
            nn.ReflectionPad2d(1),
            nn.Conv2d(channels, channels, kernel_size=3),
            nn.InstanceNorm2d(channels),
            nn.ReLU(True),
            nn.ReflectionPad2d(1),
            nn.Conv2d(channels, channels, kernel_size=3),
            nn.InstanceNorm2d(channels),
        )
    def forward(self, x):
        return x + self.conv(x)

class TransformerNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.ReflectionPad2d(40),
            nn.Conv2d(3, 32, kernel_size=9, stride=1),
            nn.InstanceNorm2d(32), nn.ReLU(True),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),
            nn.InstanceNorm2d(64), nn.ReLU(True),
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
            nn.InstanceNorm2d(128), nn.ReLU(True),
        )
        self.residuals = nn.Sequential(*[ResidualBlock(128) for _ in range(5)])
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.InstanceNorm2d(64), nn.ReLU(True),
            nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.InstanceNorm2d(32), nn.ReLU(True),
            nn.ReflectionPad2d(40),
            nn.Conv2d(32, 3, kernel_size=9, stride=1),
        )
    def forward(self, x):
        return self.decoder(self.residuals(self.encoder(x)))

Hyperparamètres

Avantages

1. Créativité algorithmique : Le NST a été l’une des premières applications grand public à montrer que l’IA peut faire de l’art, pas seulement de l’analyse.
2. Pas d’entraînement requis : La méthode originale n’entraîne aucun réseau — elle optimise directement les pixels. Chaque paire contenu/style est unique.
3. Contrôle fin : Les poids alpha/beta permettent de régler précisément le compromis entre fidélité au contenu et expression du style.
4. Fast NST : Une fois le transformateur entraîné pour un style spécifique, le transfert est instantané (une seule passe forward).

Limites

1. Lenteur de la méthode originale : L’optimisation itérative de l’image prend plusieurs minutes par résultat.
2. Un modèle par style (Fast NST) : Le Fast NST nécessite un réseau dédié par style. Pas de transfert zero-shot sur des styles non vus.
3. Artefacts visuels : Le NST peut produire des halos de couleur, des textures répétitives ou des distorsions sur les contours.
4. Choix subjectif des hyperparamètres : Le ratio contenu/style optimal dépend du contenu et du style — il n’existe pas de valeur universelle.

4 cas d’usage concrets

1. Applications mobiles artistiques (Prisma, Deep Dream)

Prisma a popularisé le NST en 2016 avec plus de 100 millions de téléchargements. L’application applique des styles artistiques célèbres aux photos des utilisateurs en temps quasi-réel grâce à des modèles feed-forward entraînés spécifiquement pour chaque filtre de style.

2. Production de contenu pour le divertissement

Les studios de cinéma et de jeu vidéo utilisent le NST pour créer des visuels stylisés : concept art, storyboards, textures pour les environnements 3D. Le NST permet d’explorer rapidement plusieurs directions artistiques sans engager un peintre pour chaque variation.

3. Photographie et retouche d’images

Les photographes utilisent le NST comme outil créatif pour transformer des photos en œuvres d’art, appliquer des filtres de style cohérents à un portfolio entier, ou créer des variations artistiques pour des expositions.

4. Augmentation de données pour la vision par ordinateur

Le NST peut générer des versions stylisées d’images d’entraînement pour améliorer la robustesse d’un modèle de classification. En appliquant différents styles (dessin, peinture, croquis) aux images d’entraînement, le modèle apprend des features plus abstraites et moins dépendantes de l’apparence photoréaliste.

Comparaison avec les approches modernes

Le NST original (Gatys et al., 2015) a été suivi par des approches plus récentes et puissantes :

• AdaIN (2017) : Alignement des statistiques (moyenne et variance) des features du contenu avec celles du style. Plus rapide et permet un contrôle continu du degré de stylisation.
• StyleGAN (2019) : Intègre le style directement dans la génération, permettant un contrôle multi-échelle (style grossier → couleurs globales, style fin → textures détaillées).
• Diffusion-based style transfer (2023-2024) : Les modèles de diffusion comme Stable Diffusion permettent du text-guided style transfer (“une photo de chat dans le style de Van Gogh”) avec une qualité photoréaliste.

Conclusion

Le Neural Style Transfer a été une révolution conceptuelle : il a prouvé que les réseaux neuronaux profonds séparent naturellement le contenu du style dans leurs représentations. Cette découverte a ouvert la voie à l’art génératif moderne et aux modèles comme DALL-E, Midjourney et Stable Diffusion.

Bien que les méthodes modernes de diffusion aient largement surpassé le NST en qualité visuelle, le principe fondamental — séparer et recombiner les dimensions du contenu et du style — reste au cœur de la génération d’images contemporaine.

Voir aussi

• Découvrez ‘Factor Shuffle’ en Python : Guide Complet pour Réorganiser vos Collections Efficacement
• Découverte des Voisins Lexicographiques en Python : Guide Complet pour Développeurs