서론

AI·빅데이터 시대에 벡터 DB는 단순 유사도 검색을 넘어서 저장·검색·추론·보안·운영을 통합하는 핵심 인프라로 부상하고 있습니다.

특히 기존 RDBMS 벤더의 시장 진출 가능성과 AI 기능의 네이티브 통합, 멀티모달 지원, 분산 아키텍처, 실시간 인제스트, 표준화·상호운용성, 에지 컴퓨팅 통합 등은 벡터 DB의 미래를 결정짓는 주요 축이라고 생각됩니다. 이들 각 축을 살펴보고, 향후 벡터 DB가 나아갈 방향을 예측해 보고자 합니다.

본론

1. 오라클과 같은 기업들의 De Facto Standard

오라클과 같은 전통적 DB 벤더가 벡터 DB 기능을 자사 제품에 통합해 시장에 진출하면, 사실상 업계 표준으로 자리잡을 가능성이 높을 것 같습니다.

금융·의료·공공 등 보안·규제 준수가 중요한 환경에서 엔터프라이즈급 암호화·감사 로그 기능은 큰 강점이 될 것이며, 기존 RDBMS 환경과의 통합 운영 편의성도 도입 장벽을 낮춰줄 것 같습니다.

2. AI-네이티브 데이터 플랫폼 통합

벡터 DB가 임베딩 생성, RAG(Retrieval-Augmented Generation), 분류·요약 같은 AI 기능을 네이티브로 제공하게 될 것 같습니다.

이를 통해 별도의 AI 파이프라인 구축·운영 부담이 줄어들고, 데이터 저장소와 추론 엔진을 하나의 플랫폼에서 통합 관리할 수 있게 될 것 같습니다.

3. 멀티모달 지원 강화

텍스트뿐 아니라 이미지, 음성, 그래프 데이터를 모두 벡터화해 단일 인덱스에서 처리할 수 있을 것 같습니다.

의료 영상과 전자의무기록을 동시에 탐색하거나, 음성 명령과 텍스트 쿼리를 결합한 시나리오가 보편화되면서 데이터 소스 간 상호 보완적 분석이 더욱 활성화될 것 같습니다.

4. 클라우드-네이티브 분산 아키텍처

벡터 DB가 완전 관리형 클라우드 서비스로 제공되어, 사용자는 서버 설정이나 용량 계획에 신경 쓰지 않아도 될 것 같습니다.

자동 스케일링을 통해 트래픽 급증에도 안정적으로 대응할 수 있고, 투명하게 관리되어 운영 효율이 크게 향상될 것 같습니다.

5. 실시간 스트리밍 인제스트

배치 색인 방식을 벗어나 신규 벡터를 생성 즉시 색인하는 ‘실시간 Vector DB’가 일반화될 것 같습니다.

금융 거래, IoT 센서, 자율주행 차량 등 초저지연 응답이 필요한 분야에서 필수적인 기능으로 자리잡아, 항상 최신 데이터를 놓치지 않고 활용할 수 있을 것 같습니다.

6. 표준화·상호운용성

ONNX·OpenVector 같은 오픈 포맷이 표준으로 채택되어, 서로 다른 벡터 DB 간 데이터 이전이 자유로워질 것 같습니다.

Milvus, Qdrant, OpenSearch 등 주요 오픈소스 프로젝트가 공통 REST/gRPC API 레이어를 제공하면서, 벤더 종속성을 최소화하고 다양한 제품을 유연하게 조합할 수 있을 것 같습니다.

7. 에지 컴퓨팅과 LLM 통합

에지 디바이스에 소형 LLM과 벡터 DB를 결합하면 실시간 처리 성능이 크게 향상될 것 같습니다.

특히 자율주행차량에서는 내부에서 센서 데이터를 즉시 벡터로 변환해 도로 상황을 분석하고, 네트워크 지연 없이 즉각적인 주행 결정을 지원할 수 있을 것 같습니다. 스마트 팩토리나 원격 장비 제어 환경에서도 현장 데이터를 실시간으로 처리해 예측 가능한 성능을 제공할 것 같습니다.

결론

벡터 DB는 전통적 DB 벤더의 시장 주도력과 오픈 소스·혁신 생태계의 융합을 통해, AI 네이티브 플랫폼으로 자리매김할 것 같습니다.

멀티모달 지원, 분산 아키텍처, 실시간 인제스트, 표준화·상호운용성, 에지 컴퓨팅 통합 등을 통해 저장·검색·추론·보안·운영이 통합된 차세대 인프라로 발전할 것이라 생각됩니다.

서론

AI·빅데이터 시대에 벡터 DB는 단순 유사도 검색을 넘어서 저장·검색·추론·보안·운영을 통합하는 핵심 인프라로 부상하고 있습니다.

특히 기존 RDBMS 벤더의 시장 진출 가능성과 AI 기능의 네이티브 통합, 멀티모달 지원, 분산 아키텍처, 실시간 인제스트, 표준화·상호운용성, 에지 컴퓨팅 통합 등은 벡터 DB의 미래를 결정짓는 주요 축이라고 생각됩니다. 이들 각 축을 살펴보고, 향후 벡터 DB가 나아갈 방향을 예측해 보고자 합니다.

본론

1. 오라클과 같은 기업들의 De Facto Standard

오라클과 같은 전통적 DB 벤더가 벡터 DB 기능을 자사 제품에 통합해 시장에 진출하면, 사실상 업계 표준으로 자리잡을 가능성이 높을 것 같습니다.

금융·의료·공공 등 보안·규제 준수가 중요한 환경에서 엔터프라이즈급 암호화·감사 로그 기능은 큰 강점이 될 것이며, 기존 RDBMS 환경과의 통합 운영 편의성도 도입 장벽을 낮춰줄 것 같습니다.

2. AI-네이티브 데이터 플랫폼 통합

벡터 DB가 임베딩 생성, RAG(Retrieval-Augmented Generation), 분류·요약 같은 AI 기능을 네이티브로 제공하게 될 것 같습니다.

이를 통해 별도의 AI 파이프라인 구축·운영 부담이 줄어들고, 데이터 저장소와 추론 엔진을 하나의 플랫폼에서 통합 관리할 수 있게 될 것 같습니다.

3. 멀티모달 지원 강화

텍스트뿐 아니라 이미지, 음성, 그래프 데이터를 모두 벡터화해 단일 인덱스에서 처리할 수 있을 것 같습니다.

의료 영상과 전자의무기록을 동시에 탐색하거나, 음성 명령과 텍스트 쿼리를 결합한 시나리오가 보편화되면서 데이터 소스 간 상호 보완적 분석이 더욱 활성화될 것 같습니다.

4. 클라우드-네이티브 분산 아키텍처

벡터 DB가 완전 관리형 클라우드 서비스로 제공되어, 사용자는 서버 설정이나 용량 계획에 신경 쓰지 않아도 될 것 같습니다.

자동 스케일링을 통해 트래픽 급증에도 안정적으로 대응할 수 있고, 투명하게 관리되어 운영 효율이 크게 향상될 것 같습니다.

5. 실시간 스트리밍 인제스트

배치 색인 방식을 벗어나 신규 벡터를 생성 즉시 색인하는 ‘실시간 Vector DB’가 일반화될 것 같습니다.

금융 거래, IoT 센서, 자율주행 차량 등 초저지연 응답이 필요한 분야에서 필수적인 기능으로 자리잡아, 항상 최신 데이터를 놓치지 않고 활용할 수 있을 것 같습니다.

6. 표준화·상호운용성

ONNX·OpenVector 같은 오픈 포맷이 표준으로 채택되어, 서로 다른 벡터 DB 간 데이터 이전이 자유로워질 것 같습니다.

Milvus, Qdrant, OpenSearch 등 주요 오픈소스 프로젝트가 공통 REST/gRPC API 레이어를 제공하면서, 벤더 종속성을 최소화하고 다양한 제품을 유연하게 조합할 수 있을 것 같습니다.

7. 에지 컴퓨팅과 LLM 통합

에지 디바이스에 소형 LLM과 벡터 DB를 결합하면 실시간 처리 성능이 크게 향상될 것 같습니다.

특히 자율주행차량에서는 내부에서 센서 데이터를 즉시 벡터로 변환해 도로 상황을 분석하고, 네트워크 지연 없이 즉각적인 주행 결정을 지원할 수 있을 것 같습니다. 스마트 팩토리나 원격 장비 제어 환경에서도 현장 데이터를 실시간으로 처리해 예측 가능한 성능을 제공할 것 같습니다.

결론

벡터 DB는 전통적 DB 벤더의 시장 주도력과 오픈 소스·혁신 생태계의 융합을 통해, AI 네이티브 플랫폼으로 자리매김할 것 같습니다.

멀티모달 지원, 분산 아키텍처, 실시간 인제스트, 표준화·상호운용성, 에지 컴퓨팅 통합 등을 통해 저장·검색·추론·보안·운영이 통합된 차세대 인프라로 발전할 것이라 생각됩니다.

!pip install pymysql sentence-transformers scikit-learn python-dotenv faiss-cpu

환경 변수 로드 및 DB 접속 정보 초기화

import os
from dotenv import load_dotenv
import pymysql

# 1) .env 파일 내용을 읽어 환경변수로 설정
load_dotenv()  

# 2) os.getenv 로 값을 가져오기
HOST     = os.getenv('HOST')
PORT     = int(os.getenv('PORT', 3306))
USER     = os.getenv('USER')
PASSWORD = os.getenv('PASSWORD')
DB_NAME  = os.getenv('DB_NAME')

.env 에 정의해 둔 DB 접속 정보를 읽어서 파이썬 변수(HOST, PORT, USER, PASSWORD, DB_NAME)로 할당

MariaDB 연결 및 문서 불러오기

import pymysql

# 2) MariaDB에 연결 (autocommit=True 로 하면 별도 commit() 불필요)
conn = pymysql.connect(
    host=HOST,
    port=PORT,
    user=USER,
    password=PASSWORD,
    db=DB_NAME,
    charset='utf8mb4',
    autocommit=True
)

try:
    with conn.cursor() as cursor:
        # 3) documents 테이블 생성
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS documents (
            id INT PRIMARY KEY,
            content TEXT
        );
        """)

        # 4) 10개 레코드를 한 번에 INSERT
        insert_sql = """
        INSERT INTO documents (id, content) VALUES
        (1,  'Artificial intelligence is transforming many industries.'),
        (2,  'Machine learning models can improve over time with more data.'),
        (3,  'Natural language processing enables computers to understand human language.'),
        (4,  'Deep learning is a subset of machine learning using neural networks.'),
        (5,  'Transformers have revolutionized natural language processing tasks.'),
        (6,  'AI applications range from healthcare to autonomous vehicles.'),
        (7,  'Neural networks are inspired by the structure of the human brain.'),
        (8,  'Training a deep learning model requires large datasets and computing power.'),
        (9,  'Transfer learning allows models to adapt quickly to new tasks.'),
        (10, 'Explainable AI helps humans understand how AI systems make decisions.')
        ;
        """
        cursor.execute(insert_sql)

        print("✅ test_db.documents 테이블에 10개 레코드 삽입 완료")
finally:
    conn.close()

테이블을 만들고 데이터(문장)을 삽입

결과 : ✅ test_db.documents 테이블에 10개 레코드 삽입 완료

try:
    with conn.cursor() as cursor:
        # 1) 모든 레코드 조회
        cursor.execute("SELECT id, content FROM documents ORDER BY id;")
        rows = cursor.fetchall()

        # 2) 출력
        if not rows:
            print("⚠️ documents 테이블에 데이터가 없습니다.")
        else:
            print("✅ documents 테이블 내용:")
            for row in rows:
                print(f"  • id={row[0]}: {row[1]}")
finally:
    conn.close()

✅ documents 테이블 내용: • id=1: Artificial intelligence is transforming many industries. • id=2: Machine learning models can improve over time with more data. • id=3: Natural language processing enables computers to understand human language. • id=4: Deep learning is a subset of machine learning using neural networks. • id=5: Transformers have revolutionized natural language processing tasks. • id=6: AI applications range from healthcare to autonomous vehicles. • id=7: Neural networks are inspired by the structure of the human brain. • id=8: Training a deep learning model requires large datasets and computing power. • id=9: Transfer learning allows models to adapt quickly to new tasks. • id=10: Explainable AI helps humans understand how AI systems make decisions.

정상적으로 데이터가 저장되었음을 확인할 수 있다.

Sentence-BERT 모델 로딩 및 임베딩 생성 확인

from sentence_transformers import SentenceTransformer

# 2) 코드 내에서 직접 사용할 모델명 지정
model_name = 'all-MiniLM-L6-v2'  # 원하는 SBERT 프리트레인 모델로 변경 가능

# 3) 모델 로딩
print(f"Loading Sentence-BERT model: {model_name} …")
model = SentenceTransformer(model_name)
print("Model loaded successfully!")

# 4) (테스트) 간단히 임베딩 생성 확인
examples = [
    "안녕하세요, Sentence-BERT 테스트입니다.",
    "자연어 처리 모델이 잘 로드되었는지 확인합니다."
]
embeddings = model.encode(examples, show_progress_bar=True)
for text, emb in zip(examples, embeddings):
    print(f"– \"{text}\" → embedding 크기: {len(emb)}")

Model loaded successfully! Batches: 100%|██████████| 1/1 [00:00<00:00, 4.55it/s] – "안녕하세요, Sentence-BERT 테스트입니다." → embedding 크기: 384 – "자연어 처리 모델이 잘 로드되었는지 확인합니다." → embedding 크기: 384

모델이 정상적으로 로딩되고 임베딩이 정상적으로 이루어짐을 확인

VectorDB 생성

기존에 연결되었던 MariaDB를 사용하지 않고 새로운 벡터 DB를 생성하여 임베딩 정보들을 저장하였다.

벡터 연산에 최적화된 벡터 DB를 도입함으로써 대규모·고속 검색이 가능해지고, 애플리케이션의 응답성과 유지보수성이 크게 향상시키고자 하였다.

import json
import numpy as np
import faiss
from sentence_transformers import SentenceTransformer
import os
from dotenv import load_dotenv
import pymysql

def build_vector_db(conn, model,
                    index_path='corpus.index',
                    ids_path='ids.json'):
    """
    conn: pymysql 커넥션
    model: 이미 로드된 SentenceTransformer 객체
    index_path, ids_path: 저장할 파일명
    """
    # 1) DB에서 문장 불러오기
    with conn.cursor(pymysql.cursors.DictCursor) as cur:
        cur.execute("SELECT id, content FROM documents;")
        rows = cur.fetchall()

    ids    = [r['id']      for r in rows]
    corpus = [r['content'] for r in rows]

    # 2) 문장 임베딩 (NumPy 배열)
    embeddings = model.encode(
        corpus,
        convert_to_numpy=True,
        show_progress_bar=True
    )

    # 3) FAISS 인덱스 구축 (코사인 유사도용)
    d     = embeddings.shape[1]
    index = faiss.IndexFlatIP(d)
    faiss.normalize_L2(embeddings)
    index.add(embeddings)

    # 4) 디스크에 저장
    faiss.write_index(index, index_path)
    with open(ids_path, 'w', encoding='utf-8') as f:
        json.dump(ids, f, ensure_ascii=False)

    print(f"✅ VectorDB 저장 완료 → {index_path}, {ids_path}")

# — 호출 예 —
# (앞에서 model 이 이미 로드된 상태여야 함)
build_vector_db(conn, model)

conn.close()

“데이터베이스에서 문장 데이터를 로드 → SBERT로 임베딩 생성 → FAISS 기반 벡터DB 인덱싱 및 저장”

Batches: 100%|██████████| 1/1 [00:00<00:00, 15.15it/s] ✅ VectorDB 저장 완료 → corpus.index, ids.json

시맨틱 검색 함수 정의

# FAISS 인덱스 & ID 매핑
index = faiss.read_index('corpus.index')
with open('ids.json','r',encoding='utf-8') as f:
    ids = json.load(f)

corpus.index 파일에서 FAISS 벡터 인덱스를 로드하고, ids.json에서 벡터↔문서 ID 매핑을 불러옴

def get_connection():
    """ .env 기반으로 새 커넥션 반환 """
    return pymysql.connect(
        host=os.getenv('HOST'),
        port=int(os.getenv('PORT', 3306)),
        user=os.getenv('USER'),
        password=os.getenv('PASSWORD'),
        db=os.getenv('DB_NAME'),
        charset='utf8mb4'
    )

.env 에 정의된 환경변수(HOST, PORT, USER, PASSWORD, DB_NAME)를 읽는 함수

def semantic_search(query: str, top_k: int = 5):
    # 1) 쿼리 임베딩
    q_emb = model.encode(query, convert_to_numpy=True).astype('float32')
    q_emb = q_emb.reshape(1, -1)
    faiss.normalize_L2(q_emb)

    # 2) FAISS 검색
    D, I = index.search(q_emb, k=top_k)

    results = []
    conn = get_connection()
    try:
        with conn.cursor(pymysql.cursors.DictCursor) as cur:
            for dist, idx in zip(D[0], I[0]):
                doc_id = ids[int(idx)]
                cur.execute(
                    "SELECT content FROM documents WHERE id = %s", 
                    (doc_id,)
                )
                row = cur.fetchone()
                if row:
                    results.append({
                        'id':      doc_id,
                        'content': row['content'],
                        'score':   float(dist)
                    })
    finally:
        conn.close()

    return results

• 쿼리 임베딩: 입력된 검색어 query 를 SBERT 모델로 벡터화하고 L2 정규화
• FAISS 검색: 미리 구축해 둔 FAISS 인덱스(index)에서 상위 top_k개의 벡터 이웃을 찾아
• DB 조회: FAISS가 반환한 인덱스 번호(idx)→실제 문서 ID(ids[idx])로 매핑한 뒤, 그 ID로 documents 테이블에서 원문(content)을 꺼내 함께 결과 리스트에 담아 리턴

hits = semantic_search("What is transfer learning?", top_k=3)
for hit in hits:
    print(f"id={hit['id']}  score={hit['score']:.4f}")
    print("→", hit['content'], "\n")

What is transfer learning 라는 질문에 대해 3개의 유사도 있는 문장을 찾아온다.

하이브리드 검색

!pip install rank-bm25

키워드 기반 랭킹 계산을 위한 라이브러리

from rank_bm25 import BM25Okapi
import json, os

검색 함수 정의

def hybrid_search(query: str,
                  top_k: int = 5,
                  alpha: float = 0.5):
    """
    * query: 검색어
    * top_k: 최종 반환 개수
    * alpha: 시맨틱(score_sem) vs BM25(score_bm) 가중치
    """
    # 1) 쿼리 임베딩 & 정규화
    q_emb = model.encode(query, convert_to_numpy=True).astype('float32')
    q_emb = q_emb.reshape(1, -1)
    faiss.normalize_L2(q_emb)

    # 2) FAISS 시맨틱 검색
    D_sem, I_sem = index.search(q_emb, k=top_k * 2)
    sem_scores = { ids[int(idx)]: float(dist)
                   for dist, idx in zip(D_sem[0], I_sem[0]) }

    # 3) BM25 점수 계산 및 정규화
    tokenized_query = query.split()
    bm25_scores = bm25.get_scores(tokenized_query)
    bm25_norm   = bm25_scores / (bm25_scores.max() or 1.0)
    bm25_scores_map = { ids[i]: bm25_norm[i] for i in range(len(ids)) }

    # 4) 하이브리드 스코어 결합
    all_ids = set(sem_scores) | set(bm25_scores_map)
    hybrid_list = [
        (doc_id, alpha * sem_scores.get(doc_id, 0.0) + 
                 (1 - alpha) * bm25_scores_map.get(doc_id, 0.0))
        for doc_id in all_ids
    ]
    hybrid_list.sort(key=lambda x: x[1], reverse=True)
    topk = hybrid_list[:top_k]

    # 5) 결과 조회
    results = []
    conn = get_connection()
    try:
        with conn.cursor(pymysql.cursors.DictCursor) as cur:
            for doc_id, score in topk:
                cur.execute(
                    "SELECT content FROM documents WHERE id=%s", (doc_id,)
                )
                row = cur.fetchone()
                if row:
                    results.append({
                        'id':      doc_id,
                        'content': row['content'],
                        'score':   score
                    })
    finally:
        conn.close()

    return results

hybrid_search 함수는 시맨틱 검색(SBERT+FAISS) 과 키워드 검색(BM25) 점수를 동시에 활용해, 두 점수를 alpha 비율로 가중 결합한 뒤 최종 상위 k개 결과를 반환

for hit in hybrid_search("What is transfer learning?", top_k=3, alpha=0.7):
    print(f"id={hit['id']}  hybrid_score={hit['score']:.4f}")
    print("→", hit['content'], "\n")

벡터가 왜 필요할까?

1. 기존 추천 시스템의 한계

• 명시적 행동 기반 추천 (예: A를 샀으니 B 추천)

• 유저의 구매 이력 + 제품 속성 조합으로 추천

  → 의미 기반 유사성 파악에 어려움 존재

벡터 기반 추천 시스템

작동 방식

1. 사용자 행동 데이터 수집 (클릭, 시청, 좋아요 등)
2. AI 모델로 사용자와 아이템을 임베딩 (Embedding)
3. 벡터 DB에 저장
4. 유저가 들어오면 해당 유저의 벡터와 가장 유사한 아이템 벡터 검색

장점

• 콜드 스타트 문제 해결: 행동 데이터 적어도 의미 기반 추천 가능
• 의미 기반 추천: 카테고리, 장르가 달라도 분위기 유사한 콘텐츠 추천 가능
• 실시간 반영: 벡터 변화 반영 시 즉시 추천 가능

실제 사용 예시

이미지 검색

벡터 기반 이미지 검색

정의

• 이미지 자체를 AI 모델로 분석하여 벡터로 변환
• 이미지의 시각적 특성을 수치로 표현
• 쿼리 이미지와 유사한 벡터를 찾아 의미적으로 유사한 이미지 검색

예시

• 사용자가 사진을 업로드

  → AI 모델이 벡터로 변환

  → DB에 있는 수백만 벡터 중 가장 유사한 5개 이미지 검색

  예: "강아지가 모래사장에서 노는 사진" → 비슷한 분위기의 강아지 사진 반환

기존 이미지 검색 방식의 한계

• 텍스트 기반 검색: 이미지에 태그나 파일명이 있어야 검색 가능

  예: "노을 사진" → sunset.jpg 또는 #sunset 태그 필요

  → 텍스트 정보 없으면 검색 불가

작동 방식

1. 이미지 → AI 모델(CNN, CLIP 등) → 고차원 벡터
2. 벡터 DB에 저장
3. 쿼리 이미지 → 동일 모델로 벡터화
4. 쿼리 벡터와 가장 유사한 벡터를 Top-K로 검색

장점

• 텍스트 없이도 검색 가능 (이미지 그 자체로 검색)
• 색감, 구성, 분위기 등의 시각적 유사성까지 반영
• 패션, 디자인, 건축 등 비정형 시각 데이터에 강력

자연어 처리 응용

텍스트 벡터화란?

• 벡터화(embedding): 문장, 문서, 질문 등을 AI 모델을 통해 숫자의 배열(벡터)로 변환
• 이 숫자 배열은 텍스트의 의미, 감정, 주제, 스타일 등을 반영

주요 응용 분야

대표 벡터 모델

이 분야 공통점

• 텍스트 / 이미지 / 사용자 / 상품 → 벡터로 변환
• 벡터 DB에 저장
• 유사도 기반 검색 수행

벡터 DB는 AI 시스템의 의미 기반 검색 엔진 역할을 수행함.

CLIP

OPENAI가 만든, 텍스트와 이미지를 함께 이해할 수 있는 AI 모델

CLIP은 이미지와 텍스트를 같은 공간(벡터 공간)에 매핑

CLIP은 2개의 인코더를 가지고 있음

CLIP은 텍스트와 이미지를 같은 벡터 공간에서 비교할 수 있기 때문에 텍스트로 이미지 찾기, 이미지로 텍스트 찾기 둘 다 가능

import clip
import torch
from PIL import Image

model, preprocess = clip.load("ViT-B/32")
image = preprocess(Image.open("cat.jpg")).unsqueeze(0)
text = clip.tokenize(["a cat", "a dog", "a car"])

with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)

# 유사도 계산 (Cosine similarity)
similarity = (image_features @ text_features.T).softmax(dim=-1)
print(similarity)

대규모 언어 모델 LLM 과의 통합

RAG

• 필요한 정보를 먼저 찾아오고
• 그걸 참고해서 답변을 생성하는 방식

RAG를 구성하는 핵심 요소

장점

LLM 모델의 제약으로 벡터 DB가 필요

이 문제를 해결하기 위해 등장한 것이 바로 벡터 데이터베이스 + RAG 조합

벡터 Database 구축 및 관리

벡터 저장 공간 구분

주요 벡터 Database 솔루션 비교

성능 최적화 전략

스케일링 전략, 규모 확장

사례

단순 키워드 검색이 아닌 텍스트, 이미지, 오디오 등의 의미 기반 유사성 검색

벡터 DB 쿼리 단계

전통 DB와 벡터 DB 비교

병렬 처리와 분산 시스템 - 병렬 처리

병렬처리 개요

이런 연산을 하나하나 직렬로 처리하면 느려서 병렬처리 필요

병렬 처리 방식

예시

• 사용자가 query_vector 하나로 1,000만 개 벡터와 유사도 비교 요청 시
  • 직렬 처리: 1 CPU가 1개씩 비교 → 시간 매우 오래 걸림
  • 병렬 처리 예시:
    • 8코어 CPU → 코어당 125만 개씩 병렬 비교
    • GPU 수천 개 코어 → 병렬 벡터 내적 연산으로 훨씬 빠름

병렬 처리와 분산 시스템 - 분산 시스템

분산 시스템 개요

여러 서버에 나눠서 저장하고 동시에 검색하는 구조가 필요

구성요소 및 역할

예시

• 1억 개 벡터 데이터를 10대의 서버에 나눠 저장
• 쿼리가 들어오면 10대 서버가 동시에 검색 수행
• 각 서버는 1,000만 개씩 검색 → 속도 10배 향상
• 결과는 병합해서 최종 Top-K 반환

요약: 병렬처리 vs 분산 시스템

요약 정리:

• 벡터 검색은 수많은 벡터 간 고차원 거리 계산으로 연산량이 큼
• 병렬 처리는 한 서버 안에서 연산을 빠르게 → CPU/GPU 활용
• 분산 시스템은 여러 서버에 데이터를 나눠 → 속도 및 저장 확장
• 실제 서비스에서는 두 가지를 함께 활용하는 것이 일반적
  • 예: Milvus + CUDA + 클러스터 구성

벡터 DB는 텍스트, 이미지, 음성 등을 벡터(숫자 배열)로 변환한 뒤, 비슷한 벡터끼리 검색하므로 검색 요청 시 4단계를 거쳐 결과를 출력

1. 쿼리 임베딩 생성 (Query Embedding)

• 검색어나 질문을 벡터로 변환하는 단계

• 사용자가 입력한 텍스트(예: "붉은 드레스")를 벡터로 변환

• NLP 또는 멀티모달 AI 모델(BERT, CLIP 등)을 사용

• 예시 임베딩 결과: [0.12, -0.45, 0.89, ...] (보통 128~768차원 이상)

검색 품질은 사용하는 모델에 따라 달라짐

2. 인덱스 트리 탐색 (Index Tree Search)

• 전체 벡터 중에서 빠르게 후보 벡터를 찾기 위한 구조적 탐색

• ANN 알고리즘 사용 (예: HNSW, IVF, PQ 등)

검색 속도 최적화에 핵심적인 역할

3. 유사도 스코어 계산 (Similarity Score Calculation)

• 쿼리 벡터와 후보 벡터 간의 유사도 또는 거리 계산

• 주요 방법:

  • Cosine Similarity (0~1): 각도 기반 유사성
  • L2 거리: 유클리드 거리 (작을수록 유사)
  • Dot Product: 내적 계산

• 예: 코사인 유사도가 0.92면 거의 비슷한 것으로 간주

4. 결과 정렬 및 필터링 (Ranking & Filtering)

• 유사도 점수 기준으로 정렬 (Top-K 등)

• 필터링 조건 적용 가능 (예: 가격, 브랜드, 카테고리 등)

• 메타데이터 기반 필터링도 가능

하이브리드 검색 : 벡터 + 메타데이터 결합

“벡터 검색 결과 + 조건 기반 필터”를 함께 사용하는 방식

예시 쿼리

“붉은 색 드레스 + 가격 < 5만 원”

처리 방식

• “붉은 색 드레스” → 텍스트 벡터화 → 유사도 검색 수행
• 가격 < 50,000 → 메타데이터 필터링 조건으로 적용

동작 순서

1. 쿼리 "붉은 드레스"를 임베딩 → 벡터 A 생성
2. 벡터 A와 데이터셋 내 임베딩들과 유사도 비교
3. 유사도 상위 결과 Top-K 추출
4. 그 중 가격이 5만 원 미만인 항목만 필터링
5. 최종 결과 반환

즉, 벡터 기반 의미 검색과 속성 기반 필터링이 결합된 형태로, 텍스트 의미 유사성과 숫자 조건을 함께 만족하는 결과를 효율적으로 추출

벡터 DB애서 하이브리드 검색 구현

[하이브리드 검색 구현 가능 대상]

• 벡터 인덱싱
• ANN 탐색
• 메타데이터 필터링 쿼리
• 정렬 및 랭킹 전략

[요약]

[하이브리드 검색]

• 설명: 의미 기반 + 구조 기반 필터를 동시에 사용
• 장점: 정확도 향상, 사용자의 외도(의도 외 조건)까지 반영 가능
• 예시:
  • "빨간색 가방" + 브랜드 = 구찌
  • 가격 < 100만 원

Qdrant 기반 벡터 DB 실습

1. 사전 설치

pip install qdrant-client sentence-transformers

1. 예제 코드

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, Filter, FieldCondition, Range
from sentence_transformers import SentenceTransformer

# 1. 벡터화 모델 로딩 (텍스트 -> 벡터)
encoder = SentenceTransformer('all-MiniLM-L6-v2')

# 2. Qdrant 클라이언트 연결 (로컬 or 클라우드)
client = QdrantClient(host='localhost', port=6333)

# 3. 예시 데이터 (신발 정보 + 가격)
products = [
    {"id": 1, "name": "노란색 운동화", "price": 30000},
    {"id": 2, "name": "검정 구두", "price": 70000},
    {"id": 3, "name": "노란색 슬리퍼", "price": 45000},
    {"id": 4, "name": "빨간색 운동화", "price": 40000}
]

# 4. 벡터 생성 및 업로드
points = []
for p in products:
    벡터 = encoder.encode(p["name"]).tolist()
    payload = {"name": p["name"], "price": p["price"]}
    points.append(PointStruct(id=p["id"], vector=벡터, payload=payload))

# 5. 컬렉션 생성 및 데이터 업로드
collection_name = "shoes"
client.recreate_collection(
    collection_name=collection_name,
    vector_size=len(points[0].vector),
    distance="Cosine"
)
client.upsert(collection_name=collection_name, points=points)

→ 유사도는 코사인을 기준으로 측정함

# 6. 검색 쿼리: "노란색 신발" + 가격 < 50000
query_text = "노란색 신발"
query_벡터 = encoder.encode(query_text).tolist()

# 메타데이터 필터 정의
price_filter = Filter(
    must=[
        FieldCondition(
            key="price",
            range=Range(lt=50000)
        )
    ]
)

# 7. 벡터 + 필터 검색 (하이브리드)
results = client.search(
    collection_name=collection_name,
    query_vector=query_벡터,
    limit=3,
    query_filter=price_filter
)

# 8. 결과 출력
for r in results:
    print(f"{r.payload['name']} | {r.payload['price']}원 | 유사도: {r.score:.4f}")

벡터 DB 검색 방식 비교

키워드 검색

단어의 등장 빈도가 비슷한 문서를 검색하거나, 등장 여부를 필터링하여 검색하는 방식

[키워드 검색]

■ 개념

• 사용자가 입력한 정확한 단어(키워드)가 포함된 문서를 찾는 전통적인 검색 방식
• 일반적으로 역 색인 구조 사용
• 입력된 단어와 일치하는 문서를 색인에서 빠르게 조회

■ 기술적 구성

• 텍스트 토큰화 → 불용어 제거(Stopword removal) → 소문자 변환 등 전처리
• 사용자 쿼리도 동일 방식으로 처리하여 색인과 매칭

■ 예시

• "인공지능 기술 동향" → 문서 내 일치 문장 검색
• "2023년 AI 기술이 급속히 발전" → 연도 포함 문서 매칭
• "BERT" → 기술 키워드 필터링
• "AI 관련 정보 사례" 등 명확 키워드 기반 문장

■ 장점

• 빠른 검색 속도 (역색인 기반)
• 구현이 용이하고 단순

■ 단점

• 동의어, 오탈자, 유사 표현 인식 어려움
• 의미나 문맥 이해 없이 문자 그대로만 매칭되므로 질의 의도 파악이 어렵다

[보완 방식]

1. Attribute Filter (속성 필터 검색)

• 검색 조건으로 특정 속성(attribute, column, field)의 값을 기준으로 필터링
• SQL의 WHERE 절과 유사
• 예: 가격 < 50000, 카테고리 = '신발'

2. Sparse 벡터 검색 (희소 벡터 검색)

• 텍스트 문서를 단어 중심의 희소 벡터(sparse vector)로 표현하여 검색
• 대표 알고리즘: TF-IDF, BM25 등
• 단어 등장 빈도 기반으로 관련 문서 검색

키워드 검색 (Sparse 벡터 Search)

개념

• 단순 키워드 기반 필터 검색보다 한 단계 진화한 형태의 키워드 검색 방식
• 문서 내 단어 출현 빈도를 기반으로 문서를 벡터로 표현

구성 방식

• 문서 전체를 대상으로 단어 은행(Vocabulary)을 만들고,

  이를 기반으로 n-gram 형태로 벡터화

• Sparse(희소)*하다고 불리는 이유는

  대부분의 단어가 해당 문서에 존재하지 않기 때문에 0이 많은 벡터가 생성되기 때문

장점

• 단어 간 유사성보다는 정확한 단어 매칭에 초점

• 단어가 벡터 차원별로 매핑되고 빈도수로 표현되므로

  해당 단어의 중요도 반영 가능

• 단순히 등장 여부뿐만 아니라 빈도 기반의 정밀한 모델링 가능

대표 모델

• BM25, SPLADE 등이 대표적인 sparse 벡터 검색 모델

Sparse 벡터 Search - BM25

개념

• TF-IDF 기반 메커니즘을 활용한 키워드 중심 검색 모델

• TF (Term Frequency): 문서에서 특정 단어가 얼마나 자주 등장하는지를 기반으로 n-gram 형태로 벡터화

• IDF (Inverse Document Frequency): 전체 문서에서 얼마나 희귀한 단어인지를 반영

  → 흔하게 등장하지 않는 단어일수록 높은 가중치를 부여

작동 원리

• 사용자가 쿼리에서 입력한 단어들이 문서에 얼마나 등장했는지(TF), 그리고 해당 단어가 전체 문서 집합에서 얼마나 희귀한지(IDF)를 바탕으로 각 문서에 대해 BM25 점수를 계산
• 높은 점수를 가진 문서가 결과로 반환됨

특징

• Dense 벡터가 아닌 희소 벡터 기반이므로 일반적인 벡터 DB (예: Faiss, Qdrant)에서는 직접 사용이 어려움

  → 별도로 sparse 벡터를 위한 인덱싱 시스템 필요

Sparse 벡터 Search - SPLADE

개념

• 기존 Sparse 벡터 검색 방식의 한계인 유연성 부족을 개선하기 위해,

  BERT 기반 모델을 활용하여 sparse 벡터를 생성하는 방법

• 단순 등장 빈도가 아닌 단어의 문서 내 중요도(score)에 따라 스파스하게 표현

주요 특징

• 중요도 기반 가중치 부여
  • 단어가 문서에서 얼마나 중요한지를 수치로 표현하여 벡터 생성
• Term Expansion
  • BERT 모델과 결합하여 의미적으로 유사한 단어 표현까지 확장
  • 예: "2단", "2중적 표현" 등이 같은 의미로 확장되어 검색 가능
• 유연한 검색 가능
  • 단순 키워드 일치 외에도 의미 기반 검색 지원(오타, 간접적 표현을 인식할 수 있음)
  • 사용자 쿼리에 포함되지 않은 단어라도 문서의 중요도 기반으로 관련성이 높은 문서를 찾을 수 있음

시맨틱 검색

개념

• 사용자의 검색 질의(Query)와 문서 간의 의미적 유사도(Semantic Similarity)를 계산하여

  의미가 유사한 문서를 찾아주는 검색 방식

• 핵심 기술: 자연어 문장을 벡터로 변환하는 임베딩(Embedding)

기술적 구성

• 문장을 벡터로 변환 (임베딩)
• 사용자 질의도 같은 방식으로 벡터화
• 두 벡터 간 거리 계산 (예: 코사인 유사도, 유클리디안 거리 등)

예시

• 검색어: "변비로 고생한 김철민"

  → 문서: "고양이를 키우면서 주의해야할 건강요소" → 유사도 낮음

  → 문서: "변비 증상과 해결법" → 유사도 높음

  → 문서: "변화됨을 본질 비교" → 유사도 낮음

장점

• 의미가 비슷한 문장도 검색 가능
• 고도화된 사용자 질의 대응 가능

단점

• 느린 검색 속도 (벡터 기반 거리 계산 필요)
• 벡터 DB 등 추가 시스템 필요
• 포괄적 결과를 반환하여 정확성이 떨어질 수 있음

추가 설명

인덱싱 및 거리 계산 알고리즘

• LSH 기반: 해싱 방식, 유클리디안 거리 사용
• HNSW + PQ 기반: 그래프 탐색 + 압축, 반복 탐색 기반

거리 계산 방식

• Euclidean Distance
• Cosine Similarity
• Dot Product Similarity

어떤 인덱싱/알고리즘을 사용하느냐에 따라 정확도 및 속도는 달라짐

일반적으로 임베딩 모델의 벡터를 그대로 사용하는 것이 가장 이상적

하이브리드 검색

키워드 서칭 방식과 Semantic 서칭 방식을 조합하여 상호 간의 장점만 취하는 방향으로 안정적인 성능

개념

• 키워드 검색과 시맨틱 검색을 결합한 방식
• 정확한 단어 일치 정보와 문맥적 의미 유사성을 동시에 고려하여 검색 품질을 높임
• “키워드 서칭 방식과 Semantic 서칭 방식을 조합하여 상호 간의 장점만 취하는 방향으로 더욱 안정적인 성능을 노리는 방식”

기술적 구성

• 키워드 필터링 후 시맨틱 정렬

• 점수 계산 방식:

  최종점수 = 키워드 점수 * 가중치 + 시맨틱 점수 * 가중치

예시

• 검색어: “고양이 건강 정보”
  

  → 문서 A: 키워드+시맨틱 모두 높음 (정확한 노출)
  

  → 문서 B: 키워드만 존재, 시맨틱은 낮음
  

  → 문서 C: 시맨틱만 높음 (유사 표현)

• 예시 쿼리:
  

  → “○○일에만 한 번 전 발간된 급리 관련 내용을 찾아줘”
  

  → Attribute Filter(발간일, 발행일) + Semantic Search
  

  → “축구 관련 기사를 찾는데, 그 중에서도 해외파 선수들의 소속팀에서의 성적과 관련된 부분을 찾아줘”
  

  → SPLADE(해외파 선수 = 손흥민, 김민재 등) + Semantic Search

장점

• 키워드 정확도 + 시맨틱 문맥 이해 → 검색 정확도 향상

단점

• 구현 복잡도, 리소스 사용 증가
• 검색결과 튜닝 필요 (가중치 설정 등)

• RRF

• RSF

• DBSF

청크

Vector화 할 대상이 되는 데이터

청크로 구분된 데이터는 임베딩 처리를 통해 고정된 크기의 Vector 값으로 변환

• 청크 크기와 응답시간 간의 관계는 정보 검색 및 자연어 처리 시스템의 전체적인 성능에 매우 중요한 영향을 미침

• 청크 크기를 적절하게 설정하는 것이 시스템의 효율성과 정확도를 좌우함

• 따라서, RAG 시스템의 효율성과 정확성에 영향을 미칠 수 있는 중요한 결정 중 하나는 적절한 청크 크기(Chunk Size)를 선택하는 것

→ 청크 사이즈가 증가할수록 정확도가 감소하고, 속도가 늘어남

Fixed Size Chunking

장점

• 구현이 간단

• 균일한 데이터 분포

• 예측 가능한 성능

단점

• 비효율성: 고정된 크기를 채우지 못할 경우 공간이 비효율적으로 사용됨

• 데이터 경계의 의미 상실: 데이터의 논리적 경계를 무시하게 되어 의미를 온전히 이해하기 어려움

사용 예시

• 대량의 로그 데이터

Overlapping Chunking

장점

• 높은 검색 포괄성

• 검색 정확성 증가

단점

• 저장 공간 증가

사용 예시

• 문서 검색: 문단 간 연결 정보를 보존하고 싶을 때

• 멀티 미디어 데이터: 장면 단위로 나눌 때, 장면 간 전환 부분을 중복 포함하고 싶을 때

Recursive Chunking

Chunk2와 Chunk4 처럼 의미 있는 문맥 단위가 너무 커서 고정 크기를 넘는 경우에는

→ 재귀적으로 또는 추가적으로 문맥을 고려한 분할(Content Aware)을 적용함

Semantic Chunking

의미

• 청크의 유사성을 기준으로 텍스트를 분할하는 방법

• 문장을 단위로 청크한 후, 각 청크를 임베딩하여 벡터화

• 청크 간 코사인 유사도를 계산하고,

  • 설정한 임계값보다 유사도가 낮을 때 분할 수행
  • 분할 기준 이전은 하나의 청크로 간주, 이후도 같은 방식으로 반복

장점

• 높은 이해도

• 정확한 검색 결과

• 효율적인 처리 가능

단점

• 구현 복잡성: 의미 단위를 인식하고 정확하게 분할하는 알고리즘이 복잡할 수 있음

Summarization Chunking

의미

• 데이터를 요약된 형태로 나누는 방법

• 긴 텍스트나 문서를 요약하여 중요한 정보만 포함하는 청크를 만드는 것이 목적

장점

• 빠른 정보 파악

• 효율적인 검색

• 데이터 축소

단점

• 정보 손실

• 요약 정확도 품질 저하 가능

사용 예시

• 뉴스 요약

• 리포트 요약

Parent Child Chunking

의미

• 데이터를 계층 구조로 나누는 방식

• 큰 청크(부모)와 작은 청크(자식)로 분할하고, 각 청크를 계층적으로 연결

• 청크 자체에는 원문 전체를 저장하지 않고, 원문은 별도 저장소에 저장

  • 검색 시, 청크에 연결된 포인터를 통해 원문 위치를 찾아감

장점

• 효율적 탐색

• 구조적 접근

• 세분화된 분석 가능

단점

• 구현 복잡성

• 데이터 중복 가능성

사용 예시

• 문서 구조화

• 웹사이트 구조화

단계를 내려가며 청크를 쪼갬, 원문을 각 청크로 요약해서 원문을 찾아갈 수 있도록

Rag를 위한 5가지 청킹

https://blog.dailydoseofds.com/p/5-chunking-strategies-for-rag

벡터 DB 스키마 설계는 벡터 임베딩을 효율적으로 저장하고 검색하는 구조를 계획하는 과정 데이터 특성과 Application의 요구사항을 고려하여 수행

1. 데이터 구조 계획

• 데이터 유형 결정

  • 벡터 임베딩의 출처(이미지, 텍스트, 지리 좌표 등)에 따라 저장할 데이터 유형을 정의

• 벡터 차원 정의

  • 각 임베딩 벡터의 차원 수를 설정 (예: 일반적으로 768차원)

2. 필드 정의

• 벡터 필드

  • 실제 임베딩을 저장할 필드들(example)
    • image_vector, summary_dense_vector 등

• 메타데이터 필드

  • 문서나 항목에 대한 추가 정보를 저장할 필드들(example)
    • summary, publish_ts 등

3. 확장성 및 성능

• 수평 확장 고려

  • 데이터 양 또는 쿼리 부하가 증가해도 성능을 유지할 수 있도록 노드 증설 계획

• 부하 분산

  • 여러 노드에 쿼리 요청을 효율적으로 분배하기 위한 로드 밸런싱 전략

4. 인덱싱 전략

• 인덱스 유형

  • HNSW, IVF 등 다양한 알고리즘 중에서 선택

  • 쿼리 성능과 데이터 크기에 따라 최적의 인덱스 구조 결정

• 메트릭 유형

  • 유사도를 측정하는 데 사용할 메트릭 선택
  • 내적(dot product) 또는 코사인 유사도가 일반적으로 사용됨

5. 데이터 저장 및 검색

• 저장 방식

  • 메모리 기반 저장 또는 디스크 기반 저장

    • 메모리 기반: 빠른 응답 속도, 메모리 사용량 증가
    • 디스크 기반: 대용량 데이터 저장에 유리하나 상대적으로 느림

• 검색 최적화

  • 캐싱, 병렬 처리 등을 통해 쿼리 속도 최적화
  • 요청을 분산 처리하여 부하를 효율적으로 관리

필드 정의 및 인덱싱

VectorDB 일반적인 스키마 구조

collection 안에 원본 데이터가 존재

단일 Collection vs 멀티 collection

상황, 데이터형태 별로 VectorDB의 분할 저장을 결정할 수 있음 → 검색 속도 & 정확도

• Collection 관리 기법

Vector DB에서 Collection을 효율적으로 관리하기 위한 전략

• 단일 Collection 관리

  • 데이터 양이 적거나 단순한 서비스에서는 하나의 Collection에 모든 데이터를 저장·검색

• 다중 Collection 분리

  • 대규모 데이터 또는 높은 동시성 요구 시, 여러 Collection으로 분산 저장
  • 병렬 처리로 검색 성능 및 확장성 확보

• 분리 기준 설정

  • 정확도: 서로 다른 도메인·속성의 데이터를 별도 Collection으로 분리해 검색 품질 유지
  • 성능: 읽기·쓰기 부하 분산, 인덱스 크기 관리 등을 고려하여 분할

• 상황별 판단

  • 소량 데이터 & 단일 워크로드 → 단일 Collection
  • 대량 데이터 & 복합 워크로드 → 다중 Collection 분리

멀티 모달에서 단일 Collection

장점

• 간소화된 검색: 하나의 벡터로 문서와 동영상의 복합 정보를 표현할 수 있어 검색이 간편해짐.

단점

• 복합 표현의 한계: 문서와 동영상의 정보를 하나의 벡터에 결합하는 과정에서 정보 손실 발생 가능.

• 벡터 크기 증가: 두 벡터를 결합하며 벡터 크기가 커지고, 이에 따라 저장공간과 계산 비용이 증가.

Collection으로 나누는 기준

사례 - 뉴스기사 대상 Collection 설계

• 날짜 기준으로 나누기

  • 기준: 날짜 별로 Collection을 나누어, 매일 생성된 뉴스를 별도의 Collection에 저장

  • 장점: 최신 뉴스에 대한 빠른 접근이 가능하고, 오래된 뉴스를 쉽게 아카이브할 수 있다.

  • 예시: news_20250201, news_20250202

• 주제 또는 카테고리 기준으로 나누기

  • 기준: 주제별로 Collection을 나누어, 정치, 경제, 스포츠 등 카테고리 별로 뉴스를 저장
  • 장점: 특정 주제에 대한 검색이 빠르고 효율적이다.
  • 예시: news_politics, news_economy, news_sports

• 날짜와 주제 기준을 혼합한 기준으로 나누기

  • 기준: 날짜와 주제 기준을 혼합하여 Collection을 나눈다. 예를 들어, 매달 주제별로 Collection을 생성
  • 장점: 데이터가 너무 세분화되지 않으면서도, 특정 기간과 주제에 대한 검색이 효율적이다.
  • 예시: news_202501_politics, news_202501_economy, news_202501_sports

멀티 Collection에서의 유사도 검색

멀티 Collection 유사도 검색을 위해서는 벡터 공간의 일관성 필요

일관된 벡터 공간이란?

벡터 데이터베이스에서 서로 다른 데이터 항목들이 동일한 차원 수와 동일한 의미적 해석을 갖도록 변환된 공간

• 벡터 간 유사도를 정확하게 계산하고 비교할 수 있도록 함

• 서로 다른 Collection의 벡터들도 동일한 임베딩 스페이스에 있어야 함

벡터 공간의 일관성 요건

1. 동일한 차원 수: 모든 벡터는 동일한 차원 수를 가져야 함

2. 동일한 임베딩 모델: 동일한 임베딩 모델을 사용하여 데이터를 벡터화해야 함

3. 동일한 처리 방식: 데이터 전처리와 임베딩 생성 과정이 일관되어야 함

하나의 문서를 다양한 방식(Sparse+Dense)의 벡터로 저장 → 하이브리드 검색(Hybrid Retrieval) 가능

멀티 Vector 값을 관리하는 이유 Sparse + Dense

다양한 인덱싱 전략 사용

• Sparse Vector: 효율적인 저장과 검색을 위한 특화된 인덱싱 방식
• Dense Vector: 빠른 유사도 검색을 위한 인덱싱 방식 사용 가능

복합 검색 기능

• Sparse Vector와 Dense Vector의 혼합 저장을 통해 다양한 검색 조건 동시 적용 가능
• 예: 텍스트와 이미지 데이터를 동시에 검색하여 관련성 평가 가능

확장성

• 다양한 유형의 벡터 데이터를 하나의 Collection에 저장함으로써 시스템의 확장성 향상
• 데이터 타입과 저장 방식에 구애받지 않고 Collection 확장 가능

주어진 단어들을 바탕으로 Word2Vec 모델을 학습시켰다.

new_sentences = [
  ["기차", "자동차", "자전거", "비행기", "배"]
]

# 기존 모델 업데이트를 위한 빌드
model.build_vocab(new_sentences, update=True)
model.train(new_sentences, total_examples=len(new_sentences), epochs=10)

# 단어 벡터 확인
print(model.wv['기차'])  # 예시 출력

새로 추가된 단어들을 바탕으로 모델을 재 학습 시키고

[ 0.01417759 -0.00313586 0.015895 -0.01897732 -0.016059 -0.01328074 … 와 같이 임베딩됨을 확인할 수 있다.

from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import numpy as np

# Word2Vec 모델에서 단어 벡터 추출
words = list(model.wv.index_to_key)
vectors = np.array([model.wv[word] for word in words])

# t-SNE 차원 축소
tsne = TSNE(n_components=2, random_state=42, perplexity=5)
reduced = tsne.fit_transform(vectors)

# 한글 폰트 설정 (환경별로 구분)
import platform
if platform.system() == 'Windows':
    font_path = "C:/Windows/Fonts/malgun.ttf"  # Windows: 맑은 고딕
elif platform.system() == 'Darwin':
    font_path = "/System/Library/Fonts/AppleGothic.ttf"  # macOS
else:
    font_path = "/usr/share/fonts/truetype/nanum/NanumGothic.ttf"  # Colab (NanumGothic 설치 필요)

font_name = fm.FontProperties(fname=font_path).get_name()
plt.rc("font", family=font_name)
plt.rcParams["axes.unicode_minus"] = False

# 시각화
plt.figure(figsize=(12, 8))
for i, word in enumerate(words):
    plt.scatter(reduced[i, 0], reduced[i, 1])
    plt.annotate(word, (reduced[i, 0], reduced[i, 1]))
plt.title("Word2Vec 임베딩 시각화 (t-SNE)")
plt.grid(True)
plt.show()

임베딩된 단어들을 시각화하였을 때 다음 이미지처럼 나왔는데, 학습 데이터가 굉장히 적어 적절한 임베딩이 되지 않았다고 생각하였다.

Annoy를 사용하여 단어 임베딩

from annoy import AnnoyIndex

dim = model.vector_size
annoy_index = AnnoyIndex(dim, 'angular')

# 모든 단어 벡터 추가
for i, word in enumerate(words):
    annoy_index.add_item(i, model.wv[word])
annoy_index.build(10)

# 유사한 단어 검색 (예: '사과')
target_word = '사과'
target_index = words.index(target_word)
similar_indices = annoy_index.get_nns_by_item(target_index, 5)

print(f"'{target_word}'와 유사한 단어:")
for i in similar_indices:
    print(words[i])

FAISS 대신 ANNOY를 사용하여 진행해보았고,

'사과'와 유사한 단어: 사과 일본 자전거 소파 중국

이 또한 적절하지 않음을 확인할 수 있었다.

나무위키 파일로 학습하기

from datasets import load_dataset

# Hugging Face에서 나무위키 데이터셋 로드
dataset = load_dataset("heegyu/namuwiki-extracted")
documents = dataset["train"].select(range(1000))  # 처음 1000개 문서만 사용 (속도 고려)
print(documents[0])

학습데이터가 적은 문제점을 해결하기 위하여 Hugging Face에서 제공하는 나무위키 데이터셋을 불러와 학습하고자 하였다.

시간이 오래 걸리는 관계 상 100개, 1000개, 3000개의 문서를 비교군으로 사용하였다.

import re
import kss
from tqdm import tqdm

def simple_tokenize(text):
    text = re.sub(r"[^\uAC00-\uD7A3\s]", "", text)
    return text.strip().split()

tokenized_sentences = []
for doc in tqdm(documents, desc="문장 분리 및 토큰화"):
    try:
        if not doc["text"].strip():
            continue
        sentences = kss.split_sentences(doc["text"])
        for sent in sentences:
            tokens = simple_tokenize(sent)
            if len(tokens) >= 1:
                tokenized_sentences.append(tokens)
    except Exception as e:
        continue

기본적으로 형태소를 기준으로 나눌 수는 없어 조사는 제외시키지 못하였고, 단순히 띄어쓰기를 기준으로 단어를 구분하였다.

from gensim.models import Word2Vec

model = Word2Vec(
    sentences=tokenized_sentences,
    vector_size=200,
    window=5,
    min_count=5,
    workers=4,
    sg=1,
    epochs=5
)

구분한 단어를 기준으로 모델을 학습시켜 단어 임베딩을 진행하였다.

print(model.wv.most_similar("한국"))

다음과 같이 단어를 입력하고 입력된 단어를 기반으로 유사한 단어를 출력하도록 유도하였다.

1. 100개의 문서 만을 학습한 경우

[('신체', 0.9989925622940063), ('일부터', 0.998943030834198), ('앨범', 0.9982248544692993), ('게임', 0.9980660080909729), ('상대로', 0.9975945353507996), ('일에', 0.9973501563072205), ('기록했으나', 0.9973440170288086), ('북미', 0.9972758293151855), ('에서', 0.9972389340400696), ('첫', 0.9970090389251709)]

2. 1000개의 문서 만을 학습한 경우

[('중국', 0.7050928473472595), ('일본', 0.6985045075416565), ('대한민국', 0.6862316131591797), ('정식', 0.6725090742111206), ('아프리카', 0.6644840836524963), ('공식', 0.656909704208374), ('홍콩', 0.639904797077179), ('텔레비전', 0.6321231126785278), ('미', 0.6287841796875), ('일본에서', 0.6239179968833923)]

3. 3000개의 문서로 학습한 경우

[('대한민국', 0.5823025703430176), ('국내', 0.5639891624450684), ('중국', 0.5514899492263794), ('그룹', 0.5409524440765381), ('일본', 0.5325442552566528), ('대만', 0.505932092666626), ('아이돌', 0.49861907958984375), ('중국의', 0.49011966586112976), ('국적의', 0.4735112488269806), ('인기', 0.471205472946167)]

위와 같이 문서의 양이 늘어났을 때, 출력되는 단어의 종류가 육안으로도 향상됨을 확인할 수 있었다.

학습된 모델로 시각화

위의 나무위키를 통해서 학습된 모델을 바탕으로 위의 sentences 를 다시 시각화해보았다.

# 시각화할 단어 리스트
visual_words = [
    "사과", "바나나", "포도", "수박",
    "개", "고양이", "토끼", "호랑이",
    "컴퓨터", "노트북", "스마트폰", "태블릿",
    "의자", "테이블", "침대", "소파",
    "한국", "일본", "중국", "미국"
]

import numpy as np

valid_words = []
vectors = []

for word in visual_words:
    if word in model.wv:
        valid_words.append(word)
        vectors.append(model.wv[word])
    else:
        print(f"⚠️ '{word}' 단어는 어휘 사전에 없습니다.")

vectors = np.array(vectors)

앞서 말했던 학습데이터에 없던 데이터를 확인하고 제거하는 방식으로 시각화를 진행하였다.

1000개의 데이터셋을 활용한 경우에는 다음과 같이 존재하지 않는 단어도 존재했지만,

⚠️ '포도' 단어는 어휘 사전에 없습니다. ⚠️ '노트북' 단어는 어휘 사전에 없습니다. ⚠️ '태블릿' 단어는 어휘 사전에 없습니다. ⚠️ '소파' 단어는 어휘 사전에 없습니다.

3000개의 문서를 활용한 경우 학습데이터에서 제거되는 데이터는 존재하지 않았다. 즉, 모든 데이터를 시각화할 수 있었다.

from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import platform

# t-SNE 차원 축소
tsne = TSNE(n_components=2, random_state=42, perplexity=5)
reduced = tsne.fit_transform(vectors)

# 한글 폰트 설정
if platform.system() == 'Windows':
    font_path = "C:/Windows/Fonts/malgun.ttf"
elif platform.system() == 'Darwin':
    font_path = "/System/Library/Fonts/AppleGothic.ttf"
else:
    font_path = "/usr/share/fonts/truetype/nanum/NanumGothic.ttf"

font_name = fm.FontProperties(fname=font_path).get_name()
plt.rc("font", family=font_name)
plt.rcParams["axes.unicode_minus"] = False

# 시각화
plt.figure(figsize=(10, 7))
for i, word in enumerate(valid_words):
    plt.scatter(reduced[i, 0], reduced[i, 1])
    plt.annotate(word, (reduced[i, 0], reduced[i, 1]))
plt.title("지정 단어 Word2Vec 시각화 (t-SNE)")
plt.grid(True)
plt.show()

비교 및 정리

1. 5개의 데이터로 학습한 모델의 경우

비슷한 종류의 데이터끼리 흩어져 있음을 확인할 수 있다.

2. 나무위키를 통해 1000개의 데이터로 학습한 모델의 경우

많은 향상을 이루어내지는 못했지만, 어느 정도 향상된 결과가 나옴을 확인할 수 있었다.

3. 나무위키 3000개의 문서로 학습한 모델의 경우

육안으로도 1000개의 데이터를 통해 학습한 모델보다 3000개의 데이터를 활용한 모델이 더 잘 구분됨을 확인할 수 있었다.

한계

1. 학습 데이터 부족

KeyError: "Key '인공지능' not present in vocabulary”

위의 코드는 모델에 “인공지능”이라는 키워드를 넣었을 때, 출력되는 단어였다. 위의 에러처럼 만약 학습시킨 문서에 해당 단어가 없다면 유사도를 출력할 수 없는 문제가 존재했다.

1. 조사 처리 X

또한, 위의 출력 결과들을 확인하면 조사를 제거하지 않아 “일본”과 “알본에서”가 각각 출력되는 것을 확인할 수 있다.

만약 모델의 성능을 향상시키기 위해서는 조사를 처리하는 방식으로 형태소를 구분해 모델 성능을 향상시킬 수 있을 것이라고 생각된다.

한계의 보완 - 조사 처리

KoNLPy란?

• 한국어 형태소 분석을 위한 파이썬 라이브러리이다.
• 여러 형태소 분석기(예: Okt, Kkma, Hannanum, Mecab 등)를 파이썬에서 사용할 수 있도록 래핑할 수 있다.

그 중에서, Okt는 "Open Korea Text"를 사용하여 품사를 태깅해 명사와 동사만을 추출하여 단어 임베딩을 진행하였다.

import re
import kss
from konlpy.tag import Okt
from tqdm import tqdm

okt = Okt()

def extract_nouns_verbs(text):
    text = re.sub(r"[^\uAC00-\uD7A3\s]", "", text)  # 한글과 공백만 유지
    return [word for word, pos in okt.pos(text) if pos in ['Noun', 'Verb']]

tokenized_sentences = []

for doc in tqdm(documents, desc="문장 분리 및 품사 필터링"):
    try:
        if not doc["text"].strip():
            continue
        sentences = kss.split_sentences(doc["text"])
        for sent in sentences:
            tokens = extract_nouns_verbs(sent)
            if len(tokens) >= 1:
                tokenized_sentences.append(tokens)
    except:
        continue

print(model.wv.most_similar("수학"))

[('과목', 0.9074293375015259), ('응시', 0.8836804032325745), ('성적표', 0.8830194473266602), ('수생', 0.8793541789054871), ('시험', 0.8571914434432983), ('국어', 0.853074848651886), ('한국사', 0.8445228338241577), ('고과', 0.8427404761314392), ('학년', 0.8421928882598877), ('대학', 0.8208978176116943)]

성능이 향상됨을 확인할 수 있으며, 조사 또한 제거되었다.

ANN이란 질문 벡터(Query 벡터)에 대해 가장 비슷한 데티어(Nearest Neighbor)를 찾는 작업

정확도는 조금 낮아져도, 속도를 크게 높이는 것이 목표!!

VDB 검색 알고리즘

■ VDB

• 고차원 벡터 데이터를 저장
• 벡터 간의 유사성 검색을 효율적으로 수행하는 시스템

■ VDB 중요성

• 이미지 검색, 자연어 처리, 추천 시스템 등 대규모 벡터 데이터를 다루는 경우

  검색 속도는 시스템의 성능과 사용자 경험에 매우 중요

KNN (K-Nearest Neighbor) 알고리즘

정의

KNN(K-Nearest Neighbor, K-최근접 이웃) 알고리즘은 머신러닝과 검색 시스템에서 가장 기본적인 알고리즘 중 하나

【 KNN이란? 】

• 단순하지만 강력한 분류(Classification) 및 회귀(Regression) 알고리즘

• 새로운 데이터 포인트(예측할 데이터)가 들어오면,

  • 주변에 있는 K개의 가장 가까운 데이터를 찾아서
  • 다수결(분류) 또는 평균(회귀)을 통해 예측

• 비슷한 친구가 많으면 나도 그 부류에 속할 가능성이 높다는 개념

“비슷한 데이터는 비슷한 특성을 가진다”는 아이디어에서 출발

<장/단점>

보통 K는 홀수로 설정하여 다수결 판별이 용이하도록 함.

주요 내용

• 브루트포스 검색(유사한 데이터 찾는 데 집중) 대비 KNN은 예측을 목표

• KNN에서 거리 계산을 하기 위해 브루트포스, KD-Tree, Ball Tree, ANN(HNSW 등) 사용 가능

• 쿼리 벡터와 전체 벡터를 거리(L2, Cos 등)로 직접 비교하여 유사한 것 탐색

  • 검색을 위한 쿼리 벡터 검색 시 모든 벡터와 직접 비교 (L2, Cos, Dot-product)

• 가장 정확한 검색 방법

• 데이터 개수가 많아지면 검색 시간이 데이터 개수에 따라 증가

KNN을 활용하여 간단한 분류

from sklearn.neighbors import KNeighborsClassifier
import numpy as np

# 간단한 데이터: [키(cm), 몸무게(kg)]
X = np.array([[180, 80], [160, 50], [170, 60], [155, 45], [190, 90]])

# 정답(라벨)
y = np.array(["남자", "여자", "남자", "여자", "남자"])

# KNN 모델 생성 (K=3)
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X, y)

# 새로운 사람 [165cm, 55kg]이 남자인지 여자인지 예측
new_person = np.array([[165, 55]])
prediction = knn.predict(new_person)

print("예측 결과:", prediction)  # 출력: ['여자']

ANN은 근사값을 사용해서 속도를 빠르게 하는 KNN의 개선 버전

브루트포스 검색

가능한 모든 경우를 전부 탐색하여 해답을 찾는 방식

import numpy as np
from sklearn.metrics.pairwise import euclidean_distances

# 쿼리 벡터 (예: [3, 3])
query = np.array([[3, 3]])

# 데이터셋 (비교 대상 벡터들)
data = np.array([[1, 1], [2, 2], [5, 5], [6, 6]])

# 거리 계산
distances = euclidean_distances(query, data)
print("거리:", distances)

# 가장 가까운 2개 인덱스 추출
nearest_index = np.argsort(distances[0])[:2]
print("가장 가까운 2개:", data[nearest_index])

시간이 매우 오래 걸리므로 GPU를 사용하여 병렬처리함

브루트포스 검색 – Search on GPU (Flat: 브루트포스)

개요

• 모든 임베딩 벡터를 GPU의 VRAM에 업로드한 후 검색 수행

• 브루트포스 방식이지만 GPU를 사용하면 매우 빠른 응답 속도 제공

• VRAM 용량에 따라 처리 가능한 벡터 수가 결정됨

◾ 단일 GPU 사용

res = faiss.StandardGpuResources()                 # GPU 자원 할당
index_flat = faiss.IndexFlatL2(d)                  # L2 거리 기반 Flat Index 생성

gpu_index_flat = faiss.index_cpu_to_gpu(res, 0, index_flat)  # GPU로 인덱스 이동
gpu_index_flat.add(xb)                             # 임베딩 벡터 추가
D, I = index.search(xq, k)                         # 검색 수행

◾ 멀티 GPU 사용

cpu_index = faiss.IndexFlatL2(d)                            # CPU 상의 인덱스 생성
gpu_index_flat = faiss.index_cpu_to_all_gpus(cpu_index)     # 모든 GPU로 인덱스 복사
gpu_index_flat.add(xb)                                      # 임베딩 벡터 추가
D, I = index.search(xq, k)                                  # 검색 수행

ANN 알고리즘

ANN 알고리즘 (Approximate Nearest Neighbor)

• 정의:

  대규모 벡터 데이터셋에서 특정 벡터와 가장 유사한 벡터를 빠르게 찾기 위한 검색 기법

• 특징:

  • KNN과 비교 시 정확도를 약간 희생하는 대신 검색 속도 향상
  • 고차원 벡터 공간에서 근사값을 빠르게 계산해 유사한 결과 반환

주요 ANN 알고리즘

LSH, Locality Sensitive Hashing

LSH의 구조

LSH의 장점

• 전체 벡터를 비교하지 않아 속도가 빠름

• 해시 버킷을 기준으로 검색 대상이 자동으로 줄어듦

해시 비트 수(nbit) vs Recall

관계 및 특징

• nbit가 작을수록: recall이 낮아짐 (정확도 떨어짐)

• nbit가 커질수록: recall이 높아짐 (정확도 향상)

• 그러나 32bit ~ 64bit 이상부터는 성능 향상이 둔화

  • 일정 수준 이상에서는 정확도 증가가 미미함

즉, 성능 향상은 있으나 한계가 존재함

IVF, Inverted File Index

Voronoi Cell 기반 분할 (IVF 구조)

IVF의 핵심은 검색 범위를 셀 단위로 줄여 속도를 향상시키는 것이며, 클러스터링 기반의 효율적인 인덱싱 구조

nprobe = 1일 때 (IVF 탐색 설정)

nprobe=1은 속도 우선 전략이며, 정확도는 희생될 수 있음

nprobe = 8일 때 (IVF 탐색 설정)

nprobe=8은 정확도 우선 전략으로, 속도를 일부 희생하더라도 유사 벡터를 더 놓치지 않고 찾기 위함

IVF 성능 그래프 해석

속도 vs 정확도 트레이드오프 존재

IVF 관련 주요 용어 정리

PQ

인덱스 방식별 비교

요약 포인트

• IVFPQ: 벡터 수가 많아져도 시간 증가 거의 없음 → 대규모 데이터에 적합

• FlatL2: 가장 정확하지만, 데이터 많을수록 기하급수적으로 느려짐

• IVFFlat: 속도·정확도 균형 잡힌 선택지

HNSW

HNSW 정리

<원리>

• 데이터 포인트를 노드로 간주, 이들 간 근접성 기반 그래프 구성

• 계층 구조로 구성되며, 상위 레벨일수록 노드 수는 적고 연결은 추상적

• 검색은 최상위 레벨부터 시작, 점점 하위 레벨로 내려가며 이웃 노드를 탐색

• 각 단계에서 가장 가까운 노드로 이동하면서 목표 벡터에 점차적으로 접근

<장점>

• 정확도 매우 높음 (95~99%)

• 속도도 빠름

<단점>

• 메모리 사용량 큼

• 구조 구축 시간 오래 걸리고 구현 복잡도 높음

Skip List: 일종의 계층형 연결 리스트

개념

• 기본 연결 리스트는 노드를 순서대로 연결

• Skip List는 "건너뛸 수 있는 고속도로" 개념

  → 상위 레벨 링크를 추가하여 일부 노드를 건너뛰며 탐색 속도 향상

구조

• Balanced Tree와 Linked List의 장점을 결합한 자료 구조

탐색 흐름

1. 최상위 레벨에서 시작

2. 다음 노드의 키와 검색하려는 값 비교

   • 다음 키가 작으면 오른쪽으로 이동
   • 다음 키가 크면 하위 레벨로 이동

3. 가장 하위 레벨에 도달할 때까지 반복

Navigable Small World (NSW)

개념

• 네트워크 구조에서 효율적인 검색과 탐색을 가능하게 하는 데이터 구조 및 알고리즘 개념

• 전체 노드가 넓게 퍼져 있어도, 몇 번의 연결만으로 거의 모든 노드에 도달할 수 있음

• 각 노드는 k개의 이웃 노드와 연결되어 있으며,

  • long-range 연결과 short-range 연결을 조합하여 구성됨

• 가까운 노드만 따라가도 목표 노드에 도달 가능

예시

• SNS(소셜 네트워크)
  • “세상은 좁다”는 말처럼 대부분의 사람은 6단계 이내로 연결됨 ("6 degrees of separation")

탐색 흐름

1. 쿼리 벡터가 입력되면

2. 상위 레벨에서 출발 (멀리 있는 친구들부터 시작)

3. 가까운 노드를 따라 이동

   • 점점 정확히 위치를 좁혀가며
   • 최종적으로 목표에 가까운 노드에 도달
   • 위 과정을 목표 도달 시까지 반복

NHSW는 Skip List에서 아이디어를 얻었지만, 훨씬 더 강력한 그래프 탐색 구조로 발전했다.

import nmslib

index = nmslib.init(method='hnsw', space='cosinesimil')

# 데이터 추가
index.addDataPointBatch(data)

# HNSW 파라미터 설정
index.createIndex({
    'M': 32,
    'efConstruction': 200
}, print_progress=True)

# ef_search 설정
index.setQueryTimeParams({
    'efSearch': 100
})

ANN 알고리즘 평가지표

MRR, Mean Reciprocal Rank

정답(정답 벡터, relevant item)이 검색 결과 중 **몇 번째에 나오는지를 평가하는 지표

■ 개념 요약

• “내가 찾고자 했던 진짜 이웃(정답 벡터)이 결과 몇 번째에 있었나?”를 확인

• 각 쿼리의 가장 먼저 등장하는 정답 문서의 순위의 역수를 계산하여 평균

• 값이 1에 가까울수록 상위에 정답이 위치함

• 하나의 쿼리에 복수 정답이 있어도 첫 번째 정답만 고려

■ 계산 방식

1. 각 쿼리(query)*에 대해 정답의 순위(rank)를 기록

2. 해당 순위의 역수 (1 / rank)를 계산

3. 전체 쿼리에 대해 평균

■ 예시

• 쿼리 1: 정답이 1등 → 1/1 = 1.0

• 쿼리 2: 정답이 3등 → 1/3 ≈ 0.333

• MRR = (1.0 + 0.333) / 2 = 0.666

ANN 알고리즘 MRR 평가 흐름

1. Ground Truth 생성

   • 브루트포스 방식으로 정확한 KNN 결과를 미리 계산하여 기준값 생성

2. ANN 결과 도출

   • HNSW, IVF, PQ 등 다양한 ANN 방식으로 검색 결과 생성

3. 정답 순위 확인

   • 각 쿼리에 대해 정답이 검색 결과에서 몇 번째에 위치했는지 확인

4. MRR 계산

   • 정답의 순위에 대한 역수 평균을 통해 ANN 알고리즘의 성능 평가

def compute_mrr(results, ground_truth):
    """
    results: List[List[int]] -> 쿼리별 검색 결과 (예: [[2, 5, 8], [1, 3, 4]])
    ground_truth: List[int] -> 각 쿼리의 정답 인덱스
    """
    total_reciprocal = 0
    for i, res in enumerate(results):
        if ground_truth[i] in res:
            rank = res.index(ground_truth[i]) + 1  # 0-based -> 1-based
            total_reciprocal += 1 / rank
        else:
            total_reciprocal += 0
    return total_reciprocal / len(results)

# 예시
results = [[2, 5, 3], [1, 4, 0], [8, 6, 7]]
ground_truth = [5, 1, 6]

mrr = compute_mrr(results, ground_truth)
print(f"MRR: {mrr:.4f}")

• 머신러닝, 정보 검색, 자연어 처리 등 다양한 분야에서 활용
• 데이터 간의 관계를 수치화할 때 유용

코사인 유사도, cosine similarity

두 벡터 사이의 각도를 기준으로 유사도를 측정하는 방식.

→ 두 벡터가 이루는 각도가 작을수록(즉, 방향이 비슷할수록) 유사도가 높음.

수식:

공식

$$ Cosine Similarity= \frac{A \cdot B}{|A| \times |B|} $$

$$ A⋅B $$

두 벡터의 내적

$$ ∥A∥,∥B∥ $$

각 벡터의 크기 (Euclidean norm)

<예제>

• A = [1, 2, 3], B = [2, 3, 4] 라는 두 벡터가 주어졌을 때

1. 내적 계산

$$ A⋅B=(1×2)+(2×3)+(3×4)=2+6+12=20 $$

1. 벡터 크기 계산

$$ |A| = \sqrt{1^2 + 2^2 + 3^2} = \sqrt{14}, \quad |B| = \sqrt{2^2 + 3^2 + 4^2} = \sqrt{29} $$

1. Cosine Similarity 계산

$$ \text{Cosine Similarity} = \frac{20}{\sqrt{14} \times \sqrt{29}} \approx 0.99 $$

→ 1에 가까울수록 유사한 벡터임을 의미

<활용 분야>

• 문서 간 유사도 비교 (예: 뉴스 기사 추천)
• 추천 시스템 (예: 영화 추천)
• 검색 엔진 (예: 사용자 검색어와 문서 간 유사도 평가)

유클리드 거리

두 점(벡터) 사이의 직선 거리를 측정하는 방법으로, 쉽게 말해 두 점이 얼마나 떨어져 있는지를 표시

$$ \text{Euclidean Distance} = \sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2 + \ldots} $$

• 각 차원의 차이를 제곱하여 더한 후, 제곱근을 구함

<예제>

• 두 개의 점 A와 B 사이의 유클리드 거리

  A(1,2) 와 B(4,6)

• 각 차원의 계산

$$ (4-1)^2 = 9, (6-2)^2 = 16 $$

• 합산 후 제곱근 계산

$$ \sqrt{9 + 16} = \sqrt{25} = 5 $$

→ 두 점 사이의 거리는 5

<활용 예>

• 이미지 검색: 색상이나 패턴이 유사한 이미지 찾기
• 클러스터링: K-means 알고리즘에서 데이터를 군집화할 때
• 추천 시스템: 사용자와 아이템 간의 거리 측정

기타 유사도 측정 방법

자카드 유사도 (Jaccard Similarity)

• 집합(Set) 간의 유사도를 비교하는 방법
• 교집합과 합집합의 비율을 사용

$$ \text{Jaccard Similarity} = \frac{|A \cap B|}{|A \cup B|} $$

• 예시:

  A = {사과, 바나나, 오렌지}

  B = {바나나, 오렌지, 수박}

  $$ → 유사도 = \frac{2}{4} = 0.5 $$

• 활용 분야:

  • 텍스트 중복 탐지
  • 사용자 취향 비교

마할라노비스 거리 (Mahalanobis Distance)

• 데이터의 분산과 공분산을 고려한 거리 측정 방식
• 데이터가 서로 다른 분포를 가질 때, 유클리드 거리보다 더 신뢰할 수 있는 방식

$$ D_M(A, B) = \sqrt{(A - B)^T S^{-1} (A - B)} $$

• 여기서

$$ S^{-1} $$

은 공분산 행렬의 역행렬

• 활용 분야:
  • 이상치 탐지
  • 다변량 데이터 분석

내적 유사도 (Dot Product Similarity)

• 두 벡터의 내적(Dot Product)을 계산하여 유사도를 측정하는 방법

$$ A \cdot B = x_1 y_1 + x_2 y_2 + \cdots + x_n y_n $$

• 내적 값이 클수록 두 벡터가 비슷한 방향을 가짐을 의미
• 활용 예시
  • 신경망 가중치 적용 (딥러닝)
  • 추천 시스템 (사용자 선호도 예측)

맨해튼 거리 (Manhattan Distance)

• 각 차원의 차이의 절댓값을 더해서 거리를 측정하는 방식
• “격자 무늬 거리”라고도 하며, 도시 블록처럼 수직·수평 방향으로만 이동하는 거리 방식과 유사

$$ \text{Manhattan Distance} = |x_1 - x_2| + |y_1 - y_2| + \cdots $$

• 예시:

  A(1,2) 와 B(4,6)의 맨해튼 거리

  $$ |4 - 1| + |6 - 2| = 3 + 4 = 7 $$

• 활용 예시

  • 네트워크 라우팅 (최적 경로 찾기)
  • 주식 데이터 비교 (가격 변화량 분석)

유사도 측정 방식은 상황에 따라 다르게 적용되니 데이터의 특징과 목적에 따라 적절한 방식 선택

공분산 행렬, Covariance Matrix

• 여러 변수 간의 공분산(Covariance) 값을 정리한 행렬
• 공분산은 두 변수 간의 관계를 나타내는 값
  • 양수: 양의 상관관계 (함께 증가)
  • 음수: 음의 상관관계 (한쪽 증가, 한쪽 감소)
  • 0: 관계 없음
• 데이터의 분포 특성을 분석할 때 사용
• 활용 분야:
  • PCA(주성분 분석)
  • 머신러닝
  • 통계분석
  • 금융공학 등

<정의 및 계산식>

• 두 변수 XX 와 YY 의 공분산:

$$ \text{Cov}(X, Y) = \frac{1}{n} \sum_{i=1}^{n} (X_i - \bar{X})(Y_i - \bar{Y}) $$

• 설명:
  • n: 데이터 개수
  • X_i, Y_i: 각 X와 Y 변수의 값
  • 각 X와 Y의 평균
• 의미:
  • X 증가, Y 증가 → 공분산 > 0 (양의 상관관계)
  • X 증가, Y 감소 → 공분산 < 0 (음의 상관관계)
  • X와 Y가 서로 관계 없음 → 공분산 = 0

【활용】

• PCA (주성분 분석)
  • 공분산 행렬을 사용하여 데이터의 주요 방향(주성분)을 찾고 차원 축소 수행
• 다변량 정규분포 분석
  • 여러 개의 변수가 동시에 정규분포를 따를 때, 그 관계를 나타내는 데 사용
• 포트폴리오 최적화 (금융공학)
  • 주식 간의 변동성을 분석하여 리스크를 최소화하는 투자 포트폴리오 구성
• 머신러닝 및 데이터 분석
  • 데이터의 상관관계를 분석하고, 변수 선택(feature selection)에 활용

【Python 활용 예제】

• Python에서는 numpy 라이브러리를 이용하여 쉽게 공분산 행렬 계산 가능

import numpy as np

# 예제 데이터: 3개의 변수 (X, Y, Z)
data = np.array([
    [1, 2, 3],
    [2, 3, 5],
    [3, 4, 6],
    [4, 5, 6]
])

# 공분산 행렬 계산
cov_matrix = np.cov(data, rowvar=False)

print("공분산 행렬:\n", cov_matrix)

• 결과:

공분산 행렬:
[[1.66 1.66 0.5 ]
 [1.66 1.66 1.0 ]
 [0.5  1.0  2.66]]

• 설명
  • 대각선: 각 변수의 분산
  • 나머지 값: 변수 간의 공분산

• 데이터베이스에 벡터 데이터를 구조화된 인덱스에 담는 행위
• 추후 검색 성능을 고려하여 KNN이 아닌 ANN(Approximate Nearest Neighbor) 가능한 구조로 설계

목표: 검색 정확도 ↔ 검색 속도 간의 tradeoff 관계 최적화

Quantinized(양자화) : 쪼개서,,,

벡터 인덱싱

벡터를 적절히 분류하고 저장하여, 유사한 벡터를 빠르게 찾음

• 예시

도서관에서 장르 별로 분류하고 원하는 장르에서 찾기

• 종류

HNSW, Hierarchical Navigable Small World

최신 많이 시용하는 방법, 데이터가 수십만개 정도 되는 경우 효과적

<동작방식>

• 다층 네트워크 생성

  • 벡터 데이터를 여러 계층(Layer)으로 나눔
  • 상위 계층에는 적은 수의 벡터(전략적 거점)가 배치됨
  • 하위 계층에는 더 많은 벡터(세부적인 노드)가 배치됨

• 빠른 검색

  • 먼저 상위 계층에서 대략적인 위치를 찾음
  • 하위 계층으로 내려가면서 점점 더 정확한 벡터를 탐색
  • 최종적으로 가장 유사한 벡터를 반환

<장/단점>

• 장점
  • 검색 속도가 매우 빠름 (로그 시간 복잡도, O(log N))
  • 높은 정확도를 유지함
  • 최신 벡터를 쉽게 추가할 수 있음 (동적 업데이트 가능)
• 단점
  • 인덱스를 만들 때 메모리를 많이 사용
  • 특정 조건에서 속도가 느려질 수 있음

근사 최근접 이웃 검색(ANN: Approximate Nearest Neighbor)을 위해 사용되며, 그래프 기반 구조와 계층적 접근 방식으로 빠른 검색 성능을 제공

IVF, Inverted File Index

여러 그룹으로 나누고 필요한 그룹에서만 검색

<동작방식>

• 벡터를 여러 개의 그룹(버킷)으로 분리

  • K-means 알고리즘을 사용하여 유사한 벡터끼리 그룹화
  • 각 그룹은 대표값(centroid, 중심점)을 가짐

• 검색 시, 가장 유사한 그룹을 먼저 찾음

  • 전체 데이터를 검색하지 않고, 가장 유사한 그룹(버킷)만 탐색
  • 해당 그룹 내에서 가장 가까운 벡터를 반환

• 벡터 공간을 보로노이 다이어그램과 같이 나누어 서치 스페이스를 축소

• 쿼리 벡터와 centroid 간 거리 계산 후, 가장 가까운 centroid에 해당하는 공간 내 임베딩 벡터들과 거리 계산 수행

<장/단점>

• 장점

  • 전체 데이터베이스를 검색하지 않아서 속도가 빠름
  • 대량의 벡터 데이터를 처리할 때 유리
  • 메모리 사용량이 비교적 적음

• 단점

  • 정확도가 HNSW보다 낮을 수 있음
  • 그룹이 잘못 설정되면 검색 성능 저하 가능성 존재
  • 새로운 벡터 추가 시 기존 그룹에 제대로 배치되지 않을 수 있음
  • 공간을 형성하는 벡터가 많을수록 공간 나누는 작업의 속도가 느려짐

속도는 빠를 수 있지만, 정확도가 낮을 수 있음 ⇒ PQ와 함께 사용함

PQ, Product Quantization

벡터를 여러 개의 작은 벡터로 나누고, 각 벡터를 압축하여 저장

<동작방식>

• 벡터를 여러 개의 서브 벡터로 분리

  • 예: 128차원 벡터 → 4개의 32차원 벡터로 분할

• 각 서브 벡터를 미리 정해둔 코드북(Codebook)에서 가장 가까운 값으로 매칭하여 저장

  • "비슷한 벡터를 대표하는 값"을 사용하여 저장 공간 절감

• 검색 시, 압축된 값만 비교하여 빠르게 유사도를 계산

  • 원본 벡터를 모두 비교하는 것보다 훨씬 빠름

코드북(Codebook)은 서브 벡터들을 대표하는 기준 벡터(클러스터 중심)들의 집합으로, 유사한 벡터를 압축하여 표현할 때 참조되는 값들

<장/단점>

• 장점

  • 벡터를 압축해서 저장하므로 메모리 사용량이 적음
  • 대규모 데이터에서도 유사도 검색을 빠르게 수행 가능

• 단점

  • 벡터를 압축하는 과정에서 정확도가 조금 떨어질 수 있음
  • 너무 작은 차원으로 압축 시 원본 데이터의 특성을 잃을 수 있음

메모리 사용량이 적은 편이라 대규모 데이터에 적합함

HNSW, IVF, PQ 개념 요약

⇒ 하나만 고집해서 사용하는 것이 아닌, 여러 방법을 섞어서 사용

Hash Index

고차원 데이터는 그대로 두는데, 해시 테이블을 별도로 만들어서

<동작방식>

• 고차원 데이터를 저차원 해시코드로 변환하여 서칭 컴플렉시티 개선을 노리는 방식

• 일반적 해싱과 반대로, 벡터 인덱싱 시 비슷한 데이터끼리 해시 충돌이 나도록 하는 구조

• 이때 사용되는 해싱 함수를 그대로 쿼리 벡터에 대해서도 적용시켜, 동일한 해시버킷에 위치한 벡터들에 대해서만 거리 계산 수행

• LSH(Locally Sensitive Hashing) 등이 여기에 해당

<장/단점>

• 장점
  • 빠른 검색 속도
• 단점
  • 낮은 검색 정확도

Query가 들어오면 Hash Index화 하고 유사함 Bucket으로 가서 유사한 Hash 값을 찾음

Tree Index

<동작방식>

• Binary Search Tree 구조를 사용하여 고차원 벡터 공간에서의 검색 속도 향상을 도모하는 방식

• 유사한 벡터들이 같은 서브트리 노드(혹은 공간)에 속하도록 하는 구조

• 검색 시, 해시버킷과 유사하게 쿼링 벡터가 속하는 서브트리 노드에 존재하는 다른 벡터들과의 거리만 계산하여 검색 속도 최적화

• Spotify Annoy 알고리즘이 여기에 해당

<장/단점>

• 장점
  • 빠른 검색 속도
• 단점
  • 고차원 벡터에 대해서는 검색 정확도가 좋지 않다

• HNSW: 그래프를 따라 돌아다니며 "지금보다 더 가까운 이웃은 없을까?"를 반복적으로 묻는 방식

• Tree Index: "이쪽 리프 노드면 이 근처에 있을 거야"라고 트리를 타고 내려가는 방식

Graph Index

HNSW가 대표적임

<동작방식>

• 임베딩 벡터들을 그래프 구조로 구성하여, 임베딩 벡터를 노드로, 연결된 엣지를 벡터 간 거리로 표현

• 유사한 벡터끼리 엣지 커넥션이 더 잘 이루어지도록 설계

• HNSW(Hierarchical Navigable Small World) 알고리즘이 여기에 해당

• 여러 계층으로 그래프를 제작

  • 가장 밀도가 낮은 계층에서 랜덤한 노드로 시작하여, 해당 계층에서 가장 가까운 노드를 찾은 후 다음 계층으로 이동
  • 최종적으로 원래 쿼리 벡터와 가장 가까운 이웃을 찾을 때까지 계층 탐색

<장/단점>

• 장점
  • 검색 속도도 빠르고 검색 성능도 빠르다
• 단점
  • 검색 그래프를 구성하는 방식에 따라 검색 성능이 의존적 (파라미터 튜닝 필요)

Flat Indexing(Exhaustive Search)

모든 데이터를 하나하나 비교하는 방식

<동작방식>

• 모든 데이터를 하나하나 비교하는 방식

• 벡터를 압축 없이 그대로 저장

• 검색할 때 모든 벡터를 하나씩 비교 (완전 탐색, brute-force search)

• 정확도가 높지만 속도가 느리고, 메모리를 많이 사용

• 사용 사례

  • 데이터 개수가 적거나, 정확도가 중요한 경우
  • 의료 데이터 분석 (잘못된 결과가 나오면 안 되는 경우)
  • 소규모 데이터에서 가장 가까운 벡터를 찾을 때

<장/단점>

• 장점
  • 100% 정확한 검색 결과 (손실 없음)
  • 추가적인 전처리 없이 사용 가능
• 단점
  • 데이터가 많아질수록 속도가 느려짐
  • 메모리 사용량이 많음

Quantized 인덱싱, 양자화 방식

벡터를 압축하여 저장하고, 근사 검색을 수행하는 방식

• 양자화

벡터를 압축하여 더 적은 공간을 사용하고 검색 속도를 빠르게 하는 기법

<장점>

• 검색 속도가 빠름

• 메모리 사용량 절약 가능

<단점>

• 완벽한 검색이 아닌 근사 검색(Approximate Search)

  → 정확도가 약간 낮을 수 있음

<사용 사례>

• 데이터가 많고 빠른 검색이 필요한 경우

  • 예) 수억 개의 상품 중 유사한 것을 추천하는 쇼핑몰 추천 시스템

  • 예) 실시간 검색 시스템 (구글 이미지 검색, 영상 검색 등)

정확도를 중요시 하면 Flat, 속도를 중요시 하면 Quantized

Scalar Quantization, SQ

벡터 인덱싱에서 벡터를 더 작은 크기로 변환하여 저장하는 기법

→ 벡터의 각 요소를 특정 범위의 정수값으로 변환(압축)하여 메모리를 절약하는 방법

• 모바일, 임베디드, Edge AI 환경에서 속도와 저장 공간을 최적화하기 위함

• 특히 int8은 양자화된 모델을 실행할 수 있는 TensorRT, ONNX Runtime, TFLite 등에서 활발히 사용

Product Quantization, PQ

대규모 벡터 데이터의 검색 속도를 높이고 메모리를 절약하는 인덱싱 기법

벡터 압축 후 근사 검색 수행

장점

• 메모리 절약 → 벡터를 압축하여 저장 가능

• 검색 속도 향상 → 근사 검색을 통해 빠르게 유사한 벡터 탐색

• 대규모 데이터에 적합 → 수억 개의 벡터도 효율적으로 저장 및 검색 가능

단점

• 정확도가 완전 탐색(Flat Indexing)보다 약간 낮음

• 적절한 코드북(Codebook) 크기 설정이 필요

• 고차원 벡터에서는 압축 과정이 복잡할 수 있음

언제 사용?

• 대규모 데이터에서 빠른 검색이 필요할 때

• 메모리를 절약하면서 유사 검색을 수행할 때

• 추천 시스템, 이미지 검색, 문서 검색 등에 활용

대표 활용 예

• Google 이미지 검색

• Netflix 추천 시스템

• 시기반 챗봇 검색 시스템

• FAISS (Facebook AI Similarity Search)

요약

Product Quantization(PQ)는 대규모 데이터에서 메모리를 절약하고 빠르게 검색할 때 사용된다. 정확도가 약간 떨어질 수 있지만, 속도와 효율성을 크게 향상시킨다.

<정리>

• Scalar Quantization 기법과 유사하게, 임베딩 벡터의 floating point 값을 8비트 integer로 변환하여 메모리 효율성을 높이는 기법

• 이 방식에 몇 가지 추가 기술이 결합된 것이 바로 PQ (Product Quantization)

• 원본 벡터를 n개의 청크 또는 서브벡터 단위로 분할

• 각 서브벡터 단위로 K-means 클러스터링을 수행 (예: K = 256)

• 클러스터링 결과로 얻은 256개의 centroid를 서브벡터의 표현으로 사용하여 양자화(Quantization) 수행

• 새로운 쿼리 벡터가 들어오면 동일한 방식으로 서브벡터 단위로 나누고, 각 서브벡터별로 해당 centroid에 매핑하여 8비트 정수 형태로 변환

• 이후 거리 계산 시, 메모리 효율성과 검색 속도 모두 향상되는 방식

• 덜 쪼갤수록 압축률은 올라가지만 정확도가 낮아지고, 더 많이 쪼개면 정확도는 올라가지만 압축률은 낮아지는 trade-off 관계 존재

import faiss
import numpy as np

# 1. 1000개의 128차원 벡터 생성 (더미 데이터)
d = 128  # 벡터 차원
nb = 1000  # 데이터베이스 크기
np.random.seed(42)
data = np.random.random((nb, d)).astype('float32')

# 2. Product Quantization (PQ) 인덱스 생성
m = 8  # 서브벡터 개수
quantizer = faiss.IndexFlatL2(d)  # 기본 L2 거리 기반
index = faiss.IndexIVFPQ(quantizer, d, 10, m, 8)  # IVF + PQ 적용
index.train(data)  # 학습
index.add(data)    # 벡터 추가

# 3. 검색 수행
query = np.random.random((1, d)).astype('float32')
D, I = index.search(query, k=5)  # 가장 가까운 5개 검색

print("검색 결과 (Nearest Neighbors):", I)
print("거리 (Distances):", D)

FAISS를 사용하면 쉽게 Product Quantization을 적용가능

# !pip install chromadb

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import chromadb
from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction

# 1. 문서 정의
docs = [
    "Python is a programming language.",
    "Pandas is a library for data analysis.",
    "Transformers are used in NLP tasks.",
    "Vector databases store high-dimensional embeddings.",
    "ChromaDB supports fast vector search."
]

# 2. Sentence-BERT 모델 로딩
model = SentenceTransformer('all-MiniLM-L6-v2')

벡터DB화와 유사도를 측정하기 위한 실습이므로, 'all-MiniLM-L6-v2' 모델을 사용함.

# 3. ChromaDB 클라이언트 생성
chroma_client = chromadb.Client()

ChromaDB의 클라이언트 객체를 생성하여, ChromaDB와 상호작용함.

# 4. ChromaDB에 사용할 Sentence-BERT 기반 임베딩 함수 정의
embedding_function = SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")

ChromaDB가 내부적으로 문서나 쿼리를 벡터로 바꿀 때 사용할 임베딩 생성기를 지정

collection_name = "qa-docs"

# 기존 컬렉션이 존재하는지 확인
existing_collections = chroma_client.list_collections()
collection_names = [col.name for col in existing_collections]

if collection_name in collection_names:
    collection = chroma_client.get_collection(name=collection_name, embedding_function=embedding_function)
    print("vectorDB가 이미 존재합니다.")
else:
    collection = chroma_client.create_collection(name=collection_name, embedding_function=embedding_function)
    print("새로운 vectorDB를 생성합니다.")

ChromaDB가 텍스트를 SBERT 기반 벡터로 변환할 수 있도록 다시 연결해주는 과정

# 6. 쿼리 정의 및 임베딩
query = "What is used in natural language processing?"
query_embedding = model.encode([query])

질문을 변수로 할당하고, 이를 기존 모델을 통해서 벡터화를 진행.

# 7. ChromaDB에서 후보 문서 검색 (빠른 검색)
results = collection.query(
    query_texts=[query],
    n_results=3  # top-k 후보
)

collection.query(...)를 통해서 주어진 쿼리 벡터(=질문)를 기반으로 가장 유사한 문서 3개를 반환

반환되는 결과 구조 (results 변수)

{
  'ids': [['doc2', 'doc4', 'doc1']],
  'documents': [[...]],
  'distances': [[...]]  # (L2 거리 or 유사도 기반 거리값)
}

• documents[0]: Top 3 유사 문장
• distances[0]: 각 문장과의 거리 값 (작을수록 유사함)
• ids[0]: 해당 문서의 ID 값

# 8. 후처리: cosine similarity 계산
print("query: ", query)
for i in range(len(results['documents'][0])):
    doc_text = results['documents'][0][i]
    doc_embedding = model.encode([doc_text])
    sim_score = cosine_similarity(query_embedding, doc_embedding)[0][0]

    print(f"\n[Top {i+1}] 문장: {doc_text}")
    print(f"→ cosine similarity: {sim_score:.4f}")

왜 cosine 유사도를 다시 계산하나요?

query: What is used in natural language processing?

[Top 1] 문장: Transformers are used in NLP tasks. → cosine similarity: 0.5670

[Top 2] 문장: Python is a programming language. → cosine similarity: 0.3393

[Top 3] 문장: Pandas is a library for data analysis. → cosine similarity: 0.2515

→ 따라서, 코사인 유사도를 통해서 문서의 유사도를 확인하는 코드를 다시 작성함

2. 코사인 유사도를 통한 정렬

# 1. 문서 정의
docs = [
    "Python is a programming language.",
    "Pandas is a library for data analysis.",
    "Transformers are used in NLP tasks.",
    "Vector databases store high-dimensional embeddings.",
    "ChromaDB supports fast vector search."
]
doc_ids = [f"doc{i}" for i in range(len(docs))]

# 2. SBERT 모델 로딩
model = SentenceTransformer('all-MiniLM-L6-v2')

# 3. ChromaDB 클라이언트 및 임베딩 함수 설정
chroma_client = chromadb.Client()
embedding_function = SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")

collection_name = "qa-docs"
existing_collections = [col.name for col in chroma_client.list_collections()]

# 컬렉션 불러오거나 생성
if collection_name in existing_collections:
    collection = chroma_client.get_collection(name=collection_name, embedding_function=embedding_function)
    print("기존 컬렉션을 불러왔습니다.")
else:
    collection = chroma_client.create_collection(name=collection_name, embedding_function=embedding_function)
    print("새 컬렉션을 생성했습니다.")

# 이미 저장된 문서 확인 (문장 기준으로 중복 제거)
existing_data = collection.get()
existing_docs = set(existing_data['documents'])

# 새롭게 추가할 문장만 필터링
new_docs = [doc for doc in docs if doc not in existing_docs]
new_ids = [f"doc{i}" for i, doc in enumerate(docs) if doc not in existing_docs]

# 문서 추가
if new_docs:
    collection.add(documents=new_docs, ids=new_ids)
    print(f"{len(new_docs)}개의 문서를 추가했습니다.")
else:
    print("추가할 문서가 없습니다.")

해당 코드를 통해서 컬렉션이 존재하면 기존의 컬렉션을 확인하고, 문서의 존재 여부를 확인하여 해당 문서가 없다는 새롭게 추가하도록 작성

# 5. 의미 검색 함수 (Chroma에서 벡터 꺼내서 직접 비교)
def semantic_search_cosine(query: str, collection, model: SentenceTransformer, top_n: int = 3):
    # query 임베딩
    query_embedding = model.encode([query])[0]

    # Chroma에서 문서 및 벡터 가져오기
    all_data = collection.get()
    doc_texts = all_data['documents']
    doc_ids = all_data['ids']
    doc_embeddings = model.encode(doc_texts)

    # cosine 유사도 계산
    similarities = cosine_similarity([query_embedding], doc_embeddings)[0]
    scored_docs = sorted(zip(doc_texts, similarities), key=lambda x: x[1], reverse=True)

    return scored_docs[:top_n]

VectorDB의 각 문장의 벡터와 새로 입력되어 비교될 벡터의 유사도를 코사인 유사도를 기준으로 비교

# 6. 실행
query = "What is used in natural language processing?"
results = semantic_search_cosine(query, collection, model, top_n=3)

print("query:", query)
print()
for i, (doc, score) in enumerate(results, 1):
    print(f"[Top {i}] 유사도 {score:.4f} → {doc}")

1. 필요 라이브러리 설치

pip install transformers sentence-transformers scikit-learn matplotlib

2. 라이브러리 불러오기

from transformers import AutoTokenizer, AutoModel
import torch
import numpy as np
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

3. BERT 모델 로드

해당 텍스트들을 어떠한 용도로 사용할지 모르기 때문에, 범용성을 가지는 일반 Bert를 활용

# 1. Hugging Face BERT (일반 BERT 사용)
# 해당 텍스트들을 어떠한 용도로 사용할지 모르기 때문에, 범용성을 가지는 일반 Bert를 활용
model_name = 'bert-base-uncased'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

4. 벡터화할 텍스트 데이터 정의

# 문장 리스트
sentences = [
    "I love artificial intelligence.",
    "Machine learning is fascinating.",
    "Natural language processing is a subfield of AI.",
    "Deep learning improves neural networks.",
    "Transformers have changed AI forever."
]

• 문장 리스트로 구성된 입력 데이터

5. 텍스트 토크나이즈

# 2. 토큰화
encoded = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')

• padding=True: 문장 길이를 맞춤
• truncation=True: 최대 길이 초과 시 자름
• return_tensors="pt": PyTorch 텐서 형태로 반환

6. BERT 모델을 이용한 임베딩 추출

# 3. 모델 통과
with torch.no_grad():
    output = model(**encoded)

• torch.no_grad(): 학습이 아닌 추론 모드

# 4. mean pooling 구현 : 문장의 의미를 더 잘 반영하도록 유도
def mean_pooling(model_output, attention_mask):
    token_embeddings = model_output.last_hidden_state
    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    sum_embeddings = (token_embeddings * input_mask_expanded).sum(1)
    sum_mask = input_mask_expanded.sum(1)
    sum_mask = torch.clamp(sum_mask, min=1e-9)  # 0 방지
    return sum_embeddings / sum_mask

embeddings = mean_pooling(output, encoded['attention_mask']).numpy()
print(embeddings.shape)

(5, 768)

• 모델 출력 (model_output)과 attention_mask를 받아서 평균 임베딩을 계산하는 함수.
• 분모가 0이 되는 것을 방지하기 위해 최소값 설정

# 5. PCA로 3차원 축소
pca = PCA(n_components=3)
reduced = pca.fit_transform(embeddings)

• n_components=3은 원래 임베딩 벡터(예: 768차원) 를 3차원으로 줄이겠다는 의미

# 6. PCA 시각화
fig = plt.figure(figsize=(10, 14))
ax = fig.add_subplot(111, projection='3d')
colors = ['r', 'g', 'b', 'y', 'c']
for i, sentence in enumerate(sentences):
    ax.scatter(*reduced[i], c=colors[i], marker='o', s=100, label=sentences[i])
    ax.text(reduced[i][0]+0.2, reduced[i][1]+0.2, reduced[i][2]+0.2, f"{i+1}", size=12, zorder=1, color='black')

ax.set_title("3D PCA of BERT Embeddings: bert-base-uncased + mean pooling")
ax.set_xlabel("PC1")
ax.set_ylabel("PC2")
ax.set_zlabel("PC3")
ax.legend()
plt.show()

2. Sentence-BERT

import torch
from transformers import BertTokenizer, BertModel, AutoTokenizer, AutoModel
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
# 1. 입력 문장
sentences = [
   "I love artificial intelligence.",
   "Machine learning is fascinating.",
   "Natural language processing is a subfield of AI.",
   "Deep learning improves neural networks.",
   "Transformers have changed AI forever."
]
# 2. BERT-base (순수 BERT) 준비
bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
bert_model = BertModel.from_pretrained('bert-base-uncased')
# 3. Sentence-BERT 준비
sbert_tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
sbert_model = AutoModel.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
# 4. BERT-base 임베딩 (CLS 토큰)
def get_bert_embeddings(sentences):
    embeddings = []
    for sentence in sentences:
        inputs = bert_tokenizer(sentence, return_tensors='pt', truncation=True, padding=True)
        with torch.no_grad():
            outputs = bert_model(**inputs)

        # mean pooling 적용
        token_embeddings = outputs.last_hidden_state  # [1, seq_len, hidden_size]
        attention_mask = inputs['attention_mask']     # [1, seq_len]
        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()

        sum_embeddings = (token_embeddings * input_mask_expanded).sum(1)
        sum_mask = input_mask_expanded.sum(1)
        mean_pooled = sum_embeddings / torch.clamp(sum_mask, min=1e-9)

        embeddings.append(mean_pooled.squeeze(0).numpy())

    return np.array(embeddings)

# 5. Sentence-BERT 임베딩 (CLS 토큰)
def get_sbert_embeddings(sentences):
   inputs = sbert_tokenizer(sentences, return_tensors='pt', padding=True, truncation=True)
   with torch.no_grad():
       outputs = sbert_model(**inputs)
   cls_embeddings = outputs.last_hidden_state[:, 0, :] # (batch_size, hidden_size)
   return cls_embeddings.numpy()
# 6. 임베딩 추출
bert_embeddings = get_bert_embeddings(sentences)
sbert_embeddings = get_sbert_embeddings(sentences)
# 7. PCA로 3D 축소
pca_bert = PCA(n_components=3)
pca_sbert = PCA(n_components=3)
bert_3d = pca_bert.fit_transform(bert_embeddings)
sbert_3d = pca_sbert.fit_transform(sbert_embeddings)
# 8. 3D 시각화
fig = plt.figure(figsize=(16, 7))
# BERT 결과
ax1 = fig.add_subplot(121, projection='3d')
for i, sentence in enumerate(sentences):
   x, y, z = bert_3d[i]
   ax1.scatter(x, y, z, label=f"{i+1}")
   ax1.text(x, y, z, f'{i+1}', fontsize=9)
ax1.set_title("BERT-base (bert-base-uncased) Embeddings")
ax1.set_xlabel('PCA1')
ax1.set_ylabel('PCA2')
ax1.set_zlabel('PCA3')
# Sentence-BERT 결과
ax2 = fig.add_subplot(122, projection='3d')
for i, sentence in enumerate(sentences):
   x, y, z = sbert_3d[i]
   ax2.scatter(x, y, z, label=f"{i+1}")
   ax2.text(x, y, z, f'{i+1}', fontsize=9)
ax2.set_title("Sentence-BERT (all-MiniLM-L6-v2) Embeddings")
ax2.set_xlabel('PCA1')
ax2.set_ylabel('PCA2')
ax2.set_zlabel('PCA3')
plt.tight_layout()
plt.show()

BERT-base (bert-base-uncased)에서 [CLS] 토큰은 분류 태스크용이라 문장 의미를 잘 표현하지 못하는 문제점이 존재합니다. 따라서 문장 간의 유사도를 비교하는 데에 있어서 성능이 떨어집니다.

⇒ Sentence-BERT를 활용하여 학습 과정 자체가 의미 기반으로 진행되어, 문자의 의미를 내포하는 데에 더욱 효과적입니다. ⇒ 또한, 이러한 문제점을 해결하기 위해 실습 과정에서 BERT-base (bert-base-uncased)에 mean-pooling을 적용하여 문장의 의미를 더 잘 표현하도록 유도하였습니다.

벡터 DB 정의

"고차원 벡터 데이터를 효율적으로 저장, 관리, 검색하기 위해 설계된 데이터베이스"

특징 및 설명

• 텍스트, 이미지, 오디오 등의 데이터를 임베딩(벡터화)하여 저장하고, 관리하며, 검색 기능을 제공하는 임베딩 벡터 전용 DB
• 고차원(벡터 차원 수)의 공간(인덱스)에 임베디드 벡터를 인덱싱하여 저장하는 방식

주요 기능

• 입력 Query와 가장 가까운 이웃을 찾아주는 방식 사용
• ANN (Approximate Nearest Neighbor) 기반 알고리즘으로 검색 효율성 향상
• 기본적인 CRUD (Create, Read, Update, Delete) 지원
• 벡터 DB 서비스 제공자마다 서로 다른 인덱싱 및 검색 알고리즘 방식 사용

처리 단계

1. Indexing
2. Querying

• 이외에도 검색 성능을 높이기 위한 추가 단계:

  • Loading

  • Transforming

  • Post-Processing

    (→ 벡터 DB가 자체적으로 지원하거나 외부에서 처리)

목적

• 비정형 데이터를 벡터화하여
• 유사한 데이터를 빠르게 찾을 수 있도록 설계된 시스템

주요 특징 - 확장성

기존 DB와 벡터 DB의 차이

벡터 DB의 수평 확장 방식

• Sharding (샤딩)
  • 벡터 데이터를 여러 노드에 분산 저장
  • 예: 10억 개의 벡터를 10개 노드에 1억 개씩 배치
• Distributed Indexing (분산 인덱싱)
  • 검색 시 여러 노드에서 병렬로 처리하여 속도 향상
  • 예: HNSW + IVF를 혼합 적용 가능
• Load Balancing (부하 분산)
  • 대량의 검색 요청을 균등하게 분배하여 성능 유지
  • 예: 여러 개의 검색 서버가 동시에 요청 처리

활용 사례

• AI 기반 이미지 검색 서비스
  • 수억 개 이미지 저장 및 검색
• 대규모 추천 시스템
  • 예: Netflix, Amazon 등의 제품 추천 시스템

주요 특징 - 메타데이터 통합 관리 기능

메타데이터란?

• 벡터와 함께 저장되어 검색 결과에 대한 추가 정보를 제공하는 데이터
• 벡터 데이터 자체는 숫자(좌표)로 표현되기 때문에, 실제 의미를 설명할 부가 정보가 필요함

예시

활용 사례

• AI 검색엔진: 사용자 입력 텍스트와 유사한 문서를 찾은 후 제목, 저자, 링크 제공
• 전자상거래 추천 시스템: 유사한 제품 추천 시 상품명, 가격, 브랜드 등 함께 표시
• 의료 데이터 분석: 환자 유사도 검색 시 환자 ID, 병원, 진료 기록 등과 연계

메타데이터를 활용한 향상된 검색

• 벡터 검색 이후, 필터링(Query Filtering) 가능
• 예: '강아지 이미지' 검색 결과 중 최근 1년 이내 업로드된 데이터만 조회

주요 특징 - 동적 데이터 업데이트 지원

기존 RDB의 문제점

• 새로운 데이터를 추가할 때 전체 인덱스를 다시 생성해야 함
  • → 처리 속도 느림
• 벡터 데이터는 고차원 공간에 위치해 있기 때문에 위치가 바뀌면 업데이트가 어려움

벡터 DB에서의 동적 업데이트 방식

1. Incremental Indexing (점진적 인덱싱)
   • 전체 인덱스를 재구성하지 않고 기존 인덱스에 새 데이터를 추가
   • 예: HNSW 방식에서 새로운 노드를 기존 구조에 연결
2. Lazy Update (지연 업데이트)
   • 벡터를 즉시 반영하지 않고, 일정 시간 후 일괄 업데이트(batch)
   • 검색 성능 유지하면서 동적 데이터 반영 가능
3. Delete & Rebuild (삭제 후 재구성)
   • 일정 시간마다 불필요한 벡터를 삭제하고 인덱스를 재구성하여 최적화 유지

활용 사례

• 실시간 감성 분석: SNS에서 사용자 감정(긍정/부정)을 업데이트하여 최신 트렌드 반영
• 보안 시스템 (얼굴 인식): 새로운 얼굴 벡터를 실시간으로 추가하여 보안 강화
• 뉴스 추천 시스템: 새로운 기사가 추가되면 즉시 벡터화하여 추천 시스템에 반영

벡터 DB의 중요성

1. 대용량 데이터도 빠르게 검색 가능

   • 고속 검색을 위한 알고리즘 활용:

     예) HNSW, IVF, PQ 등

2. 메타데이터 통합 관리

   • 검색 결과에 부가 정보를 함께 제공하여 더 풍부한 결과 도출 가능

3. 실시간 데이터 업데이트 지원

   • 새로운 데이터가 추가되면 즉시 반영 가능, 최신 상태 유지

벡터 DB는 AI 시대의 필수 기술

• OpenAI, Google, Facebook 등에서 사용하는 핵심 기술
• AI 모델을 활용한 다양한 서비스에 적용됨
  • 예) 추천 시스템, 보안, 검색, 자연어 처리(NLP), 의료 AI 등

#3. 벡터와 벡터 공간

유클리드 거리 (Euclidean Distance)

• 가장 기본적인 거리 측정 방식
• 두 벡터 간의 직선 거리(피타고라스 정리 기반)를 계산
• 저차원(2D, 3D)에서는 효과적이지만, 차원이 증가할수록 성능이 저하

공식:

$$ d(a,b)= \sqrt{(a_1 - b_1)^2 + (a_2 - b_2)^2 + \cdots + (a_n - b_n)^2} $$

고차원에서의 문제점

1. 차원의 저주 (Curse of Dimensionality)
   • 차원이 높아질수록 벡터 간 거리가 균등하게 증가
   • → 거리 기반 검색의 효용이 떨어짐
   • → 데이터가 희소해지고, 유사한 벡터를 찾기 어려워짐
2. 유사한 벡터 간 거리 차이가 작아짐
   • 고차원 공간에서는 대부분의 점들이 서로 비슷한 거리를 가지게 되어, 분별력이 낮아짐

해결 방법: 코사인 유사도 (Cosine Similarity)

• 벡터 간의 방향(각도)를 비교하여 유사도를 측정
• 방향이 중요한 경우에 효과적 (예: 자연어 처리에서 단어 벡터)

공식:

$$ cos⁡(θ) = \frac{\mathbf{a} \cdot \mathbf{b}}{|\mathbf{a}| |\mathbf{b}|} $$

• 0도 (동일 방향): 유사도 = 1
• 90도 (직각): 유사도 ≈ 0
• 180도 (반대 방향): 유사도 = -1

요약

• 고차원 공간에서는 유클리드 거리보다 코사인 유사도가 더 적합한 경우가 많음
• 특히, 단어 임베딩이나 BERT 등의 자연어 처리 벡터에서는 방향 정보가 중요

벡터 DB

쿼리가 들어오면 Index를 비교

전체 프로세스

관계형 VS 벡터 DB

벡터 Embedding 기초

단어, 문장, 이미지 같은 데이터를 숫자로 변환하는 과정

비유: 도시 위치

• 우리가 살고 있는 도시는 비슷한 지역끼리 가까운 위치에 배치되어 있음
  • 서울 vs. 부산 → 같은 나라, 비슷한 카테고리
  • 서울 vs. 도쿄 → 가깝지만 다른 나라, 유사성 존재
  • 서울 vs. 고양이 → 완전히 무관, 관련 없음

벡터 임베딩과의 연관성

• 벡터 임베딩도 같은 원리
  • 비슷한 의미를 가진 단어나 이미지끼리는 가까운 숫자 벡터로 변환

벡터 임베딩의 목적

• 텍스트, 이미지, 소리 등 비정형 데이터를 숫자로 표현하는 과정
• 컴퓨터가 의미를 이해하고, 이를 통해 검색, 추천, 번역 등에 활용

요약하자면, 벡터 임베딩은 의미가 비슷한 데이터들을 공간상에서 가깝게 위치시키는 방식이며, 이를 통해 AI는 인간처럼 유사성을 판단할 수 있게 됩니다.

word2vec → BERT

Word2Vec (2013)

• 아이디어
  • "비슷한 의미의 단어들은 벡터 공간에서 가깝게 위치할 것"
  • 단어를 숫자로 변환하여 의미를 벡터화
• 특징
  • 단어를 고정된 벡터로 표현 (문맥 고려하지 않음)
  • 문맥 이해 부족 → 예: “bank”가 은행인지, 강변인지 구분 불가
• 예시 벡터

| 단어 | Word2Vec 벡터 예시 |
| --- | --- |
| king | [0.2, 0.5, 0.8] |
| queen | [0.3, 0.6, 0.6] |
| apple | [0.8, 0.1, 0.2] |

• 장점
  • 연산 가능: "king - man + woman = queen"과 같은 관계 유추 가능

해당 연산이 답은 “일본”

BERT (2018, Google)

• 개요

  • Word2Vec의 한계를 개선한 최신 기법
  • 문맥을 반영하여 단어의 의미를 더 정교하게 임베딩

• 특징

  • Transformer 기반 모델

  • 문장의 양방향 문맥을 활용하여 단어의 의미 파악

  • 예: "나는 은행(bank)에서 돈을 찾았다." → 금융

    "강둑 은행(bank)에 앉아 있었다." → 강변

    → 문맥에 따라 의미를 정확히 구분 가능

• 활용

  • 문장 의미 파악, 검색, 챗봇, AI 번역 등 다양한 NLP 응용에 활용

핵심 비교 요약

Word2vec 학습 메커니즘

CBOW (Continuous Bag of Words)

• 개념:

  문맥(Context) 단어를 보고 중심 단어(Target Word)를 예측하는 방식

  예: "나는 맛있는 피자를 먹었다."

  • 중심 단어: "피자"

  • 주변 단어: ["나는", "맛있는", "먹었다"]

    → 입력: ["나는", "맛있는", "먹었다"] → 출력: "피자"

• 구조:

  입력(주변 단어) → 신경망 학습 → 출력(중심 단어 예측)

• 특징:

  • 학습 속도가 빠름
  • 자주 등장하는 단어 예측에 유리
  • 문맥을 고려한 예측 가능

Skip-Gram

• 개념:

  중심 단어(Target Word)를 보고 주변 단어(Context Words)를 예측하는 방식

  예: "나는 맛있는 피자를 먹었다."

  • 중심 단어: "피자"

  • 주변 단어: ["나는", "맛있는", "먹었다"]

    → 입력: "피자" → 출력: ["나는", "맛있는", "먹었다"]

• 구조:

  입력(중심 단어) → 신경망 학습 → 출력(주변 단어 예측)

• 특징:

  • 희귀 단어 학습에 강함
  • CBOW보다 학습 속도는 느림
  • 데이터가 적을 때도 성능이 좋음

요약 비교

윈도우 크기와 문맥(Context)

• 윈도우 크기 2 라면:

  • 중심 단어 기준으로 앞쪽 2개, 뒤쪽 2개의 단어를 문맥으로 보는 것을 의미

  • 예: 중심 단어가 "fox"일 때

    → 문장: the quick brown fox jumps over the lazy dog

    → 주변 단어: ["quick", "brown", "jumps", "over"]

• CBOW 모델:

  주변 단어를 보고 중심 단어를 예측

• Skip-Gram 모델:

  중심 단어를 보고 주변 단어를 예측

• 윈도우 크기가 n이라면, 주변 단어 수는 총 2n개

정의

문장 전체에 슬라이딩 윈도우를 적용하여 학습용 데이터를 만드는 과정을

슬라이딩 윈도우(sliding window) 라고 부름.

Word2Vec의 한계점

1. 문맥 무시

• 같은 단어라도 문맥에 따라 의미가 달라질 수 있음

  → 기존 임베딩은 이를 고려하지 않음

• 예시:

  • "단풍잎이 시뻘겋다."

  • "얼굴이 시뻘겋다."

    (같은 단어 "시뻘겋다"지만 의미 다름)

2. 다의성 해결 불가

• 같은 단어인데도 여러 의미(다의어)를 가지는 경우 하나의 벡터로만 표현됨

• 예시:

  • "모자(cap)" → 모자(의류), 모자(엄마와 아들)

    → 의미 구분 불가

3. 장기 의존성 문제

• 기존 모델은 근처 단어에만 의존하여 학습함

• 멀리 떨어져 있어도 의미적으로 연관된 단어 간의 관계를 반영하지 못함

• 예시:

  • "나는 많은 나라를 여행했고,

    그 중 프랑스는 내가 좋아하는 나라 중 하나였다."

    → "프랑스"와 "좋아하는 나라" 사이의 연관성 반영 어려움

이미지 임베딩 : CNN 기반 특성 추출

CNN (합성곱 신경망, Convolutional Neural Network)

1. CNN의 개념

• CNN은 사람이 이미지를 볼 때, 먼저 큰 특징(예: 얼굴, 배경)을 보고, 점차 세부적인 특징(예: 눈, 입, 턱)을 인식하는 방식과 유사한 구조로 설계된 딥러닝 모델이다.

2. CNN의 핵심 과정

• Conv Layer (합성곱 층)

  필터를 사용하여 이미지에서 엣지, 모양 등 중요한 패턴을 추출한다.

• Pooling Layer (풀링 층)

  정보를 압축하여 연산 속도를 높이고, 불필요한 부분을 제거한다.

• Fully Connected Layer (완전 연결 층)

  벡터화된 정보를 바탕으로 객체(강아지, 고양이, 사람 등)를 분류한다.

3. 활용 방식

• CNN은 이미지를 숫자 벡터로 변환하여, 유사한 이미지끼리 벡터 간의 거리로 비교할 수 있도록 한다.
• 예: 얼굴 인식 시스템에서는 비슷한 얼굴일수록 유사한 벡터 값을 갖게 되어, 이를 기반으로 얼굴을 매칭한다.

멀티모달 임베딩 (텍스트 + 이미지 결합)

멀티모달 (Multimodal)

1. 개념

• 여러 형태의 데이터를 동시에 이해할 수 있는 AI 모델

  예: 텍스트, 이미지, 음성 등을 함께 처리

• 예: ChatGPT 같은 AI가 "고양이"라는 텍스트를 입력받고 실제 고양이 이미지를 찾아낼 수 있는 기능

예시 및 적용 사례

CLIP (OpenAI)

• 텍스트(예: 설명)와 이미지(예: 사진)를 동일한 벡터 공간에 배치
• 예: "개"라는 단어를 입력하면 개와 관련된 이미지 벡터를 가까운 위치로 매칭시킴

DALL·E (OpenAI)

• 텍스트로 설명한 내용을 바탕으로 AI가 이미지를 생성

멀티모달 임베딩 방식의 예

1. 텍스트: "바닷가에서 노는 강아지"
2. 이미지 벡터: 실제 바닷가에서 노는 강아지 사진
3. 벡터 비교: 텍스트 벡터와 이미지 벡터 간의 거리를 계산해 가까운 것을 매칭

→ 검색 엔진에서 "강아지"라고 검색하면 강아지 이미지가 자동으로 나오는 원리와 유사

정리: 벡터 임베딩 기초

1. 벡터 임베딩이란?

• 데이터를 숫자로 변환하여 AI가 이해할 수 있도록 하는 과정

2. 텍스트 임베딩 (Word2Vec → BERT)

• 문맥을 이해하는 방식으로 발전
• 검색, 번역, 챗봇 등 다양한 자연어 처리 분야에서 활용됨

3. 이미지 임베딩 (CNN 기반)

• 이미지의 특징을 벡터로 변환
• 검색, 분류, 추천 시스템 등에 사용됨

4. 멀티모달 임베딩 (텍스트 + 이미지 결합)

• AI가 텍스트와 이미지를 동시에 이해하도록 하는 기술
• 대표 예: CLIP, DALL·E 등

생성형 AI가 발전하면서 환각 없는 생성형 콘텐츠의 중요성이 확대됐고, 환각을 최소화하는 방안으로 RAG가 각광받고 있습니다.

또한, RAG를 위해서는 벡터 DB가 반드시 필요합니다.

전통적인 데이터베이스 vs 벡터 데이터베이스 비교

요약 설명

• 전통적인 데이터베이스는 ‘정확한 값을 찾는 데 강함’

• 벡터 데이터베이스는 ‘비슷한 것을 찾는 데 강함’

[참고] KNN 검색 vs. ANN 검색

요약

• KNN: 정확도는 높지만 속도와 확장성이 떨어짐. 소규모 데이터에 적합

• ANN: 근사값을 이용하여 빠른 검색 가능. 대규모 벡터 검색에 적합

벡터 데이터베이스의 필요성

기존 데이터베이스의 한계

• 숫자나 텍스트(예: "홍길동") 같은 구조화된 데이터 저장·검색에는 최적화되어 있음

• 이미지, 음성, 문장 의미 같은 비정형 데이터 검색은 어려움

• 이미지, 영상, 음성, 텍스트 등 비정형 데이터의 확산으로 기존 관계형 DB만으로는 한계

  • SNS, 쇼핑, 스트리밍 플랫폼에서 비정형 데이터 활용 증가

• ChatGPT, DALL·E, Stable Diffusion 등 생성형 AI 발전

• 이미지 검색, 음성 인식, 추천 시스템 등에는 고급 검색 필요

• 전통적인 데이터베이스에서는 유사도 검색의 비효율성

  → 벡터 DB 필요성 대두

벡터 데이터베이스가 해결하는 문제

• 데이터를 숫자 벡터(좌표)로 변환하여 저장하고

  "비슷한 것"을 쉽게 찾을 수 있음

• 활용 예시:

  • 이미지 검색: “이 사진이랑 비슷한 사진 찾아줘!”

  • 음성 인식: “이 사람 목소리랑 비슷한 사람 찾아줘!”

  • 추천 시스템: “내가 좋아할 만한 음악 추천해줘!”

이미지에서의 VectorDB

1. 이미지 임베딩(벡터화) 속도

• 자율주행 카메라에서 들어오는 영상 프레임을 실시간 벡터로 바꾸려면, 경량화된 모델 또는 하드웨어 가속이 필수입니다.

• 해결책:

  • ONNX, TensorRT로 딥러닝 모델 경량화 및 최적화

  • GPU/TPU 또는 엣지 디바이스(NVIDIA Jetson, Coral 등) 활용

  • 딥러닝 모델을 Batch 처리하여 처리 효율 향상

2. 벡터 유사도 검색 속도

• 벡터 DB는 수천만 개의 벡터 중에서 유사한 벡터를 빠르게 찾아야 함

• 해결책:

  • ANN (Approximate Nearest Neighbor) 알고리즘 사용 (예: HNSW, IVF)
  • 벡터 DB에서 search latency를 10ms 이하로 줄이는 기술 확보
  • Memory-mapped storage, RAM caching, quantization(PQ) 기법 활용

3. 동시성 및 시스템 아키텍처 최적화

• 실시간 시스템은 단일 질의 성능뿐만 아니라 동시 다수 요청 처리 능력도 중요

• 해결책:

  • 마이크로서비스 기반으로 벡터화/검색 분리 (Embedding 서버 ↔ Vector DB 서버)
  • 실시간 스트림 프레임워크 (Kafka, ROS 등)와 연계
  • 벡터 DB는 미리 인덱싱된 데이터로만 검색하고, 새 벡터는 배치로 업데이트

실제 사용 예시

결론

• 실시간 유사도 검색은 가능하지만 고성능 하드웨어 + 최적화된 아키텍처 + 효율적인 알고리즘이 전제 조건입니다.

• 자율주행처럼 수밀리초 수준의 응답 시간이 요구되는 환경에서도 벡터 DB는 적극 활용되고 있습니다.

벡터와 벡터공간

벡터란?

• 벡터: 여러 개의 숫자로 이루어진 배열
• 예시
  • 1차원 벡터: [5]
  • 2차원 벡터: [3, 4]
  • 3차원 벡터: [2, 5, 1]
• 활용 예시
  • 위치 좌표: [x, y] = [3, 4] (지도상의 위치)
  • 색상 정보: [R, G, B] = [255, 0, 0] (빨간색)

벡터는 숫자로 이루어진 데이터의 표현 방식

고차원 벡터 공간이란?

• 벡터의 차원이 많아지면 고차원 벡터 공간이 됨

• 예: 텍스트를 벡터로 바꾸면

  → [0.2, 0.8, 0.5, 0.1, …] 형태가 됨

• 이런 방식으로 텍스트, 이미지, 음성 등을 벡터로 변환 가능

벡터화 (Vectorization)란?

• 텍스트, 이미지, 오디오 등의 데이터를 벡터(숫자 배열)로 변환하는 과정

벡터 임베딩 (Embedding)이란?

• 데이터를 의미가 보존된 숫자 벡터로 변환하는 방법
• AI가 이해할 수 있도록 데이터를 표현하는 과정

벡터 임베딩은 데이터를 숫자로 변환하는 중요한 과정

벡터화 방법 예시

1. 텍스트 → 벡터
   • Word2Vec: 단어의 의미를 숫자로 표현
   • BERT: 문장의 의미까지 이해할 수 있도록 표현
2. 이미지 → 벡터
   • CNN(합성곱 신경망)을 이용해 이미지의 특징을 벡터로 변환
3. 오디오 → 벡터
   • MFCC, Wave2Vec 등을 이용하여 음성을 벡터로 변환

BERT

BERT란?

• BERT (Bidirectional Encoder Representations from Transformers)는

  자연어 처리(NLP)를 위한 인공지능 모델

• 구글에서 개발

• 문장의 맥락을 양방향(Bidirectional) 으로 이해하는 것이 특징

BERT의 특징

1. 양방향 이해

   • 기존 모델은 왼쪽 → 오른쪽 또는 오른쪽 → 왼쪽 한 방향만 학습
   • BERT는 양방향으로 문장을 학습 → 문장 전체의 맥락을 더 정확히 파악 가능

2. 문맥 이해 능력

   • 예:

     "나는 은행에 갔다." → 금융기관인지, 강변인지 문맥으로 구분 가능

     "나는 은행에서 돈을 찾았다." → "금융기관"으로 해석

3. 사전 훈련 후 미세 조정 (Fine-tuning)

   • 대량의 텍스트로 기본 학습 후
   • 특정 작업(감성 분석, 번역 등)에 맞춰 세부 조정 가능

BERT의 활용 사례

• 검색 엔진

  → 검색 결과의 정확도 향상 (예: 구글 검색)

• 챗봇

  → 질문의 맥락을 이해하고 더 정확한 답변 제공

• 문장 의미 분석

  → 문장의 긍정/부정 감정 분석, 질문-답변 시스템 등에 활용

BERT 간단한 실습 예제 (Hugging Face 사용)

1. 라이브러리 임포트

from transformers import BertTokenizer, BertModel

2. BERT 토크나이저 불러오기

tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

3. 예제 문장 정의

text = "I love natural language processing."

4. 문장을 토큰화

tokens = tokenizer.tokenize(text)
print(tokens)

5. 토큰을 인덱스로 변환

input_ids = tokenizer.encode(text, add_special_tokens=True)
print(input_ids)

Hugging Face의 transformers 라이브러리를 사용하면 BERT 모델을 쉽게 불러와 문장을 토큰화하고, 모델이 이해할 수 있는 입력 형식으로 변환할 수 있습니다.

MFCC, Mel-Frequency Cepsrtal Coefficients

MFCC란?

• 음성 신호를 숫자로 변환(음성 벡터화)하는 기술
• 사람의 청각 특성을 반영하여 음성 데이터를 분석하는 데 유용

MFCC 원리 및 음성 처리 과정

원리

• 사람의 귀는 주파수가 낮은 소리에 더 민감함
• 이러한 청각 특성을 반영해 음성을 분석

음성 처리 과정

1. 음성을 작은 조각(Frame)으로 나눔
2. 각 조각을 푸리에 변환(Fourier Transform)하여 주파수 분석
3. Mel 필터 적용 (인간 청각에 맞게 변환)
4. Cepstrum 분석 (중요한 특징을 추출하여 벡터화)

→ 이 과정을 통해 음성을 숫자로 변환

활용 사례

• 음성 인식
  • 예: "Siri, 오늘 날씨 어때?"
• 음성 감정 분석
  • 사람의 감정을 분석해 상담 서비스에 활용
• 음성 인증 시스템
  • 예: 은행 콜센터 등에서 목소리로 본인 확인

MFCC 실습 (Python - librosa 라이브러리 사용)

1. 라이브러리 임포트

import librosa
import librosa.display
import numpy as np
import matplotlib.pyplot as plt

2. 음성 파일 로드

audio_file = "example.wav"
y, sr = librosa.load(audio_file, sr=22050)

• y: 음성 신호
• sr: 샘플링 레이트 (22050Hz)

3. MFCC 특징 추출

mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)

• 13개의 MFCC 계수를 추출

4. MFCC 시각화

plt.figure(figsize=(10, 4))
librosa.display.specshow(mfccs, x_axis="time")
plt.colorbar()
plt.title("MFCC")
plt.show()

• MFCC 결과를 시간에 따라 시각화

요약

• 음성 데이터를 MFCC로 변환하고
• 변환된 결과를 시각화하여 분석에 활용

Wave2Vec

Wave2Vec 개요

설명

• 텍스트 레이블 없이도 음성 학습이 가능한 딥러닝 모델
• Facebook AI 연구팀이 개발

주요 특징

1. 비지도 학습(Self-Supervised Learning)
   • Wave2Vec은 음성 데이터만으로 사전 학습 진행
   • 레이블이 없는 대량의 음성 데이터로도 학습 가능
2. 음성을 직접 벡터로 변환
   • 기존 방식(MFCC 등)은 중간 처리 과정이 필요
   • Wave2Vec은 원본 음성(Waveform)을 바로 벡터로 변환 가능
3. 적은 데이터로도 뛰어난 성능
   • 기존 모델은 많은 데이터가 필요했으나
   • Wave2Vec은 적은 데이터로도 높은 정확도 가능

활용 사례

• 자동 음성 인식 (ASR, Automatic Speech Recognition)
  • 예: AI 비서, 콜센터 자동화
• 자연어 처리와 결합
  • 음성을 텍스트로 변환 후 감정 분석 등 가능
• 다국어 음성 인식
  • 적은 데이터로 다양한 언어 학습 가능

Wave2Vec 실습 예제 (Hugging Face 사용)

1. 라이브러리 임포트

from transformers import Wav2Vec2Processor, Wav2Vec2ForCTC
import torch
import librosa

2. Wave2Vec 모델 불러오기

processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-large-960h")
model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h")

3. 음성 파일 로드

audio_file = "example.wav"
y, sr = librosa.load(audio_file, sr=16000)

4. 음성을 모델 입력 형식으로 변환

input_values = processor(y, return_tensors="pt", sampling_rate=16000).input_values

5. 모델 예측 수행

with torch.no_grad():
    logits = model(input_values).logits

6. 예측값을 텍스트로 변환

predicted_ids = torch.argmax(logits, dim=-1)
transcription = processor.batch_decode(predicted_ids)[0]
print(transcription)

요약

• 음성 파일을 불러와 Wave2Vec 모델에 입력
• 음성을 텍스트로 변환하여 자동 음성 인식 구현 가능

Hugging Face

Hugging Face 개요

• 자연어 처리(NLP) 분야에서 유명한 AI 스타트업이자 오픈소스 커뮤니티
• AI 모델을 쉽게 사용할 수 있도록 다양한 도구와 라이브러리를 제공

주요 서비스 및 제품 - Transformers

• Transformers 라이브러리
  • Hugging Face에서 제공하는 가장 유명한 오픈소스 라이브러리
  • 다양한 사전 학습(pre-trained) 모델을 쉽게 사용할 수 있음
  • 주요 모델 예시:
    • BERT, GPT, T5, BART, RoBERTa, XLM-R 등
  • 이 라이브러리를 통해 NLP 모델을 쉽게 로드, 훈련, 평가, 추론 가능

예시 코드

from transformers import pipeline

# 사전 학습된 모델을 사용한 감정 분석
classifier = pipeline('sentiment-analysis')
result = classifier("I love using Hugging Face!")
print(result)

• Hugging Face의 사전 학습된 감정 분석 모델을 사용하여 주어진 텍스트의 감정을 분석

주요 서비스 및 제품 - Hugging Face Hub

• Hugging Face Hub
  • 수천 개의 AI 모델과 데이터셋을 호스팅하는 플랫폼
  • 다양한 모델을 다운로드하거나 자신만의 모델을 업로드 가능
  • 텍스트, 이미지, 음성 등 여러 가지 유형의 모델과 다양한 언어를 지원
  • 개발자들은 공개된 모델을 직접 사용하거나, 자신만의 모델을 공유할 수 있음

주요 서비스 및 제품 - Datasets

• Hugging Face Datasets
  • 수백 가지의 NLP 중심 데이터셋을 포함한 라이브러리 제공
  • 데이터를 쉽게 로드, 변환, 분석할 수 있음
  • 예시 데이터셋:
    • SQuAD
    • GLUE
    • CoNLL-03

주요 서비스 및 제품 - AutoNLP 및 AutoML

• AutoNLP
  • 자동화된 NLP 모델 훈련과 최적화를 위한 서비스
  • 프로그래밍 경험이 없어도 인터페이스를 통해 모델을 쉽게 훈련시키고 사용할 수 있음

Hugging Face – 핵심 특징

1. 오픈 소스

• Hugging Face의 Transformers 라이브러리는 완전 오픈 소스로 누구나 무료로 사용 가능
• 코드와 모델은 GitHub에 공개되어 있어, 누구나 자신의 모델을 업로드하거나 기여 가능

2. 다양한 사전 학습 모델 (Pre-trained)

• 다양한 사전 학습된 모델을 통해 AI 연구자와 개발자들이 이미 학습된 모델을 기반으로 빠르게 실험 및 적용 가능
• 많은 데이터로 학습된 고성능 모델이며, 텍스트 분석, 요약, 번역, 감정 분석 등 다양한 작업 가능

3. 편리한 사용

• 간단한 API와 파이프라인을 통해 복잡한 모델도 손쉽게 사용 가능
• 예: pipeline 함수를 쓰면 감정 분석, 텍스트 요약, 질의응답 시스템 등을 쉽게 구현할 수 있음

4. 협업 및 커뮤니티

• AI 커뮤니티가 잘 활성화되어 있어 여러 연구자들이 모델을 공유하고 협업 체계가 잘 구성되어 있음

Python 설치 및 확인

1. Python 버전 확인 명령어

    python --version
    또는
    python3 --version
   

2. Python 다운로드 링크

   https://www.python.org/downloads/release/python-31010/

3. 설치 시 주의 사항

   설치 시 "Add Python to PATH" 옵션 체크 필수

4. 설치 완료 후 확인 방법

   VSCode에서 다음 명령어로 설치 확인

    python --version
   

벡터 DB 실행을 위한 필수 라이브러리 설치

• 설치 명령어

    pip install faiss-cpu weaviate-client pymilvus pinecone-client
  

• 설치된 라이브러리 예제 코드

  
    import faiss
    import weaviate
    import pymilvus
    import pinecone
  
    print("벡터 DB 라이브러리 설치 완료!")

• 참고: faiss, milvus, weaviate, pinecone 등은 일반적으로 벡터 데이터베이스를 실행할 때 사용하는 대표적인 라이브러리들입니다.

ChromaDB 환경설정

Windows 환경에서 ChromaDB 설치 절차

필수 요구 사항 : Python 3.10.x 권장 + pip 최신 버전 + 가상환경(Virtual Environment) 사용

1. Python 버전 확인

    python --version

2. pip 최신 버전으로 업데이트

    python -m pip install --upgrade pip

3. 가상환경 생성 및 활성화 (venv 사용)

    python -m venv chromadb_env
    .\chromadb_env\Scripts\Activate

4. ChromaDB 설치

    pip install chromadb

【 Chroma DB 인덱싱 & 검색 예제 】

import chromadb

# Chroma DB 인스턴스 생성
chroma_client = chromadb.PersistentClient(path="./chroma_db")

# 컬렉션 생성 (벡터를 저장할 공간)
collection = chroma_client.get_or_create_collection(name="test_collection")

# 데이터 추가 (텍스트와 벡터)
collection.add(
    documents=["Hello World", "Artificial Intelligence", "벡터 Databases are cool!"],
    metadatas=[{"source": "A"}, {"source": "B"}, {"source": "C"}],
    ids=["doc1", "doc2", "doc3"]
)

# 검색 테스트 (유사한 문서 찾기)
results = collection.query(
    query_texts=["AI"],
    n_results=2
)

print("검색 결과:", results)

• 벡터 삽입 및 검색이 정상적으로 동작하는지 확인

ChromaDB Collection

벡터 DB Collection = RDB 테이블 = 엑셀 시트…

• Collection은 RDB의 테이블과 같은 역할로 데이터를 저장할 수 있는 저장소

• 벡터 데이터와 그와 관련된 메타데이터를 논리적으로 그룹화한 데이터 집합

구성요소

벡터, 메타데이터, ID = RDB 테이블 컬럼…

• 벡터(Vector): 컬렉션에 저장되는 고차원 벡터 값, 각 데이터의 임베딩(embedding) 정보

• ID: 각 벡터의 고유한 식별자, 이름 등을 통해 특정 벡터를 조회하거나 업데이트 가능

• 메타데이터(Metadata): 벡터에 추가로 연결된 정보로, JSON 형식의 데이터

  (예: 한국어 위키의 각 제목, 작성자 등)

• 문서(Document): 컬렉션에서 추가적으로 저장되는 문서 형식의 데이터

• URI: 컬렉션에 추가적으로 저장하기 어려운 이미지나 음성 등의 데이터 경로

list_collections

• client.count_collections()

  → Collection 개수 조회

• client.list_collections()

  → Collection 목록 조회

delete_collection

• client.delete_collection(name="height_weight")

  → Collection 삭제

  → 해당 Collection이 존재하지 않으면 오류 발생

【 get_or_create_collection 】

client.get_or_create_collection(
    name="chroma_tutorial",
    metadata={
        "hnsw:space": "cosine"
    }
)

• Collection 생성 또는 조회

  해당 이름의 Collection이 없으면 생성, 있으면 그대로 조회

• 검색 방식 설정

  "hnsw:space" 옵션을 통해 l2, ip, cosine 등 검색 방법 지정 가능

metadata={"hnsw:space": "cosine"} 설명

이 설정은 HNSW(탐색 알고리즘)를 사용할 때 어떤 거리 측정 방식(search metric)을 사용할지를 지정합니다.

【 Add 】

collection.add(
    ids=id_list,
    embeddings=embedding_list,
    metadatas=metadata_list,
    documents=doc_list,
    uris=uri_list
)

각 인자의 의미:

• ids=id_list

  → 유일한 구분자. 중복 입력 불가

• embeddings=embedding_list

  → 특정 벡터 목록. 고차원 임베딩 벡터들을 직접 지정

• metadatas=metadata_list

  → 원본 데이터의 메타데이터. Dict 형식으로 입력 (예: 출처, 카테고리 등)

• documents=doc_list

  → 특정 벡터를 생성하기 위한 문서 텍스트

• uris=uri_list

  → 이미지, 음성 등과 같이 컬렉션에 직접 저장하기 어려운 데이터의 경로

이 중 최소한 ids와 documents 또는 embeddings는 필수입니다. 둘 다 없으면 벡터 추가가 불가능합니다.

【 GET 】

collection.count()

→ 데이터 개수 조회

collection.get(
    offset=0,              # 데이터 시작 위치
    limit=3,               # 조회할 데이터 개수
    where={"키": {"$gte": 170}},           # Metadata 검색 조건
    where_document={"$contains": "name"}  # Document 검색 조건
)

Where Document 조건

• $contains : 문자열 포함
• $not_contains : 문자열 포함하지 않음
• $and : and 조건
• $or : or 조건

Where 조건

• $eq : 동일 (문자열, 정수, 부동 소수점)
• $ne : 동일하지 않음
• $gt : 큼 (정수, 부동 소수점)
• $gte : 크거나 같음
• $lt : 작음
• $lte : 작거나 같음

【 Query 】

collection.query(
    [183, 78],                          # 유사도를 검색할 특정 벡터
    where={"키": {"$gte": 170}},       # Metadata 검색 조건
    where_document=None,               # Document 검색 조건
    n_results=11,                      # 조회할 데이터 개수
    include=['metadatas', 'embeddings']  # 검색 결과에 포함시킬 필드
)

【 DELETE 】

collection.delete(
    ids=None,                                     # 삭제할 데이터 ID
    where={"키": {"$lte": 170}},                  # 삭제할 Metadata 조건
    where_document={"$contains": "name"}          # 삭제할 Document 조건
)

각 인자 설명

• ids : 삭제할 벡터의 ID 목록. None이면 ID 조건 없이 삭제
• where : 메타데이터를 기준으로 삭제할 조건 지정
• where_document : 문서 내용을 기준으로 삭제할 조건 지정

이 함수는 조건에 일치하는 데이터만 삭제하며, ID, 메타데이터, 문서 중 하나 이상으로 삭제 조건을 줄 수 있습니다.

PostgreSQL + pg벡터

1. PostgreSQL 설치

sudo apt -y install postgresql
sudo apt -y install postgresql-server-dev-all gcc make

2. PostgreSQL 실행

sudo service postgresql start

3. 관리자 비밀번호 설정

sudo -u postgres psql -U postgres -c "ALTER USER postgres PASSWORD 'postgres';"

위 명령어들은 Ubuntu 등 Debian 기반 리눅스 환경에서 PostgreSQL을 설치하고 기본 설정을 하는 데 사용됩니다.

pg벡터 설치 방법

1. pg벡터란?

• PostgreSQL에서 벡터 검색 기능을 추가해주는 확장 플러그인
• 벡터 데이터를 저장하고 유사성 검색 가능

2. 소스 코드 다운로드 및 설치

git clone https://github.com/pgvector/pgvector.git
cd pgvector
make
sudo make install

3. pg벡터 플러그인 활성화

CREATE EXTENSION IF NOT EXISTS vector;

위 단계를 따라 하면 PostgreSQL에서 벡터 유사도 검색을 수행할 수 있습니다.

벡터 테이블 생성

【 SQL: Create Table 】

CREATE TABLE IF NOT EXISTS height_weight (
    username varchar(64) NOT NULL,     -- 기존 RDB 필드
    height real NOT NULL,
    weight real NOT NULL,
    embedding vector(2) NOT NULL       -- 2차원 벡터를 저장할 수 있는 필드
);

설명

• username, height, weight는 일반적인 관계형 데이터베이스(RDB) 필드
• embedding vector(2)는 pgvector 확장을 통해 사용 가능한 2차원 벡터 필드
  • 예: [180.0, 75.0] 같은 벡터를 저장

【 SQL: INSERT 】

INSERT INTO height_weight VALUES (
    'hong',           -- 기존 RDB 입력과 동일
    176.7,
    72.2,
    '[176.7, 72.2]'   -- 벡터 입력 형식은 string 형식
);

설명

• username, height, weight는 일반적인 RDB 필드 값
• embedding 필드에는 문자열 형태의 벡터를 입력 (예: '[값1, 값2]')
• pgvector 확장을 통해 벡터 형태로 저장됨

【 SQL: SELECT 】

SELECT * FROM height_weight
WHERE height > 177
ORDER BY embedding <-> '[183,78]'
LIMIT 11;

설명

• WHERE height > 177

  → 기존 RDB 조건과 동일하게 사용 가능

• ORDER BY embedding <-> '[183,78]'

  → embedding 벡터 필드를 기준으로 유사도 정렬

벡터 유사도 연산자 종류

위 쿼리는 pgvector를 사용하는 PostgreSQL에서 벡터 기반 최근접 이웃(NN) 검색을 수행하는 대표적인 방식입니다.

들어가기에 앞서 SMILE 화학식 코드에 대해서 유용한 라이브러리를 알개되었다

RDKit

RDKit이라는 라이브러리로, SMILES ↔ 분자 객체(Mol) 변환이 가능하며, 다양한 분자 지문(fingerprint), 분자 지표(descriptor) 계산을 할 수 있다.

from rdkit import Chem
mol = Chem.MolFromSmiles('CCO')        # SMILES → 분자 객체
smi = Chem.MolToSmiles(mol)            # 분자 객체 → SMILES
fp = Chem.RDKFingerprint(mol)          # 분자 지문 생성

smiles_list = [
    'CCOc1ccc(CC(=O)O)cc1',  # 아세트아닐리드 유사
    'CCN(CC)CCOC(=O)c1ccccc1',  # 베타 차단제 유사
    'C1=CC=C2C(=C1)C=CC=C2',     # 나프탈렌 (비약물)
]

for mol, smi in zip(mols, smiles_list):
    if mol is None:
        continue
    mw    = Descriptors.ExactMolWt(mol)       # 정확한 분자량
    logp  = Crippen.MolLogP(mol)              # clogP
    qed_s = QED.qed(mol)                      # QED score (0~1)
    results.append((smi, mw, logp, qed_s))

위의 코드와 같이 스마일 코드를 입력하면, 분자량과 Fingerprint 정보 등을 알 수 있는 유용한 라이브러리이다.

데이터 분석을 진행하는 과정에서, 내가 진행했던 코드가 사라져 다른 팀원분들의 코드를 참고하였다.

나의 코드는 위의 이미지와 같이 train에 대해서 0.830 정도의 점수가 나왔지만 테스트에서 0.82 정도로 다소 낮은 점수가 나왔다...

데이터 로딩 및 피처 정의

환경은 GPU를 사용하기 위해서 구글 코랩을 사용하였다.

# 1. 데이터 로딩
train = pd.read_csv('/content/drive/MyDrive/train.csv')
test  = pd.read_csv('/content/drive/MyDrive/predict_input.csv')

# 2. 피처 정의
feature_cols = [col for col in train.columns if col.startswith(('ecfp_', 'fcfp_', 'ptfp_'))]
meta_cols    = ['MolWt', 'clogp', 'sa_score', 'qed']

'ecfp_', 'fcfp_', 'ptfp_' 의 Fingerprint 정보를 별도로 분리하였다.

ecfp_cols = [c for c in feature_cols if c.startswith("ecfp_")]
fcfp_cols = [c for c in feature_cols if c.startswith("fcfp_")]
ptfp_cols = [c for c in feature_cols if c.startswith("ptfp_")]

# 3. 학습 데이터 구성
X_train = train[feature_cols + meta_cols].copy()
X_train['ecfp_sum'] = train[ecfp_cols].sum(axis=1)
X_train['fcfp_sum'] = train[fcfp_cols].sum(axis=1)
X_train['ptfp_sum'] = train[ptfp_cols].sum(axis=1)
y_train = train['label']

# 4. 테스트 데이터 구성
X_test = test[feature_cols + meta_cols].copy()
X_test['ecfp_sum'] = test[ecfp_cols].sum(axis=1)
X_test['fcfp_sum'] = test[fcfp_cols].sum(axis=1)
X_test['ptfp_sum'] = test[ptfp_cols].sum(axis=1)

여기서 좋은 아이디어라고 생각했던 코드인데, 앞서 EDA과정을 통해 fingerprint 데이터가 중요 feature인 점을 확인하였지만, column의 수가 너무 많아 이를 적용하면 모델의 성능이 저하될 위험이 있었다.

위의 코드와 같이 같은 fingerptint 컬럼끼리의 정보를 합친 파생변수를 만들고, 이에 대하여 randomforest의 importance를 구해보았더니 파생변수의 중요도가 매우 높게 나옴을 확인할 수 있었다.

# 5. Train/Validation 분할
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train,
    test_size=0.2,
    stratify=y_train,
    random_state=42
)

# 6. SMOTE 오버샘플링
smote = SMOTE(random_state=42)
X_train_over, y_train_over = smote.fit_resample(X_train, y_train)

해당 데이터는 8300개 가량의 sample을 가지고 있었고 이는 데이터를 학습시키는 데에 굉장히 부족했다.

따라서 SMOTE 방법론을 활용해서 불균형 데이터에 대해서 데이터를 증강시키는 데에 활용하여 모델의 성능을 높이는 참신한 아이디어였다.

기본적으로도 라벨 1에 대한 score가 높이 나왔는데, 해당 방법을 통해서 confusion matrix에 대해 균형을 맞출 수 있었다

이에 대하여 다음과 같이 모델을 구축하였고,

해당 코드는 검증용 데이터에서는 0.8218을 테스트 데이터에서는 0.831에 가까운 좋은 성능을 보였다.

해당 미니 프로젝트는 실제로 sk 내에서 진행했던 경진대회? 느낌의 프로젝트이다.

위의 표와 같이 데이터는 총 3078개의 Column으로 이루어져 있었고, 데이터의 총 수는 약 8300개 가량이었다.

데이터의 수가 매우 적으며, 차원의 수가 매우 많은 데이터의 특성을 가짐

아래와 같이 세 개의 표로 정리할 수 있다.

2초 동안 생각함

1. 기초통계분석

결측치

print(train.isnull().sum().sum())

위의 이미지와 같이 결측치는 존재하지 않았다.

데이터 정보(Info & Describe)

처음에는 위에서 나왔던 3가지의 Fingerprint 를 제외하고 float 타입의 4가지 컬럼에 집중해서 EDA를 진행하고자 하였다.

print(train.iloc[:, 3073:].info())

인덱싱 과정을 통해서 MolWt, clogp, sa_score, qed 컬럼이 수치형으로 이루어져 있음을 확인할 수 있었다.

print(train.iloc[:, 3073:].describe())

• 전체 데이터프레임에서 수치형 특성 컬럼들만 선택한 후 요약하였다.
• 해당 자료는 라벨 별로 확인할 수 없기에 라벨 별로 기초통계량을 구하는 방향으로 진행하였다.

라벨을 기준으로 컬럼 별 통계(평균, 표준편차, 최솟값, 최댓값)

이상치 탐지 및 예측 모델링을 위해, label(0: 독성, 1: 비독성) 별로, 주요 수치형 변수(MolWt, clogp, sa_score, qed)의 평균값 분포를 비교하였다.

agg_result = train.iloc[:, 3073:].groupby('label').agg(['mean', 'std', 'min', 'max'])
display(agg_result)

컬럼 별 평균값 시각화

# 평균만 계산
agg_result = train.iloc[:, 3073:].groupby('label').mean().reset_index()

# 시각화할 컬럼 목록 (label 제외)
mean_columns = agg_result.columns.drop('label')

# 시각화
agg_result.plot(x='label', y=mean_columns, kind='bar', figsize=(14, 6))
plt.title('Mean Values of All Numerical Columns by Label')
plt.ylabel('mean')
plt.xlabel('label')
plt.xticks(rotation=0)
plt.legend(title='column', bbox_to_anchor=(1.05, 1), loc='upper left')  # 범례 바깥으로
plt.tight_layout()
plt.show()

MolWt 컬럼의 수치가 커 비교가 쉽지 않았기에, 이를 각 컬럼 별로 다시 시각화하였다.

각 컬럼 별 Label 간 평균 차이

for col in mean_columns:
    plt.figure(figsize=(6, 4))

    # 막대그래프
    sns.barplot(data=agg_result, x='label', y=col, palette=['#1f77b4', '#ff7f0e'])

    # 범례 수동 추가
    blue_patch = mpatches.Patch(color='#1f77b4', label='label 0')
    orange_patch = mpatches.Patch(color='#ff7f0e', label='label 1')
    plt.legend(handles=[blue_patch, orange_patch],
               title='Label',
               loc='center left',
               bbox_to_anchor=(1.0, 0.5))  # 오른쪽 바깥에 위치

    # 그래프 설정
    plt.title(f'{col} mean')
    plt.ylabel(col)
    plt.xlabel('label')
    plt.tight_layout()
    plt.show()

라벨 별로 각 컬럼의 평균값을 비교해 보았을 때, cloup를 제외하고 큰 차이가 없음을 확인할 수 있었다.

# 컬럼 별 평균값을 표로 출력
print("Mean Values Table:")
display(agg_result)

컬럼 별 이상치 탐지

import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches  # 범례용 패치

# Numeric columns only
numeric_cols = train.columns[3073:]

# Boxplot for each column by label
for col in numeric_cols[:-1]:  # 마지막 컬럼 제외
    plt.figure(figsize=(6, 4))

    # Boxplot with custom colors
    sns.boxplot(x='label', y=col, data=train, palette={"0": '#1f77b4', "1": '#ff7f0e'})

    # 범례 수동 추가 (오른쪽 바깥으로)
    blue_patch = mpatches.Patch(color='#1f77b4', label='label 0')
    orange_patch = mpatches.Patch(color='#ff7f0e', label='label 1')
    plt.legend(handles=[blue_patch, orange_patch], title='Label', loc='center left', bbox_to_anchor=(1.02, 0.5))

    # 라벨 및 제목 설정
    plt.title(f'{col} - Boxplot by label')
    plt.xlabel('label')
    plt.ylabel(col)
    plt.tight_layout()
    plt.show()

1. MolWt (분자량)

• 전반적으로 분포 유사
• 비독성 화합물의 분자량이 약간 더 큼
• 매우 큰 분자(outlier)는 양쪽 모두 존재

2. clogp (분배계수)

• 독성 있는 화합물의 clogp가 더 높음
• 일부 label=0은 8~10 이상 outlier 존재
• clogp는 지용성 → 흡수성, 체내 분포에 영향

차후 target과의 상관관계의 분석 필요성

3. sa_score (합성 용이성 점수)

• label=0이 평균적으로 약간 높음
• sa_score는 1에 가까울수록 합성 쉬움, 10에 가까우면 어려움

4. qed

• label=1 (비독성) 쪽의 qed 값이 더 높음
• 약물 유사성이 높을수록 비독성일 가능성↑
• qed는 약물로 적합한 분자 구조 유사도를 나타냄

컬럼 별 이상치 개수

# 수치형 컬럼만 선택 (3074번째 이후)
numeric_df = train.iloc[:, 3073:-1]

# 이상치 개수 저장용 딕셔너리
outlier_counts = {}

# 각 컬럼별 이상치 계산 (IQR 기준)
for col in numeric_df.columns:
    Q1 = numeric_df[col].quantile(0.25)
    Q3 = numeric_df[col].quantile(0.75)
    IQR = Q3 - Q1
    lower = Q1 - 1.5 * IQR
    upper = Q3 + 1.5 * IQR

    outlier_count = ((numeric_df[col] < lower) | (numeric_df[col] > upper)).sum()
    outlier_counts[col] = outlier_count

# 결과를 데이터프레임으로 변환
outlier_df = pd.DataFrame(list(outlier_counts.items()), columns=['column', 'outlier_count'])
outlier_df = outlier_df.sort_values(by='outlier_count', ascending=False).reset_index(drop=True)

# 출력
from IPython.display import display
print("Outlier Count per Column:")
display(outlier_df)

proportion

독성 물질과 비독성 물질의 비율

label toxic 0.544017 non-toxic 0.455983 Name: proportion, dtype: float64

독성 물질(toxic)과 비독성 물질(non-toxic)의 샘플 수가 대체로 균형 있게 분포하고 있다.

2. 분포 시각화

히스토그램, KDE를 통한 분포 시각화.

4개의 column에 대해서 위와 같이 정규분포와 비슷한 형태의 분포가 나왔으며, 라벨별로 차이를 두더라도 큰 차이를 확인하기 힘들었다

3. 상관관계 분석

상관계수

3077개의 칼럼 중 대부분이 MoleCular Fingerprint Data와 관련 된 칼럼이고, 4개만이 다른 정보를 담고 있는 칼럼이라, 상대적으로 중요한 정보를 담고 있는 칼럼이라고 생각하고,

우선 독성(label 칼럼에 0,1로 표기됨)과의 상관관계를 뽑아보았다.

상관관계 히트맵

산점도로 개별 관계 시각화

히트맵에서는 상관계수가 낮아도, 비선형 관계나 분포 차이가 있을 수 있으므로 산점도를 통해 시각적으로 확인

• MolWt(분자량) - qed(약물 유사성)

  분자량이 클수록 약물 유사성(qed)은 낮아지는 경향이 뚜렷하며, 이 영역에 독성 화합물이 더 많이 분포하지만, 독성과 비독성을 명확히 구분짓지는 못함

• clogp(분배계수) - qed(약물 유사성)

  일부 높은 clogp, 낮은 qed 조합에서 독성이 다소 많음, 독성 여부와 뚜렷한 구분은 어려움

• MolWt(분자량) - clogp(분배계수)

  중간 정도의 양의 상관관계가 있으나, 독성/비독성 간 뚜렷한 구분은 없음

• sa_score(합성가능성)

  sa_score는 전반적으로 다른 변수들과 독성 간 구분력이 약하며, 분포 차이가 뚜렷하진 않음

즉, 처음 생각과는 달리 뒤 4개의 column은 라벨을 결정하는 데에 큰 영향을 주지 못했다.

• 원인(도메인 지식 부족)

화학·독성 분야 도메인 지식 없이 “분자량이 크면 독성이 높다” 등 단순 가설에 의존하였고, 분자의 독성 여부는 합성 용이성(sa_score)이나 약물 유사도(qed)만으로 설명하기 어려움이 존재

• 배운 점

도메인 전문가의 인사이트 없이 단순 메타 특성만으로는 복잡한 화학·독성 현상을 포착하기 어려움

모델링 전, 각 피처가 실제로 어떤 메커니즘과 연관되는지 충분히 검토해야 함

구조적 fingerprint 정보가 화학 데이터 분석에서 핵심임을 인지하고, 필요시 물리·화학 특성은 보조 피처로 활용할 것

이러한 부분을 느끼고 나서 FingerPrint에 집중하기 시작하였다

PCA, t-SNE, UMAP

Fingerprint 데이터를 2차원으로 차원 축소

• PCA (Principal Component Analysis):
  • PCA 모델을 생성하고, 스케일링된 Fingerprint 데이터를 2개의 주성분으로 차원 축소 .(fit_transform).
  • 축소된 2차원 데이터를 visualize_embedding 함수를 사용하여 label에 따라 색깔을 구분하여 산점도로 시각화.
  • 첫 번째와 두 번째 주성분이 설명하는 분산 비율을 출력하여 전체 데이터의 구조를 얼마나 잘 보존하고 있는지 확인하였다.
• t-SNE (t-distributed Stochastic Neighbor Embedding):
  • TSNE 모델을 생성하고, 스케일링된 Fingerprint 데이터를 2차원으로 비선형 차원 축소 (fit_transform). perplexity와 n_iter 등의 파라미터가 설정됨.
  • 축소된 2차원 데이터를 visualize_embedding 함수를 사용하여 시각화.
• UMAP (Uniform Manifold Approximation and Projection):
  • umap.UMAP 모델을 생성하고, 스케일링된 Fingerprint 데이터를 2차원으로 비선형 차원 축소. (fit_transform). n_neighbors와 min_dist 등의 파라미터가 설정됨.
  • 축소된 2차원 데이터를 visualize_embedding 함수를 사용하여 시각화.

결론

⇒ 뚜렷한 군집은 보이지 않음

Finger Print 종류별 UMAP 분석 결과

각 Fingerprint Feature에 대한 독성 비율

구조의 존재에 따른 독성 영향 하위 20

구조의 존재에 따른 독성 영향 상위 20

결론

이번 분석에서는 화합물의 독성 여부와 분자 특성 간의 관계를 탐색하였다.

MolWt, clogp, sa_score, qed 네 가지 변수에 대해 KDE plot과 boxplot 등을 통해 분포를 비교하였으나, 독성 여부를 명확히 구분할 수 있는 뚜렷한 경향은 발견되지 않았다.

반면, fingerprint feature를 기준으로 분석한 결과, 특정 구조가 독성 화합물에서 매우 높은 비율로 등장하거나 거의 등장하지 않는 등, 독성과의 강한 상관성을 보이는 feature들이 다수 확인되었다.

결론적으로 수치형 특성보다는 fingerprint 기반 구조 정보가 독성 예측에 훨씬 유의미하므로, 향후 분석과 모델링은 fingerprint 중심으로 진행하는 것이 바람직하다고 판단된다.

목표: 자신의 애플리케이션 프로그램을 Kubernetes 환경에 배포해서 운영 가능하도록 구성

• 경로를 변환

cd shared-dir/collaboration 

• 원격에 있는 파일을 local로 copy

remote-cp -rf ./cloud  /config/workspace

remote-cp -rf ./k8s-rbac  /config/workspace

ls -al

만약 workspace의 user가 root인 경우

sudo chown -R 911:911

sudo chown -R 911:911 ./workspace

해당 코드로 user를 변경

Accounts

쿠버네티스 API server에 접속하는 주체(Subject)를 의미

ServiceAccount

• Pod 또는 외부 서비스가 클러스터 리소스에 접근할 수 있게 해주는 K8s 내장 계정

• 시스템 간 인증을 위한 계정

• K8s 리소스로 Namespace 안에 생성

• Pod 생성 시 default ServiceAccount가 자동 연결

User

• 사람이(Human) 사용하는 계정

• kubectl CLI, k8s Dashboard, 또는 API를 직접 호출해서 사용

• K8s 자체에서는 미지원, 외부 시스템과 연동 필요

  예: OIDC, x509 인증서, SSO, alice@example.com, devops-admin

Group

• 여러 User를 묶는 논리적 단위

• K8s 자체에서는 미지원, 외부 시스템과 연동 필요

Service Account 중심 계정 관리

kubernete 내에서는 다음과 같은 이유로 Service Account 중심으로 사용하며 User 와 User Group은 잘 사용하지 않음

계정은 단순히 사용자를 구분하는 용도

1. Kubernetes가 직접 User/Group을 관리 미지원

   • 외부 인증 연동이 필요하며, 구성과 운영이 복잡

   • 관리 포인트 증가

2. 자동화 환경에서는 사람이 직접 API를 호출하는 경우가 거의 없음

   • 대부분 앱이나 컨트롤러(예: ArgoCD, Tekton, Jenkins 등)가 자동으로 실행

   • 자동화 앱이나 컨트롤러는 Pod로 동작하므로 ServiceAccount가 적합

   • kubectl 등을 활용한 접근 역시 Service Account로 생성해서 실행 가능

3. RBAC이 ServiceAccount에 최적화되어 있음

   • RoleBinding, ClusterRoleBinding 등에서 명확하게 ServiceAccount를 지정

   • Namespace 단위로 권한을 잘게 쪼개어 관리하기 용이

ServiceAccount 는 쿠버네티스 클러스터 내부에서 Pod나 서비스가 API 서버에 인증된 방식으로 접근할 수 있도록 만들어진 계정.

이를 위해 인증 수단으로 JWT(JSON Web Token) 형태의 ServiceAccount 토큰이 사용

k get sa

• default

자기 네임스페이스에 대한 접근 권한을 가질 수 있음

Service Account 기반 API server 통신 방식

• Service Account는 Token 발행을 위해 동일 이름을 자동 생성, 1.24 이후 버전에서는 수동 연결해서 Token 발행

• Pod가 Service Acount 연결 시 아래 디렉토리에 token, ca.crt, namespace 파일 생성

토큰 적용 순서

1. KubeConfig 환경변수 설정

   config에 있는 토큰 값을 가져와서 담음

2. 자기 홈 디렉토리 내 config에 있는 토큰을 가져옴

3. /var/run/…/serviceaccount 경로의 토큰을 가져옴

[실습] mounted service account 확인하기

kubectl get pod -n skala-practice

k exec -it collabo-shared-sts-0 -- /bin/bash

collabo-shared-sts-0 Pod에 접속해서 bash 셸로 들어갈 수 있음.

cd /var/run/secrets/kubernetes.io/serviceaccount

ls

ctrl d로 나갈 수 있음

Role-Base Acess Control (RBAC)

RBAC (Role-baed Access Control)의 목적

Kubernetes는 모든 리소스에 대한 처리는 kube API Server + ETCD Resource 에 대한 접근

모든 Action에 대해서 API Server를 활용해야 하므로, 통신을 위해선 RBAC을 사용해야 함

RBAC (Role-baed Access Control)

역할 기반 접근 제어 (RBAC)는 사용자가 직접 권한을 받는 것이 아니라, 역할(Role)을 통해 접근 권한을 조절하는 방법

ServiceAccount skala-admin-sa가 namespace 리소스를 조회할 권한이 없어서 생긴 문제

• skala-practice 네임스페이스 안의 skala-admin-sa 라는 ServiceAccount가 클러스터 수준(cluster scope)의 namespaces 리소스를 조회할 권한이 없음

Role 정의

api 그룹에 대한 path 내용도 담고 있음

• verbs: 어떤 권한을 줄 지를 표시

⇒ Role은 namespace가 존재함

⇒ ClusterRole은 namespace가 존재하지 X

Role의 Rules

rules 필드 설명 (RBAC 권한 설정)

RBAC의 rules 필드는 Role 또는 ClusterRole 안에서 사용되며, 권한을 정의합니다.

kubectl api-resources 명령어 예시

kubectl api-resources

이 명령어는 Kubernetes 클러스터에서 사용 가능한 모든 API 리소스 목록을 보여줍니다.

k get sa
k get secret

k get secret skala-admin-sa-token -o yaml

skala-admin-sa-token이라는 이름의 시크릿(Secret) 리소스를 YAML 형식으로 출력

k get pod

쿠버네티스(Kubernetes)에서 파드(Pod)의 목록과 상태를 조회하는 명령어

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  labels:
    amdp.io/app: skala25a-stock-api-wamdp
    amdp.io/profile: skala.skala-a
    argocd.argoproj.io/instance: skala25a-stock-api-wamdp.skala-a.skala
    cluster-tier: dev
  name: skala25a-stock-api-wamdp-pod-reader-skala-a
  namespace: skala-practice
rules:
- apiGroups:
  - ""
  resources:
  - pods
  - configmaps
  verbs:
  - get
  - watch
  - list # 목록을 볼 수 있음

k get clusterrole admin -o yaml

쿠버네티스 클러스터 내에 정의된 admin이라는 이름의 ClusterRole의 상세 정보를 YAML 형식으로 출력

k get --raw /metrics

쿠버네티스 API 서버 또는 각 컴포넌트(예: kubelet, kube-scheduler, kube-controller-manager 등)가 노출하는 Prometheus 형식의 시스템 메트릭을 그대로 출력

(RDE) > kcns skala-argocd 
Context "skala-edu-cluster" modified.

쿠버네티스 환경에서 현재 작업 중인 네임스페이스를 skala-argocd로 전환하는 역할

(= kubectl config set-context --current --namespace=skala-argocd)

Namespace

Namespace는 Kubernetes 클러스터 안에서 리소스들을 논리적으로 분리해주는 가상 공간.

특정 리소스 자원을 나눠주는, 리소스를 각각의 분리된 영역으로 나누기 좋은 방법

(명시적 분리)

• 여러 네임스페이스를 사용하면 복잡한 쿠버네티스 시스템을 더 작은 그룹으로 분할

• 멀티 테넌트(Multi-tenant) 환경을 분리하여 리소스를 생산, 개발, QA 환경 등으로 사용

• 리소스 이름은 네임스페이스 내에서만 고유 명칭 사용

• 현재 클러스터의 기본 네임스페이스 확인하기

테넌트 : 클라우드 인프라/서비스 제공 방식에서 소프트웨어 인스턴스(Software Instance)를 공유하는 사용자

Namespace는 Kubernetes 리소스를 논리적으로 나누고 관리하는 컨테이너 역할을 하며, 자원 분리와 보안, 조직화에 매우 유용

kubectlget pod -A. (full argument: --all-namespaces)

전체 네임스페이스를 대상으로 kubectl을 실행하는 방법

Pod

Kubernetes는 Pod 단위로 라이프사이클을 관리하며, 컨테이너는 직접적인 관리를 하지 않는다

• 컨테이너의 공동 배포된 그룹이며 쿠버네티스의 기본 빌딩 블록을 대표

• 쿠버네티스는 컨테이너를 개별적으로 배포하지 않고 컨테이너의 포드를 항상 배포하고 운영

• 일반적으로 포드는 단일 컨테이너만 포함하지만 다수의 컨테이너를 포함 할 수 있음

• 포드는 다수의 노드에 생성되지 않고 단일 노드에서만 실행

• 여러 프로세스를 실행하기 위해서는 컨테이너 당 단일 프로세스가 적합

• 다수의 프로세스를 제어하려면? -> 다수의 컨테이너를 다룰 수 있는 그룹이 필요!

컨테이너는 보통 하나의 Pod 안에서 함께 실행되며, 같은 네트워크(IP), 같은 저장소(Volume)를 공유합니다.

장점

• 포드는 밀접하게 연관된 프로세스를 함께 실행하고 마치 하나의 환경에서 동작하는 것처럼 보임

• 그러나 동일한 환경을 제공하면서 다소 격리된 상태로 유지

동일한 포드의 컨테이너 사이의 부분 격리

포드의 모든 컨테이너는 동일한 네트워크 및 리눅스 네임스페이스에서 실행

같은 호스트 이름 및 네트워크 인터페이스를 공유 (포트 충돌 가능성 있음)

포드의 모든 컨테이너는 동일한 IPC 네임스페이스 아래에서 실행되며 IPC를 통해 통신 가능

POD 네트워크 구조

Plat Inter-Pod 네트워크 구조

• 쿠버네티스 클러스터의 모든 포드는 공유된 단일 플랫, 네트워크 주소 공간에 위치

• 파드 사이에는 NAT 게이트웨이가 존재 하지 않음

  ⇒ 모든 Pod는 고유한 IP를 갖고 있고, 클러스터 내부에서는 NAT 없이 직접 통신이 가능.

• 파드내 컨테이너 간 통신은 local host 기반을 통신하면 모든 자원을 공유

POD 내 컨테이너 구성 방법

컨테이너를 포드 전체에 적절하게 구성하는 방법

• 다수의 포드로 멀티티어 애플리케이션 분할하기

• 각각 스케일링이 가능한 포드로 분할하기

front/back 단을 병렬로 띄우기 위해선 나누어서 구성

: 둘 간의 communication 과정을 보고 결정하지만, 보통 main process는 나누어서 구성

port-forward

컨테이너에서 호스트로 포트 포워딩, 로컬 PC ↔ 클러스터 내부 리소스 간에 직접 연결하는 유용한 디버깅 도구

• 디버깅 혹은 다른 이유로 서비스를 거치지 않고 특정 포드와 통신하고 싶을 때 사용

• kubectlport-forward 명령으로 수행

• 컨테이너 8888 포트를 pod의 8080 포트로 전달

Multi-Pod에 Port-forward 시 개별 IP

kubectl port-forward pod/webserver-pod 8888:8080 –n {namespace}

bg

curl localhost:8888

kubectl port-forward는 로컬 포트를 Kubernetes 리소스의 포트에 연결해서, 클러스터 내부 리소스를 외부에서 직접 접근 가능하게 해주는 도구.

Pod yaml 구조

Pod는 하나의 독자적인 실행 단위이며, kubernetes에서 관리하는 최소 단위

Pod Argument 전달

docker가 가지고 있는 arguments를 전달할 수 있음.

python3 fastserver.py --host 0.0.0.0 --port 8080

Init-Containr

Pod의 실행되기 전 가장 먼저 초기에 실행되어 초기화 및 사전 작업을 수행하는 컨테이너로 Pod 내 포함

• Pod 실행 시 최초 실행되며, Init-container가 정상적으로 종료해야 하지만 다음 절차가 실행

• Init-container가 일정 시간 이상 내에 정상 처리되지 않으면 재시작 정책에 따라 재시도

apiVersion: v1
kind: Pod
metadata:
  name: sk000-init-container-test
  namespace: skala-practice
  annotations:
    prometheus.io/scrape: 'true'
    prometheus.io/port: '8081'
    prometheus.io/path: '/actuator/prometheus'
    update: ${ANNOTATION_UPDATE}
  labels:
    app: sk000-init-container-test
spec:
  initContainers:
  - name: check-active-enabled
    image: busybox
    command:
    - sh
    - -c
    - |
      timeout 300 sh -c "
      while [ ! -f /root/active.enabled ]; do
        echo 'Waiting for active.enabled file...'
        sleep 5
      done
      echo 'File active.enabled found. Initialization complete.'
      "
    volumeMounts:
    - name: root-volume
      mountPath: /root
  containers:
  - name: init-container-test
    image: amdp-registry.skala-ai.com/skala25a/sk000-webserver:2.0.0
    imagePullPolicy: Always
    env:
    - name: LOGGING_LEVEL
      value: DEBUG
    - name: USER_NAME
      value: sk000
  volumes:
  - name: root-volume
    emptyDir: {}

[실습] kubernetes 환경에서 배포를 실행

yaml을 생성한 후 생성된 pod 확인

1. env.properties 파일에 들어가서, USER_NAME=sk021 로 변경

cicd.sh -y

중간에 묻는 질문 없이 자동으로 모든 과정을 진행하는 자동 확인 옵션

k apply –f init-pod.yaml

해당 YAML 파일을 기준으로 Kubernetes 리소스를 생성하거나 업데이트하는 명령어

k get pod –w

 k exec  -it sk021-init-container-test -c check-active-enabled -- /bin/sh

 / # cd /root
 ~ # ls
 ~ # touch active.enabled

해당 pod 내 check-active-enabled 컨테이너에 셸로 접속

~ # touch active.enabled

active.enabled라는 빈 파일을 생성

sk021-init-container-test라는 Pod의 check-active-enabled 컨테이너 안에 접속해서 /root/active.enabled라는 상태 파일을 생성

1. env.properties에서 자기 username으로 고치고

sudo cicd.sh --all # -a or -build -push

sudo cicd.sh --all은 Docker 이미지 빌드부터 푸시, 배포까지의 전체 파이프라인을 자동으로 실행하는 스크립트

Init Container 동작 원리 요약

1. Init Container는 메인 컨테이너보다 먼저 실행.

2. 모든 Init Container가 성공적으로 종료(exit 0) 되어야 메인 컨테이너가 실행되고, Pod 전체가 Running 상태가 됨.

3. 보통 Init Container는 특정 조건이나 파일 존재 등을 검사하고, 조건이 맞아야 끝나도록 설계됨.

init-container의 목적은 어떤 조건이 충족될 때까지 기다리는 것이고, 그 조건이 /root/active.enabled 존재 여부라면 touch로 조건을 만족시킴

initContainers:
- name: check-active-enabled
  image: busybox
  command:
  - sh
  - -c
  - |
    timeout 300 sh -c "
    while [ ! -f /root/active.enabled ]; do
      echo 'Waiting for active.enabled file...'
      sleep 5
    done
    echo 'File active.enabled found. Initialization complete.'
    "

해당 코드는 init-pod.yaml 중 일부로 init-container가 실행되면서 /root/active.enabled 파일이 존재할 때까지 최대 5분(300초) 동안 대기한다는 의미

Sidecar container

일반적으로 Pod는 주 컨테이너 와 지원 컨테이너인 한 개 이상의 side car 컨테이너로 이루어져 있다.

Pod 내 모든 컨테이너가 주 컨테이너로 구성하지 않는 이유

• Pod내 컨테이너는 한 배를 탄 동지 죽어도 같이 죽고 살아도 같이 산다

• Kubernetes의 핵심은 컨테이너의 탄력적 확장성 지원인데, Pod 내 컨테이너는 지원되지 않는다.

일반적으로 공통 기능을 옆에 같이 포함 (side car) 시켜서 컨테이너의 안정성, 네트워크, 로그, 모니터링, 자가 복구를 지원하도록 한다

service mesh istio

service간 트래픽 연결을 그물망처럼 자유롭게 연결

• Pod 내 주 컨테이너로 들어오고 나가는 모든 트래픽을 side car container인 proxy가 모두 통제함으로써 유연하게 트래픽 제어

외/내부의 모든 traffic을 관리할 수 있음 Traffic Flow Control & Traffic Resilient

ReplicaSet

ReplicaSet은 Kubernetes에서 지정한 수의 Pod 복제본을 항상 유지하도록 도와주는 컨트롤러

만약 어떤 Pod가 종료되거나 삭제되면, ReplicaSet이 자동으로 새로운 Pod를 생성해서 지정된 수를 유지

• ReplicaSet을 사용자가 생성하지 않고 Deployment 적용 시 ReplicaSet Controller가 RepllicaSet을 자동 구성

• Deployment는 여러 개의 ReplicasSet을 제공해서 버전 변화에 따라 Rolling Update 및 Rollback 실행

Replicaset을 둬서, Rolling-update 역할(점진적 업데이트)을 할 수 있음

ReplicaSet를 통한 Rolling Update

• pod 이미지 업데이트 시 새로운 ReplicaSet이 만들어지고 Old 와 New Pod가 점진적 업데이트 (Rolling update) 지원

• ReplicaSet의 선언적 정의는 Deployment 내에 포함되어 있음

ReplicaSet를 통한 Rolling Update: 2가지 정책

1. maxSurge: (최대 넘침)

Rolling Update 시 기존 desired replica 개수보다 추가로 생성될 수 있는 Pod = 일시적 넘침

2. maxUnavailable

업데이트 중에 기존 desired replica 개수기준 동작하지 않아도 되는 Pod 수

maxSurge 만큼 넘친 다음에 항상 4개가 유지되도록 해서 멈춘 pod가 없게끔 설정

maxSurge 만큼 넘치지만, 최대 maxUnavailable만큼 비활성화될 수 있음

[실습] Rolling Update & Roll back

1. env.properties 수정

1. 각 명령어를 버전을 바꿔가면서 해보기

cicd.sh -y  

kubectl apply -f deploy.yaml

k describe replicaset sk021-replicaset-test-7bd98549cd

kubectl rollout history deploy sk021-replicaset-test 

kubectl rollout history deploy sk021-replicaset-test --revision=3

(RDE) > kubectl port-forward svc/sk021-replicaset-test 8080:8080

• 롤백

(RDE) > kubectl rollout undo deploy sk021-replicaset-test

• 롤백 확인

(RDE) > kubectl rollout history deploy sk021-replicaset-test --revision=4

undo를 통해서 정상적으로 rollback이 됨을 확인할 수 있음

(⎈|skala-edu-cluster:skala-practice) ~/workspace/cloud/k8s-ddive/04.replicaset
(RDE) > k get pod -l app=sk021-replicaset-test               
NAME                                     READY   STATUS             RESTARTS   AGE
sk021-replicaset-test-68fd9576bf-gjmbr   0/1     ImagePullBackOff   0          14m
sk021-replicaset-test-7bd98549cd-s4wzw   1/1     Running            0          44m

(⎈|skala-edu-cluster:skala-practice) ~/workspace/cloud/k8s-ddive/04.replicaset
(RDE) > k delete pod sk021-replicaset-test-68fd9576bf-gjmbr  
pod "sk021-replicaset-test-68fd9576bf-gjmbr" deleted

(⎈|skala-edu-cluster:skala-practice) ~/workspace/cloud/k8s-ddive/04.replicaset
(RDE) > k get pod -l app=sk021-replicaset-test         
NAME                                     READY   STATUS    RESTARTS   AGE
sk021-replicaset-test-68fd9576bf-z7jjq   1/1     Running   0          15s

Rollback을 했는데, Webserver에 1.0.0 버전이 없어서 오류가 발생 → 해당 pod에는 오류가 생겨 정상적으로 작동하지 않고, 그 전의 pod를 죽이지 않고 그대로 유지 → webserver에 우선적으로 1.0.0을 배포하고 오류가 있는 pod를 지우고 다시 실행해야 롤백한 버전이 정상적으로 웹에 뜸

C:\Users\Administrator\Desktop\cloud_k8s\rde-launcher-1.2.2.add-jmeter\exec\rde-launcher-windows\config\workspace\cloud\container\05.webserver

해당 경로에서

docker login amdp-registry.skala-ai.com/skala25a

아이디와 비밀번호를 입력한 후,

docker build --tag amdp-registry.skala-ai.com/skala25a/sk021-webserver:1.0.0 .

docker push amdp-registry.skala-ai.com/skala25a/sk021-webserver:1.0.0

해당 과정을 통해서 1.0.0 버전을 docker 로 push하여 webserver에 이미지를 올릴 수 있음

k port-forward deploy/sk021-replicaset-test --address 0.0.0.0 8080:8080

Deployment

Deployment는 여러 개의 Replicas를 관리하기 위한 ReplicaSet 상위 리소스

새로운 이미지를 가지는 동일한 Deployment를 배포하는 경우 기존 운영 중인 Replica Set Pod와 신규 버전 Replica Set Pod가 점진적 업데이트되는데, 이를 통합 관리하는 것이 Deployment

label 과 Selector

Label

k8s 리소스에 붙이는 Key-value 쌍의 메타데이터로, 리소스를 그룹화하기 위한 필터링 도구로 활용

⇒ 사용자가 리소스를 분류하거나 특정 그룹으로 묶는 데 사용예를 들어, 특정 애플리케이션, 환경, 또는 릴리즈 버전에 따라 리소스를 구분

붙였다가 땔 수 있음.

Selector

특정 조건에 따라 Label을 가진 리소스를 선택하는 기능

⇒ Service, Deployment, 또는 다른 리소스가 Selector를 통해 특정 Label을 가진 리소스(예: Pod)를 타겟팅하거나 관리