12. 벡터데이터베이스로 확장하기 : RAG 구현하기

☀️  Summary 

❍  벡터데이터베이스
❍  Indexing & Search : KNN, ANN(HNSW, IVF)
❍  파인콘

 

 

 

 

1.   벡터 데이터베이스란 

---

 

1.1  딥러닝과 벡터 데이터 베이스 

 

❍  벡터데이터베이스

 ↪︎  벡터 임베딩을 키로 사용하는 데이터베이스를 말한다. 벡터 사이의 거리 계산에 특화된 데이터베이스이다. 

 ↪︎  텍스트, 이미지 등의 비정형 데이터 뿐만 아니라 상품/사용자 같은 개념도 모두 임베딩 모델을 통해 벡터로 표현할 수 있다. 

 ↪︎  적절한 임베딩 모델을 통해 데이터를 임베딩 벡터로 변환했다면, 벡터 데이터베이스에 저장하고, 임베딩 벡터의 거리 계산을 통해 유사하거나 관련이 깊은 데이터를 검색할 수 있다. 

 

 

❍  딥러닝과 벡터DB

 

 

↪︎  머신러닝과 달리 딥러닝 모델은 Representation learning (표현학습) 을 통해, 데이터만 충분하다면 모델이 알아서 데이터의 특징추출까지도 자동으로 학습한다. 

 ↪︎  표현학습이 제대로 수행된 딥러닝 모델로 임베딩을 공간상에 배치하면, 비슷한 특징을 가진 데이터는 가깝게 다른 데이터는 멀게 위치하게 된다. 이러한 임베딩 벡터의 특징을 이용하면 벡터 사이의 거리를 계산해 서로 비슷한 데이터를 찾을 수 있다. 벡터DB는 이러한 임베딩벡터의 특징을 이용하기 위한 목적으로 개발되었다. 

 

 

❍  벡터DB활용 3단계

 

 

 ↪︎  1) 저장 : 저장할 데이터를 임베딩 모델을 거쳐 벡터로 변환하고, 벡터DB에 저장한다. 

 ↪︎  2) 검색 : 검색할 데이터(ex.검색쿼리)를 임베딩 모델을 거쳐 벡터로 변환하고, 벡터DB에서 검색한다. 

 ↪︎  3) 결과반환 : 벡터DB에서는 검색쿼리의 임베딩과 거리가 가까운 벡터를 찾아 반환한다. 

 

 ↪︎  벡터 사이의 거리를 측정하는 방법으로는 일반적으로 유클리디안거리, 코사인유사도, 점곱(내적)을 가장 많이 사용한다. 

 ↪︎  딥러닝 기술이 폭넓게 활용되며 데이터의 특징을 추출한 임베딩을 활용하는 경우가 많아졌고, 임베딩을 저장하고 관리하는 기능이 요구되며 여러 벡터DB가 등장했다. 핀터레스트같은 이미지 검색 기능이나 추천시스템을 구현할 때 많이 활용한다. 임베딩 벡터의 유사도를 기반으로 한 문서 검색을 활용하는 RAG가 LLM의 환각현상을 줄이고 학습 없이도 최신 정보를 추가하는 핵심 기법으로 활용되어 지금은 대부분의 DB에 벡터검색 기능이 추가되고 있다. 

 

 

 

1.2  벡터데이터베이스 지형 파악하기 

 

❍  벡터임베딩과 관련한 소프트웨어 종류

 ↪︎  1) 벡터 라이브러리 : Faiss, Annoy, NMSLIB, ScaNN 

       ↪︎  소규모 프로젝트에서는 벡터 라이브러리를 통해서 충분히 벡터 저장 및 검색 기능을 구현할 수 있다. 

 ↪︎  2) 벡터 전용 데이터베이스 : Pinecone, Weaviate, Milvus, Chroma, Qdrant, Vespa 

       ↪︎  저장, 검색, 메타데이터 저장 및 필터링, 백업 및 관리, 모니터링 및 AI도구 등과의 통합, 보안 및 엑세스 관리 

 ↪︎  3) 기존의 데이터베이스에 벡터 저장과 검색 기능을 추가 : Elasticsearch, PostgreSQL, MongoDB, Neo4j 

 

 

❍  벡터데이터베이스 구분

 

 

 ↪︎  고급 벡터 검색이나 워크로드(데이터수, 차원수 등)가 큰 경우, 왼쪽의 벡터 전용 데이터베이스를 선택하는 것이 좋고, 벡터 이외의 데이터 형태 처리까지도 원한다면 오른쪽 전용 데이터베이스를 활용하는 것이 좋다. 

 

 

 

 

2.   벡터 데이터베이스 작동 원리 

---

 

2.1  KNN검색과 한계 

 

❍  KNN검색

 ↪︎  검색하려는 벡터와 가장 가까운 K개의 이웃 벡터를 찾는 검색 방식

 ↪︎  직관적이고 모든 데이터를 조사하므로 정확하지만, 그만큼 연산량이 데이터 수에 비례하여 속도가 느려져 확장성이 떨어진다는 한계가 있다. 

 

 

❍  벡터검색

 ↪︎  1) Indexing (색인) : 인덱스에 벡터를 저장하는 과정 (검색을 위해 일종의 지도나 목차를 만드는 것) ➱ 인덱스의 메모리 사용량과 색인 시간이 중요

 ↪︎  2) Search : 검색 시간과 재현율(Recall)이 중요

 ↪︎  Recall : 실제로 가장 가까운 K개의 정답 데이터 중 몇 개가 검색 결과로 반환되었는지 비율을 나타낸 값, KNN은 모든 벡터를 검색하므로 항상 100% 

 

 

 

 

❍  실습데이터 불러오기

 

import time
import faiss
from faiss.contrib.datasets import DatasetSIFT1M

ds = DatasetSIFT1M()

xq = ds.get_queries()
xb = ds.get_database()
gt = ds.get_groundtruth()

 

 ↪︎  SIFT1M : 100만개의 128차원 임베딩 데이터

 ↪︎  faiss 라이브러리에서 제공하는 DatasetSIFT1M 클래스를 사용해, 내려받은 SIFT1M데이터셋을 불러온다. 

 ↪︎  xq : 검색에 사용할 데이터, xb : 저장된 벡터 데이터, gt : 실제 정답 데이터 

 

 

 

❍  데이터가 늘어날 때 색인/검색시간, 메모리 사용량 변화

 

k=1
d = xq.shape[1] 
nq = 1000 # 검색할 데이터 수 : 1000개 
xq = xq[:nq] 

for i in range(1, 10, 2): # 저장하는 데이터수를 점차 늘리기 
    start_memory = get_memory_usage_mb() 
    start_indexing = time.time() 
    index = faiss.IndexFlatL2(d) # 인덱스 만들기 
    index.add(xb[:(i+1)*100000]) # add메서드로 임베딩 벡터를 색인 
    end_indexing = time.time()
    end_memory = get_memory_usage_mb() # 메모리사용량 측정 (직접 함수 정의)

    t0 = time.time() 
    D, I = index.search(xq, k) # search 메서드로 검색 수행 
    t1 = time.time()
    print(f"데이터 {(i+1)*100000}개:")
    print(f"색인: {(end_indexing - start_indexing) * 1000 :.3f} ms ({end_memory - start_memory:.3f} MB) 검색: {(t1 - t0) * 1000 / nq :.3f} ms")

 

 

 ↪︎  데이터가 늘어나면서 색인 시간이 늘어나고, 메모리 사용량도 지속적으로 선형적으로 증가한다. 

 ↪︎  KNN검색의 경우에는, 인덱스에 더 빠른 검색을 위한 별도 데이터를 저장하지 않아 메모리 사용량이 작고, 색인시간도 거의 무시할 정도의 시간이 걸린다. 검색시간이 문제인 것

 ↪︎  임베딩 벡터의 차원이 커지면 검색에 더 오랜 시간이 걸린다. 즉, 벡터의 차원이 커지면 검색 속도가 느려진다. 실사례에서는 데이터가 크고 고차원인 경우가 많기 때문에 효율적으로 검색하는 다양한 알고리즘이 등장했다. 

 

 

 

 

2.2  ANN 검색이란 

 

❍  ANN

 ↪︎  근사최근접이웃 검색은 대용량 데이터에서 주어진 쿼리 항목과 가장 유사한 항목을 효율적으로 찾는 데 사용되는 기술 

 ↪︎  약간의 정확도를 희생하는 대신 훨씬 더 빠른 검색속도를 제공 

 ↪︎  검색 시 탐색 할 범위를 좁히는데 집중 

 ↪︎  대표적인 알고리즘 : IVF, HNSW 

 

 

❍  IVF

 

 ↪︎  검색 공간을 제한하기 위해, 데이터셋 벡터들을 클러스터로 그룹화하는 ANN 알고리즘 

 ↪︎  인덱싱 시점에 IVF는 데이터를 가져와 중심점(유사한 벡터들의 클러스터)을 형성 

 ↪︎  쿼리 시점에는 먼저 가장 가까운 중심점을 찾고, 해당 중심점 내에서 가장 가까운 데이터 포인트를 찾는다 

 ↪︎  검색되지 않은 클러스터에 할당된 일부 이웃을 놓칠 수 있다는 단점

 

 

 

❍  HNSW

 

 ↪︎  효율적인 ANN검색을 위한 그래프 기반 인덱싱 구조 

 ↪︎ 상위 계층은 연결이 적고, 하위 계층은 연결이 밀집된 다층 그래프를 구축한다. 

 ↪︎ 최상위 계층은 연결이 적어서 데이터 사이의 거리가 먼데, 한 번에 먼 거리를 이동할 수 있으므로 그래프를 빠르게 탐색할 수 있다. 각 하위 계층에는 더 많은 연결이 있어 꼼꼼한 탐색이 가능하다. 

 

 

❍  ANN 검색의 재현율

 ↪︎  재현율 = (예측 중 정답에 해당하는 수)/(실제정답수)

 ↪︎  K : 검색할 근접 데이터의 수 

 ↪︎  ANN 검색의 재현율 = (KNN으로 찾은 실제 가장 가까운 K개 중 ANN이 찾은 개수)/K

 

 

 

2.3  탐색가능한 작은세계 (NSW) 

 

❍  그래프 구조 

 ↪︎  노드(node) : 벡터 임베딩

 ↪︎  edge : 서로 연결된 노드끼리만 탐색이 가능하기 때문에, 노드와 노드 사이에 얼마나 많은 edge를 연결할지가 검색 성능과 속도에 영향을 미친다. 

 

❍  탐색가능한 작은 세계  

 

 ↪︎  완전히 랜덤한 그래프와 완전히 규칙적인 그래프 사이에 적당히 랜덤하게 연결된 그래프 상태 

 

 

 ↪︎  small world 는, 규칙적인 연결에서 일부 연결만 랜덤하게 바꾼 형태로, 정확한 탐색이 가능하면서도 랜덤한 성질을 통해 빠른 탐색이 가능하다는 특징이 있다. 

 ↪︎  랜덤 연결을 만들어주기 위해, 벡터의 순서를 랜덤으로 섞어 저장하는 방식을 사용한다. 

 ↪︎  그러나, 랜덤으로 저장하게 되면 찾으려는 검색 벡터와 가장 가까운 점이 아닌 점에서 탐색을 멈추는 local minimum 문제가 발생하게 된다. 이러한 문제를 해결하기 위해 계층구조를 추가했다. 

 

 

 

2.4 계층구조

 

❍  Linked list 

 

 

 ↪︎  많이 활용되는 자료구조로 새로운 데이터를 추가하거나 삭제할 때 서로를 연결하는 주소 정보를 추가하거나 삭제하면된다. 그러나 앞에서부터 순차 탐색을 해야 해서 속도가 느리다. 가령, 91을 찾는다 하면 8단계를 거쳐야 한다. 

 

 

❍  Skip list 

 

 

 

 ↪︎  가령, level을 설정하고 데이터를 듬성듬성 배치하는 검색 방식을 활용한다고 하면, 3단계만에 91을 찾을 수 있다. 이러한 계층 구조를 NSW에 접목해서 여러 계층에 그래프를 배치하는 방식으로 벡터를 저장한다. 

 

 

 

❍  HNSW

 

 

 

 

 ↪︎  레벨0에서는 모든 벡터를 저장하고, 레벨1,레벨2로 갈수록 적은 데이터만 저장한다. 

 ↪︎  스킵리스트와 마찬가지로 높은 층에 있는 데이터는 그보다 낮은 층에 항상 존재한다. 

 ↪︎  높은층에 어떤 벡터를 저장할지말지 결정하는 것은 복잡하지만, 본질적으로 확률을 이용해 높은 층으로 갈수록 데이터가 적어지는 구조를 사용한다고만 이해해도 좋다. 아무튼 낮은 층에는 모든 벡터가 저장되어 있으므로 지역 최솟값에 빠질 위험을 줄일 수 있다. 

 

 

 

 

3.   실습 : HNSW 인덱스의 핵심 파라미터 이해하기

---

 

❍  3가지 파라미터로 메모리 사용량, 색인시간, 재현율, 검색시간이 달라진다. 

 

 

3.1  파라미터 m 

 

❍  m

 ↪︎  하나의 벡터에 연결하는 최소 연결수 (추가하는 임베딩 벡터에 연결하는 edge의 수) 

 ↪︎  m이 클수록 연결되는 edge 수가 늘어나 그래프가 더 촘촘하게 연결되므로 재현율은 좋아지나, 메모리 사용량은 커지고 색인 시간이 증가한다. 탐색에서도 더 많은 edge를 고려하므로 검색시간도 증가한다. 

 

 

❍  실습

 

import numpy as np

k=1
d = xq.shape[1]
nq = 1000
xq = xq[:nq]

for m in [8, 16, 32, 64]:
    index = faiss.IndexHNSWFlat(d, m) # HNSW 인덱스를 생성할 수 있는 클래스에 m 파라미터 지정 
    time.sleep(3)
    start_memory = get_memory_usage_mb()
    start_index = time.time()
    index.add(xb)
    end_memory = get_memory_usage_mb()
    end_index = time.time()
    print(f"M: {m} - 색인 시간: {end_index - start_index} s, 메모리 사용량: {end_memory - start_memory} MB")

    t0 = time.time()
    D, I = index.search(xq, k)
    t1 = time.time()

    recall_at_1 = np.equal(I, gt[:nq, :1]).sum() / float(nq)
    print(f"{(t1 - t0) * 1000.0 / nq:.3f} ms per query, R@1 {recall_at_1:.3f}")

 

 ↪︎  ef_construction = 40, ef_search = 16인 기본값에서, m만 조정했을 때, m이 커지면 재현율이 크게 증가하고 메모리사용량이 증가하고 검색과 색인 시간이 길어진다. 그러나, KNN과 비교했을 때를 보면, m=64일 때 검색시간이 0.237ms 밖에 걸리지 않으면서 93.2%의 재현율을 보이는데, KNN은 검색에 7.6ms나 걸렸으니 30배 이상 빨라진 것이다. 

 

 

 

3.2  파라미터 ef_construction 

 

❍  ef_construction

 ↪︎  색인 과정에서 가장 가까운 M개를 선택하기 위해 저장하는 후보의 수 

 ↪︎ 인덱스에 새로운 벡터를 추가하는 경우, 검색할 때 유사하게 추가한 벡터와 가장 가까운 벡터를 탐색한다. 

 ↪︎ ef_construction 이 크면 더 많은 후보를 탐색하므로, 실제로 추가한 벡터와 가장 가까운 벡터를 선택할 가능성이 높아진다. 즉 생성하는 그래프의 품질이 좋아진다. 따라서 재현율이 올라간다. 그러나 더 많은 후보를 탐색하므로 색인 시간이 증가한다. 메모리 사용량과 검색시간은 크게 영향받지 않는다. 

 

 

❍  실습

 

k=1
d = xq.shape[1]
nq = 1000
xq = xq[:nq]

for ef_construction in [40, 80, 160, 320]:
    index = faiss.IndexHNSWFlat(d, 32)
    index.hnsw.efConstruction = ef_construction # efConstruction 속성 지정 
    time.sleep(3)
    start_memory = get_memory_usage_mb()
    start_index = time.time()
    index.add(xb)
    end_memory = get_memory_usage_mb()
    end_index = time.time()
    print(f"efConstruction: {ef_construction} - 색인 시간: {end_index - start_index} s, 메모리 사용량: {end_memory - start_memory} MB")

    t0 = time.time()
    D, I = index.search(xq, k)
    t1 = time.time()

    recall_at_1 = np.equal(I, gt[:nq, :1]).sum() / float(nq)
    print(f"{(t1 - t0) * 1000.0 / nq:.3f} ms per query, R@1 {recall_at_1:.3f}")

 

 ↪︎  ef_construction이 증가하면 재현율이 증가하고(그러나 그래프에 랜덤성이 들어가므로 언제나 증가하는 것은 아니다) 색인시간도 증가한다. 메모리 사용량과 검색시간은 크게 영향을 받지 않는다. 

 

 

 

 

3.3  파라미터 ef_search 

 

❍  ef_search

 ↪︎  검색 과정에서 가장 가까운 K개를 선택할 때 저장하는 후보의 수 

 ↪︎  후보군이 커지면 더 많은 벡터를 탐색해 재현율이 높아지지만 검색 시간은 증가한다. 

 

❍  실습

for ef_search in [16, 32, 64, 128]:
    index.hnsw.efSearch = ef_search # ef_search 지정
    t0 = time.time()
    D, I = index.search(xq, k) 
    t1 = time.time()

    recall_at_1 = np.equal(I, gt[:nq, :1]).sum() / float(nq)
    print(f"{(t1 - t0) * 1000.0 / nq:.3f} ms per query, R@1 {recall_at_1:.3f}")

 

 ↪︎  색인과는 관련이 없어 메모리 사용량이나 색인시간에는 영향을 주지 않는다. ef_search를 32 이상 설정했을 때 재현율이 0.97이상이고, 검색 시간은 1ms 미만으로, KNN과 비교했을 때 약 10배 이상 빠르다. 

 

 

 

 

 

4.   실습 : 파인콘으로 벡터 검색 구현하기 

---

 

4.1  파인콘 클라이언트 사용법

 

❍  파인콘

 ↪︎  대표적인 벡터데이터베이스 

 

 

 

(1) 계정 연결 및 인덱스 생성 

from pinecone import Pinecone, ServerlessSpec

# 계정 연결 
pinecone_api_key = "자신의 API 키를 입력"
pc = Pinecone(api_key=pinecone_api_key)

# 인덱스 생성
pc.create_index("llm-book", spec=ServerlessSpec("aws", "us-east-1"), dimension=768)
index = pc.Index('llm-book')

 

↪︎  인덱스 이름은 'llm-book'으로, 임베딩 벡터의 차원수는 768로 설정 

↪︎  Index클래스에 생성한 인덱스 이름을 입력해 사용할 인덱스를 불러온다. 

 

 

(2) 임베딩 생성

from datasets import load_dataset
from sentence_transformers import SentenceTransformer

# 임베딩 모델 불러오기
sentence_model = SentenceTransformer('snunlp/KR-SBERT-V40K-klueNLI-augSTS')

# 데이터셋 불러오기
klue_dp_train = load_dataset('klue', 'dp', split='train[:100]')

# 임베딩변환
embeddings = sentence_model.encode(klue_dp_train['sentence'])

 

↪︎  한국어임베딩모델 불러오기 

↪︎  데이터 불러오기 KLUE DP 데이터셋 

↪︎  encode 메서드를 사용해 실습 데이터셋 텍스트 데이터를 임베딩으로 변환 

 

 

 

(3) 파인콘 입력을 위한 데이터 형태 변경 

# 파이썬 기본 데이터 타입으로 변경
embeddings = embeddings.tolist()

# {"id": 문서 ID(str), "values": 벡터 임베딩(List[float]), "metadata": 메타 데이터(dict) ) 형태로 데이터 준비
insert_data = []
for idx, (embedding, text) in enumerate(zip(embeddings, klue_dp_train['sentence'])):
  insert_data.append({"id": str(idx), "values": embedding, "metadata": {'text': text}})

 

↪︎  파인콘 인덱스에 저장할 수 있도록 데이터 형태 변경

↪︎  id, values, metadata로 구성된 사전 형식으로 데이터 변환 

 

 

(4) 임베딩 데이터를 인덱스에 저장 

upsert_response = index.upsert(vectors = insert_data, namespace='llm-book-sub')

 

↪︎  upsert 메서드를 통해 파인콘 인덱스에 저장 

↪︎  namespace를 지정하는데, 파인콘에서는 하나의 인덱스 안에서도 여러 네임스페이스를 구분할 수 있다. 

 

 

 

 

(5) 인덱스 검색하기 

query_response = index.query(
    namespace='llm-book-sub', # 검색할 네임스페이스
    top_k=10, # 몇 개의 결과를 반환할지
    include_values=True, # 벡터 임베딩 반환 여부
    include_metadata=True, # 메타 데이터 반환 여부
    vector=embeddings[0] # 검색할 벡터 임베딩
)
query_response

 

↪︎  query 메서드 : 네임스페이스, 몇 개의 결과를 검색할지(top_k), 검색 결과에 포함시킬 데이터 종류 (include_values 또는 include_metadata), 검색할 벡터 vector) 인자를 전달한다. 

 

 

 

(6) 파인콘에서 문서 수정 및 삭제 

new_text = '변경할 새로운 텍스트'
new_embedding = sentence_model.encode(new_text).tolist()

# 업데이트
update_response = index.update(
    id= '기존_문서_id',
    values=new_embedding,
    set_metadata={'text': new_text},
    namespace='llm-book-sub'
)

# 삭제
delete_response = index.delete(ids=['기존_문서_id'], namespace='llm-book-sub')

 

↪︎  update 메서드 : 데이터 수정 : 문서의 id와, 변경할 값을 입력하면 된다. 

↪︎  delete 메서드 : 삭제하려는 문서의 id와 네임스페이스 전달 

 

 

 

 

4.2  라마인덱스에서 벡터 데이터베이스 변경하기

 

❍  라마 인덱스에 파인콘 인덱스 연결

 

# 파인콘 기본 설정
from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key=pinecone_api_key)
pc.create_index(
    "quickstart", dimension=1536, metric="euclidean", spec=ServerlessSpec("aws", "us-east-1")
)
pinecone_index = pc.Index("quickstart")


# 라마인덱스에 파인콘 인덱스 연결
from llama_index.core import VectorStoreIndex
from llama_index.vector_stores.pinecone import PineconeVectorStore
from llama_index.core import StorageContext

vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context
)

 

 ↪︎  (복습) 라마인덱스 : 사용자 인터페이스, 임베딩 모델, 벡터데이터베이스등 LLM 애플리케이션을 위한 다양한 구성요소를 연결하는 LLM오케스트레이션 도구 

 ↪︎  라마인덱스에서는 다양한 벡터 데이터베이스와 쉽게 통합할 수 있는 기능을 지원한다. 위 코드는 파인콘을 라마인덱스와 연결시켜 RAG의 벡터db로 활용하는 코드다. 

 

 

 

 

 

 

 

5.   실습 : 파인콘을 활용해 멀티모달검색 구현하기 

---

❍  요약

 ↪︎  이미지와 텍스트를 동일한 벡터 공간에 임베딩으로 변환할 수 있는 CLIP 모델을 사용하여, 입력한 이미지와 비슷한 이미지를 생성하는 기능에서 파인콘을 벡터db로 활용 

 ↪︎  프롬프트와 이미지쌍으로 구성된 DeffusionDB 데이터 사용