Hướng dẫn SAM3 (Segment Everything Model 3): Xây dựng bộ lọc quyền riêng tư

SAM 3 là mô hình “segment anything” mới của Meta, có thể tìm mọi thể hiện của một khái niệm thông qua lời nhắc văn bản ngắn hoặc ví dụ và trả về các mặt nạ chính xác từng điểm ảnh trên ảnh và video. Điều này khiến nó rất phù hợp cho các tác vụ bảo mật riêng tư thực tế như làm mờ khuôn mặt, biển số, hoặc màn hình mà không cần vẽ tay vùng chọn hay viết bộ dò cổ điển.

Trong hướng dẫn này, chúng ta sẽ xây dựng một Bộ lọc quyền riêng tư SAM3 trên Colab bằng giao diện Gradio. Chỉ cần tải lên ảnh hoặc video, nhập lời nhắc (như faces, license plates), và SAM3 sẽ trả về các mặt nạ theo từng đối tượng để chúng ta chỉ làm mờ những điểm ảnh đó. Chúng ta sẽ đi qua các bước thiết lập, tạo mặt nạ, áp dụng Gaussian blur và kết nối ứng dụng Gradio để xuất tệp cuối cùng.

SAM3 là gì?

Segment Anything Model 3 (SAM 3) là mô hình hợp nhất của Meta dành cho phát hiện, phân đoạn và theo dõi với từ vựng mở trên ảnh và video. Thay vì cấu hình các bộ dò riêng cho từng lớp, bạn có thể nhắc bằng cụm từ ngắn hoặc mẫu ví dụ, và SAM 3 trả về mặt nạ theo từng thể hiện.

Bên dưới, SAM 3 kết hợp bộ mã hóa văn bản và bộ mã hóa ảnh với bộ dò kiểu DETR và bộ theo dõi dẫn xuất từ SAM-2 có ngân hàng bộ nhớ. Ở mỗi khung hình, nó phát hiện các mặt nạ cho khái niệm từ lời nhắc, lan truyền mặt nạ về phía trước qua bộ theo dõi, và trộn các mặt nạ mới phát hiện và đã theo dõi vào đầu ra cuối cùng cho khung đó. 

Nguồn: SAM3 GitHub

SAM 3 được phát hành kèm trọng số mô hình, mã fine-tune và dữ liệu đánh giá, bao gồm benchmark SA-Co cho phân đoạn khái niệm theo lời nhắc. 

Trong các báo cáo của Meta, nó cho thấy mức tăng ~2x so với các đường cơ sở mạnh trên phân đoạn từ vựng mở trong ảnh và video, đồng thời vẫn giữ điểm mạnh tương tác của SAM-2. 

Trong hướng dẫn này, chúng ta sẽ lấy các mặt nạ của SAM 3 và biến chúng thành bản tổng hợp làm mờ Gaussian cho cả ảnh và video, gói trong giao diện Gradio. 

Ví dụ SAM3: Xây dựng bộ lọc quyền riêng tư cho ảnh và video

Trong phần này, chúng ta sẽ xây dựng bộ lọc quyền riêng tư với SAM3 cho ảnh và video tích hợp trong giao diện Gradio đơn giản.

Cách hoạt động như sau:

• Bắt đầu bằng cách nhập mục tiêu, ví dụ: faces, license plates, computer screens, v.v.
• SAM3 phân đoạn các thể hiện khớp với lời nhắc văn bản của bạn và trả về mặt nạ cho từng đối tượng
• Sau đó chúng ta hợp nhất các mặt nạ đó và chỉ làm mờ các điểm ảnh được che
• Tiếp theo, dùng thành phần UI của Gradio để tải ảnh hoặc video, điều chỉnh độ mạnh làm mờ và độ tin cậy, rồi xem trước và tải kết quả.

Chúng ta sẽ đi qua toàn bộ triển khai theo từng bước nhỏ.

Bước 1: Cài đặt phụ thuộc

Trước khi chạy bản demo này, hãy đảm bảo bạn đã có đủ các điều kiện tiên quyết. Để chạy Bộ lọc quyền riêng tư SAM3 trên Colab, bạn cần thư viện Transformers mới nhất cùng một vài thư viện runtime cho UI, phép toán tensor, ảnh và I/O video. Đoạn mã dưới đây cài đặt tất cả trong một lần.

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)Được hỗ trợ bởi

Vai trò của từng thành phần tiên quyết:

• git+https://github.com/huggingface/transformers.git: Tải thư viện Transformers mới nhất từ mã nguồn, để các lớp Sam3Processor và Sam3Model sẵn dùng.
• torch và torchvision: Là công cụ tính toán tensor và tiện ích ảnh để chạy forward pass của SAM3
• accelerate: Trình hỗ trợ suy luận được Transformers sử dụng.
• gradio: Giao diện web gọn nhẹ để tải media và xem trước kết quả làm mờ.
• numpy, pillow: Cung cấp mảng ảnh và các thao tác ảnh PIL cho việc hợp thành mặt nạ/làm mờ.
• imageio[ffmpeg]: Đọc/ghi video và mã hóa MP4 (FFmpeg) cho thẻ video.

Khi môi trường đã sẵn sàng và facebook/sam3 được nạp, bản demo cho phép bạn phân đoạn bằng lời nhắc văn bản ngắn và làm mờ các mặt nạ kết quả trong ảnh hoặc video qua ứng dụng Gradio đơn giản. 

Lưu ý: Nếu bạn định dùng GPU trên Colab, hãy đặt runtime sang GPU (T4/A100) trước khi cài đặt. Tôi dùng GPU A100 trên Colab để có trải nghiệm nhanh hơn.

Bước 2: Import

Khi môi trường đã sẵn sàng, hãy import các thư viện cung cấp UI, suy luận mô hình, xử lý ảnh/video và đo thời gian. Đây là các mô-đun duy nhất bạn cần cho bộ lọc quyền riêng tư 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Được hỗ trợ bởi

Bây giờ, Gradio cung cấp giao diện web, thư viện transformers chạy SAM3, và PyTorch thực thi suy luận trên GPU hoặc CPU. Trong khi PIL tải và chỉnh sửa ảnh (bao gồm Gaussian blur), NumPy quản lý các mảng mặt nạ, và imageio đọc/ghi tệp video.

Tiếp theo, chúng ta sẽ nạp mô hình và xây dựng một engine nhỏ chuyển lời nhắc văn bản thành các mặt nạ để bạn làm mờ.

Bước 3: Nạp SAM3 và dự đoán mặt nạ

Khi môi trường đã sẵn sàng, hãy đóng gói SAM3 vào một engine nhỏ nạp mô hình một lần, chạy phân đoạn theo thể hiện dựa trên lời nhắc văn bản khi cần, và trả về các mặt nạ nhị phân dùng để làm 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()Được hỗ trợ bởi

Hãy cùng hiểu engine này khớp vào pipeline như thế nào:

• Sam3PrivacyEngine.init(): Trình khởi tạo này chọn thiết bị tốt nhất (CUDA nếu có, nếu không thì CPU), nạp trọng số facebook/sam3 và Sam3Processor đi kèm, và chuyển mô hình sang thiết bị đã chọn để suy luận chạy hiệu quả.
• Sam3PrivacyEngine.predict_masks(): Phương thức này tạo đầu vào mô hình từ ảnh PIL và lời nhắc văn bản, chạy forward dưới torch.no_grad() để tránh chi phí gradient, và hậu xử lý đầu ra bằng post_process_instance_segmentation với ngưỡng phát hiện và mặt nạ đã cho, cũng như kích thước mục tiêu gốc để scale chính xác. Nó trả về các mặt nạ phân đoạn theo từng thể hiện được chuyển từ tensor sang mảng NumPy rồi sang mặt nạ PIL “L” (ảnh thang xám 8-bit, chế độ "L") nơi mỗi điểm ảnh có giá trị từ 0–255) để hợp thành.
• engine = Sam3PrivacyEngine(): Dòng này tạo một thể hiện engine có thể tái sử dụng để mô hình SAM3 chỉ nạp một lần và có thể được gọi lặp lại cho ảnh hoặc khung hình video mà không cần khởi tạo lại.

Với engine độc lập này đã khởi tạo, bạn có thể chuyển bất kỳ ảnh và lời nhắc văn bản nào thành các mặt nạ theo thể hiện. Tiếp theo, chúng ta sẽ áp dụng làm mờ có chọn lọc bằng các mặt nạ này và nhúng tất cả vào giao diện Gradio.

Bước 4: Logic làm mờ

Trong phần này, chúng ta lấy các mặt nạ của SAM3 và áp dụng bảo vệ riêng tư. Nó chỉ làm mờ các vùng được che, giữ nguyên phần còn lại. Chúng ta bắt đầu với hàm làm mờ Gaussian có thể tái sử dụng, rồi kết nối vào hai pipeline: một cho ảnh, một cho video.

Bước 4.1: Gaussian blur

Trình trợ giúp này nhận một ảnh và một hoặc nhiều mặt nạ PIL "L", trộn chúng thành một mặt nạ tổng hợp duy nhất, và dán một bản sao ảnh đã làm mờ chỉ tại nơi mặt nạ có màu trắng (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Được hỗ trợ bởi

Cách hàm này hoạt động:

• Hàm GaussianBlur() trước tiên tạo một bản làm mờ hoàn toàn của ảnh. Trong khi composite_mask là mặt nạ “L” (thang xám) khởi tạo màu đen (0 = giữ nguyên bản gốc). 
• Với mỗi mặt nạ SAM3, chúng ta dán nó vào mặt nạ tổng hợp để các điểm ảnh màu trắng (255) tích lũy nơi cần hiển thị làm mờ. 
• Cuối cùng, chúng ta dán ảnh đã làm mờ lên ảnh gốc bằng composite_mask, nên chỉ các vùng màu trắng mới bị làm mờ.
• Phương thức final_image.paste() chỉ thay thế các điểm ảnh được che, phần còn lại giữ nguyên để đảm bảo độ trung thực hình ảnh tối đa.

Chỉ với một lần gọi, bạn có thể làm mờ bất kỳ tập vùng nào như khuôn mặt, màn hình, biển số, trong khi giữ nền như cũ.

Bước 4.2: Pipeline ảnh

Tiểu bước này bao quát luồng ảnh đầu-cuối, từ chuẩn hóa đầu vào đến lấy mặt nạ từ SAM3, sau đó làm mờ các điểm ảnh được che, và cuối cùng trả về kết quả.

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Được hỗ trợ bởi

Chúng ta xử lý ảnh với pipeline tuần tự sau:

• Trước tiên, chuyển mọi mảng NumPy từ Gradio thành ảnh PIL RGB để đảm bảo xử lý nhất quán.
• Tiếp theo, gọi engine.predict_masks() để lấy các mặt nạ SAM3 cho text_prompt đã cung cấp.
• Sau đó áp dụng hàm apply_blur_pure() với blur_strength đã chọn để chỉ làm mờ các vùng được che.
• Sau khi xử lý, lưu kết quả thành png và trả về cả mảng NumPy lẫn tệp có thể tải xuống.

Khi luồng xử lý ảnh đã hoàn tất, chúng ta chuyển sang pipeline video.

Bước 4.3: Pipeline video

Luồng video phản chiếu đường đi của ảnh, nhưng phát theo từng khung bằng imageio. Với mỗi khung, chúng ta phân đoạn, làm mờ vùng được che, và ghi ra tệp MP4 mã hóa 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Được hỗ trợ bởi

Chúng ta xử lý video theo pipeline sau:

• Mở tệp bằng imageio.get_reader(), sau đó lặp qua các khung, và đọc FPS từ metadata (mặc định 24 nếu thiếu).
• Với mỗi khung, chuyển thành ảnh PIL, dự đoán mặt nạ với SAM3 qua phương thức engine.predict_masks(), và làm mờ các vùng được che bằng hàm apply_blur_pure().
• Ghép từng khung đã xử lý vào trình ghi MP4 cấu hình pixelformat='yuv420p' để tương thích rộng rãi và macro_block_size=1 để tránh lỗi căn chỉnh.
• Sau khi xử lý, chúng ta chủ động cắt ngắn đầu ra bằng cách dừng sau một số khung nhất định, mặc định 60 khung (~2 giây) để thử nghiệm trên Colab nhanh và tránh timeout.

Với luồng video này, bạn có thể làm mờ vùng nhạy cảm trong bản ghi họp, clip camera hành trình, hoặc quay màn hình chỉ với một lời nhắc văn bản.

Bước 5: Suy luận với Gradio

Khi đã có mặt nạ và làm mờ, chúng ta sẽ bọc tất cả trong giao diện Gradio gọn nhẹ để bất kỳ ai cũng có thể tải ảnh hoặc video, nhập lời nhắc văn bản và tải đầu ra.

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)Được hỗ trợ bởi

Ứng dụng Gradio nhúng pipeline tạo mặt nạ và làm mờ của SAM3 vào UI web đơn giản bằng cách dùng:

• Khung ứng dụng (gr.Blocks): Tạo một ứng dụng Gradio một trang với tiêu đề và hai thẻ, một cho ảnh và một cho video, để người dùng chuyển chế độ mà không rời trang.
• Thẻ Ảnh: Đầu vào gồm bộ tải ảnh, ô nhập lời nhắc văn bản, và các thanh trượt cho độ mạnh làm mờ và độ tin cậy. Trường đầu ra hiển thị bản xem trước đã xử lý và PNG có thể tải xuống, trong khi nút Blur Image dẫn mọi thứ đến process_image, gọi SAM3 để lấy mặt nạ và áp dụng Gaussian blur chỉ trên điểm ảnh được che.
• Thẻ Video: Với làm mờ video, đầu vào gồm bộ tải video, ô nhập lời nhắc văn bản, thanh trượt cho độ mạnh làm mờ và độ tin cậy, và giới hạn số khung tối đa cho demo nhanh. Trường đầu ra cung cấp xem trước nội tuyến và MP4 có thể tải xuống, trong khi nút Blur Video gọi process_video, lặp qua các khung để dự đoán mặt nạ, làm mờ vùng được che, và mã hóa video H.264.
• Khởi chạy: Phương thức demo.launch() khởi động ứng dụng, tạo liên kết có thể chia sẻ, và hiển thị trace chi tiết khi bật gỡ lỗi.

Giờ đây, Bộ lọc quyền riêng tư SAM3 đã sẵn sàng để tải media (ảnh/video), đặt lời nhắc và ngưỡng, và xuất các đầu ra đã làm mờ.

Lưu ý: Tất cả ảnh và video trong bản demo này được lấy từ Pexels.com và được phép sử dụng miễn phí.