다중 모델 A/B 테스트 프레임워크: 품질 최고 · 비용 최소 조합 자동 탐색

AI 애플리케이션 개발에서 단일 모델 의존은 리스크입니다. 같은 작업이라도 모델마다 응답 품질과 비용이 극적으로 다릅니다. 이번 튜토리얼에서는 HolySheep AI를 활용해 다중 모델 A/B 테스트를 자동화하고, 품질과 비용 측면에서 최적의 모델 조합을 찾는 실전 프레임워크를 구축합니다.

플랫폼 비교: HolySheep AI vs 공식 API vs 기타 릴레이 서비스

A/B 테스트 프레임워크 개요

우리가 구축할 프레임워크의 핵심 기능:

• 동시 호출: 여러 모델에 동일한 프롬프트 동시 전송
• 자동 품질 평가: 응답 품질 점수화 시스템
• 비용 추적: 각 모델별 토큰 사용량 및 비용 실시간 모니터링
• 최적 조합 추천: 품질/비용 비율 기반 자동 추천
• failover: 특정 모델 실패 시 자동 대체

프로젝트 설정

# 필요한 패키지 설치
pip install openai python-dotenv pandas numpy aiohttp

프로젝트 구조
'''
multi_model_ab_test/
├── config.py          # 모델 설정 및 가격 정보
├── evaluator.py       # 품질 평가 로직
├── ab_tester.py       # 핵심 A/B 테스트 엔진
├── cost_tracker.py    # 비용 추적 및 보고
├── main.py            # 실행 엔트리포인트
└── results/           # 테스트 결과 저장 디렉토리
'''

설정 파일: config.py

import os
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class ModelConfig:
    name: str
    provider: str
    price_per_mtok_input: float
    price_per_mtok_output: float
    max_tokens: int
    temperature: float = 0.7

HolySheep AI에서 지원하는 주요 모델 및 가격 설정
MODEL_CONFIGS: Dict[str, ModelConfig] = {
    "gpt-4.1": ModelConfig(
        name="gpt-4.1",
        provider="openai",
        price_per_mtok_input=8.0,  # $8/MTok
        price_per_mtok_output=8.0,
        max_tokens=128000,
        temperature=0.7
    ),
    "claude-sonnet-4": ModelConfig(
        name="claude-sonnet-4",
        provider="anthropic",
        price_per_mtok_input=4.5,  # $4.5/MTok
        price_per_mtok_output=15.0,  # $15/MTok output
        max_tokens=200000,
        temperature=0.7
    ),
    "gemini-2.5-flash": ModelConfig(
        name="gemini-2.5-flash",
        provider="google",
        price_per_mtok_input=2.5,  # $2.50/MTok
        price_per_mtok_output=10.0,
        max_tokens=1000000,
        temperature=0.7
    ),
    "deepseek-v3": ModelConfig(
        name="deepseek-v3",
        provider="deepseek",
        price_per_mtok_input=0.42,  # $0.42/MTok - 최고 가성비
        price_per_mtok_output=1.68,
        max_tokens=64000,
        temperature=0.7
    ),
}

HolySheep AI API 설정
HOLYSHEEP_CONFIG = {
    "base_url": "https://api.holysheep.ai/v1",
    "api_key": os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY"),
}

테스트 설정
TEST_CONFIG = {
    "max_concurrent_requests": 4,
    "timeout_seconds": 60,
    "max_retries": 3,
    "quality_threshold": 0.7,  # 최소 품질 임계값
}

품질 평가기: evaluator.py

import re
from typing import Dict, Optional
from dataclasses import dataclass

@dataclass
class QualityScore:
    overall_score: float  # 0.0 - 1.0
    coherence: float      # 일관성 점수
    completeness: float   # 완전성 점수
    accuracy: float       # 정확성 점수
    helpfulness: float    # 유용성 점수
    reasoning: str        # 평가 근거

class ResponseEvaluator:
    """AI 응답 품질 자동 평가 시스템"""
    
    def __init__(self):
        self.penalty_keywords = [
            "i'm sorry", "sorry", "cannot", "can't", 
            "unable to", "apologize", "오류", "에러"
        ]
        self.quality_indicators = [
            "therefore", "consequently", "additionally",
            "furthermore", "moreover", "however",
            "정리하면", "결론적으로", "즉", "따라서"
        ]
    
    def evaluate(self, prompt: str, response: str, 
                 expected_keywords: Optional[List[str]] = None) -> QualityScore:
        """응답 품질 평가 실행"""
        
        # 기본 품질 지표 계산
        coherence = self._calculate_coherence(response)
        completeness = self._calculate_completeness(response, prompt)
        accuracy = self._calculate_accuracy(response)
        helpfulness = self._calculate_helpfulness(response)
        
        # 키워드 매칭 점수 (expected_keywords가 제공된 경우)
        keyword_score = 1.0
        if expected_keywords:
            keyword_score = self._calculate_keyword_match(response, expected_keywords)
        
        # 가중 평균으로 전체 점수 계산
        overall_score = (
            coherence * 0.2 +
            completeness * 0.25 +
            accuracy * 0.25 +
            helpfulness * 0.15 +
            keyword_score * 0.15
        )
        
        reasoning = self._generate_reasoning(
            coherence, completeness, accuracy, helpfulness, keyword_score
        )
        
        return QualityScore(
            overall_score=round(overall_score, 3),
            coherence=round(coherence, 3),
            completeness=round(completeness, 3),
            accuracy=round(accuracy, 3),
            helpfulness=round(helpfulness, 3),
            reasoning=reasoning
        )
    
    def _calculate_coherence(self, response: str) -> float:
        """응답 일관성 점수 계산"""
        if not response or len(response) < 20:
            return 0.0
        
        # 문장 수 대비 평균 문장 길이
        sentences = re.split(r'[.!?]+', response)
        sentences = [s.strip() for s in sentences if s.strip()]
        
        if not sentences:
            return 0.3
        
        avg_sentence_length = sum(len(s) for s in sentences) / len(sentences)
        
        # 적절한 문장 길이 (20-200자) 범위 확인
        if 20 <= avg_sentence_length <= 200:
            length_score = 1.0
        else:
            length_score = max(0.3, 1.0 - abs(avg_sentence_length - 100) / 200)
        
        # 불일치 키워드 감점
        penalty = sum(1 for kw in self.penalty_keywords if kw.lower() in response.lower())
        penalty_score = max(0.3, 1.0 - penalty * 0.2)
        
        return (length_score + penalty_score) / 2
    
    def _calculate_completeness(self, response: str, prompt: str) -> float:
        """응답 완전성 점수 계산"""
        if not response:
            return 0.0
        
        # 질문 유형 감지
        question_types = {
            "why": r'\b(porque|why|because|이유|원인|왜)\b',
            "how": r'\b(how|cmo|어떻게|방법|ways)\b',
            "what": r'\b(what|qu|es|무엇|뭔가|정의)\b',
            "compare": r'\b(compare|diferencia|차이|비교|vs)\b',
            "list": r'\b(first|second|third|primero|둘째|첫째|ordered)\b'
        }
        
        detected_type = None
        for qtype, pattern in question_types.items():
            if re.search(pattern, prompt.lower()):
                detected_type = qtype
                break
        
        # 질문 유형별 완전성 판단
        base_score = min(1.0, len(response) / 500)  # 기본 길이 점수
        
        if detected_type == "list":
            list_markers = len(re.findall(r'\d+[.)]|\b(primero|segundo|tercero|둘째|셋째|첫째)\b', response))
            if list_markers >= 3:
                base_score = min(1.0, base_score + 0.3)
        
        return base_score
    
    def _calculate_accuracy(self, response: str) -> float:
        """응답 정확성 점수 계산 (형식 기반)"""
        if not response:
            return 0.0
        
        score = 0.5  # 기본 점수
        
        # 품질 지표 키워드 presence
        quality_count = sum(1 for kw in self.quality_indicators if kw.lower() in response.lower())
        score += min(0.3, quality_count * 0.1)
        
        # 구체적 수치나 예시 포함 시 가점
        numbers = re.findall(r'\d+', response)
        if len(numbers) > 0:
            score += 0.1
        
        # 코드 블록이나 구조화된 응답 가점
        if '```' in response or '•' in response or '-' in response:
            score += 0.1
        
        return min(1.0, score)
    
    def _calculate_helpfulness(self, response: str) -> float:
        """응답 유용성 점수 계산"""
        if not response:
            return 0.0
        
        # 길이 기반 유용성 (너무 짧으면 불필요)
        length_score = min(1.0, len(response) / 300)
        
        # 불필요한 반복 감점
        words = response.lower().split()
        if len(words) > 10:
            unique_ratio = len(set(words)) / len(words)
            if unique_ratio < 0.5:
                length_score *= 0.7
        
        return length_score
    
    def _calculate_keyword_match(self, response: str, 
                                  keywords: List[str]) -> float:
        """기대 키워드 매칭 점수"""
        response_lower = response.lower()
        matches = sum(1 for kw in keywords if kw.lower() in response_lower)
        return matches / len(keywords) if keywords else 1.0
    
    def _generate_reasoning(self, coherence: float, 
                           completeness: float, accuracy: float,
                           helpfulness: float, keyword_score: float) -> str:
        """평가 근거 생성"""
        reasons = []
        
        if coherence >= 0.8:
            reasons.append("응답 구조가 일관성 있음")
        elif coherence < 0.5:
            reasons.append("일관성 개선 필요")
        
        if completeness >= 0.8:
            reasons.append("내용이 충분히 충실함")
        
        if accuracy >= 0.8:
            reasons.append("정보 정확도 높음")
        
        return "; ".join(reasons) if reasons else "보통 수준의 응답"

A/B 테스트 엔진: ab_tester.py

import asyncio
import time
import json
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass, field
from datetime import datetime
from openai import AsyncOpenAI, RateLimitError, APIError
import anthropic

from config import MODEL_CONFIGS, HOLYSHEEP_CONFIG, TEST_CONFIG
from evaluator import ResponseEvaluator, QualityScore
from cost_tracker import CostTracker

@dataclass
class ModelResult:
    model_name: str
    response: str
    quality_score: QualityScore
    tokens_used: int
    cost: float
    latency_ms: float
    success: bool
    error_message: Optional[str] = None

@dataclass
class ABTestResult:
    test_id: str
    timestamp: str
    prompt: str
    results: Dict[str, ModelResult] = field(default_factory=dict)
    best_model: Optional[str] = None
    best_cost_efficiency: Optional[str] = None
    total_cost: float = 0.0
    execution_time_ms: float = 0.0

class MultiModelABTester:
    """다중 모델 A/B 테스트 핵심 엔진"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.client = AsyncOpenAI(
            api_key=api_key,
            base_url=HOLYSHEEP_CONFIG["base_url"]
        )
        self.evaluator = ResponseEvaluator()
        self.cost_tracker = CostTracker()
        
        # Claude용 별도 클라이언트 (호환성을 위해)
        self.anthropic_client = anthropic.AsyncAnthropic(
            api_key=api_key,
            base_url=f"{HOLYSHEEP_CONFIG['base_url']}/anthropic"
        )
    
    async def test_models(
        self,
        prompt: str,
        models: List[str],
        system_prompt: Optional[str] = None,
        expected_keywords: Optional[List[str]] = None,
        temperature: float = 0.7
    ) -> ABTestResult:
        """선택된 모델들에 대해 동시 A/B 테스트 실행"""
        
        test_id = f"test_{int(time.time())}_{hash(prompt) % 10000}"
        start_time = time.time()
        
        # 선택된 모델 유효성 검사
        valid_models = [m for m in models if m in MODEL_CONFIGS]
        
        if not valid_models:
            raise ValueError(f"유효한 모델이 없습니다. 선택: {models}, 사용 가능: {list(MODEL_CONFIGS.keys())}")
        
        # 동시 호출 태스크 생성
        tasks = []
        for model_name in valid_models:
            task = self
관련 리소스
📚 AI API 기술 문서
💰 요금제 보기
📖 개발자 문서
🚀 무료 가입
관련 문서