1. Introducción
Última actualización: 08/04/2024
Incorporación de texto
La incorporación de texto hace referencia al proceso de transformar datos textuales en representaciones numéricas. Estas representaciones numéricas, que suelen ser vectores, capturan el significado semántico y las relaciones entre las palabras de un texto. Imagínalo de esta manera:
El texto es como un lenguaje complejo, lleno de matices y ambigüedades.
La incorporación de texto traduce ese lenguaje a un formato matemático más simple que las computadoras pueden entender y manipular.
Beneficios de la incorporación de texto
- Permite un procesamiento eficiente: Las computadoras pueden procesar las representaciones numéricas mucho más rápido que el texto sin procesar. Esto es fundamental para tareas como los motores de búsqueda, los sistemas de recomendación y la traducción automática.
- Captura el significado semántico: Las incorporaciones van más allá del significado literal de las palabras. Captan el contexto y las relaciones entre las palabras, lo que permite un análisis más detallado.
- Mejora el rendimiento del aprendizaje automático: Las incorporaciones de texto se pueden usar como atributos en los modelos de aprendizaje automático, lo que genera un mejor rendimiento en tareas como el análisis de opiniones, la clasificación de texto y el modelado de temas.
Casos de uso de la incorporación de texto
Las incorporaciones de texto, al transformar el texto en representaciones numéricas, desbloquean una variedad de aplicaciones en el procesamiento de lenguaje natural (PLN). Estos son algunos casos de uso clave:
1. Motores de búsqueda y recuperación de información:
Las incorporaciones de texto permiten que los motores de búsqueda comprendan el significado semántico detrás de las búsquedas y las hagan coincidir con documentos relevantes, incluso si no están presentes las palabras clave exactas.
Cuando se comparan las incorporaciones de una búsqueda con las incorporaciones de documentos, los motores de búsqueda pueden identificar documentos que abarcan temas o conceptos similares.
2. Sistemas de recomendación:
Los sistemas de recomendación usan incorporaciones de texto para analizar el comportamiento y las preferencias de los usuarios que se expresan a través de opiniones, calificaciones o historial de navegación.
Luego, el sistema puede recomendar elementos similares comparando las incorporaciones de productos, artículos y otro contenido con el que el usuario interactuó.
3. Detección de plagio:
Comparar las incorporaciones de dos textos puede ayudar a identificar posibles plagios, ya que se encuentran similitudes significativas en su estructura semántica.
Estos son solo algunos ejemplos, y las posibilidades siguen creciendo a medida que evolucionan las técnicas de incorporación de texto. A medida que las computadoras comprendan mejor el lenguaje a través de las incorporaciones, podemos esperar aplicaciones aún más innovadoras en el futuro.
textembedding-gecko@003
Textembedding-gecko@003 es una versión específica de un modelo de incorporación de texto previamente entrenado que ofrece Google Cloud Platform (GCP) a través de Vertex AI y su paquete de herramientas y servicios de IA.
Qué compilarás
En este codelab, compilarás una secuencia de comandos de Python. Esta secuencia de comandos hará lo siguiente:
- Usa la API de Vertex para llamar a textembedding-gecko@003 y transformar el texto en incorporaciones de texto (vectores).
- Crea una base de datos simulada hecha de texto y sus vectores
- Compara los vectores y realiza una consulta a nuestra base de datos de vectores simulados para obtener la respuesta más probable.
Qué aprenderás
- Cómo usar la incorporación de texto en GCP
- Cómo llamar a textembedding-gecko@003
- Cómo ejecutar esto en Workbench
- Cómo usar Vertex AI Workbench para ejecutar secuencias de comandos
Requisitos
- Una versión reciente de Chrome
- Conocimientos de Python
- Un proyecto de Google Cloud
- Acceso a Vertex AI - Workbench
2. Cómo prepararte
Crea una instancia de Vertex AI Workbench
- En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
- Ir al selector de proyectos
- Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.
- Habilita la API de Notebooks.
Puedes crear una instancia de Vertex AI Workbench con la consola de Google Cloud, gcloud CLI o Terraform. A los efectos de este instructivo, lo crearemos con la consola de Google Cloud. Obtén más información sobre los otros métodos aquí.
- En la consola de Google Cloud, ve a la página Instancias, a la que se puede acceder en el menú de Vertex AI, en la sección Notebooks, y haz clic en Workbench.
- Ve a Instancias.
- Haz clic en Crear nueva.
- En el diálogo Crear instancia, en la sección Detalles, proporciona la siguiente información para tu instancia nueva:
Nombre: Proporciona un nombre para la instancia nueva. El nombre debe comenzar con una letra seguida de un máximo de 62 letras minúsculas, números o guiones (-), y no puede terminar con un guion.
Región y zona: Selecciona una región y una zona para la instancia nueva. Para obtener el mejor rendimiento de red, selecciona la región que se encuentra más cerca de tu ubicación geográfica.
No es necesario instalar la GPU
En la sección Herramientas de redes, proporciona la siguiente información:
Herramientas de redes: Ajusta las opciones de red para usar una red en tu proyecto actual o una red de VPC compartida desde un proyecto host, si existe una configurada. Si usas una VPC compartida en el proyecto host, también debes otorgar el rol de usuario de la red de Compute (roles/compute.networkUser) al agente de servicio de Notebooks desde el proyecto de servicio.
En el campo Red, selecciona la red que desees. Puedes seleccionar una red de VPC, siempre que esta tenga habilitado el Acceso privado a Google o pueda acceder a Internet.
En el campo Subred: Selecciona la subred que desees. Puedes elegir la predeterminada.
En las propiedades de la instancia, puedes dejar la predeterminada, es decir, una e2-standard-4.
- Haz clic en Crear.
Vertex AI Workbench crea una instancia y la inicia de forma automática. Cuando la instancia está lista para usarse, Vertex AI Workbench activa un vínculo para abrir JupyterLab. Haz clic en ella.
Cómo crear un notebook de Python 3
- Dentro de Jupyterlab, en el selector, en la sección Notebook, haz clic en el ícono con el logotipo de Python que dice Python3.
- Se crea un notebook de Jupyter con el nombre Sin título y la extensión ipynb.
- Puedes cambiarle el nombre con la sección del navegador de archivos que se encuentra en el lado izquierdo o dejarlo como está.
Ahora, podemos comenzar a poner nuestro código en el notebook.
3. Importa bibliotecas obligatorias
Una vez que se crea la instancia y se abre JupyterLab, debemos instalar todas las bibliotecas necesarias para nuestro codelab.
Necesitaremos lo siguiente:
- numpy
- pandas
- TextEmbeddingInput, TextEmbeddingModel desde vertexai.language_models
Copia y pega el siguiente código en una celda:
from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel
import numpy as np
import pandas as pd
Se vería algo así:
4. Crea una base de datos de vectores simulada
Para probar nuestro código, crearemos una base de datos de texto y sus respectivos vectores traducidos con el modelo de incorporación de texto gecko@003.
El objetivo es que los usuarios busquen un texto, lo traduzcan a un vector, lo busquen en nuestra base de datos y muestren el resultado más aproximado.
Nuestra base de datos de vectores contendrá 3 registros. Así es como la crearemos:
Copia y pega el siguiente código en una celda nueva.
DOCUMENT1 = {
"title": "Operating the Climate Control System",
"content": "Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car. To operate the climate control system, use the buttons and knobs located on the center console. Temperature: The temperature knob controls the temperature inside the car. Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature. Airflow: The airflow knob controls the amount of airflow inside the car. Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow. Fan speed: The fan speed knob controls the speed of the fan. Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed. Mode: The mode button allows you to select the desired mode. The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level. Cool: The car will blow cool air into the car. Heat: The car will blow warm air into the car. Defrost: The car will blow warm air onto the windshield to defrost it."}
DOCUMENT2 = {
"title": "Touchscreen",
"content": "Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control. To use the touchscreen display, simply touch the desired icon. For example, you can touch the \"Navigation\" icon to get directions to your destination or touch the \"Music\" icon to play your favorite songs."}
DOCUMENT3 = {
"title": "Shifting Gears",
"content": "Your Googlecar has an automatic transmission. To shift gears, simply move the shift lever to the desired position. Park: This position is used when you are parked. The wheels are locked and the car cannot move. Reverse: This position is used to back up. Neutral: This position is used when you are stopped at a light or in traffic. The car is not in gear and will not move unless you press the gas pedal. Drive: This position is used to drive forward. Low: This position is used for driving in snow or other slippery conditions."}
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
Se vería de la siguiente manera:
Analicemos el código
En las variables DOCUMENT1, DOCUMENT2 y DOCUMENT3, almacenamos un diccionario que emulará documentos con sus títulos y contenidos. Estos "documentos" hacen referencia a un manual simulado de un automóvil fabricado por Google.
En la siguiente línea, creamos una lista a partir de esos 3 documentos (diccionarios).
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
Por último, aprovechando pandas, creamos un dataframe a partir de esa lista que se llamará df_initial_db.
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
5. Crear embeddings de texto
Ahora, obtendremos una incorporación de texto con el modelo gecko@003 para cada registro de nuestra base de datos simulada de documentos.
Copia y pega el siguiente código en una celda nueva:
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
Se vería de la siguiente manera:
Analicemos el código
Definimos una función llamada embed_fn que recibirá como entrada un dataframe de pandas que contiene el texto para realizar la incorporación. Luego, la función muestra el texto codificado como un vector.
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
En la lista llamada list_embedded_values, almacenaremos y adjuntaremos el texto codificado de cada fila.
Con el método iterrows de pandas, podemos iterar cada fila del marco de datos y obtener los valores de la columna Text (que contiene la información manual de nuestra base de datos simulada).
Para enviar texto normal y mostrar su vector con el modelo gecko@003, inicializamos el modelo de variable, que es donde configuramos el modelo para usar llamando a la función TextEmbeddingModel.from_pretrained.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
Luego, en las incorporaciones de variables, capturamos el vector del texto que enviamos a través de la función model.get_embeddings.
Al final de la función, creamos una nueva columna en el marco de datos llamada Texto incorporado, que contendrá la lista de vectores creados en función del modelo gecko@003.
df_input['Embedded text'] = list_embedded_values
return df_input
Por último, en la variable df_embedded_values_db, capturamos el dataframe que contiene nuestros datos originales de la base de datos simulada, además de una columna nueva que contiene la lista de vectores para cada fila.
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
6. Cómo hacer una pregunta a la base de datos de vectores
Ahora que nuestra base de datos contiene texto y sus vectores, podemos hacer una pregunta y consultar nuestra base de datos para encontrar una respuesta.
Para ello, copia y pega el siguiente código en una celda nueva:
question='How do you shift gears in the Google car?'
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(question)])
text_to_search=embeddings[0].values
len(text_to_search)
El resultado se vería de la siguiente manera:
Analicemos el código
Al igual que en la función del paso anterior, primero inicializamos la variable de pregunta con lo que queremos preguntarle a nuestra base de datos.
question='How do you shift gears in the Google car?'
Luego, en la variable del modelo, configuramos el modelo que queremos usar a través de la función TextEmbeddingModel.from_pretrained, que en este caso es el modelo gecko@003.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
En la variable embeddings, llamamos a la función model.get_embeddings y pasamos el texto que se convertirá en vector. En este caso, pasamos la pregunta que se hará.
embeddings = model.get_embeddings([(question)])
Por último, la variable texto_para_buscar contiene la lista de vectores traducidos de la pregunta.
Imprimimos la longitud del vector solo como referencia.
text_to_search=embeddings[0].values
len(text_to_search)
7. Comparación de vectores
Ahora tenemos una lista de vectores en nuestra base de datos simulada y una pregunta transformada en un vector. Es decir, ahora podemos comparar el vector de la pregunta con todos los vectores de nuestra base de datos para saber cuál es el más cercano para responder nuestra pregunta con mayor precisión.
Para ello, mediremos la distancia entre el vector de la pregunta y cada vector de la base de datos. Existen varias técnicas para medir las distancias entre vectores. En este codelab específico, usaremos la distancia euclidiana o la norma L2.
En Python, podemos aprovechar la función numpy para lograrlo.
Copia y pega el siguiente código en una celda nueva:
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
print(f'The shortest distance is {shortest_distance} and the position of that value is {shortest_position}')
El resultado debería verse como el siguiente:
Analicemos el código
Comenzamos por convertir la columna que contiene el texto incorporado o los vectores de nuestra base de datos en una lista y almacenarla en list_embedded_text_from_db.
También inicializamos la variable shortest_distance en 1 para seguir actualizándola hasta que encontremos la distancia más corta real.
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
Luego, con un bucle for, iteramos y obtenemos la distancia entre el vector de la pregunta y cada vector de la base de datos.
Con la función numpy linalg.norm, calculamos su distancia.
Si la distancia calculada es menor que la de la variable shortest_distance, la distancia calculada se establecerá en esta variable.
Luego, capturamos la distancia más corta, así como la posición en la lista en la que se encontró. En las variables shortest_distance y shortest_position.
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
8. Resultados
Si conocemos la posición en la lista del vector que tiene la distancia más corta entre la pregunta y la base de datos, podemos imprimir los resultados.
Copia y pega el siguiente código en una celda nueva:
print("Your question was:\n "+question+ " \nAnd our answer is:\n "+
df_embedded_values_db.at[shortest_position, 'Title']+": "+
df_embedded_values_db.at[shortest_position, 'Text'])
Después de ejecutarlo, obtendrás algo como lo siguiente:
9. Felicitaciones
¡Felicitaciones! Compilaste correctamente tu primera aplicación con el modelo textembedding-gecko@003 en un caso de uso real.
Aprendiste los fundamentos de las incorporaciones de texto y cómo usar el modelo gecko003 en GCP Workbench.
Ahora conoces los pasos clave necesarios para seguir aplicando tus conocimientos a más casos de uso.
¿Qué sigue?
Consulta algunos codelabs sobre los siguientes temas: