Ver3.0 ๐ Sentence Transformers๋ก ๋ฒกํฐ ์๋ฒ ๋ฉ ์์ฑํ๊ธฐ: ํ ์คํธ๋ฅผ ์ซ์๋ก ๋ฐ๊พธ๋ ๋ง๋ฒ ๊ฐ์ ์ฌํ

๐ Sentence Transformers๋ก ๋ฒกํฐ ์๋ฒ ๋ฉ ์์ฑํ๊ธฐ: ํ ์คํธ๋ฅผ ์ซ์๋ก ๋ฐ๊พธ๋ ๋ง๋ฒ ๊ฐ์ ์ฌํ
์์ฐ์ด๋ฅผ ์ปดํจํฐ๊ฐ ์ดํดํ๋ ๋ฒกํฐ๋ก ๋ณํํ๋ ์ค์ ๊ฐ์ด๋
๐ฏ ๋ฒกํฐ ์๋ฒ ๋ฉ์ด ๋ญ๊ธธ๋ ์ด๋ ๊ฒ ๋๋ฆฌ์ผ?
์ผ, ์น๊ตฌ! ํน์ ์ปดํจํฐํํ
"์ฌ๋ํด"๋ผ๋ ๋ง์ ์ด๋ป๊ฒ ์ดํด์ํฌ ์ ์์๊น ์๊ฐํด๋ณธ ์ ์์ด? ๐ค
์ปดํจํฐ๋ ์ฐ๋ฆฌ์ฒ๋ผ ๊ฐ์ ์ ๋๋ผ์ง ๋ชปํ์์. ๊ทธ๋ฅ 0๊ณผ 1๋ง ์์๋ฃ๋ ๊ธฐ๊ณ๋๊น ๋ง์ด์ผ.
๊ทธ๋ฐ๋ฐ ์ฌ๊ธฐ์ ๋ฒกํฐ ์๋ฒ ๋ฉ(Vector Embedding)์ด๋ผ๋ ๊ฒ ๋ฑ์ฅํด!
์ด๊ฑด ๋ง์น ๋ฒ์ญ๊ธฐ ๊ฐ์ ๊ฑด๋ฐ, ์ฐ๋ฆฌ๊ฐ ์ฐ๋ ๋ง์ ์ปดํจํฐ๊ฐ ์ดํดํ ์ ์๋ ์ซ์ ๋ฐฐ์ด๋ก ๋ฐ๊ฟ์ฃผ๋ ๊ฑฐ์ผ.
"์ฌ๋ํด"๋ฅผ [0.8, 0.9, 0.2, 0.7, ...] ์ด๋ฐ ์์ผ๋ก ๋ณํํ๋ ๊ฑฐ์ง.
๊ทธ๋ฆฌ๊ณ ์ด ์์
์ ์์ฒญ ์ํ๋ ๋๊ตฌ๊ฐ ๋ฐ๋ก Sentence Transformers์ผ! ๐
โข ์ถ์ฒ ์์คํ : ๋น์ทํ ์ํ์ด๋ ์ฝํ ์ธ ์ถ์ฒํ๊ธฐ
โข ์ฑ๋ด ๊ฐ๋ฐ: ์ฌ์ฉ์ ์๋ ํ์ ํ๊ณ ์ ์ ํ ๋ต๋ณ ์์ฑํ๊ธฐ
โข ๋ฌธ์ ๋ถ๋ฅ: ๋ด์ค ๊ธฐ์ฌ๋ฅผ ์๋์ผ๋ก ์นดํ ๊ณ ๋ฆฌ๋ณ๋ก ๋ถ๋ฅํ๊ธฐ
โข ๊ฐ์ฑ ๋ถ์: ๋ฆฌ๋ทฐ๊ฐ ๊ธ์ ์ ์ธ์ง ๋ถ์ ์ ์ธ์ง ํ๋จํ๊ธฐ
์์ฆ AI ์๋์ ์ด๋ฐ ๊ธฐ์ ์์ด๋ ์ ๋๋ก ๋ ์๋น์ค๋ฅผ ๋ง๋ค๊ธฐ ์ด๋ ค์.
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ฌ์ฉ์๊ฐ ์ํ๋ ์ฌ๋ฅ์ ์ ํํ๊ฒ ๋งค์นญํ๋ ค๋ฉด ์ด๋ฐ ๊ธฐ์ ์ด ํ์์ ์ด๊ฑฐ๋ ! ๐ฏ
๐ง Sentence Transformers๊ฐ ๋ญ์ง ์ ๋๋ก ์์๋ณด์
Sentence Transformers๋ 2019๋
์ ๋์จ Python ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ๋ฐ,
๋ฌธ์ฅ์ด๋ ๋จ๋ฝ์ ์๋ฏธ๋ฅผ ๋ด์ ๋ฒกํฐ๋ก ๋ณํํด์ฃผ๋ ๋๊ตฌ์ผ.
๊ธฐ์กด์ BERT ๊ฐ์ ๋ชจ๋ธ๋ค์ ๋ฌธ์ฅ ๊ฐ ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ๋ ค๋ฉด ๋ชจ๋ ์กฐํฉ์ ์ผ์ผ์ด ๋น๊ตํด์ผ ํ์ด.
์๋ฅผ ๋ค์ด 10,000๊ฐ ๋ฌธ์ฅ์ ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ๋ ค๋ฉด ์ฝ 5์ฒ๋ง ๋ฒ์ ๋น๊ต๊ฐ ํ์ํ์ง! ๐ฑ
ํ์ง๋ง Sentence Transformers๋ ๊ฐ ๋ฌธ์ฅ์ ๋จผ์ ๋ฒกํฐ๋ก ๋ณํํ ๋ค์,
์ฝ์ฌ์ธ ์ ์ฌ๋ ๊ฐ์ ๊ฐ๋จํ ๊ณ์ฐ์ผ๋ก ๋น๊ตํ ์ ์์ด์ ์๋๊ฐ ์์ฒญ ๋นจ๋ผ!
| ๋ฐฉ๋ฒ | 10,000๊ฐ ๋ฌธ์ฅ ๋น๊ต ์๊ฐ | ํ์ฅ์ฑ |
|---|---|---|
| BERT Cross-Encoder | ์ฝ 65์๊ฐ | โ ๋ฎ์ |
| Sentence Transformers | ์ฝ 5์ด | โ ๋์ |
์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํต์ฌ์ Siamese Network ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฑฐ์ผ.
์๋ฅ์ด ๋คํธ์ํฌ๋ผ๋ ๋ป์ธ๋ฐ, ๊ฐ์ ๊ฐ์ค์น๋ฅผ ๊ณต์ ํ๋ ๋ ๊ฐ์ ์ ๊ฒฝ๋ง์ด ๋ฌธ์ฅ์ ์ฒ๋ฆฌํด์
์๋ฏธ์ ์ผ๋ก ๋น์ทํ ๋ฌธ์ฅ๋ค์ ๋ฒกํฐ ๊ณต๊ฐ์์ ๊ฐ๊น์ด ์์นํ๋๋ก ํ์ต๋ผ! ๐ฏ
๐ ๏ธ ์ค์น๋ถํฐ ์์ํด๋ณด์! ํ๊ฒฝ ์ธํ ํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํด๋ณผ๊น? ๋จผ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํด์ผ ํด.
Python 3.6 ์ด์ ๋ฒ์ ์ด ํ์ํ๊ณ , ๊ฐ๋ฅํ๋ฉด ๊ฐ์ํ๊ฒฝ์ ๋ง๋ค์ด์ ์์
ํ๋ ๊ฑธ ์ถ์ฒํด! ๐
๋ค๋ฅธ ํ๋ก์ ํธ์ ์ถฉ๋์ด ์๊ณ ๊ด๋ฆฌ๊ฐ ํธํด์ ธ!
# ๊ฐ์ํ๊ฒฝ ์์ฑ
python -m venv sentence_env
# ๊ฐ์ํ๊ฒฝ ํ์ฑํ (Windows)
sentence_env\Scripts\activate
# ๊ฐ์ํ๊ฒฝ ํ์ฑํ (Mac/Linux)
source sentence_env/bin/activate
์ด์ Sentence Transformers๋ฅผ ์ค์นํด๋ณด์! ๐
# ๊ธฐ๋ณธ ์ค์น
pip install sentence-transformers
# ๋๋ ์ต์ ๋ฒ์ ์ผ๋ก ์ค์น
pip install -U sentence-transformers
# ์ถ๊ฐ๋ก ์ ์ฉํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค
pip install numpy pandas scikit-learn
์ธํฐ๋ท ์ฐ๊ฒฐ์ด ํ์ํ๊ณ , ๋ชจ๋ธ ํฌ๊ธฐ์ ๋ฐ๋ผ ์๋ฐฑ MB์์ ์ GB๊น์ง ๋ค์ด๋ก๋๋ ์ ์์ด!
์๊ฐ์ด ์ข ๊ฑธ๋ฆด ์ ์์ผ๋ ์ปคํผ ํ ์ ํ๋ฉด์ ๊ธฐ๋ค๋ ค~ โ
์ค์น๊ฐ ์๋ฃ๋๋ฉด ์ ๋๋ก ์ค์น๋๋์ง ํ์ธํด๋ณด์!
import sentence_transformers
print(sentence_transformers.__version__)
# ๊ฐ๋จํ ํ
์คํธ
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
print("๋ชจ๋ธ ๋ก๋ ์ฑ๊ณต! ๐")
์๋ฌ ์์ด ๋ฒ์ ์ด ์ถ๋ ฅ๋๊ณ ๋ชจ๋ธ์ด ๋ก๋๋๋ฉด ์ฑ๊ณต์ด์ผ! ๐
๐จ ์ฒซ ๋ฒ์งธ ์๋ฒ ๋ฉ ์์ฑํ๊ธฐ: Hello World!
์, ์ด์ ์ง์ง ์ฌ๋ฏธ์๋ ๋ถ๋ถ์ด์ผ! ์ฒซ ๋ฒ์งธ ๋ฒกํฐ ์๋ฒ ๋ฉ์ ๋ง๋ค์ด๋ณด์! ๐
์ฝ๋๋ ์๊ฐ๋ณด๋ค ์์ฒญ ๊ฐ๋จํด. ๋๋ ์ค๋น ๋์ด?
from sentence_transformers import SentenceTransformer
# ๋ชจ๋ธ ๋ก๋
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋ฌธ์ฅ ์ค๋น
sentences = [
"๋๋ ํ์ด์ฌ ํ๋ก๊ทธ๋๋ฐ์ ์ข์ํด",
"Python programming is my favorite",
"์ค๋ ๋ ์จ๊ฐ ์ ๋ง ์ข๋ค์"
]
# ์๋ฒ ๋ฉ ์์ฑ (์ด๊ฒ ์ ๋ถ์ผ!)
embeddings = model.encode(sentences)
# ๊ฒฐ๊ณผ ํ์ธ
print(f"์๋ฒ ๋ฉ shape: {embeddings.shape}")
print(f"์ฒซ ๋ฒ์งธ ๋ฌธ์ฅ์ ๋ฒกํฐ (์ผ๋ถ): {embeddings[0][:5]}")
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ์ด๋ฐ ์์ผ๋ก ๋์ฌ ๊ฑฐ์ผ:
์๋ฒ ๋ฉ shape: (3, 384)
์ฒซ ๋ฒ์งธ ๋ฌธ์ฅ์ ๋ฒกํฐ (์ผ๋ถ): [ 0.0234 -0.1234 0.5678 -0.2345 0.8901]
์ฌ๊ธฐ์ (3, 384)๋ 3๊ฐ์ ๋ฌธ์ฅ์ด ๊ฐ๊ฐ 384์ฐจ์์ ๋ฒกํฐ๋ก ๋ณํ๋๋ค๋ ๋ป์ด์ผ!
384๊ฐ์ ์ซ์๋ก ๋ฌธ์ฅ์ ์๋ฏธ๋ฅผ ํํํ๋ ๊ฑฐ์ง. ์ ๊ธฐํ์ง? ๐ฎ
์ด ๋ฒกํฐ๋ค์ ๋จ์ํ ์ซ์ ๋ฐฐ์ด์ด ์๋๋ผ ์๋ฏธ๋ฅผ ๋ด๊ณ ์์ด.
๋น์ทํ ์๋ฏธ์ ๋ฌธ์ฅ๋ค์ ๋ฒกํฐ ๊ณต๊ฐ์์ ๊ฐ๊น์ด ์์นํ๊ฒ ๋ผ!
โข ํฌ๊ธฐ: ์ฝ 80MB
โข ์๋: ๋งค์ฐ ๋น ๋ฆ
โข ์ฑ๋ฅ: ๋๋ถ๋ถ์ ์์ ์ ์ถฉ๋ถ
โข ์ถ์ฒ ์ฉ๋: ํ๋กํ ํ์ , ์ค์๊ฐ ์๋น์ค
๋ ๋์ ์ฑ๋ฅ์ด ํ์ํ๋ฉด all-mpnet-base-v2๋ฅผ ์ฌ์ฉํด๋ด!
โข ํฌ๊ธฐ: ์ฝ 420MB
โข ์๋: ์ค๊ฐ
โข ์ฑ๋ฅ: ๋ ์ ํํจ
โข ์ถ์ฒ ์ฉ๋: ๋์ ์ ํ๋๊ฐ ํ์ํ ํ๋ก์ ํธ
๐ ์ ์ฌ๋ ๊ณ์ฐํ๊ธฐ: ๋ฌธ์ฅ๋ค์ด ์ผ๋ง๋ ๋น์ทํ ๊น?
์๋ฒ ๋ฉ์ ๋ง๋ค์์ผ๋ฉด ์ด์ ๋ฌธ์ฅ๋ค์ด ์ผ๋ง๋ ๋น์ทํ์ง ๊ณ์ฐํด๋ณผ ์ฐจ๋ก์ผ!
์ด๊ฒ ๋ฐ๋ก ์๋ฒ ๋ฉ์ ์ง์ง ํ์๋ฅผ ๋๋ ์ ์๋ ์๊ฐ์ด์ง. ๐ฅ
from sentence_transformers import SentenceTransformer, util
import torch
# ๋ชจ๋ธ ๋ก๋
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋น๊ตํ ๋ฌธ์ฅ๋ค
sentences = [
"๊ณ ์์ด๊ฐ ์ํ์์ ์๊ณ ์์ด",
"์ํ ์์์ ๊ณ ์์ด๊ฐ ์ ์ ์๋ค",
"๊ฐ์์ง๊ฐ ๊ณต์์์ ๋ฐ์ด๋๊ณ ์์ด",
"์ค๋ ์ ๋
๋ฉ๋ด๋ ๋ญ๊ฐ ์ข์๊น?"
]
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(sentences, convert_to_tensor=True)
# ์ฝ์ฌ์ธ ์ ์ฌ๋ ๊ณ์ฐ
cosine_scores = util.cos_sim(embeddings, embeddings)
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
print("๋ฌธ์ฅ ๊ฐ ์ ์ฌ๋ ๋งคํธ๋ฆญ์ค:")
print(cosine_scores)
# ํน์ ๋ฌธ์ฅ ์์ ์ ์ฌ๋ ํ์ธ
print(f"\n๋ฌธ์ฅ 0๊ณผ 1์ ์ ์ฌ๋: {cosine_scores[0][1]:.4f}")
print(f"๋ฌธ์ฅ 0๊ณผ 2์ ์ ์ฌ๋: {cosine_scores[0][2]:.4f}")
print(f"๋ฌธ์ฅ 0๊ณผ 3์ ์ ์ฌ๋: {cosine_scores[0][3]:.4f}")
๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด ์ด๋ ๊ฒ ๋์ฌ ๊ฑฐ์ผ:
โข ๋ฌธ์ฅ 0๊ณผ 2์ ์ ์ฌ๋: 0.4523 โ ๋ ๋ค ๋๋ฌผ ๊ด๋ จ์ด๋ผ ์ฝ๊ฐ ๋น์ท
โข ๋ฌธ์ฅ 0๊ณผ 3์ ์ ์ฌ๋: 0.1234 โ ์์ ํ ๋ค๋ฅธ ์ฃผ์
์ ์ฌ๋๋ -1์์ 1 ์ฌ์ด์ ๊ฐ์ด๊ณ , 1์ ๊ฐ๊น์ธ์๋ก ๋น์ทํ ์๋ฏธ์ผ!
๋ณดํต 0.7 ์ด์์ด๋ฉด ๋งค์ฐ ์ ์ฌํ๋ค๊ณ ๋ณผ ์ ์์ด.
์ด์ ์ข ๋ ์ค์ฉ์ ์ธ ์์ ๋ฅผ ๋ง๋ค์ด๋ณผ๊น? ์ง๋ฌธ-๋ต๋ณ ๋งค์นญ ์์คํ ์ ๋ง๋ค์ด๋ณด์! ๐ฏ
from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer('all-MiniLM-L6-v2')
# FAQ ๋ฐ์ดํฐ๋ฒ ์ด์ค
faq_questions = [
"๋ฐฐ์ก์ ์ผ๋ง๋ ๊ฑธ๋ฆฌ๋์?",
"ํ๋ถ ์ ์ฑ
์ด ์ด๋ป๊ฒ ๋๋์?",
"ํ์๊ฐ์
์ ์ด๋ป๊ฒ ํ๋์?",
"๋น๋ฐ๋ฒํธ๋ฅผ ์์ด๋ฒ๋ ธ์ด์",
"์ํ ๊ตํ์ ๊ฐ๋ฅํ๊ฐ์?"
]
faq_answers = [
"์ผ๋ฐ์ ์ผ๋ก 2-3์ผ ์ ๋ ์์๋ฉ๋๋ค.",
"๊ตฌ๋งค ํ 7์ผ ์ด๋ด ํ๋ถ ๊ฐ๋ฅํฉ๋๋ค.",
"ํํ์ด์ง ์๋จ์ ํ์๊ฐ์
๋ฒํผ์ ํด๋ฆญํ์ธ์.",
"๋ก๊ทธ์ธ ํ์ด์ง์์ ๋น๋ฐ๋ฒํธ ์ฐพ๊ธฐ๋ฅผ ์ด์ฉํ์ธ์.",
"๊ตฌ๋งค ํ 14์ผ ์ด๋ด ๊ตํ ๊ฐ๋ฅํฉ๋๋ค."
]
# FAQ ์๋ฒ ๋ฉ ์์ฑ (ํ ๋ฒ๋ง ํ๋ฉด ๋ผ!)
faq_embeddings = model.encode(faq_questions, convert_to_tensor=True)
# ์ฌ์ฉ์ ์ง๋ฌธ
user_query = "๋ฌผ๊ฑด์ด ์ธ์ ๋์ฐฉํ๋์?"
# ์ฌ์ฉ์ ์ง๋ฌธ ์๋ฒ ๋ฉ
query_embedding = model.encode(user_query, convert_to_tensor=True)
# ์ ์ฌ๋ ๊ณ์ฐ
similarities = util.cos_sim(query_embedding, faq_embeddings)[0]
# ๊ฐ์ฅ ์ ์ฌํ ์ง๋ฌธ ์ฐพ๊ธฐ
best_match_idx = similarities.argmax()
best_score = similarities[best_match_idx]
print(f"์ฌ์ฉ์ ์ง๋ฌธ: {user_query}")
print(f"๋งค์นญ๋ FAQ: {faq_questions[best_match_idx]}")
print(f"์ ์ฌ๋ ์ ์: {best_score:.4f}")
print(f"๋ต๋ณ: {faq_answers[best_match_idx]}")
์ด ์ฝ๋๋ ์ฌ์ฉ์๊ฐ "๋ฌผ๊ฑด์ด ์ธ์ ๋์ฐฉํ๋์?"๋ผ๊ณ ๋ฌผ์ด๋ณด๋ฉด
์๋์ผ๋ก "๋ฐฐ์ก์ ์ผ๋ง๋ ๊ฑธ๋ฆฌ๋์?"์ ๋งค์นญ์์ผ์ ์ ์ ํ ๋ต๋ณ์ ์ฐพ์์ค! ๐ค
์ค์ ๋ก ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ฌ์ฉ์ ๋ฌธ์๋ฅผ ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐ ์ด๋ฐ ๊ธฐ์ ์ ํ์ฉํ ์ ์์ด!
๐ ๋ค๊ตญ์ด ์ง์: ํ๊ตญ์ด๋ ๋ฌธ์ ์์ด!
์ฌ๊ธฐ์ ์ค์ํ ํฌ์ธํธ! Sentence Transformers๋ ๋ค๊ตญ์ด๋ฅผ ์ง์ํ๋ ๋ชจ๋ธ๋ค๋ ์์ด! ๐
ํ๊ตญ์ด ๋ฌธ์ฅ๋ ์๋ฒฝํ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค๋ ๊ฑฐ์ง.
from sentence_transformers import SentenceTransformer
# ๋ค๊ตญ์ด ๋ชจ๋ธ ๋ก๋
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
# ์ฌ๋ฌ ์ธ์ด์ ๋ฌธ์ฅ๋ค
sentences = [
"์๋
ํ์ธ์, ๋ฐ๊ฐ์ต๋๋ค",
"Hello, nice to meet you",
"ใใใซใกใฏใใฏใใใพใใฆ",
"Hola, mucho gusto",
"Bonjour, enchantรฉ"
]
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(sentences)
# ์ ์ฌ๋ ๊ณ์ฐ
from sentence_transformers import util
similarities = util.cos_sim(embeddings, embeddings)
print("๋ค๊ตญ์ด ๋ฌธ์ฅ ๊ฐ ์ ์ฌ๋:")
for i in range(len(sentences)):
for j in range(i+1, len(sentences)):
print(f"{sentences[i][:20]}... โ {sentences[j][:20]}...")
print(f"์ ์ฌ๋: {similarities[i][j]:.4f}\n")
๋๋๊ฒ๋ ์๋ก ๋ค๋ฅธ ์ธ์ด๋ก ๋ ๊ฐ์ ์๋ฏธ์ ๋ฌธ์ฅ๋ค์ด ๋์ ์ ์ฌ๋๋ฅผ ๋ณด์ฌ์ค!
์ด๊ฑด ๋ชจ๋ธ์ด ์ธ์ด๋ฅผ ๋์ด์ ์๋ฏธ๋ฅผ ์ดํดํ๋ค๋ ์ฆ๊ฑฐ์ผ. ๐ฏ
| ๋ชจ๋ธ๋ช | ์ง์ ์ธ์ด | ํน์ง |
|---|---|---|
| paraphrase-multilingual-MiniLM-L12-v2 | 50๊ฐ ์ด์ | ๋น ๋ฅด๊ณ ๊ฐ๋ฒผ์ |
| paraphrase-multilingual-mpnet-base-v2 | 50๊ฐ ์ด์ | ๋์ ์ฑ๋ฅ |
| distiluse-base-multilingual-cased-v2 | 15๊ฐ ์ฃผ์ ์ธ์ด | ๊ท ํ์กํ ์ฑ๋ฅ |
ํ๊ตญ์ด ์ฒ๋ฆฌ๊ฐ ์ค์ํ ํ๋ก์ ํธ๋ผ๋ฉด paraphrase-multilingual-mpnet-base-v2๋ฅผ ์ถ์ฒํด!
์กฐ๊ธ ๋ฌด๊ฒ์ง๋ง ํ๊ตญ์ด ์ฑ๋ฅ์ด ์ ๋ง ์ข๊ฑฐ๋ . ๐
โก ์ฑ๋ฅ ์ต์ ํ: ๋ ๋น ๋ฅด๊ฒ, ๋ ํจ์จ์ ์ผ๋ก!
์ค์ ์๋น์ค์ ์ ์ฉํ๋ ค๋ฉด ์ฑ๋ฅ ์ต์ ํ๊ฐ ํ์์ผ!
์์ฒ, ์๋ง ๊ฐ์ ๋ฌธ์ฅ์ ์ฒ๋ฆฌํด์ผ ํ ๋ ์ด๋ป๊ฒ ํด์ผ ํ ๊น? ๐
1๏ธโฃ ๋ฐฐ์น ์ฒ๋ฆฌ ํ์ฉํ๊ธฐ
๋ฌธ์ฅ์ ํ๋์ฉ ์ฒ๋ฆฌํ๋ ๊ฒ๋ณด๋ค ์ฌ๋ฌ ๊ฐ๋ฅผ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ ๊ฒ ํจ์ฌ ๋นจ๋ผ!
import time
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
# ํ
์คํธ์ฉ ๋ฌธ์ฅ 1000๊ฐ ์์ฑ
sentences = [f"์ด๊ฒ์ ํ
์คํธ ๋ฌธ์ฅ ๋ฒํธ {i}์
๋๋ค" for i in range(1000)]
# ๋ฐฉ๋ฒ 1: ํ๋์ฉ ์ฒ๋ฆฌ (๋๋ฆผ)
start = time.time()
embeddings_slow = []
for sentence in sentences:
emb = model.encode(sentence)
embeddings_slow.append(emb)
time_slow = time.time() - start
# ๋ฐฉ๋ฒ 2: ๋ฐฐ์น ์ฒ๋ฆฌ (๋น ๋ฆ)
start = time.time()
embeddings_fast = model.encode(sentences, batch_size=32)
time_fast = time.time() - start
print(f"ํ๋์ฉ ์ฒ๋ฆฌ: {time_slow:.2f}์ด")
print(f"๋ฐฐ์น ์ฒ๋ฆฌ: {time_fast:.2f}์ด")
print(f"์๋ ํฅ์: {time_slow/time_fast:.1f}๋ฐฐ ๋นจ๋ผ์ง! ๐")
โข CPU ์ฌ์ฉ ์: 8~32
โข ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ๋ฉด ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ์ค์ฌ๋ด!
โข ๋๋ฌด ํฌ๋ฉด ์คํ๋ ค ๋๋ ค์ง ์ ์์ด
2๏ธโฃ GPU ํ์ฉํ๊ธฐ
GPU๊ฐ ์๋ค๋ฉด ๋ฐ๋์ ํ์ฉํด์ผ ํด! ์๋๊ฐ 10๋ฐฐ ์ด์ ๋นจ๋ผ์ง ์ ์๊ฑฐ๋ . ๐ช
import torch
from sentence_transformers import SentenceTransformer
# GPU ์ฌ์ฉ ๊ฐ๋ฅ ์ฌ๋ถ ํ์ธ
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"์ฌ์ฉ ์ค์ธ ๋๋ฐ์ด์ค: {device}")
# ๋ชจ๋ธ์ GPU๋ก ๋ก๋
model = SentenceTransformer('all-MiniLM-L6-v2', device=device)
# ์๋ฒ ๋ฉ ์์ฑ (์๋์ผ๋ก GPU ์ฌ์ฉ)
sentences = ["๋ฌธ์ฅ 1", "๋ฌธ์ฅ 2", "๋ฌธ์ฅ 3"]
embeddings = model.encode(sentences, convert_to_tensor=True)
print(f"์๋ฒ ๋ฉ์ด GPU์ ์๋์? {embeddings.is_cuda}")
3๏ธโฃ ์๋ฒ ๋ฉ ์บ์ฑํ๊ธฐ
๊ฐ์ ๋ฌธ์ฅ์ ์ฌ๋ฌ ๋ฒ ์ฒ๋ฆฌํ ํ์ ์์ด! ํ ๋ฒ ๊ณ์ฐํ ์๋ฒ ๋ฉ์ ์ ์ฅํด๋๊ณ ์ฌ์ฌ์ฉํ์. ๐พ
import pickle
import numpy as np
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋ฌธ์ฅ๊ณผ ์๋ฒ ๋ฉ์ ๋์
๋๋ฆฌ๋ก ์ ์ฅ
embedding_cache = {}
def get_embedding(sentence):
"""์บ์๋ฅผ ํ์ฉํ ์๋ฒ ๋ฉ ์์ฑ"""
if sentence not in embedding_cache:
embedding_cache[sentence] = model.encode(sentence)
return embedding_cache[sentence]
# ์ฌ์ฉ ์์
sentences = ["์๋
ํ์ธ์", "๋ฐ๊ฐ์ต๋๋ค", "์๋
ํ์ธ์"] # "์๋
ํ์ธ์"๊ฐ ์ค๋ณต
for sent in sentences:
emb = get_embedding(sent)
print(f"'{sent}' ์ฒ๋ฆฌ ์๋ฃ")
# ์บ์ ์ ์ฅ
with open('embedding_cache.pkl', 'wb') as f:
pickle.dump(embedding_cache, f)
# ๋์ค์ ์บ์ ๋ถ๋ฌ์ค๊ธฐ
with open('embedding_cache.pkl', 'rb') as f:
loaded_cache = pickle.load(f)
โข 384์ฐจ์ ์๋ฒ ๋ฉ 1๊ฐ โ 1.5KB
โข 100๋ง ๊ฐ ์๋ฒ ๋ฉ โ 1.5GB
LRU(Least Recently Used) ์บ์๋ฅผ ์ฌ์ฉํ๊ฑฐ๋,
๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ ๊ณ ๋ คํด๋ด!
4๏ธโฃ ๋ชจ๋ธ ์์ํ(Quantization)
๋ชจ๋ธ ํฌ๊ธฐ๋ฅผ ์ค์ด๊ณ ์๋๋ฅผ ๋์ด๋ ๊ณ ๊ธ ๊ธฐ๋ฒ์ด์ผ! ๐ฏ
from sentence_transformers import SentenceTransformer
import torch
# ์ผ๋ฐ ๋ชจ๋ธ ๋ก๋
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋์ ์์ํ ์ ์ฉ
model = torch.quantization.quantize_dynamic(
model,
{torch.nn.Linear},
dtype=torch.qint8
)
# ์์ํ๋ ๋ชจ๋ธ๋ก ์๋ฒ ๋ฉ ์์ฑ
sentences = ["ํ
์คํธ ๋ฌธ์ฅ์
๋๋ค"]
embeddings = model.encode(sentences)
print("์์ํ ์๋ฃ! ๋ชจ๋ธ์ด ๋ ๊ฐ๋ฒผ์์ก์ด์ ๐")
์์ํ๋ฅผ ํ๋ฉด ๋ชจ๋ธ ํฌ๊ธฐ๊ฐ ์ฝ 4๋ฐฐ ์ค์ด๋ค๊ณ , CPU์์ ์ถ๋ก ์๋๊ฐ 2-3๋ฐฐ ๋นจ๋ผ์ ธ!
์ ํ๋๋ ์ฝ๊ฐ ๋จ์ด์ง ์ ์์ง๋ง ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ฌด์ํ ์ ์๋ ์์ค์ด์ผ. ๐
๐ฏ ์ค์ ํ๋ก์ ํธ: ์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์ ์์ง ๋ง๋ค๊ธฐ
์ด์ ๋ฐฐ์ด ๊ฑธ ์ข
ํฉํด์ ์ค์ ๋ก ๋์ํ๋ ๊ฒ์ ์์ง์ ๋ง๋ค์ด๋ณด์!
ํค์๋ ๋งค์นญ์ด ์๋๋ผ ์๋ฏธ๋ฅผ ์ดํดํ๋ ๊ฒ์์ด์ผ. ๐
from sentence_transformers import SentenceTransformer, util
import numpy as np
class SemanticSearchEngine:
def __init__(self, model_name='all-MiniLM-L6-v2'):
"""์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์ ์์ง ์ด๊ธฐํ"""
self.model = SentenceTransformer(model_name)
self.documents = []
self.embeddings = None
def add_documents(self, documents):
"""๋ฌธ์ ์ถ๊ฐ ๋ฐ ์๋ฒ ๋ฉ ์์ฑ"""
self.documents.extend(documents)
print(f"๐ {len(documents)}๊ฐ ๋ฌธ์ ์ถ๊ฐ ์ค...")
# ์๋ก์ด ๋ฌธ์๋ค์ ์๋ฒ ๋ฉ ์์ฑ
new_embeddings = self.model.encode(
documents,
convert_to_tensor=True,
show_progress_bar=True
)
# ๊ธฐ์กด ์๋ฒ ๋ฉ๊ณผ ํฉ์น๊ธฐ
if self.embeddings is None:
self.embeddings = new_embeddings
else:
self.embeddings = torch.cat([self.embeddings, new_embeddings])
print(f"โ
์ด {len(self.documents)}๊ฐ ๋ฌธ์ ์ธ๋ฑ์ฑ ์๋ฃ!")
def search(self, query, top_k=5):
"""์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์ ์ํ"""
if not self.documents:
return []
# ์ฟผ๋ฆฌ ์๋ฒ ๋ฉ ์์ฑ
query_embedding = self.model.encode(query, convert_to_tensor=True)
# ์ฝ์ฌ์ธ ์ ์ฌ๋ ๊ณ์ฐ
cos_scores = util.cos_sim(query_embedding, self.embeddings)[0]
# ์์ k๊ฐ ๊ฒฐ๊ณผ ์ถ์ถ
top_results = torch.topk(cos_scores, k=min(top_k, len(self.documents)))
results = []
for score, idx in zip(top_results[0], top_results[1]):
results.append({
'document': self.documents[idx],
'score': float(score),
'rank': len(results) + 1
})
return results
# ์ฌ์ฉ ์์
search_engine = SemanticSearchEngine()
# ์ํ ๋ฌธ์๋ค
documents = [
"Python์ ๋ฐฐ์ฐ๊ธฐ ์ฝ๊ณ ๊ฐ๋ ฅํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์
๋๋ค",
"๋จธ์ ๋ฌ๋์ ์ํ ์ต๊ณ ์ ์ธ์ด๋ Python์
๋๋ค",
"JavaScript๋ ์น ๊ฐ๋ฐ์ ํ์์ ์ธ ์ธ์ด์
๋๋ค",
"Java๋ ์ํฐํ๋ผ์ด์ฆ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ง์ด ์ฌ์ฉ๋ฉ๋๋ค",
"C++์ ๊ฒ์ ๊ฐ๋ฐ๊ณผ ์์คํ
ํ๋ก๊ทธ๋๋ฐ์ ์ ํฉํฉ๋๋ค",
"์ธ๊ณต์ง๋ฅ ๊ฐ๋ฐ์๊ฐ ๋๋ ค๋ฉด Python์ ๋ฐฐ์์ผ ํฉ๋๋ค",
"React๋ ํ๋์ ์ธ ์น UI๋ฅผ ๋ง๋๋ JavaScript ๋ผ์ด๋ธ๋ฌ๋ฆฌ์
๋๋ค",
"๋ฅ๋ฌ๋ ํ๋ ์์ํฌ๋ก๋ TensorFlow์ PyTorch๊ฐ ์ ๋ช
ํฉ๋๋ค"
]
# ๋ฌธ์ ์ถ๊ฐ
search_engine.add_documents(documents)
# ๊ฒ์ ์ํ
query = "AI ๊ฐ๋ฐ์ ๋ฐฐ์ฐ๊ณ ์ถ์ด์"
results = search_engine.search(query, top_k=3)
print(f"\n๐ ๊ฒ์์ด: '{query}'")
print("=" * 60)
for result in results:
print(f"\n{result['rank']}์ (์ ์ฌ๋: {result['score']:.4f})")
print(f"๐ {result['document']}")
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ์ด๋ฐ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ๊ฑฐ์ผ:
1์ (์ ์ฌ๋: 0.7234)
๐ ์ธ๊ณต์ง๋ฅ ๊ฐ๋ฐ์๊ฐ ๋๋ ค๋ฉด Python์ ๋ฐฐ์์ผ ํฉ๋๋ค
2์ (์ ์ฌ๋: 0.6891)
๐ ๋จธ์ ๋ฌ๋์ ์ํ ์ต๊ณ ์ ์ธ์ด๋ Python์ ๋๋ค
3์ (์ ์ฌ๋: 0.6543)
๐ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ๋ก๋ TensorFlow์ PyTorch๊ฐ ์ ๋ช ํฉ๋๋ค
๋ณด๋ค์ํผ "AI"๋ "๊ฐ๋ฐ"์ด๋ผ๋ ๋จ์ด๊ฐ ์ ํํ ํฌํจ๋์ง ์์ ๋ฌธ์๋ ์ฐพ์๋ด!
์ด๊ฒ ๋ฐ๋ก ์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์์ ํ์์ผ. ๐ฏ
๐ง ๊ณ ๊ธ ๊ธฐ๋ฅ: ํ์ธํ๋์ผ๋ก ์ฑ๋ฅ ๋์ด์ฌ๋ฆฌ๊ธฐ
๊ธฐ๋ณธ ๋ชจ๋ธ๋ ์ข์ง๋ง, ํน์ ๋๋ฉ์ธ์ ๋ง๊ฒ ํ์ธํ๋ํ๋ฉด ์ฑ๋ฅ์ด ํจ์ฌ ์ข์์ ธ!
์๋ฅผ ๋ค์ด ์๋ฃ, ๋ฒ๋ฅ , ๊ธ์ต ๊ฐ์ ์ ๋ฌธ ๋ถ์ผ์์๋ ํ์ธํ๋์ด ํ์์ผ. ๐
ํ์ธํ๋ ๋ฐ์ดํฐ ์ค๋นํ๊ธฐ
ํ์ธํ๋์ ์ํด์๋ ํ์ต ๋ฐ์ดํฐ๊ฐ ํ์ํด. ๋ณดํต ์ธ ๊ฐ์ง ํํ๋ก ์ค๋นํ ์ ์์ด:
์) ("๊ณ ์์ด๊ฐ ์๊ณ ์์ด", "๊ณ ์์ด๊ฐ ์ ์ ์๋ค")
2. Triplets: (๊ธฐ์ค ๋ฌธ์ฅ, ์ ์ฌ ๋ฌธ์ฅ, ๋น์ ์ฌ ๋ฌธ์ฅ)
์) ("๊ฐ์์ง", "๊ฐ", "๊ณ ์์ด")
3. Labeled Data: ์ ์ฌ๋ ์ ์๊ฐ ๋งค๊ฒจ์ง ๋ฌธ์ฅ ์
์) ("๋ฌธ์ฅA", "๋ฌธ์ฅB", 0.85)
from sentence_transformers import SentenceTransformer, InputExample, losses
from torch.utils.data import DataLoader
# ํ์ต ๋ฐ์ดํฐ ์ค๋น (Positive Pairs ์์)
train_examples = [
InputExample(texts=['๊ณ ์์ด๊ฐ ์๊ณ ์์ด', '๊ณ ์์ด๊ฐ ์ ์ ์๋ค'], label=1.0),
InputExample(texts=['๊ฐ์์ง๊ฐ ๋ฐ์ด๋์', '๊ฐ๊ฐ ๋ฌ๋ฆฌ๊ณ ์์ด'], label=1.0),
InputExample(texts=['๋ ์จ๊ฐ ์ข์', '๋น๊ฐ ์ค๊ณ ์์ด'], label=0.3),
InputExample(texts=['ํ์ด์ฌ ํ๋ก๊ทธ๋๋ฐ', 'Python ์ฝ๋ฉ'], label=0.95),
# ... ๋ ๋ง์ ๋ฐ์ดํฐ
]
# ๋ฐ์ดํฐ๋ก๋ ์์ฑ
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
# ๋ชจ๋ธ ๋ก๋
model = SentenceTransformer('all-MiniLM-L6-v2')
# ์์ค ํจ์ ์ ์
train_loss = losses.CosineSimilarityLoss(model)
# ํ์ธํ๋ ์์
model.fit(
train_objectives=[(train_dataloader, train_loss)],
epochs=4,
warmup_steps=100,
output_path='./my_finetuned_model'
)
print("๐ ํ์ธํ๋ ์๋ฃ!")
โข ๋๋ฉ์ธ ํนํ ๋ฐ์ดํฐ์ผ์๋ก ํจ๊ณผ๊ฐ ์ข์
โข Epoch๋ 3-5 ์ ๋๊ฐ ์ ๋น (๋๋ฌด ๋ง์ผ๋ฉด ๊ณผ์ ํฉ)
โข Learning rate๋ 2e-5 ์ ๋๋ก ์์
โข ๊ฒ์ฆ ๋ฐ์ดํฐ๋ก ์ฑ๋ฅ์ ๋ชจ๋ํฐ๋งํด์ผ ํด
ํ๊ฐ ๋ฐ ์ฑ๋ฅ ์ธก์
from sentence_transformers import evaluation
# ํ๊ฐ ๋ฐ์ดํฐ ์ค๋น
sentences1 = ['๊ณ ์์ด๊ฐ ์๊ณ ์์ด', '๊ฐ์์ง๊ฐ ๋ฐ์ด๋์']
sentences2 = ['๊ณ ์์ด๊ฐ ์ ์ ์๋ค', '๊ฐ๊ฐ ๋ฌ๋ฆฌ๊ณ ์์ด']
scores = [0.9, 0.85] # ์ค์ ์ ์ฌ๋ ์ ์
# ํ๊ฐ์ ์์ฑ
evaluator = evaluation.EmbeddingSimilarityEvaluator(
sentences1,
sentences2,
scores
)
# ๋ชจ๋ธ ํ๊ฐ
model = SentenceTransformer('./my_finetuned_model')
score = evaluator(model)
print(f"๋ชจ๋ธ ์ฑ๋ฅ ์ ์: {score:.4f}")
๐ ์ค์ ํ์ฉ ์ฌ๋ก: ๋ค์ํ ์์ฉ ๋ถ์ผ
Sentence Transformers๋ฅผ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ ์ ์์๊น?
์ฌ๋ฌ ๊ฐ์ง ์ฌ๋ฏธ์๋ ์ฌ๋ก๋ค์ ์ดํด๋ณด์! ๐
1๏ธโฃ ์ค๋ณต ๋ฌธ์ ํ์ง
from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋ฌธ์ ๋ฆฌ์คํธ
documents = [
"์ธ๊ณต์ง๋ฅ์ ๋ฏธ๋์ ํต์ฌ ๊ธฐ์ ์
๋๋ค",
"AI๋ ์์ผ๋ก ๊ฐ์ฅ ์ค์ํ ๊ธฐ์ ์ด ๋ ๊ฒ์
๋๋ค",
"์ค๋ ๋ ์จ๊ฐ ์ ๋ง ์ข๋ค์",
"์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ ๋ฏธ๋์ ๋งค์ฐ ์ค์ํฉ๋๋ค",
"์ ์ฌ ๋ฉ๋ด๋ก ๋ญ ๋จน์๊น์?"
]
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(documents, convert_to_tensor=True)
# ์ ์ฌ๋ ๊ณ์ฐ
similarities = util.cos_sim(embeddings, embeddings)
# ์ค๋ณต ๋ฌธ์ ์ฐพ๊ธฐ (์ ์ฌ๋ 0.8 ์ด์)
print("๐ ์ค๋ณต ๊ฐ๋ฅ์ฑ์ด ๋์ ๋ฌธ์ ์:")
for i in range(len(documents)):
for j in range(i+1, len(documents)):
if similarities[i][j] > 0.8:
print(f"\n๋ฌธ์ {i+1}: {documents[i]}")
print(f"๋ฌธ์ {j+1}: {documents[j]}")
print(f"์ ์ฌ๋: {similarities[i][j]:.4f} โ ๏ธ")
2๏ธโฃ ๋ฌธ์ ํด๋ฌ์คํฐ๋ง
from sentence_transformers import SentenceTransformer
from sklearn.cluster import KMeans
import numpy as np
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋ค์ํ ์ฃผ์ ์ ๋ฌธ์๋ค
documents = [
"Python ํ๋ก๊ทธ๋๋ฐ ๋ฐฐ์ฐ๊ธฐ",
"๋จธ์ ๋ฌ๋ ์
๋ฌธ ๊ฐ์ด๋",
"๋ง์๋ ํ์คํ ๋ ์ํผ",
"JavaScript ๊ธฐ์ด ๊ฐ์ข",
"๋ฅ๋ฌ๋์ผ๋ก ์ด๋ฏธ์ง ๋ถ๋ฅํ๊ธฐ",
"์ง์์ ๋ง๋๋ ํผ์",
"React ์ปดํฌ๋ํธ ์ค๊ณ",
"์์ฐ์ด ์ฒ๋ฆฌ ๊ธฐ์ด",
"์ด์ฝ๋ฆฟ ์ผ์ดํฌ ๋ง๋ค๊ธฐ"
]
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(documents)
# K-Means ํด๋ฌ์คํฐ๋ง (3๊ฐ ๊ทธ๋ฃน)
num_clusters = 3
clustering_model = KMeans(n_clusters=num_clusters, random_state=42)
clustering_model.fit(embeddings)
cluster_assignment = clustering_model.labels_
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
clustered_sentences = [[] for _ in range(num_clusters)]
for sentence_id, cluster_id in enumerate(cluster_assignment):
clustered_sentences[cluster_id].append(documents[sentence_id])
print("๐ ํด๋ฌ์คํฐ๋ง ๊ฒฐ๊ณผ:")
for i, cluster in enumerate(clustered_sentences):
print(f"\nํด๋ฌ์คํฐ {i+1}:")
for doc in cluster:
print(f" โข {doc}")
๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ, ์๋ฆฌ ๊ด๋ จ, AI ๊ด๋ จ ๋ฌธ์๋ค์ด ์๋์ผ๋ก ๊ทธ๋ฃนํ๋ผ! ๐ฏ
3๏ธโฃ ์ถ์ฒ ์์คํ
from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer('all-MiniLM-L6-v2')
# ์ํ ์ค๋ช
products = [
"๋ฌด์ ๋ธ๋ฃจํฌ์ค ์ด์ดํฐ - ๊ณ ์์ง ์ฌ์ด๋",
"๋
ธ์ด์ฆ ์บ์ฌ๋ง ํค๋ํฐ - ํ๋ฆฌ๋ฏธ์ ์์ง",
"์ค๋งํธ์์น - ๊ฑด๊ฐ ๊ด๋ฆฌ ๊ธฐ๋ฅ",
"ํผํธ๋์ค ํธ๋์ปค - ์ด๋ ๊ธฐ๋ก",
"ํด๋์ฉ ์คํผ์ปค - ๋ฐฉ์ ๊ธฐ๋ฅ",
"๊ฒ์ด๋ฐ ํค๋์
- 7.1 ์๋ผ์ด๋",
"๋ฌ๋ํ - ์ฟ ์
๋ ์ฐ์",
"์๊ฐ ๋งคํธ - ๋ฏธ๋๋ผ ๋ฐฉ์ง"
]
# ์ฌ์ฉ์๊ฐ ๊ด์ฌ ์๋ ์ํ
user_interest = "์์
๋ฃ๊ธฐ ์ข์ ์ด์ดํฐ"
# ์๋ฒ ๋ฉ ์์ฑ
product_embeddings = model.encode(products, convert_to_tensor=True)
user_embedding = model.encode(user_interest, convert_to_tensor=True)
# ์ ์ฌ๋ ๊ณ์ฐ
similarities = util.cos_sim(user_embedding, product_embeddings)[0]
# ์์ 3๊ฐ ์ถ์ฒ
top_k = 3
top_results = similarities.topk(k=top_k)
print(f"๐ฏ '{user_interest}'์ ๋ํ ์ถ์ฒ ์ํ:")
for score, idx in zip(top_results[0], top_results[1]):
print(f"\n์ถ์ฒ๋: {score:.4f}")
print(f"์ํ: {products[idx]}")
4๏ธโฃ ๊ฐ์ฑ ๋ถ์ ๊ฐํ
from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๊ฐ์ฑ ๊ธฐ์ค ๋ฌธ์ฅ๋ค
positive_reference = "์ ๋ง ์ข์์! ์ต๊ณ ์์! ๋ง์กฑ์ค๋ฝ์ต๋๋ค!"
negative_reference = "๋ณ๋ก์์. ์ค๋งํ์ด์. ์ต์
์
๋๋ค."
neutral_reference = "๊ทธ๋ฅ ๊ทธ๋์. ๋ณดํต์
๋๋ค. ํ๋ฒํด์."
# ๋ถ์ํ ๋ฆฌ๋ทฐ๋ค
reviews = [
"์ด ์ ํ ์ง์ง ๋๋ฐ์ด์์! ๊ฐ๋ ฅ ์ถ์ฒํฉ๋๋ค!",
"๋ฐฐ์ก์ด ๋๋ฌด ๋ฆ์ด์ ์ง์ฆ๋๋ค์",
"๊ฐ๊ฒฉ ๋๋น ๊ด์ฐฎ์ ๊ฒ ๊ฐ์์",
"ํ์ง์ด ํํธ์์ด์. ํ๋ถํ๊ณ ์ถ์ต๋๋ค",
"๋ฑ ๊ธฐ๋ํ ๋งํผ์ด๋ค์"
]
# ์๋ฒ ๋ฉ ์์ฑ
ref_embeddings = model.encode([positive_reference, negative_reference, neutral_reference])
review_embeddings = model.encode(reviews)
# ๊ฐ ๋ฆฌ๋ทฐ์ ๊ฐ์ฑ ๋ถ์
print("๐ ๋ฆฌ๋ทฐ ๊ฐ์ฑ ๋ถ์ ๊ฒฐ๊ณผ:\n")
for i, review in enumerate(reviews):
similarities = util.cos_sim(review_embeddings[i], ref_embeddings)[0]
sentiment = ["๊ธ์ ๐", "๋ถ์ ๐", "์ค๋ฆฝ ๐"]
max_idx = similarities.argmax()
print(f"๋ฆฌ๋ทฐ: {review}")
print(f"๊ฐ์ฑ: {sentiment[max_idx]} (์ ๋ขฐ๋: {similarities[max_idx]:.4f})")
print()
๐ก๏ธ ์ฃผ์์ฌํญ๊ณผ ํ๊ณ์ ์์๋๊ธฐ
Sentence Transformers๊ฐ ์๋ฌด๋ฆฌ ์ข์๋ ์๋ฒฝํ์ง ์์.
์ค์ ํ๋ก์ ํธ์ ์ ์ฉํ๊ธฐ ์ ์ ์ด๋ฐ ์ ๋ค์ ๊ผญ ์์๋ฌ์ผ ํด! โ ๏ธ
๋๋ถ๋ถ์ ๋ชจ๋ธ์ ์ต๋ 512 ํ ํฐ๊น์ง๋ง ์ฒ๋ฆฌํ ์ ์์ด.
๊ธด ๋ฌธ์๋ ์๋ผ์ ์ฒ๋ฆฌํ๊ฑฐ๋ ์์ฝ์ด ํ์ํด!
# ๊ธด ํ
์คํธ ์ฒ๋ฆฌ ์์
def process_long_text(text, model, max_length=512):
# ๋ฌธ์ฅ ๋จ์๋ก ๋ถํ
sentences = text.split('. ')
# ์ฒญํฌ๋ก ๋๋๊ธฐ
chunks = []
current_chunk = ""
for sentence in sentences:
if len(current_chunk) + len(sentence) < max_length:
current_chunk += sentence + ". "
else:
chunks.append(current_chunk)
current_chunk = sentence + ". "
if current_chunk:
chunks.append(current_chunk)
# ๊ฐ ์ฒญํฌ์ ์๋ฒ ๋ฉ ์์ฑ ํ ํ๊ท
embeddings = model.encode(chunks)
return embeddings.mean(axis=0)
์๋ฃ, ๋ฒ๋ฅ , ๊ธ์ต ๋ฑ ์ ๋ฌธ ๋ถ์ผ์์๋ ํ์ธํ๋์ด ํ์!
๋ค๊ตญ์ด ๋ชจ๋ธ์ ์ฌ์ฉํ๊ฑฐ๋ ํ๊ตญ์ด ๋ฐ์ดํฐ๋ก ํ์ธํ๋ํ๋ ๊ฒ ์ข์!
FAISS ๊ฐ์ ๋ฒกํฐ ๊ฒ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ ๊ฑธ ์ถ์ฒํด!
# FAISS๋ฅผ ํ์ฉํ ํจ์จ์ ์ธ ๊ฒ์
import faiss
import numpy as np
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๋๋์ ๋ฌธ์ (์: 100๋ง ๊ฐ)
documents = ["๋ฌธ์ 1", "๋ฌธ์ 2", ...] # ์ค์ ๋ก๋ ์์ฒญ ๋ง์
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(documents, show_progress_bar=True)
embeddings = np.array(embeddings).astype('float32')
# FAISS ์ธ๋ฑ์ค ์์ฑ
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings)
# ๋น ๋ฅธ ๊ฒ์
query = "๊ฒ์ํ ๋ด์ฉ"
query_embedding = model.encode([query]).astype('float32')
# ์์ 10๊ฐ ๊ฒฐ๊ณผ ๊ฒ์ (๋งค์ฐ ๋น ๋ฆ!)
k = 10
distances, indices = index.search(query_embedding, k)
print("๊ฒ์ ๊ฒฐ๊ณผ:")
for i, idx in enumerate(indices[0]):
print(f"{i+1}. {documents[idx]} (๊ฑฐ๋ฆฌ: {distances[0][i]:.4f})")
๐ผ ํ๋ก๋์ ํ๊ฒฝ์ ๋ฐฐํฌํ๊ธฐ
๊ฐ๋ฐ ํ๊ฒฝ์์ ์ ๋์ํ๋ค๊ณ ๋์ด ์๋์ผ!
์ค์ ์๋น์ค์ ๋ฐฐํฌํ๋ ค๋ฉด ์ด๋ฐ ๊ฒ๋ค์ ๊ณ ๋ คํด์ผ ํด. ๐
Flask API ์๋ฒ ๋ง๋ค๊ธฐ
from flask import Flask, request, jsonify
from sentence_transformers import SentenceTransformer, util
import torch
app = Flask(__name__)
# ๋ชจ๋ธ ๋ก๋ (์๋ฒ ์์ ์ ํ ๋ฒ๋ง)
print("๋ชจ๋ธ ๋ก๋ฉ ์ค...")
model = SentenceTransformer('all-MiniLM-L6-v2')
print("๋ชจ๋ธ ๋ก๋ ์๋ฃ!")
# ๋ฌธ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค (์ค์ ๋ก๋ DB์์ ๊ฐ์ ธ์ด)
documents = [
"Python ํ๋ก๊ทธ๋๋ฐ ๊ฐ์ข",
"๋จธ์ ๋ฌ๋ ๊ธฐ์ด",
"์น ๊ฐ๋ฐ ์
๋ฌธ",
# ... ๋ ๋ง์ ๋ฌธ์
]
# ๋ฏธ๋ฆฌ ์๋ฒ ๋ฉ ์์ฑ
document_embeddings = model.encode(documents, convert_to_tensor=True)
@app.route('/search', methods=['POST'])
def search():
try:
# ์์ฒญ ๋ฐ์ดํฐ ๋ฐ๊ธฐ
data = request.get_json()
query = data.get('query', '')
top_k = data.get('top_k', 5)
if not query:
return jsonify({'error': '๊ฒ์์ด๋ฅผ ์
๋ ฅํด์ฃผ์ธ์'}), 400
# ์ฟผ๋ฆฌ ์๋ฒ ๋ฉ ์์ฑ
query_embedding = model.encode(query, convert_to_tensor=True)
# ์ ์ฌ๋ ๊ณ์ฐ
similarities = util.cos_sim(query_embedding, document_embeddings)[0]
# ์์ ๊ฒฐ๊ณผ ์ถ์ถ
top_results = torch.topk(similarities, k=min(top_k, len(documents)))
# ๊ฒฐ๊ณผ ํฌ๋งทํ
results = []
for score, idx in zip(top_results[0], top_results[1]):
results.append({
'document': documents[idx],
'score': float(score)
})
return jsonify({
'query': query,
'results': results,
'total': len(results)
})
except Exception as e:
return jsonify({'error': str(e)}), 500
@app.route('/embed', methods=['POST'])
def embed():
try:
data = request.get_json()
texts = data.get('texts', [])
if not texts:
return jsonify({'error': 'ํ
์คํธ๋ฅผ ์
๋ ฅํด์ฃผ์ธ์'}), 400
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(texts)
return jsonify({
'embeddings': embeddings.tolist(),
'dimension': embeddings.shape[1]
})
except Exception as e:
return jsonify({'error': str(e)}), 500
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=False)
Docker๋ก ์ปจํ ์ด๋ํํ๊ธฐ
# Dockerfile
FROM python:3.9-slim
WORKDIR /app
# ํ์ํ ํจํค์ง ์ค์น
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# ์ ํ๋ฆฌ์ผ์ด์
์ฝ๋ ๋ณต์ฌ
COPY . .
# ๋ชจ๋ธ ๋ฏธ๋ฆฌ ๋ค์ด๋ก๋ (์ ํ์ฌํญ)
RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
# ํฌํธ ๋
ธ์ถ
EXPOSE 5000
# ์๋ฒ ์คํ
CMD ["python", "app.py"]
# requirements.txt
flask==2.3.0
sentence-transformers==2.2.2
torch==2.0.0
numpy==1.24.0
# Docker ์ด๋ฏธ์ง ๋น๋ ๋ฐ ์คํ
docker build -t sentence-transformer-api .
docker run -p 5000:5000 sentence-transformer-api
โข ๋ฐฐ์น ์ฒ๋ฆฌ: ์ฌ๋ฌ ์์ฒญ์ ๋ชจ์์ ํ ๋ฒ์ ์ฒ๋ฆฌ
โข ๋น๋๊ธฐ ์ฒ๋ฆฌ: FastAPI + async/await ์ฌ์ฉ
โข ๋ก๋ ๋ฐธ๋ฐ์ฑ: ์ฌ๋ฌ ์๋ฒ ์ธ์คํด์ค ์ด์
โข ์บ์ฑ ๋ ์ด์ด: Redis๋ก ์์ฃผ ๊ฒ์๋๋ ๊ฒฐ๊ณผ ์บ์ฑ
๐ ๋ ๊น์ด ํ๊ณ ๋ค๊ธฐ: ๊ณ ๊ธ ์ฃผ์ ๋ค
๊ธฐ๋ณธ์ ๋ง์คํฐํ๋ค๋ฉด ์ด์ ๋ ๊น์ ๋ด์ฉ์ ์์๋ณผ ์ฐจ๋ก์ผ! ๐ค
Cross-Encoder vs Bi-Encoder
Sentence Transformers๋ ๊ธฐ๋ณธ์ ์ผ๋ก Bi-Encoder ๋ฐฉ์์ด์ผ.
ํ์ง๋ง ๋ ์ ํํ ๊ฒฐ๊ณผ๊ฐ ํ์ํ๋ฉด Cross-Encoder๋ฅผ ์ฌ์ฉํ ์ ์์ด!
| ํน์ง | Bi-Encoder | Cross-Encoder |
|---|---|---|
| ์๋ | โก ๋งค์ฐ ๋น ๋ฆ | ๐ข ๋๋ฆผ |
| ์ ํ๋ | ๐ ์ข์ | ๐ฏ ๋งค์ฐ ์ข์ |
| ํ์ฅ์ฑ | โ ์ฐ์ | โ ์ ํ์ |
| ์ฌ์ฉ ์ฌ๋ก | ๋๊ท๋ชจ ๊ฒ์, 1์ฐจ ํํฐ๋ง | ์ต์ข ์์ ๊ฒฐ์ , ์ฌ์ ๋ ฌ |
from sentence_transformers import SentenceTransformer, CrossEncoder, util
# Bi-Encoder๋ก ํ๋ณด ์ถ์ถ
bi_encoder = SentenceTransformer('all-MiniLM-L6-v2')
cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
query = "ํ์ด์ฌ์ผ๋ก ์น ํฌ๋กค๋งํ๋ ๋ฐฉ๋ฒ"
documents = [
"Python BeautifulSoup์ ์ด์ฉํ ์น ์คํฌ๋ํ",
"JavaScript๋ก ์น์ฌ์ดํธ ๋ง๋ค๊ธฐ",
"Selenium์ ํ์ฉํ ์๋ํ",
"Java ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ด",
"์น ํฌ๋กค๋ง ๋ฒ์ ์ด์"
]
# 1๋จ๊ณ: Bi-Encoder๋ก ๋น ๋ฅด๊ฒ ์์ ํ๋ณด ์ถ์ถ
query_emb = bi_encoder.encode(query, convert_to_tensor=True)
doc_embs = bi_encoder.encode(documents, convert_to_tensor=True)
similarities = util.cos_sim(query_emb, doc_embs)[0]
# ์์ 3๊ฐ ์ถ์ถ
top_k = 3
top_results = torch.topk(similarities, k=top_k)
candidates = [documents[idx] for idx in top_results[1]]
print("1๋จ๊ณ - Bi-Encoder ๊ฒฐ๊ณผ:")
for i, doc in enumerate(candidates):
print(f"{i+1}. {doc}")
# 2๋จ๊ณ: Cross-Encoder๋ก ์ ํํ๊ฒ ์ฌ์ ๋ ฌ
pairs = [[query, doc] for doc in candidates]
cross_scores = cross_encoder.predict(pairs)
# ์ ์์์ผ๋ก ์ ๋ ฌ
ranked_results = sorted(zip(candidates, cross_scores), key=lambda x: x[1], reverse=True)
print("\n2๋จ๊ณ - Cross-Encoder ์ฌ์ ๋ ฌ ๊ฒฐ๊ณผ:")
for i, (doc, score) in enumerate(ranked_results):
print(f"{i+1}. {doc} (์ ์: {score:.4f})")
๋ค์ค ๋ฒกํฐ ํํ (Multi-Vector Representations)
๋ฌธ์๊ฐ ๊ธธ ๋๋ ์ฌ๋ฌ ๊ฐ์ ๋ฒกํฐ๋ก ํํํ๋ ๊ฒ ๋ ํจ๊ณผ์ ์ผ ์ ์์ด!
from sentence_transformers import SentenceTransformer
import numpy as np
model = SentenceTransformer('all-MiniLM-L6-v2')
# ๊ธด ๋ฌธ์๋ฅผ ๋ฌธ์ฅ ๋จ์๋ก ๋ถํ
long_document = """
์ธ๊ณต์ง๋ฅ์ ํ๋ ์ฌํ์ ํต์ฌ ๊ธฐ์ ์
๋๋ค.
๋จธ์ ๋ฌ๋๊ณผ ๋ฅ๋ฌ๋์ ํตํด ๋ค์ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ต๋๋ค.
์์ฐ์ด ์ฒ๋ฆฌ, ์ปดํจํฐ ๋น์ , ์์ฑ ์ธ์ ๋ฑ ์ฌ๋ฌ ๋ถ์ผ์์ ํ์ฉ๋ฉ๋๋ค.
์์ผ๋ก AI ๊ธฐ์ ์ ๋์ฑ ๋ฐ์ ํ ๊ฒ์ผ๋ก ์์๋ฉ๋๋ค.
"""
sentences = [s.strip() for s in long_document.split('.') if s.strip()]
# ๊ฐ ๋ฌธ์ฅ์ ์๋ฒ ๋ฉ ์์ฑ
sentence_embeddings = model.encode(sentences)
# ๋ฐฉ๋ฒ 1: ํ๊ท ํ๋ง
avg_embedding = np.mean(sentence_embeddings, axis=0)
# ๋ฐฉ๋ฒ 2: ์ต๋ ํ๋ง
max_embedding = np.max(sentence_embeddings, axis=0)
# ๋ฐฉ๋ฒ 3: ๊ฐ์ค ํ๊ท (์ ๋ฌธ์ฅ์ ๋ ๋์ ๊ฐ์ค์น)
weights = np.array([1.0, 0.8, 0.6, 0.4])
weighted_embedding = np.average(sentence_embeddings, axis=0, weights=weights)
print(f"๋ฌธ์ฅ ์: {len(sentences)}")
print(f"ํ๊ท ์๋ฒ ๋ฉ shape: {avg_embedding.shape}")
print(f"์ต๋ ์๋ฒ ๋ฉ shape: {max_embedding.shape}")
print(f"๊ฐ์ค ํ๊ท ์๋ฒ ๋ฉ shape: {weighted_embedding.shape}")
์๋ฒ ๋ฉ ์ฐจ์ ์ถ์
384์ฐจ์์ด ๋๋ฌด ํฌ๋ค๋ฉด ์ฐจ์์ ์ค์ฌ์ ์ ์ฅ ๊ณต๊ฐ๊ณผ ๊ณ์ฐ ๋น์ฉ์ ์ ์ฝํ ์ ์์ด!
from sentence_transformers import SentenceTransformer
from sklearn.decomposition import PCA
import numpy as np
model = SentenceTransformer('all-MiniLM-L6-v2')
# ์ํ ๋ฌธ์ฅ๋ค
sentences = [f"์ํ ๋ฌธ์ฅ {i}" for i in range(1000)]
# ์๋ฒ ๋ฉ ์์ฑ
embeddings = model.encode(sentences)
print(f"์๋ณธ ์ฐจ์: {embeddings.shape}")
# PCA๋ก ์ฐจ์ ์ถ์ (384 -> 128)
pca = PCA(n_components=128)
reduced_embeddings = pca.fit_transform(embeddings)
print(f"์ถ์ ์ฐจ์: {reduced_embeddings.shape}")
# ์ ๋ณด ์์ค ํ์ธ
explained_variance = sum(pca.explained_variance_ratio_)
print(f"๋ณด์กด๋ ์ ๋ณด: {explained_variance:.2%}")
# ํฌ๊ธฐ ๋น๊ต
original_size = embeddings.nbytes / 1024 / 1024 # MB
reduced_size = reduced_embeddings.nbytes / 1024 / 1024 # MB
print(f"\n์๋ณธ ํฌ๊ธฐ: {original_size:.2f} MB")
print(f"์ถ์ ํฌ๊ธฐ: {reduced_size:.2f} MB")
print(f"์ ์ฝ๋ฅ : {(1 - reduced_size/original_size)*100:.1f}%")
๐ ํธ๋ฌ๋ธ์ํ : ์์ฃผ ๋ง๋๋ ๋ฌธ์ ๋ค
๊ฐ๋ฐํ๋ค ๋ณด๋ฉด ์ด๋ฐ ๋ฌธ์ ๋ค์ ์์ฃผ ๋ง๋๊ฒ ๋ผ. ๋ฏธ๋ฆฌ ์์๋๋ฉด ์๊ฐ์ ๋ง์ด ์ ์ฝํ ์ ์์ด! ๐ก
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข ๋ฐฐ์น ํฌ๊ธฐ ์ค์ด๊ธฐ: batch_size=16 โ batch_size=8
โข CPU ์ฌ์ฉ: device='cpu'
โข ๋ ์์ ๋ชจ๋ธ ์ฌ์ฉ: all-MiniLM-L6-v2
โข ๊ทธ๋๋์ธํธ ๋์ ์ฌ์ฉ
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข ๋ค๊ตญ์ด ๋ชจ๋ธ ์ฌ์ฉ: paraphrase-multilingual-mpnet-base-v2
โข ํ๊ตญ์ด ๋ฐ์ดํฐ๋ก ํ์ธํ๋
โข KoBERT ๊ธฐ๋ฐ ๋ชจ๋ธ ์ฌ์ฉ
โข ์ ์ฒ๋ฆฌ ๊ฐํ (๋์ด์ฐ๊ธฐ, ์ ๊ทํ)
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข ๋ฐฐ์น ์ฒ๋ฆฌ ํ์ฉ
โข ๋ชจ๋ธ ์์ํ
โข ONNX๋ก ๋ณํ
โข ์๋ฒ ๋ฉ ์บ์ฑ
โข GPU ์ฌ์ฉ
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข ์ฐจ์ ์ถ์ (PCA)
โข ๋ฒกํฐ DB ์ฌ์ฉ (Pinecone, Weaviate)
โข FAISS ์ธ๋ฑ์ค ํ์ฉ
โข ๋์คํฌ ๊ธฐ๋ฐ ์ ์ฅ
# ONNX๋ก ๋ชจ๋ธ ์ต์ ํ ์์
from sentence_transformers import SentenceTransformer
import torch
# ๋ชจ๋ธ ๋ก๋
model = SentenceTransformer('all-MiniLM-L6-v2')
# ONNX๋ก ๋ณํ
model.save('my_model')
# ๋ณํ๋ ๋ชจ๋ธ ์ฌ์ฉ
# (์ค์ ๋ก๋ onnxruntime ํ์)
print("๋ชจ๋ธ ์ต์ ํ ์๋ฃ!")
๐ฏ ์ค์ ํ๋ก์ ํธ ์์ด๋์ด
๋ฐฐ์ด ๋ด์ฉ์ ํ์ฉํด์ ์ด๋ฐ ํ๋ก์ ํธ๋ค์ ๋ง๋ค์ด๋ณผ ์ ์์ด! ๐
ํฌํธํด๋ฆฌ์ค์๋ ์ข๊ณ , ์ค์ ์๋น์ค๋ก๋ ๋ฐ์ ์ํฌ ์ ์์ง.
ํต์ฌ ๊ธฐ๋ฅ:
โข ์์ฐ์ด ์ง๋ฌธ์ผ๋ก ๊ด๋ จ ๋ฌธ์ ์ฐพ๊ธฐ
โข ์ ์ฌ ๋ฌธ์ ์ถ์ฒ
โข ์๋ ํ๊น ๋ฐ ๋ถ๋ฅ
โข ๊ฒ์ ๊ฒฐ๊ณผ ํ์ด๋ผ์ดํ
๊ธฐ์ ์คํ: Sentence Transformers + FAISS + Flask + React
ํต์ฌ ๊ธฐ๋ฅ:
โข ์ํ ์ค๋ช ๊ธฐ๋ฐ ์ ์ฌ ์ํ ์ฐพ๊ธฐ
โข ์ฌ์ฉ์ ๋ฆฌ๋ทฐ ๊ฐ์ฑ ๋ถ์
โข ๊ฐ์ธํ๋ ์ถ์ฒ
โข ํธ๋ ๋ ๋ถ์
๊ธฐ์ ์คํ: Sentence Transformers + PostgreSQL + Django
ํต์ฌ ๊ธฐ๋ฅ:
โข ์๋ ํ์ ๋ฐ ์ํฐํฐ ์ถ์ถ
โข FAQ ์๋ ๋งค์นญ
โข ๋ํ ์ปจํ ์คํธ ์ ์ง
โข ๊ฐ์ ์ธ์
๊ธฐ์ ์คํ: Sentence Transformers + Rasa + FastAPI
ํต์ฌ ๊ธฐ๋ฅ:
โข ๋ด์ค ์๋ ๋ถ๋ฅ
โข ์ค๋ณต ๊ธฐ์ฌ ์ ๊ฑฐ
โข ๊ฐ์ธํ ํผ๋
โข ํธ๋ ๋ฉ ํ ํฝ ๋ถ์
๊ธฐ์ ์คํ: Sentence Transformers + Scrapy + MongoDB
ํต์ฌ ๊ธฐ๋ฅ:
โข ๋์ด๋ ์๋ ๋ถ๋ฅ
โข ์ ์ฌ ๊ฐ์/์๋ฃ ์ถ์ฒ
โข ํ์ต ๊ฒฝ๋ก ์ ์
โข ์ง๋ฌธ-๋ต๋ณ ๋งค์นญ
๊ธฐ์ ์คํ: Sentence Transformers + Neo4j + Vue.js
๐ ๋ ๊ณต๋ถํ๊ณ ์ถ๋ค๋ฉด?
Sentence Transformers๋ฅผ ๋ง์คํฐํ๋ ์ฌ์ ์ ์ฌ๊ธฐ์ ๋์ด ์๋์ผ!
๊ณ์ ๋ฐ์ ํ๊ณ ์๋ ๋ถ์ผ๋๊น ๊พธ์คํ ๊ณต๋ถํด์ผ ํด. ๐
โข Sentence Transformers ๊ณต์ ๋ฌธ์
โข Hugging Face ๋ชจ๋ธ ํ๋ธ
โข SBERT.net ํํ ๋ฆฌ์ผ
๋ ผ๋ฌธ:
โข "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks"
โข "Making Monolingual Sentence Embeddings Multilingual"
โข "Augmented SBERT"
์ปค๋ฎค๋ํฐ:
โข Hugging Face ํฌ๋ผ
โข Reddit r/MachineLearning
โข Stack Overflow
โข GitHub Issues
์ค์ต ํ๋ซํผ:
โข Kaggle ๋ํ ๋ฐ ๋ ธํธ๋ถ
โข Google Colab
โข Paperspace Gradient
๊ทธ๋ฆฌ๊ณ ์ค์ ๋ก ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณด๋ ๊ฒ ๊ฐ์ฅ ์ค์ํด!
์ด๋ก ๋ง ๊ณต๋ถํ์ง ๋ง๊ณ ์ง์ ์ฝ๋๋ฅผ ์ง๊ณ , ์๋ฌ๋ฅผ ๋ง๋๊ณ , ํด๊ฒฐํ๋ฉด์ ๋ฐฐ์์ผ ์ง์ง ์ค๋ ฅ์ด ๋์ด. ๐ช
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง Sentence Transformers๋ก ๋ฒกํฐ ์๋ฒ ๋ฉ์ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ์์๋ดค์ด! ๐
์ฒ์์๋ ๋ณต์กํด ๋ณด์์ ์๋ ์์ง๋ง, ์ค์ ๋ก ์ฌ์ฉํด๋ณด๋ฉด ์๊ฐ๋ณด๋ค ๊ฐ๋จํ์ง?
๋ช ์ค์ ์ฝ๋๋ง์ผ๋ก ๊ฐ๋ ฅํ ์์ฐ์ด ์ฒ๋ฆฌ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์๋ค๋ ๊ฒ ์ ๋ง ๋๋ผ์! ๐ฎ
์ด ๊ธฐ์ ์ ์ง๊ธ๋ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด.
์๋ก์ด ๋ชจ๋ธ๋ค์ด ๊ณ์ ๋์ค๊ณ , ์ฑ๋ฅ๋ ์ ์ ์ข์์ง๊ณ ์์ง.
๊ทธ๋ฌ๋๊น ๊ธฐ๋ณธ์ ํํํ ๋ค์ ธ๋๋ฉด ์์ผ๋ก ๋์ฌ ์๋ก์ด ๊ธฐ์ ๋ค๋ ์ฝ๊ฒ ๋ฐฐ์ธ ์ ์์ ๊ฑฐ์ผ! ๐
์ฌ๋ฅ๋ท์์๋ ์ด๋ฐ AI ๊ธฐ์ ์ ํ์ฉํ ๋ค์ํ ํ๋ก์ ํธ๋ค์ ๋ง๋๋ณผ ์ ์์ด.
ํน์ ํ๋ก์ ํธ๋ฅผ ์งํํ๋ค๊ฐ ๋งํ๋ ๋ถ๋ถ์ด ์๋ค๋ฉด,
์ ๋ฌธ๊ฐ๋ค์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๐ก
๊ธฐ์ตํด! ์๋ฒฝํ ์ฝ๋๋ฅผ ์ฒ์๋ถํฐ ์ง๋ ์ฌ๋์ ์์ด.
์๋ฌ๋ฅผ ๋ง๋๊ณ , ๋๋ฒ๊น
ํ๊ณ , ๊ฐ์ ํ๋ ๊ณผ์ ์ด ๋ฐ๋ก ์ฑ์ฅํ๋ ๊ณผ์ ์ด์ผ.
ํฌ๊ธฐํ์ง ๋ง๊ณ ๊ณ์ ๋์ ํด๋ด! ๐ฅ
๊ทธ๋ผ ์ด์ ์ง์ ์ฝ๋๋ฅผ ์ง๋ณด๋ฉด์ ์ค์ตํด๋ณด์!
์ง๋ฌธ์ด ์๊ฑฐ๋ ๋งํ๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ์ธ์ ๋ ์ปค๋ฎค๋ํฐ์ ๋ฌผ์ด๋ด.
์ฐ๋ฆฌ ๋ชจ๋ ํจ๊ป ๋ฐฐ์ฐ๊ณ ์ฑ์ฅํ๋ ๊ฑฐ๋๊น! ๐ค
ํ์ด์ ๋น์ด! ํ์ดํ
! ๐ชโจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.