Neural Style Transfer : Guide Complet — Transfert de Style Artistique

Résumé

Le Neural Style Transfer (transfert de style neuronal) représente l’une des applications les plus spectaculaires et visuellement impressionnantes du deep learning. Cette technique permet de fusionner le contenu d’une image photographique avec le style artistique d’une œuvre picturale, produisant ainsi une nouvelle image qui conserve les structures et objets de la première tout en adoptant les coups de pinceau, les palettes de couleurs et les textures caractéristiques de la seconde. Introduit par Gatys, Ecker et Bethge en 2015 dans leur article fondateur « A Neural Algorithm of Artistic Style », ce procédé repose sur l’exploitation des représentations internes d’un réseau de neurones convolutionnel pré-entraîné, typiquement VGG19 ou VGG16. Contrairement aux approches traditionnelles de traitement d’image, le Neural Style Transfer ne repose sur aucun filtre manuel ou règle heuristique : il extrait automatiquement les signatures stylistiques à partir des données mêmes. Dans ce guide complet, nous explorerons les fondements mathématiques, l’intuition visuelle, l’implémentation pratique avec TensorFlow, le réglage des hyperparamètres, ainsi que les cas d’usage réels de cette technologie fascinante.

Principe Mathématique du Neural Style Transfer

Le cœur du Neural Style Transfer repose sur une fonction de perte (loss function) composite qui mesure simultanément deux objectifs apparemment contradictoires : préserver le contenu d’une image source et adopter le style d’une image de référence. La formule fondamentale s’écrit :

Loss totale = α × L_contenu + β × L_style

où α et β sont des pondérations scalaires qui contrôlent l’équilibre relatif entre la fidélité au contenu et l’intensité du style appliqué.

Loss de Contenu

La loss de contenu mesure à quel point les structures spatiales de l’image générée correspondent à celles de l’image de contenu. Mathématiquement, elle se définit comme la différence quadratique moyenne entre les activations d’une couche intermédiaire du réseau convolutionnel :

L_contenu = ||F^l(c) – F^l(g)||²

où F^l(c) représente le tenseur d’activations de la couche l pour l’image de contenu c, et F^l(g) le même tenseur pour l’image générée g. Dans la pratique, on utilise généralement une couche profonde du réseau (par exemple block5_conv2 dans VGG19), car ces couches capturent les structures sémantiques de haut niveau — les formes des objets, leurs positions relatives — tout en ayant abandonné les détails fins de texture qui appartiennent plutôt au style.

Cette loss pénalise les écarts entre l’image générée et l’image de contenu au niveau des représentations abstraites du réseau. Si l’image générée préserve bien les grands traits du contenu, le produit F^l(g) sera proche de F^l(c) et la loss sera faible. Le réseau ne compare pas les pixels individuels, mais plutôt les activations neuronales, ce qui permet une certaine flexibilité spatiale tout en conservant la structure globale.

Loss de Style

La loss de style est la partie la plus ingénieuse de l’algorithme. Plutôt que de comparer directement les activations, elle compare les matrices de Gram calculées à partir de ces activations :

L_style = ||G^l(s) – G^l(g)||²_F

où G^l(s) est la matrice de Gram de la couche l pour l’image de style s, G^l(g) est la matrice de Gram de la même couche pour l’image générée g, et ||·||_F désigne la norme de Frobenius (la racine carrée de la somme des carrés de tous les éléments de la matrice).

Mais qu’est-ce qu’une matrice de Gram exactement ? Pour une couche donnée possédant N filtres (ou canaux), la matrice de Gram est une matrice carrée de taille N × N où chaque élément G_ij représente le produit scalaire entre les réponses vectorisées du filtre i et du filtre j. Autrement dit, elle capture les corrélations entre les filtres : si deux filtres tendent à s’activer simultanément sur une image, leur coefficient dans la matrice de Gram sera élevé.

L’idée fondamentale est que ces corrélations capturent l’essence du style — les textures récurrentes, les combinaisons de couleurs, les motifs caractéristiques — sans retenir l’information spatiale précise. En minimisant la différence entre les matrices de Gram du style et de l’image générée, on force cette dernière à reproduire les mêmes distributions de textures et de couleurs.

Dans la pratique, on ne se limite pas à une seule couche. On calcule la loss de style sur plusieurs couches simultanément (par exemple block1_conv1, block2_conv1, block3_conv1, block4_conv1, block5_conv1 dans VGG19) et on fait la somme pondérée :

L_style_total = Σ w_l × ||G^l(s) – G^l(g)||²_F

Les couches basses capturent les textures fines (grains de peinture, traits courts), tandis que les couches plus profondes capturent des motifs structurels plus larges (formes de coups de pinceau, distributions de couleurs à grande échelle).

Optimisation Itérative : Pixel par Pixel

Ce qui distingue fondamentalement le Neural Style Transfer de l’entraînement classique d’un réseau de neurones est le suivant : on n’optimise pas les poids du réseau. Les poids du VGG19 pré-entraîné sont figés (non entraînables). À la place, on optimise directement les pixels de l’image générée.

Le processus est le suivant :

1. On initialise l’image générée g (soit aléatoirement avec du bruit gaussien, soit en copiant l’image de contenu pour une convergence plus rapide).
2. On effectue une passe avant (forward pass) à travers le VGG19 figé pour extraire les activations aux couches pertinentes.
3. On calcule la loss totale combinant content loss et style loss.
4. On effectue une rétropropagation (backpropagation) pour calculer les gradients de la loss par rapport aux pixels de l’image générée (∂L/∂g).
5. On met à jour les pixels de g via un optimiseur (typiquement L-BFGS ou Adam).
6. On répète les étapes 2 à 5 pendant un nombre déterminé d’itérations.

C’est cette particularité — optimiser les pixels plutôt que les poids — qui rend le Neural Style Transfer si remarquable. L’image générée émerge progressivement du bruit, se structurant itérativement pour satisfaire simultanément les contraintes de contenu et de style. Chaque itération affine les détails, renforce les textures stylistiques et précise les contours du contenu.

Intuition Visuelle : Le Peintre Numérique

Pour comprendre intuitivement comment fonctionne le Neural Style Transfer, imaginez un peintre talentueux installé devant son chevalet. Sur sa gauche, il regarde une photographie d’un paysage — disons la baie de San Francisco avec le Golden Gate Bridge. Sur sa droite, il contemple « La Nuit Étoilée » de Vincent van Gogh à Arles, avec ses tourbillons de bleu profond et ses étoiles jaunes rayonnantes.

Le peintre ne copie ni l’un ni l’autre. Il recrée le paysage de San Francisco — le pont, l’eau, le ciel — mais il le peint avec les coups de pinceau tourbillonnants, la palette de couleurs vibrantes, les textures empâtées et l’expressivité émotionnelle caractéristiques du style de Van Gogh. Le Golden Gate Bridge apparaît, mais ses lignes droites sont adoucies par des arabesques tourbillonnantes. L’eau de la baie devient un fleuve de bleus et de verts striés de traits de pinceau visibles. Le ciel nocturne prend vie avec des étoiles tournoyantes.

C’est exactement ce que fait le Neural Style Transfer, mais de manière algorithmique :

• Les couches profondes du réseau jouent le rôle de la perception des formes du peintre : elles reconnaissent « il y a un pont ici, de l’eau là-bas, un ciel au-dessus ».
• Les matrices de Gram jouent le rôle de la mémoire stylistique du peintre : elles encodent « les coups de pinceau sont courbes et tourbillonnants, les couleurs sont saturées avec des contrastes marqués bleu-jaune, les textures sont épaisses et directionnelles ».
• L’optimisation itérative joue le rôle des coups de pinceau successifs : chaque itération affine un peu plus l’image, rapprochant le résultat de l’idéal visé.

Cette métaphore du peintre illustre parfaitement la séparation entre contenu et style que le Neural Style Transfer opère naturellement grâce à l’architecture hiérarchique des réseaux convolutionnels profonds.

Implémentation Python avec TensorFlow

Voici une implémentation complète et fonctionnelle du Neural Style Transfer utilisant TensorFlow/Keras avec le modèle VGG19 pré-entraîné sur ImageNet.

Étape 1 : Configuration et Chargement du Modèle

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.applications import VGG19
from tensorflow.keras import Model
import time

# --- Configuration ---
CONTENT_IMAGE_PATH = "content.jpg"
STYLE_IMAGE_PATH = "style.jpg"
OUTPUT_IMAGE_PATH = "output.jpg"

# Couches pour l'extraction du style et du contenu
CONTENT_LAYER = "block5_conv2"
STYLE_LAYERS = [
    "block1_conv1",
    "block2_conv1",
    "block3_conv1",
    "block4_conv1",
    "block5_conv1",
]

# Hyperparamètres
NUM_ITERATIONS = 1000
CONTENT_WEIGHT = 1e9
STYLE_WEIGHT = 1e-2
TOTAL_VARIATION_WEIGHT = 30
LEARNING_RATE = 2.0

# Dimensions de l'image
IMG_HEIGHT = 400
IMG_WIDTH = 400

Étape 2 : Prétraitement des Images

def load_and_preprocess_image(image_path):
    """Charge et prétraite une image pour VGG19."""
    img = tf.io.read_file(image_path)
    img = tf.io.decode_image(img, channels=3)
    img = tf.cast(img, tf.float32)
    img = tf.image.resize(img, (IMG_HEIGHT, IMG_WIDTH))
    # VGG19: soustraction des moyennes ImageNet (BGR)
    img = tf.keras.applications.vgg19.preprocess_input(img)
    return img


def deprocess_image(img):
    """Inverse le prétraitement VGG19 pour l'affichage."""
    # VGG19 preprocess_input soustrait les moyennes [103.939, 116.779, 123.68]
    img[:, :, 0] += 103.939
    img[:, :, 1] += 116.779
    img[:, :, 2] += 123.68
    img = img[:, :, ::-1]  # BGR → RGB
    img = tf.clip_by_value(img, 0, 255)
    return tf.cast(img, tf.uint8)

Étape 3 : Construction du Modèle d’Extraction des Features

def get_vgg19_feature_extractor(style_layers, content_layer):
    """
    Construit un modèle VGG19 qui extrait les activations
    des couches spécifiées pour le style et le contenu.
    """
    vgg = VGG19(include_top=False, weights="imagenet",
                input_shape=(IMG_HEIGHT, IMG_WIDTH, 3))
    vgg.trainable = False  # Poids figés !

    # Récupérer les sorties des couches désirées
    style_outputs = [vgg.get_layer(name).output for name in style_layers]
    content_output = vgg.get_layer(content_layer).output

    return Model(inputs=vgg.input,
                 outputs=style_outputs + [content_output])


def compute_gram_matrix(feature_map):
    """
    Calcule la matrice de Gram d'un tenseur d'activations.
    feature_map: tenseur de forme (1, H, W, C)
    retourne: matrice de Gram de forme (C, C)
    """
    # Aplatir les dimensions spatiales
    channels = int(feature_map.shape[-1])
    features = tf.reshape(feature_map, [-1, channels])

    # Produit scalaire normalisé
    gram = tf.matmul(tf.transpose(features), features)
    num_locations = tf.cast(tf.shape(feature_map)[1] * tf.shape(feature_map)[2],
                            tf.float32)
    return gram / num_locations

Étape 4 : Fonction de Perte Custom

def compute_loss(model, generated_image, content_image, style_image):
    """
    Calcule la loss totale combinant content loss, style loss
    et total variation loss.
    """
    # Préparer l'entrée (concaténer les 3 images pour un seul forward pass)
    inputs = tf.concat([content_image, style_image, generated_image], axis=0)

    # Forward pass unique à travers VGG19
    outputs = model(inputs)

    # Séparer les outputs: 5 couches de style + 1 couche de contenu
    # Pour chaque image (content, style, generated)
    num_style_layers = len(STYLE_LAYERS)

    # Outputs pour chaque image
    content_outputs = outputs[num_style_layers]           # (3, H, W, C)
    style_outputs = outputs[:num_style_layers]            # liste de 5 tenseurs (3, H, W, C_i)

    # Extraire les activations générées (indice 2)
    generated_content = content_outputs[2:3]    # (1, H, W, C)
    generated_style = [s[2:3] for s in style_outputs]  # liste de (1, H, W, C_i)

    # Content loss
    content_target = content_outputs[0:1]       # (1, H, W, C) du contenu
    content_loss = tf.reduce_mean(tf.square(generated_content - content_target))

    # Style loss (sur toutes les couches de style)
    style_loss = 0.0
    for gen_style_feat, style_image_feat in zip(generated_style, style_outputs):
        gram_generated = compute_gram_matrix(gen_style_feat)
        gram_target = compute_gram_matrix(style_image_feat[0:1])
        style_loss += tf.reduce_mean(tf.square(gram_target - gram_generated))
    style_loss /= len(STYLE_LAYERS)

    # Total Variation Loss (réduit le bruit haute-fréquence)
    tv_loss = compute_total_variation_loss(generated_image)

    # Pondération
    total_loss = (CONTENT_WEIGHT * content_loss +
                  STYLE_WEIGHT * style_loss +
                  TOTAL_VARIATION_WEIGHT * tv_loss)

    return total_loss, content_loss, style_loss, tv_loss


def compute_total_variation_loss(image):
    """
    Pénalise les variations brusques entre pixels adjacents,
    favorisant la régularité spatiale et réduisant le bruit.
    """
    x_deltas = image[:, 1:, :, :] - image[:, :-1, :, :]
    y_deltas = image[:, :, 1:, :] - image[:, :, :-1, :]
    return tf.reduce_sum(tf.abs(x_deltas)) + tf.reduce_sum(tf.abs(y_deltas))

Étape 5 : Boucle d’Optimisation Complète

@tf.function
def train_step(model, generated_image, content_image, style_image, optimizer):
    """
    Effectue une seule étape d'optimisation de l'image générée.
    Utilise tf.function pour la compilation graphique (performance).
    """
    with tf.GradientTape() as tape:
        total_loss, content_loss, style_loss, tv_loss = compute_loss(
            model, generated_image, content_image, style_image
        )

    # Gradients par rapport aux pixels de l'image générée
    grads = tape.gradient(total_loss, generated_image)

    # Mise à jour des pixels
    optimizer.apply_gradients([(grads, generated_image)])

    return total_loss, content_loss, style_loss, tv_loss


def run_neural_style_transfer():
    """Fonction principale exécutant le Neural Style Transfer."""

    # Chargement des images
    content_image = load_and_preprocess_image(CONTENT_IMAGE_PATH)
    content_image = tf.expand_dims(content_image, axis=0)  # (1, H, W, 3)

    style_image = load_and_preprocess_image(STYLE_IMAGE_PATH)
    style_image = tf.expand_dims(style_image, axis=0)

    # Initialisation de l'image générée (bruit + contenu pour convergence rapide)
    generated_image = tf.Variable(
        content_image + tf.random.normal(content_image.shape, stddev=0.1),
        dtype=tf.float32
    )

    # Construction du modèle extracteur
    model = get_vgg19_feature_extractor(STYLE_LAYERS, CONTENT_LAYER)

    # Optimiseur Adam
    optimizer = tf.keras.optimizers.Adam(
        learning_rate=LEARNING_RATE, beta_1=0.99, epsilon=1e-1
    )

    # Boucle d'optimisation
    best_loss = float("inf")
    best_image = None

    for i in range(NUM_ITERATIONS):
        total_loss, c_loss, s_loss, tv_loss = train_step(
            model, generated_image, content_image, style_image, optimizer
        )

        if total_loss < best_loss:
            best_loss = total_loss
            best_image = generated_image.numpy().copy()

        if (i + 1) % 100 == 0:
            print(f"Itération {i+1}/{NUM_ITERATIONS}")
            print(f"  Loss totale : {total_loss:.2f}")
            print(f"  Content loss : {c_loss:.2f}")
            print(f"  Style loss   : {s_loss:.2f}")
            print(f"  TV loss      : {tv_loss:.2f}")

    # Sauvegarde du résultat final
    result = deprocess_image(best_image[0])
    result_img = tf.keras.preprocessing.image.array_to_img(result)
    result_img.save(OUTPUT_IMAGE_PATH)
    print(f"\nImage sauvegardée : {OUTPUT_IMAGE_PATH}")

    return result

Étape 6 : Exécution

if __name__ == "__main__":
    print("=== Neural Style Transfer ===")
    print("Chargement des images et du modèle VGG19...")
    result = run_neural_style_transfer()

    # Affichage du résultat
    plt.figure(figsize=(10, 10))
    plt.imshow(result)
    plt.axis("off")
    plt.title("Résultat du Neural Style Transfer")
    plt.tight_layout()
    plt.show()

Réglage des Hyperparamètres

Le Neural Style Transfer est très sensible au choix des hyperparamètres. Voici un guide pratique pour les ajuster :

Content Weight (α)

Le content_weight contrôle la fidélité au contenu original. Une valeur élevée (ex: 1e9) préserve strictement les structures de l’image de contenu, au risque d’un style moins prononcé. Une valeur trop faible produit une image qui ressemble davantage au style qu’au contenu. La valeur par défaut recommandée se situe entre 1e8 et 1e10, selon la résolution de l’image.

Style Weight (β)

Le style_weight détermine l’intensité du transfert de style. Une valeur plus élevée rend le style plus dominant et envahissant. Les valeurs typiques se situent entre 1e-4 et 1e0. Si le style est trop discret, augmentez cette valeur ; s’il écrase complètement le contenu, réduisez-la.

Total Variation Weight

Le total_variation_weight est crucial pour la qualité visuelle. Il pénalise les variations brusques entre pixels adjacents, ce qui supprime le bruit haute-fréquence généré par l’optimisation et rend l’image plus lisse et naturelle. Sans cette régularisation, l’image finale présente souvent un grain désagréable. Les valeurs recommandées se situent entre 10 et 50.

Nombre d’Itérations

Le num_iterations contrôle la durée de l’optimisation. Typiquement, 500 à 1500 itérations sont nécessaires pour obtenir un résultat de qualité avec Adam. L’algorithme L-BFGS converge généralement plus rapidement (200 à 500 itérations) mais est plus complexe à implémenter dans TensorFlow natif.

Résumé des Hyperparamètres

Astuce pratique : commencez toujours avec l’image de contenu comme initialisation (plutôt que le bruit pur), car cela accélère considérablement la convergence et produit des résultats plus cohérents.

Avantages et Limites

Avantages

• Créativité algorithmique : permet de générer des œuvres visuellement impressionnantes sans intervention artistique manuelle, ouvrant de nouvelles possibilités de création numérique.
• Généralisation remarquable : le même algorithme fonctionne avec n’importe quelle paire d’images (contenu + style), sans besoin de réentraînement ou de fine-tuning du modèle VGG19.
• Fondement théorique solide : repose sur des principes mathématiques rigoureux d’analyse des représentations neuronales profondes et des matrices de Gram.
• Élégance conceptuelle : la séparation contenu/style par l’architecture hiérarchique d’un CNN constitue une découverte fondamentale en vision par ordinateur.
• Accessibilité : l’implémentation nécessite uniquement un modèle pré-entraîné et quelques centaines de lignes de code Python avec TensorFlow ou PyTorch.

Limites

• Lenteur computationnelle : chaque image nécessite une optimisation itérative complète (plusieurs centaines à milliers d’itérations), ce qui prend de quelques minutes à plusieurs heures selon la résolution et le matériel disponible.
• Résolution limitée : les matrices de Gram deviennent extrêmement coûteuses en mémoire pour les images haute résolution. La plupart des implémentations se limitent à 400-800 pixels de côté.
• Artefacts visuels : le résultat peut présenter des distorsions, du bruit, ou des incohérences structurelles, surtout avec des styles très complexes ou des contenus très détaillés.
• Pas de compréhension sémantique : l’algorithme ne reconnaît pas les objets individuels ni leur importance relative. Un visage et un arbre reçoivent le même traitement stylistique, ce qui peut produire des résultats étranges.
• Dépendance aux couches choisies : le choix des couches pour l’extraction du style et du contenu influence drastiquement le résultat, et ce choix reste largement empirique.

Pour pallier certaines de ces limitations, des méthodes plus récentes ont été développées, comme les réseaux de transfert de style rapides (feed-forward style transfer networks) qui apprennent une transformation directe par un seul forward pass, ou AdaIN (Adaptive Instance Normalization) qui permet un contrôle arbitraire du style sans optimisation itérative.

4 Cas d’Usage Concrets du Neural Style Transfer

1. Applications Artistiques et Créatives

De nombreux artistes numériques utilisent le Neural Style Transfer comme outil de création. Des applications comme Prisma, DeepArt et Deep Dream Generator ont démocratisé cette technologie auprès du grand public. Les photographes l’emploient pour ajouter un caractère pictural à leurs clichés, transformant des paysages banals en œuvres évoquant Monet, Van Gogh ou Munch. Certaines galeries d’art contemporain ont même exposé des œuvres créées intégralement par transfert de style neuronal, soulevant des questions fascinantes sur la nature de la créativité et de l’auteur.

2. Prétraitement de Données pour la Vision par Ordinateur

Le Neural Style Transfer trouve une application inattendue mais puissante en augmentation de données. En stylisant différemment les images d’entraînement d’un modèle de classification, on peut augmenter la diversité des données et améliorer la robustesse du modèle face aux variations de style dans le monde réel. Par exemple, un modèle de détection de panneaux de signalisation entraîné avec des images stylisées sera plus performant sous différentes conditions d’éclairage ou de résolution.

3. Post-production Vidéo et Cinéma

Les studios de production explorent le transfert de style pour la post-production vidéo. En appliquant un style artistique cohérent à chaque frame d’une vidéo, on peut créer des effets visuels spectaculaires — par exemple, donner à un film en prises de vues réelles l’apparence d’un dessin animé ou d’une peinture à l’huile animée. Des films comme Spider-Man: Into the Spider-Verse ont popularisé cette esthétique, et le Neural Style Transfer offre une voie automatisée pour atteindre des résultats similaires à moindre coût.

4. Design d’Intérieur et Architecture

Les architectes et designers utilisent le transfert de style pour visualiser rapidement des concepts. Une maquette 3D basique d’un intérieur peut être stylisée avec l’esthétique d’un magazine de design, d’un style architectural spécifique (Art Déco, brutalisme, minimalisme japonais) ou même d’une œuvre d’art célèbre. Cela permet de présenter des visualisations évocatrices aux clients en quelques minutes plutôt qu’en heures de rendu 3D, facilitant la communication visuelle et l’exploration créative en phase de conception.

Conclusion

Le Neural Style Transfer représente une avancée majeure dans notre compréhension de ce que les réseaux de neurones profonds capturent réellement lorsqu’ils « regardent » une image. En démontrant que les représentations neuronales peuvent être décomposées en composantes de contenu et de style indépendantes, Gatys et ses collègues ont non seulement créé un outil de génération d’images spectaculaire, mais ont également contribué à la recherche fondamentale sur l’interprétabilité des modèles profonds.

Bien que des méthodes plus récentes et plus rapides aient été développées depuis 2015, l’algorithme original demeure la référence pédagogique par excellence pour comprendre comment les matrices de Gram, les pertes composites et l’optimisation des pixels interagissent pour produire des résultats d’une beauté saisissante. Pour tout praticien du deep learning qui souhaite véritablement maîtriser la vision par ordinateur et la génération d’images, le Neural Style Transfer constitue une étape incontournable du parcours d’apprentissage.

Voir Aussi

• Calcul de la Somme des Produits en Python : Guide Complet et Astuces Pratiques
• Explorer les Nombres de $k$-Markov avec Python : Guide Complet pour Algorithmes et Programmation