Jina AI ha lanzado sus modelos de embeddings bilingües de código abierto de última generación para los pares de idiomas alemán-inglés y chino-inglés a través de Hugging Face.
GitHub
Discord
En este tutorial, vamos a revisar una instalación y caso de uso muy básicos que cubrirá:
- Descargar modelos de Jina Embedding desde Hugging Face.
- Usar los modelos para obtener codificaciones de textos en alemán e inglés.
- Construir un motor de búsqueda neuronal muy rudimentario basado en embeddings para consultas entre idiomas.
Te mostraremos cómo usar Jina Embeddings para escribir consultas en inglés que recuperen textos coincidentes en alemán y viceversa.
Este tutorial funciona igual para el modelo chino. Solo sigue las instrucciones en la sección (hacia el final) titulada Querying in Chinese para obtener el modelo bilingüe chino-inglés y un documento de ejemplo en chino.
tagModelos de Embedding Bilingües
Un modelo de embedding bilingüe es un modelo que mapea textos en dos idiomas —alemán e inglés en este tutorial, chino e inglés para el modelo chino— al mismo espacio de embeddings. Y lo hace de tal manera que si un texto en alemán y un texto en inglés significan lo mismo, sus vectores de embedding correspondientes estarán cerca uno del otro.
Modelos como este son muy adecuados para aplicaciones de recuperación de información entre idiomas, lo cual mostraremos en este tutorial, pero también pueden servir como base para chatbots basados en RAG, categorización de texto multilingüe, resumen, análisis de sentimientos y cualquier otra aplicación que use embeddings. Al usar modelos como estos, puedes tratar textos en ambos idiomas como si estuvieran escritos en el mismo idioma.
Aunque muchos modelos de lenguaje gigantes afirman soportar muchos idiomas diferentes, no los soportan a todos por igual. Hay crecientes cuestionamientos sobre el sesgo causado por el dominio del inglés en Internet y las fuentes de entrada distorsionadas por la amplia publicación en línea de textos traducidos por máquina. Al centrarnos en dos idiomas, podemos controlar mejor la calidad del embedding para ambos, minimizando el sesgo mientras producimos modelos mucho más pequeños con un rendimiento similar o superior al de los modelos gigantes que pretenden manejar docenas de idiomas.
Los modelos bilingües Jina Embeddings v2 admiten 8,192 tokens de contexto de entrada, lo que les permite no solo soportar dos idiomas, sino también manejar segmentos de texto relativamente grandes en comparación con modelos similares. Esto los hace ideales para casos de uso más complejos donde se debe procesar mucha más información textual en embeddings.
tagSigue el tutorial en Google Colab
Este tutorial tiene un notebook complementario que puedes ejecutar en Google Colab, o localmente en tu propio sistema.
tagInstalación de Prerrequisitos
Asegúrate de que el entorno actual tenga las bibliotecas relevantes instaladas. Necesitarás la última versión de transformers, así que incluso si ya está instalada, ejecuta:
pip install -U transformers
Este tutorial usará la biblioteca FAISS de Meta para realizar búsquedas y comparaciones vectoriales. Para instalarla, ejecuta:
pip install faiss-cpu
También usaremos Beautiful Soup para procesar los datos de entrada en este tutorial, así que asegúrate de que esté instalado:
pip install bs4
tagAcceso a Hugging Face
Necesitarás acceso a Hugging Face, específicamente una cuenta y un token de acceso para descargar modelos.
Si no tienes una cuenta en Hugging Face:
Ve a https://huggingface.co/ y deberías ver un botón "Sign Up" en la parte superior derecha de la página. Haz clic en él y sigue las instrucciones para crear una nueva cuenta.
Después de iniciar sesión en tu cuenta:
Sigue las instrucciones en el sitio web de Hugging Face para obtener un token de acceso.
Necesitas copiar este token en una variable de entorno llamada HF_TOKEN. Si estás trabajando en un notebook (en Google Colab, por ejemplo) o configurándolo internamente en un programa Python, usa el siguiente código Python:
import os
os.environ['HF_TOKEN'] = "<your token here>"
En tu shell, usa la sintaxis proporcionada para establecer una variable de entorno. En bash:
export HF_TOKEN="<your token here>"
tagDescargar Jina Embeddings v2 para alemán e inglés
Una vez que tu token esté configurado, puedes descargar el modelo bilingüe alemán-inglés de Jina Embeddings usando la biblioteca transformers:
from transformers import AutoModel
model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-de', trust_remote_code=True)
Esto puede tomar varios minutos la primera vez que lo hagas, pero el modelo se almacenará en caché localmente después de eso, así que no te preocupes si reinicas este tutorial más tarde.
tagDescargar datos en inglés
Para este tutorial, vamos a obtener la versión en inglés del libro Pro Git: Everything You Need to Know About Git. Este libro también está disponible en chino y alemán, que usaremos más adelante en este tutorial.
Para descargar la versión EPUB, ejecuta el siguiente comando:
wget -O progit-en.epub https://open.umn.edu/opentextbooks/formats/3437Esto copia el libro a un archivo llamado progit-en.epub en el directorio local.
Alternativamente, puedes visitar el enlace https://open.umn.edu/opentextbooks/formats/3437 para descargarlo a tu unidad local. Está disponible bajo la licencia Creative Commons Attribution Non Commercial Share Alike 3.0.
tagProcesamiento de los datos
Este texto en particular tiene una estructura interna de secciones jerárquicas, que podemos encontrar fácilmente buscando la etiqueta <section> en los datos XHTML subyacentes. El código siguiente lee el archivo EPUB y lo divide utilizando la estructura interna de un archivo EPUB y la etiqueta <section>, luego convierte cada sección a texto plano sin etiquetas XHTML. Crea un diccionario Python cuyas claves son un conjunto de cadenas que indican la ubicación de cada sección en el libro, y cuyos valores son el contenido en texto plano de esa sección.
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
Luego, ejecuta la función decompose_epub en el archivo EPUB que descargaste antes:
book_data = decompose_epub("progit-en.epub")
La variable book_data ahora tendrá 583 secciones en ella. Por ejemplo:
print(book_data['EPUB/ch01-getting-started.xhtml::12'])
Resultado:
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.
tagGeneración e indexación de embeddings con Jina Embeddings v2 y FAISS
Para cada una de las 583 secciones, generaremos un embedding y lo almacenaremos en un índice FAISS. Los modelos Jina Embeddings v2 aceptan una entrada de hasta 8192 tokens, lo suficientemente grande como para que, para un libro como este, no necesitemos hacer ninguna segmentación adicional del texto ni verificar si alguna sección tiene demasiados tokens. La sección más larga del libro tiene aproximadamente 12,000 caracteres, que, para inglés normal, debería estar muy por debajo del límite de 8k tokens.
Para generar un solo embedding, utilizas el método encode del modelo que descargamos. Por ejemplo:
model.encode([book_data['EPUB/ch01-getting-started.xhtml::12']])
Esto devuelve un array que contiene un único vector de 768 dimensiones:
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,
....
Eso es un embedding.
Los modelos Jina Embeddings están configurados para permitir el procesamiento por lotes. El tamaño óptimo del lote depende del hardware que uses al ejecutar. Un tamaño de lote grande corre el riesgo de quedarse sin memoria. Un tamaño de lote pequeño tardará más en procesarse.
batch_size=5 funcionó en Google Colab en nivel gratuito sin GPU, y tomó aproximadamente una hora para generar todo el conjunto de embeddings.En producción, recomendamos usar hardware mucho más potente o usar el servicio API de Embeddings de Jina AI. Sigue el enlace a continuación para descubrir cómo funciona y cómo comenzar con acceso gratuito.
El código siguiente genera los embeddings y los almacena en un índice FAISS. Establece la variable batch_size según corresponda a tus recursos.
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)
Cuando se trabaja en un entorno de producción, un diccionario Python no es una forma adecuada o eficiente de manejar documentos y embeddings. Deberías usar una base de datos vectorial específica, que tendrá sus propias instrucciones para la inserción de datos.
tagConsultas en alemán para resultados en inglés
Cuando consultemos algo de este conjunto de textos, esto es lo que sucederá:
- El modelo alemán-inglés de Jina Embeddings creará un embedding para la consulta.
- Usaremos el índice FAISS (
faiss_index) para obtener el embedding almacenado con el coseno más alto respecto al embedding de la consulta y devolveremos su posición en el índice. - Buscaremos el texto correspondiente en el array de datos vectoriales (
vector_data) e imprimiremos el coseno, la ubicación del texto y el texto en sí.
Eso es lo que hace la función query a continuación.
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}")
Ahora vamos a probarlo.
# Translation: "How do I roll back to a previous version?"
query("Wie kann ich auf eine frühere Version zurücksetzen?")
Resultado:
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.
Esta es una muy buena opción para responder la pregunta. Probemos otra:
# Translation: "What does 'version control' mean?"
query("Was bedeutet 'Versionsverwaltung'?")
Resultado:
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.
Pruébalo con tus propias preguntas en alemán para ver qué tan bien funciona. Como práctica general, cuando se trata de recuperación de información textual, deberías solicitar de tres a cinco respuestas en lugar de solo una. La mejor respuesta a menudo no es la primera.
tagInvirtiendo los Roles: Consultando documentos en alemán con inglés
El libro Pro Git: Everything You Need to Know About Git también está disponible en alemán. Podemos usar este mismo modelo para hacer esta demostración con los idiomas invertidos.
Descarga el libro electrónico:
wget -O progit-de.epub https://open.umn.edu/opentextbooks/formats/3454
Esto copia el libro a un archivo llamado progit-de.epub. Luego lo procesamos de la misma manera que hicimos con el libro en inglés:
book_data = decompose_epub("progit-de.epub")
Y luego generamos los embeddings de la misma manera que antes:
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)
Ahora podemos usar la misma función query para buscar en inglés respuestas en alemán:
query("What is version control?")
Resultado:
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.
El título de esta sección se traduce como "¿Qué es el control de versiones?", por lo que esta es una buena respuesta.
tagConsultando en chino
Estos ejemplos funcionarán exactamente de la misma manera con Jina Embeddings v2 para chino e inglés. Para usar el modelo chino en su lugar, simplemente ejecuta lo siguiente:
from transformers import AutoModel
model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-zh', trust_remote_code=True)
Y para obtener la edición china de Pro Git: Everything You Need to Know About Git:
wget -O progit-zh.epub https://open.umn.edu/opentextbooks/formats/3455
Luego, procesa el libro en chino:
book_data = decompose_epub("progit-zh.epub")
Todo el resto del código en este tutorial funcionará de la misma manera.
tagEl Futuro: Más Idiomas, incluyendo Programación
Estaremos lanzando más modelos bilingües en el futuro inmediato, con español y japonés ya en desarrollo, así como un modelo que admite inglés y varios lenguajes de programación importantes. Estos modelos son ideales para empresas internacionales que gestionan información multilingüe, y pueden servir como piedra angular para la recuperación de información basada en IA y modelos de lenguaje generativo basados en RAG, insertándose en una variedad de casos de uso de IA de vanguardia.
Los modelos de Jina AI son compactos y se encuentran entre los mejores de su clase, demostrando que no se necesita el modelo más grande para obtener el mejor rendimiento. Al centrarnos en el rendimiento bilingüe, producimos modelos que son mejores en esos idiomas, más fáciles de adaptar y más rentables que los modelos grandes entrenados con datos sin curar.
Jina Embeddings está disponible en Hugging Face, en el AWS marketplace para uso en Sagemaker, y a través de la API web de Jina Embeddings. Están completamente integrados en muchos marcos de proceso de IA y bases de datos vectoriales.
Consulta el sitio web de Jina Embeddings para más información, o contáctanos para discutir cómo las ofertas de Jina AI pueden adaptarse a tus procesos de negocio.
