SAM3 Eğitimi (Segment Everything Model 3): Gizlilik Filtresi Oluşturun

SAM 3, kısa metin istemleri veya örnekler aracılığıyla bir kavramın tüm örneklerini bulabilen ve görüntü ile video genelinde piksel hassasiyetinde maskeler döndürebilen Meta’nın yeni “segment anything” modelidir. Bu, seçimleri elle çizmeden veya klasik algılayıcılar yazmadan yüzleri, plakaları veya ekranları bulanıklaştırma gibi pratik gizlilik görevleri için onu mükemmel kılar.

Bu öğreticide, SAM3 Gizlilik Filtresini bir Gradio arayüzü kullanarak Colab’de oluşturacağız. Bir görsel veya video yükleyin, bir istem yazın (ör. yüzler, plakalar) ve SAM3 yalnızca bu pikselleri bulanıklaştırabilmemiz için örnek maskeler döndürsün. Kurulum, maske üretimi, Gauss bulanıklığı uygulama ve nihai dosyaları dışa aktarmak için Gradio uygulamasını bağlama adımlarını birlikte inceleyeceğiz.

SAM3 nedir?

Segment Anything Model 3 (SAM 3), görüntü ve videoda açık sözlük algılama, segmentasyon ve izleme için Meta’nın birleştirilmiş modelidir. Her sınıf için ayrı algılayıcılar yapılandırmak yerine, kısa ifadeler veya örneklerle istem verebilir, SAM 3 ise örnek başına maskeler döndürür.

Alt yapıda, SAM 3 bir metin kodlayıcıyı ve görüntü kodlayıcıyı, DETR tarzı bir algılayıcı ve bellek bankalı SAM-2 türevi bir izleyiciyle birleştirir. Her karede, istemden kavramınıza ait maskeleri tespit eder, izleyici aracılığıyla maskeleri ileriye taşır ve yeni tespit edilen ve izlenen maskeleri o kare için nihai çıktıda birleştirir. 

Kaynak: SAM3 GitHub

SAM 3; model ağırlıkları, ince ayar kodu ve değerlendirme verileriyle birlikte yayımlandı; buna, istemle yönlendirilebilen kavram segmentasyonu için SA-Co kıyaslaması da dahildir. 

Meta’nın raporlarında, görüntü ve videoda açık sözlük segmentasyonunda güçlü taban çizgilerine göre ~2x kazanım gösterirken, SAM-2’nin etkileşimli güçlü yanlarını da koruduğu belirtilir. 

Bu öğreticide, SAM 3 maskelerini hem görüntüler hem videolar için Gauss bulanıklığı uygulanmış bir kompozite dönüştürecek ve tümünü bir Gradio arayüzüne sarmalayacağız. 

SAM3 Örneği: Görüntü ve Videolar için Gizlilik Filtresi Oluşturma

Bu bölümde, basit bir Gradio arayüzüne gömülü görüntü ve videolar için SAM3 ile bir gizlilik filtresi oluşturacağız.

Nasıl çalıştığı şöyle:

• Önce hedefi yazın: örneğin yüzler, plakalar, bilgisayar ekranları vb.
• SAM3, metin isteminizle eşleşen örnekleri segmente eder ve nesne başına maskeler döndürür.
• Sonra bu maskeleri birleştirir ve yalnızca maskelenen pikselleri bulanıklaştırırız.
• Ardından Gradio bileşenini kullanarak bir görsel veya video yükler, bulanıklık gücü ve güveni ayarlar, sonuçları önizleyip indiririz.

Tam uygulamayı küçük adımlarla birlikte ele alacağız.

Adım 1:  Bağımlılıkları kurun

Bu demoyu çalıştırmadan önce tüm önkoşulların hazır olduğundan emin olalım. Colab’de SAM3 Gizlilik Filtresi’ni çalıştırmak için en güncel Transformers kütüphanesine ve arayüz, tensör işlemleri, görüntü ve video G/Ç için birkaç çalışma zamanı kütüphanesine ihtiyacınız var. Aşağıdaki parça her şeyi tek seferde kurar.

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)Altyapı:

Her önkoşulun yaptığı şey şudur:

• git+https://github.com/huggingface/transformers.git: Sam3Processor ve Sam3Model sınıfları kullanılabilir olsun diye en güncel Transformers kütüphanesini kaynaktan çeker.
• torch ve torchvision: SAM3 ileri geçişini çalıştıran tensör hesaplama ve görüntü yardımcılarıdır.
• accelerate: Transformers tarafından kullanılan çıkarım yardımcısıdır.
• gradio: Medya yüklemek ve bulanık sonuçları önizlemek için hafif bir web arayüzüdür.
• numpy, pillow: Maske/bulanıklık kompoziti için görüntü dizileri ve PIL görüntü işlemlerini içerir.
• imageio[ffmpeg]: Videoları okur/yazar ve video sekmesi için MP4’ü (FFmpeg) kodlar.

Ortam kurulduktan ve facebook/sam3 yüklendikten sonra, demo kısa metin istemleriyle segmentasyon yapmanıza ve ortaya çıkan maskeleri basit bir Gradio uygulaması üzerinden görüntüler veya videolarda bulanıklaştırmanıza olanak tanır. 

Not: Colab’de GPU kullanmayı planlıyorsanız, kuruluma başlamadan önce çalışma zamanını GPU’ya (T4/A100) ayarlayın. Daha hızlı bir deneyim için Colab’de A100 GPU kullandım.

Adım 2:  İçe aktarımlar

Ortam hazır olduğuna göre, arayüzü, model çıkarımını, görüntü/video işlemesini ve zamanlamayı sağlayan kütüphaneleri içe aktarın. SAM3 gizlilik filtresi için ihtiyaç duyduğunuz tek modüller bunlardır.

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

Artık Gradio web arayüzünü sağlar, transformers kütüphanesi SAM3’ü çalıştırır ve PyTorch çıkarımı GPU veya CPU’da yürütür. PIL görüntüleri (Gauss bulanıklığı dahil) yükleyip düzenlerken, NumPy maske dizilerini yönetir ve imageio video dosyalarını okur/yazar.

Sırada modeli yükleyip metin istemlerini bulanıklaştırabileceğiniz maskelere dönüştüren küçük bir motor inşa edeceğiz.

Adım 3: SAM3’ü yükleyin ve maskeleri tahmin edin

Ortam hazır olduğuna göre, SAM3’ü modeli bir kez yükleyen, talep üzerine metin istemli örnek segmentasyonu çalıştıran ve bulanıklaştırmada kullanılan ikili maskeleri döndüren küçük bir motor içine saralım.

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()Altyapı:

Bu motorun boru hattına nasıl oturduğunu anlayalım:

• Sam3PrivacyEngine.init(): Bu başlatıcı en iyi aygıtı (varsa CUDA, yoksa CPU) seçer, facebook/sam3 ağırlıklarını ve eşleştirilmiş Sam3Processor’ı yükler ve çıkarım verimli çalışsın diye modeli seçilen aygıta taşır.
• Sam3PrivacyEngine.predict_masks(): Bu yöntem bir PIL görüntü ve metin isteminden model girdilerini oluşturur, gradyan yükünü önlemek için torch.no_grad() altında ileri çıkarımı çalıştırır ve çıktıları post_process_instance_segmentation ile belirlenen algılama ve maske eşiklerini, ayrıca doğru ölçekleme için orijinal hedef boyutlarını kullanarak art işlemden geçirir. Çıktı, tensörlerden NumPy dizilerine ve ardından PIL “L” maskelerine (8 bit gri tonlamalı görüntüler, mod "L"; her piksel 0–255 arası değer) dönüştürülen örnek başına segmentasyon maskeleri olarak döner.
• engine = Sam3PrivacyEngine(): Bu satır, SAM3 modelinin bir kez yüklenip yeniden başlatmaya gerek kalmadan görüntüler veya video kareleri için defalarca çağrılabilmesini sağlayan tek, yeniden kullanılabilir bir motor örneği oluşturur.

Bu kendi içinde yeterli motor başlatıldıktan sonra, herhangi bir görüntü ve metin istemini örnek maskelere dönüştürebilirsiniz. Sırada bu maskeleri kullanarak seçici bulanıklaştırma uygulamak ve her şeyi Gradio arayüzüne gömmek var.

Adım 4: Bulanıklaştırma mantığı

Bu bölümde, SAM3’ün maskelerini kullanarak gizlilik uygularız. Yalnızca maskelenmiş bölgeler bulanıklaştırılır, geri kalan her şey korunur. Yeniden kullanılabilir bir Gauss bulanıklığı işleviyle başlıyor, ardından bunu görüntüler ve videolar için iki boru hattına bağlıyoruz.

Adım 4.1: Gauss bulanıklığı

Bu yardımcı, bir görüntüyü ve bir veya daha fazla PIL "L" maskesini alır, bunları tek bir birleşik maskede harmanlar ve görüntünün yalnızca maskenin beyaz (255) olduğu yerlerine bulanık bir kopyasını yapıştırır. 

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_imageAltyapı:

Bu işlev şöyle çalışır:

• GaussianBlur() önce görüntünün tamamen bulanık bir sürümünü oluşturur. composite_mask ise siyah (0 = orijinali koru) ile başlatılmış bir “L” (gri tonlamalı) maskedir. 
• Her SAM3 maskesi için bunu birleşik maskeye yapıştırırız; böylece beyaz piksellerin (255) biriktiği yerler bulanıklaştırma uygulanacak alanlar olur. 
• Son olarak, composite_mask kullanarak bulanık görüntüyü orijinalin üzerine yapıştırırız; böylece yalnızca beyaz bölgeler bulanıklaşır.
• final_image.paste() yöntemi yalnızca maskelenen pikselleri değiştirir, geri kalanını maksimum görsel sadakat için olduğu gibi bırakır.

Tek bir çağrıyla, yüzler, ekranlar, plakalar gibi herhangi bir bölge setini bulanıklaştırabilir, arka planları ise olduğu gibi tutabilirsiniz.

Adım 4.2: Görüntü boru hattı

Bu alt adım, girdinin normalleştirilmesinden SAM3’ten maskelerin alınmasına, ardından maskelenen piksellerin bulanıklaştırılmasına ve nihai sonucun döndürülmesine kadar uçtan uca görüntü akışını kapsar.

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_pathAltyapı:

Görüntüleri şu adım adım boru hattıyla işleriz:

• Önce tutarlı işleme için herhangi bir Gradio NumPy dizisini bir PIL RGB görüntüsüne dönüştürürüz.
• Ardından, verilen text_prompt için SAM3 örnek maskelerini almak üzere engine.predict_masks() çağrısı yaparız.
• Sonrasında, yalnızca maskelenen bölgeler bulanıklaşsın diye seçilen blur_strength ile apply_blur_pure() işlevini uygularız.
• İşlemeden sonra sonucu bir png olarak kaydeder ve hem bir NumPy dizisi hem indirilebilir bir dosya döndürürüz.

Görüntü akışı tamamlandığına göre şimdi video boru hattına geçebiliriz.

Adım 4.3: Video boru hattı

Video akışı, görüntü yolunun bir yansımasıdır, ancak imageio ile kare kare akar. Her kare için segmentasyon yapar, maskelenen bölgeleri bulanıklaştırır ve H.264 kodlu bir MP4 dosyasına yazarız.

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, NoneAltyapı:

Videoları şu boru hattıyla ele alırız:

• imageio.get_reader() ile dosyayı açar, kareleri yineleyip meta verilerden FPS’yi okuruz (yoksa varsayılan 24).
• Sonra, her kareyi bir PIL görüntüsüne çevirir, engine.predict_masks() yöntemiyle SAM3’ten maskeleri tahmin eder ve apply_blur_pure() ile maskelenen bölgeleri bulanıklaştırırız.
• Ardından, geniş uyumluluk için pixelformat='yuv420p' ve hizalama yapaylıklarını önlemek için macro_block_size=1 ile yapılandırılmış bir MP4 yazıcısına her işlenmiş kareyi ekleriz.
• İşlemeden sonra, Colab testlerini seri ve zaman aşımından uzak tutmak için varsayılan olarak 60 karede (~2 saniye) durarak çıktıyı kasten budarız.

Bu video akışıyla, toplantı kayıtları, araç kamerası klipleri veya ekran yakalamalarında yalnızca bir metin istemiyle hassas bölgeleri bulanıklaştırabilirsiniz.

Adım 5: Gradio çıkarımı

Maskelenme ve bulanıklaştırma hazır olduğuna göre, herkesin bir görüntü veya video yükleyebileceği, bir metin istemi yazabileceği ve çıktıyı indirebileceği hafif bir Gradio arayüzüne her şeyi sarmalayacağız.

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)Altyapı:

Gradio uygulaması, SAM3 maskeleme ve bulanıklaştırma boru hattını şu şekilde basit bir web arayüzüne gömer:

• Uygulama kabuğu (gr.Blocks): Bu blok, başlıklı tek sayfalık bir Gradio uygulaması ve kullanıcıların sayfadan ayrılmadan modlar arasında geçiş yapabilmesi için biri görüntüler, diğeri videolar için iki sekme oluşturur.
• Görüntü sekmesi: Girdiler arasında bir görüntü yükleyici, metin istemi için bir metin kutusu ve bulanıklık gücü ile güven için kaydırıcılar yer alır. Çıktı alanları işlenmiş bir önizleme ve indirilebilir bir PNG gösterirken, Görüntüyü Bulanıklaştır düğmesi her şeyi, maskeler için SAM3’ü çağıran ve yalnızca maskelenen piksellerde Gauss bulanıklığı uygulayan process_image’e yönlendirir.
• Video sekmesi: Video bulanıklaştırma için girdiler; bir video yükleyici, metin istemi için bir metin kutusu, bulanıklık gücü ve güven için kaydırıcılar ve hızlı demolar için bir azami kare sınırı içerir. Çıktı alanları satır içi önizleme ve indirilebilir bir MP4 sunarken, Videoyu Bulanıklaştır düğmesi process_video’yu çağırarak kareleri yineleyip maskeleri tahmin eder, maskelenen bölgeleri bulanıklaştırır ve bir H.264 video kodlar.
• Başlatma: demo.launch() yöntemi uygulamayı başlatır, paylaşılabilir bir bağlantı üretir ve hata ayıklama etkinleştirildiğinde ayrıntılı yığın izlerini görünür kılar.

Artık SAM3 Gizlilik Filtremiz medya (görüntü/video) yüklemeye, istemi ve eşikleri ayarlamaya ve bulanıklaştırılmış çıktıları dışa aktarmaya hazır.

Not: Bu demodaki tüm görseller ve videolar Pexels.com’dan alınmıştır ve kullanımı ücretsizdir.