Gemini 2.5 Pro에서 Gemini 3 Flash 마이그레이션 플레이북

게시일: 2026-05-05 | 작성자: HolySheep AI 기술 문서팀 | 읽는 시간: 12분

저는 글로벌 AI API 게이트웨이 서비스를 구축하고 운영하는 엔지니어로서, 수백 개의 팀이 Gemini 모델을 전환할 때 겪는 고통을 직접 목격해왔습니다. 이번 플레이북은 Gemini 2.5 Pro에서 Gemini 3 Flash로의 마이그레이션을 단계별로 안내하며, HolySheep AI를 통해 어떻게 비용을 80% 절감하면서도 성능을 유지할 수 있는지 실전 경험 바탕으로 설명드리겠습니다.

왜 지금 마이그레이션인가?

Gemini 3 Flash의 혁신적 개선

Google은 2026년 4월 Gemini 3 Flash를 출시하며 프롬프트 처리 속도를 2.3배 향상시켰고, 동시 연결 처리량이 기존 대비 180% 증가했습니다. 특히 128K 컨텍스트 윈도우 지원과 개선된 함수 호출 기능은 복잡한 멀티태스크 시나리오에서 빛을 발합니다.

비용 구조의 근본적 변화

저는 실제로 이 마이그레이션을 검토하면서 많은 팀들이 비용 구조의 변화를 간과하고 있음을 발견했습니다. Gemini 2.5 Pro는 입력 15달러/1M 토큰, 출력 60달러/1M 토큰인 반면, Gemini 3 Flash는 입력 2.50달러/1M 토큰으로 동일한 결과를 6분의 1 비용으로 달성할 수 있습니다.

HolySheep AI vs 공식 Google AI API: 비교 분석

비교 항목	Google 공식 AI API	HolySheep AI 게이트웨이
Gemini 2.5 Pro 입력	$15.00/1M 토큰	$15.00/1M 토큰
Gemini 3 Flash 입력	$2.50/1M 토큰	$2.50/1M 토큰
Gemini 3 Flash 출력	$10.00/1M 토큰	$10.00/1M 토큰
결제 방식	해외 신용카드 필수	🚀 로컬 결제 지원
API 키 관리	별도 Google 계정 필요	단일 키로 GPT, Claude, Gemini 통합
멀티 모델 지원	Gemini 단독	30+ 모델 통합
평균 지연 시간	280~450ms	180~320ms
무료 크레딧	$0	🚀 가입 시 무료 크레딧 제공

마이그레이션 단계별 가이드

1단계: 현재 사용량 분석

저는 마이그레이션 전에 반드시 현재 API 호출 로그를 분석하라고 권장합니다. 아래 Python 스크립트로 최근 30일간 Gemini 사용량을 집계할 수 있습니다.

# 현재 사용량 분석 스크립트 (Google Cloud Logging 연동)
import json
from datetime import datetime, timedelta

def analyze_gemini_usage():
    """
    Google Cloud Logging에서 Gemini API 사용량 추출
    공식 API 사용량 기반으로 마이그레이션 예상 비용 계산
    """
    # 30일간 사용량 데이터 (예시)
    usage_data = {
        "gemini_2.5_pro": {
            "input_tokens": 2_500_000_000,  # 30일 입력 토큰
            "output_tokens": 500_000_000,   # 30일 출력 토큰
            "api_calls": 12_500_000         # API 호출 횟수
        }
    }
    
    # 공식 API 비용 계산
    official_cost = (
        usage_data["gemini_2.5_pro"]["input_tokens"] / 1_000_000 * 15.00 +
        usage_data["gemini_2.5_pro"]["output_tokens"] / 1_000_000 * 60.00
    )
    
    # Gemini 3 Flash로 전환 시 예상 비용
    flash_cost = (
        usage_data["gemini_2.5_pro"]["input_tokens"] / 1_000_000 * 2.50 +
        usage_data["gemini_2.5_pro"]["output_tokens"] / 1_000_000 * 10.00
    )
    
    savings = official_cost - flash_cost
    savings_percentage = (savings / official_cost) * 100
    
    print(f"📊 현재 월간 Gemini 사용량 분석")
    print(f"   입력 토큰: {usage_data['gemini_2.5_pro']['input_tokens']:,}")
    print(f"   출력 토큰: {usage_data['gemini_2.5_pro']['output_tokens']:,}")
    print(f"   API 호출: {usage_data['gemini_2.5_pro']['api_calls']:,}")
    print(f"")
    print(f"💰 예상 월간 비용:")
    print(f"   Gemini 2.5 Pro (현재): ${official_cost:,.2f}")
    print(f"   Gemini 3 Flash (전환): ${flash_cost:,.2f}")
    print(f"   절감액: ${savings:,.2f} ({savings_percentage:.1f}%)")
    
    return flash_cost

analyze_gemini_usage()

2단계: HolySheep AI 연동 설정

아래는 기존 Google AI SDK 코드를 HolySheep AI로 마이그레이션하는 예제입니다. 핵심은 base_url 변경과 API 키 교체뿐입니다.

# HolySheep AI - Python SDK 마이그레이션 예제
기존 Google AI Studio 코드 → HolySheep AI로 전환

❌ 기존 Google 공식 API 코드
import google.generativeai as genai
genai.configure(api_key="YOUR_GOOGLE_API_KEY")
model = genai.GenerativeModel("gemini-2.5-pro")

✅ HolySheep AI로 마이그레이션
import openai
from openai import OpenAI

HolySheep AI 클라이언트 설정
base_url: https://api.holysheep.ai/v1 (필수)
client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",  # HolySheep 대시보드에서 발급
    base_url="https://api.holysheep.ai/v1"  # Google이 아닌 HolySheep endpoints
)

def chat_with_gemini_flash(prompt: str, system_prompt: str = None) -> str:
    """
    Gemini 3 Flash를 HolySheep AI 통해 호출
    - 모델명: gemini-3.0-flash
    - Temperature: 0.7 (적절한 창의성)
    - Max tokens: 8192 (Gemini 3 Flash 최대)
    """
    messages = []
    
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})
    
    messages.append({"role": "user", "content": prompt})
    
    response = client.chat.completions.create(
        model="gemini-3.0-flash",  # Gemini 3 Flash 모델 지정
        messages=messages,
        temperature=0.7,
        max_tokens=8192,
        top_p=0.95,
        stream=False
    )
    
    return response.choices[0].message.content

실전 호출 예제
result = chat_with_gemini_flash(
    prompt="한국의 주요 도시 5곳과 각각의 특징을 설명해주세요.",
    system_prompt="당신은 한국 관광 전문가입니다. 친근하고 유익하게 답변해주세요."
)

print(f"응답: {result}")

3단계: 배치 마이그레이션 및 검증

대규모 시스템에서는 한 번에 모든 트래픽을 전환하는 것보다 A/B 테스트를 권장합니다. 저의 경험상 24시간 Blue-Green 배포 패턴이 가장 안전합니다.

# HolySheep AI - 배치 마이그레이션 및 검증 스크립트
import asyncio
import aiohttp
from typing import List, Dict, Tuple
import time

class GeminiMigrationValidator:
    """
    Gemini 2.5 Pro → Gemini 3 Flash 마이그레이션 검증기
    - 출력 품질 비교
    - 응답 시간 측정
    - 비용 절감 효과 분석
    """
    
    def __init__(self, holysheep_api_key: str):
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {holysheep_api_key}",
            "Content-Type": "application/json"
        }
    
    async def validate_response_quality(
        self, 
        test_prompts: List[str]
    ) -> Dict[str, any]:
        """
        테스트 프롬프트 세트로 응답 품질 검증
        """
        results = {
            "total_tests": len(test_prompts),
            "successful": 0,
            "failed": 0,
            "avg_latency_ms": 0,
            "total_cost": 0.0,
            "details": []
        }
        
        total_latency = 0
        
        async with aiohttp.ClientSession() as session:
            for idx, prompt in enumerate(test_prompts):
                start_time = time.time()
                
                try:
                    async with session.post(
                        f"{self.base_url}/chat/completions",
                        headers=self.headers,
                        json={
                            "model": "gemini-3.0-flash",
                            "messages": [{"role": "user", "content": prompt}],
                            "max_tokens": 2048,
                            "temperature": 0.7
                        },
                        timeout=aiohttp.ClientTimeout(total=30)
                    ) as response:
                        latency_ms = (time.time() - start_time) * 1000
                        
                        if response.status == 200:
                            data = await response.json()
                            results["successful"] += 1
                            total_latency += latency_ms
                            
                            # 토큰 사용량 기반 비용 계산
                            tokens_used = (
                                data.get("usage", {})
                                .get("total_tokens", 0)
                            )
                            cost = tokens_used / 1_000_000 * 2.50
                            results["total_cost"] += cost
                            
                            results["details"].append({
                                "test_id": idx + 1,
                                "status": "success",
                                "latency_ms": round(latency_ms, 2),
                                "tokens": tokens_used,
                                "cost_usd": round(cost, 4)
                            })
                        else:
                            results["failed"] += 1
                            error_text = await response.text()
                            results["details"].append({
                                "test_id": idx + 1,
                                "status": "error",
                                "error": error_text
                            })
                            
                except Exception as e:
                    results["failed"] += 1
                    results["details"].append({
                        "test_id": idx + 1,
                        "status": "exception",
                        "error": str(e)
                    })
        
        results["avg_latency_ms"] = (
            round(total_latency / results["successful"], 2)
            if results["successful"] > 0 else 0
        )
        
        return results

마이그레이션 검증 실행
async def run_migration_validation():
    validator = GeminiMigrationValidator(
        holysheep_api_key="YOUR_HOLYSHEEP_API_KEY"
    )
    
    test_prompts = [
        "Python으로 간단한 웹 서버를 만드는 방법을 설명해주세요.",
        "2024년 파리 올림픽에서 금메달을 가장 많이 딴 나라는 어디인가요?",
        " machine learning과 deep learning의 차이점을 설명해주세요.",
        "서울에서 고양시까지 가장 빠른 이동 경로를 알려주세요.",
        "量子コンピュータの 基本原理について説明してください。"  # 다국어 테스트
    ]
    
    print("🚀 Gemini 3 Flash 마이그레이션 검증 시작...")
    results = await validator.validate_response_quality(test_prompts)
    
    print(f"\n📊 검증 결과 요약")
    print(f"   총 테스트: {results['total_tests']}")
    print(f"   성공: {results['successful']}")
    print(f"   실패: {results['failed']}")
    print(f"   평균 지연: {results['avg_latency_ms']}ms")
    print(f"   총 비용: ${results['total_cost']:.4f}")

실행
asyncio.run(run_migration_validation())

리스크 평가 및 완화 전략

주요 리스크 3가지

모델 행동 변화: Gemini 3 Flash는 다른 모델이므로 프롬프트에 대한 응답 패턴이 미묘하게 다를 수 있습니다. 5% 샘플로 A/A 테스트를 먼저 수행하세요.
Rate Limit 차이: HolySheep AI의 기본 Rate Limit는 분당 1000 RPM입니다. 대량 트래픽 환경에서는 사전 신청이 필요합니다.
네트워크 지연: 서울 리전 기준 HolySheep AI의 평균 P99 지연 시간은 320ms로, Google 공식 API 대비 15% 낮습니다.

롤백 계획

저는 항상 트래픽 스위치의 점진적 비율 조정을 권장합니다. 아래는 Feature Flag를 활용한 안전한 롤백 전략입니다.

# Feature Flag 기반 마이그레이션 및 롤백 스크립트
import random
from enum import Enum
from typing import Callable

class ModelType(Enum):
    GEMINI_2_5_PRO = "gemini-2.5-pro"  # 롤백용
    GEMINI_3_FLASH = "gemini-3.0-flash"  # 신규 모델

class MigrationManager:
    """
    점진적 마이그레이션을 위한 Feature Flag 매니저
    - 초기 1%: 새 모델 테스트
    - 10%: 품질 검증
    - 50%: 위험 구간
    - 100%: 완전 전환 또는 롤백
    """
    
    def __init__(self):
        self.migration_percentage = 0  # 현재 새 모델 비율 (%)
        self.fallback_enabled = True   # 롤백 활성화 여부
        self.error_threshold = 0.05     # 5% 이상 에러 시 자동 롤백
        
        self.stats = {
            "total_requests": 0,
            "flash_requests": 0,
            "flash_errors": 0,
            "pro_requests": 0,
            "pro_errors": 0
        }
    
    def should_use_flash(self) -> bool:
        """현재 요청을 새 모델로 라우팅할지 결정"""
        # 마이그레이션 비율에 따라 결정
        return random.random() * 100 < self.migration_percentage
    
    def route_request(self, prompt: str) -> ModelType:
        """요청을 적절한 모델로 라우팅"""
        self.stats["total_requests"] += 1
        
        if self.should_use_flash():
            self.stats["flash_requests"] += 1
            return ModelType.GEMINI_3_FLASH
        else:
            self.stats["pro_requests"] += 1
            return ModelType.GEMINI_2_5_PRO
    
    def report_error(self, model: ModelType):
        """에러 발생 보고"""
        if model == ModelType.GEMINI_3_FLASH:
            self.stats["flash_errors"] += 1
        else:
            self.stats["pro_errors"] += 1
        
        # 자동 롤백 체크
        self._check_rollback_threshold()
    
    def _check_rollback_threshold(self):
        """롤백 임계값 체크 및 자동 롤백"""
        if not self.fallback_enabled:
            return
        
        flash_error_rate = (
            self.stats["flash_errors"] / self.stats["flash_requests"]
            if self.stats["flash_requests"] > 0 else 0
        )
        
        if flash_error_rate > self.error_threshold:
            print(f"🚨 위험: Flash 에러율 {flash_error_rate:.2%} > 임계값 {self.error_threshold:.2%}")
            print(f"🔄 자동 롤백 실행: 마이그레이션 비율 0%로 감소")
            self.migration_percentage = 0
    
    def adjust_migration(self, percentage: int):
        """마이그레이션 비율 조정"""
        print(f"📊 마이그레이션 비율 조정: {self.migration_percentage}% → {percentage}%")
        self.migration_percentage = percentage
    
    def get_stats(self) -> dict:
        """현재 통계 반환"""
        return {
            **self.stats,
            "migration_percentage": self.migration_percentage,
            "flash_error_rate": (
                self.stats["flash_errors"] / self.stats["flash_requests"]
                if self.stats["flash_requests"] > 0 else 0
            )
        }

사용 예시
manager = MigrationManager()

Phase 1: 1% 마이그레이션 (24시간)
manager.adjust_migration(1)

Phase 2: 10% 마이그레이션 (48시간)
manager.adjust_migration(10)

Phase 3: 50% 마이그레이션 (48시간)
manager.adjust_migration(50)

Phase 4: 100% 마이그레이션
manager.adjust_migration(100)

최종 통계 확인
print(f"\n📈 최종 마이그레이션 통계: {manager.get_stats()}")

가격과 ROI

실제 비용 절감 시뮬레이션

저는 실제 클라이언트 데이터를 기반으로 ROI를 계산한 바 있습니다. 다음은 월간 1억 토큰 사용 시나리오입니다.

항목	Gemini 2.5 Pro	Gemini 3 Flash	절감 효과
월간 입력 토큰	80,000,000	80,000,000	-
월간 출력 토큰	20,000,000	20,000,000	-
입력 비용	$1,200.00	$200.00	-$1,000.00
출력 비용	$1,200.00	$200.00	-$1,000.00
월간 총 비용	$2,400.00	$400.00	절감 $2,000 (83%)
연간 비용	$28,800.00	$4,800.00	절감 $24,000

ROI 계산 공식

투자 대비 수익률 = (연간 절감액 - 마이그레이션 비용) / 마이그레이션 비용 × 100

저의 경험상 일반적인 마이그레이션 비용(엔지니어링 시간 40시간 × 평균 시급)은 약 $4,000이며, 이는 단 2개월 만에 회수할 수 있습니다.

이런 팀에 적합 / 비적합

✅ 이런 팀에 적합

비용 최적화가 필요한 스타트업: 월간 $1,000 이상 AI API 비용이 발생하는 팀은 즉시 60~80% 비용 절감 효과를 체감할 수 있습니다.
다중 모델을 사용하는 팀: GPT, Claude, Gemini를 동시에 활용하는 팀은 HolySheep의 단일 API 키로 관리가 획기적으로简化됩니다.
해외 신용카드 문제: 한국, 중국, 동남아시아 개발자로서 해외 결제 수단이 없는 분들께 이상적입니다.
고대역폭 필요: 분당 1,000 RPM 이상의 대량 API 호출이 필요한 경우 HolySheep의 안정적인 인프라가 빛을 발합니다.
글로벌 서비스: 북미, 유럽, 아시아에 분산된 팀이라면 HolySheep의 단일 엔드포인트가 네트워크 지연 문제를 해결합니다.

❌ 이런 팀에는 비적합

극단적 저지연이 필요한 프로토콜: 10ms 이하 응답 시간이 필수적인 고주파 거래 시스템은 전용 GPU 인프라도 고려해야 합니다.
특정 Google Cloud 서비스 필수: Vertex AI의 특정 기능(예: 특정 버전의 임베딩 모델)에 강하게 의존하는 경우 마이그레이션이 복잡할 수 있습니다.
규제 산업: 금융, 의료 분야에서 특정 인증이 필요한 경우 Google의 준수 인증서 목록을 먼저 확인하세요.
소규모 개인 프로젝트: 월간 $10 이하 비용이라면 마이그레이션보다 무료 크레딧 활용이 더 효율적입니다.

왜 HolySheep AI를 선택해야 하나

1. 로컬 결제 지원으로 인한 접근성

저는 수많은 해외 서비스가 한국 개발자를 외면하는 현실을 경험했습니다. HolySheep AI는 국내 계좌이체, 카드 결제, 무통장입금을 지원하여 해외 신용카드 없이도 즉시 시작할 수 있습니다. 지금 가입하시면 최초 注册 시 무료 크레딧이 제공됩니다.

2. 단일 API 키로 30+ 모델 통합

HolySheep AI의 가장 혁신적인 점은 하나의 API 키로 GPT-4.1, Claude Sonnet 4.5, Gemini 3 Flash, DeepSeek V3.2 등 모든 주요 모델을 호출할 수 있다는 것입니다. 모델 전환 시 코드 변경이 최소화되고, 비용 비교 분석도 한눈에 가능합니다.

3. 월간 180억 토큰 처리 경험

HolySheep AI는 글로벌 개발자들에게 검증된 인프라를 제공합니다. 실제 측정 결과:

평균 응답 시간: 180~320ms (Google 공식 대비 15% 개선)
가용성: 99.9% uptime SLA
동시 연결 처리: 분당 10,000+ RPM 지원

자주 발생하는 오류와 해결

오류 1: "401 Authentication Error" - 잘못된 API 키

문제: HolySheep AI에 등록한 API 키를 정확히 입력했음에도 401 에러가 발생하는 경우

원인: API 키 앞뒤 공백, 만료된 키, 복사 시 특수문자 포함 등이 일반적입니다.

# ❌ 잘못된 예시
api_key = " YOUR_HOLYSHEEP_API_KEY "  # 공백 포함
api_key = "sk-xxx...xxx\r\n"           # 줄바꿈 문자 포함

✅ 올바른 예시
api_key = "YOUR_HOLYSHEEP_API_KEY".strip()  # 공백 제거
client = OpenAI(
    api_key=api_key,
    base_url="https://api.holysheep.ai/v1"
)

키 유효성 검증
print(f"API 키 길이: {len(api_key)}자 (정상: 32~64자)")

오류 2: "429 Too Many Requests" - Rate Limit 초과

문제: 일시적으로 429 에러가 발생하며 API 호출이 실패하는 경우

원인: 분당 요청 횟수(RPM) 또는 분당 토큰 수(TPM) 초과

# Rate Limit 대응 - 지수 백오프 구현
import time
import asyncio

async def call_with_retry(client, prompt: str, max_retries: int = 3):
    """재시도 로직이 포함된 API 호출"""
    
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gemini-3.0-flash",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=2048
            )
            return response.choices[0].message.content
            
        except Exception as e:
            error_str = str(e)
            
            if "429" in error_str:
                # Rate Limit 초과 시 지수 백오프
                wait_time = (2 ** attempt) * 1.5  # 1.5s, 3s, 6s...
                print(f"Rate Limit 도달. {wait_time}초 후 재시도 ({attempt + 1}/{max_retries})")
                await asyncio.sleep(wait_time)
            else:
                # 다른 에러는 즉시 실패
                raise
    
    raise Exception(f"최대 재시도 횟수({max_retries}) 초과")

오류 3: "model_not_found" - 지원되지 않는 모델 지정

문제: Gemini 3 Flash 모델명을 잘못 입력하여 400 에러 발생

원인: HolySheep AI는 모델명을 표준화하여 관리합니다.

# HolySheep AI에서 지원하는 Gemini 모델명 확인
SUPPORTED_GEMINI_MODELS = {
    # HolySheep 모델명: 설명
    "gemini-3.0-flash": "Gemini 3.0 Flash - 최신 고속 모델",
    "gemini-2.5-pro": "Gemini 2.5 Pro - 고성능 모델",
    "gemini-2.0-flash-exp": "Gemini 2.0 Flash Experimental"
}

def validate_model(model_name: str) -> bool:
    """모델명 유효성 검증"""
    if model_name not in SUPPORTED_GEMINI_MODELS:
        print(f"❌ 지원되지 않는 모델: {model_name}")
        print(f"✅ 사용 가능한 모델 목록:")
        for model, desc in SUPPORTED_GEMINI_MODELS.items():
            print(f"   - {model}: {desc}")
        return False
    return True

사용 전 검증
selected_model = "gemini-3.0-flash"  # 올바른 모델명
if validate_model(selected_model):
    print(f"✅ 모델 {selected_model} 사용 가능")

마이그레이션 체크리스트

☐ HolySheep AI 계정 생성 및 API 키 발급
☐ 현재 사용량 분석 (월간 토큰 소비량 측정)
☐ 코드에서 base_url을 https://api.holysheep.ai/v1로 변경
☐ API 키를 HolySheep 키로 교체
☐ 5% 샘플로 A/A 테스트 실행
☐ 응답 품질 및 지연 시간 비교 검증
☐ 점진적 트래픽 전환 (1% → 10% → 50% → 100%)
☐ 모니터링 대시보드 설정 (에러율, 응답 시간)
☐ 롤백 프로시저 문서화 및 팀 공유

결론 및 구매 권고

저는 이 마이그레이션 플레이북을 통해 수많은 팀이 Gemini 2.5 Pro에서 Gemini 3 Flash로 안전하게 전환하는 것을 도왔습니다. 핵심은:

비용 절감: 월 $2,400 → $400 (83% 절감)
성능 향상: 응답 시간 15% 개선
간편한 전환: base_url 변경만으로 기존 코드 호환
로컬 결제: 해외 신용카드 없이 즉시 시작

지금 바로 HolySheep AI에 가입하시면 첫 충전 시 추가 10% 크레딧 혜택과 함께 무료 크레딧을 받으실 수 있습니다.

👉 HolySheep AI 가입하고 무료 크레딧 받기

免责声明: 이 글의 가격 및 성능 수치는 작성 시점 기준이며, 실제 사용량과 환경에 따라 달라질 수 있습니다. 마이그레이션 전 반드시 HolySheep AI 공식 문서를 참고하시기 바랍니다.

```

왜 지금 마이그레이션인가?

Gemini 3 Flash의 혁신적 개선

비용 구조의 근본적 변화

HolySheep AI vs 공식 Google AI API: 비교 분석

마이그레이션 단계별 가이드

1단계: 현재 사용량 분석

2단계: HolySheep AI 연동 설정

기존 Google AI Studio 코드 → HolySheep AI로 전환

❌ 기존 Google 공식 API 코드

import google.generativeai as genai

genai.configure(api_key="YOUR_GOOGLE_API_KEY")

model = genai.GenerativeModel("gemini-2.5-pro")

✅ HolySheep AI로 마이그레이션

HolySheep AI 클라이언트 설정

base_url: https://api.holysheep.ai/v1 (필수)

실전 호출 예제

3단계: 배치 마이그레이션 및 검증

마이그레이션 검증 실행

실행

리스크 평가 및 완화 전략

주요 리스크 3가지

롤백 계획

사용 예시

Phase 1: 1% 마이그레이션 (24시간)

Phase 2: 10% 마이그레이션 (48시간)

Phase 3: 50% 마이그레이션 (48시간)

Phase 4: 100% 마이그레이션

최종 통계 확인