Llama 3.3 70B Instruct

AI 기반 시맨틱 검색 엔진 구축하기: 하이브리드 검색 완전 가이드

## 키워드 검색 vs 시맨틱 검색 | 구분 | 키워드(BM25) | 시맨틱(Vector) | 하이브리드 | |------|-------------|---------------|-----------| | 검색 방식 | 단어 일치 | 의미 유사도 | 둘 다 | | "파이썬 배우기" → "Python 강좌" | ❌ 불일치 | ✅ 유사 | ✅ | | 정확한 키워드 검색 | ✅ 우수 | ❌ 약함 | ✅ | | 오타 처리 | ❌ 약함 | ✅ 강함 | ✅ | | 속도 | 매우 빠름 | 느림 | 중간 | --- ## 아키텍처 ```mermaid flowchart TD Query[사용자 쿼리] --> Parallel{병렬 검색} Parallel --> BM25[BM25 키워드 검색<br/>Elasticsearch] Parallel --> Vec[벡터 시맨틱 검색<br/>pgvector] BM25 --> Merge[결과 병합<br/>RRF 알고리즘] Vec --> Merge Merge --> Rerank[Cohere Rerank<br/>재정렬] Rerank --> Results[최종 검색 결과] ``` --- ## pgvector + BM25 하이브리드 검색 ```python import psycopg2 from openai import OpenAI from rank_bm25 import BM25Okapi import numpy as np client = OpenAI() class HybridSearchEngine: def __init__(self, conn): self.conn = conn self.documents = [] self.bm25 = None def add_documents(self, docs: list[dict]): self.documents = docs # BM25 인덱스 구축 tokenized = [doc["content"].split() for doc in docs] self.bm25 = BM25Okapi(tokenized) # 벡터 임베딩 저장 contents = [doc["content"] for doc in docs] response = client.embeddings.create( input=contents, model="text-embedding-3-small" ) with self.conn.cursor() as cur: for i, (doc, emb_data) in enumerate(zip(docs, response.data)): cur.execute( '''INSERT INTO search_index (id, content, metadata, embedding) VALUES (%s, %s, %s, %s) ON CONFLICT (id) DO UPDATE SET content=EXCLUDED.content, embedding=EXCLUDED.embedding''', (doc["id"], doc["content"], doc.get("metadata", {}), emb_data.embedding) ) self.conn.commit() def search(self, query: str, top_k: int = 10, bm25_weight: float = 0.3) -> list: # 1. BM25 점수 bm25_scores = self.bm25.get_scores(query.split()) bm25_scores = (bm25_scores - bm25_scores.min()) / (bm25_scores.max() - bm25_scores.min() + 1e-8) # 2. 벡터 유사도 query_vec = client.embeddings.create( input=[query], model="text-embedding-3-small" ).data[0].embedding with self.conn.cursor() as cur: cur.execute( '''SELECT id, 1 - (embedding <=> %s::vector) AS score FROM search_index ORDER BY embedding <=> %s::vector LIMIT %s''', (query_vec, query_vec, top_k * 2) ) vec_results = {row[0]: row[1] for row in cur.fetchall()} # 3. 점수 융합 (가중 합산) combined = [] for i, doc in enumerate(self.documents): vec_score = vec_results.get(doc["id"], 0) combined_score = bm25_weight * bm25_scores[i] + (1 - bm25_weight) * vec_score combined.append((doc, combined_score)) combined.sort(key=lambda x: x[1], reverse=True) return combined[:top_k] ``` --- ## RRF (Reciprocal Rank Fusion) 두 결과 목록을 더 공정하게 합치는 알고리즘: ```python def reciprocal_rank_fusion(rankings: list[list], k: int = 60) -> list: ''' rankings: 각 검색 방법의 문서 ID 순위 리스트 k: 완화 상수 (기본값 60) ''' scores = {} for ranking in rankings: for rank, doc_id in enumerate(ranking): scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank + 1) return sorted(scores.items(), key=lambda x: x[1], reverse=True) # 사용 bm25_ranking = ["doc3", "doc1", "doc7", "doc2"] vec_ranking = ["doc1", "doc5", "doc3", "doc8"] fused = reciprocal_rank_fusion([bm25_ranking, vec_ranking]) print(fused[:3]) # [('doc3', 0.0317...), ('doc1', 0.0313...), ...] ``` --- ## Typesense: 빠른 오픈소스 대안 ```python import typesense client = typesense.Client({ "api_key": "your-api-key", "nodes": [{"host": "localhost", "port": "8108", "protocol": "http"}], "connection_timeout_seconds": 2 }) # 스키마 생성 client.collections.create({ "name": "articles", "fields": [ {"name": "id", "type": "string"}, {"name": "title", "type": "string"}, {"name": "content", "type": "string"}, {"name": "embedding", "type": "float[]", "num_dim": 1536} # 벡터 필드 ] }) # 하이브리드 검색 (키워드 + 벡터 동시) results = client.collections["articles"].documents.search({ "q": "파이썬 머신러닝", "query_by": "title,content", "vector_query": f"embedding:([{','.join(map(str, query_embedding))}], k:10)", "hybrid_search_weight": 0.7, # 벡터 검색 가중치 "per_page": 10 }) ``` --- ## Cohere Rerank으로 최종 정렬 ```python import cohere co = cohere.Client("your-api-key") def rerank_results(query: str, documents: list[str], top_n: int = 5) -> list: results = co.rerank( model="rerank-multilingual-v3.0", query=query, documents=documents, top_n=top_n, ) return [(results.results[i].index, results.results[i].relevance_score) for i in range(len(results.results))] # 하이브리드 검색 후 리랭킹 candidates = hybrid_search(query, top_k=20) doc_texts = [c["content"] for c, _ in candidates] reranked = rerank_results(query, doc_texts, top_n=5) final_results = [candidates[idx] for idx, score in reranked] ``` --- ## 검색 품질 평가 ```python # NDCG (Normalized Discounted Cumulative Gain) 계산 def ndcg_at_k(relevance_scores: list, k: int) -> float: dcg = sum(rel / np.log2(i + 2) for i, rel in enumerate(relevance_scores[:k])) ideal = sum(s / np.log2(i + 2) for i, s in enumerate(sorted(relevance_scores, reverse=True)[:k])) return dcg / ideal if ideal > 0 else 0 # A/B 테스트 프레임워크 results_a = keyword_search(query) results_b = hybrid_search(query) ndcg_a = ndcg_at_k([1 if doc in relevant_docs else 0 for doc, _ in results_a], k=5) ndcg_b = ndcg_at_k([1 if doc in relevant_docs else 0 for doc, _ in results_b], k=5) print(f"키워드 검색 NDCG@5: {ndcg_a:.4f}") print(f"하이브리드 검색 NDCG@5: {ndcg_b:.4f}") ``` 실제 서비스에서는 클릭 데이터, 체류 시간, 전환율을 오프라인 지표와 함께 측정하세요.

온프레미스 AI 구축 가이드: GPU 서버부터 프라이빗 LLM까지

## 온프레미스 AI가 필요한 경우 - **데이터 주권**: 금융, 의료, 법무 — 외부 API에 데이터를 보낼 수 없는 경우 - **비용 절감**: 대용량 트래픽에서 API 비용보다 GPU 운영이 저렴 - **레이턴시**: 내부 네트워크로 100ms 이하 응답 - **커스터마이징**: 파인튜닝, 모델 수정, 특수 설정 --- ## GPU 요구사항 ```mermaid flowchart TD Model[모델 크기] --> Calc{VRAM 계산} Calc --> |7B FP16| G1["14GB VRAM<br/>(RTX 3090/4090)"] Calc --> |13B FP16| G2["26GB VRAM<br/>(A100 40GB)"] Calc --> |70B FP16| G3["140GB VRAM<br/>(4x A100 80GB)"] Calc --> |7B Q4| G4["4-5GB VRAM<br/>(RTX 3060 12GB)"] Calc --> |70B Q4| G5["35-40GB VRAM<br/>(2x RTX 4090)"] ``` **실용 공식:** - FP16: 파라미터 수(B) × 2 = 필요 VRAM(GB) - INT8: 파라미터 수(B) × 1 = 필요 VRAM(GB) - Q4 (4-bit): 파라미터 수(B) × 0.5 = 필요 VRAM(GB) **추천 GPU 구성:** | 용도 | GPU | VRAM | 가격대 | |------|-----|------|--------| | 개발/테스트 | RTX 4090 | 24GB | ₩200만 | | 소규모 프로덕션 | A100 40GB | 40GB | ₩1,500만 | | 대규모 프로덕션 | H100 80GB | 80GB | ₩4,000만 | | 멀티GPU | 4x A100 80GB | 320GB | ₩8,000만 | --- ## Ollama: 가장 쉬운 로컬 LLM ```bash # 설치 curl -fsSL https://ollama.ai/install.sh | sh # 모델 다운로드 및 실행 ollama pull llama3.2:3b ollama pull qwen2.5:7b ollama pull mistral:7b # 대화 시작 ollama run llama3.2:3b # REST API 서버 (기본 포트 11434) ollama serve # Python에서 사용 import ollama response = ollama.chat( model='qwen2.5:7b', messages=[{'role': 'user', 'content': '한국어로 인사해줘'}] ) print(response['message']['content']) ``` --- ## vLLM: 프로덕션 LLM 서빙 Ollama보다 3-5배 높은 처리량: ```bash # vLLM 설치 (CUDA 12.1 필요) pip install vllm # OpenAI 호환 API 서버 실행 python -m vllm.entrypoints.openai.api_server \ --model meta-llama/Llama-3.1-8B-Instruct \ --dtype auto \ --api-key your-secret-key \ --port 8000 \ --max-model-len 8192 # GPU 여러 개 사용 (tensor parallelism) python -m vllm.entrypoints.openai.api_server \ --model meta-llama/Llama-3.1-70B-Instruct \ --tensor-parallel-size 4 \ --port 8000 ``` **OpenAI SDK로 연결:** ```python from openai import OpenAI client = OpenAI( base_url="http://localhost:8000/v1", api_key="your-secret-key" ) response = client.chat.completions.create( model="meta-llama/Llama-3.1-8B-Instruct", messages=[ {"role": "system", "content": "한국어로 답변하는 AI 어시스턴트입니다."}, {"role": "user", "content": "RAG 시스템 구축 방법을 알려줘"} ], temperature=0.7, max_tokens=1000, ) print(response.choices[0].message.content) ``` --- ## Docker로 배포 ```yaml # docker-compose.yml version: '3.8' services: vllm: image: vllm/vllm-openai:latest runtime: nvidia environment: - NVIDIA_VISIBLE_DEVICES=all volumes: - ~/.cache/huggingface:/root/.cache/huggingface ports: - "8000:8000" command: > --model Qwen/Qwen2.5-7B-Instruct --dtype auto --api-key secret-key --max-model-len 4096 deploy: resources: reservations: devices: - driver: nvidia count: 1 capabilities: [gpu] ``` ```bash docker compose up -d ``` --- ## 모델 선택 가이드 | 모델 | 크기 | 한국어 | 코딩 | 용도 | |------|------|--------|------|------| | Qwen2.5-7B | 7B | ★★★★☆ | ★★★★☆ | 범용 | | Llama-3.1-8B | 8B | ★★★☆☆ | ★★★★☆ | 영어 중심 | | EXAONE-3.5-7.8B | 7.8B | ★★★★★ | ★★★★☆ | 한국어 특화 | | Mistral-7B | 7B | ★★★☆☆ | ★★★★☆ | 유럽어 | | Gemma-2-9B | 9B | ★★★☆☆ | ★★★★★ | 코드 생성 | | DeepSeek-R1-8B | 8B | ★★★★☆ | ★★★★★ | 추론 | --- ## 비용 비교 (월 100만 토큰 기준) ``` 클라우드 API: - GPT-4o: 입력 $2.50/M + 출력 $10/M = 약 ₩1.8만/100만 토큰 - Claude Sonnet: 입력 $3/M + 출력 $15/M = 약 ₩2.5만/100만 토큰 온프레미스 (RTX 4090, 월 리스 기준): - 서버 월 리스: 약 ₩30만 - 전기 요금 (350W × 720h): 약 ₩3만 - 총 월 고정비: ₩33만 - 100만 토큰/일 = 3,000만 토큰/월에서 손익분기점 ``` 하루 300만 토큰 이상 처리한다면 온프레미스가 경제적입니다. Hugging Face Model Hub에서 모델을 받고 vLLM으로 서빙하는 조합이 현재 가장 실용적인 온프레미스 AI 스택입니다.

Hugging Face 완전 가이드: AI 개발자의 GitHub (2025)

## Hugging Face가 뭐하는 곳인가? Hugging Face는 AI 모델과 데이터셋의 GitHub입니다. 2025년 현재 80만 개 이상의 모델, 15만 개 이상의 데이터셋이 공개되어 있습니다. Meta, Google, Mistral 같은 대기업도 자사 모델을 여기에 올립니다. ```mermaid flowchart LR HF[Hugging Face Hub] --> Models[모델 허브<br/>80만+ 모델] HF --> Datasets[데이터셋<br/>15만+ 데이터셋] HF --> Spaces[Spaces<br/>데모 앱 호스팅] HF --> Inference[Inference API<br/>모델 즉시 사용] Models --> Use1[로컬 실행] Models --> Use2[파인튜닝] Models --> Use3[API 호출] ``` --- ## 핵심 라이브러리 ### transformers: 모델의 모든 것 ```bash pip install transformers torch ``` ```python from transformers import pipeline # 가장 간단한 사용법: pipeline # 한국어 감성 분석 classifier = pipeline( "text-classification", model="snunlp/KR-FinBert-SC", # 한국어 금융 감성 분석 모델 device=0 # GPU 사용 (없으면 -1) ) result = classifier("삼성전자 주가가 급등했다. 긍정적인 실적 발표 덕분이다.") # [{'label': 'positive', 'score': 0.97}] # 이미지 분류 image_classifier = pipeline("image-classification", model="google/vit-base-patch16-224") # 번역 translator = pipeline("translation", model="Helsinki-NLP/opus-mt-ko-en") result = translator("안녕하세요, 저는 AI 개발자입니다.") # [{'translation_text': 'Hello, I am an AI developer.'}] ``` ### 텍스트 생성 ```python from transformers import AutoTokenizer, AutoModelForCausalLM import torch model_name = "Qwen/Qwen2.5-7B-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map="auto" ) # 채팅 형식으로 생성 messages = [ {"role": "system", "content": "당신은 AI 전문가입니다."}, {"role": "user", "content": "RAG와 파인튜닝의 차이를 설명해줘"} ] text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) inputs = tokenizer(text, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.7) response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True) print(response) ``` --- ## datasets: 데이터셋 다루기 ```python from datasets import load_dataset # 공개 데이터셋 로드 dataset = load_dataset("klue", "ynat") # KLUE 한국어 NLU 벤치마크 print(dataset) # DatasetDict({ # train: Dataset({features: ['guid', 'title', 'label', 'url'], num_rows: 45678}) # validation: Dataset({...num_rows: 9107}) # }) # 데이터 확인 print(dataset["train"][0]) # {'guid': 'ynat-v1_train_00000', 'title': '인천공항 ...', 'label': 6} # 필터링 short_texts = dataset["train"].filter(lambda x: len(x["title"]) < 20) # 커스텀 데이터셋 업로드 from datasets import Dataset my_data = {"text": ["문장1", "문장2"], "label": [0, 1]} ds = Dataset.from_dict(my_data) ds.push_to_hub("your-username/my-dataset") ``` --- ## Inference API: 코드 없이 즉시 사용 Hugging Face의 Inference API로 모델을 API처럼 사용합니다: ```python import requests API_URL = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-7B-Instruct" headers = {"Authorization": "Bearer hf_..."} def query(payload): response = requests.post(API_URL, headers=headers, json=payload) return response.json() result = query({ "inputs": "한국의 AI 산업 동향을 요약해줘", "parameters": {"max_new_tokens": 500} }) ``` **Serverless Inference 가격:** - 무료 티어: 월 30,000 토큰 - Pro ($9/월): 월 2억 토큰 - 대부분의 모델 지원 --- ## Spaces: AI 데모 즉시 배포 Spaces는 Gradio나 Streamlit 앱을 무료로 호스팅합니다: ```python # app.py (Gradio) import gradio as gr from transformers import pipeline pipe = pipeline("text-generation", model="gpt2") def generate(prompt): result = pipe(prompt, max_length=100)[0]["generated_text"] return result demo = gr.Interface( fn=generate, inputs=gr.Textbox(label="프롬프트"), outputs=gr.Textbox(label="생성된 텍스트"), title="GPT-2 텍스트 생성기" ) demo.launch() ``` ```yaml # README.md 앞에 추가 (Space 메타데이터) --- title: My AI Demo emoji: 🤖 colorFrom: blue colorTo: green sdk: gradio sdk_version: 4.0.0 app_file: app.py --- ``` `huggingface-cli` 또는 Git으로 push하면 자동 배포됩니다. --- ## 한국어 특화 모델 추천 | 태스크 | 모델 | 특징 | |--------|------|------| | 텍스트 생성 | `Qwen/Qwen2.5-7B-Instruct` | 한국어 가장 강함 | | 임베딩 | `BAAI/bge-m3` | 다국어 SOTA | | 감성 분석 | `snunlp/KR-FinBert-SC` | 금융 특화 | | NLI | `monologg/koelectra-base-v3` | KoELECTRA | | 번역 | `Helsinki-NLP/opus-mt-ko-en` | 경량 번역 | | STT | `openai/whisper-large-v3` | 한국어 최강 | --- ## 모델 허브에서 모델 찾는 법 ```python from huggingface_hub import list_models # 한국어 텍스트 분류 모델 검색 models = list_models( filter="text-classification", language="ko", sort="downloads", direction=-1, limit=10 ) for model in models: print(f"{model.id}: {model.downloads:,} downloads") ``` 또는 [huggingface.co/models](https://huggingface.co/models)에서: - Language: Korean - Task: 원하는 태스크 - Sort by: Downloads (인기순) --- ## 결론Hugging Face는 AI 개발자의 필수 도구입니다: 1. **모델 발견**: 어떤 태스크든 이미 누군가 학습시킨 모델이 있음 2. **빠른 프로토타입**: `pipeline` 5줄로 시작, 필요하면 커스터마이징 3. **한국어 생태계**: KoELECTRA, KoBERT, BGE-M3 등 한국어 특화 모델들 4. **무료 인프라**: Spaces로 무료 GPU 데모, Inference API로 즉시 사용 시작점: `transformers` 설치 후 `pipeline("task", model="...")` 한 줄로 어떤 모델이든 즉시 실행해보세요.