สร้างระบบสรุปวิดีโอแบบ Local ด้วย SmolVLM2-2.2B: ประมวลผลบนเครื่องส่วนตัวได้อย่างมีประสิทธิภาพ

# ต้องการ Python 3.10 ขึ้นไป
python --version
 
python -m venv smolvlm2-env
source smolvlm2-env/bin/activate       # macOS / Linux
smolvlm2-env\Scripts\activate          # Windows
 
# ติดตั้งจากสาขาเสถียร SmolVLM-2 -- จำเป็นสำหรับการรองรับ SmolVLM2
pip install git+https://github.com/huggingface/[email protected]
 
# การพึ่งพาหลัก (Core dependencies)
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121
pip install \
  opencv-python \
  Pillow \
  numpy \
  num2words \
  accelerate
 
# Flash Attention 2 สำหรับ CUDA -- เร็วขึ้นอย่างมากบน GPU NVIDIA
# ข้ามขั้นตอนนี้บน Apple Silicon และ CPU -- ใช้ได้เฉพาะ CUDA เท่านั้น
pip install flash-attn --no-build-isolation
 
# decord -- จำเป็นสำหรับเส้นทางการนำเข้าวิดีโอแบบดั้งเดิมของ SmolVLM2
pip install decord

# device_check.py
# รัน: python device_check.py
 
import torch
 
def detect_device():
    if torch.cuda.is_available():
        name  = torch.cuda.get_device_name(0)
        vram  = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"CUDA: {name} ({vram:.1f} GB VRAM)")
        return "cuda", torch.bfloat16, "flash_attention_2"
    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
        print("ตรวจพบ Apple Silicon MPS")
        return "mps", torch.float16, "eager"
    else:
        print("ใช้ CPU (ช้า -- พิจารณาใช้ Colab T4)")
        return "cpu", torch.float32, "eager"
 
if __name__ == "__main__":
    device, dtype, attn = detect_device()
    print(f"อุปกรณ์: {device} | dtype: {dtype} | attn: {attn}")

python device_check.py

# frame_extractor.py
import cv2
import numpy as np
from PIL import Image
 
class FrameExtractor:
    MAX_FRAMES = 50
 
def __init__(self, max_frames: int = MAX_FRAMES):
        self.max_frames = max_frames
 
def uniform_sample(self, video_path: str) -> list[tuple[float, Image.Image]]:
        cap = cv2.VideoCapture(video_path)
        if not cap.isOpened():
            raise IOError(f"ไม่สามารถเปิดวิดีโอได้: {video_path}")
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        fps          = cap.get(cv2.CAP_PROP_FPS) or 30.0
        n_extract    = min(self.max_frames, total_frames)
        indices = np.linspace(0, total_frames - 1, n_extract, dtype=int)
        results = []
        for idx in indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
            ret, frame = cap.read()
            if not ret: continue
            timestamp = round(idx / fps, 2)
            rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            results.append((timestamp, Image.fromarray(rgb)))
        cap.release()
        return results
 
def keyframe_sample(self, video_path: str, diff_threshold: float = 30.0) -> list[tuple[float, Image.Image]]:
        cap = cv2.VideoCapture(video_path)
        fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
        results, prev_gray, idx = [], None, 0
        while len(results) < self.max_frames:
            ret, frame = cap.read()
            if not ret: break
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            if prev_gray is None:
                rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                results.append((round(idx / fps, 2), Image.fromarray(rgb)))
            else:
                diff = np.mean(np.abs(gray.astype(float) - prev_gray.astype(float)))
                if diff > diff_threshold:
                    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    results.append((round(idx / fps, 2), Image.fromarray(rgb)))
            prev_gray = gray
            idx += 1
        cap.release()
        return results

# smolvlm2_loader.py
import sys
import torch
from PIL import Image
from transformers import AutoProcessor, AutoModelForImageTextToText
 
MODEL_ID = "HuggingFaceTB/SmolVLM2-2.2B-Instruct"
 
def load_model():
    # ระบบเลือก device อัตโนมัติ (CUDA/MPS/CPU)
    device = "cuda" if torch.cuda.is_available() else ("mps" if hasattr(torch.backends, "mps") and torch.backends.mps.is_available() else "cpu")
    dtype = torch.bfloat16 if device == "cuda" else (torch.float16 if device == "mps" else torch.float32)
    attn = "flash_attention_2" if device == "cuda" else "eager"
 
processor = AutoProcessor.from_pretrained(MODEL_ID)
    model = AutoModelForImageTextToText.from_pretrained(MODEL_ID, torch_dtype=dtype, _attn_implementation=attn).to(device)
    return model, processor
 
def describe_frame(model, processor, frame, prompt="Describe this frame.", max_new_tokens=256):
    messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": prompt}]}]
    input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
    inputs = processor(images=[frame], text=input_text, return_tensors="pt").to(model.device)
    with torch.no_grad():
        output_ids = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False)
    new_tokens = output_ids[0][inputs["input_ids"].shape[-1]:]
    return processor.decode(new_tokens, skip_special_tokens=True).strip()

# video_summarizer.py จัดการประมวลผลทั้งหมดเป็นขั้นตอน
# (ดูโค้ดการทำงานในส่วน Building the Foundation และ Loader ด้านบน)

# vram_calculator.py
def compute_batch_size(vram_gb: float) -> int:
    MODEL_GB = 4.5
    HEADROOM = 0.8
    MB_PER_TOKEN = 0.5 / 1024
    usable_gb = vram_gb * HEADROOM
    inference_budget = max(0.0, usable_gb - MODEL_GB)
    frames = int(inference_budget / (81 * MB_PER_TOKEN))
    return max(1, min(frames, 50))