Génération d'images par IA : Stable Diffusion, DALL-E, Midjourney

“Un chat astronaute sur Mars au coucher du soleil, style huile sur toile”

Il y a 5 ans, créer cette image aurait nécessité des heures de travail pour un illustrateur professionnel. Aujourd’hui, un modèle d’IA génère cette image en quelques secondes à partir de cette simple phrase.

La génération d’images par IA (text-to-image) est l’une des applications les plus spectaculaires de l’intelligence artificielle moderne. Ces modèles ont révolutionné la création visuelle en permettant à quiconque de produire des images de qualité professionnelle sans compétences en dessin ou design.

Révolution créative

Impact sur les industries

• Design : Prototypage rapide de concepts visuels
• Marketing : Génération de visuels publicitaires sur mesure
• Jeux vidéo : Création d’assets (textures, personnages, décors)
• Illustration : Books, magazines, sites web
• Mode : Designs de vêtements, patterns
• Architecture : Visualisation de projets

Chiffres clés (2024)

• 500+ millions d’images générées par IA par jour
• 70% des designers utilisent l’IA comme outil de prototypage
• Marché évalué à $2 milliards en 2024, projeté à $20B en 2030

Évolution historique

Timeline :

• 2015 : DeepDream (Google) - premières expérimentations artistiques
• 2021 : DALL-E 1 (OpenAI) - 400M paramètres, qualité limitée
• 2022 :
  • Stable Diffusion (Stability AI) - Open source !
  • DALL-E 2 - Saut qualitatif majeur
  • Midjourney v3 - Esthétique artistique
• 2023 :
  • DALL-E 3 - Intégration ChatGPT, précision prompts
  • Midjourney v5/v6 - Photoréalisme
  • Stable Diffusion XL - 1024×1024 natif
• 2024 :
  • Flux (Black Forest Labs) - Nouveaux state-of-art
  • Imagen 3 (Google) - Réalisme photographique ($0.03/image)
  • Stable Diffusion 3.5 - Trois variantes (Large, Turbo, Medium)
  • Ideogram - Excellence typographie
• 2025 :
  • Midjourney v7 - Voice-to-image, personnalisation poussée
  • Flux 1.1 Pro Ultra - 4MP résolution, vitesse optimale
  • Flux.2 - Multi-reference conditioning, génération + édition
  • Imagen 4 - En préparation (Google)
  • GPT-image-1 - Enhanced DALL-E avec meilleur rendu texte

Comment fonctionnent les modèles de diffusion

La plupart des modèles actuels (Stable Diffusion, DALL-E, Imagen) utilisent l’architecture de diffusion.

Principe de la diffusion

Analogie : Imaginez une sculpture de glace fondant progressivement jusqu’à devenir une flaque d’eau (ajout de bruit). Le modèle apprend à inverser ce processus : partir de bruit aléatoire et progressivement révéler une image cohérente.

Processus en 3 phases :

Forward diffusion (entraînement)

Ajouter du bruit gaussien à une vraie image en N étapes jusqu’à obtenir du bruit pur

Image originale → +bruit → +bruit → ... → Bruit pur

Reverse diffusion (génération)

Apprendre à enlever le bruit étape par étape

Bruit pur → -bruit → -bruit → ... → Image générée

Conditioning (guidage)

Guider le processus avec un prompt textuel

Bruit pur + "chat astronaute" → Débruitage guidé → Chat astronaute

Architecture technique

# Architecture simplifiée conceptuelle
class DiffusionModel:
    def __init__(self):
        # Encodeur de texte (CLIP)
        self.text_encoder = CLIPTextEncoder()

        # U-Net : Réseau de débruitage
        self.unet = UNet(
            in_channels=4,  # Latent space
            out_channels=4,
            attention_resolutions=[8, 4, 2],
            num_res_blocks=2
        )

        # VAE : Compression/décompression images
        self.vae = VariationalAutoencoder()

        # Scheduler : Gestion du processus de diffusion
        self.scheduler = DDPMScheduler(
            num_train_timesteps=1000,
            beta_schedule="linear"
        )

    def encode_prompt(self, prompt):
        """Convertir prompt en embedding"""
        tokens = self.tokenizer(prompt)
        embedding = self.text_encoder(tokens)  # Shape: [1, 77, 768]
        return embedding

    def generate(self, prompt, num_steps=50):
        """Générer image depuis prompt"""
        # 1. Encoder le prompt
        text_embedding = self.encode_prompt(prompt)

        # 2. Initialiser bruit aléatoire dans l'espace latent
        latents = torch.randn(1, 4, 64, 64)  # 64x64 latent = 512x512 image

        # 3. Débruitage itératif
        for t in range(num_steps):
            # Prédire le bruit à enlever
            noise_pred = self.unet(
                latents,
                timestep=t,
                encoder_hidden_states=text_embedding  # Guidage textuel
            )

            # Mettre à jour latents (enlever bruit prédit)
            latents = self.scheduler.step(noise_pred, t, latents).prev_sample

        # 4. Décoder latents → image RGB
        image = self.vae.decode(latents)
        return image

Rôle de CLIP

CLIP (Contrastive Language-Image Pre-training) est crucial : il crée le pont entre texte et image.

Entraînement CLIP :

• Dataset : 400M paires (image, description)
• Objectif : Rapprocher embeddings d’images et textes correspondants
• Résultat : Espace unifié où “chat” (texte) est proche d’images de chats

import torch
from transformers import CLIPProcessor, CLIPModel
from PIL import Image

# Charger CLIP
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

# Calculer similarité texte-image
image = Image.open("cat.jpg")
texts = ["a cat", "a dog", "a car"]

inputs = processor(text=texts, images=image, return_tensors="pt", padding=True)
outputs = model(**inputs)

# Similarités
logits_per_image = outputs.logits_per_image  # Shape: [1, 3]
probs = logits_per_image.softmax(dim=1)  # Probabilités

print("Similarités :")
for text, prob in zip(texts, probs[0]):
    print(f"  {text}: {prob.item():.2%}")

# Sortie :
#   a cat: 94.5%
#   a dog: 4.8%
#   a car: 0.7%

Ce mécanisme permet au modèle de diffusion de “savoir” à quoi doit ressembler l’image finale pendant le débruitage.

DALL-E 3 (OpenAI)

DALL-E 3 est le modèle d’OpenAI, intégré nativement à ChatGPT. Il excelle en précision et compréhension de prompts complexes.

Caractéristiques

Points forts :

• Précision : Respecte fidèlement les prompts, même complexes
• Texte dans images : Génère correctement du texte (ex: logos, enseignes)
• Intégration ChatGPT : Génération conversationnelle
• Sécurité : Filtres stricts contre contenu inapproprié
• Cohérence : Styles et détails cohérents

Limites :

• Coût : $0.040-0.120 par image selon résolution
• Personnalisation : Pas de fine-tuning ni LoRA
• Contrôle limité : Paramètres fixes (pas de guidance_scale, steps, etc.)
• Watermark : Images marquées (small C2PA metadata)

Utilisation via API

from openai import OpenAI
import base64
from pathlib import Path

client = OpenAI(api_key="your-api-key")

# Génération d'image
response = client.images.generate(
    model="dall-e-3",
    prompt="A serene Japanese garden with a koi pond, cherry blossoms falling, golden hour lighting, photorealistic, highly detailed",
    size="1024x1024",  # Options: 1024x1024, 1792x1024, 1024x1792
    quality="hd",  # "standard" ou "hd" (2x plus cher)
    n=1  # DALL-E 3 : toujours 1 image
)

image_url = response.data[0].url
print(f"Image générée : {image_url}")

# Télécharger l'image
import requests
img_data = requests.get(image_url).content
with open('generated_garden.png', 'wb') as f:
    f.write(img_data)

Génération via ChatGPT

L’intégration ChatGPT est l’atout majeur : vous pouvez itérer conversationnellement.

Exemple de conversation :

User: Crée-moi une affiche de concert de jazz vintage

ChatGPT: [Génère image] Voici une affiche vintage avec...

User: C'est bien mais j'aimerais plus de couleurs chaudes et un saxophone plus visible

ChatGPT: [Génère version modifiée] J'ai ajouté des tons orangés et mis le saxophone au premier plan...

User: Parfait ! Maintenant ajoute "Blue Note Café" comme titre

ChatGPT: [Génère version finale avec texte]

Cette approche itérative est beaucoup plus intuitive que de peaufiner un prompt technique complexe.

Prompt enhancement automatique

DALL-E 3 réécrit automatiquement vos prompts via GPT-4 pour améliorer les résultats.

Exemple :

• Votre prompt : “A cat”
• Prompt réel utilisé : “A fluffy orange tabby cat with green eyes, sitting on a windowsill, soft natural lighting, high detail, warm color palette”

Ce système est puissant mais enlève du contrôle précis aux utilisateurs avancés.

Cas d’usage professionnels

Publicité et marketing

def generate_ad_visuals(product_name, target_audience, style):
    """Générer variantes de visuels publicitaires"""
    prompt = f"""Professional advertisement photography for {product_name}.
    Target audience: {target_audience}.
    Style: {style}, high-end, commercial quality.
    Include: Product prominently displayed, lifestyle context, appealing composition.
    No text or watermarks."""

    variations = []
    for i in range(3):
        response = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size="1792x1024",  # Format paysage pour pub
            quality="hd"
        )
        variations.append(response.data[0].url)

    return variations

# Utilisation
visuals = generate_ad_visuals(
    product_name="luxury smartwatch",
    target_audience="young professionals 25-35",
    style="minimalist, modern, sleek"
)

for i, url in enumerate(visuals):
    print(f"Variante {i+1}: {url}")

Illustration de contenu

def illustrate_blog_post(article_title, article_summary):
    """Générer illustration pour article de blog"""
    prompt = f"""Blog post header illustration for: "{article_title}"

    Context: {article_summary}

    Requirements:
    - Conceptual and metaphorical (not literal)
    - Modern flat illustration style
    - Vibrant colors
    - Clear composition suitable for 1200x630px header
    - Professional and engaging"""

    response = client.images.generate(
        model="dall-e-3",
        prompt=prompt,
        size="1792x1024",
        quality="standard"  # Standard suffisant pour web
    )

    return response.data[0].url

# Exemple
illustration = illustrate_blog_post(
    article_title="The Future of Remote Work",
    article_summary="Exploring how AI tools are reshaping distributed teams and productivity"
)

Coûts

Budget typique : Pour 100 images HD haute résolution = $12

Stable Diffusion (Stability AI)

Stable Diffusion est le modèle open source qui a démocratisé la génération d’images. Téléchargeable gratuitement, personnalisable, et exécutable localement.

Versions

• SD 1.5 (2022) : 512×512, très populaire, modèle de base pour fine-tuning
• SD 2.1 (2022) : 768×768, nouvel encodeur, moins de fine-tunes compatibles
• SDXL (2023) : 1024×1024 natif, qualité significativement meilleure
• SD 3 (2024) : Architecture transformer, qualité encore supérieure
• SD 3.5 🆕 (2024) : Trois variantes optimisées
  • SD 3.5 Large : 8.1B paramètres, qualité maximale
  • SD 3.5 Large Turbo : Génération en 4 steps, ultra-rapide
  • SD 3.5 Medium : 2.5B paramètres, optimisé hardware consumer

Installation locale

Requirements :

• GPU NVIDIA avec 8GB+ VRAM (4GB possible avec optimisations)
• Python 3.10+
• ~10GB espace disque par modèle

# Installation
pip install diffusers transformers accelerate safetensors

# Télécharger modèle (nécessite compte Hugging Face)
huggingface-cli login

Code de génération basique :

import torch
from diffusers import StableDiffusionPipeline

# Charger le modèle SDXL
model_id = "stabilityai/stable-diffusion-xl-base-1.0"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,  # Utiliser FP16 pour économiser VRAM
    variant="fp16"
)
pipe.to("cuda")  # GPU

# Générer une image
prompt = "A majestic dragon flying over a medieval castle at sunset, fantasy art, highly detailed, dramatic lighting"
negative_prompt = "blurry, low quality, distorted, ugly, bad anatomy"

image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=50,  # Plus = meilleure qualité, plus lent
    guidance_scale=7.5,  # 7-9 optimal (respect du prompt)
    width=1024,
    height=1024
).images[0]

image.save("dragon_castle.png")

Paramètres avancés

Guidance scale :

• Valeur : 1-20 (typique : 7-9)
• Effet : Contrôle à quel point le modèle suit le prompt
  • Bas (3-5) : Plus créatif, peut dévier
  • Moyen (7-9) : Équilibre optimal
  • Haut (12-20) : Suit strictement, peut sur-saturer

# Comparaison guidance scales
for scale in [3, 7, 12]:
    image = pipe(
        prompt="a red apple",
        guidance_scale=scale,
        num_inference_steps=30
    ).images[0]
    image.save(f"apple_scale{scale}.png")

Nombre de steps :

• 20-30 : Rapide, qualité correcte
• 50-75 : Qualité standard recommandée
• 100+ : Diminishing returns, utiliser pour affinement final

Negative prompt : Crucial pour éviter défauts courants.

# Negative prompt efficace pour portraits
negative_prompt = """
blurry, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated,
extra fingers, mutated hands, poorly drawn hands, poorly drawn face,
mutation, deformed, bad anatomy, bad proportions, extra limbs,
cloned face, disfigured, gross proportions, malformed limbs,
missing arms, missing legs, extra arms, extra legs, fused fingers,
too many fingers, long neck, watermark, signature, text, logo
"""

Samplers (Schedulers)

Le sampler contrôle comment le bruit est enlevé. Chacun a ses caractéristiques.

from diffusers import (
    EulerAncestralDiscreteScheduler,
    DPMSolverMultistepScheduler,
    DDIMScheduler
)

# Comparaison samplers
samplers = {
    "Euler a": EulerAncestralDiscreteScheduler,
    "DPM++ 2M": DPMSolverMultistepScheduler,
    "DDIM": DDIMScheduler
}

for name, scheduler_class in samplers.items():
    pipe.scheduler = scheduler_class.from_config(pipe.scheduler.config)

    image = pipe(
        prompt="portrait of a woman",
        num_inference_steps=30
    ).images[0]

    image.save(f"portrait_{name}.png")

Recommandations :

• Euler a : Bon général, créatif
• DPM++ 2M Karras : Qualité/vitesse optimal
• DDIM : Déterministe (même seed = même image)

Seed control

Le seed permet la reproductibilité.

# Même prompt, même seed = même image
generator = torch.Generator("cuda").manual_seed(42)

image = pipe(
    prompt="a cute puppy",
    generator=generator,
    num_inference_steps=50
).images[0]

# Re-générer avec même seed
generator = torch.Generator("cuda").manual_seed(42)
image2 = pipe(
    prompt="a cute puppy",
    generator=generator,
    num_inference_steps=50
).images[0]

# image == image2 (identiques pixel par pixel)

Usage : Parfait pour itérer sur un prompt en gardant la composition.

# Garder composition, modifier details
seed = 123456
base_prompt = "a forest landscape"

for variation in ["at sunrise", "in winter", "with a river", "misty atmosphere"]:
    generator = torch.Generator("cuda").manual_seed(seed)
    full_prompt = f"{base_prompt} {variation}"

    image = pipe(
        prompt=full_prompt,
        generator=generator,
        num_inference_steps=50
    ).images[0]

    image.save(f"forest_{variation}.png")

Avantages open source

1. Gratuit : Aucun coût API

2. Local : Données privées, pas d’envoi sur serveurs externes

3. Personnalisable : Fine-tuning, LoRAs, embeddings

4. Contrôle total : Tous les paramètres accessibles

5. Communauté : 100,000+ modèles custom sur Civitai, Hugging Face

# Utiliser un modèle custom de la communauté
from diffusers import DiffusionPipeline

# Modèle spécialisé "Realistic Vision" (photoréalisme)
pipe = DiffusionPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Résultat : Meilleur photoréalisme que SDXL de base
image = pipe(
    prompt="professional photo of a young woman, natural lighting, 85mm lens, bokeh",
    negative_prompt="cartoon, painting, illustration, 3d render"
).images[0]

Midjourney

Midjourney est le champion de l’esthétique artistique. Pas d’API publique, uniquement via Discord.

Nouveauté : Midjourney v7 (Avril 2025)

Nouvelles fonctionnalités v7 :

• 🎙️ Voice-to-image : Créez des images par la voix, sans taper de prompt
• 🎨 Personnalisation : Le modèle s’adapte à votre style après avoir noté ~200 images
• ⚡ Turbo Mode : Génération ultra-rapide avec contrôle speed/cost
• 🎯 Meilleure compréhension : Prompts mieux interprétés, plus proche de votre vision

Caractéristiques

Points forts :

• ✅ Esthétique : Résultats visuellement époustouflants par défaut
• ✅ Cohérence artistique : Style, couleurs, composition exceptionnels
• ✅ Facilité : Prompts simples donnent de bons résultats
• ✅ Variations : Générer variations d’une image facilement
• ✅ Voice-to-image 🆕 : Création par commande vocale (v7)

Limites :

• ❌ Pas d’API : Uniquement Discord (limite l’automatisation)
• ❌ Coût : $10-120/mois selon abonnement
• ❌ v7 plus cher 🆕 : 2x le coût GPU de v6 (moitié moins d’images générées)
• ❌ Précision : Moins fidèle aux prompts détaillés que DALL-E 3
• ❌ Propriété intellectuelle : Droits commerciaux selon plan

Utilisation (Discord)

Commandes de base :

/imagine prompt: A cyberpunk cityscape at night, neon lights, rain, blade runner style --ar 16:9 --v 7

Paramètres Midjourney :

• --ar X:Y : Aspect ratio (16:9, 4:3, 1:1, etc.)
• --v 7 : Version du modèle 🆕 (7 = dernière, avril 2025)
• --v 6 : Version précédente (plus économique, 2x moins cher)
• --style raw : Style moins “artistique”, plus réaliste
• --stylize 0-1000 : Niveau de stylisation (défaut : 100)
• --chaos 0-100 : Variabilité (0 = cohérent, 100 = chaotique)
• --seed XXX : Reproductibilité
• --turbo 🆕 : Mode génération rapide (v7)

Workflow typique :

1. /imagine avec prompt initial
2. Choisir image préférée parmi 4 générées
3. Cliquer “U1-U4” pour upscale (haute résolution)
4. Cliquer “V1-V4” pour générer variations
5. Utiliser “Vary (Subtle)” ou “Vary (Strong)” pour ajuster

Prompt engineering Midjourney

Structure optimale :

[Sujet principal] [Description détaillée] [Style/Artiste] [Paramètres techniques] --parametres

Exemples :

Portrait artistique :

/imagine prompt: Portrait of an elderly fisherman, weathered face, intense blue eyes, salt and pepper beard, wearing yellow raincoat, dramatic side lighting, oil painting style, thick brushstrokes, impressionist, by John Singer Sargent --ar 2:3 --v 6 --stylize 250

Paysage fantastique :

/imagine prompt: Floating islands in the sky, waterfalls cascading into clouds, bioluminescent plants, twin moons, ethereal atmosphere, matte painting, concept art, by Hayao Miyazaki and Simon Stålenhag --ar 21:9 --v 6

Architecture moderne :

/imagine prompt: Minimalist concrete house, floor-to-ceiling windows, surrounded by pine forest, foggy morning, architectural photography, shot on medium format camera, Tadao Ando style --ar 16:9 --style raw --v 6

Références de style

Midjourney excelle avec des références artistiques.

Mouvements artistiques :

• Art nouveau, Baroque, Cyberpunk, Dieselpunk, Steampunk
• Impressionnisme, Surréalisme, Art déco, Bauhaus, Brutalism

Artistes :

• Photographes : Annie Leibovitz, Steve McCurry, Ansel Adams
• Peintres : Van Gogh, Monet, Dalí, Klimt, Hokusai
• Concept artists : Syd Mead, Ralph McQuarrie, Feng Zhu

Techniques :

• Oil painting, watercolor, charcoal sketch, ink drawing
• 3D render, clay model, papercraft, isometric
• Long exposure, tilt-shift, bokeh, golden hour

/imagine prompt: A steampunk airship, brass and copper details, intricate gears, Victorian era aesthetic, by Syd Mead and H.R. Giger, cinematic lighting, octane render --ar 16:9 --v 6

Cas d’usage

Design de produits :

/imagine prompt: Ergonomic wireless headphones, matte black finish, rose gold accents, product photography, clean white background, studio lighting, commercial photography --ar 1:1 --style raw --v 6

Book covers :

/imagine prompt: Fantasy book cover, ancient tree with glowing runes, mysterious hooded figure, magical atmosphere, title space at top, by Donato Giancola --ar 2:3 --v 6 --stylize 500

Character design :

/imagine prompt: Character concept art, female warrior, ornate armor with tribal patterns, dual swords, confident pose, full body, white background, by Artgerm and WLOP --ar 2:3 --v 6

Flux (Black Forest Labs)

Flux est la nouvelle génération de modèles développée par Black Forest Labs (anciens membres de Stability AI). Excellence en qualité, vitesse et contrôle.

Flux 1.1 Pro Ultra 🆕

Flux 1.1 Pro Ultra génère des images jusqu’à 4 mégapixels (2K) avec une vitesse exceptionnelle.

Caractéristiques :

• Résolution : 4MP (2048x2048 et ratios variés)
• Modes :
  • Ultra Mode : Composition et précision optimales
  • Raw Mode : Textures naturelles, style photo candide
• Vitesse : Génération ultra-rapide sans compromis qualité
• Photoréalisme : Contrôle amélioré et rendu réaliste

# Exemple utilisation Flux 1.1 Pro Ultra via API
import replicate

output = replicate.run(
    "black-forest-labs/flux-1.1-pro-ultra",
    input={
        "prompt": "Professional portrait photography, natural lighting, 85mm lens",
        "aspect_ratio": "16:9",
        "output_format": "png",
        "safety_tolerance": 2,
        "image_prompt_strength": 0.1
    }
)

Flux.2 Family 🆕

Flux.2 introduit la génération + édition unifiée avec multi-reference conditioning.

Trois variantes :

• Flux.2 Pro : Performance maximale, latence minimale, fidélité visuelle top
• Flux.2 Flex : Paramètres exposés (sampling steps, guidance scale) pour tuning
• Flux.2 Dev : 32B paramètres, open-weight, génération + édition dans un seul modèle

Nouveautés :

• Multi-reference : Cohérence sur 10+ images de référence
• Character consistency : Personnages cohérents across multiple générations
• Layout adherence : Respect strict de la composition
• 4MP native : Génération et édition haute résolution

# Flux.2 avec multi-reference
output = replicate.run(
    "black-forest-labs/flux-2-pro",
    input={
        "prompt": "Same character in different poses",
        "reference_images": [ref1, ref2, ref3],  # Jusqu'à 10 références
        "aspect_ratio": "1:1",
        "output_quality": 100
    }
)

Avantages :

• ✅ Qualité state-of-art : Rivalise avec les meilleurs modèles fermés
• ✅ Vitesse : Génération très rapide, surtout en mode Ultra
• ✅ Flexibilité : Open-weight (Flux.2 Dev) pour personnalisation
• ✅ Multi-modal : Génération + édition unifiée

Limites :

• ❌ API seulement : Pas de version locale facile (sauf Dev)
• ❌ Coût : Premium pricing vs alternatives open source
• ❌ Adoption récente : Moins de ressources communautaires que SD

Imagen 3 & 4 (Google)

Imagen 3 est le modèle de génération d’images de Google, intégré dans Gemini API et ImageFX.

Imagen 3 (Août 2024)

Points forts :

• ✅ Photoréalisme : Images ultra-réalistes, meilleure qualité que versions précédentes
• ✅ Rendu texte : Excellent pour typographie et texte dans images
• ✅ Prix : $0.03 par image via Gemini API (très compétitif)
• ✅ Ratios variés : 9:16, 3:4, 1:1, 4:3, 16:9
• ✅ SynthID watermark : Tatouage numérique invisible pour traçabilité

import google.generativeai as genai

genai.configure(api_key="your-api-key")

# Générer image avec Imagen 3
model = genai.GenerativeModel('imagen-3')

response = model.generate_images(
    prompt="A serene mountain landscape at golden hour, photorealistic",
    number_of_images=1,
    aspect_ratio="16:9"
)

response.images[0].save("landscape.png")

Styles supportés :

• Photoréalisme, paysages impressionnistes
• Compositions abstraites, personnages anime
• Architecture, produits, portraits
• Excellence en variété stylistique

Imagen 4 🆕 (En préparation)

Google prépare Imagen 4 avec de nouvelles fonctionnalités de privacy, safety et security.

Attentes :

• Amélioration qualité et précision
• Meilleure sécurité et filtres de contenu
• Potentiellement nouvelles features multimodales

Prompt Engineering pour Images

Le prompt engineering visuel est un art en soi. Un bon prompt fait la différence entre un résultat moyen et exceptionnel.

Anatomie d’un prompt efficace

[Type de média] + [Sujet] + [Détails] + [Style] + [Éclairage] + [Couleurs] + [Composition] + [Qualité] + [Artiste/Référence]

Exemple décomposé :

Professional portrait photography (Type)
of a female CEO (Sujet)
in her 40s, confident expression, wearing elegant black blazer (Détails)
corporate headshot style (Style)
natural window lighting from the side (Éclairage)
muted color palette, grey background (Couleurs)
rule of thirds composition, shallow depth of field (Composition)
high resolution, sharp focus, detailed (Qualité)
shot by Annie Leibovitz (Artiste)

Mots-clés puissants

Qualité :

• highly detailed, 8k, sharp focus, crisp
• professional, award-winning, masterpiece
• intricate details, photorealistic

Éclairage :

• golden hour, soft lighting, dramatic lighting
• rim light, volumetric lighting, studio lighting
• cinematic lighting, natural light, backlighting

Composition :

• rule of thirds, centered composition, symmetrical
• wide angle, telephoto, macro shot
• bird's eye view, low angle, dutch angle

Style artistique :

• digital art, oil painting, watercolor, pencil sketch
• concept art, matte painting, anime style
• pixel art, low poly, vaporwave

Techniques avancées

Poids de mots (Stable Diffusion)

# Emphase avec parenthèses (augmente importance)
prompt = "(beautiful:1.5) woman, (red dress:1.3), cityscape"
# "beautiful" a un poids de 1.5x
# "red dress" a un poids de 1.3x

# Réduire importance avec crochets
prompt = "landscape, [people], mountains"
# "people" sera moins visible

Prompt blending

# Mélanger deux concepts
prompt = "A hybrid of [lion:0.7] and [eagle:0.3], majestic, fantasy creature"
# 70% lion, 30% eagle

Negative prompts stratégiques

# Pour portraits photoréalistes
negative = "cartoon, anime, painting, illustration, 3d, render, drawing, sketch"

# Pour éviter artefacts
negative += ", blurry, grainy, low resolution, distorted, deformed, duplicate"

# Pour compositions clean
negative += ", text, watermark, signature, logo, border, frame"

Prompts multi-étapes (compositing)

# Étape 1 : Générer fond
bg_image = pipe(
    prompt="Empty medieval tavern interior, wooden tables, fireplace, warm lighting"
).images[0]

# Étape 2 : Générer personnage avec fond
from diffusers import StableDiffusionImg2ImgPipeline

img2img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(...)

final_image = img2img_pipe(
    prompt="Dwarf merchant counting gold coins, sitting at table, detailed character",
    image=bg_image,
    strength=0.6  # 60% modification du fond
).images[0]

Templates de prompts par catégorie

Portrait professionnel :

Professional headshot of [person description], [age], [expression],
wearing [clothing], [lighting] lighting, [background] background,
shot with [camera] camera, [lens]mm lens, f/2.8, bokeh,
high resolution, studio quality

Paysage :

[Type of landscape] during [time of day], [weather conditions],
[style] style, [composition], [camera settings],
highly detailed, professional photography, by [photographer]

Illustration enfant :

Children's book illustration of [subject], [action],
cute and friendly, [color palette], simple shapes,
flat color, vector art style, by [illustrator]

Concept art jeu vidéo :

Game concept art, [environment/character], [game genre] style,
detailed textures, [mood] atmosphere, [color scheme],
professional concept artist, matte painting, octane render

Techniques avancées

ControlNet

ControlNet permet de guider précisément la composition en fournissant une structure de référence (contours, pose, profondeur, etc.).

Use cases :

• Conserver pose exacte d’une personne
• Suivre un croquis précis
• Maintenir la composition d’une image existante

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from PIL import Image
import torch
import cv2
import numpy as np

# Charger ControlNet (Canny edges)
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/sd-controlnet-canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Préparer image de contrôle (détection contours Canny)
def get_canny_edges(image_path):
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # Détection de contours
    low_threshold = 100
    high_threshold = 200
    edges = cv2.Canny(image, low_threshold, high_threshold)
    edges = edges[:, :, None]
    edges = np.concatenate([edges, edges, edges], axis=2)

    return Image.fromarray(edges)

# Générer image en suivant les contours
control_image = get_canny_edges("sketch.jpg")

image = pipe(
    prompt="A beautiful woman in Renaissance dress, oil painting style, detailed, masterpiece",
    image=control_image,
    num_inference_steps=50
).images[0]

image.save("controlled_portrait.png")

Types de ControlNet :

• Canny : Contours (lines)
• Pose : Squelette humain (OpenPose)
• Depth : Carte de profondeur
• Normal : Normal map (surfaces)
• Seg : Segmentation sémantique
• Scribble : Croquis grossiers

Exemple pose :

# Maintenir pose exacte d'une personne
controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-openpose")

# Extraire pose depuis photo référence
from controlnet_aux import OpenposeDetector

openpose = OpenposeDetector.from_pretrained("lllyasviel/ControlNet")
pose_image = openpose(reference_photo)

# Générer nouvelle personne avec même pose
result = pipe(
    prompt="Superhero in action pose, dynamic, comic book style",
    image=pose_image
).images[0]

LoRA (Low-Rank Adaptation)

LoRA permet d’adapter un modèle à un style, concept ou sujet spécifique avec très peu de données (~20-100 images).

Avantages :

• Fichiers légers (5-200 MB vs 5 GB pour modèle complet)
• Combinables (utiliser plusieurs LoRAs simultanément)
• Rapide à entraîner (1-2h sur GPU consumer)

from diffusers import DiffusionPipeline
import torch

# Charger modèle de base
pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Charger LoRA (ex: style d'un artiste spécifique)
pipe.load_lora_weights("path/to/lora_weights.safetensors")

# Générer avec le style du LoRA
image = pipe(
    prompt="A portrait in the style of <lora_trigger_word>",
    num_inference_steps=50
).images[0]

# Combiner plusieurs LoRAs
pipe.load_lora_weights("artistic_style_lora.safetensors", adapter_name="style")
pipe.load_lora_weights("character_lora.safetensors", adapter_name="character")

pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.8])
# style à 70%, character à 80%

Entraîner son propre LoRA :

# Installation
git clone https://github.com/kohya-ss/sd-scripts
cd sd-scripts
pip install -r requirements.txt

# Préparer dataset
# Structure:
# dataset/
#   my_style/
#     001.jpg
#     002.jpg
#     ...

# Lancer l'entraînement
python train_network.py \
    --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
    --train_data_dir="dataset/my_style" \
    --output_dir="output/my_style_lora" \
    --network_module="networks.lora" \
    --network_dim=8 \
    --learning_rate=1e-4 \
    --max_train_steps=1000 \
    --save_every_n_epochs=1

Use cases :

• Reproduire style d’un artiste
• Générer un personnage spécifique (votre OC, mascotte)
• Style de marque cohérent
• Objets ou concepts uniques

Inpainting (Remplissage)

Inpainting = remplir une zone maskée d’une image existante.

from diffusers import StableDiffusionInpaintPipeline
from PIL import Image
import torch

pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-inpainting",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Charger image originale et masque
init_image = Image.open("room.png").resize((512, 512))
mask_image = Image.open("mask.png").resize((512, 512))
# Mask : blanc = zone à remplacer, noir = zone à conserver

# Remplacer zone maskée
prompt = "A beautiful painting of a landscape on the wall"

result = pipe(
    prompt=prompt,
    image=init_image,
    mask_image=mask_image,
    num_inference_steps=50,
    guidance_scale=7.5
).images[0]

result.save("room_with_painting.png")

Cas d’usage :

• Retouche photo : enlever objets indésirables
• Décoration virtuelle : visualiser meubles dans pièce
• Restauration : réparer zones manquantes
• Création de variantes : changer éléments spécifiques

Outpainting (Extension)

Outpainting = étendre une image au-delà de ses bords.

from diffusers import StableDiffusionInpaintPipeline
from PIL import Image, ImageDraw

def outpaint(image_path, direction="right", extension=512):
    """Étendre image dans une direction"""
    init_image = Image.open(image_path)
    width, height = init_image.size

    # Créer canvas étendu
    if direction == "right":
        new_width = width + extension
        new_height = height
        canvas = Image.new("RGB", (new_width, new_height), (255, 255, 255))
        canvas.paste(init_image, (0, 0))
        mask = Image.new("L", (new_width, new_height), 0)
        draw = ImageDraw.Draw(mask)
        draw.rectangle([(width, 0), (new_width, new_height)], fill=255)

    # Générer contenu dans zone étendue
    result = pipe(
        prompt="Continue the scene naturally, coherent style and lighting",
        image=canvas,
        mask_image=mask,
        num_inference_steps=50
    ).images[0]

    return result

extended_image = outpaint("landscape.jpg", direction="right", extension=512)

Applications :

• Panoramas : créer vues ultra-larges
• Adaptation formats : 1:1 → 16:9 pour vidéo
• Context expansion : ajouter environnement autour d’un sujet

Comparaison prix/qualité (2026)

* Selon abonnement et fast hours - v7 coûte 2x plus cher que v6 en GPU time ** Nécessite GPU (coût hardware/électricité)

Recommandations par usage :

• Prototypage rapide : DALL-E 3 (intégration ChatGPT) ou Imagen 3 (prix)
• Art/esthétique : Midjourney v7 (voice-to-image, personnalisation)
• Production à grande échelle : Imagen 3 ($0.03) ou Stable Diffusion 3.5 (gratuit)
• Précision technique : Flux 1.1 Pro Ultra (4MP) ou DALL-E 3
• Budget limité : Imagen 3 (API) ou SD 3.5 Medium (local)
• Personnalisation : SD 3.5 + LoRAs ou Flux.2 Dev
• Ultra haute résolution 🆕 : Flux 1.1 Pro Ultra (4MP native)
• Consistency 🆕 : Flux.2 Pro (multi-reference, personnages cohérents)

Éthique et copyright

Enjeux de propriété intellectuelle

Question centrale : Qui possède les images générées par IA ?

Statut légal (2024, variable selon pays) :

• USA : Copyright Office refuse copyright sur images 100% IA (sans intervention humaine significative)
• Europe : Flou juridique, directive IA Act en cours
• Général : Images IA = domaine public ou licence spécifique du service

Conditions par plateforme :

• OpenAI (DALL-E) : Vous possédez les images créées, usage commercial autorisé
• Midjourney :
  • Plan gratuit/Basic : Licence Creative Commons BY-NC 4.0 (non-commercial)
  • Plans Pro/Mega : Droits commerciaux complets
• Stable Diffusion : Licence du modèle (CreativeML OpenRAIL-M) permet usage commercial

Formation des modèles

Controverse : Les modèles sont entraînés sur milliards d’images du web, incluant œuvres protégées par copyright.

Arguments des artistes :

• Utilisation non-autorisée de leurs œuvres pour entraînement
• IA peut reproduire styles reconnaissables → concurrence déloyale
• Perte de revenus

Arguments défenseurs IA :

• Fair use / exception pédagogique
• IA ne copie pas, elle apprend des patterns (comme un humain apprenant)
• Images générées sont originales, pas des copies

Class actions en cours :

• Getty Images vs Stability AI (2023)
• Artists vs Midjourney, DeviantArt, Stability AI (2023)

Résolution en attente, probable création de cadres légaux spécifiques.

Deepfakes et désinformation

Risques :

• Génération de fausses photos d’événements
• Manipulation d’images de personnes réelles
• Propagande et désinformation à grande échelle

Protections mises en place :

• C2PA (Coalition for Content Provenance and Authenticity) : Watermarking cryptographique
• DALL-E : Refuse visages de célébrités, politiciens
• Midjourney : Ban si usage malveillant détecté

# Vérifier métadonnées C2PA d'une image
from c2pa import verify

def check_ai_provenance(image_path):
    """Vérifier si image contient métadonnées d'origine IA"""
    result = verify(image_path)

    if result:
        print(f"Image générée avec : {result['generator']}")
        print(f"Date : {result['timestamp']}")
        print(f"Modèle : {result['model']}")
        print(f"Prompt (si disponible) : {result.get('prompt', 'N/A')}")
    else:
        print("Pas de métadonnées C2PA détectées")

Bonnes pratiques éthiques

1. Transparence : Indiquer clairement qu’une image est générée par IA
2. Respect : Ne pas générer d’images de personnes réelles sans consentement
3. Attribution : Mentionner l’outil utilisé si pertinent
4. Vérification : Ne pas diffuser d’images trompeuses comme authentiques
5. Crédit artistes : Si vous vous inspirez d’un style spécifique, créditer l’artiste original

# Exemple de crédit approprié

Image générée avec Midjourney v6
Prompt : "Cyberpunk cityscape, neon lights, Blade Runner style"
Style inspiré de Syd Mead

Exercices pratiques

Générer une identité visuelle de marque

Objectif : Créer un set cohérent de visuels pour une marque fictive.

Livrables :

1. Logo (variantes couleur et N&B)
2. 5 images de produits cohérentes visuellement
3. 3 visuels marketing (réseaux sociaux)
4. Palette de couleurs extraite

Contraintes :

• Même style artistique pour tous les visuels
• Cohérence des couleurs
• Utiliser seed fixe pour compositions similaires

Inpainting créatif

Objectif : Transformer une photo existante avec inpainting.

Scénario : Vous avez une photo de salon vide, ajoutez :

• Tableau au mur
• Plante dans le coin
• Nouveau canapé
• Modification éclairage (sunset through window)

Technique : Inpainting successifs, maintenir cohérence d’éclairage.

LoRA custom

Objectif : Entraîner un LoRA sur un style personnel.

Étapes :

1. Réunir 30-50 images d’un style cohérent (ex: vos propres illustrations)
2. Préparer dataset (annotations basiques)
3. Entraîner LoRA avec Kohya
4. Tester et ajuster hyperparamètres
5. Générer 10 nouvelles images avec le LoRA

Succès : Les images générées capturent l’essence du style.

Conclusion

La génération d’images par IA a atteint une maturité impressionnante en 2026. Les outils sont accessibles, les résultats spectaculaires, et les possibilités infinies.

Points clés :

1. Modèles majeurs 2026 :

   • Midjourney v7 : Voice-to-image révolutionnaire, personnalisation poussée
   • Flux 1.1 Pro Ultra & Flux.2 : 4MP, multi-reference, génération + édition unifiée
   • Stable Diffusion 3.5 : 3 variantes open source (Large 8.1B, Turbo, Medium)
   • Imagen 3 : Champion prix/qualité ($0.03/image)
   • DALL-E 3 : Précision et intégration ChatGPT

2. Innovations 2025-2026 :

   • Voice-to-image (Midjourney v7)
   • Résolution 4MP native (Flux)
   • Multi-reference conditioning (cohérence personnages)
   • Génération + édition unifiée (Flux.2)
   • Prix en baisse continue (Imagen 3 $0.03)

3. Prompt engineering : Structurer prompts avec type média, sujet, style, éclairage, composition

4. Techniques avancées : ControlNet (contrôle composition), LoRA (styles personnalisés), Inpainting/Outpainting

5. Choix modèle : Selon budget, contrôle souhaité, et cas d’usage

6. Éthique : Transparence, respect copyright, éviter deepfakes malveillants

Perspectives 2026 et au-delà :

• Vidéo : Génération vidéo cohérente (Sora, Runway Gen-3, Veo)
• 3D : Text-to-3D natif de plus en plus performant
• Temps réel : Génération interactive instantanée
• Multi-modal : Fusion texte, audio, vidéo, 3D
• Personnalisation : Modèles s’adaptant automatiquement à votre style

Tendances 2026 :

• 📉 Prix en chute : Imagen 3 ($0.03) démocratise l’accès
• 🎙️ Voice-to-image : Création par commande vocale (Midjourney v7)
• 🖼️ 4MP natif : Ultra haute résolution devient standard (Flux)
• 🤝 Multi-reference : Cohérence personnages et styles
• 🔓 Open source fort : SD 3.5, Flux.2 Dev rivalisent avec le closed-source

L’IA n’a pas remplacé les artistes : elle a créé de nouveaux outils créatifs et démocratisé l’accès à la création visuelle. La maîtrise de ces outils devient une compétence clé pour designers, marketeurs et créateurs de contenu.

Le moment est idéal pour expérimenter et intégrer ces technologies dans vos workflows créatifs !

Ressources

Articles liés :

• Modèles multimodaux
• Diffusion models - Architecture technique des modèles de diffusion
• Génération d’images en local - Stable Diffusion, ComfyUI, Automatic1111 sur votre machine
• OpenAI

Plateformes :

• DALL-E 3 - GPT-image-1 enhanced
• Midjourney - Version 7 avec voice-to-image
• Midjourney Documentation
• Stable Diffusion
• Stable Diffusion 3.5 Announcement
• Flux by Black Forest Labs
• Flux 1.1 Pro Ultra
• Imagen 3 on Gemini API
• Imagen 3 on Vertex AI
• Hugging Face Diffusers

Communautés :

• Civitai - Modèles custom, LoRAs, embeddings
• r/StableDiffusion
• Lexica.art - Galerie prompts Stable Diffusion

Outils :

• Automatic1111 WebUI - Interface Stable Diffusion
• ComfyUI - Workflows avancés
• Invoke AI - Alternative WebUI pro