Nettoyage

Le nettoyage des données va être assez simple et rustique : on va garder uniquement les caractères standard du texte (ASCII pour les connaisseurs) : on transforme donc les “é” et “è” en “e” et ainsi de suite. On va aussi tout passer en minuscule. L’idée derrière ces 2 étapes est d’avoir le vocabulaire, c’est à dire le nombre de mot différent, le plus restreint possible. Comme on applique un modèle statistique basé sur la fréquence d’apparition des mots, on veut par exemple que “Ménage” et “menage” soient un seul et même mot (“menage” en l’occurrence). A noter qu’il y a des techniques avancées qui permettent d’aller plus loin dans la normalisation des mots, notamment le stemming et la lemmatization. Mais je ne les utiliserai pas ici pour rester simple.

Enfin un mot sur la ponctuation et les espaces. Toute ponctuation qui marque la fin d’une phrase, le “.” bien entendu, mais aussi “?”, “!”, etc. est convertie simplement en “.”. On les utilisera pour délimiter des phrases. Tous les espaces sont aussi standardisés : saut de ligne, espaces multiples et autres sont réduits à un simple espace ” “.

import re
import unicodedata

def clean_messages(messages):
    cleaned_list = []
    
    for msg in messages:

        # Tous les caractères "spéciaux" sont transformés en ascii : on remplace les accents par leur équivalent ("é" -> "e"), les cédilles ("ç" -> "c"), etc.
        msg = unicodedata.normalize('NFKD', msg)
        msg = msg.encode('ascii', 'ignore').decode('ascii')

        # On convertit tout en minuscule
        msg = msg.lower()    

        # Toutes les ponctuations de fin de texte sont remplacées par un point "." (même chose pour les "..." remplacés par un ".")
        msg = re.sub(r'[!?;\.]+', '.', msg)
        
        # On supprime tout ce qui n'est pas du texte ou un point "." (remplacer par un espace)
        msg = re.sub(r'[^a-z\s\.\']', ' ', msg)

        # On nettoie le message système de Whatsapp qui indique qu'un média (photo, vidéo...) n'est pas récupéré
        msg = re.sub(r'medias omis', ' ', msg)

        # On nettoie les espaces en trop
        msg = re.sub(r'\s+', ' ', msg).strip()

        cleaned_list.append(msg)
        
    return cleaned_list

messages_clean = clean_messages(messages)
print(messages_clean[:3])

["honte a moi j'ai pas du tout eu le temps de m'en occuper.", "d'accord c'etait pour l'ultrabook il coute rien mais je sais pas si c'est ouf go de ram.", "ca a pas l'air dingue dingue en fait."]

Tokenisation

Pour comprendre comment un LLM traite le langage, il faut s’intéresser à sa brique élémentaire : le token. C’est son unité basique de traitement du texte, ce qu’il va manipuler notamment pour prédire la suite de sa génération. Pour la plupart des LLM, ce token est une “partie de mot”. Par exemple pour le mot “antibrouillard”, il peut y avoir un token “anti” et un token “brouillard”. Cette décomposition d’un mot en blocs permet au LLM de “définir” un sens aux mots complexes (le “anti” lui permettant de “comprendre” que cela va contre le “brouillard”). A noter que tous les LLM n’utilisent pas la même tokenisation.

Dans notre cas d’exemple très simple, on va utiliser comme token un mot entier (donc “antibrouillard” pour reprendre notre exemple). Et pour faciliter encore plus cette étape, la logique de cet exercice étant avant tout pédagogique, on va séparer en mots uniquement en se basant sur les espaces qui viennent tout droit de notre étape de cleaning.

Détail important aussi, on l’a évoqué rapidement plus haut, on va délimiter des phrases, afin que notre LLM prédise des phrases qui se terminent. Sinon on se retrouverait à créer un générateur qui prédit des mots sans s’arrêter. Ce sont les “.” qui vont les délimiter. Par convention, on va pour chaque phrase ajouter 2 tokens techniques : , pour le début d’une phrase, pour la fin d’une phrase. On verra qu’ils nous serviront plus tard dans la prédiction du prochain mot (et/ou de la fin de la phrase !).

sentences_tokenized = []

# Notre tokenisation étant très simple (séparation par espace), on a uniquement à utiliser un strip pour séparer les mots. Un autre split est utilisé pour séparer les phrases avec les "."
for message in messages_clean:
    for sentence in [s.strip() for s in message.split(".") if s.strip()]:
        sentences_tokenized.append(["<BOS>"] + sentence.split() + ["<EOS>"])

print(sentences_tokenized[:3])

[['<BOS>', 'honte', 'a', 'moi', "j'ai", 'pas', 'du', 'tout', 'eu', 'le', 'temps', 'de', "m'en", 'occuper', '<EOS>'], ['<BOS>', "d'accord", "c'etait", 'pour', "l'ultrabook", 'il', 'coute', 'rien', 'mais', 'je', 'sais', 'pas', 'si', "c'est", 'ouf', 'go', 'de', 'ram', '<EOS>'], ['<BOS>', 'ca', 'a', 'pas', "l'air", 'dingue', 'dingue', 'en', 'fait', '<EOS>']]

Wrap up prétraitement

Maintenant que nous avons fini avec les étapes de preprocessing, écrivons à partir de ce que l’on vient de faire une fonction utilitaire qui nous permettra d’appliquer ces traitements à du nouveau texte :

def preprocess(messages):
    cleaned_list = clean_messages(messages)

    sentences = []
    for message in cleaned_list:
        for sentence in [s.strip() for s in message.split(".") if s.strip()]:
            sentences.append(["<BOS>"] + sentence.split() + ["<EOS>"])

    return sentences

Compter les occurrences

Pour alimenter notre modèle statistique, nous devons calculer à quelle fréquence un mot apparait après une suite de mots. On arrive déjà à une première définition intéressante : de combien de mots doit être notre suite de mots ?

Si on prend un seul mot, on ne risque pas de capturer beaucoup de sens. Il n’aura quasiment aucun contexte sur la phrase. Par exemple il prédira peut-être le mot “balle” après “la”, alors que la phrase commence par “il a mangé la”. Pas idéal pour prédire des phrases qui ont un minimum de sens.

Si on choisit un contexte long - de 10 mots par exemple - on fait face à 2 contraintes. Déjà le modèle va être très lourd à calculer. Mais surtout, vu la taille du jeu de données d’entrainement qu’on lui donne, qui est assez réduite, le modèle risque d’avoir trop peu d’exemples pour une suite de mots et peut donc se retrouver à “overfitter”. L’overfit est un concept clé dans le machine learning, c’est le manque de capacité d’un modèle à généraliser. Reprenons un exemple, si la suite de mots est “il a mangé à 4h et maintenant il va se” et que l’on a un seul exemple dans notre jeu de données (mon frère qui m’aurait dit par exemple : “il a mangé à 4h et maintenant il va se coucher”). Le mot prédit sera toujours “coucher” après cette suite de mots.

Une longue fenêtre de contexte implique donc qu’il faut un grand ensemble de données pour avoir des résultats pertinents. Pour information, les LLM actuels ont des fenêtres de contexte qui peuvent monter à 1 million de tokens, voire plus. Un million de tokens, c’est à peu près la taille de l’intégrale du Seigneur des Anneaux, il y a de quoi faire donc. Mais les moyens, en termes de données d’entrainement, et de puissance de calcul, sont bien sûr d’un autre ordre que notre exemple.

Nous allons de notre côté nous arrêter sur une fenêtre de 3 mots. On va donc calculer les occurrences de mots après une séquence de jusqu’à 3 mots. L’implémentation est un peu tricky : notre fenêtre doit aller jusqu’à 3 mots, mais elle peut être plus petite. Par exemple, pour un début de phrase, nous aurons moins de 3 mots de contexte pour deviner le prochain.

Une fois les occurrences comptabilisées, on va appliquer une étape de normalisation pour avoir des probabilités.

from collections import defaultdict, Counter

# La taille MAX de la fenêtre (le n-gramme cible)
MAX_WINDOW = 4

def build_flexible_ngram_model(sentences_tokenized, max_window):
    counts = defaultdict(Counter)

    # On parcourt chaque phrase avec une fenêtre flexible
    for sentence in sentences_tokenized:
        # Pour chaque position i dans la phrase...
        for i in range(len(sentence)):
            # On définit la fin de notre fenêtre glissante
            # Elle ne doit pas dépasser max_window et ne pas sortir de la phrase actuelle
            # On cherche le mot suivant, donc on regarde jusqu'à i + max_window
            for window_size in range(1, max_window + 1):
                # Le "contexte" est la séquence de mots précédant le mot cible
                # On définit l'index du mot cible (le dernier de notre fenêtre)
                target_idx = i + window_size - 1
                
                # On vérifie qu'on ne dépasse pas la fin de la phrase actuelle
                if target_idx < len(sentence):
                    # Le contexte est ce qui précède target_idx, mais sans dépasser max_window-1
                    # On prend les mots de l'index (i) jusqu'à (target_index - 1)
                    context_start = i
                    
                    # Si le contexte est vide (cas du premier mot de la phrase), 
                    # on peut décider soit de l'ignorer, soit de marquer un contexte spécial.
                    # Ici, pour la pédagogie, on ne prend que si context_start < target_idx
                    if context_start < target_idx:
                        context = tuple(sentence[context_start:target_idx])
                        next_word = sentence[target_idx]
                        counts[context][next_word] += 1

    # Normalisation
    model = {}
    for context, next_words_counts in counts.items():
        total = sum(next_words_counts.values())
        model[context] = {word: count / total for word, count in next_words_counts.items()}
        
    return model

bro_model = build_flexible_ngram_model(sentences_tokenized, MAX_WINDOW)

Jetons un coup d’oeil rapide au dictionnaire ainsi créé :

bro_model[("il", "a", "un", )]

{'vieux': 0.3333333333333333,
 'diplome': 0.3333333333333333,
 'petit': 0.3333333333333333}

La prédiction

La prédiction du prochain mot est plus subtile qu’on peut le penser au premier abord. Il ne s’agit pas de “bêtement” prédire le mot le plus fréquent après une séquence de mots. Cela donnerait un LLM assez … plat et peu créatif. Construisons un exemple rapide pour s’en rendre compte.

def predict_next_word(text):
    # Pour construire les tokens sur lesquels on va prédire notre prochain mot, on utilise la fonction preprocess qu'on a construite plus haut. En ne prenant en compte que la dernière phrase
    # Si le texte est vide (ou ne contient aucun mot), preprocess ne renvoie aucune phrase : on part alors directement de <BOS> pour générer une phrase de bout en bout
    sentences = preprocess([text])
    tokens = sentences[-1][:-1] if sentences else ["<BOS>"]

    # Tant que l'on arrive pas à la fin de phrase, on répète la prédiction du prochain mot
    while tokens[-1] != "<EOS>":
        next_word = None

        # On utilise une boucle pour gérer les séquence qu'on ne connaitrait pas (qui ne serait jamais apparues dans notre jeu d'entrainement). Si la séquence en cours n'a jamais été vue, alors on la réduit (on enlève des mots) pour augmenter nos chance de récupérer des probas
        for window_size in range(min(MAX_WINDOW - 1, len(tokens)), 0, -1):
            context = tuple(tokens[-window_size:])
            if context in bro_model:
                next_word = max(bro_model[context], key=bro_model[context].get)
                break
        
        # Si même en réduisant le contexte, on tombe sur un mot qui n'a jamais été vu, alors on prend le mot le plus fréquemment cité en début de phrase (callback assez rustique on en conviendra...)
        if next_word is None:
            next_word = max(bro_model[("<BOS>",)], key=bro_model[("<BOS>",)].get)

        tokens.append(next_word)

    return " ".join(t for t in tokens if t not in ("<BOS>", "<EOS>"))

Faisons maintenant quelques tests :

import textwrap

# Fonction utilitaire dont le but est d'afficher l'input et l'output du modèle
def print_results(pairs):
    blocks = []

    for input_text, result in pairs:
        input_block = textwrap.fill(input_text, initial_indent="Input : ", subsequent_indent=" " * 8)
        output_block = textwrap.fill(result, initial_indent="Output: ", subsequent_indent=" " * 8)
        blocks.append(input_block + "\n" + output_block)

    print("\n\n".join(blocks))

print_results([
    ("elle", predict_next_word("elle")),
    ("elle est", predict_next_word("elle est")),
    ("elle est trop", predict_next_word("elle est trop")),
])

Input : elle
Output: elle est trop belle

Input : elle est
Output: elle est trop belle

Input : elle est trop
Output: elle est trop belle

On conviendra qu’on a déjà vu plus créatif comme LLM.

C’est que les LLM sont construits sur une approche probabiliste, et non déterministique comme le modèle que l’on vient de créer. Cela leur permet d’avoir un ton plus naturel, plus humain, mais aussi d’être plus “créatif”. L’inconvénient évident, c’est que pour un même prompt, un LLM retournera des réponses différentes. Pire, c’est ce qui peut générer les fameuses hallucinations dont on a beaucoup parlé : le LLM ne répète pas méthodiquement ce sur quoi il a été entrainé, il peut dévier et générer des incohérences liées à sa nature aléatoire.

La plupart des LLM permettent de contrôler cette partie “stochastique” - mot compliqué pour dire basé sur une nature aléatoire - via leur API à travers deux paramètres :

• la température, qui permet d’influer sur la probabilité de choisir un mot moins fréquent
• le “top k”, qui permet de déterminer quels sont les k mots les plus fréquents sur lesquels le LLM pourra piocher.

Encore une fois, pour rester simple, on va se concentrer sur un seul concept, le top k. L’idée derrière ce paramètre est de limiter le choix du modèle aux k mots les plus fréquents pour sa prédiction. Par exemple les 5 mots les plus fréquents. Cela évite au modèle de possiblement prédire un mot très rare après une séquence, qui pourrait l’amener à une phrase sans queue ni tête.

Mettons en place ce top k dans notre fonction, en prenant le top 5.

import random

random.seed(0)

def predict_next_word_top_k(text, k=5):
    # On preprocess le texte en utilisant la fonction que l'on avait définie
    sentences = preprocess([text])
    tokens = sentences[-1][:-1] if sentences else ["<BOS>"]

    # Fonction qui permet de normaliser les probabilités récupérées des top k mots les plus fréquents
    def sample_top_k(distribution, k):
        top_words = sorted(distribution.items(), key=lambda x: x[1], reverse=True)[:k]
        words, probs = zip(*top_words)
        total = sum(probs)
        renormalized_probs = [p / total for p in probs]
        return random.choices(words, weights=renormalized_probs, k=1)[0]

    # Tant que l'on arrive pas sur le token <EOS>, on continue de générer des mots
    while tokens[-1] != "<EOS>":
        next_word = None

        # On utilise la fenêtre de contexte (window_size) : si on ne trouve pas d'entrée dans le modèle, on raccourcit celle-ci en retirant un mot
        for window_size in range(min(MAX_WINDOW - 1, len(tokens)), 0, -1):
            context = tuple(tokens[-window_size:])
            if context in bro_model:
                next_word = sample_top_k(bro_model[context], k)
                break
        
        # Si malgré la réduction de la fenêtre de contexte on ne trouve toujours pas d'entrée dans le modèle, alors on prend le mot le plus fréquent utilisé en début de phrase (après <BOS>)
        if next_word is None:
            next_word = sample_top_k(bro_model[("<BOS>",)], k)

        tokens.append(next_word)

    return " ".join(t for t in tokens if t not in ("<BOS>", "<EOS>"))

print_results([
    ("elle", predict_next_word_top_k("elle")),
    ("elle", predict_next_word_top_k("elle")),
    ("elle", predict_next_word_top_k("elle")),
])

Input : elle
Output: elle etait tres contente

Input : elle
Output: elle a l'air bien cool

Input : elle
Output: elle a toujours un qui vomi apres

On voit que les sorties sont beaucoup plus créatives et moins fermées que notre modèle déterministique. Les phrases ont l’air naturelles, même si elles n’ont pas beaucoup de sens (mention spéciale pour la 3e, particulièrement longue).

Essayons quelques exemples de phrases créées de bout en bout :

random.seed(0)
print_results([
    ("", predict_next_word_top_k("")),
    ("", predict_next_word_top_k("")),
    ("", predict_next_word_top_k("")),
])

Output: ca a l'air trop bien


Output: ca va mon bro en tout cas on est trop soulage c'est alle super
        vite


Output: trop fort

Encore une fois, on retrouve bien le ton court et naturel des conversations de messagerie instantanée.

A la recherche d’une identité visuelle

Alors que j’écrivais le premier billet de ce blog, je me suis dit qu’il me fallait des images pour illustrer le contenu et rendre la lecture plus agréable. Comme nous sommes à l’ère de l’IA générative, plus besoin de passer des heures sur Pixabay (ou autre site d’images libres de droit) à la recherche de l’image parfaite : ces nouveaux modèles permettent de créer des images photoréalistes sur commande (ou plutôt sur “prompt”). Dans mon cas, ce qui m’intéressait particulièrement était de pouvoir créer une identité visuelle, en gardant une constance / cohérence dans les illustrations de mon blog.

Pour changer des éternelles images sur l’IA type science fiction avec des faisceaux de lumières sur fond noir, j’ai voulu prendre le contre pied et partir sur un thème léger et original. Je suis un grand fan (et collectionneur) de comics strips : ces petites histoires comiques qui se développent sur quelques cases dans les journaux papiers, comme Calvin & Hobbes, Snoopy, Pearls Before Swine… Mon idée est donc d’apporter ce type de visuel très croquis / cartoon pour ce blog. En le pilotant donc à l’aide des prompts que j’utiliserai pour développer ces images.

L’état de l’art… à l’heure d’aujourd’hui

Je n’avais pas suivi de très près l’évolution des modèles de génération d’image, mais je sais que ChatGPT d’OpenAI a fait beaucoup parler de lui, notamment avec sa capacité à produire des images “à la Ghibli” (avec les problèmes de copyright que cela a posé). Et Nano Banana de Google s’est aussi distingué ces derniers temps, les 2 entreprises se partagent le podium de la génération d’image sur LLM Stats.

Mais ce n’est pas la direction que je souhaitais prendre : je n’aime pas être contraint par des solutions propriétaires dont l’évolution rapide (prix, fin de produit, etc.), peut m’amener à changer de solution tous les 4 matins. Le décomissionnement récent de Sora (toujours de OpenAI) en est un bon rappel.

Il reste donc les solutions open source, heureusement fort nombreuses et de qualité. Il y a déjà la famille des Stable Diffusion qui a été aux prémices de la génération d’image par IA dans le domaine du libre, et dont le modèle XL est toujours en tête des téléchargements sur Hugging Face. Mais c’est surtout la famille des modèles Flux de Black Forest Labs qui fait école aujourd’hui, avec des images générées de qualité vraiment impressionnante. Mais, comme pour les solutions propriétaires, le paysage évolue très vite et des challengers apparaissent tous les jours : Z Image, Qwen Image, … Comme pour les LLM de génération de texte, beaucoup de ces nouveaux modèles viennent de Chine et ont une approche plus sobre en termes de configuration requise.

Les constantes

Ces présentations faites, il est temps de passer aux choses sérieuses et d’écrire du code pour générer ces fameux visuels. Je le disais tout à l’heure, mon idée est d’avoir une identité visuelle inspirée des comics strips de journaux. J’ai donc écrit un prompt générique pour le style graphique, en m’aidant d’un LLM (Claude Sonnet 4.6). Le prompt est en anglais, certains modèles ne supportant que cette langue en input.

STYLE_ANCHOR = """Pen and ink illustration in the tradition of newspaper comic strips.
Style evokes Bill Watterson's Calvin and Hobbes: expressive brushwork,
confident ink linework, light crosshatching for shadows, generous
whitespace, and occasional sparse watercolor-like tints — never flat fills.

Background: off-white paper texture, warm and slightly aged.
Palette: near-monochrome ink with at most 2 restrained accent colors,
applied sparingly as washes rather than fills.
No gradients, no digital effects, no screen tones, no halftone dots.
No embedded text, no speech bubbles, no captions.

Characters when present: anthropomorphic animals rendered with
expressive body language and clear silhouettes. Postures tell the story
without words — curiosity, concentration, mild exasperation, wonder.
Line quality varies: thick confident outlines, thin detail lines inside.

Objects and settings: simplified but recognizable, drawn with the economy
of a skilled cartoonist. Machinery looks mechanical and slightly whimsical.
Negative space is used deliberately — the white of the paper is part of the composition.

Mood: warm, slightly wry, intellectually playful. The kind of illustration
that makes a technical concept feel approachable and human."""

Enfin, définissons une “scène” qui sera rajoutée au prompt, et qui sera différente pour tous les visuels à créer. Je vais générer ici un visuel pour… ce même article (que c’est méta !). Partons sur un renard dessinant sur une table de dessinateur.

SCENE = """
fox artist working at a large professional drafting table, slanted drawing board, sketching with precision, studio setting
"""

Finissons enfin par quelques constantes : le seed (pour la reproducibilité), le nombre d’images à générer et leurs dimensions.

SEED = 42
N_IMAGES = 2
WIDTH = 1024
HEIGHT = 576 # this generates a 16:9 ratio. ideal for header image

Hugging Face spaces

Hugging Face propose des spaces qui exposent des modèles d’IA gratuitement : LLM, génération d’image, OCR, etc. Ils sont disponibles directement sans même s’enregistrer sur le site, mais avec un quota limité tout de même. Mieux : ils sont utilisables via API (sans token !), et sont généralement bien documentés.

En utilisant leur package, c’est d’une simplicité déconcertante, par exemple avec Flux 2 Klein 9B :

from gradio_client import Client, handle_file
import shutil
from pathlib import Path

Path("outputs").mkdir(exist_ok=True)

for i in range(N_IMAGES):
    # code générant un fichier à partir du prompt. Le fichier est stocké dans un dossier temporaire stocké dans result
    client = Client("black-forest-labs/FLUX.2-klein-9B")
    result = client.predict(
        prompt=STYLE_ANCHOR + SCENE,
        mode_choice="Distilled (4 steps)", # Utilise la version distillée pour génération plus rapide
        seed=SEED + i, # on change le seed entre les 2 images (pour ne pas que ce soit les mêmes)
        width=WIDTH,
        height=HEIGHT,
        num_inference_steps=4,
        guidance_scale=1,
        prompt_upsampling=False,
        api_name="/generate"
    )

    # on déplace le fichier à l'endroit souhaité
    destination_folder = Path("./outputs/")
    new_filename = f"hf_flux2_klein_{i}.png"  
    final_path = os.path.join(destination_folder, new_filename)
    shutil.copy2(result[0], final_path)

Et voici les résultats, générés en l’espace de quelques secondes :

C’est très bon ! Bien dans la tonalité que je recherche.

Cependant le fait de dépendre d’un service cloud, qui peut lui aussi évoluer très vite, me chiffonne. Les spaces sont très pratiques mais changent rapidement, en fonction des nouveaux modèles qui arrivent, et l’offre de Hugging Face ne restera très probablement pas éternellement gratuite.

Mon idée est donc de voir pour faire tourner ces modèles en local.

En local

Petit point sur ma config avant d’aller plus loin. J’utilise un HP Zbook G5, un PC portable workstation qui est une petite bombe… de 2018. Je l’ai effectivement acheté reconditionné, et son processeur Xeon E-2186M (proche d’un Intel Core i7 de 8e génération) et sa carte Quadro P3200 avec 6 Go de VRAM ne sont pas nés de la dernière pluie.

Je l’utilise régulièrement pour mes projets ML / LLM sans problème. J’arrive à faire de l’inférence de LLM qui ont une taille de 10-15B paramètres (en version quantisée bien sûr), les modèles se chargeant partiellement en VRAM, et le reste sur ma RAM système (ce qu’on appelle offload dans le jargon). J’étais donc confiant dans la capacité de ma config à faire tourner par exemple le Flux 2 Klein 9B que l’on a vu, même lentement…

STYLE_ANCHOR_SHORT = """
pen and ink, newspaper comic strip, calvin & hobbes style,
large expressive head, simple rounded body, anthropomorphic animal character,
clean thin linework, off-white background, watercolor spot color,
no gradients, no digital effects, no text
"""

from diffusers import AutoPipelineForText2Image
import torch

pipe_t1 = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/sdxl-turbo",
    torch_dtype=torch.float32,
    variant="fp16"
)
pipe_t1.enable_attention_slicing()

for i in range(N_IMAGES):
    seed = SEED + i
    generator = torch.Generator("cpu").manual_seed(seed)

    result = pipe_t1(
        prompt=STYLE_ANCHOR_SHORT + SCENE,
        width=WIDTH,
        height=HEIGHT,
        num_inference_steps=3, # j'ai choisi de partir sur 3 étapes, les résultats étant étrangement meilleurs que ceux à 4, le maximum "pertinent" d'étapes d'après la doc officielle
        guidance_scale=0.0,
        generator=generator,
    )

    img = result.images[0]
    img.save(f"outputs/sdxl_turbo_{i}.png")

import gc

del pipe_t1
gc.collect()

from optimum.intel import OVStableDiffusionXLPipeline

pipe_t2 = OVStableDiffusionXLPipeline.from_pretrained(
    "rupeshs/SDXL-Lightning-2steps-openvino-int8",
    compile=False,
)
pipe_t2.compile()

for i in range(N_IMAGES):
    result = pipe_t2(
        prompt=STYLE_ANCHOR_SHORT + SCENE,
        width=WIDTH,
        height=HEIGHT,
        num_inference_steps=2,
        guidance_scale=0,
    ) # Note : pas de seed ici. Non supporté par OpenVINO

    img = result.images[0]
    img.save(f"outputs/sdxl_lightning_{i}.png")

del pipe_t2
gc.collect()

from optimum.intel import OVPipelineForText2Image

pipe_t3 = OVPipelineForText2Image.from_pretrained(
    "rupeshs/sana-sprint-0.6b-openvino-int4",
    ov_config={"CACHE_DIR": ""},
)

for i in range(10):
    result = pipe_t3(
        prompt=STYLE_ANCHOR + SCENE,
        width=WIDTH,
        height=HEIGHT,
        num_inference_steps=2,
        guidance_scale=4.5,
    )

    img = result.images[0]
    img.save(f"outputs/sana_sprint_{i}.png")

del pipe_t3
gc.collect()