SAM3-Tutorial (Segment Everything Model 3): Mach dir einen Sichtschutz

SAM 3 ist das neue „Segment Anything”, das jedes Vorkommen eines Konzepts über kurze Textanweisungen oder Beispiele finden und pixelgenaue Masken über Bilder und Videos hinweg zurückgeben kann. Das macht es super für praktische Datenschutzaufgaben wie das Verwischen von Gesichtern, Nummernschildern oder Bildschirmen, ohne dass man manuell Auswahlen zeichnen oder klassische Detektoren schreiben muss.

In diesem Tutorial erstellen wir einen SAM3-Datenschutzfilter in Colab mit einer Gradio -Benutzeroberfläche. Lade einfach ein Bild oder Video hoch, gib eine Eingabeaufforderung ein (z. B. Gesichter, Nummernschilder) und SAM3 gibt Instanzmasken zurück, sodass wir nur diese Pixel unscharf machen können. Wir schauen uns die Einrichtung, die Maskenerstellung, das Anwenden eines Gaußschen Weichzeichners und die Verknüpfung der Gradio-App an, um die fertigen Dateien zu exportieren.

Was ist SAM3?

Segment Anything Model 3 (SAM 3) ist das einheitliche Modell von Meta für die Erkennung, Segmentierung und Verfolgung von offenen Vokabeln in Bildern und Videos. Anstatt für jede Klasse separate Detektoren einzurichten, kannst du kurze Sätze oder Beispiele eingeben, und SAM 3 gibt dir dann Masken für jede Instanz zurück.

Unter der Haube kombiniert SAM 3 einen Text- und einen Bild-Encoder mit einem DETR-ähnlichen Detektor und einem von SAM-2 abgeleiteten Tracker mit Speicherbank. Bei jedem Frame findet es Masken für dein Konzept aus der Eingabeaufforderung, gibt die Masken über den Tracker weiter und fügt die neu gefundenen und verfolgten Masken in die endgültige Ausgabe für diesen Frame ein. 

Quelle: SAM3 GitHub

SAM 3 kommt mit Modellgewichten, Feinabstimmungscode und Bewertungsdaten, einschließlich des SA-Co-Benchmark für die promptfähige Konzeptsegmentierung. 

In den Berichten von Meta steht etwa doppelt so hohe Gewinne gegenüber starken Basiswerten bei der Segmentierung mit offenem Vokabular in Bildern und Videos, während die interaktiven Stärken von SAM-2 erhalten bleiben. 

In diesem Tutorial nehmen wir diese SAM-3-Masken und machen daraus eine mit Gaußscher Unschärfe bearbeitete Komposition für Bilder und Videos, eingebettet in eine Gradio-Benutzeroberfläche. 

SAM3 Beispiel: Einen Datenschutzfilter für Bilder und Videos erstellen

In diesem Abschnitt erstellen wir mit SAM3 einen Datenschutzfilter für Bilder und Videos, die in eine einfache Gradio-Benutzeroberfläche eingebettet sind.

So läuft's ab:

• Fang damit an, ein Ziel einzugeben, zum Beispiel Gesichter, Nummernschilder, Computerbildschirme usw.
• SAM3 teilt Instanzen, die zu deiner Textanweisung passen, in Segmente auf und gibt Masken pro Objekt zurück.
• Dann fügen wir diese Masken zusammen und verwischen nur die maskierten Pixel.
• Dann nehmen wir die Gradio-UI-Komponente, um ein Bild oder Video hochzuladen, die Unschärfestärke und die Zuverlässigkeit anzupassen und dann die Ergebnisse vorab anzusehen und runterzuladen.

Wir gehen die komplette Umsetzung in kleinen Schritten durch.

Schritt 1:  Installiere Abhängigkeiten

Bevor wir diese Demo starten, sollten wir sicherstellen, dass wir alle Voraussetzungen erfüllt haben. Um den SAM3-Datenschutzfilter in Colab zu nutzen, brauchst du die neueste Version von Transformers-Bibliothek sowie ein paar Laufzeitbibliotheken für UI, Tensor-Operationen, Bilder und Video-I/O. Der folgende Ausschnitt installiert alles auf einmal.

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)

Hier ist, was jede Voraussetzung macht:

• git+https://github.com/huggingface/transformers.git: Damit holst du die neueste Version der Bibliothek „ Transformers ” aus dem Quellcode, sodass die Klassen „ Sam3Processor ” und „ Sam3Model ” verfügbar sind.
• torch und torchvision: Das sind die Tensor-Berechnungs- und Bildbearbeitungsprogramme, die den SAM3-Vorwärtsdurchlauf ausführen.
• accelerate: Das ist der Inferenz-Helfer, den Transformers benutzt.
• gradio: Eine schlanke Web-Benutzeroberfläche zum Hochladen von Medien und zum Anzeigen unscharfer Ergebnisse.
• numpy, pillow: Dazu gehören Bildarrays und PIL-Bildoperationen für die Masken-/Weichzeichnungszusammensetzung.
• imageio[ffmpeg]: Es liest/schreibt Videos und codiert MP4 (FFmpeg) für den Video-Tab.

Sobald die Umgebung eingerichtet und facebook/sam3 geladen ist, kannst du mit der Demo mithilfe kurzer Textanweisungen Segmente erstellen und die resultierenden Masken in Bildern oder Videos über eine einfache Gradio-App verwischen. 

Anmerkung: Wenn du vorhast, eine GPU in Colab zu nutzen, stell die Laufzeit vor der Installation auf GPU (T4/A100) ein. Ich hab 'ne A100-GPU auf Colab benutzt, um schneller voranzukommen.

Schritt 2:  Importe

Wenn die Umgebung fertig ist, importier die Bibliotheken, die die Benutzeroberfläche, die Modellinferenz, die Bild-/Videoverarbeitung und das Timing unterstützen. Das sind die einzigen Module, die du für den SAM3-Datenschutzfilter brauchst.

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

Jetzt macht Gradio das Webinterface, die Bibliothek transformers läuft auf SAM3 und PyTorch macht die Inferenz auf GPU oder CPU. Während PIL Bilder lädt und bearbeitet (einschließlich Gaußscher Unschärfe), kümmert sich NumPy um die Masken-Arrays und imageio liest und schreibt Videodateien.

Als Nächstes laden wir das Modell und bauen einen kleinen Motor, der Textanweisungen in Masken verwandelt, die du verwischen kannst.

Schritt 3: Lade SAM3 und sage Masken voraus

Jetzt, wo alles fertig ist, packen wir SAM3 in eine kleine Engine, die das Modell einmal lädt, bei Bedarf eine textgesteuerte Instanzsegmentierung durchführt und Binärmasken zurückgibt, die zum Weichzeichnen verwendet werden.

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()

Schauen wir mal, wie diese Engine in die Pipeline passt:

• Sam3PrivacyEngine.init(): Dieser Initialisierer sucht das beste Gerät (CUDA, wenn verfügbar, sonst CPU), lädt die Gewichte „ facebook/sam3 “ und die dazugehörigen „ Sam3Processor “ und verschiebt das Modell auf das ausgewählte Gerät, damit die Inferenz effizient laufen kann.
• Sam3PrivacyEngine.predict_masks(): Diese Methode erstellt Modelleingaben aus einem PIL-Bild und einer Textanweisung, führt eine Vorwärtsinferenz unter Verwendung von „ torch.no_grad() “ durch, um Gradienten-Overhead zu vermeiden, und bearbeitet die Ausgaben nachträglich mit „ post_process_instance_segmentation “, wobei die vorgegebenen Erkennungs- und Maskenschwellenwerte sowie die ursprünglichen Zielgrößen für die korrekte Skalierung verwendet werden. Es gibt Segmentierungsmasken pro Instanz zurück, die von Tensoren in NumPy-Arrays und dann in PIL-„L“-Masken (8-Bit-Graustufenbilder (Modus us „L“), bei denen jedes Pixel einen Wert zwischen 0 und 255 hat) für die Zusammensetzung umgewandelt wurden.
• engine = Sam3PrivacyEngine(): Diese Zeile baut eine einzige, wiederverwendbare Engine-Instanz auf, sodass das SAM3-Modell einmal geladen wird und dann immer wieder für Bilder oder Videoframes genutzt werden kann, ohne dass es neu initialisiert werden muss.

Sobald diese eigenständige Engine gestartet ist, kannst du jedes Bild und jeden Text in Instanzmasken umwandeln. Als Nächstes machen wir mit diesen Masken ein paar selektive Unschärfen und packen alles in die Gradio-Benutzeroberfläche.

Schritt 4: Verschwommene Logik

In diesem Abschnitt nehmen wir die Masken von SAM3 und machen sie privat. Es verwischt nur die maskierten Bereiche, während alles andere erhalten bleibt. Wir fangen mit einer wiederverwendbaren Gaußschen Weichzeichnungsfunktion an und verbinden sie dann mit zwei Pipelines, eine für Bilder und eine für Videos.

Schritt 4.1: Gaußscher Weichzeichner

Dieser Helfer nimmt ein Bild und eine oder mehrere PIL-„L“-Masken, mischt sie zu einer einzigen zusammengesetzten Maske und fügt eine unscharfe Kopie des Bildes nur dort ein, wo die Maske weiß (255) ist. 

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

So funktioniert diese Funktion:

• Die Funktion „ GaussianBlur() “ macht erst mal eine komplett unscharfe Version vom Bild. Während „ composite_mask “ eine „L“-Maske (Graustufen) ist, die auf Schwarz initialisiert ist (0 = Original beibehalten). 
• Für jede SAM3-Maske fügen wir sie in diese Komposition ein, sodass weiße Pixel (255) dort erscheinen, wo Unschärfe sein soll. 
• Zum Schluss kleben wir das unscharfe Bild mit „ composite_mask “ über das Original, sodass nur die weißen Bereiche unscharf werden.
• Die Methode „ final_image.paste() “ ersetzt nur maskierte Pixel und lässt den Rest für maximale visuelle Genauigkeit unverändert.

Mit einem einzigen Anruf kannst du beliebige Bereiche wie Gesichter, Bildschirme oder Teller unscharf machen, während der Hintergrund unverändert bleibt.

Schritt 4.2: Bild-Pipeline

Dieser Teilschritt kümmert sich um den kompletten Bildfluss, von der Normalisierung der Eingabe über das Abrufen von Masken aus SAM3 bis hin zum Weichzeichnen maskierter Pixel und schließlich zur Rückgabe des Ergebnisses.

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

Wir bearbeiten Bilder mit der folgenden Schritt-für-Schritt-Pipeline:

• Wir wandeln erst mal jedes Gradio-NumPy-Array in ein PIL-RGB-Bild um, damit alles einheitlich verarbeitet wird.
• Als Nächstes rufen wir „ engine.predict_masks() “ auf, um SAM3-Instanzmasken für die angegebene „ text_prompt “ zu bekommen.
• Dann nehmen wir die Funktion „ apply_blur_pure() “ mit dem ausgewählten „ blur_strength “ und sorgen dafür, dass nur die maskierten Bereiche unscharf werden.
• Nach der Verarbeitung speichern wir das Ergebnis als „ png “ und geben sowohl ein NumPy-Array als auch eine Datei zum Download zurück.

Nachdem der Bildfluss fertig ist, können wir jetzt mit der Videopipeline weitermachen.

Schritt 4.3: Videopipeline

Der Videofluss ist wie der Bildpfad, aber mit „ imageio “ wird Bild für Bild gestreamt. Für jedes Einzelbild machen wir eine Segmentierung, verwischen maskierte Bereiche und speichern das Ganze in einer H.264-kodierten MP4-Datei.

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

So machen wir das mit Videos über die folgende Pipeline:

• Zuerst öffnen wir die Datei mit „ imageio.get_reader() “, dann gehen wir die Frames durch und lesen die FPS aus den Metadaten (wenn die fehlen, nehmen wir 24 als Standardwert).
• Als Nächstes machen wir aus jedem Frame ein PIL-Bild, sagen mit SAM3 über die Methode „ engine.predict_masks() “ Masken voraus und verwischen die maskierten Bereiche mit der Funktion „ apply_blur_pure() “.
• Dann fügen wir jeden bearbeiteten Frame an einen MP4-Writer an, der mit „ pixelformat='yuv420p' ” für breite Kompatibilität und „ macro_block_size=1 ” konfiguriert ist, um Ausrichtungsartefakte zu vermeiden.
• Nach der Verarbeitung schneiden wir die Ausgabe absichtlich ab, indem wir nach einer bestimmten Anzahl von Frames stoppen, die standardmäßig auf 60 Frames (~2 Sekunden) eingestellt ist, um Colab-Tests schnell zu halten und Zeitüberschreitungen zu vermeiden.

Mit diesem Video-Flow kannst du sensible Bereiche in Meeting-Aufzeichnungen, Dashcam-Clips oder Screenshots mit einer einfachen Textanweisung unkenntlich machen.

Schritt 5: Gradio-Inferenz

Jetzt, wo das Maskieren und Verwischen fertig sind, packen wir alles in eine schlanke Gradio-Benutzeroberfläche, damit jeder ein Bild oder Video hochladen, eine Textanweisung eingeben und das Ergebnis runterladen kann.

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)

Die Gradio-App macht die SAM3-Masking- und Unschärfe-Pipeline in einer einfachen Web-Benutzeroberfläche verfügbar, indem sie Folgendes nutzt:

• App shell (gr.Blocks): Dieser Block erstellt eine einseitige Gradio-App mit einem Titel und zwei Registerkarten, eine für Bilder und eine für Videos, sodass die Benutzer den Modus wechseln können, ohne die Seite zu verlassen.
• Bildregisterkarte „ “: Zu den Eingaben gehören ein Bild-Uploader, ein Textfeld für die Texteingabeaufforderung und Schieberegler für die Unschärfestärke und die Zuverlässigkeit. Die Ausgabefelder zeigen eine bearbeitete Vorschau und eine herunterladbare PNG-Datei, während die Schaltfläche„ Blur Image“ alles an process_image weiterleitet, das SAM3 für Masken aufruft und nur auf maskierte Pixel einen Gaußschen Weichzeichner anwendet.
• Video-Tab „ “: Für die Videoverwischung gibt's einen Video-Uploader, ein Textfeld für die Texteingabe, Schieberegler für die Verwischungsstärke und die Zuverlässigkeit sowie eine Obergrenze für die maximale Anzahl an Frames für schnelle Demos. Die Ausgabefelder bieten eine Inline-Vorschau und eine MP4-Datei zum Herunterladen, während die Schaltfläche„ Blur Video“ (Verschwommenes Video erstellen) die Funktion „ process_video “ (Verschwommenes Video erstellen) aufruft, die Frames iteriert, um Masken vorherzusagen, maskierte Bereiche zu verwischen und ein „ H.264 “-Video zu codieren.
• starten: Die Methode „ demo.launch() “ startet die App, macht einen Link, den man teilen kann, und zeigt detaillierte Stapelverfolgungen an, wenn das Debuggen aktiviert ist.

Jetzt ist unser SAM3-Datenschutzfilter bereit, Medien (Bilder/Videos) hochzuladen, Eingabeaufforderungen und Schwellenwerte festzulegen und die unscharf gemachten Ergebnisse zu exportieren.

Anmerkung: Alle Bilder und Videos in dieser Demo kommen von Pexels.com und können kostenlos genutzt werden.