Split View: 멀티모달 AI 완전 정복: CLIP, LLaVA, GPT-4V, Gemini Vision 마스터하기

2021: CLIP (OpenAI) - 대조 학습으로 이미지-텍스트 연결
2022: BLIP - 이미지 캡셔닝과 VQA 통합
2023: BLIP-2 - Q-Former로 효율적 멀티모달 학습
2023: LLaVA - 오픈소스 비전-언어 어시스턴트
2023: GPT-4V - 상업용 멀티모달 LLM
2023: Gemini - 구글의 멀티모달 파운데이션 모델
2024: Claude 3 Vision - Anthropic의 멀티모달 모델
2024: LLaVA-1.6, InternVL2, Qwen-VL2 - 오픈소스 개선
2025: 비디오 이해, 3D 이해로 확장

이미지 → [이미지 인코더 (ViT/ResNet)] → 이미지 임베딩 (512차원)
                                                    ↕ 유사도 측정
텍스트 → [텍스트 인코더 (Transformer)]→ 텍스트 임베딩 (512차원)

import torch
import torch.nn.functional as F
from PIL import Image
import requests
from transformers import CLIPProcessor, CLIPModel

# CLIP 모델 로드
model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")

def clip_zero_shot_classification(
    image: Image.Image,
    candidate_labels: list[str]
) -> dict[str, float]:
    """CLIP을 사용한 제로샷 이미지 분류."""

    # 텍스트 프롬프트 생성 (CLIP의 권장 형식)
    text_prompts = [f"a photo of a {label}" for label in candidate_labels]

    # 전처리
    inputs = processor(
        text=text_prompts,
        images=image,
        return_tensors="pt",
        padding=True
    )

    # 추론
    with torch.no_grad():
        outputs = model(**inputs)
        logits_per_image = outputs.logits_per_image
        probs = logits_per_image.softmax(dim=1)

    # 결과 반환
    return {
        label: prob.item()
        for label, prob in zip(candidate_labels, probs[0])
    }

# 사용 예시
image_url = "https://example.com/sample_image.jpg"
image = Image.open(requests.get(image_url, stream=True).raw)

labels = ["cat", "dog", "bird", "fish", "rabbit"]
results = clip_zero_shot_classification(image, labels)

# 확률 기준 정렬
sorted_results = sorted(results.items(), key=lambda x: x[1], reverse=True)
for label, prob in sorted_results:
    print(f"{label}: {prob:.4f} ({prob*100:.1f}%)")

import numpy as np
from typing import Union

class CLIPSearchEngine:
    """CLIP 기반 이미지-텍스트 검색 엔진."""

    def __init__(self, model_name: str = "openai/clip-vit-large-patch14"):
        self.model = CLIPModel.from_pretrained(model_name)
        self.processor = CLIPProcessor.from_pretrained(model_name)
        self.image_embeddings = []
        self.text_embeddings = []
        self.image_metadata = []
        self.text_metadata = []

    def encode_images(self, images: list[Image.Image]) -> torch.Tensor:
        """이미지 배치를 임베딩으로 변환."""
        inputs = self.processor(
            images=images,
            return_tensors="pt",
            padding=True
        )
        with torch.no_grad():
            image_features = self.model.get_image_features(**inputs)
            # L2 정규화
            image_features = F.normalize(image_features, p=2, dim=-1)
        return image_features

    def encode_texts(self, texts: list[str]) -> torch.Tensor:
        """텍스트 배치를 임베딩으로 변환."""
        inputs = self.processor(
            text=texts,
            return_tensors="pt",
            padding=True,
            truncation=True
        )
        with torch.no_grad():
            text_features = self.model.get_text_features(**inputs)
            text_features = F.normalize(text_features, p=2, dim=-1)
        return text_features

    def index_images(
        self,
        images: list[Image.Image],
        metadata: list[dict] = None
    ):
        """이미지를 인덱싱합니다."""
        embeddings = self.encode_images(images)
        self.image_embeddings.append(embeddings)
        if metadata:
            self.image_metadata.extend(metadata)

    def text_to_image_search(
        self,
        query: str,
        top_k: int = 5
    ) -> list[dict]:
        """텍스트 쿼리로 이미지를 검색합니다."""
        if not self.image_embeddings:
            return []

        # 모든 이미지 임베딩 결합
        all_embeddings = torch.cat(self.image_embeddings, dim=0)

        # 쿼리 인코딩
        query_embedding = self.encode_texts([query])

        # 코사인 유사도 계산 (이미 L2 정규화됨)
        similarities = (all_embeddings @ query_embedding.T).squeeze(-1)

        # Top-K 결과 선택
        top_indices = similarities.argsort(descending=True)[:top_k]

        results = []
        for idx in top_indices:
            idx = idx.item()
            result = {
                "index": idx,
                "similarity": similarities[idx].item()
            }
            if self.image_metadata:
                result.update(self.image_metadata[idx])
            results.append(result)

        return results

# OpenCLIP: 다양한 아키텍처와 학습 데이터 지원
# pip install open_clip_torch

import open_clip
import torch
from PIL import Image

# 사용 가능한 모델 목록 확인
available_models = open_clip.list_pretrained()
print("사용 가능한 모델:", available_models[:5])

# LAION-2B로 학습된 대형 모델 로드
model, preprocess_train, preprocess_val = open_clip.create_model_and_transforms(
    'ViT-H-14',
    pretrained='laion2b_s32b_b79k'
)
tokenizer = open_clip.get_tokenizer('ViT-H-14')

def compute_clip_similarity(
    image: Image.Image,
    texts: list[str],
    model=model,
    preprocess=preprocess_val,
    tokenizer=tokenizer
) -> list[float]:
    """이미지와 텍스트 목록 간의 CLIP 유사도를 계산합니다."""
    model.eval()

    # 이미지 전처리
    image_input = preprocess(image).unsqueeze(0)

    # 텍스트 토큰화
    text_input = tokenizer(texts)

    with torch.no_grad(), torch.cuda.amp.autocast():
        image_features = model.encode_image(image_input)
        text_features = model.encode_text(text_input)

        # 정규화
        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)

    return similarity[0].tolist()

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
from transformers import CLIPModel, CLIPProcessor
import torch.optim as optim

class ImageTextDataset(Dataset):
    """이미지-텍스트 쌍 데이터셋."""

    def __init__(
        self,
        image_paths: list[str],
        texts: list[str],
        processor: CLIPProcessor
    ):
        self.image_paths = image_paths
        self.texts = texts
        self.processor = processor

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        image = Image.open(self.image_paths[idx]).convert("RGB")
        text = self.texts[idx]

        inputs = self.processor(
            images=image,
            text=text,
            return_tensors="pt",
            padding="max_length",
            max_length=77,
            truncation=True
        )

        return {
            "pixel_values": inputs["pixel_values"].squeeze(0),
            "input_ids": inputs["input_ids"].squeeze(0),
            "attention_mask": inputs["attention_mask"].squeeze(0)
        }

class CLIPFineTuner:
    """CLIP 모델 파인튜닝 클래스."""

    def __init__(self, model_name: str = "openai/clip-vit-base-patch32"):
        self.model = CLIPModel.from_pretrained(model_name)
        self.processor = CLIPProcessor.from_pretrained(model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)

    def contrastive_loss(
        self,
        image_features: torch.Tensor,
        text_features: torch.Tensor,
        temperature: float = 0.07
    ) -> torch.Tensor:
        """대조 학습 손실 함수."""
        # 정규화
        image_features = F.normalize(image_features, dim=-1)
        text_features = F.normalize(text_features, dim=-1)

        # 유사도 행렬
        logits = torch.matmul(image_features, text_features.T) / temperature

        # 대각선이 정답 (i번째 이미지는 i번째 텍스트와 쌍)
        labels = torch.arange(len(logits)).to(self.device)

        # 양방향 크로스 엔트로피
        loss_i = F.cross_entropy(logits, labels)
        loss_t = F.cross_entropy(logits.T, labels)

        return (loss_i + loss_t) / 2

    def train(
        self,
        train_dataset: ImageTextDataset,
        num_epochs: int = 10,
        batch_size: int = 32,
        learning_rate: float = 1e-5
    ):
        """CLIP 파인튜닝 학습."""
        dataloader = DataLoader(
            train_dataset,
            batch_size=batch_size,
            shuffle=True,
            num_workers=4
        )

        optimizer = optim.AdamW(
            self.model.parameters(),
            lr=learning_rate,
            weight_decay=0.01
        )

        scheduler = optim.lr_scheduler.CosineAnnealingLR(
            optimizer,
            T_max=num_epochs
        )

        for epoch in range(num_epochs):
            total_loss = 0
            self.model.train()

            for batch in dataloader:
                pixel_values = batch["pixel_values"].to(self.device)
                input_ids = batch["input_ids"].to(self.device)
                attention_mask = batch["attention_mask"].to(self.device)

                # 순전파
                outputs = self.model(
                    pixel_values=pixel_values,
                    input_ids=input_ids,
                    attention_mask=attention_mask
                )

                image_features = outputs.image_embeds
                text_features = outputs.text_embeds

                # 손실 계산
                loss = self.contrastive_loss(image_features, text_features)

                # 역전파
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()

                total_loss += loss.item()

            scheduler.step()
            avg_loss = total_loss / len(dataloader)
            print(f"Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}")

from transformers import BlipProcessor, BlipForConditionalGeneration
from transformers import BlipForQuestionAnswering
from PIL import Image
import torch

# BLIP 이미지 캡셔닝
class BLIPCaptioner:
    def __init__(self):
        self.processor = BlipProcessor.from_pretrained(
            "Salesforce/blip-image-captioning-large"
        )
        self.model = BlipForConditionalGeneration.from_pretrained(
            "Salesforce/blip-image-captioning-large",
            torch_dtype=torch.float16
        )
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model.to(self.device)

    def caption(
        self,
        image: Image.Image,
        conditional_text: str = None,
        max_new_tokens: int = 50
    ) -> str:
        """이미지에 대한 캡션을 생성합니다."""
        if conditional_text:
            # 조건부 캡셔닝
            inputs = self.processor(
                image,
                conditional_text,
                return_tensors="pt"
            ).to(self.device, torch.float16)
        else:
            # 무조건부 캡셔닝
            inputs = self.processor(
                image,
                return_tensors="pt"
            ).to(self.device, torch.float16)

        with torch.no_grad():
            output = self.model.generate(
                **inputs,
                max_new_tokens=max_new_tokens,
                num_beams=4,
                early_stopping=True
            )

        return self.processor.decode(output[0], skip_special_tokens=True)

# BLIP VQA (시각적 질의응답)
class BLIPVisualQA:
    def __init__(self):
        self.processor = BlipProcessor.from_pretrained(
            "Salesforce/blip-vqa-base"
        )
        self.model = BlipForQuestionAnswering.from_pretrained(
            "Salesforce/blip-vqa-base"
        )

    def answer(self, image: Image.Image, question: str) -> str:
        """이미지에 대한 질문에 답변합니다."""
        inputs = self.processor(image, question, return_tensors="pt")

        with torch.no_grad():
            output = self.model.generate(**inputs, max_new_tokens=50)

        return self.processor.decode(output[0], skip_special_tokens=True)

# 사용 예시
captioner = BLIPCaptioner()
vqa = BLIPVisualQA()

image = Image.open("sample.jpg")

# 캡션 생성
caption = captioner.caption(image)
print(f"캡션: {caption}")

# 조건부 캡션
cond_caption = captioner.caption(image, "a photo of")
print(f"조건부 캡션: {cond_caption}")

# VQA
answer = vqa.answer(image, "What color is the sky?")
print(f"답변: {answer}")

from transformers import Blip2Processor, Blip2ForConditionalGeneration
import torch

class BLIP2Assistant:
    """BLIP-2 기반 시각 질의응답 어시스턴트."""

    def __init__(
        self,
        model_name: str = "Salesforce/blip2-opt-2.7b"
    ):
        self.processor = Blip2Processor.from_pretrained(model_name)
        self.model = Blip2ForConditionalGeneration.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto"
        )

    def generate_response(
        self,
        image: Image.Image,
        prompt: str = None,
        max_new_tokens: int = 200,
        temperature: float = 1.0
    ) -> str:
        """이미지와 (선택적) 프롬프트에 대한 응답을 생성합니다."""

        if prompt:
            inputs = self.processor(
                images=image,
                text=prompt,
                return_tensors="pt"
            ).to("cuda", torch.float16)
        else:
            inputs = self.processor(
                images=image,
                return_tensors="pt"
            ).to("cuda", torch.float16)

        with torch.no_grad():
            generated_ids = self.model.generate(
                **inputs,
                max_new_tokens=max_new_tokens,
                temperature=temperature,
                do_sample=temperature > 0
            )

        generated_text = self.processor.batch_decode(
            generated_ids,
            skip_special_tokens=True
        )[0].strip()

        return generated_text

    def batch_caption(
        self,
        images: list[Image.Image],
        batch_size: int = 8
    ) -> list[str]:
        """이미지 배치에 대한 캡션을 일괄 생성합니다."""
        all_captions = []

        for i in range(0, len(images), batch_size):
            batch = images[i:i + batch_size]

            inputs = self.processor(
                images=batch,
                return_tensors="pt",
                padding=True
            ).to("cuda", torch.float16)

            with torch.no_grad():
                generated_ids = self.model.generate(
                    **inputs,
                    max_new_tokens=50
                )

            captions = self.processor.batch_decode(
                generated_ids,
                skip_special_tokens=True
            )

            all_captions.extend([c.strip() for c in captions])

        return all_captions

# 사용 예시
assistant = BLIP2Assistant("Salesforce/blip2-flan-t5-xxl")
image = Image.open("document.png")

# 자유 형식 질문
response = assistant.generate_response(
    image,
    "Question: What is the main topic of this document? Answer:"
)
print(response)

# 대화형 세션
conversation_history = []
questions = [
    "이미지에 무엇이 보이나요?",
    "색상은 어떻게 되나요?",
    "배경은 어떤가요?"
]

for q in questions:
    history_text = "\n".join(conversation_history)
    prompt = f"{history_text}\nQuestion: {q} Answer:"
    answer = assistant.generate_response(image, prompt)
    print(f"Q: {q}")
    print(f"A: {answer}")
    conversation_history.append(f"Q: {q} A: {answer}")

이미지 → [CLIP ViT-L/14] → 이미지 특징 (1024차원)
                              ↓
                      [선형 프로젝션 레이어]
                              ↓
                      [비주얼 토큰들]
                              ↓
           [LLM (LLaMA/Vicuna)] ← [텍스트 토큰들]
                              ↓
                          최종 응답

from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
import torch
from PIL import Image

class LLaVAAssistant:
    """LLaVA-1.6 기반 시각 어시스턴트."""

    def __init__(
        self,
        model_name: str = "llava-hf/llava-v1.6-mistral-7b-hf"
    ):
        self.processor = LlavaNextProcessor.from_pretrained(model_name)
        self.model = LlavaNextForConditionalGeneration.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            low_cpu_mem_usage=True,
            device_map="auto"
        )

    def chat(
        self,
        image: Image.Image,
        message: str,
        max_new_tokens: int = 500,
        temperature: float = 0.7
    ) -> str:
        """이미지와 함께 대화합니다."""

        # LLaVA-1.6의 대화 형식
        conversation = [
            {
                "role": "user",
                "content": [
                    {"type": "image"},
                    {"type": "text", "text": message}
                ]
            }
        ]

        prompt = self.processor.apply_chat_template(
            conversation,
            add_generation_prompt=True
        )

        inputs = self.processor(
            prompt,
            image,
            return_tensors="pt"
        ).to("cuda")

        with torch.no_grad():
            output = self.model.generate(
                **inputs,
                max_new_tokens=max_new_tokens,
                temperature=temperature,
                do_sample=temperature > 0,
                pad_token_id=self.processor.tokenizer.eos_token_id
            )

        # 입력 제외하고 생성된 텍스트만 추출
        generated = output[0][inputs["input_ids"].shape[1]:]
        return self.processor.decode(generated, skip_special_tokens=True)

    def analyze_chart(self, chart_image: Image.Image) -> dict:
        """차트 이미지를 분석합니다."""
        analysis_prompts = [
            "이 차트의 제목은 무엇인가요?",
            "x축과 y축은 무엇을 나타내나요?",
            "가장 높은 값과 낮은 값은 무엇인가요?",
            "전체적인 트렌드를 설명해주세요.",
            "이 데이터에서 가장 중요한 인사이트는 무엇인가요?"
        ]

        results = {}
        for prompt in analysis_prompts:
            response = self.chat(chart_image, prompt)
            results[prompt] = response

        return results

    def extract_text_from_image(self, image: Image.Image) -> str:
        """이미지에서 텍스트를 추출합니다 (OCR)."""
        return self.chat(
            image,
            "이 이미지에 있는 모든 텍스트를 정확히 추출해주세요. "
            "텍스트만 반환하고 다른 설명은 추가하지 마세요."
        )


# 실전 활용: 문서 분석 파이프라인
class DocumentAnalysisPipeline:
    """LLaVA를 사용한 문서 분석 파이프라인."""

    def __init__(self):
        self.llava = LLaVAAssistant()

    def analyze_document(self, document_image: Image.Image) -> dict:
        """문서 이미지를 종합 분석합니다."""

        # 1. 문서 타입 식별
        doc_type = self.llava.chat(
            document_image,
            "이 문서의 유형은 무엇인가요? (청구서, 계약서, 보고서, 양식 등)"
        )

        # 2. 텍스트 추출
        extracted_text = self.llava.extract_text_from_image(document_image)

        # 3. 핵심 정보 추출
        key_info = self.llava.chat(
            document_image,
            f"이 {doc_type}에서 다음 정보를 JSON 형식으로 추출해주세요: "
            "날짜, 발신인, 수신인, 금액(있는 경우), 주요 내용 요약"
        )

        # 4. 액션 아이템 식별
        action_items = self.llava.chat(
            document_image,
            "이 문서에서 필요한 조치사항이 있다면 목록으로 나열해주세요."
        )

        return {
            "document_type": doc_type,
            "extracted_text": extracted_text,
            "key_information": key_info,
            "action_items": action_items
        }

from transformers import InstructBlipProcessor, InstructBlipForConditionalGeneration
import torch
from PIL import Image

class InstructBLIPAssistant:
    """InstructBLIP 기반 지시 따르기 어시스턴트."""

    def __init__(self, model_name: str = "Salesforce/instructblip-vicuna-7b"):
        self.processor = InstructBlipProcessor.from_pretrained(model_name)
        self.model = InstructBlipForConditionalGeneration.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto"
        )

    def instruct(
        self,
        image: Image.Image,
        instruction: str,
        max_new_tokens: int = 300
    ) -> str:
        """이미지에 대한 구체적인 지시를 수행합니다."""
        inputs = self.processor(
            images=image,
            text=instruction,
            return_tensors="pt"
        ).to("cuda", torch.float16)

        with torch.no_grad():
            outputs = self.model.generate(
                **inputs,
                do_sample=False,
                num_beams=5,
                max_new_tokens=max_new_tokens,
                min_length=1,
                top_p=0.9,
                repetition_penalty=1.5,
                length_penalty=1.0,
                temperature=1.0
            )

        generated_text = self.processor.batch_decode(
            outputs,
            skip_special_tokens=True
        )[0].strip()

        return generated_text

# 다양한 활용 예시
assistant = InstructBLIPAssistant()
image = Image.open("complex_diagram.png")

# 복잡한 다이어그램 설명
description = assistant.instruct(
    image,
    "이 다이어그램을 상세히 설명해주세요. 각 컴포넌트의 역할과 연결 관계를 포함하세요."
)

# 특정 객체 감지
objects = assistant.instruct(
    image,
    "이미지에서 발견되는 모든 객체를 목록으로 나열하고, 각 객체의 위치를 설명해주세요."
)

# 감정 분석
emotion = assistant.instruct(
    image,
    "이미지에 있는 사람들의 감정 상태를 분석하고, 그 근거를 설명해주세요."
)

# 비교 분석
if len([image]) > 1:  # 여러 이미지의 경우
    comparison = assistant.instruct(
        image,
        "이미지의 특징을 자세히 설명하고, 비슷한 이미지와 비교했을 때의 차이점을 설명해주세요."
    )

import openai
import base64
from pathlib import Path
import httpx

client = openai.OpenAI()

def encode_image_to_base64(image_path: str) -> str:
    """이미지 파일을 Base64로 인코딩합니다."""
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

def image_url_to_base64(url: str) -> str:
    """URL에서 이미지를 다운로드하여 Base64로 인코딩합니다."""
    response = httpx.get(url)
    return base64.b64encode(response.content).decode('utf-8')

class GPT4VisionAnalyzer:
    """GPT-4 Vision 기반 이미지 분석기."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = openai.OpenAI()
        self.model = model

    def analyze_image(
        self,
        image_source: str,  # 파일 경로 또는 URL
        prompt: str,
        is_url: bool = True,
        detail: str = "high",  # "low", "high", "auto"
        max_tokens: int = 1000
    ) -> str:
        """단일 이미지를 분석합니다."""

        if is_url:
            image_content = {
                "type": "image_url",
                "image_url": {
                    "url": image_source,
                    "detail": detail
                }
            }
        else:
            # 로컬 파일
            base64_image = encode_image_to_base64(image_source)
            ext = Path(image_source).suffix.lower()
            media_type_map = {
                ".jpg": "image/jpeg",
                ".jpeg": "image/jpeg",
                ".png": "image/png",
                ".gif": "image/gif",
                ".webp": "image/webp"
            }
            media_type = media_type_map.get(ext, "image/jpeg")

            image_content = {
                "type": "image_url",
                "image_url": {
                    "url": f"data:{media_type};base64,{base64_image}",
                    "detail": detail
                }
            }

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "user",
                    "content": [
                        image_content,
                        {"type": "text", "text": prompt}
                    ]
                }
            ],
            max_tokens=max_tokens
        )

        return response.choices[0].message.content

    def analyze_multiple_images(
        self,
        image_sources: list[dict],  # [{"source": "...", "is_url": True}]
        prompt: str,
        max_tokens: int = 2000
    ) -> str:
        """여러 이미지를 동시에 분석합니다."""
        content = []

        for img_info in image_sources:
            source = img_info["source"]
            is_url = img_info.get("is_url", True)

            if is_url:
                content.append({
                    "type": "image_url",
                    "image_url": {"url": source, "detail": "high"}
                })
            else:
                base64_image = encode_image_to_base64(source)
                content.append({
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                })

        content.append({"type": "text", "text": prompt})

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": content}],
            max_tokens=max_tokens
        )

        return response.choices[0].message.content

    def analyze_chart_or_graph(self, image_source: str) -> dict:
        """차트나 그래프를 구조화된 형식으로 분석합니다."""
        prompt = """이 차트/그래프를 분석하여 다음 JSON 형식으로 반환해주세요:
{
  "chart_type": "막대/선/원/산점도 등",
  "title": "차트 제목",
  "x_axis": {"label": "X축 레이블", "unit": "단위"},
  "y_axis": {"label": "Y축 레이블", "unit": "단위"},
  "data_series": [{"name": "시리즈명", "trend": "상승/하락/유지"}],
  "key_findings": ["발견사항1", "발견사항2"],
  "data_range": {"min": 0, "max": 0},
  "anomalies": ["이상치 설명"]
}"""

        response = self.analyze_image(
            image_source,
            prompt,
            detail="high",
            max_tokens=1500
        )

        import json
        try:
            # JSON 파싱 시도
            start = response.find('{')
            end = response.rfind('}') + 1
            if start >= 0 and end > start:
                return json.loads(response[start:end])
        except json.JSONDecodeError:
            pass

        return {"raw_response": response}

    def extract_structured_data_from_document(
        self,
        document_image_path: str
    ) -> dict:
        """문서 이미지에서 구조화된 데이터를 추출합니다."""
        prompt = """이 문서에서 다음 정보를 JSON 형식으로 추출해주세요:
1. 문서 유형
2. 날짜 (있는 경우)
3. 발신인/작성자
4. 수신인 (있는 경우)
5. 주요 내용 요약 (3-5문장)
6. 주요 수치 데이터 (표, 금액 등)
7. 서명/승인 여부

JSON 형식:
{
  "document_type": "",
  "date": "",
  "author": "",
  "recipient": "",
  "summary": "",
  "numerical_data": [],
  "signature_present": false
}"""

        return self.analyze_chart_or_graph.__func__(self, document_image_path)


# 실전 활용: 이커머스 제품 분석
def analyze_product_images(image_urls: list[str]) -> dict:
    """여러 제품 이미지를 분석합니다."""
    analyzer = GPT4VisionAnalyzer()

    image_sources = [{"source": url, "is_url": True} for url in image_urls]

    result = analyzer.analyze_multiple_images(
        image_sources,
        prompt="""이 제품 이미지들을 분석하여 다음을 JSON으로 반환해주세요:
{
  "product_name": "추정 제품명",
  "category": "제품 카테고리",
  "color_options": ["색상 목록"],
  "key_features": ["주요 특징"],
  "condition": "새 제품/중고 등",
  "quality_score": 0-10,
  "marketing_description": "마케팅용 설명 (100자)",
  "seo_keywords": ["SEO 키워드"]
}"""
    )

    return result

import google.generativeai as genai
import PIL.Image
from pathlib import Path
import base64

# API 키 설정
genai.configure(api_key="YOUR_GEMINI_API_KEY")

class GeminiVisionAnalyzer:
    """Gemini Vision 기반 분석기."""

    def __init__(self, model_name: str = "gemini-1.5-pro"):
        self.model = genai.GenerativeModel(model_name)
        self.vision_model = genai.GenerativeModel("gemini-1.5-flash")

    def analyze_image(
        self,
        image_path: str,
        prompt: str
    ) -> str:
        """이미지를 분석합니다."""
        image = PIL.Image.open(image_path)
        response = self.model.generate_content([prompt, image])
        return response.text

    def analyze_with_url(self, image_url: str, prompt: str) -> str:
        """URL의 이미지를 분석합니다."""
        import httpx
        image_data = httpx.get(image_url).content

        image_part = {
            "mime_type": "image/jpeg",
            "data": base64.b64encode(image_data).decode('utf-8')
        }

        response = self.model.generate_content([
            {"text": prompt},
            image_part
        ])
        return response.text

    def analyze_video(
        self,
        video_path: str,
        questions: list[str]
    ) -> dict:
        """비디오를 분석합니다. (Gemini 1.5 Pro의 강점)"""

        # 비디오 파일 업로드
        print(f"비디오 업로드 중: {video_path}")
        video_file = genai.upload_file(
            path=video_path,
            display_name="analysis_video"
        )

        # 업로드 완료 대기
        import time
        while video_file.state.name == "PROCESSING":
            print("처리 중...")
            time.sleep(10)
            video_file = genai.get_file(video_file.name)

        if video_file.state.name == "FAILED":
            raise ValueError("비디오 처리 실패")

        print(f"비디오 업로드 완료: {video_file.uri}")

        # 질문별 분석
        results = {}
        for question in questions:
            response = self.model.generate_content(
                [video_file, question],
                request_options={"timeout": 600}
            )
            results[question] = response.text

        # 파일 삭제 (선택적)
        genai.delete_file(video_file.name)

        return results

    def analyze_multiple_images_interleaved(
        self,
        image_text_pairs: list[dict]  # [{"image": PIL.Image, "text": str}]
    ) -> str:
        """이미지와 텍스트가 교차 배치된 복합 쿼리를 처리합니다."""
        content = []

        for pair in image_text_pairs:
            if "text" in pair:
                content.append(pair["text"])
            if "image" in pair:
                content.append(pair["image"])

        response = self.model.generate_content(content)
        return response.text

    def process_document_batch(
        self,
        document_images: list[PIL.Image.Image],
        extraction_schema: str
    ) -> list[dict]:
        """여러 문서를 일괄 처리합니다 (Gemini의 긴 컨텍스트 활용)."""
        import json

        # 모든 이미지를 하나의 요청으로 처리
        content = [f"다음 {len(document_images)}개의 문서를 분석해주세요:\n"]

        for i, img in enumerate(document_images, 1):
            content.append(f"\n--- 문서 {i} ---")
            content.append(img)

        content.append(f"\n각 문서에 대해 다음 JSON 스키마로 데이터를 추출하세요:\n{extraction_schema}")

        response = self.model.generate_content(content)

        # JSON 파싱
        try:
            text = response.text
            # JSON 배열 추출
            start = text.find('[')
            end = text.rfind(']') + 1
            if start >= 0 and end > start:
                return json.loads(text[start:end])
        except json.JSONDecodeError:
            return [{"raw_response": response.text}]


# 활용 예시: 비디오 분석
analyzer = GeminiVisionAnalyzer()

video_questions = [
    "비디오의 전체 내용을 요약해주세요.",
    "주요 장면들을 타임스탬프와 함께 나열해주세요.",
    "비디오에서 언급된 주요 키워드나 개념은 무엇인가요?",
    "비디오의 주제와 목적은 무엇인가요?"
]

results = analyzer.analyze_video("lecture_video.mp4", video_questions)
for question, answer in results.items():
    print(f"\n질문: {question}")
    print(f"답변: {answer}")

import anthropic
import base64
import httpx
from pathlib import Path

client = anthropic.Anthropic()

class ClaudeVisionAnalyzer:
    """Claude Vision 기반 이미지 분석기."""

    def __init__(self, model: str = "claude-3-5-sonnet-20241022"):
        self.client = anthropic.Anthropic()
        self.model = model

    def _prepare_image_content(
        self,
        image_source: str,
        is_url: bool = True
    ) -> dict:
        """이미지 콘텐츠를 Claude API 형식으로 준비합니다."""
        if is_url:
            return {
                "type": "image",
                "source": {
                    "type": "url",
                    "url": image_source
                }
            }
        else:
            # 로컬 파일을 Base64로 인코딩
            with open(image_source, "rb") as f:
                image_data = base64.standard_b64encode(f.read()).decode("utf-8")

            ext = Path(image_source).suffix.lower()
            media_type_map = {
                ".jpg": "image/jpeg",
                ".jpeg": "image/jpeg",
                ".png": "image/png",
                ".gif": "image/gif",
                ".webp": "image/webp"
            }
            media_type = media_type_map.get(ext, "image/jpeg")

            return {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": media_type,
                    "data": image_data
                }
            }

    def analyze(
        self,
        image_source: str,
        prompt: str,
        is_url: bool = True,
        system_prompt: str = None,
        max_tokens: int = 1000
    ) -> str:
        """이미지를 분석합니다."""
        image_content = self._prepare_image_content(image_source, is_url)

        messages = [
            {
                "role": "user",
                "content": [
                    image_content,
                    {"type": "text", "text": prompt}
                ]
            }
        ]

        kwargs = {
            "model": self.model,
            "max_tokens": max_tokens,
            "messages": messages
        }

        if system_prompt:
            kwargs["system"] = system_prompt

        response = self.client.messages.create(**kwargs)
        return response.content[0].text

    def analyze_code_screenshot(
        self,
        screenshot_path: str
    ) -> dict:
        """코드 스크린샷을 분석하고 코드를 추출합니다."""
        system_prompt = """당신은 코드 분석 전문가입니다.
스크린샷에서 코드를 정확히 추출하고 분석하세요."""

        extraction_prompt = """이 코드 스크린샷에서:
1. 코드를 정확히 추출하세요 (들여쓰기 포함)
2. 프로그래밍 언어를 식별하세요
3. 코드의 주요 기능을 설명하세요
4. 잠재적인 버그나 개선사항을 제안하세요

다음 JSON 형식으로 응답하세요:
{
  "language": "프로그래밍 언어",
  "code": "추출된 코드",
  "description": "코드 설명",
  "potential_issues": ["이슈1", "이슈2"],
  "improvements": ["개선사항1", "개선사항2"]
}"""

        response = self.analyze(
            screenshot_path,
            extraction_prompt,
            is_url=False,
            system_prompt=system_prompt,
            max_tokens=2000
        )

        import json
        try:
            start = response.find('{')
            end = response.rfind('}') + 1
            return json.loads(response[start:end])
        except json.JSONDecodeError:
            return {"raw_response": response}

    def compare_images(
        self,
        image_sources: list[tuple[str, bool]],  # (source, is_url) 쌍
        comparison_prompt: str
    ) -> str:
        """여러 이미지를 비교 분석합니다."""
        content = []

        for source, is_url in image_sources:
            content.append(self._prepare_image_content(source, is_url))

        content.append({"type": "text", "text": comparison_prompt})

        response = self.client.messages.create(
            model=self.model,
            max_tokens=2000,
            messages=[{"role": "user", "content": content}]
        )

        return response.content[0].text

    def analyze_ui_design(self, ui_screenshot_path: str) -> dict:
        """UI 디자인 스크린샷을 분석합니다."""
        prompt = """이 UI 스크린샷을 UX/UI 전문가 관점에서 분석해주세요:

분석 항목:
1. 레이아웃 구조
2. 색상 팔레트
3. 타이포그래피
4. 사용성 (Usability) 평가
5. 접근성 (Accessibility) 이슈
6. 개선 제안사항

JSON 형식으로 반환해주세요:
{
  "layout": "레이아웃 설명",
  "color_palette": ["주요 색상들"],
  "typography": "타이포그래피 평가",
  "usability_score": 0-10,
  "usability_issues": ["이슈들"],
  "accessibility_issues": ["접근성 문제"],
  "improvements": ["개선 제안"]
}"""

        return self.analyze(
            ui_screenshot_path,
            prompt,
            is_url=False,
            max_tokens=1500
        )

# 사용 예시
analyzer = ClaudeVisionAnalyzer()

# 이미지 분석
result = analyzer.analyze(
    "https://example.com/product.jpg",
    "이 제품의 특징을 자세히 설명하고, 잠재적 고객층을 추천해주세요.",
    is_url=True
)
print(result)

import torch
import numpy as np
from PIL import Image
from transformers import CLIPModel, CLIPProcessor
import chromadb
from chromadb.utils.embedding_functions import OpenCLIPEmbeddingFunction
import base64
import io

class MultimodalRAGSystem:
    """멀티모달 RAG 시스템."""

    def __init__(self):
        # CLIP 모델 초기화
        self.clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
        self.clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

        # ChromaDB 초기화
        self.chroma_client = chromadb.Client()
        self.image_collection = self.chroma_client.get_or_create_collection(
            name="images",
            metadata={"hnsw:space": "cosine"}
        )
        self.text_collection = self.chroma_client.get_or_create_collection(
            name="texts"
        )

    def get_image_embedding(self, image: Image.Image) -> np.ndarray:
        """이미지를 CLIP 임베딩으로 변환합니다."""
        inputs = self.clip_processor(
            images=image,
            return_tensors="pt"
        )
        with torch.no_grad():
            features = self.clip_model.get_image_features(**inputs)
            features = torch.nn.functional.normalize(features, p=2, dim=-1)
        return features.numpy()[0]

    def get_text_embedding(self, text: str) -> np.ndarray:
        """텍스트를 CLIP 임베딩으로 변환합니다."""
        inputs = self.clip_processor(
            text=[text],
            return_tensors="pt",
            padding=True,
            truncation=True
        )
        with torch.no_grad():
            features = self.clip_model.get_text_features(**inputs)
            features = torch.nn.functional.normalize(features, p=2, dim=-1)
        return features.numpy()[0]

    def index_image(
        self,
        image: Image.Image,
        image_id: str,
        metadata: dict = None
    ):
        """이미지를 인덱싱합니다."""
        embedding = self.get_image_embedding(image)

        # 이미지를 Base64로 저장
        buffer = io.BytesIO()
        image.save(buffer, format="PNG")
        image_b64 = base64.b64encode(buffer.getvalue()).decode('utf-8')

        doc_metadata = {"image_b64": image_b64}
        if metadata:
            doc_metadata.update(metadata)

        self.image_collection.add(
            embeddings=[embedding.tolist()],
            ids=[image_id],
            metadatas=[doc_metadata]
        )

    def search_images_by_text(
        self,
        query: str,
        n_results: int = 5
    ) -> list[dict]:
        """텍스트로 이미지를 검색합니다."""
        query_embedding = self.get_text_embedding(query)

        results = self.image_collection.query(
            query_embeddings=[query_embedding.tolist()],
            n_results=n_results,
            include=["metadatas", "distances", "ids"]
        )

        retrieved = []
        for i in range(len(results['ids'][0])):
            metadata = results['metadatas'][0][i]
            image_b64 = metadata.pop('image_b64', None)

            image = None
            if image_b64:
                image_bytes = base64.b64decode(image_b64)
                image = Image.open(io.BytesIO(image_bytes))

            retrieved.append({
                "id": results['ids'][0][i],
                "distance": results['distances'][0][i],
                "metadata": metadata,
                "image": image
            })

        return retrieved

    def multimodal_rag_query(
        self,
        question: str,
        vision_model_fn,  # GPT-4V, Claude Vision 등
        n_image_results: int = 3
    ) -> str:
        """멀티모달 RAG 쿼리를 수행합니다."""

        # 관련 이미지 검색
        relevant_images = self.search_images_by_text(question, n_image_results)

        if not relevant_images:
            return vision_model_fn(question=question, images=[])

        # 검색된 이미지로 응답 생성
        retrieved_images = [r["image"] for r in relevant_images if r["image"]]
        metadata_info = [
            f"이미지 {i+1}: {r['metadata']}"
            for i, r in enumerate(relevant_images)
        ]

        enhanced_prompt = f"""
질문: {question}

관련 이미지 정보:
{chr(10).join(metadata_info)}

위의 이미지들을 참고하여 질문에 답변해주세요.
각 이미지의 관련 내용을 구체적으로 인용하세요.
"""

        return vision_model_fn(question=enhanced_prompt, images=retrieved_images)

# ColPali: 비전 언어 모델로 PDF 페이지 직접 검색
# pip install colpali-engine

from colpali_engine.models import ColPali, ColPaliProcessor
import torch

class ColPaliPDFSearch:
    """ColPali를 사용한 PDF 페이지 검색."""

    def __init__(self, model_name: str = "vidore/colpali-v1.2"):
        self.model = ColPali.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="cuda"
        )
        self.processor = ColPaliProcessor.from_pretrained(model_name)

    def index_pdf_pages(
        self,
        page_images: list[Image.Image]
    ) -> torch.Tensor:
        """PDF 페이지 이미지들을 인덱싱합니다."""
        all_embeddings = []

        batch_size = 4
        for i in range(0, len(page_images), batch_size):
            batch = page_images[i:i + batch_size]
            inputs = self.processor.process_images(batch)
            inputs = {k: v.to("cuda") for k, v in inputs.items()}

            with torch.no_grad():
                embeddings = self.model(**inputs)

            all_embeddings.append(embeddings)

        return torch.cat(all_embeddings, dim=0)

    def search(
        self,
        query: str,
        page_embeddings: torch.Tensor,
        top_k: int = 3
    ) -> list[int]:
        """쿼리로 관련 PDF 페이지를 검색합니다."""
        # 쿼리 임베딩
        query_inputs = self.processor.process_queries([query])
        query_inputs = {k: v.to("cuda") for k, v in query_inputs.items()}

        with torch.no_grad():
            query_embedding = self.model(**query_inputs)

        # MaxSim 스코어 계산 (ColPali의 핵심)
        scores = self.processor.score_multi_vector(
            query_embedding,
            page_embeddings
        )

        # Top-K 페이지 인덱스 반환
        top_indices = scores[0].argsort(descending=True)[:top_k]
        return top_indices.tolist()

from transformers import AutoModelForCausalLM, AutoProcessor
import torch
from PIL import Image

class Phi3VisionModel:
    """Microsoft Phi-3 Vision 모델."""

    def __init__(self):
        model_id = "microsoft/Phi-3-vision-128k-instruct"

        self.model = AutoModelForCausalLM.from_pretrained(
            model_id,
            device_map="cuda",
            trust_remote_code=True,
            torch_dtype=torch.bfloat16,
            _attn_implementation='flash_attention_2'  # CUDA 필요
        )

        self.processor = AutoProcessor.from_pretrained(
            model_id,
            trust_remote_code=True
        )

    def analyze(self, image: Image.Image, prompt: str) -> str:
        """이미지를 분석합니다."""
        messages = [
            {"role": "user", "content": f"<|image_1|>\n{prompt}"}
        ]

        prompt_text = self.processor.tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )

        inputs = self.processor(
            prompt_text,
            [image],
            return_tensors="pt"
        ).to("cuda")

        with torch.no_grad():
            output = self.model.generate(
                **inputs,
                max_new_tokens=500,
                eos_token_id=self.processor.tokenizer.eos_token_id
            )

        generated = output[0][inputs['input_ids'].shape[1]:]
        return self.processor.decode(generated, skip_special_tokens=True)

from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info
import torch

class QwenVLModel:
    """Qwen2-VL 멀티모달 모델."""

    def __init__(self, model_name: str = "Qwen/Qwen2-VL-7B-Instruct"):
        self.model = Qwen2VLForConditionalGeneration.from_pretrained(
            model_name,
            torch_dtype=torch.bfloat16,
            attn_implementation="flash_attention_2",
            device_map="auto"
        )
        self.processor = AutoProcessor.from_pretrained(
            model_name,
            min_pixels=256*28*28,
            max_pixels=1280*28*28
        )

    def analyze_image(
        self,
        image_path: str,
        question: str
    ) -> str:
        """이미지를 분석합니다."""
        messages = [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "image": image_path
                    },
                    {
                        "type": "text",
                        "text": question
                    }
                ]
            }
        ]

        text = self.processor.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )

        image_inputs, video_inputs = process_vision_info(messages)

        inputs = self.processor(
            text=[text],
            images=image_inputs,
            videos=video_inputs,
            padding=True,
            return_tensors="pt"
        ).to("cuda")

        with torch.no_grad():
            output_ids = self.model.generate(**inputs, max_new_tokens=512)

        generated_ids = [
            output_ids[len(input_ids):]
            for input_ids, output_ids in zip(inputs.input_ids, output_ids)
        ]

        return self.processor.batch_decode(
            generated_ids,
            skip_special_tokens=True,
            clean_up_tokenization_spaces=False
        )[0]

# Ollama로 멀티모달 모델 로컬 실행
# ollama.ai에서 Ollama 설치

# LLaVA 모델 다운로드 및 실행
ollama pull llava:13b

# 이미지와 함께 모델 실행
ollama run llava:13b

import ollama
from pathlib import Path

class OllamaVisionModel:
    """Ollama를 사용한 로컬 비전 모델."""

    def __init__(self, model: str = "llava:13b"):
        self.model = model

    def analyze(
        self,
        image_path: str,
        prompt: str
    ) -> str:
        """로컬 모델로 이미지를 분석합니다."""
        response = ollama.chat(
            model=self.model,
            messages=[
                {
                    "role": "user",
                    "content": prompt,
                    "images": [image_path]
                }
            ]
        )
        return response["message"]["content"]

    def batch_analyze(
        self,
        image_paths: list[str],
        prompt: str
    ) -> list[str]:
        """여러 이미지를 순차 분석합니다."""
        results = []
        for path in image_paths:
            result = self.analyze(path, prompt)
            results.append(result)
        return results

# 사용 예시
model = OllamaVisionModel("llava:13b")
result = model.analyze(
    "/path/to/image.jpg",
    "이 이미지에 무엇이 있나요? 자세히 설명해주세요."
)
print(result)

from transformers import VideoMAEImageProcessor, VideoMAEModel
import torch
import numpy as np

class VideoFeatureExtractor:
    """VideoMAE를 사용한 비디오 특징 추출기."""

    def __init__(self, model_name: str = "MCG-NJU/videomae-base"):
        self.processor = VideoMAEImageProcessor.from_pretrained(model_name)
        self.model = VideoMAEModel.from_pretrained(model_name)

    def extract_video_features(
        self,
        video_frames: list,  # PIL 이미지 또는 numpy 배열 목록
        num_frames: int = 16  # VideoMAE는 보통 16프레임 사용
    ) -> torch.Tensor:
        """비디오 프레임에서 특징을 추출합니다."""

        # 균일하게 프레임 샘플링
        total_frames = len(video_frames)
        indices = np.linspace(0, total_frames - 1, num_frames, dtype=int)
        sampled_frames = [video_frames[i] for i in indices]

        # 전처리
        inputs = self.processor(sampled_frames, return_tensors="pt")

        with torch.no_grad():
            outputs = self.model(**inputs)

        # [batch, num_patches, hidden_size] 형태
        return outputs.last_hidden_state

# OpenCV로 비디오 프레임 추출
import cv2

def extract_frames_from_video(
    video_path: str,
    target_fps: int = 1
) -> list:
    """비디오에서 프레임을 추출합니다."""
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_interval = int(fps / target_fps)

    frames = []
    frame_count = 0

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        if frame_count % frame_interval == 0:
            # BGR을 RGB로 변환
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            from PIL import Image
            pil_frame = Image.fromarray(frame_rgb)
            frames.append(pil_frame)

        frame_count += 1

    cap.release()
    return frames

import google.generativeai as genai
import time

class LongVideoUnderstanding:
    """Gemini 1.5 Pro를 사용한 긴 비디오 이해 시스템."""

    def __init__(self):
        self.model = genai.GenerativeModel("gemini-1.5-pro")

    def analyze_long_video(
        self,
        video_path: str,
        analysis_tasks: list[str]
    ) -> dict:
        """최대 1시간 길이의 비디오를 분석합니다."""

        print("비디오 업로드 중...")
        video_file = genai.upload_file(
            path=video_path,
            display_name="long_video_analysis"
        )

        # 처리 완료 대기
        while video_file.state.name == "PROCESSING":
            print(f"처리 중... (상태: {video_file.state.name})")
            time.sleep(15)
            video_file = genai.get_file(video_file.name)

        if video_file.state.name != "ACTIVE":
            raise RuntimeError(f"비디오 처리 실패: {video_file.state.name}")

        print(f"업로드 완료 (URI: {video_file.uri})")

        results = {}

        for task in analysis_tasks:
            print(f"분석 중: {task}")
            response = self.model.generate_content(
                [video_file, task],
                request_options={"timeout": 900}
            )
            results[task] = response.text

        # 업로드된 파일 정리
        genai.delete_file(video_file.name)
        print("파일 정리 완료")

        return results

    def create_video_summary(self, video_path: str) -> dict:
        """비디오의 종합 요약을 생성합니다."""
        tasks = [
            "비디오의 전체 내용을 3-5문장으로 요약해주세요.",
            "주요 장면을 타임스탬프와 함께 나열해주세요. 형식: MM:SS - 설명",
            "비디오에 등장하는 주요 인물, 사물, 장소를 목록으로 나열해주세요.",
            "비디오에서 강조된 핵심 메시지나 결론은 무엇인가요?",
            "이 비디오의 대상 시청자와 목적은 무엇인가요?"
        ]

        return self.analyze_long_video(video_path, tasks)

# 비디오 이해 시스템 활용
video_analyzer = LongVideoUnderstanding()
summary = video_analyzer.create_video_summary("lecture.mp4")

for task, result in summary.items():
    print(f"\n{'='*50}")
    print(f"질문: {task}")
    print(f"답변: {result}")