Генерация вложений с помощью преобразователей предложений

Посмотреть на ai.google.dev Запустить в Google Colab Запустить в Kaggle Открыть в Vertex AI Просмотреть исходный код на GitHub

EmbeddingGemma — это лёгкая, открытая модель встраивания, разработанная для быстрого и качественного поиска данных на повседневных устройствах, таких как мобильные телефоны. Благодаря всего 308 миллионам параметров, она достаточно эффективна для использования передовых методов искусственного интеллекта, таких как Retrieval Augmented Generation (RAG), непосредственно на вашем локальном компьютере без подключения к Интернету.

Настраивать

Перед началом работы с этим руководством выполните следующие шаги:

  • Чтобы получить доступ к Gemma, войдите в Hugging Face и выберите «Подтвердить лицензию» для модели Gemma.
  • Создайте токен доступа Hugging Face и используйте его для входа в Colab.

Этот ноутбук будет работать как на центральном процессоре, так и на графическом процессоре.

Установить пакеты Python

Установите библиотеки, необходимые для запуска модели EmbeddingGemma и генерации встраиваемых представлений. Sentence Transformers — это фреймворк Python для встраиваемых представлений текста и изображений. Подробнее см. в документации по Sentence Transformers .

pip install -U sentence-transformers git+https://github.com/huggingface/transformers@v4.56.0-Embedding-Gemma-preview

После принятия лицензии вам понадобится действительный токен Hugging Face для доступа к модели.

# Login into Hugging Face Hub
from huggingface_hub import login
login()

Модель нагрузки

Используйте библиотеки sentence-transformers для создания экземпляра класса модели с EmbeddingGemma.

import torch
from sentence_transformers import SentenceTransformer

device = "cuda" if torch.cuda.is_available() else "cpu"

model_id = "google/embeddinggemma-300M"
model = SentenceTransformer(model_id).to(device=device)

print(f"Device: {model.device}")
print(model)
print("Total number of parameters in the model:", sum([p.numel() for _, p in model.named_parameters()]))

Device: cuda:0
SentenceTransformer(
  (0): Transformer({'max_seq_length': 2048, 'do_lower_case': False, 'architecture': 'Gemma3TextModel'})
  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
  (2): Dense({'in_features': 768, 'out_features': 3072, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
  (3): Dense({'in_features': 3072, 'out_features': 768, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
  (4): Normalize()
)
Total number of parameters in the model: 307581696

Генерация встраивания

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

Давайте посмотрим, как EmbeddingGemma будет обрабатывать три разных слова ["apple", "banana", "car"] .

EmbeddingGemma прошла обучение на больших объемах текста и изучила взаимосвязи между словами и понятиями.

words = ["apple", "banana", "car"]

# Calculate embeddings by calling model.encode()
embeddings = model.encode(words)

print(embeddings)
for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1} (shape): {embedding.shape}")

[[-0.18476306  0.00167681  0.03773484 ... -0.07996225 -0.02348064
   0.00976741]
 [-0.21189538 -0.02657359  0.02513712 ... -0.08042689 -0.01999852
   0.00512146]
 [-0.18924113 -0.02551468  0.04486253 ... -0.06377774 -0.03699806
   0.03973572]]
Embedding 1: (768,)
Embedding 2: (768,)
Embedding 3: (768,)

Модель выводит числовой вектор для каждого предложения. Сами векторы очень длинные (768), но для простоты они представлены с несколькими измерениями.

Ключевым моментом являются не сами отдельные числа, а расстояние между векторами . Если бы мы изобразили эти векторы в многомерном пространстве, векторы apple и banana были бы очень близки друг к другу. А вектор car был бы очень далек от двух других.

Определение сходства

В этом разделе мы используем векторное представление для определения степени семантического сходства различных предложений. Здесь мы приводим примеры с высокой, средней и низкой степенью сходства.

  • Высокое сходство:

    • Предложение А: «Шеф-повар приготовил для гостей вкусную еду».
    • Предложение Б: «Повар приготовил для гостей вкусный ужин».
    • Рассуждение: Оба предложения описывают одно и то же событие, используя разные слова и грамматические конструкции (действительный и страдательный залог). Они передают один и тот же основной смысл.

  • Среднее сходство:

    • Предложение А: «Она — эксперт в области машинного обучения».
    • Предложение B: «Он глубоко интересуется искусственным интеллектом».
    • Обоснование: Предложения связаны, поскольку машинное обучение — это подраздел искусственного интеллекта. Однако в них речь идёт о разных людях с разным уровнем вовлечённости (эксперт или интерес).

  • Низкое сходство:

    • Предложение А: «Сегодня в Токио солнечная погода».
    • Предложение Б: «Мне нужно купить продукты на неделю».
    • Рассуждение: Оба предложения касаются совершенно не связанных между собой тем и не имеют семантического совпадения. 
# The sentences to encode
sentence_high = [
    "The chef prepared a delicious meal for the guests.",
    "A tasty dinner was cooked by the chef for the visitors."
]
sentence_medium = [
    "She is an expert in machine learning.",
    "He has a deep interest in artificial intelligence."
]
sentence_low = [
    "The weather in Tokyo is sunny today.",
    "I need to buy groceries for the week."
]

for sentence in [sentence_high, sentence_medium, sentence_low]:
  print("🙋‍♂️")
  print(sentence)
  embeddings = model.encode(sentence)
  similarities = model.similarity(embeddings[0], embeddings[1])
  print("`-> 🤖 score: ", similarities.numpy()[0][0])

🙋‍♂️
['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']
`-> 🤖 score:  0.8002148
🙋‍♂️
['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']
`-> 🤖 score:  0.45417833
🙋‍♂️
['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']
`-> 🤖 score:  0.22262995

Использование подсказок с EmbeddingGemma

Чтобы создать наилучшие вложения с помощью EmbeddingGemma, добавьте «инструкцию» или «задание» в начало входного текста. Эти подсказки оптимизируют вложения для конкретных задач, таких как поиск документов или ответы на вопросы, и помогают модели различать различные типы входных данных, например, поисковый запрос и документ.

Как применять подсказки

Применить подсказку во время вывода можно тремя способами.

  1. Использование аргумента prompt
    Передайте полную строку запроса непосредственно в метод encode . Это обеспечивает точный контроль.

    embeddings = model.encode(
    sentence,
    prompt="task: sentence similarity | query: "
)

  2. Использование аргумента prompt_name
    Выберите предопределенную подсказку по ее имени. Эти подсказки загружаются из конфигурации модели или во время ее инициализации. 

    embeddings = model.encode(sentence, prompt_name="STS")

  3. Использование подсказки по умолчанию
    Если не указано ни prompt , ни prompt_name , система автоматически будет использовать подсказку, заданную как default_prompt_name ; если значение по умолчанию не задано, подсказка не применяется. 

    embeddings = model.encode(sentence)

print("Available tasks:")
for name, prefix in model.prompts.items():
  print(f" {name}: \"{prefix}\"")
print("-"*80)

for sentence in [sentence_high, sentence_medium, sentence_low]:
  print("🙋‍♂️")
  print(sentence)
  embeddings = model.encode(sentence, prompt_name="STS")
  similarities = model.similarity(embeddings[0], embeddings[1])
  print("`-> 🤖 score: ", similarities.numpy()[0][0])

Available tasks:
 query: "task: search result | query: "
 document: "title: none | text: "
 BitextMining: "task: search result | query: "
 Clustering: "task: clustering | query: "
 Classification: "task: classification | query: "
 InstructionRetrieval: "task: code retrieval | query: "
 MultilabelClassification: "task: classification | query: "
 PairClassification: "task: sentence similarity | query: "
 Reranking: "task: search result | query: "
 Retrieval: "task: search result | query: "
 Retrieval-query: "task: search result | query: "
 Retrieval-document: "title: none | text: "
 STS: "task: sentence similarity | query: "
 Summarization: "task: summarization | query: "
--------------------------------------------------------------------------------
🙋‍♂️
['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']
`-> 🤖 score:  0.9363755
🙋‍♂️
['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']
`-> 🤖 score:  0.6425841
🙋‍♂️
['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']
`-> 🤖 score:  0.38587403

Пример использования: генерация дополненной поисковой информации (RAG)

Для систем RAG используйте следующие значения prompt_name для создания специализированных внедрений для ваших запросов и документов:

  • Для запросов: используйте prompt_name="Retrieval-query" . 

    query_embedding = model.encode(
    "How do I use prompts with this model?",
    prompt_name="Retrieval-query"
)

  • Для документов: используйте prompt_name="Retrieval-document" . Для дальнейшего улучшения встраивания документов можно также включить заголовок, напрямую используя аргумент prompt :

    • С заголовком: 
    doc_embedding = model.encode(
    "The document text...",
    prompt="title: Using Prompts in RAG | text: "
)
    • Без названия: 
    doc_embedding = model.encode(
    "The document text...",
    prompt="title: none | text: "
)

Дополнительное чтение

Классификация

Классификация — это задача отнесения фрагмента текста к одной или нескольким предопределённым категориям или меткам. Это одна из важнейших задач в обработке естественного языка (НЛП).

Практическое применение классификации текста — маршрутизация тикетов службы поддержки клиентов. Этот процесс автоматически направляет запросы клиентов в нужный отдел, экономя время и сокращая объем ручной работы. 

labels = ["Billing Issue", "Technical Support", "Sales Inquiry"]

sentence = [
  "Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password.",
  "I would like to inquire about your enterprise plan pricing and features for a team of 50 people.",
]

# Calculate embeddings by calling model.encode()
label_embeddings = model.encode(labels, prompt_name="Classification")
embeddings = model.encode(sentence, prompt_name="Classification")

# Calculate the embedding similarities
similarities = model.similarity(embeddings, label_embeddings)
print(similarities)

idx = similarities.argmax(1)
print(idx)

for example in sentence:
  print("🙋‍♂️", example, "-> 🤖", labels[idx[sentence.index(example)]])

tensor([[0.4673, 0.5145, 0.3604],
        [0.4191, 0.5010, 0.5966]])
tensor([1, 2])
🙋‍♂️ Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password. -> 🤖 Technical Support
🙋‍♂️ I would like to inquire about your enterprise plan pricing and features for a team of 50 people. -> 🤖 Sales Inquiry

Обучение представлению матрешки (MRL)

EmbeddingGemma использует MRL для создания эмбеддингов разных размеров из одной модели. Это интеллектуальный метод обучения, создающий единое высококачественное эмбедирование, в котором наиболее важная информация сосредоточена в начале вектора.

Это означает, что вы можете получить меньшее, но всё ещё очень полезное вложение, просто взяв первые N измерений полного вложения. Использование меньших, усечённых вложений значительно дешевле хранить и быстрее обрабатывать, но эта эффективность достигается за счёт потенциального снижения качества вложений. MRL даёт вам возможность выбрать оптимальный баланс между скоростью и точностью в соответствии с конкретными потребностями вашего приложения.

Давайте используем три слова ["apple", "banana", "car"] и создадим упрощенные вложения, чтобы увидеть, как работает MRL. 

def check_word_similarities():
  # Calculate the embedding similarities
  print("similarity function: ", model.similarity_fn_name)
  similarities = model.similarity(embeddings[0], embeddings[1:])
  print(similarities)

  for idx, word in enumerate(words[1:]):
    print("🙋‍♂️ apple vs.", word, "-> 🤖 score: ", similarities.numpy()[0][idx])

# Calculate embeddings by calling model.encode()
embeddings = model.encode(words, prompt_name="STS")

check_word_similarities()

similarity function:  cosine
tensor([[0.7510, 0.6685]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.75102395
🙋‍♂️ apple vs. car -> 🤖 score:  0.6684626

Теперь, чтобы приложение работало быстрее, вам не нужна новая модель. Просто обрежьте все вложения до первых 512 измерений . Для достижения оптимальных результатов рекомендуется также установить normalize_embeddings=True , что масштабирует векторы до единичной длины. 

embeddings = model.encode(words, truncate_dim=512, normalize_embeddings=True)

for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1}: {embedding.shape}")

print("-"*80)
check_word_similarities()

Embedding 1: (512,)
Embedding 2: (512,)
Embedding 3: (512,)
--------------------------------------------------------------------------------
similarity function:  cosine
tensor([[0.7674, 0.7041]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.767427
🙋‍♂️ apple vs. car -> 🤖 score:  0.7040509

В крайне ограниченных условиях можно дополнительно сократить вложения до всего лишь 256 измерений . Также можно использовать более эффективное скалярное произведение для вычисления подобия вместо стандартного косинусного подобия. 

model = SentenceTransformer(model_id, truncate_dim=256, similarity_fn_name="dot").to(device=device)
embeddings = model.encode(words, prompt_name="STS", normalize_embeddings=True)

for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1}: {embedding.shape}")

print("-"*80)
check_word_similarities()

Embedding 1: (256,)
Embedding 2: (256,)
Embedding 3: (256,)
--------------------------------------------------------------------------------
similarity function:  dot
tensor([[0.7855, 0.7382]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.7854644
🙋‍♂️ apple vs. car -> 🤖 score:  0.7382126

Резюме и дальнейшие шаги

Теперь вы готовы создавать высококачественные текстовые вставки с помощью EmbeddingGemma и библиотеки Sentence Transformers. Примените эти навыки для создания мощных функций, таких как семантическое сходство, классификация текста и системы генерации дополненного поиска (RAG), а также продолжайте изучать возможности моделей Gemma.

Далее изучите следующие документы: