Installation et configuration

• Assurez-vous que vous êtes dans un environnement virtuel Python. Téléchargez le code de départ et installez les dépendances Python via pip install -r requirements.txt.
• Vérifiez que votre installation fonctionne en exécutant le script: python tp5.py. Lors de la première exécution, le téléchargement du modèle prendra quelques minutes.
• Modifiez la variable prompt dans tp5.py avec une courte description de votre cru (par exemple "un paysage magnifique avec un soleil couchant") et exécutez à nouveau le script. Vous devriez voir l'image générée s'enregistrer sous example.png. Répétez cette opération avec au moins 3 prompts différents de votre cru et rapportez les images générées dans votre rapport.
• Dans votre rapport, documentez les spécifications de votre ordinateur (processeur, système d'exploitation) et le temps de génération pour une image.

Comprendre l'échelle de guidage

Le guidage sans classifieur (Classifier-Free Guidance, CFG) est une technique qui améliore l'alignement entre les images générées et les prompts textuels. Le paramètre d'échelle de guidage (guidance scale) contrôle le compromis entre la qualité/diversité des images et l'adhérence au prompt.

L'équation clef est :

$\varepsilon_{\text{guidé}} = \varepsilon_{\text{incond}} + s \cdot (\varepsilon_{\text{cond}} - \varepsilon_{\text{incond}})$

où $\varepsilon_{\text{cond}}$ est la prédiction du modèle conditionnée par le prompt textuel, $\varepsilon_{\text{incond}}$ est la prédiction inconditionnelle (sans prompt) et $s$ est le facteur de guidage. Un facteur de guidage plus élevé aligne la génération plus fortement vers le prompt, mais peut causer des artéfacts.

Étude expérimentale

En utilisant la même graine (seed, déjà spécifié fixe dans le code de départ) et le même prompt, générez des images avec les facteurs de guidage suivants : 0.0, 0.5, 1.0, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 20.0, 40.0 et 60.0. Vous devrez modifier la variable guidance_scale dans le script tp5.py.

Pour chaque échelle de guidage, documentez :

• La qualité visuelle de l'image générée
• À quel point l'image correspond au prompt

Questions d'analyse (répondez dans votre rapport) :

• Que se passe-t-il lorsque guidance_scale = 1.0 ? Pourquoi ?
• À quelle échelle de guidage observez-vous la meilleure adhérence au prompt ?
• À quelle échelle de guidage les artéfacts commencent-ils à apparaître ?

L'inpainting consiste à reconstruire une région masquée d'une image en générant un contenu cohérent avec le contexte visuel autour du masque.

Étendez le code fourni pour supporter l'inpainting d'images.

Contexte : Comment fonctionne l'inpainting

Voici les étapes à réaliser pour effectuer l'inpainting:

1. Ajouter l'image d'entrée et le masque d'entrée comme paramètres d'entrée de la fonction generate_image.
2. Avant la boucle de débruitage, redimensionnez l'image à width et height pixels, puis convertissez-la en tenseur [-1, 1] et encodez l'image par le VAE pour obtenir les vecteurs latents qui la représentent. Finalement, générez le masque latent en réduisant la résolution du masque d'entrée pour correspondre aux dimensions latentes. Voici un code d'exemple pour réaliser ceci:

   image = image.resize((width, height), Image.Resampling.LANCZOS)
   mask = mask.resize((width, height), Image.Resampling.LANCZOS)
   
   # Convertir l'image en tenseur [-1, 1]
   img_array = np.array(image.convert("RGB")).astype(np.float32) / 127.5 - 1.0
   img_tensor = torch.from_numpy(img_array).permute(2, 0, 1).unsqueeze(0).to(device, dtype=text_embeddings.dtype)
   
   # Encoder l'image dans l'espace latent
   init_latents_orig = pipe.vae.encode(img_tensor).latent_dist.sample(generator=generator)
   init_latents_orig = init_latents_orig * pipe.vae.config.scaling_factor
   
   # Convertir le masque en tenseur [0, 1] et redimensionner pour correspondre aux dimensions latentes
   mask_array = np.array(mask.convert("L")).astype(np.float32) / 255.0
   # Le masque est 1 où nous voulons régénérer (blanc), 0 où nous voulons conserver (noir)
   mask_tensor = torch.from_numpy(mask_array).unsqueeze(0).unsqueeze(0).to(device, dtype=text_embeddings.dtype)
   mask_latent = torch.nn.functional.interpolate(mask_tensor, size=(height // 8, width // 8), mode='nearest')

3. À chaque étape de débruitage, fusionnez les latents de l'image originale (avec le niveau de bruit approprié, disponible dans t_prev = timesteps[i + 1]) dans les régions non masquées, par exemple:

   noise = torch.randn_like(init_latents_orig)
   t_prev_tensor = torch.tensor([t_prev.item()], device=device)
   noisy_orig_latents = pipe.scheduler.add_noise(init_latents_orig, noise, t_prev_tensor)

   Puis, fusionnez ces latents avec les latents générés à l'étape courante, une étape similaire à celle de composition: latents = (1 - mask_latent) * noisy_orig_latents + mask_latent * latents
4. Décodez les latents finaux en espace pixel.

Validation

Testez votre implémentation sur les images et masques de test fournis. Votre inpainting devrait :

• Fusionner harmonieusement le contenu généré avec l'image originale
• Respecter les frontières du masque sans coutures visibles
• Générer du contenu correspondant au prompt textuel
• Maintenir un éclairage et un style cohérents avec l'image environnante

Discussion requise : Veuillez discuter brièvement des résultats obtenus dans cette section, avec quelques images de tests et leurs résultats en inpainting.

Exemple de suppression d'objet (avant / masque / résultat). Le modèle employé n'est pas parfait, mais permet d'obtenir des résultats éducatifs.

En utilisant votre implémentation d'inpainting, effectuez la suppression d'objets sur des images. L'objectif est de retirer des objets indésirables et de remplir la région avec un contenu d'arrière-plan plausible.

Tâches

Utilisez les images de imgs.zip suivantes (avec le masque *_mask.png correspondant) :

• graffiti.png : supprimez le graffiti
• pisa.png : supprimez la tour de Pise
• chateau_frontenac.png : supprimez la personne devant le Château

Pour chaque suppression :

• Documentez l'image originale, le masque, le prompt utilisé et le résultat
• Discutez de tout artéfact ou imperfection
• Si le résultat n'est pas satisfaisant, expliquez pourquoi et montrez vos tentatives d'amélioration

Exigence obligatoire (évaluée) : Ajoutez au moins un cas supplémentaire avec votre propre image et votre propre masque.

Questions d'analyse :

• Quels types d'arrière-plans sont les plus faciles/difficiles à reconstruire ?
• Comment la taille de l'objet supprimé affecte-t-elle la qualité ?
• Quelles stratégies de prompts fonctionnent le mieux pour la suppression d'objets ?

Discussion requise : Veuillez discuter brièvement des résultats obtenus dans cette section.

Remplacement d'objet (avant / masque / résultat).

Le remplacement d'objets combine le masquage avec la génération ciblée : au lieu de remplir avec de l'arrière-plan, vous générez un nouvel objet à la place de l'ancien.

Tâches

Utilisez les images de imgs.zip suivantes (avec le masque *_mask.png correspondant) :

• pyramides.webp : ajoutez de la neige sur la pyramide
• baie_beauport.avif : ajoutez un pingouin sur la plage
• moulin.png : remplacez le moulin par un géant

Pour chaque remplacement :

• Documentez l'objet original, le prompt de remplacement et le résultat
• Analysez comment le nouvel objet s'intègre dans la scène
• Discutez de la cohérence de l'éclairage, de l'échelle appropriée et de la qualité des bords

Exigence obligatoire (évaluée) : Ajoutez au moins un cas supplémentaire avec votre propre image et votre propre masque.

Discussion requise : Veuillez discuter brièvement des résultats obtenus dans cette section.

Installation and Configuration

• Make sure you are in a Python virtual environment. Download the starter code and install Python dependencies via pip install -r requirements.txt.
• Verify your setup by running python tp5.py. On the first run, model download will take a few minutes.
• Modify the variable prompt in tp5.py with a short prompt of your choice (for example "a beautiful landscape with a sunset") and run the script again. You should see the generated image saved as example.png. Repeat this with at least 3 different prompts and include the generated images in your report.
• In your report, document your machine specifications (CPU, operating system) and the generation time for one image.

Understanding Guidance Scale

Classifier-Free Guidance (CFG) is a technique that improves the alignment between generated images and text prompts without requiring a separate classifier network. The guidance scale parameter controls the trade-off between image quality/diversity and prompt adherence.

The key equation is:

$\varepsilon_{\text{guided}} = \varepsilon_{\text{uncond}} + s \times (\varepsilon_{\text{cond}} - \varepsilon_{\text{uncond}})$

where $\varepsilon_{\text{cond}}$ is the model's prediction conditioned on the text prompt, $\varepsilon_{\text{uncond}}$ is the unconditional prediction (no prompt), and $s$ is the guidance scale. Higher guidance scales push the generation more strongly toward the prompt, but may produce artifacts.

Experimental Study

Using the same seed (already fixed in the starter code) and the same prompt, generate images with guidance scales: 0.0, 0.5, 1.0, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 20.0, 40.0, and 60.0. You will need to modify the variable guidance_scale in tp5.py.

For each guidance scale, document:

• Visual quality of the generated image
• How well the image matches the prompt

Analysis Questions (answer in your report):

• What happens at guidance_scale = 1.0? Why?
• At what guidance scale do you observe the best prompt adherence?
• At what guidance scale do artifacts begin to appear?

Inpainting is the task of reconstructing a masked region in an image by generating content that is consistent with the surrounding visual context.

Extend the provided code to support image inpainting.

Background: How Inpainting Works

Here are the steps to implement inpainting:

1. Add the input image and input mask as inputs to the function generate_image.
2. Before the denoising loop, resize the image to width and height, convert it to a tensor in [-1, 1], and encode it with the VAE to obtain latent vectors. Then build a latent mask by downsampling the input mask to match latent dimensions. Example code:

   image = image.resize((width, height), Image.Resampling.LANCZOS)
   mask = mask.resize((width, height), Image.Resampling.LANCZOS)
   
   # Convert image to tensor [-1, 1]
   img_array = np.array(image.convert("RGB")).astype(np.float32) / 127.5 - 1.0
   img_tensor = torch.from_numpy(img_array).permute(2, 0, 1).unsqueeze(0).to(device, dtype=text_embeddings.dtype)
   
   # Encode image in latent space
   init_latents_orig = pipe.vae.encode(img_tensor).latent_dist.sample(generator=generator)
   init_latents_orig = init_latents_orig * pipe.vae.config.scaling_factor
   
   # Convert mask to tensor [0, 1] and resize to latent dimensions
   mask_array = np.array(mask.convert("L")).astype(np.float32) / 255.0
   # The mask is 1 where we regenerate (white), 0 where we keep (black)
   mask_tensor = torch.from_numpy(mask_array).unsqueeze(0).unsqueeze(0).to(device, dtype=text_embeddings.dtype)
   mask_latent = torch.nn.functional.interpolate(mask_tensor, size=(height // 8, width // 8), mode='nearest')

3. At each denoising step, merge original image latents (with the appropriate noise level, available in t_prev = timesteps[i + 1]) in the unmasked region, for example:

   noise = torch.randn_like(init_latents_orig)
   t_prev_tensor = torch.tensor([t_prev.item()], device=device)
   noisy_orig_latents = pipe.scheduler.add_noise(init_latents_orig, noise, t_prev_tensor)

   Then combine these latents with current generated latents, similarly to compositing: latents = (1 - mask_latent) * noisy_orig_latents + mask_latent * latents.
4. Decode final latents back to pixel space.

Validation

Test your implementation on the provided test images and masks. Your inpainting should:

• Seamlessly blend generated content with the original image
• Respect mask boundaries without visible seams
• Generate content that matches the text prompt
• Maintain consistent lighting and style with the surrounding image

Required Discussion: Please discuss briefly the results obtained in this section.

Teaser: object removal (before / mask / result).

Using your inpainting implementation, perform object removal on images. The goal is to remove unwanted objects and fill the region with plausible background content.

Tasks

Use the following images from imgs.zip (with the corresponding *_mask.png mask):

• graffiti.png: remove the graffiti
• pisa.png: remove the Pisa tower
• chateau_frontenac.png: remove the person in front of the Château

For each removal:

• Document the original image, mask, prompt used, and result
• Discuss any artifacts or imperfections
• If the result is not satisfactory, explain why and show attempts to improve it

Mandatory graded requirement: Include at least one additional test case using your own image and your own mask.

Analysis Questions:

• What types of backgrounds are easiest/hardest to reconstruct?
• How does the size of the removed object affect quality?
• What prompt strategies work best for object removal?

Required Discussion: Please discuss briefly the results obtained in this section.

Teaser: object replacement (before / mask / result).

Object replacement combines masking with targeted generation: instead of filling with background, you generate a new object in place of the old one.

Tasks

Use the following images from imgs.zip (with the corresponding *_mask.png mask):

• pyramides.webp: add snow on the pyramid
• baie_beauport.avif: add a penguin to the beach
• moulin.png: replace the windmill by a giant

For each replacement:

• Document the original object, replacement prompt, and result
• Analyze how well the new object integrates with the scene
• Discuss lighting consistency, scale appropriateness, and edge quality

Mandatory graded requirement: Include at least one additional test case using your own image and your own mask.

Required Discussion: Please discuss briefly the results obtained in this section.