2026년 생성형 AI 시장은 다중모드(Multimodal) 모델 중심으로 빠르게 진화하고 있습니다. 단일 모델로 텍스트, 이미지, 비디오, 오디오를 동시에 이해하고 처리할 수 있는 능력이 핵심 경쟁력으로 부상했죠. 본 튜토리얼에서는 Google의 Gemini 2.0 Flash 다중모드 API를 활용하여 이미지 분석, 비디오 이해, 오디오 처리, 그리고 이 세 가지를 통합하는 실전 프로젝트를 단계별로 구현하겠습니다.
2026년 주요 모델 비용 비교
프로젝트를 시작하기 전에, 먼저 비용 효율성을 비교해보겠습니다. 월 1,000만 토큰 사용 시 각 모델의 비용을 정리하면 다음과 같습니다.
| 모델 | 출력 비용 ($/MTok) | 월 10M 토큰 비용 | 주요 특징 |
|---|---|---|---|
| GPT-4.1 | $8.00 | $80 | 최고 품질 텍스트 처리 |
| Claude Sonnet 4.5 | $15.00 | $150 | 긴 컨텍스트, 안전성 |
| Gemini 2.5 Flash | $2.50 | $25 | 다중모드, 고속 처리 |
| DeepSeek V3.2 | $0.42 | $4.20 | 초저비용 텍스트 중심 |
可以看到，Gemini 2.5 Flash는 GPT-4.1 대비 3.2배 저렴하고, Claude Sonnet 4.5 대비 6배 저렴합니다. 특히 다중모드 작업을 수행할 때는 Gemini의 비용 효율성이 더욱 빛을 발합니다. 월 1,000만 토큰 기준 Gemini 2.5 Flash는 GPT-4.1 대비 월 $55 절감, Claude 대비는 월 $125 절감 효과가 있습니다.
HolySheep AI 소개
지금 가입하여 HolySheep AI의 글로벌 AI API 게이트웨이 서비스를 경험해보세요. HolySheep AI는 해외 신용카드 없이 로컬 결제를 지원하며, 단일 API 키로 GPT-4.1, Claude, Gemini, DeepSeek 등 모든 주요 모델을 통합하여 사용할 수 있습니다. 특히 Gemini 2.5 Flash 출력 $2.50/MTok의 경쟁력 있는 가격과 안정적인 연결을 제공하여 프로덕션 환경에 최적화되어 있습니다.
Python 환경 설정
# 필요한 패키지 설치
pip install openai python-dotenv pillow requests
프로젝트 디렉토리 구조
project/
├── .env
├── image_analysis.py
├── video_understanding.py
├── audio_processing.py
├── multimodal_unified.py
└── assets/
├── sample_image.jpg
├── sample_video.mp4
└── sample_audio.mp3
# .env 파일 설정
HolySheep AI API 키 설정 (https://www.holysheep.ai/api-keys 에서 생성)
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
HOLYSHEEP_BASE_URL=https://api.holysheep.ai/v1Gemini 2.0 Flash 다중모드 API 개요
Gemini 2.0 Flash는 Google의 최신 다중모드 모델로, 다음과 같은 핵심 capability를 제공합니다.
- 이미지 이해: 사진, 차트, 다이어그램,スクリーン샷 분석
- 비디오 이해: 프레임 간 관계 파악, 동작 인식, 장면 설명
- 오디오 처리: 음성 인식, 화자 구분,音频 내용 요약
- 통합 추론: 텍스트+이미지+오디오 조합 분석
1. 이미지 분석实战
먼저 가장 기본적인 사용 사례인 이미지 분석부터 시작하겠습니다. 저는 실무에서 이 기능을用于 자동화 문서 처리와 제품 이미지 분류에 활용하고 있습니다.
"""
HolySheep AI를 통한 Gemini 2.0 Flash 이미지 분석
저장 공간이 부족한 이미지를Base64 인코딩하여 전송
"""
import base64
import os
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
HolySheep AI 클라이언트 초기화
client = OpenAI(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url=os.getenv("HOLYSHEEP_BASE_URL")
)
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 analyze_product_image(image_path: str, product_context: str = "") -> dict:
"""
제품 이미지 분석 함수
Args:
image_path: 분석할 이미지 파일 경로
product_context: 추가 컨텍스트 (선택사항)
Returns:
분석 결과를 담은 딕셔너리
"""
# 이미지Base64 인코딩
base64_image = encode_image_to_base64(image_path)
prompt = f"""
이 제품 이미지를 상세히 분석해주세요.
분석 항목:
1. 제품 카테고리 및 유형
2. 주요 색상 및 디자인 특징
3. 품질 상태 (신상품/중고/손상 등)
4. 브랜드 여부 및 브랜드명 (판독 가능한 경우)
5. 예상 가격대 (시장 평균 기준)
추가 컨텍스트: {product_context if product_context else "없음"}
결과를 구조화된 형식(JSON)으로 반환해주세요.
"""
response = client.chat.completions.create(
model="gemini-2.0-flash",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": prompt
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}",
"detail": "high"
}
}
]
}
],
max_tokens=1024,
temperature=0.3
)
return {
"analysis": response.choices[0].message.content,
"usage": {
"input_tokens": response.usage.input_tokens,
"output_tokens": response.usage.output_tokens,
"total_tokens": response.usage.total_tokens
}
}
def analyze_chart_image(image_path: str, chart_type: str = "auto") -> dict:
"""차트/그래프 이미지 분석"""
base64_image = encode_image_to_base64(image_path)
prompt = f"""
이 차트 이미지를 분석해주세요.
분석 항목:
1. 차트 유형 ({chart_type})
2. X축/Y축 라벨 및 단위
3. 주요 데이터 포인트 및 추세
4. 핵심 인사이트 3가지
5. 데이터 기반 결론
결과를 마크다운 표 형식으로 정리해주세요.
"""
response = client.chat.completions.create(
model="gemini-2.0-flash",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}", "detail": "high"}}
]
}
],
max_tokens=1536
)
return {
"chart_analysis": response.choices[0].message.content,
"tokens_used": response.usage.total_tokens
}
사용 예제
if __name__ == "__main__":
# 제품 이미지 분석
result = analyze_product_image(
"assets/product_sample.jpg",
product_context="온라인 마켓플레이스 판매용"
)
print("=== 제품 이미지 분석 결과 ===")
print(result["analysis"])
print(f"\n토큰 사용량: {result['usage']['total_tokens']}")
# 비용 계산 (Gemini 2.5 Flash 기준)
input_cost = result["usage"]["input_tokens"] / 1_000_000 * 0.075 # $0.075/MTok 입력
output_cost = result["usage"]["output_tokens"] / 1_000_000 * 2.50 # $2.50/MTok 출력
total_cost = input_cost + output_cost
print(f"예상 비용: ${total_cost:.4f}")2. 비디오 이해实战
비디오 분석은 여러 프레임을 순차적으로 전송하여 시간적 맥락을 이해하게 합니다. 저는 고객 지원 채널의 비디오 통화를 분석하여 자동 태깅과 요약에 활용하고 있습니다.
"""
Gemini 2.0 Flash 비디오 이해 API
여러 프레임 이미지를 시퀀스로 전송하여 비디오 내용 분석
"""
import base64
import cv2
import os
from openai import OpenAI
from dotenv import load_dotenv
from typing import List, Tuple
load_dotenv()
client = OpenAI(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url=os.getenv("HOLYSHEEP_BASE_URL")
)
def extract_video_frames(video_path: str, num_frames: int = 8) -> List[str]:
"""
비디오에서 균등하게 프레임 추출
Args:
video_path: 비디오 파일 경로
num_frames: 추출할 프레임 수 (기본 8개)
Returns:
Base64 인코딩된 프레임 이미지 목록
"""
cap = cv2.VideoCapture(video_path)
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
fps = cap.get(cv2.CAP_PROP_FPS)
duration = total_frames / fps if fps > 0 else 0
frame_indices = [int(i * total_frames / num_frames) for i in range(num_frames)]
frames = []
for idx, frame_num in enumerate(frame_indices):
cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
ret, frame = cap.read()
if ret:
# BGR -> RGB 변환
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# 이미지 저장 후Base64 인코딩
import tempfile
with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as f:
temp_path = f.name
cv2.imwrite(temp_path, cv2.cvtColor(frame_rgb, cv2.COLOR_RGB2BGR))
with open(temp_path, "rb") as img_file:
frames.append(base64.b64encode(img_file.read()).decode("utf-8"))
os.unlink(temp_path)
cap.release()
print(f"비디오时长: {duration:.1f}초, {total_frames}프레임에서 {len(frames)}개 추출")
return frames
def analyze_video_content(video_path: str, analysis_type: str = "full") -> dict:
"""
비디오 내용 종합 분석
Args:
video_path: 분석할 비디오 파일 경로
analysis_type: "full" | "summary" | "highlights"
Returns:
비디오 분석 결과
"""
# 프레임 추출 (8개 프레임 사용)
frames = extract_video_frames(video_path, num_frames=8)
if analysis_type == "summary":
prompt = """
이 비디오의 내용을 30초 이내로 요약해주세요.
포함할 내용:
- 주요 장면 3개
- 전체적인 내용/스토리
- 핵심 메시지
"""
elif analysis_type == "highlights":
prompt = """
이 비디오에서 주요 하이라이트(하이라이트) 5가지를 추출해주세요.
각 하이라이트에 대해:
- 타임스탬프 (비디오 시작 시점 기준)
- 해당 장면의 내용
- 하이라이트로 선정한 이유
"""
else: # full
prompt = """
이 비디오의 전체 내용을 상세히 분석해주세요.
분석 항목:
1. 비디오 유형 (교육/엔터테인먼트/뉴스/마케팅 등)
2. 주요 등장인물/오브젝트
3. 주요 собыms 및 타임라인
4. 전체적인 톤 및 스타일
5. 핵심 인사이트 및 결론
6. 비디오 품질 평가
결과를 마크다운 형식으로 작성해주세요.
"""
# 프레임을 메시지 컨텐트에 추가
content = [{"type": "text", "text": prompt}]
for idx, frame_base64 in enumerate(frames):
content.append({
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{frame_base64}",
"detail": "low" # 비디오는 저해상도로 충분
}
})
response = client.chat.completions.create(
model="gemini-2.0-flash",
messages=[
{
"role": "user",
"content": content
}
],
max_tokens=2048,
temperature=0.2
)
return {
"analysis_type": analysis_type,
"result": response.choices[0].message.content,
"frames_analyzed": len(frames),
"tokens": response.usage.total_tokens,
"cost_estimate": f"${response.usage.total_tokens / 1_000_000 * 2.50:.4f}"
}
def detect_video_changes(video_path: str) -> List[dict]:
"""비디오 장면 전환 감지"""
frames = extract_video_frames(video_path, num_frames=16)
prompt = """
이 비디오의 16개 프레임을 분석하여 장면 전환점을 감지해주세요.
각 프레임에 대해:
- 타임스탬프 (추정치)
- 주요 변경 내용
- 장면 전환 여부 (예/아니오)
장면 전환이 감지된 시점을 명시해주세요.
"""
content = [{"type": "text", "text": prompt}]
for frame_base64 in frames:
content.append({
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{frame_base64}", "detail": "low"}
})
response = client.chat.completions.create(
model="gemini-2.0-flash",
messages=[{"role": "user", "content": content}],
max_tokens=1536
)
return {
"scene_detection": response.choices[0].message.content,
"frames_analyzed": len(frames)
}
사용 예제
if __name__ == "__main__":
# 전체 비디오 분석
result = analyze_video_content(
"assets/sample_video.mp4",
analysis_type="highlights"
)
print(f"=== 비디오 분석 결과 ({result['analysis_type']}) ===")
print(result["result"])
print(f"\n분석 프레임: {result['frames_analyzed']}")
print(f"토큰 사용: {result['tokens']}")
print(f"예상 비용: {result['cost_estimate']}")3. 오디오 처리实战
오디오 분석의 경우, HolySheep AI에서는 Whisper API를 통한 음성 인식과 Gemini를 통한音频内容 이해를 조합하여 사용합니다. 저는 콜센터录音 분석에 이 기능을 활용하여 고객 감정 분석과 이슈 분류를 자동화했습니다.
"""
HolySheep AI 음성 처리 솔루션
Whisper + Gemini 조합으로音频 변환 및 분석
"""
import os
import base64
import requests
from openai import OpenAI
from dotenv import load_dotenv
from typing import Optional, List
load_dotenv()
client = OpenAI(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url=os.getenv("HOLYSHEEP_BASE_URL")
)
def transcribe_audio(audio_path: str, language: Optional[str] = None) -> dict:
"""
Whisper API를 통한 음성 → 텍스트 변환
Args:
audio_path: 오디오 파일 경로
language: 언어 코드 (예: "ko", "en", "ja") - None이면 자동 감지
Returns:
변환된 텍스트 및 메타데이터
"""
with open(audio_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
language=language,
response_format="verbose_json"
)
return {
"text": response.text,
"language": getattr(response, "language", "auto-detected"),
"duration": getattr(response, "duration", None)
}
def analyze_audio_content(audio_path: str, analysis_focus: str = "general") -> dict:
"""
오디오 파일 내용 분석
1단계: Whisper로 텍스트 변환
2단계: Gemini로 내용 분석
Args:
audio_path: 분석할 오디오 파일 경로
analysis_focus: "general" | "meeting" | "call_center" | "interview"
Returns:
분석 결과
"""
# 1단계: 음성 인식
print("1단계: 음성 인식 중...")
transcription = transcribe_audio(audio_path)
transcript_text = transcription["text"]
print(f"변환 완료: {len(transcript_text)}자")
# 2단계: Gemini로 분석
print("2단계: 내용 분석 중...")
focus_prompts = {
"general": "이音频 내용을 분석하고 주요 내용을 요약해주세요.",
"meeting": """
이 회의 오디오를 분석해주세요.
분석 항목:
- 회의 참여자 및 역할
- 주요 논의 사항
- 결정된 사항
- 다음 단계/할 일
- 액션 아이템
""",
"call_center": """
이 콜센터 통화를 분석해주세요.
분석 항목:
- 고객 이슈 유형
- 고객 감정 상태 (positive/neutral/negative)
- 해결 여부
- 상담원 평가 (친절함/전문성/해결 능력)
- 개선 제안
""",
"interview": """
이 인터뷰 오디오를 분석해주세요.
분석 항목:
- 인터뷰어/인터뷰이
- 주요 질문 5개
- 핵심 답변/내용
- 인터뷰 분위기
"""
}
response = client.chat.completions.create(
model="gemini-2.0-flash",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": f"오디오 내용:\n{transcript_text}\n\n{focus_prompts.get(analysis_focus, focus_prompts['general'])}"}
]
}
],
max_tokens=2048,
temperature=0.3
)
return {
"transcription": transcript_text,
"analysis": response.choices[0].message.content,
"focus": analysis_focus,
"tokens": response.usage.total_tokens
}
def process_audio_batch(audio_files: List[str], batch_analysis: bool = True) -> List[dict]:
"""
여러 오디오 파일 배치 처리
Args:
audio_files: 오디오 파일 경로 목록
batch_analysis: True면 모든音频을 하나의 분석으로 처리
Returns:
각 파일의 분석 결과 목록
"""
results = []
for audio_file in audio_files:
print(f"\n처리 중: {audio_file}")
# 개별 오디오 처리
transcription = transcribe_audio(audio_file)
results.append({
"file": audio_file,
"transcript": transcription["text"],
"duration": transcription.get("duration")
})
if batch_analysis and len(results) > 1:
# 배치 분석 (모든 텍스트를 결합)
combined_transcripts = "\n\n---\n\n".join([
f"파일 {i+1}: {r['file']}\n{r['transcript']}"
for i, r in enumerate(results)
])
response = client.chat.completions.create(
model="gemini-2.0-flash",
messages=[
{
"role": "user",
"content": f"다음 {len(results)}개의 오디오 파일 내용을 분석해주세요:\n\n{combined_transcripts}\n\n각 파일의 핵심 내용과 전체적인 패턴/인사이트를 분석해주세요."
}
],
max_tokens=2048
)
# 배치 분석 결과를 각 결과에 추가
for result in results:
result["batch_analysis"] = response.choices[0].message.content
return results
사용 예제
if __name__ == "__main__":
# 단일 오디오 분석
result = analyze_audio_content(
"assets/sample_audio.mp3",
analysis_focus="call_center"
)
print("=== 오디오 내용 분석 ===")
print(result["analysis"])
print(f"\n토큰 사용: {result['tokens']}")
# 비용 계산
whisper_cost = 0.003 # Whisper: $0.003/분 (HolySheep 기준)
gemini_cost = result["tokens"] / 1_000_000 * 2.50
print(f"예상 비용: Whisper ${whisper_cost:.4f} + Gemini ${gemini_cost:.4f}")4. 다중모드 통합 시스템
실무에서는 단일 기능보다는 이미지, 비디오, 오디오를 조합하여 사용하는 경우가 많습니다. 아래는 미디어 콘텐츠 종합 분석 파이프라인을 구현한 것입니다.
"""
HolySheep AI 다중모드 통합 분석 시스템
이미지 + 비디오 + 오디오 + 텍스트 통합 처리 파이프라인
"""
import os
import base64
import cv2
from openai import OpenAI
from dotenv import load_dotenv
from typing import List, Dict, Optional, Union
from dataclasses import dataclass
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
load_dotenv()
client = OpenAI(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url=os.getenv("HOLYSHEEP_BASE_URL")
)
@dataclass
class MediaContent:
"""미디어 콘텐츠 데이터 클래스"""
text: Optional[str] = None
images: Optional[List[str]] = None # Base64 또는 URL
video_frames: Optional[List[str]] = None
audio_transcript: Optional[str] = None
metadata: Optional[Dict] = None
@dataclass
class AnalysisResult:
"""분석 결과 데이터 클래스"""
content_type: str
analysis: str
confidence: float
tags: List[str]
cost: float
processing_time: float
class MultimodalAnalyzer:
"""다중모드 콘텐츠 분석기"""
def __init__(self, api_key: str, base_url: str):
self.client = OpenAI(api_key=api_key, base_url=base_url)
def analyze_image(self, image_path: str) -> AnalysisResult:
"""단일 이미지 분석"""
start_time = time.time()
with open(image_path, "rb") as f:
base64_image = base64.b64encode(f.read()).decode("utf-8")
prompt = """
이 이미지를 상세히 분석해주세요.
다음 항목 포함:
1. 이미지 유형 (사진/일러스트/차트/スクリーン샷 등)
2. 주요 콘텐츠 3가지
3. 핵심 정보/메시지
4. 태그 (쉼표로 구분, 5개 이하)
5. 신뢰도 점수 (0.0-1.0)
JSON 형식으로 반환:
{"type": "...", "content": [...], "message": "...", "tags": [...], "confidence": 0.0}
"""
response = self.client.chat.completions.create(
model="gemini-2.0-flash",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}", "detail": "high"}}
]
}
],
max_tokens=512
)
processing_time = time.time() - start_time
return AnalysisResult(
content_type="image",
analysis=response.choices[0].message.content,
confidence=0.85,
tags=["image", "analysis"],
cost=response.usage.total_tokens / 1_000_000 * 2.50,
processing_time=processing_time
)
def analyze_video(self, video_path: str, num_frames: int = 6) -> AnalysisResult:
"""비디오 분석"""
start_time = time.time()
# 프레임 추출
cap = cv2.VideoCapture(video_path)
total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
frames = []
for i in range(num_frames):
cap.set(cv2.CAP_PROP_POS_FRAMES, int(i * total / num_frames))
ret, frame = cap.read()
if ret:
_, buffer = cv2.imencode('.jpg', frame)
frames.append(base64.b64encode(buffer).decode("utf-8"))
cap.release()
prompt = """
이 비디오의 {num_frames}개 프레임을 분석해주세요.
분석 항목:
1. 비디오 내용 요약 (3문장 이내)
2. 주요 장면 3가지
3. 전체적인 분위기/톤
4. 태그 (5개 이하)
5. 신뢰도 점수
JSON 형식으로 반환해주세요.
""".format(num_frames=num_frames)
content = [{"type": "text", "text": prompt}]
for frame in frames:
content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{frame}", "detail": "low"}})
response = self.client.chat.completions.create(
model="gemini-2.0-flash",
messages=[{"role": "user", "content": content}],
max_tokens=768
)
processing_time = time.time() - start_time
return AnalysisResult(
content_type="video",
analysis=response.choices[0].message.content,
confidence=0.80,
tags=["video", "multiframe"],
cost=response.usage.total_tokens / 1_000_000 * 2.50,
processing_time=processing_time
)
def analyze_media_content(self, content: MediaContent) -> Dict:
"""
통합 다중모드 분석
이미지, 비디오, 오디오, 텍스트 조합 분석
"""
results = {}
total_cost = 0
total_time = 0
with ThreadPoolExecutor(max_workers=3) as executor:
futures = {}
if content.images:
for idx, img in enumerate(content.images):
future = executor.submit(self._analyze_single_image, img, idx)
futures[future] = f"image_{idx}"
if content.video_frames:
future = executor.submit(self._analyze_video_frames, content.video_frames)
futures[future] = "video"
if content.audio_transcript or content.text:
text = content.audio_transcript or content.text
future = executor.submit(self._analyze_text, text)
futures[future] = "text"
for future in as_completed(futures):
key = futures[future]
try:
result = future.result()
results[key] = result
total_cost += result.cost
total_time += result.processing_time
except Exception as e:
results[key] = {"error": str(e)}
# 통합 요약 생성
summary = self._generate_summary(results)
return {
"individual_results": results,
"summary": summary,
"total_cost": total_cost,
"total_processing_time": total_time,
"cost_per_content_type": {
k: v.cost if hasattr(v, 'cost') else 0
for k, v in results.items()
}
}
def _analyze_single_image(self, image_data: str, idx: int) -> AnalysisResult:
"""단일 이미지 분석 (내부용)"""
# image_data가 이미 base64인지 확인
if not image_data.startswith("data:"):
with open(image_data, "rb") as f:
image_data = base64.b64encode(f.read()).decode("utf-8")
response = self.client.chat.completions.create(
model="gemini-2.0-flash",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "이 이미지를 간단히 분석하고 태그 3개를 제시해주세요."},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_data}", "detail": "high"}}
]
}],
max_tokens=256
)
return AnalysisResult(
content_type=f"image_{idx}",
analysis=response.choices[0].message.content,
confidence=0.85,
tags=[],
cost=response.usage.total_tokens / 1_000_000 * 2.50,
processing_time=0
)
def _analyze_video_frames(self, frames: List[str]) -> AnalysisResult:
"""비디오 프레임 분석 (내부용)"""
content = [{"type": "text", "text": "이 비디오 프레임들을 분석하고 내용을 요약해주세요."}]
for frame in frames[:8]:
if not frame.startswith("data:"):
with open(frame, "rb") as f:
frame = base64.b64encode(f.read()).decode("utf-8")
content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{frame}", "detail": "low"}})
response = self.client.chat.completions.create(
model="gemini-2.0-flash",
messages=[{"role": "user", "content": content}],
max_tokens=512
)
return AnalysisResult(
content_type="video",
analysis=response.choices[0].message.content,
confidence=0.80,
tags=["video"],
cost=response.usage.total_tokens / 1_000_000 * 2.50,
processing_time=0
)
def _analyze_text(self, text: str) -> AnalysisResult:
"""텍스트 분석 (내부용)"""
response = self.client.chat.completions.create(
model="gemini-2.0-flash",
messages=[{
"role": "user",
"content": f"다음 텍스트를 분석하고 핵심 내용과 태그 3개를 제시해주세요.\n\n{text[:2000]}"
}],
max_tokens=256
)
return AnalysisResult(
content_type="text",
analysis=response.choices[0].message.content,
confidence=0.90,
tags=["text"],
cost=response.usage.total_tokens / 1_000_000 * 2.50,
processing_time=0
)
def _generate_summary(self, results: Dict) -> str:
"""결과 통합 요약 생성"""
if not results:
return "분석할 콘텐츠가 없습니다."
combined_analysis = "\n".join([
f"=== {k.upper()} ===\n{v.analysis if hasattr(v, 'analysis') else v}"
for k, v in results.items()
])
response = self.client.chat.completions.create(
model="gemini-2.0-flash",
messages=[{
"role": "user",
"content": f"다음 분석 결과를 통합하여 최종 요약을 작성해주세요:\n\n{combined_analysis}"
}],
max_tokens=512
)
return response.choices[0].message.content
사용 예제
if __name__ == "__main__":
analyzer = MultimodalAnalyzer(
api_key=os.getenv("HOLYSHEEP_API_KEY"),
base_url=os.getenv("HOLYSHEEP_BASE_URL")
)
# 통합 분석 예제
content = MediaContent(
text="제품 발표회가 열렸습니다. 참석자들은 새로운 라인업을 흥미롭게 살펴보았습니다.",
images=["assets/product_1.jpg", "assets/product_2.jpg"]
)
result = analyzer.analyze_media_content(content)
print("=== 다중모드 통합 분석 결과 ===")
print(result["summary"])
print(f"\n총 비용: ${result['total_cost']:.4f}")
print(f"처리 시간: {result['total_processing_time']:.2f}초")성능 최적화 팁
실무에서 저의 경험에 기반한 최적화 조언을 드리겠습니다.
- 프레임 수 최소화: 비디오 분석 시 8프레임 이상이면 대부분의 내용 파악 가능. 16프레임 이상은 비용만 증가
- 이미지 해상도 조정: high detail은 텍스트 분석 시만 사용, 일반 이미지 분석은 low detail로 충분
- 배치 처리 활용: 여러 파일 동시 처리 시 ThreadPoolExecutor로 병렬 처리
- 토큰 캐싱: 반복 분석 시 이전 결과를 캐시하여 API 호출 감소
비용 계산 예시
실제 프로덕션 환경에서의 비용을估算해 보겠습니다.
| 작업 유형 | 입력 | 출력 토큰 |
관련 리소스관련 문서 |
|---|