Embedding modely — jak AI rozumí textu
Embedding modely jsou základním kamenem moderní AI pro práci s textem. Umožňují počítačům převést slova a věty do číselných vektorů, které zachycují jejich význam a umožňují porovnávat podobnost textů.
Co jsou embedding modely
Embedding modely představují fundamentální technologii, která umožňuje strojům "rozumět" textu podobně jako lidé. Zatímco počítač pracuje pouze s čísly, text se skládá ze slov a frází. Embedding modely fungují jako překladač, který převádí slova, věty nebo celé dokumenty na vektory čísel, přičemž zachovávají sémantický význam.
Klíčovou vlastností kvalitních embeddingů je schopnost zachytit vztahy mezi slovy. Například slova "král" a "královna" budou mít podobné vektorové reprezentace, stejně jako "Paříž" a "Francie". Tyto vztahy se projevují jako vzdálenosti ve vektorovém prostoru.
Jak embeddings fungují v praxi
Představte si každé slovo jako bod ve vícerozměrném prostoru. Moderní embedding modely používají typicky 300-1536 dimenzí. Slova se podobným významem jsou umístěna blízko sebe, zatímco slova s odlišným významem jsou vzdálená.
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
# Příklad jednoduchých 3D embeddingů
embeddings = {
'král': np.array([0.1, 0.8, 0.3]),
'královna': np.array([0.2, 0.7, 0.4]),
'muž': np.array([0.0, 0.9, 0.1]),
'žena': np.array([0.1, 0.6, 0.2]),
'auto': np.array([0.8, 0.1, 0.9])
}
# Výpočet podobnosti mezi "král" a "královna"
similarity = cosine_similarity([embeddings['král']], [embeddings['královna']])
print(f"Podobnost král-královna: {similarity[0][0]:.3f}")
Word2Vec: průkopník moderních embeddingů
Word2Vec, představený Googlem v roce 2013, byl prvním úspěšným embedding modelem. Používá dvě architektury:
- CBOW (Continuous Bag of Words): Předpovídá slovo na základě kontextu
- Skip-gram: Předpovídá kontext na základě slova
from gensim.models import Word2Vec
import nltk
from nltk.tokenize import sent_tokenize, word_tokenize
# Příprava dat
text = "Artificial intelligence pomáhá firmám automatizovat procesy. Machine learning je součástí AI."
sentences = [word_tokenize(sent.lower()) for sent in sent_tokenize(text)]
# Trénování Word2Vec modelu
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)
# Získání vektoru pro slovo
vector = model.wv['intelligence']
print(f"Vektor pro 'intelligence': {vector[:5]}...") # První 5 dimenzí
# Hledání podobných slov
similar_words = model.wv.most_similar('artificial', topn=3)
print(f"Slova podobná 'artificial': {similar_words}")
Moderní transformer-based embeddings
Zatímco Word2Vec vytváří statické reprezentace, moderní modely jako BERT, RoBERTa nebo OpenAI Ada generují kontextové embeddings. Stejné slovo má různé vektory podle kontextu, ve kterém se vyskytuje.
from transformers import AutoTokenizer, AutoModel
import torch
# Načtení českého BERT modelu
model_name = "ufal/robeczech-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
def get_sentence_embedding(text):
# Tokenizace
inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True)
# Forward pass
with torch.no_grad():
outputs = model(**inputs)
# Mean pooling posledních hidden states
embeddings = outputs.last_hidden_state.mean(dim=1)
return embeddings.numpy()
# Získání embeddingů pro věty
sentence1 = "Umělá inteligence mění svět."
sentence2 = "AI transformuje naši společnost."
embedding1 = get_sentence_embedding(sentence1)
embedding2 = get_sentence_embedding(sentence2)
# Výpočet podobnosti
from sklearn.metrics.pairwise import cosine_similarity
similarity = cosine_similarity(embedding1, embedding2)[0][0]
print(f"Podobnost vět: {similarity:.3f}")
OpenAI embeddings API
Pro produkční použití často využíváme hotová API. OpenAI nabízí výkonné embedding modely dostupné přes REST API:
import openai
import numpy as np
# Nastavení API klíče
openai.api_key = "your-api-key"
def get_openai_embedding(text, model="text-embedding-ada-002"):
response = openai.Embedding.create(
input=text,
model=model
)
return np.array(response['data'][0]['embedding'])
# Získání embeddingů
texts = [
"Jak implementovat vyhledávání v dokumentech?",
"Jaký je nejlepší způsob fulltextového vyhledávání?",
"Recepty na goulash s knedlíky"
]
embeddings = [get_openai_embedding(text) for text in texts]
# Porovnání podobnosti
from sklearn.metrics.pairwise import cosine_similarity
similarity_matrix = cosine_similarity(embeddings)
print("Matice podobnosti:")
print(similarity_matrix)
Praktické aplikace embeddingů
Sémantické vyhledávání
Tradiční keyword vyhledávání hledá přesné shody. Sémantické vyhledávání pomocí embeddingů rozumí významu a najde relevantní výsledky i bez přesné shody klíčových slov.
import faiss
import numpy as np
class SemanticSearch:
def __init__(self):
self.index = None
self.documents = []
self.embeddings = []
def add_documents(self, docs, embeddings):
self.documents.extend(docs)
self.embeddings.extend(embeddings)
# Vytvoření FAISS indexu pro rychlé vyhledávání
dimension = len(embeddings[0])
self.index = faiss.IndexFlatIP(dimension) # Inner product
self.index.add(np.array(embeddings).astype('float32'))
def search(self, query_embedding, top_k=5):
# Vyhledání nejpodobnějších dokumentů
scores, indices = self.index.search(
np.array([query_embedding]).astype('float32'),
top_k
)
results = []
for score, idx in zip(scores[0], indices[0]):
results.append({
'document': self.documents[idx],
'score': float(score)
})
return results
# Použití
search_engine = SemanticSearch()
documents = [
"Python je programovací jazyk",
"JavaScript se používá pro web development",
"Machine learning algoritmy v Pythonu"
]
# Přidání dokumentů (v reálné aplikaci by se embeddings počítaly)
doc_embeddings = [get_openai_embedding(doc) for doc in documents]
search_engine.add_documents(documents, doc_embeddings)
# Vyhledávání
query = "programování webových aplikací"
query_embedding = get_openai_embedding(query)
results = search_engine.search(query_embedding, top_k=2)
for result in results:
print(f"Score: {result['score']:.3f} - {result['document']}")
Clustering a klasifikace
Embeddings umožňují seskupovat podobné dokumenty nebo je klasifikovat do kategorií založených na sémantické podobnosti:
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
# Clustering dokumentů
def cluster_documents(embeddings, n_clusters=3):
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
clusters = kmeans.fit_predict(embeddings)
return clusters, kmeans
# PCA pro vizualizaci
def visualize_embeddings(embeddings, labels, documents):
pca = PCA(n_components=2)
reduced_embeddings = pca.fit_transform(embeddings)
plt.figure(figsize=(10, 8))
for i, doc in enumerate(documents):
plt.scatter(reduced_embeddings[i, 0], reduced_embeddings[i, 1],
c=f'C{labels[i]}', s=100)
plt.annotate(doc[:30] + '...',
(reduced_embeddings[i, 0], reduced_embeddings[i, 1]))
plt.title('Vizualizace dokumentových embeddingů')
plt.xlabel('PCA Komponenta 1')
plt.ylabel('PCA Komponenta 2')
plt.show()
# Použití
clusters, model = cluster_documents(np.array(doc_embeddings))
print(f"Clustery: {clusters}")
Optimalizace a best practices
Výběr správného modelu
Různé embedding modely se hodí pro různé účely:
- Word2Vec/FastText: Rychlé, vhodné pro základní úlohy
- BERT/RoBERTa: Kontextové, lepší pro složitější NLP úlohy
- Sentence-BERT: Optimalizované pro similarity vět
- OpenAI Ada-002: Univerzální, vysoká kvalita
Cachování a optimalizace
import pickle
import hashlib
from functools import lru_cache
class EmbeddingCache:
def __init__(self, cache_file="embeddings_cache.pkl"):
self.cache_file = cache_file
self.cache = self._load_cache()
def _load_cache(self):
try:
with open(self.cache_file, 'rb') as f:
return pickle.load(f)
except FileNotFoundError:
return {}
def _save_cache(self):
with open(self.cache_file, 'wb') as f:
pickle.dump(self.cache, f)
def get_embedding(self, text, model_func):
# Vytvoření hashe textu
text_hash = hashlib.md5(text.encode()).hexdigest()
if text_hash in self.cache:
return self.cache[text_hash]
# Výpočet nového embeddingu
embedding = model_func(text)
self.cache[text_hash] = embedding
self._save_cache()
return embedding
# Použití
cache = EmbeddingCache()
embedding = cache.get_embedding("test text", get_openai_embedding)
Shrnutí
Embedding modely jsou klíčovou technologií moderního NLP, která umožňuje strojům porozumět textu na sémantické úrovni. Od klasických Word2Vec modelů po moderní transformer-based architektury, embeddings nacházejí uplatnění v široké škále aplikací - od vyhledávání přes doporučovací systémy až po pokročilou analýzu textu. Správný výběr modelu, efektivní cachování a porozumění principům fungování vám pomůže vybudovat robustní AI aplikace založené na zpracování přirozeného jazyka.