Что такое embedding и как он используется?

Embedding: числовое представление данных

Embedding (встраивание) — это преобразование дискретных объектов (слов, категорий, изображений, пользователей) в плотные векторы вещественных чисел в многомерном пространстве. Embeddings позволяют моделям работать с данными численно и отражают семантическую близость между объектами.

Основная идея

# Вместо категории используем вектор чисел:

# Плохо: категориальное кодирование
slovo = 'король'  # просто строка, не понятно модели

# Хорошо: embedding
embedding = {
    'король': [0.25, -0.83, 0.41, 0.56, ...],  # 300-мерный вектор
    'королева': [0.28, -0.81, 0.39, 0.58, ...],  # похож на король
    'кот': [0.12, 0.45, -0.33, 0.92, ...]  # отличается
}

# Семантическая близость => близость в пространстве
# король близко к королеве, но далеко от кота

Примеры embeddings

1. Word Embeddings (для текста)

Word2Vec:

from gensim.models import Word2Vec
import numpy as np

# Тренируем embeddings на корпусе текстов
sentences = [
    ['король', 'сидит', 'на', 'троне'],
    ['королева', 'правит', 'королевством'],
    ['кот', 'спит', 'на', 'кровати'],
    ['собака', 'бежит', 'по', 'дорожке']
]

model = Word2Vec(
    sentences=sentences,
    vector_size=100,  # размер embedding
    window=3,  # контекстное окно
    min_count=1,
    workers=4
)

# Получить embedding слова
king_embedding = model.wv['король']  # shape: (100,)
print(king_embedding)

# Найти похожие слова
similar = model.wv.most_similar('король', topn=3)
print(f"Похожие на 'король': {similar}")
# [('королева', 0.87), ('трон', 0.75), ('правит', 0.68)]

# Знаменитое свойство Word2Vec: король - король + королева = королева
result = model.wv.most_similar(
    positive=['король', 'королева'],
    negative=['король'],
    topn=1
)
print(result)  # близко к 'королева'

GloVe и FastText:

from fasttext import load_model

# FastText автоматически использует подслова
model = load_model('model.bin')
embed = model.get_word_vector('король')

# Работает даже для слов, которых не было в тренировке:
embed_rare = model.get_word_vector('королевич')  # похож на король

2. Sentence/Document Embeddings

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

sentences = [
    'Король сидит на золотом троне',
    'Монарх правит королевством',
    'Кот спит на кровати'
]

embeddings = model.encode(sentences)
print(embeddings.shape)  # (3, 384) - 384 мерные embeddings

# Сравним близость
from sklearn.metrics.pairwise import cosine_similarity

cosine_sim = cosine_similarity(embeddings)
print(cosine_sim[0, 1])  # близость между 1 и 2 предложениями (высокая)
print(cosine_sim[0, 2])  # близость между 1 и 3 предложениями (низкая)

3. User/Item Embeddings (рекомендательные системы)

import torch
import torch.nn as nn

class RecommendationModel(nn.Module):
    def __init__(self, n_users, n_items, embedding_dim=50):
        super().__init__()
        
        # Embeddings для пользователей и товаров
        self.user_embedding = nn.Embedding(n_users, embedding_dim)
        self.item_embedding = nn.Embedding(n_items, embedding_dim)
        
        # Bias terms
        self.user_bias = nn.Embedding(n_users, 1)
        self.item_bias = nn.Embedding(n_items, 1)
    
    def forward(self, user_id, item_id):
        user_embed = self.user_embedding(user_id)  # (batch_size, embedding_dim)
        item_embed = self.item_embedding(item_id)  # (batch_size, embedding_dim)
        
        # Предсказание рейтинга = скалярное произведение embeddings
        score = (user_embed * item_embed).sum(dim=1)  # (batch_size,)
        score += self.user_bias(user_id).squeeze()
        score += self.item_bias(item_id).squeeze()
        
        return score

model = RecommendationModel(n_users=1000, n_items=500, embedding_dim=50)

4. Image Embeddings

from transformers import ViTImageProcessor, ViTModel
from PIL import Image
import requests

# Используем Vision Transformer для получения embeddings изображений
processor = ViTImageProcessor.from_pretrained(
    'google/vit-base-patch16-224'
)
model = ViTModel.from_pretrained(
    'google/vit-base-patch16-224'
)

# Загружаем изображение
url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

# Получаем embedding
inputs = processor(images=image, return_tensors='pt')
outputs = model(**inputs)
last_hidden_states = outputs.last_hidden_state  # (1, 197, 768)
image_embedding = last_hidden_states[:, 0]  # берём [CLS] token

Как embeddings создаются

1. Word2Vec (Skip-gram model)

# Skip-gram: предсказываем контекст по слову
# "король сидит на троне" -> для слова "король" нужно предсказать "сидит" и "на"

import torch
import torch.nn as nn

class SkipGramModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.output = nn.Linear(embedding_dim, vocab_size)
    
    def forward(self, target_word_id):
        embed = self.embedding(target_word_id)  # (batch_size, embedding_dim)
        logits = self.output(embed)  # (batch_size, vocab_size)
        return logits

# Loss функция: предсказание контекстных слов
model = SkipGramModel(vocab_size=10000, embedding_dim=100)

2. Fine-tuning embeddings

from transformers import AutoTokenizer, AutoModel
import torch

# Используем предобученные embeddings как стартовую точку
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
model = AutoModel.from_pretrained('bert-base-uncased')

# Fine-tune на своих данных
import torch.optim as optim

optimizer = optim.Adam(model.parameters(), lr=2e-5)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(3):
    for batch in data_loader:
        input_ids = batch['input_ids']
        labels = batch['labels']
        
        # Forward pass
        outputs = model(input_ids)
        logits = outputs.last_hidden_state[:, 0]  # [CLS] token
        
        # Loss и обновление
        loss = loss_fn(logits, labels)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

Использование embeddings

# 1. Поиск похожести
from sklearn.metrics.pairwise import cosine_similarity

query_embedding = embeddings[0]
similarities = cosine_similarity([query_embedding], embeddings)[0]
top_similar = np.argsort(similarities)[::-1][:5]

# 2. Кластеризация
from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=10)
clusters = kmeans.fit_predict(embeddings)

# 3. Классификация
from sklearn.linear_model import LogisticRegression

classifier = LogisticRegression()
classifier.fit(embeddings, labels)
predictions = classifier.predict(test_embeddings)

# 4. Поиск ближайшего соседа (FAISS для больших данных)
import faiss

index = faiss.IndexFlatL2(embedding_dim)
index.add(np.array(embeddings).astype('float32'))

query = np.array([embeddings[0]]).astype('float32')
distances, indices = index.search(query, k=10)

Распространённые embedding модели

Свойства хороших embeddings

1. Семантическая близость — похожие объекты -> близкие векторы
2. Пространственная структура — отношения в данных отражаются в пространстве
3. Компактность — достаточно малая размерность для эффективности
4. Универсальность — работают для разных задач (transfer learning)
5. Стабильность — небольшие изменения входа -> небольшие изменения embedding

Выводы

Embeddings — это фундаментальная техника современного ML, позволяющая работать с категориальными, текстовыми и другими дискретными данными. Они лежат в основе почти всех современных NLP и CV моделей, и понимание их критично для работы с глубоким обучением.