Tutorial SAM3 (Segment Everything Model 3): Membangun Filter Privasi

SAM 3 adalah model baru Meta “segment anything” yang dapat menemukan setiap instance suatu konsep melalui prompt teks singkat atau contoh, lalu mengembalikan mask piksel-akurasi pada gambar dan video. Ini membuatnya sangat cocok untuk tugas privasi praktis seperti mengaburkan wajah, plat nomor, atau layar tanpa menggambar seleksi secara manual atau menulis detektor klasik.

Dalam tutorial ini, kita akan membangun SAM3 Privacy Filter di Colab menggunakan UI Gradio. Cukup unggah gambar atau video, ketikkan prompt (misalnya faces, license plates), dan SAM3 akan mengembalikan mask per-instance sehingga kita dapat mengaburkan hanya piksel tersebut. Kita akan membahas penyiapan, pembuatan mask, penerapan Gaussian blur, dan menyambungkan aplikasi Gradio untuk mengekspor file akhir.

Apa itu SAM3?

Segment Anything Model 3 (SAM 3) adalah model terpadu Meta untuk deteksi, segmentasi, dan pelacakan open-vocabulary pada gambar dan video. Alih-alih mengonfigurasi detektor terpisah untuk setiap kelas, Anda dapat memberi prompt dengan frasa singkat atau contoh, dan SAM 3 mengembalikan mask per-instance.

Di balik layar, SAM 3 menggabungkan encoder teks dan encoder gambar dengan detektor bergaya DETR serta pelacak turunan SAM-2 dengan memory bank. Pada setiap frame, model mendeteksi mask untuk konsep dari prompt, mempropagasi mask ke depan melalui pelacak, dan menggabungkan mask yang baru terdeteksi dan terlacak ke output final untuk frame tersebut. 

Sumber: GitHub SAM3

SAM 3 dirilis dengan bobot model, kode fine-tuning, dan data evaluasi, termasuk tolok ukur SA-Co untuk segmentasi konsep yang dapat diprompt. 

Dalam laporan Meta, model ini menunjukkan peningkatan ~2x dibanding baseline kuat pada segmentasi open-vocabulary di gambar dan video, sekaligus mempertahankan kekuatan interaktif SAM-2. 

Dalam tutorial ini, kita akan mengambil mask SAM 3 tersebut dan mengubahnya menjadi komposit dengan Gaussian blur untuk gambar maupun video, dibungkus dalam UI Gradio. 

Contoh SAM3: Membangun Filter Privasi untuk Gambar dan Video

Pada bagian ini, kita akan membangun filter privasi dengan SAM3 untuk gambar dan video yang ditanamkan dalam UI Gradio sederhana.

Cara kerjanya sebagai berikut:

• Mulai dengan mengetik target, misalnya faces, license plates, computer screens, dll.
• SAM3 melakukan segmentasi instance yang cocok dengan prompt teks Anda dan mengembalikan mask per-objek
• Kita kemudian melakukan union mask-mask tersebut dan hanya mengaburkan piksel yang termask
• Lalu kita gunakan komponen UI Gradio untuk mengunggah gambar atau video, menyesuaikan kekuatan blur dan confidence, kemudian pratinjau dan unduh hasilnya.

Kita akan menelusuri implementasi lengkapnya dalam langkah-langkah kecil.

Langkah 1:  Instal dependensi

Sebelum menjalankan demo ini, pastikan semua prasyarat sudah siap. Untuk menjalankan SAM3 Privacy Filter di Colab, Anda memerlukan pustaka Transformers terbaru beserta beberapa pustaka runtime untuk UI, operasi tensor, gambar, dan I/O video. Cuplikan di bawah menginstal semuanya sekaligus.

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)Didukung oleh

Berikut fungsi setiap prasyarat:

• git+https://github.com/huggingface/transformers.git: Mengambil pustaka Transformers terbaru dari sumber, sehingga kelas Sam3Processor dan Sam3Model tersedia.
• torch dan torchvision: Utilitas komputasi tensor dan gambar yang menjalankan forward pass SAM3
• accelerate: Helper inferensi yang digunakan oleh Transformers.
• gradio: UI web ringan untuk mengunggah media dan meninjau hasil blur.
• numpy, pillow: Menyediakan array gambar dan operasi gambar PIL untuk komposisi mask/blur.
• imageio[ffmpeg]: Membaca/menulis video dan menyandikan MP4 (FFmpeg) untuk tab video.

Setelah lingkungan siap dan facebook/sam3 dimuat, demo memungkinkan Anda melakukan segmentasi dengan prompt teks singkat dan mengaburkan mask hasilnya pada gambar atau video melalui aplikasi Gradio sederhana. 

Catatan: Jika Anda berencana menggunakan GPU di Colab, atur runtime ke GPU (T4/A100) sebelum instalasi. Saya menggunakan GPU A100 di Colab untuk pengalaman yang lebih cepat.

Langkah 2:  Impor

Dengan lingkungan yang sudah siap, impor pustaka yang menjalankan UI, inferensi model, penanganan gambar/video, dan pengukuran waktu. Hanya modul-modul ini yang Anda perlukan untuk SAM3 privacy filter.

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

Sekarang, Gradio menyediakan antarmuka web, pustaka transformers menjalankan SAM3, dan PyTorch mengeksekusi inferensi di GPU atau CPU. Sementara itu PIL memuat dan mengedit gambar (termasuk Gaussian blur), NumPy mengelola array mask, dan imageio membaca serta menulis file video.

Selanjutnya, kita akan memuat model dan membangun mesin kecil yang mengubah prompt teks menjadi mask yang dapat Anda kaburkan.

Langkah 3: Muat SAM3 dan Prediksi Mask

Sekarang lingkungan sudah siap, mari bungkus SAM3 ke dalam mesin kecil yang memuat model sekali, menjalankan segmentasi instance berbasis prompt teks sesuai permintaan, dan mengembalikan mask biner yang digunakan untuk pengaburan.

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

Mari pahami bagaimana mesin ini menyatu dalam pipeline:

• Sam3PrivacyEngine.init(): Inisialisator ini memilih perangkat terbaik (CUDA jika tersedia, jika tidak CPU), memuat bobot facebook/sam3 dan Sam3Processor yang berpasangan, lalu memindahkan model ke perangkat pilihan agar inferensi berjalan efisien.
• Sam3PrivacyEngine.predict_masks(): Metode ini membangun input model dari gambar PIL dan prompt teks, menjalankan forward inferensi di bawah torch.no_grad() untuk menghindari overhead gradien, dan memroses keluaran dengan post_process_instance_segmentation menggunakan ambang deteksi dan mask yang diberikan serta ukuran target asli untuk penskalaan yang tepat. Metode ini mengembalikan mask segmentasi per-instance yang dikonversi dari tensor ke array NumPy lalu ke mask PIL “L” (citra grayscale 8-bit (mode "L") di mana setiap piksel bernilai 0–255) untuk komposit.
• engine = Sam3PrivacyEngine(): Baris ini membuat satu instance mesin yang dapat digunakan kembali sehingga model SAM3 dimuat sekali dan dapat dipanggil berulang untuk gambar atau frame video tanpa inisialisasi ulang.

Dengan mesin mandiri ini diinisialisasi, Anda dapat mengubah gambar dan prompt teks apa pun menjadi mask instance. Selanjutnya, kita akan menerapkan blur secara selektif menggunakan mask-mask ini dan menanamkan semuanya ke UI Gradio.

Langkah 4: Logika pengaburan

Pada bagian ini, kita mengambil mask SAM3 dan menerapkan privasi. Hanya area termask yang dikaburkan sementara bagian lain tetap dipertahankan. Kita mulai dengan fungsi Gaussian blur yang dapat digunakan kembali, lalu menghubungkannya ke dua pipeline, satu untuk gambar dan satu untuk video.

Langkah 4.1: Gaussian blur

Helper ini menerima gambar dan satu atau lebih mask PIL "L", menggabungkannya menjadi satu mask komposit, dan menempelkan salinan gambar yang sudah diburamkan hanya pada area di mana mask berwarna putih (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_imageDidukung oleh

Berikut cara kerja fungsi ini:

• Fungsi GaussianBlur() terlebih dahulu membuat versi gambar yang sepenuhnya diburamkan. Sementara itu composite_mask adalah mask “L” (grayscale) yang diinisialisasi hitam (0 = pertahankan asli). 
• Untuk setiap mask SAM3, kita tempelkan ke mask komposit ini sehingga piksel putih (255) terakumulasi pada area yang harus diburamkan. 
• Terakhir, kita menempelkan gambar yang diburamkan di atas gambar asli menggunakan composite_mask, sehingga hanya area putih yang menjadi buram.
• Metode final_image.paste() menggantikan hanya piksel yang termask, membiarkan sisanya utuh untuk fidelitas visual maksimum.

Dengan satu pemanggilan, Anda dapat mengaburkan area apa pun seperti wajah, layar, plat, sambil mempertahankan latar belakang apa adanya.

Langkah 4.2: Pipeline gambar

Sub-langkah ini mencakup alur gambar end-to-end, mulai dari normalisasi input hingga mendapatkan mask dari SAM3, lalu mengaburkan piksel termask, dan akhirnya mengembalikan hasilnya.

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_pathDidukung oleh

Kita menangani gambar dengan pipeline bertahap berikut:

• Pertama, kita mengonversi array NumPy dari Gradio menjadi gambar PIL RGB untuk memastikan pemrosesan konsisten.
• Berikutnya, kita memanggil engine.predict_masks() untuk memperoleh mask instance SAM3 untuk text_prompt yang diberikan.
• Kemudian, kita menerapkan fungsi apply_blur_pure() dengan blur_strength yang dipilih sehingga hanya area termask yang diburamkan.
• Setelah pemrosesan, kita menyimpan hasil sebagai png dan mengembalikan array NumPy serta file yang dapat diunduh.

Dengan alur gambar selesai, kini kita dapat lanjut ke pipeline video.

Langkah 4.3: Pipeline video

Alur video mencerminkan jalur gambar, tetapi melakukan streaming frame demi frame dengan imageio. Untuk setiap frame, kita melakukan segmentasi, mengaburkan area termask, dan menulis ke file MP4 yang disandikan 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, NoneDidukung oleh

Begini cara kita menangani video dengan pipeline berikut:

• Pertama kita membuka file dengan imageio.get_reader(), lalu melakukan iterasi frame, dan membaca FPS dari metadata (default 24 jika tidak ada).
• Berikutnya, untuk setiap frame, kita konversi ke gambar PIL, prediksi mask dengan SAM3 melalui metode engine.predict_masks(), dan kaburkan area termask menggunakan fungsi apply_blur_pure().
• Kemudian, kita menambahkan setiap frame yang sudah diproses ke penulis MP4 yang dikonfigurasi dengan pixelformat='yuv420p' untuk kompatibilitas luas dan macro_block_size=1 agar terhindar dari artefak perataan.
• Setelah pemrosesan, kita sengaja memangkas output dengan berhenti setelah jumlah frame tertentu, yang default-nya 60 frame (~2 detik) agar uji coba Colab tetap cepat dan menghindari timeout.

Dengan alur video ini, Anda dapat mengaburkan area sensitif pada rekaman rapat, cuplikan dashcam, atau rekaman layar menggunakan prompt teks sederhana.

Langkah 5: Inferensi Gradio

Setelah masking dan pengaburan siap, kita akan membungkus semuanya dalam UI Gradio yang ringan agar siapa pun dapat mengunggah gambar atau video, mengetik prompt teks, dan mengunduh outputnya.

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)Didukung oleh

Aplikasi Gradio menanamkan pipeline masking dan pengaburan SAM3 ke UI web sederhana dengan menggunakan:

• Kerangka aplikasi (gr.Blocks): Blok ini membuat aplikasi Gradio satu halaman dengan judul dan dua tab, satu untuk gambar dan satu untuk video, sehingga pengguna dapat beralih mode tanpa meninggalkan halaman.
• Tab gambar: Input mencakup pengunggah gambar, kotak teks untuk prompt teks, dan slider untuk kekuatan blur dan confidence. Bidang output menampilkan pratinjau hasil dan PNG yang dapat diunduh, sementara tombol Blur Image mengarahkan semuanya ke process_image, yang memanggil SAM3 untuk mask dan menerapkan Gaussian blur hanya pada piksel yang termask.
• Tab video: Untuk pengaburan video, input mencakup pengunggah video, kotak teks untuk prompt teks, slider untuk kekuatan blur dan confidence, serta batas maksimum frame untuk demo cepat. Bidang output menyediakan pratinjau inline dan MP4 yang dapat diunduh, sementara tombol Blur Video memanggil process_video, mengiterasi frame untuk memprediksi mask, mengaburkan area termask, dan menyandikan video H.264.
• Peluncuran: Metode demo.launch() menjalankan aplikasi, menghasilkan tautan yang dapat dibagikan, dan menampilkan stack trace terperinci saat debugging diaktifkan.

Kini, SAM3 Privacy Filter kita siap untuk mengunggah media (gambar/video), menetapkan prompt dan ambang, serta mengekspor output yang diburamkan.

Catatan: Semua gambar dan video dalam demo ini bersumber dari Pexels.com dan bebas digunakan.