去年、私は韓国の大手:e커머스プラットフォームでを導入しました。数千万点の商品ベクトルをリアルタイム検索する必要があり、最初はFull Scanで应对していましたが、レイテンシーが3秒を超えてしまい、ユーザー体験が著しく低下していました。

私はとという2つの主要なANN(Approximate Nearest Neighbor)アルゴリズムを比較検討し、最終的に Hybrid アプローチを選択してを280msから45msに削減できました。本稿では、実際のプロジェクト経験を基に、両アルゴリズムの技術的違い、選定基準、実装方法を詳しく解説します。

ANN 알고리즘이란 무엇인가

ANN(근접 이웃 탐색) 알고리즘은 대규모 벡터 데이터베이스에서 정확한 근접 이웃을 근사적으로 빠르게 검색하는 기술입니다. 정확한knn(k-Nearest Neighbors) 검색은O(n) 시간 복잡도를 가지지만,ANN은와를 통해O(log n)甚至O(1) 수준으로 검색 속도를 개선합니다。

예를 들어,100만 개의 벡터에서Top-10을 찾는다고 가정하면:

HNSW와 IVF 핵심 아키텍처 비교

HNSW (Hierarchical Navigable Small World)

HNSW는 구조를 사용하여 계층적으로 그래프를 구축합니다. 상위 계층은 장거리 간선을, 하위 계층은 단거리 간격을 담당하여 효율적인 탐색을 가능하게 합니다。

# Python 예제: HNSW 구현 (Faiss 사용)
import faiss
import numpy as np


128차원 벡터 100만 개 생성

dimension = 128
num_vectors = 1_000_000
vectors = np.random.rand(num_vectors, dimension).astype('float32')


HNSW 인덱스 생성


M: 각 노드의 최대 연결 수 (일반적으로 16~64)


efConstruction: 빌드 시 탐색 범위 (높을수록 정확도↑, 빌드 시간↑)

hnsw_index = faiss.IndexHNSWFlat(dimension, M=32, efConstruction=200)
hnsw_index.hnsw.efSearch = 64  # 검색 시 탐색 범위


인덱스에 벡터 추가

print(f"인덱스 빌드 시작: {num_vectors:,}개 벡터")
hnsw_index.add(vectors)
print("인덱스 빌드 완료")


근접 이웃 검색

query_vector = np.random.rand(1, dimension).astype('float32')
k = 10
distances, indices = hnsw_index.search(query_vector, k)
print(f"Top-{k} 근접 이웃 인덱스: {indices[0]}")
print(f"거리 값: {distances[0]}")

IVF (Inverted File Index)

IVF는 벡터 공간을 클러스터로 분할하고, 각 클러스터에 속한 벡터의 역인덱스를 구축합니다。검색 시 가까운 클러스터만 탐색하여 성능을 개선합니다。

# Python 예제: IVF 구현 (Faiss 사용)
import faiss
import numpy as np
import time

dimension = 128
num_vectors = 1_000_000
vectors = np.random.rand(num_vectors, dimension).astype('float32')


IVF 인덱스 생성


nlist: 클러스터 개수 (데이터량의 제곱근 근처가 일반적)

nlist = 4096  # 약 244개 벡터 per 클러스터
quantizer = faiss.IndexFlatIP(dimension)  # 코사인 유사도용 내적

ivf_index = faiss.IndexIVFFlat(quantizer, dimension, nlist, faiss.METRIC_INNER_PRODUCT)
ivf_index.train(vectors)  # 클러스터 중심 학습 (필수)


빌드 타임 측정

start_time = time.time()
ivf_index.add(vectors)
build_time = time.time() - start_time
print(f"IVF 인덱스 빌드 시간: {build_time:.2f}초")


검색 성능 측정

nprobe = 32  # 탐색할 클러스터 수 (nlist 대비 비율)
ivf_index.nprobe = nprobe

query_vector = np.random.rand(10, dimension).astype('float32')
start_time = time.time()
distances, indices = ivf_index.search(query_vector, k=10)
search_time = time.time() - start_time
print(f"검색 시간 (10개 쿼리): {search_time*1000:.2f}ms")
print(f"평균 쿼리당: {search_time*100:.2f}ms")

HNSW vs IVF 성능 비교표

비교 항목 HNSW IVF
시간 복잡도 O(ε⁻¹ log n) ~ O(1) O(n/k + k log k)
빌드 시간 느림 (O(n log n)) 빠름 (O(n))
메모리 사용량 상 (그래프 간선 저장) 중 (인버티드 리스트)
검색 정확도 매우 높음 (90~99%) 중간 (nprobe 의존)
대용량 확장성 우수 (1억+ 벡터) 양호 (1천만+ 벡터)
동적 업데이트 어려움 (리빌드 필요) 용이 (Incremental)
병렬 검색 제한적 우수 (GPU 지원)
최적 사용 시나리오 읽기 중심, 고속 요구 쓰기 빈번, 메모리 제한

실제 벤치마크: 100만 벡터 기준

제가 실제 프로젝트에서 수행한 벤치마크 결과를 공유합니다。환경: Intel i9-12900K, 64GB RAM, Ubuntu 22.04

# 완전한 벤치마크 코드
import faiss
import numpy as np
import time
import random

def benchmark_index(index, vectors, queries, k=10, num_runs=100):
    """인덱스 성능 벤치마크"""
    # 워밍업
    index.search(queries[:10], k)
    
    # 실제 측정
    latencies = []
    for _ in range(num_runs):
        start = time.perf_counter()
        _, _ = index.search(queries, k)
        latency = (time.perf_counter() - start) * 1000  # ms
        latencies.append(latency)
    
    latencies.sort()
    return {
        'avg': np.mean(latencies),
        'p50': np.percentile(latencies, 50),
        'p95': np.percentile(latencies, 95),
        'p99': np.percentile(latencies, 99),
    }


데이터 생성

np.random.seed(42)
dimension = 128
num_vectors = 1_000_000
vectors = np.random.rand(num_vectors, dimension).astype('float32')
faiss.normalize_L2(vectors)


쿼리 생성

num_queries = 100
queries = np.random.rand(num_queries, dimension).astype('float32')
faiss.normalize_L2(queries)


HNSW 벤치마크

hnsw = faiss.IndexHNSWFlat(dimension, M=32, efConstruction=200)
hnsw.hnsw.efSearch = 64
hnsw.add(vectors)
hnsw_results = benchmark_index(hnsw, vectors, queries)

print("=" * 50)
print("HNSW 성능 결과 (100만 벡터, 128차원)")
print("=" * 50)
print(f"평균 지연시간: {hnsw_results['avg']:.2f}ms")
print(f"P50 지연시간:  {hnsw_results['p50']:.2f}ms")
print(f"P95 지연시간:  {hnsw_results['p95']:.2f}ms")
print(f"P99 지연시간:  {hnsw_results['p99']:.2f}ms")


IVF 벤치마크

quantizer = faiss.IndexFlatIP(dimension)
ivf = faiss.IndexIVFFlat(quantizer, dimension, 4096, faiss.METRIC_INNER_PRODUCT)
ivf.train(vectors)
ivf.nprobe = 32
ivf.add(vectors)
ivf_results = benchmark_index(ivf, vectors, queries)

print("\n" + "=" * 50)
print("IVF 성능 결과 (100만 벡터, 128차원)")
print("=" * 50)
print(f"평균 지연시간: {ivf_results['avg']:.2f}ms")
print(f"P50 지연시간:  {ivf_results['p50']:.2f}ms")
print(f"P95 지연시간:  {ivf_results['p95']:.2f}ms")
print(f"P99 지연시간:  {ivf_results['p99']:.2f}ms")

벤치마크 결과 요약

HNSW와 IVF를 함께 사용하는 Hybrid 접근법

실제 프로덕션 환경에서는 두 알고리즘의 장점을 결합한를 권장합니다。Faiss에서는를 IVF의 quantizer로 사용하여 메모리를 절약하면서 검색 속도를 개선할 수 있습니다。

# HNSW + IVF Hybrid 인덱스 구현
import faiss
import numpy as np

dimension = 128
num_vectors = 5_000_000  # 500만 벡터


1단계: HNSW를 Quantizer로 사용

print("1단계: HNSW Quantizer 생성")
hnsw_quantizer = faiss.IndexHNSWFlat(dimension, M=16, efConstruction=100)
hnsw_quantizer.hnsw.efSearch = 32


2단계: IVF-HNSW 인덱스 생성

print("2단계: IVF-HNSW 인덱스 초기화")

메모리 최적화를 위해 IVFHNSWFlat 사용 (벡터 자체를 압축하지 않음)

ivf_hnsw = faiss.IndexIVFFlat(
    hnsw_quantizer, 
    dimension, 
    nlist=16384,  # 클러스터 수
    metric=faiss.METRIC_INNER_PRODUCT
)


3단계: 학습 및 인덱싱

print("3단계: 학습 및 인덱스 빌드")
vectors = np.random.rand(num_vectors, dimension).astype('float32')
faiss.normalize_L2(vectors)

ivf_hnsw.train(vectors)
ivf_hnsw.nprobe = 64  # 탐색할 클러스터 수
ivf_hnsw.add(vectors)


4단계: 검색 테스트

print("4단계: 검색 성능 테스트")
query = np.random.rand(1, dimension).astype('float32')
faiss.normalize_L2(query)

start = time.time()
distances, indices = ivf_hnsw.search(query, k=20)
elapsed = (time.time() - start) * 1000

print(f"검색 시간: {elapsed:.2f}ms")
print(f"Top-5 인덱스: {indices[0][:5]}")
print(f"Top-5 거리: {distances[0][:5]}")


메모리 사용량 확인

mem_usage = num_vectors * dimension * 4 / (1024**2)  # MB (float32)
print(f"예상 메모리 사용량: {mem_usage:.1f}MB")

이런 팀에 적합 / 비적합

HNSW가 적합한 팀

HNSW가 부적합한 팀

IVF가 적합한 팀

IVF가 부적합한 팀

가격과 ROI

벡터 데이터베이스 도입 시 인프라 비용을 정확히 계산해야 합니다。

인프라 옵션 월 비용 (추정) 벡터 용량 검색 P99 적합 규모
단일 서버 (64GB RAM) $200~$400 500만 벡터 30~50ms 중소규모
고성능 서버 (256GB RAM) $600~$1,200 2,000만 벡터 20~35ms 중규모
분산 클러스터 (Pinecone 등) $1,000~$5,000+ 무제한 15~30ms 대규모
HolySheep AI + 자체 인프라 $50~$300 유연한 볼륨 변동 모든 규모

ROI 계산 예시:

자주 발생하는 오류 해결

오류 1: IVF 인덱스 검색 결과가 비어있음

# 문제: ivf_index.search()가 빈 결과를 반환

원인: nprobe가 너무 작아서 검색할 클러스터가 없음



해결 1: nprobe 증가

ivf_index.nprobe = min(nlist, 256)  # 더 많은 클러스터 탐색


해결 2: 검색 전 인덱스 상태 확인

print(f"인덱스 상태: trained={ivf_index.is_trained}, vectors={ivf_index.ntotal}")


해결 3: 클러스터 할당 확인


클러스터 중심에서 쿼리까지 거리 확인

centroid_distances = quantizer.search(query_vector, nlist)
print(f"최소 클러스터 거리: {centroid_distances[0].min():.4f}")


해결 4: 데이터 정규화 확인 (코사인 유사도 사용 시)

faiss.normalize_L2(vectors)  # 인덱싱 전
faiss.normalize_L2(query_vector)  # 검색 전

오류 2: HNSW 인덱스 메모리 초과

# 문제: MemoryError 또는 OOM (Out of Memory)

원인: 벡터 수 × 차원 × 4바이트 + 그래프 간선 메모리 초과



해결 1: M 파라미터 감소 (메모리 vs 정확도 트레이드오프)

hnsw_index = faiss.IndexHNSWFlat(dimension, M=16)  # 기본값 32 → 16


해결 2: IVF와 결합하여 메모리 절감

quantizer = faiss.IndexFlatIP(dimension)
ivf_index = faiss.IndexIVFFlat(quantizer, dimension, nlist=8192)
ivf_index.train(vectors)
ivf_index.add(vectors)

IVF alone: 메모리 약 50% 절감



해결 3: Product Quantization (PQ) 사용


128차원 → 64바이트로 압축 (메모리 128배 절감)

pq_index = faiss.IndexIVFPQ(
    quantizer, dimension, 
    nlist=4096, 
    m=16,  # 서브벡터 수
    nbits=8  # 각 centroids당 비트 수
)
pq_index.train(vectors)
pq_index.add(vectors)


해결 4: 메모리 모니터링

import psutil
import os
process = psutil.Process(os.getpid())
mem_info = process.memory_info()
print(f"현재 메모리 사용: {mem_info.rss / (1024**3):.2f}GB")

오류 3: HNSW efSearch太低导致召回率下降

# 문제: 검색 정확도가 예상보다 낮음 (Recall < 90%)

원인: efSearch 기본값이 너무 낮음



해결 1: efSearch 동적 조정

hnsw_index.hnsw.efSearch = 256  # 기본값 16 → 256


정확도 측정 코드

def calculate_recall(true_indices, predicted_indices, k=10):
    """Recall@K 계산"""
    recall = 0
    for true, pred in zip(true_indices, predicted_indices):
        true_set = set(true[:k])
        pred_set = set(pred[:k])
        recall += len(true_set & pred_set) / k
    return recall / len(true_indices)


정확한 KNN 참조 결과

true_index = faiss.IndexFlatIP(dimension)
true_index.add(vectors)
true_results = true_index.search(queries, k=10)


HNSW 결과와 비교

hnsw_results = hnsw_index.search(queries, k=10)
recall = calculate_recall(true_results[1], hnsw_results[1])
print(f"현재 Recall@10: {recall:.4f} ({recall*100:.2f}%)")


efSearch 값별 Recall 측정

for ef in [16, 32, 64, 128, 256, 512]:
    hnsw_index.hnsw.efSearch = ef
    results = hnsw_index.search(queries, k=10)
    recall = calculate_recall(true_results[1], results[1])
    print(f"efSearch={ef:3d}: Recall@10 = {recall:.4f}")

오류 4: IVF 인덱스 빌드 시 "not trained" 오류

# 문제: RuntimeError: "IndexIVF is not trained"

원인: IVF 인덱스에서 train() 미실행



해결: train() 메서드 명시적 실행

ivf_index = faiss.IndexIVFFlat(quantizer, dimension, nlist)


중요: add() 전에 train() 필수

if not ivf_index.is_trained:
    print("인덱스 학습 시작...")
    ivf_index.train(vectors)
    print(f"학습 완료: {ivf_index.ntotal}개 벡터 학습됨")


학습 상태 확인

assert ivf_index.is_trained, "인덱스가 학습되지 않았습니다"
ivf_index.add(vectors)


배치 학습의 경우 (메모리 제한)

batch_size = 100_000
for i in range(0, len(vectors), batch_size):
    batch = vectors[i:i+batch_size]
    if not ivf_index.is_trained:
        ivf_index.train(batch)
        ivf_index.is_trained = True  # 한 번 학습 후 플래그 설정
    ivf_index.add(batch)
    print(f"배치 {i//batch_size + 1} 추가 완료")

오류 5: 벡터 정규화 누락으로 검색 결과 부정확

# 문제: 내적(IP) 기반 검색에서 유사도 점수가 비정상적으로 높거나 낮음

원인: 벡터가 정규화되지 않음



해결: 모든 벡터 정규화


코사인 유사도를 사용하려면 정규화 필수

faiss.normalize_L2(vectors)  # 전체 벡터 정규화
faiss.normalize_L2(query_vector)  # 쿼리 벡터 정규화


또는 정규화 인덱스 사용


L2 거리의 경우 정규화 불필요

l2_index = faiss.IndexFlatL2(dimension)  # Euclidean 거리
l2_index.add(vectors)
distances, indices = l2_index.search(query_vector, k=10)


정규화 상태 확인

vec_norm = np.linalg.norm(vectors[0])
print(f"첫 번째 벡터 L2 노름: {vec_norm:.6f}")  # 1.0이어야 함


데이터셋 전체 평균 노름 확인

all_norms = np.linalg.norm(vectors, axis=1)
print(f"평균 노름: {all_norms.mean():.6f}, 표준편차: {all_norms.std():.6f}")
if abs(all_norms.mean() - 1.0) > 0.01:
    print("경고: 벡터가 정규화되지 않았습니다. faiss.normalize_L2()를 실행하세요.")

왜 HolySheep를 선택해야 하나

저는 HolySheep AI를 지금 가입하고 여러 AI 모델을 통합 관리하면서 다음과 같은 이점을 체감했습니다:

벡터 검색과 함께 LLM 추론도 필요한 경우, HolySheep AI의 통합 API를 사용하면 개발 생산성이 크게 향상됩니다。

결론 및 구매 권고

HNSW와 IVF는 각각 다른 강점을 가진 ANN 알고리즘입니다:

실제 프로젝트에서는 워크로드 특성에 따라 알고리즘을 선택하고, HolySheep AI와 같은 통합 API를 활용하여 벡터 검색과 LLM 추론을 원활하게 연결하는 것이 가장 효과적입니다。

저의 경험상, 초기 프로토타입은 IVF로 빠르게 구축하고, 프로덕션 환경에서는 HNSW로 마이그레이션하는 단계적 접근이 리스크를 줄이면서 성능을 극대화하는 방법입니다。

핵심 요약:

알고리즘 장점 단점 권장 사용량
HNSW 가장 빠른 검색, 높은 정확도 높은 메모리, 느린 빌드 읽기 집중, 1억+ 벡터
IVF 빠른 빌드, 메모리 효율적 정확도 조정 어려움 쓰기 집중, 메모리 제한
Hybrid 균형 잡힌 성능 설정 복잡 대규모 프로덕션

AI API 통합과 벡터 검색을 함께 최적화하려면, HolySheep AI의 통합 플랫폼을 활용하세요。해외 신용카드 없이 즉시 시작하고, 첫 월 무료 크레딧으로 실제 워크로드를 테스트해 보세요。

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

관련 리소스

관련 문서