Tutoriel SAM3 (Segment Everything Model 3) : Construire un filtre de confidentialité

SAM 3 est le nouveau segment de Meta.segmenter tout» de Meta qui permet de trouver toutes les occurrences d'un concept à partir de courtes invites textuelles ou d'exemples, et de renvoyer des masques précis au pixel près sur des images et des vidéos. Cela le rend idéal pour les tâches pratiques liées à la confidentialité, telles que le floutage des visages, des plaques d'immatriculation ou des écrans, sans avoir à sélectionner manuellement les zones à traiter ou à écrire des détecteurs classiques.

Dans ce tutoriel, nous allons créer un filtre de confidentialité SAM3 dans Colab à l'aide d'une interface utilisateur Gradio. Il suffit de télécharger une image ou une vidéo, de saisir une instruction (telle que « visages », « plaques d'immatriculation ») et SAM3 renverra des masques d'instance afin que nous puissions flouter uniquement ces pixels. Nous allons vous guider à travers la configuration, la génération de masques, l'application d'un flou gaussien et le câblage de l'application Gradio pour exporter les fichiers finaux.

Qu'est-ce que SAM3 ?

Segment Anything Model 3 (SAM 3) est le modèle unifié de Meta pour la détection, la segmentation et le suivi à vocabulaire ouvert dans les images et les vidéos. Au lieu de configurer des détecteurs distincts pour chaque classe, vous pouvez fournir de courtes phrases ou des exemples, et SAM 3 renvoie des masques par instance.

En arrière-plan, SAM 3 combine un encodeur de texte et un encodeur d'image avec un détecteur de type DETR et un tracker dérivé de SAM-2 avec une banque de mémoire. À chaque image, il détecte les masques correspondant à votre concept à partir de l'invite, propage les masques vers l'avant via le tracker et fusionne les masques nouvellement détectés et suivis dans le résultat final pour cette image. 

Source : SAM3 GitHub

SAM 3 est publié avec les poids des modèles, le code de réglage fin et les données d'évaluation, y compris le benchmark SA-Co pour la segmentation de concepts promptables. 

Dans les rapports de Meta, il est indiqué des gains d'environ 2x par rapport aux références solides en matière de segmentation à vocabulaire ouvert dans les images et les vidéos, tout en conservant les atouts interactifs de SAM-2. 

Dans ce tutoriel, nous allons utiliser ces masques SAM 3 et les transformer en un composite flou gaussien pour les images et les vidéos, intégré dans une interface utilisateur Gradio. 

Exemple SAM3 : Création d'un filtre de confidentialité pour les images et les vidéos

Dans cette section, nous allons créer un filtre de confidentialité avec SAM3 pour les images et les vidéos intégrées dans une interface utilisateur Gradio simple.

Voici comment cela fonctionne :

• Commencez par saisir une cible, par exemple des visages, des plaques d'immatriculation, des écrans d'ordinateur, etc.
• SAM3 segmente les instances qui correspondent à votre invite textuelle et renvoie des masques par objet.
• Nous fusionnons ensuite ces masques et floutons uniquement les pixels masqués.
• Ensuite, nous utilisons le composant Gradio UI pour télécharger une image ou une vidéo, ajuster l'intensité du flou et le niveau de confiance, puis prévisualiser et télécharger les résultats.

Nous allons vous guider à travers la mise en œuvre complète, étape par étape.

Étape 1 :  Veuillez installer les dépendances.

Avant de lancer cette démonstration, veuillez vous assurer que toutes les conditions préalables sont remplies. Pour exécuter le filtre de confidentialité SAM3 dans Colab, vous devez disposer de la dernière version de Transformers ainsi que quelques bibliothèques d'exécution pour l'interface utilisateur, les opérations tensorielles, les images et les E/S vidéo. L'extrait ci-dessous permet d'installer tous les éléments en une seule fois.

import subprocess
import sys
import os
def install(package):
    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", package])
print(" Installing latest Transformers")
install("git+https://github.com/huggingface/transformers.git")
pkgs = [
    "accelerate",
    "gradio",
    "numpy",
    "pillow",
    "torch",
    "torchvision",
    "imageio[ffmpeg]" 
]
for p in pkgs:
    install(p)

Voici ce que fait chaque prérequis :

• git+https://github.com/huggingface/transformers.git: Cela permet de récupérer la dernière bibliothèque Transformers à partir de la source, afin que les classes Sam3Processor et Sam3Model soient disponibles.
• torch et torchvision: Il s'agit des utilitaires de calcul tensoriel et d'image qui exécutent le passage direct SAM3.
• accelerate: Il s'agit de l'assistant d'inférence utilisé par Transformers.
• gradio: Une interface utilisateur web légère pour télécharger des médias et prévisualiser les résultats flous.
• numpy, pillow: Il s'agit notamment de tableaux d'images et d'opérations sur les images PIL pour la composition de masques/flous.
• imageio[ffmpeg]: Il lit/écrit des vidéos et encode au format MP4 (FFmpeg) pour l'onglet vidéo.

Une fois l'environnement configuré et facebook/sam3 chargé, la démonstration vous permet de segmenter à l'aide de courtes invites textuelles et de flouter les masques obtenus dans des images ou des vidéos à l'aide d'une application Gradio simple. 

Remarque : Si vous envisagez d'utiliser un GPU dans Colab, veuillez configurer le runtime sur GPU (T4/A100) avant l'installation. J'ai utilisé un GPU A100 sur Colab pour une expérience plus rapide.

Étape 2 :  Imports

Une fois l'environnement configuré, veuillez importer les bibliothèques qui alimentent l'interface utilisateur, l'inférence de modèle, le traitement des images/vidéos et la synchronisation. Ce sont les seuls modules dont vous avez besoin pour le filtre de confidentialité SAM3.

import gradio as gr
import torch
import numpy as np
import imageio
from PIL import Image, ImageFilter
from transformers import Sam3Processor, Sam3Model
import time

À présent, Gradio fournit l'interface Web, la bibliothèque transformers exécute SAM3 et PyTorch effectue l'inférence sur le GPU ou le CPU. PIL permet de charger et de modifier des images (y compris le flou gaussien), NumPy gère les tableaux de masques et imageio lit et écrit des fichiers vidéo.

Ensuite, nous chargerons le modèle et construirons un petit moteur qui transforme les invites de texte en masques que vous pouvez flouter.

Étape 3 : Charger SAM3 et prédire les masques

Maintenant que l'environnement est prêt, intégrons SAM3 dans un petit moteur qui charge le modèle une seule fois, exécute la segmentation d'instances à la demande à partir d'une invite textuelle et renvoie des masques binaires utilisés pour le flou.

class Sam3PrivacyEngine:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model = None
        self.processor = None
        print(f"Initializing SAM3 on {self.device}")
        try:
            self.model = Sam3Model.from_pretrained("facebook/sam3").to(self.device)
            self.processor = Sam3Processor.from_pretrained("facebook/sam3")
            print("SAM3 Loaded Successfully!")
        except Exception as e:
            print(f"Error loading SAM3: {e}")
    def predict_masks(self, image_pil, text_prompt, threshold=0.4):
        if self.model is None: return []
        inputs = self.processor(
            images=image_pil,
            text=text_prompt,
            return_tensors="pt"
        ).to(self.device)
        with torch.no_grad():
            outputs = self.model(**inputs)
        results = self.processor.post_process_instance_segmentation(
            outputs, 
            threshold=threshold, 
            mask_threshold=0.5, 
            target_sizes=inputs["original_sizes"].tolist()
        )[0]
        masks = []
        if "masks" in results:
            for i, mask_tensor in enumerate(results["masks"]):
                mask_np = (mask_tensor.cpu().numpy() * 255).astype(np.uint8)
                mask_pil = Image.fromarray(mask_np)
                masks.append(mask_pil)
        return masks
engine = Sam3PrivacyEngine()

Comprenons comment ce moteur s'intègre dans le pipeline :

• Sam3PrivacyEngine.init(): Cet initialiseur sélectionne le meilleur périphérique (CUDA si disponible, sinon CPU), charge les poids d'facebook/sam3 et l'Sam3Processor associé, puis transfère le modèle vers le périphérique choisi afin que l'inférence puisse s'exécuter efficacement.
• Sam3PrivacyEngine.predict_masks(): Cette méthode génère des entrées de modèle à partir d'une image PIL et d'une invite de texte, exécute une inférence directe sous torch.no_grad() afin d'éviter la surcharge du gradient, et traite les sorties avec post_process_instance_segmentation en utilisant les seuils de détection et de masque donnés ainsi que les tailles cibles d'origine pour un redimensionnement correct. Il renvoie des masques de segmentation par instance convertis à partir de tenseurs en tableaux NumPy, puis en masques PIL « L » (images en niveaux de gris 8 bits (mode « L ») où chaque pixel correspond à une valeur comprise entre 0 et 255) pour la composition.
• engine = Sam3PrivacyEngine(): Cette ligne crée une instance de moteur unique et réutilisable afin que le modèle SAM3 ne soit chargé qu'une seule fois et puisse être appelé à plusieurs reprises pour des images ou des trames vidéo sans réinitialisation.

Une fois ce moteur autonome initialisé, vous pouvez transformer n'importe quelle image et n'importe quel texte en masques d'instance. Ensuite, nous appliquerons un flou de manière sélective à l'aide de ces masques et intégrerons le tout dans l'interface utilisateur Gradio.

Étape 4 : Logique floue

Dans cette section, nous utilisons les masques SAM3 et appliquons la confidentialité. Il ne floute que les zones masquées tout en conservant le reste. Nous commençons par une fonction de flou gaussien réutilisable, puis nous la connectons à deux pipelines, l'un pour les images et l'autre pour les vidéos.

Étape 4.1 : flou gaussien

Cet assistant prend une image et un ou plusieurs masques PIL « L », les fusionne en un seul masque composite et colle une copie floue de l'image uniquement là où le masque est blanc (255). 

def apply_blur_pure(image_pil, masks, blur_strength):
    if not masks:
        return image_pil
    radius = blur_strength
    blurred_image = image_pil.filter(ImageFilter.GaussianBlur(radius=radius))
    composite_mask = Image.new("L", image_pil.size, 0)
    for mask in masks:
        composite_mask.paste(255, (0, 0), mask=mask)
    final_image = image_pil.copy()
    final_image.paste(blurred_image, (0, 0), mask=composite_mask)
    return final_image

Voici comment cette fonction fonctionne :

• La fonction GaussianBlur() commence par créer une version entièrement floue de l'image. Alors que composite_mask est un masque « L » (niveaux de gris) initialisé en noir (0 = conserver l'original). 
• Pour chaque masque SAM3, nous l'intégrons à ce composite afin que les pixels blancs (255) s'accumulent là où le flou doit apparaître. 
• Enfin, nous superposons l'image floue sur l'originale à l'aide de la fonction composite_mask, de sorte que seules les zones blanches apparaissent floues.
• La méthode « final_image.paste() » remplace uniquement les pixels masqués, laissant les autres inchangés pour une fidélité visuelle optimale.

En un seul appel, vous pouvez flouter n'importe quel ensemble de zones telles que les visages, les écrans, les plaques, tout en conservant les arrière-plans tels quels.

Étape 4.2 : Pipeline d'images

Cette sous-étape couvre le flux d'images de bout en bout, depuis la normalisation des entrées jusqu'à l'obtention des masques à partir de SAM3, puis le floutage des pixels masqués et enfin le renvoi du résultat.

def process_image(input_img, text_prompt, blur_strength, confidence):
    if input_img is None: return None, None
    if isinstance(input_img, np.ndarray):
        image_pil = Image.fromarray(input_img).convert("RGB")
    else:
        image_pil = input_img.convert("RGB")
    masks = engine.predict_masks(image_pil, text_prompt, confidence)
    result_pil = apply_blur_pure(image_pil, masks, blur_strength)
    output_path = "privacy_image.png"
    result_pil.save(output_path)
    return np.array(result_pil), output_path

Nous traitons les images selon le processus étape par étape suivant :

• Nous convertissons d'abord tout tableau NumPy Gradio en une image RVB PIL afin de garantir un traitement cohérent.
• Ensuite, nous appelons engine.predict_masks() pour obtenir les masques d'instance SAM3 pour l'text_prompt fourni.
• Nous appliquons ensuite la fonction apply_blur_pure() avec l'blur_strength e sélectionnée afin que seules les zones masquées soient floutées.
• Après traitement, nous enregistrons le résultat sous forme de fichier png et renvoyons à la fois un tableau NumPy et un fichier téléchargeable.

Une fois le flux d'images terminé, nous pouvons maintenant passer au pipeline vidéo.

Étape 4.3 : Chaîne de production vidéo

Le flux vidéo reflète le cheminement de l'image, mais est diffusé image par image avec imageio. Pour chaque image, nous procédons à la segmentation, au floutage des zones masquées et à l'écriture dans un fichier MP4 encodé au format H.264.

def process_video(video_path, text_prompt, blur_strength, confidence, max_frames):
    if not video_path: return None, None
    try:
        reader = imageio.get_reader(video_path)
        meta = reader.get_meta_data()
        fps = meta.get('fps', 24)  
        output_path = "privacy_video.mp4"
        writer = imageio.get_writer(
            output_path, 
            fps=fps, 
            codec='libx264', 
            pixelformat='yuv420p',
            macro_block_size=1
        )  
        print("Starting video processing...")
        for i, frame in enumerate(reader):
            if i >= max_frames:
                break  
            frame_pil = Image.fromarray(frame).convert("RGB")
            masks = engine.predict_masks(frame_pil, text_prompt, confidence)
            processed_pil = apply_blur_pure(frame_pil, masks, blur_strength)
            writer.append_data(np.array(processed_pil))
            if i % 10 == 0:
                print(f"Processed frame {i}...")
        writer.close()
        reader.close()
        print("Video processing complete.")
        return output_path, output_path
    except Exception as e:
        print(f"Error: {e}")
        return None, None

Voici comment nous traitons les vidéos à l'aide du pipeline suivant :

• Nous commençons par ouvrir le fichier avec imageio.get_reader(), puis nous parcourons les images et lisons le FPS à partir des métadonnées (la valeur par défaut est 24 si elle est manquante).
• Ensuite, pour chaque image, nous la convertissons en image PIL, prédisons les masques avec SAM3 via la méthode engine.predict_masks() et floutons les régions masquées à l'aide de la fonction apply_blur_pure().
• Nous ajoutons ensuite chaque image traitée à un enregistreur MP4 configuré avec pixelformat='yuv420p' pour une compatibilité étendue et macro_block_size=1 afin d'éviter les artefacts d'alignement.
• Après le traitement, nous réduisons intentionnellement la sortie en nous arrêtant après un nombre spécifique d'images, qui est par défaut de 60 images (~2 secondes), afin de garantir la rapidité des tests Colab et d'éviter les délais d'attente.

Grâce à ce flux vidéo, vous pouvez flouter les zones sensibles dans les enregistrements de réunions, les clips de caméras embarquées ou les captures d'écran à l'aide d'une simple invite textuelle.

Étape 5 : Inférence Gradio

Maintenant que le masquage et le floutage sont prêts, nous allons intégrer le tout dans une interface utilisateur Gradio légère afin que tout le monde puisse télécharger une image ou une vidéo, saisir une invite de texte et télécharger le résultat.

with gr.Blocks(title="SAM3 Privacy Filter", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# SAM3 Privacy Filter")
    gr.Markdown("Auto-detect and blur faces/objects.")
    with gr.Tabs():
        with gr.Tab("Image"):
            with gr.Row():
                with gr.Column():
                    im_input = gr.Image(label="Input Image", type="numpy")
                    im_prompt = gr.Textbox(label="Text Prompt", value="faces")
                    im_blur = gr.Slider(5, 100, value=30, label="Blur Strength")
                    im_conf = gr.Slider(0.1, 1.0, value=0.4, label="Confidence")
                    im_btn = gr.Button("Blur Image", variant="primary")
                with gr.Column():
                    im_output = gr.Image(label="Preview")
                    im_dl = gr.File(label="Download Image")   
            im_btn.click(process_image, [im_input, im_prompt, im_blur, im_conf], [im_output, im_dl])
        with gr.Tab("Video"):
            with gr.Row():
                with gr.Column():
                    vid_input = gr.Video(label="Input Video")
                    vid_prompt = gr.Textbox(label="Text Prompt", value="faces")
                    vid_blur = gr.Slider(5, 100, value=30, label="Blur Strength")
                    vid_conf = gr.Slider(0.1, 1.0, value=0.4, label="Confidence")
                    vid_limit = gr.Slider(10, 300, value=60, step=10, label="Max Frames")
                    vid_btn = gr.Button("Blur Video", variant="primary")
                with gr.Column():
                    vid_output = gr.Video(label="Preview")
                    vid_dl = gr.File(label="Download Video")
            vid_btn.click(process_video, [vid_input, vid_prompt, vid_blur, vid_conf, vid_limit], [vid_output, vid_dl])
demo.launch(share=True, debug=True)

L'application Gradio intègre le pipeline de masquage et de flou SAM3 à une interface utilisateur Web simple en utilisant :

• App shell (gr.Blocks): Ce bloc crée une application Gradio d'une seule page avec un titre et deux onglets, l'un pour les images et l'autre pour les vidéos, afin que les utilisateurs puissent changer de mode sans quitter la page.
• Onglet Image: Les entrées comprennent un outil de téléchargement d'images, une zone de texte pour la saisie de texte et des curseurs pour régler l'intensité du flou et le niveau de confiance. Les champs de sortie affichent un aperçu traité et un fichier PNG téléchargeable, tandis que le bouton« Blur Image » (Flouter l'image) de l' redirige l'ensemble vers process_image, qui fait appel à SAM3 pour les masques et applique un flou gaussien uniquement sur les pixels masqués.
• Onglet Vidéo: Pour le floutage vidéo, les entrées comprennent un outil de téléchargement de vidéo, une zone de texte pour l'invite, des curseurs pour régler l'intensité et la confiance du floutage, ainsi qu'une limite maximale d'images pour les démonstrations rapides. Les champs de sortie fournissent un aperçu en ligne et un fichier MP4 téléchargeable, tandis que le bouton« Blur Video » (Flouter la vidéo) de l' permet d'accéder à process_video, où les images sont parcourues pour prédire les masques, flouter les zones masquées et encoder une vidéo H.264.
• Lancement de l': La méthode ` demo.launch() ` lance l'application, génère un lien partageable et affiche des traces de pile détaillées lorsque le débogage est activé.

À présent, notre filtre de confidentialité SAM3 est prêt à télécharger des médias (images/vidéos), à définir des invites et des seuils, et à exporter les résultats floutés.

Remarque : Toutes les images et vidéos de cette démonstration proviennent de Pexels.com et sont libres d'utilisation.