🔍 CLIP의 작동 원리: 마법 같지만 과학이야

자, 이제 본격적으로 CLIP이 어떻게 작동하는지 파헤쳐보자! 🕵️ 복잡해 보이지만, 차근차근 따라오면 "아하!" 하는 순간이 올 거야.

CLIP의 핵심은 두 개의 인코더야. 하나는 이미지를 처리하고, 다른 하나는 텍스트를 처리해. 그리고 이 둘이 만들어낸 결과물을 같은 공간(Embedding Space)에 놓는 거지. 마치 서로 다른 언어를 쓰는 사람들이 공통의 언어로 대화하는 것처럼 말이야! 🌐

📸 이미지 인코더: 시각 정보의 번역가

이미지 인코더는 주로 Vision Transformer(ViT)나 ResNet 같은 구조를 사용해. OpenAI의 원본 CLIP은 두 가지 버전을 제공하는데:

1. ResNet 기반 (RN50, RN101 등)
전통적인 CNN 구조로, 이미지를 여러 단계의 합성곱 레이어를 거쳐 처리해. 안정적이고 검증된 방식이지! 🏛️

2. Vision Transformer 기반 (ViT-B/32, ViT-L/14 등)
이미지를 작은 패치로 나눠서 Transformer로 처리하는 최신 방식. 더 강력하지만 계산량이 많아. 💪

어떤 구조를 쓰든, 최종 목표는 같아. 이미지를 고정된 크기의 벡터로 변환하는 거야. 예를 들어, 512차원 벡터로 만들면, 그 벡터가 이미지의 모든 특징을 담고 있는 거지!

📝 텍스트 인코더: 언어의 마법사

텍스트 인코더는 Transformer 구조를 사용해. GPT와 비슷한 구조라고 생각하면 돼! 텍스트를 토큰으로 나누고, 각 토큰의 의미와 문맥을 파악해서 최종적으로 하나의 벡터로 만들어내는 거야. 📚

재미있는 건, CLIP의 텍스트 인코더는 최대 77개의 토큰까지 처리할 수 있어. 그러니까 꽤 긴 문장도 이해할 수 있다는 뜻이지! "A photo of a golden retriever puppy playing with a red ball in a sunny park during autumn"처럼 구체적인 설명도 가능해. 🍂

🎯 대조 학습(Contrastive Learning): 핵심 중의 핵심

자, 이제 가장 중요한 부분이야! CLIP이 어떻게 학습하는지 알아보자. 🎓

상상해봐. 배치(batch) 안에 32개의 이미지-텍스트 쌍이 있어. 각 이미지는 자신과 매칭되는 텍스트가 하나씩 있지. CLIP의 목표는 뭘까?

매칭되는 이미지-텍스트 쌍의 벡터는 가깝게, 매칭되지 않는 쌍의 벡터는 멀게 만드는 거야! 🎯

구체적으로 설명하면:

이 과정을 수식으로 표현하면 InfoNCE Loss를 사용하는데, 간단히 말하면 "정답은 확률을 높이고, 오답은 확률을 낮춰라"는 거야. 마치 객관식 시험에서 정답을 찾는 것처럼! ✅

💻 실전 구현: 코드로 만나는 CLIP

이론은 충분히 배웠으니, 이제 진짜 코드를 작성해보자! 🚀 Python과 PyTorch를 사용할 거야. 걱정 마, 하나하나 설명해줄게!

🔧 환경 설정: 준비운동부터

먼저 필요한 라이브러리들을 설치해야 해. 터미널을 열고 다음 명령어를 입력해봐:

pip install torch torchvision
pip install ftfy regex tqdm
pip install git+https://github.com/openai/CLIP.git

ftfy는 텍스트 정규화를 위한 라이브러리고, regex는 정규표현식, tqdm은 진행 상황 표시를 위한 거야. 마지막 줄은 OpenAI의 공식 CLIP 라이브러리를 설치하는 명령어지! 📦

🎬 기본 사용법: Hello CLIP!

가장 간단한 예제부터 시작해보자. 이미지 하나와 여러 텍스트 중에서 가장 잘 매칭되는 걸 찾는 코드야:

import torch
import clip
from PIL import Image

# 디바이스 설정 (GPU 있으면 GPU, 없으면 CPU)
device = "cuda" if torch.cuda.is_available() else "cpu"

# CLIP 모델 로드
model, preprocess = clip.load("ViT-B/32", device=device)

# 이미지 로드 및 전처리
image = preprocess(Image.open("dog.jpg")).unsqueeze(0).to(device)

# 후보 텍스트들
text_candidates = [
    "a photo of a dog",
    "a photo of a cat", 
    "a photo of a car",
    "a photo of a bird"
]

# 텍스트 토큰화
text = clip.tokenize(text_candidates).to(device)

# 추론 (inference)
with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)
    
    # 유사도 계산
    logits_per_image, logits_per_text = model(image, text)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()

# 결과 출력
print("각 텍스트의 확률:")
for i, candidate in enumerate(text_candidates):
    print(f"{candidate}: {probs[0][i]*100:.2f}%")

이 코드를 실행하면, 각 텍스트가 이미지와 얼마나 잘 매칭되는지 확률로 보여줘! 만약 dog.jpg가 정말 강아지 사진이라면, "a photo of a dog"가 90% 이상의 높은 확률을 보일 거야. 🐕

🔎 이미지 검색 시스템 만들기

이제 좀 더 실용적인 걸 만들어보자! 여러 이미지 중에서 텍스트 쿼리와 가장 잘 맞는 이미지를 찾는 검색 시스템이야. 마치 구글 이미지 검색처럼! 🔍

import os
import torch
import clip
from PIL import Image
import numpy as np

class ImageSearchEngine:
    def __init__(self, model_name="ViT-B/32"):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model, self.preprocess = clip.load(model_name, device=self.device)
        self.image_features = None
        self.image_paths = []
    
    def index_images(self, image_folder):
        """이미지 폴더의 모든 이미지를 인덱싱"""
        print(f"📁 {image_folder}의 이미지들을 인덱싱 중...")
        
        image_files = [f for f in os.listdir(image_folder) 
                      if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
        
        features_list = []
        
        for img_file in image_files:
            img_path = os.path.join(image_folder, img_file)
            image = self.preprocess(Image.open(img_path)).unsqueeze(0).to(self.device)
            
            with torch.no_grad():
                features = self.model.encode_image(image)
                features /= features.norm(dim=-1, keepdim=True)  # 정규화
            
            features_list.append(features)
            self.image_paths.append(img_path)
        
        self.image_features = torch.cat(features_list, dim=0)
        print(f"✅ {len(self.image_paths)}개 이미지 인덱싱 완료!")
    
    def search(self, query, top_k=5):
        """텍스트 쿼리로 이미지 검색"""
        text = clip.tokenize([query]).to(self.device)
        
        with torch.no_grad():
            text_features = self.model.encode_text(text)
            text_features /= text_features.norm(dim=-1, keepdim=True)
        
        # 코사인 유사도 계산
        similarity = (text_features @ self.image_features.T).squeeze(0)
        
        # 상위 k개 결과
        top_indices = similarity.argsort(descending=True)[:top_k]
        
        results = []
        for idx in top_indices:
            results.append({
                'path': self.image_paths[idx],
                'score': similarity[idx].item()
            })
        
        return results

# 사용 예시
if __name__ == "__main__":
    engine = ImageSearchEngine()
    engine.index_images("./my_photos")
    
    query = "a beautiful sunset over the ocean"
    results = engine.search(query, top_k=3)
    
    print(f"\n🔍 검색어: '{query}'")
    print("=" * 50)
    for i, result in enumerate(results, 1):
        print(f"{i}. {result['path']}")
        print(f"   유사도: {result['score']:.4f}")

이 코드는 진짜 실용적이야! 🎉 index_images() 메서드로 이미지들을 미리 인코딩해두고, search() 메서드로 원하는 이미지를 찾을 수 있어. 코사인 유사도를 사용해서 가장 비슷한 이미지를 찾는 거지!

특히 정규화(normalization)가 중요해. 벡터를 정규화하면 코사인 유사도를 내적(dot product)으로 간단히 계산할 수 있거든! 수학적으로 효율적이야. 📐

🎨 제로샷 이미지 분류기

CLIP의 가장 강력한 기능 중 하나가 바로 제로샷 분류(Zero-shot Classification)야! 학습 데이터 없이도 새로운 카테고리를 분류할 수 있어. 어떻게? 텍스트로 카테고리를 설명하면 되거든! 🎯

class ZeroShotClassifier:
    def __init__(self, model_name="ViT-B/32"):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model, self.preprocess = clip.load(model_name, device=self.device)
    
    def classify(self, image_path, categories, template="a photo of a {}"):
        """이미지를 주어진 카테고리로 분류"""
        # 이미지 로드
        image = self.preprocess(Image.open(image_path)).unsqueeze(0).to(self.device)
        
        # 카테고리별 텍스트 생성
        texts = [template.format(cat) for cat in categories]
        text_tokens = clip.tokenize(texts).to(self.device)
        
        # 인코딩
        with torch.no_grad():
            image_features = self.model.encode_image(image)
            text_features = self.model.encode_text(text_tokens)
            
            # 정규화
            image_features /= image_features.norm(dim=-1, keepdim=True)
            text_features /= text_features.norm(dim=-1, keepdim=True)
            
            # 유사도 계산 및 확률 변환
            similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1)
        
        # 결과 정리
        results = []
        for i, category in enumerate(categories):
            results.append({
                'category': category,
                'probability': similarity[0, i].item()
            })
        
        # 확률 순으로 정렬
        results.sort(key=lambda x: x['probability'], reverse=True)
        return results

# 사용 예시
classifier = ZeroShotClassifier()

# 동물 분류
animal_categories = ["dog", "cat", "bird", "fish", "horse", "elephant"]
results = classifier.classify("animal.jpg", animal_categories)

print("🐾 동물 분류 결과:")
for result in results:
    print(f"{result['category']}: {result['probability']*100:.2f}%")

# 감정 분류 (같은 이미지로!)
emotion_categories = ["happy", "sad", "angry", "surprised", "neutral"]
emotion_template = "a {} looking animal"
results = classifier.classify("animal.jpg", emotion_categories, emotion_template)

print("\n😊 감정 분류 결과:")
for result in results:
    print(f"{result['category']}: {result['probability']*100:.2f}%")

이 코드의 멋진 점은 template 파라미터야! 템플릿을 바꾸면 같은 이미지를 다른 관점에서 분류할 수 있어. "a photo of a {}"는 일반적인 분류에 좋고, "a {} looking animal"은 감정 분류에 적합하지. 유연성이 정말 좋아! 🎭

⚡ 성능 최적화: 더 빠르고 효율적으로

CLIP은 강력하지만, 제대로 최적화하지 않으면 느릴 수 있어. 특히 수천, 수만 개의 이미지를 처리할 때는 최적화가 필수야! 🚀 실전에서 쓸 수 있는 팁들을 알려줄게.

🎯 배치 처리로 속도 올리기

이미지를 하나씩 처리하는 건 비효율적이야. GPU는 병렬 처리에 최적화되어 있거든! 여러 이미지를 한 번에 처리하는 배치 처리를 사용하면 속도가 엄청 빨라져. 💨

def batch_encode_images(model, preprocess, image_paths, batch_size=32, device="cuda"):
    """이미지들을 배치로 인코딩"""
    all_features = []
    
    for i in range(0, len(image_paths), batch_size):
        batch_paths = image_paths[i:i+batch_size]
        
        # 배치 이미지 로드
        images = []
        for path in batch_paths:
            image = preprocess(Image.open(path))
            images.append(image)
        
        # 텐서로 변환
        batch_tensor = torch.stack(images).to(device)
        
        # 인코딩
        with torch.no_grad():
            features = model.encode_image(batch_tensor)
            features /= features.norm(dim=-1, keepdim=True)
        
        all_features.append(features)
    
    return torch.cat(all_features, dim=0)

# 사용 예시
image_paths = ["img1.jpg", "img2.jpg", ..., "img1000.jpg"]
features = batch_encode_images(model, preprocess, image_paths, batch_size=64)

배치 크기는 GPU 메모리에 따라 조절해야 해. RTX 3090 같은 고성능 GPU는 64~128도 가능하지만, 일반 GPU는 16~32가 적당해. 메모리 부족 에러가 나면 배치 크기를 줄여봐! 🎮

💾 특징 벡터 캐싱

같은 이미지를 여러 번 인코딩하는 건 낭비야! 한 번 계산한 특징 벡터는 저장해두고 재사용하자. 🗄️

import pickle
import hashlib

class FeatureCache:
    def __init__(self, cache_file="feature_cache.pkl"):
        self.cache_file = cache_file
        self.cache = self._load_cache()
    
    def _load_cache(self):
        """캐시 파일 로드"""
        try:
            with open(self.cache_file, 'rb') as f:
                return pickle.load(f)
        except FileNotFoundError:
            return {}
    
    def _save_cache(self):
        """캐시 파일 저장"""
        with open(self.cache_file, 'wb') as f:
            pickle.dump(self.cache, f)
    
    def _get_file_hash(self, file_path):
        """파일 해시 계산 (캐시 키로 사용)"""
        with open(file_path, 'rb') as f:
            return hashlib.md5(f.read()).hexdigest()
    
    def get_feature(self, file_path):
        """캐시에서 특징 벡터 가져오기"""
        file_hash = self._get_file_hash(file_path)
        return self.cache.get(file_hash)
    
    def set_feature(self, file_path, feature):
        """특징 벡터를 캐시에 저장"""
        file_hash = self._get_file_hash(file_path)
        self.cache[file_hash] = feature.cpu().numpy()
        self._save_cache()

# 사용 예시
cache = FeatureCache()

def encode_with_cache(model, preprocess, image_path, device="cuda"):
    # 캐시 확인
    cached_feature = cache.get_feature(image_path)
    if cached_feature is not None:
        print(f"✅ 캐시에서 로드: {image_path}")
        return torch.from_numpy(cached_feature).to(device)
    
    # 캐시 없으면 새로 계산
    print(f"🔄 새로 계산: {image_path}")
    image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
    with torch.no_grad():
        feature = model.encode_image(image)
        feature /= feature.norm(dim=-1, keepdim=True)
    
    # 캐시에 저장
    cache.set_feature(image_path, feature)
    return feature

이 방식은 특히 개발 단계에서 유용해! 같은 이미지로 여러 번 테스트할 때 시간을 엄청 절약할 수 있거든. ⏰

🔧 모델 양자화(Quantization)

모델 크기를 줄이고 추론 속도를 높이려면 양자화를 고려해봐. FP32(32비트 부동소수점)를 FP16이나 INT8로 변환하는 거야. 정확도는 약간 떨어지지만, 속도는 2~4배 빨라질 수 있어! ⚡

# FP16 (Half Precision) 사용
model, preprocess = clip.load("ViT-B/32", device="cuda")
model = model.half()  # FP16으로 변환

# 이미지도 FP16으로
image = preprocess(Image.open("test.jpg")).unsqueeze(0).to("cuda").half()

with torch.no_grad():
    features = model.encode_image(image)

🎯 고급 활용: CLIP의 무한한 가능성

기본적인 사용법은 마스터했으니, 이제 더 창의적인 활용법을 알아보자! CLIP은 정말 다양한 분야에 적용할 수 있어. 🌈

🎭 콘텐츠 모더레이션

CLIP을 사용하면 부적절한 콘텐츠를 자동으로 필터링할 수 있어. 특정 카테고리의 이미지를 감지하는 거지!

class ContentModerator:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model, self.preprocess = clip.load("ViT-B/32", device=self.device)
        
        # 부적절한 콘텐츠 카테고리
        self.inappropriate_categories = [
            "violent content",
            "explicit content",
            "hate symbols",
            "graphic violence"
        ]
        
        # 적절한 콘텐츠 카테고리
        self.appropriate_categories = [
            "safe for work content",
            "family friendly image",
            "appropriate content",
            "general audience content"
        ]
    
    def check_image(self, image_path, threshold=0.3):
        """이미지 적절성 검사"""
        image = self.preprocess(Image.open(image_path)).unsqueeze(0).to(self.device)
        
        all_categories = self.inappropriate_categories + self.appropriate_categories
        texts = [f"a photo containing {cat}" for cat in all_categories]
        text_tokens = clip.tokenize(texts).to(self.device)
        
        with torch.no_grad():
            image_features = self.model.encode_image(image)
            text_features = self.model.encode_text(text_tokens)
            
            image_features /= image_features.norm(dim=-1, keepdim=True)
            text_features /= text_features.norm(dim=-1, keepdim=True)
            
            similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1)
        
        # 부적절한 콘텐츠 점수 계산
        inappropriate_score = similarity[0, :len(self.inappropriate_categories)].sum().item()
        
        result = {
            'is_safe': inappropriate_score < threshold,
            'inappropriate_score': inappropriate_score,
            'details': {}
        }
        
        for i, cat in enumerate(all_categories):
            result['details'][cat] = similarity[0, i].item()
        
        return result

# 사용 예시
moderator = ContentModerator()
result = moderator.check_image("user_upload.jpg")

if result['is_safe']:
    print("✅ 안전한 콘텐츠입니다")
else:
    print(f"⚠️ 부적절한 콘텐츠 가능성: {result['inappropriate_score']:.2%}")

🏷️ 자동 태그 생성

이미지에 자동으로 태그를 달아주는 시스템도 만들 수 있어! 수백 개의 태그 후보 중에서 가장 관련성 높은 태그를 선택하는 거야. 📸

class AutoTagger:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model, self.preprocess = clip.load("ViT-B/32", device=self.device)
        
        # 태그 후보들 (실제로는 더 많이!)
        self.tag_candidates = [
            # 객체
            "person", "people", "crowd", "dog", "cat", "car", "building",
            "tree", "flower", "food", "phone", "computer", "book",
            # 장소
            "indoor", "outdoor", "city", "nature", "beach", "mountain",
            "park", "street", "room", "office", "restaurant",
            # 활동
            "working", "playing", "eating", "sleeping", "running",
            "reading", "writing", "cooking", "driving",
            # 분위기
            "happy", "sad", "peaceful", "energetic", "romantic",
            "professional", "casual", "formal",
            # 시간/날씨
            "daytime", "nighttime", "sunny", "cloudy", "rainy", "snowy",
            # 스타일
            "colorful", "black and white", "vintage", "modern",
            "minimalist", "artistic", "realistic"
        ]
    
    def generate_tags(self, image_path, top_k=10, threshold=0.2):
        """이미지에 대한 태그 생성"""
        image = self.preprocess(Image.open(image_path)).unsqueeze(0).to(self.device)
        
        # 배치 처리로 효율성 향상
        batch_size = 50
        all_similarities = []
        
        for i in range(0, len(self.tag_candidates), batch_size):
            batch_tags = self.tag_candidates[i:i+batch_size]
            texts = [f"a photo of {tag}" for tag in batch_tags]
            text_tokens = clip.tokenize(texts).to(self.device)
            
            with torch.no_grad():
                image_features = self.model.encode_image(image)
                text_features = self.model.encode_text(text_tokens)
                
                image_features /= image_features.norm(dim=-1, keepdim=True)
                text_features /= text_features.norm(dim=-1, keepdim=True)
                
                similarity = (image_features @ text_features.T).squeeze(0)
                all_similarities.append(similarity)
        
        # 모든 유사도 합치기
        all_similarities = torch.cat(all_similarities)
        
        # 임계값 이상인 태그만 선택
        valid_indices = (all_similarities > threshold).nonzero(as_tuple=True)[0]
        
        if len(valid_indices) == 0:
            # 임계값을 만족하는 태그가 없으면 상위 k개 선택
            top_indices = all_similarities.argsort(descending=True)[:top_k]
        else:
            # 임계값 이상 중에서 상위 k개
            valid_similarities = all_similarities[valid_indices]
            sorted_valid = valid_similarities.argsort(descending=True)[:top_k]
            top_indices = valid_indices[sorted_valid]
        
        tags = []
        for idx in top_indices:
            tags.append({
                'tag': self.tag_candidates[idx],
                'confidence': all_similarities[idx].item()
            })
        
        return tags

# 사용 예시
tagger = AutoTagger()
tags = tagger.generate_tags("photo.jpg", top_k=15)

print("🏷️ 생성된 태그:")
for tag_info in tags:
    print(f"  #{tag_info['tag']} (신뢰도: {tag_info['confidence']:.3f})")

🎨 이미지 스타일 분석

CLIP으로 이미지의 예술적 스타일이나 분위기를 분석할 수도 있어! 사진작가나 디자이너에게 유용한 기능이지. 🖼️

class StyleAnalyzer:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model, self.preprocess = clip.load("ViT-B/32", device=self.device)
        
        self.style_dimensions = {
            'color_palette': [
                "vibrant colors", "muted colors", "pastel colors",
                "monochrome", "warm tones", "cool tones"
            ],
            'composition': [
                "symmetrical composition", "asymmetrical composition",
                "rule of thirds", "centered subject", "minimalist composition"
            ],
            'lighting': [
                "natural lighting", "artificial lighting", "dramatic lighting",
                "soft lighting", "harsh shadows", "golden hour lighting"
            ],
            'mood': [
                "cheerful mood", "melancholic mood", "mysterious mood",
                "energetic mood", "calm mood", "romantic mood"
            ],
            'art_style': [
                "realistic style", "abstract style", "impressionist style",
                "modern style", "vintage style", "cinematic style"
            ]
        }
    
    def analyze(self, image_path):
        """이미지 스타일 종합 분석"""
        image = self.preprocess(Image.open(image_path)).unsqueeze(0).to(self.device)
        
        analysis_result = {}
        
        for dimension, options in self.style_dimensions.items():
            texts = [f"a photo with {opt}" for opt in options]
            text_tokens = clip.tokenize(texts).to(self.device)
            
            with torch.no_grad():
                image_features = self.model.encode_image(image)
                text_features = self.model.encode_text(text_tokens)
                
                image_features /= image_features.norm(dim=-1, keepdim=True)
                text_features /= text_features.norm(dim=-1, keepdim=True)
                
                similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1)
            
            # 가장 높은 점수의 스타일 선택
            top_idx = similarity.argmax().item()
            
            analysis_result[dimension] = {
                'primary': options[top_idx],
                'confidence': similarity[0, top_idx].item(),
                'all_scores': {opt: similarity[0, i].item() 
                              for i, opt in enumerate(options)}
            }
        
        return analysis_result

# 사용 예시
analyzer = StyleAnalyzer()
analysis = analyzer.analyze("artwork.jpg")

print("🎨 이미지 스타일 분석 결과:\n")
for dimension, result in analysis.items():
    print(f"📊 {dimension.replace('_', ' ').title()}:")
    print(f"   주요 특징: {result['primary']} ({result['confidence']:.1%})")
    print()

🌟 실전 활용 사례: 현업에서는 이렇게 써요

이론과 코드는 충분히 봤으니, 이제 실제로 어떻게 활용되는지 알아보자! 🏢

🛍️ 전자상거래: 비주얼 검색

온라인 쇼핑몰에서 "이 옷과 비슷한 상품 찾기" 기능, 본 적 있지? 그게 바로 CLIP 같은 기술이야! 사용자가 마음에 드는 상품 이미지를 업로드하면, 비슷한 스타일의 상품을 추천해주는 거지. 👗

실제 구현 포인트:
- 전체 상품 카탈로그를 미리 인덱싱
- 사용자 업로드 이미지를 실시간으로 인코딩
- FAISS로 빠른 유사 상품 검색
- 가격대, 브랜드 등 필터와 결합

📱 소셜 미디어: 콘텐츠 추천

인스타그램이나 핀터레스트 같은 플랫폼에서 "당신이 좋아할 만한 게시물"을 추천할 때도 비슷한 기술을 써. 사용자가 좋아요를 누른 이미지들의 패턴을 학습해서, 비슷한 스타일의 콘텐츠를 찾아주는 거야! 📸

재능넷 같은 플랫폼에서도 활용할 수 있어! 사용자가 관심 있어 하는 포트폴리오 스타일을 분석해서, 비슷한 재능을 가진 다른 크리에이터를 추천해주는 거지. 🎨

🏥 의료: 의료 이미지 검색

의사들이 비슷한 증례를 찾을 때도 CLIP을 활용할 수 있어. "폐렴 패턴이 있는 X-ray"처럼 자연어로 검색하면, 관련 의료 이미지를 찾아주는 거야. 물론 의료 도메인에 파인튜닝된 모델을 써야 하지만! 🏥

🎬 미디어: 비디오 콘텐츠 분석

비디오를 프레임별로 분석해서 특정 장면을 찾을 수 있어. "해변에서 일몰을 보는 장면"을 검색하면, 수시간짜리 영상에서 해당 장면만 쏙 찾아내는 거지! 🎥

import cv2

class VideoSearchEngine:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model, self.preprocess = clip.load("ViT-B/32", device=self.device)
    
    def search_in_video(self, video_path, query, threshold=0.25, sample_rate=30):
        """비디오에서 쿼리와 매칭되는 장면 찾기"""
        cap = cv2.VideoCapture(video_path)
        fps = cap.get(cv2.CAP_PROP_FPS)
        
        text = clip.tokenize([query]).to(self.device)
        with torch.no_grad():
            text_features = self.model.encode_text(text)
            text_features /= text_features.norm(dim=-1, keepdim=True)
        
        matching_frames = []
        frame_count = 0
        
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            
            # 샘플링 (모든 프레임을 처리하면 너무 느림)
            if frame_count % sample_rate == 0:
                # OpenCV BGR을 RGB로 변환
                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                pil_image = Image.fromarray(frame_rgb)
                
                image = self.preprocess(pil_image).unsqueeze(0).to(self.device)
                
                with torch.no_grad():
                    image_features = self.model.encode_image(image)
                    image_features /= image_features.norm(dim=-1, keepdim=True)
                    
                    similarity = (image_features @ text_features.T).item()
                
                if similarity > threshold:
                    timestamp = frame_count / fps
                    matching_frames.append({
                        'frame': frame_count,
                        'timestamp': timestamp,
                        'similarity': similarity
                    })
                    print(f"✅ 매칭 발견: {timestamp:.2f}초 (유사도: {similarity:.3f})")
            
            frame_count += 1
        
        cap.release()
        return matching_frames

# 사용 예시
video_search = VideoSearchEngine()
results = video_search.search_in_video(
    "movie.mp4",
    "a person running on the beach",
    threshold=0.3,
    sample_rate=15  # 15프레임마다 샘플링
)

print(f"\n🎬 총 {len(results)}개 장면 발견!")