Jina AI a publié ses modèles d'embedding bilingues open-source à la pointe de la technologie pour les paires de langues allemand-anglais et chinois-anglais via Hugging Face.
GitHub
Discord
Dans ce tutoriel, nous allons passer en revue une installation et un cas d'utilisation très simples qui couvriront :
- Le téléchargement des modèles Jina Embedding depuis Hugging Face.
- L'utilisation des modèles pour obtenir des encodages de textes en allemand et en anglais.
- La création d'un moteur de recherche neuronal rudimentaire basé sur les embeddings pour des requêtes multilingues.
Nous vous montrerons comment utiliser Jina Embeddings pour écrire des requêtes en anglais qui retrouvent des textes correspondants en allemand et vice-versa.
Ce tutoriel fonctionne de la même manière pour le modèle chinois. Suivez simplement les instructions dans la section (vers la fin) intitulée Querying in Chinese pour obtenir le modèle bilingue chinois-anglais et un exemple de document en chinois.
tagModèles d'Embedding Bilingues
Un modèle d'embedding bilingue est un modèle qui projette des textes dans deux langues — l'allemand et l'anglais dans ce tutoriel, le chinois et l'anglais pour le modèle chinois — dans le même espace d'embedding. Et il le fait de telle sorte que si un texte allemand et un texte anglais signifient la même chose, leurs vecteurs d'embedding correspondants seront proches l'un de l'autre.
Ces modèles sont très bien adaptés aux applications de recherche d'information multilingue, ce que nous montrerons dans ce tutoriel, mais peuvent également servir de base pour les chatbots basés sur RAG, la catégorisation de textes multilingues, la synthèse, l'analyse des sentiments et toute autre application utilisant des embeddings. En utilisant ces modèles, vous pouvez traiter les textes dans les deux langues comme s'ils étaient écrits dans la même langue.
Bien que de nombreux grands modèles de langage prétendent prendre en charge de nombreuses langues différentes, ils ne les supportent pas toutes de manière égale. Il y a des questions croissantes concernant les biais causés par la domination de l'anglais sur Internet et les sources d'entrée déformées par la publication généralisée en ligne de textes traduits automatiquement. En se concentrant sur deux langues, nous pouvons mieux contrôler la qualité des embeddings pour les deux, minimisant les biais tout en produisant des modèles beaucoup plus petits avec des performances similaires ou supérieures aux modèles géants qui prétendent gérer des dizaines de langues.
Les modèles bilingues Jina Embeddings v2 prennent en charge 8 192 tokens de contexte d'entrée, leur permettant non seulement de supporter deux langues, mais aussi de traiter des segments de texte relativement importants par rapport aux modèles comparables. Cela les rend idéaux pour des cas d'utilisation plus complexes où beaucoup plus d'informations textuelles doivent être traitées en embeddings.
tagSuivez le tutoriel sur Google Colab
Ce tutoriel dispose d'un notebook d'accompagnement que vous pouvez exécuter sur Google Colab, ou localement sur votre propre système.
tagInstallation des Prérequis
Assurez-vous que l'environnement actuel dispose des bibliothèques nécessaires installées. Vous aurez besoin de la dernière version de transformers, donc même si elle est déjà installée, exécutez :
pip install -U transformers
Ce tutoriel utilisera la bibliothèque FAISS de Meta pour effectuer la recherche et la comparaison de vecteurs. Pour l'installer, exécutez :
pip install faiss-cpu
Nous utiliserons également Beautiful Soup pour traiter les données d'entrée dans ce tutoriel, donc assurez-vous qu'il est installé :
pip install bs4
tagAccès à Hugging Face
Vous aurez besoin d'un accès à Hugging Face, en particulier d'un compte et d'un jeton d'accès pour télécharger les modèles.
Si vous n'avez pas de compte sur Hugging Face :
Allez sur https://huggingface.co/ et vous devriez voir un bouton "Sign Up" en haut à droite de la page. Cliquez dessus et suivez les instructions pour créer un nouveau compte.
Une fois connecté à votre compte :
Suivez les instructions sur le site web de Hugging Face pour obtenir un jeton d'accès.
Vous devez copier ce jeton dans une variable d'environnement appelée HF_TOKEN. Si vous travaillez dans un notebook (sur Google Colab, par exemple) ou si vous le définissez en interne dans un programme Python, utilisez le code Python suivant :
import os
os.environ['HF_TOKEN'] = "<your token here>"
Dans votre shell, utilisez la syntaxe fournie pour définir une variable d'environnement. Dans bash :
export HF_TOKEN="<your token here>"
tagTélécharger Jina Embeddings v2 pour l'allemand et l'anglais
Une fois votre jeton défini, vous pouvez télécharger le modèle bilingue allemand-anglais Jina Embeddings en utilisant la bibliothèque transformers :
from transformers import AutoModel
model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-de', trust_remote_code=True)
Cela peut prendre plusieurs minutes la première fois que vous le faites, mais le modèle sera ensuite mis en cache localement, donc ne vous inquiétez pas si vous redémarrez ce tutoriel plus tard.
tagTélécharger les données en langue anglaise
Pour ce tutoriel, nous allons obtenir la version anglaise du livre Pro Git : Everything You Need to Know About Git. Ce livre est également disponible en chinois et en allemand, que nous utiliserons plus tard dans ce tutoriel.
Pour télécharger la version EPUB, exécutez la commande suivante :
wget -O progit-en.epub https://open.umn.edu/opentextbooks/formats/3437Cela copie le livre dans un fichier nommé progit-en.epub dans le répertoire local.
Alternativement, vous pouvez simplement visiter le lien https://open.umn.edu/opentextbooks/formats/3437 pour le télécharger sur un disque local. Il est disponible sous la licence Creative Commons Attribution Non Commercial Share Alike 3.0.
tagTraitement des données
Ce texte particulier a une structure interne de sections hiérarchiques, que nous pouvons facilement trouver en recherchant la balise <section> dans les données XHTML sous-jacentes. Le code ci-dessous lit le fichier EPUB et le divise en utilisant la structure interne d'un fichier EPUB et la balise <section>, puis convertit chaque section en texte brut sans balises XHTML. Il crée un dictionnaire Python dont les clés sont un ensemble de chaînes indiquant l'emplacement de chaque section dans le livre, et dont les valeurs sont le contenu en texte brut de cette section.
from zipfile import ZipFile
from bs4 import BeautifulSoup
import copy
def decompose_epub(file_name):
def to_top_text(section):
selected = copy.copy(section)
while next_section := selected.find("section"):
next_section.decompose()
return selected.get_text().strip()
ret = {}
with ZipFile(file_name, 'r') as zip:
for name in zip.namelist():
if name.endswith(".xhtml"):
data = zip.read(name)
doc = BeautifulSoup(data.decode('utf-8'), 'html.parser')
ret[name + ":top"] = to_top_text(doc)
for num, sect in enumerate(doc.find_all("section")):
ret[name + f"::{num}"] = to_top_text(sect)
return ret
Ensuite, exécutez la fonction decompose_epub sur le fichier EPUB que vous avez téléchargé précédemment :
book_data = decompose_epub("progit-en.epub")
La variable book_data contiendra maintenant 583 sections. Par exemple :
print(book_data['EPUB/ch01-getting-started.xhtml::12'])
Résultat :
The Command Line
There are a lot of different ways to use Git.
There are the original command-line tools, and there are many graphical user interfaces of varying capabilities.
For this book, we will be using Git on the command line.
For one, the command line is the only place you can run all Git commands — most of the GUIs implement only a partial subset of Git functionality for simplicity.
If you know how to run the command-line version, you can probably also figure out how to run the GUI version, while the opposite is not necessarily true.
Also, while your choice of graphical client is a matter of personal taste, all users will have the command-line tools installed and available.
So we will expect you to know how to open Terminal in macOS or Command Prompt or PowerShell in Windows.
If you don't know what we're talking about here, you may need to stop and research that quickly so that you can follow the rest of the examples and descriptions in this book.
tagGénération et indexation des embeddings avec Jina Embeddings v2 et FAISS
Pour chacune des 583 sections, nous allons générer un embedding et le stocker dans un index FAISS. Les modèles Jina Embeddings v2 acceptent des entrées jusqu'à 8192 tokens, une taille suffisante pour qu'avec un livre comme celui-ci, nous n'ayons pas besoin de faire de segmentation de texte supplémentaire ni de vérifier si une section a trop de tokens. La section la plus longue du livre compte environ 12 000 caractères, ce qui, pour l'anglais normal, devrait être bien en dessous de la limite de 8k tokens.
Pour générer un seul embedding, vous utilisez la méthode encode du modèle que nous avons téléchargé. Par exemple :
model.encode([book_data['EPUB/ch01-getting-started.xhtml::12']])
Cela renvoie un tableau contenant un seul vecteur de 768 dimensions :
array([[ 6.11135997e-02, 1.67829826e-01, -1.94809273e-01,
4.45595086e-02, 3.28837298e-02, -1.33441269e-01,
1.35364473e-01, -1.23119736e-02, 7.51526654e-02,
-4.25386652e-02, -6.91794455e-02, 1.03527725e-01,
-2.90831417e-01, -6.21018047e-03, -2.16205455e-02,
-2.20803712e-02, 1.50471330e-01, -3.31433356e-01,
-1.48741454e-01, -2.10959971e-01, 8.80039856e-02,
....
C'est un embedding.
Les modèles Jina Embeddings sont configurés pour permettre le traitement par lots. La taille optimale des lots dépend du matériel que vous utilisez lors de l'exécution. Une taille de lot importante risque d'épuiser la mémoire. Une petite taille de lot prendra plus de temps à traiter.
batch_size=5 a fonctionné sur Google Colab en version gratuite sans GPU, et a pris environ une heure pour générer l'ensemble complet des embeddings.En production, nous recommandons d'utiliser du matériel beaucoup plus puissant ou d'utiliser le service API Embedding de Jina AI. Suivez le lien ci-dessous pour découvrir comment il fonctionne et comment commencer avec un accès gratuit.
Le code ci-dessous génère les embeddings et les stocke dans un index FAISS. Définissez la variable batch_size en fonction de vos ressources.
import faiss
batch_size = 5
vector_data = []
faiss_index = faiss.IndexFlatIP(768)
data = [(key, txt) for key, txt in book_data.items()]
batches = [data[i:i + batch_size] for i in range(0, len(data), batch_size)]
for ind, batch in enumerate(batches):
print(f"Processing batch {ind + 1} of {len(batches)}")
batch_embeddings = model.encode([x[1] for x in batch], normalize_embeddings=True)
vector_data.extend(batch)
faiss_index.add(batch_embeddings)
Dans un environnement de production, un dictionnaire Python n'est pas une façon adéquate ou performante de gérer les documents et les embeddings. Vous devriez utiliser une base de données vectorielle dédiée, qui aura ses propres instructions pour l'insertion des données.
tagRequêtes en allemand pour des résultats en anglais
Lorsque nous faisons une requête dans cet ensemble de textes, voici ce qui se passera :
- Le modèle Jina Embeddings allemand-anglais créera un embedding pour la requête.
- Nous utiliserons l'index FAISS (
faiss_index) pour obtenir l'embedding stocké ayant le cosinus le plus élevé avec l'embedding de la requête et renvoyer sa place dans l'index. - Nous rechercherons le texte correspondant dans le tableau de données vectorielles (
vector_data) et afficherons le cosinus, l'emplacement du texte et le texte lui-même.
C'est ce que fait la fonction query ci-dessous.
def query(query_str):
query = model.encode([query_str], normalize_embeddings=True)
cosine, index = faiss_index.search(query, 1)
print(f"Cosine: {cosine[0][0]}")
loc, txt = vector_data[index[0][0]]
print(f"Location: {loc}\\nText:\\n\\n{txt}")
Essayons-le maintenant.
# Translation: "How do I roll back to a previous version?"
query("Wie kann ich auf eine frühere Version zurücksetzen?")
Résultat :
Cosine: 0.5202275514602661
Location: EPUB/ch02-git-basics-chapter.xhtml::20
Text:
Undoing things with git restore
Git version 2.23.0 introduced a new command: git restore.
It's basically an alternative to git reset which we just covered.
From Git version 2.23.0 onwards, Git will use git restore instead of git reset for many undo operations.
Let's retrace our steps, and undo things with git restore instead of git reset.
C'est un très bon choix pour répondre à la question. Essayons-en un autre :
# Translation: "What does 'version control' mean?"
query("Was bedeutet 'Versionsverwaltung'?")
Résultat :
Cosine: 0.5001817941665649
Location: EPUB/ch01-getting-started.xhtml::1
Text:
About Version Control
What is "version control", and why should you care?
Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later.
For the examples in this book, you will use software source code as the files being version controlled, though in reality you can do this with nearly any type of file on a computer.
If you are a graphic or web designer and want to keep every version of an image or layout (which you would most certainly want to), a Version Control System (VCS) is a very wise thing to use.
It allows you to revert selected files back to a previous state, revert the entire project back to a previous state, compare changes over time, see who last modified something that might be causing a problem, who introduced an issue and when, and more.
Using a VCS also generally means that if you screw things up or lose files, you can easily recover.
In addition, you get all this for very little overhead.
Essayez avec vos propres questions en allemand pour voir à quel point cela fonctionne bien. En règle générale, lorsque vous traitez la recherche d'informations textuelles, vous devriez demander trois à cinq réponses au lieu d'une seule. La meilleure réponse n'est souvent pas la première.
tagInverser les rôles : Interroger des documents allemands en anglais
Le livre Pro Git: Everything You Need to Know About Git est également disponible en allemand. Nous pouvons utiliser ce même modèle pour faire cette démonstration avec les langues inversées.
Téléchargez l'ebook :
wget -O progit-de.epub https://open.umn.edu/opentextbooks/formats/3454
Cela copie le livre dans un fichier nommé progit-de.epub. Nous le traitons ensuite de la même manière que pour le livre anglais :
book_data = decompose_epub("progit-de.epub")
Puis nous générons les embeddings de la même manière qu'auparavant :
batch_size = 5
vector_data = []
faiss_index = faiss.IndexFlatIP(768)
data = [(key, txt) for key, txt in book_data.items()]
batches = [data[i:i + batch_size] for i in range(0, len(data), batch_size)]
for ind, batch in enumerate(batches):
print(f"Processing batch {ind + 1} of {len(batches)}")
batch_embeddings = model.encode([x[1] for x in batch], normalize_embeddings=True)
vector_data.extend(batch)
faiss_index.add(batch_embeddings)
Nous pouvons maintenant utiliser la même fonction query pour rechercher en anglais des réponses en allemand :
query("What is version control?")
Résultat :
Cosine: 0.6719034910202026
Location: EPUB/ch01-getting-started.xhtml::1
Text:
Was ist Versionsverwaltung?
Was ist „Versionsverwaltung", und warum sollten Sie sich dafür interessieren?
Versionsverwaltung ist ein System, welches die Änderungen an einer oder einer Reihe von Dateien über die Zeit hinweg protokolliert, sodass man später auf eine bestimmte Version zurückgreifen kann.
Die Dateien, die in den Beispielen in diesem Buch unter Versionsverwaltung gestellt werden, enthalten Quelltext von Software, tatsächlich kann in der Praxis nahezu jede Art von Datei per Versionsverwaltung nachverfolgt werden.
Als Grafik- oder Webdesigner möchte man zum Beispiel in der Lage sein, jede Version eines Bildes oder Layouts nachverfolgen zu können. Als solcher wäre es deshalb ratsam, ein Versionsverwaltungssystem (engl. Version Control System, VCS) einzusetzen.
Ein solches System erlaubt es, einzelne Dateien oder auch ein ganzes Projekt in einen früheren Zustand zurückzuversetzen, nachzuvollziehen, wer zuletzt welche Änderungen vorgenommen hat, die möglicherweise Probleme verursachen, herauszufinden wer eine Änderung ursprünglich vorgenommen hat und viele weitere Dinge.
Ein Versionsverwaltungssystem bietet allgemein die Möglichkeit, jederzeit zu einem vorherigen, funktionierenden Zustand zurückzukehren, auch wenn man einmal Mist gebaut oder aus irgendeinem Grund Dateien verloren hat.
All diese Vorteile erhält man für einen nur sehr geringen, zusätzlichen Aufwand.
Le titre de cette section se traduit par "Qu'est-ce que le contrôle de version ?", c'est donc une bonne réponse.
tagInterrogation en chinois
Ces exemples fonctionneront exactement de la même manière avec Jina Embeddings v2 pour le chinois et l'anglais. Pour utiliser le modèle chinois à la place, exécutez simplement :
from transformers import AutoModel
model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-zh', trust_remote_code=True)
Et pour obtenir l'édition chinoise de Pro Git: Everything You Need to Know About Git :
wget -O progit-zh.epub https://open.umn.edu/opentextbooks/formats/3455
Puis, traitez le livre chinois :
book_data = decompose_epub("progit-zh.epub")
Tout le reste du code de ce tutoriel fonctionnera de la même manière.
tagL'avenir : Plus de langues, y compris la programmation
Nous déploierons davantage de modèles bilingues dans un avenir immédiat, avec l'espagnol et le japonais déjà en développement, ainsi qu'un modèle qui prend en charge l'anglais et plusieurs langages de programmation majeurs. Ces modèles sont idéalement adaptés aux entreprises internationales qui gèrent des informations multilingues, et peuvent servir de pierre angulaire pour la recherche d'informations basée sur l'IA et les modèles de langage génératifs basés sur RAG, s'intégrant dans une variété de cas d'utilisation d'IA de pointe.
Les modèles de Jina AI sont compacts et comptent parmi les meilleurs de leur catégorie, montrant qu'il n'est pas nécessaire d'avoir le plus grand modèle pour obtenir les meilleures performances. En se concentrant sur les performances bilingues, nous produisons des modèles qui sont à la fois meilleurs dans ces langues, plus faciles à adapter et plus rentables que les grands modèles entraînés sur des données non organisées.
Les Jina Embeddings sont disponibles sur Hugging Face, sur l'AWS marketplace pour une utilisation dans Sagemaker, et via l'API web Jina Embeddings. Ils sont entièrement intégrés dans de nombreux frameworks de processus d'IA et bases de données vectorielles.
Consultez le site web de Jina Embeddings pour plus d'informations, ou contactez-nous pour discuter de la façon dont les offres de Jina AI peuvent s'intégrer dans vos processus d'entreprise.
