1. Introducción
Última actualización: 2024-04-08
Incorporación de texto
La incorporación de texto se refiere al proceso de transformar datos textuales en representaciones numéricas. Estas representaciones numéricas, a menudo vectores, capturan el significado semántico y las relaciones entre las palabras de un texto. Imagina lo siguiente:
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 comprender y manipular.
Beneficios de la incorporación de texto
- Permite un procesamiento eficiente: Las representaciones numéricas son mucho más rápidas para que las computadoras las procesen en comparación con el texto sin procesar. Esto es fundamental para tareas como motores de búsqueda, sistemas de recomendación y traducción automática.
- Captura el significado semántico: Las incorporaciones van más allá del significado literal de las palabras. Capturan el contexto y las relaciones entre las palabras, lo que permite un análisis más matizado.
- 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 del 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 consultas y las hagan coincidir con documentos relevantes, incluso si las palabras clave exactas no están presentes.
Al comparar las incorporaciones de una consulta de 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 expresados 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 o cualquier otro contenido con el que el usuario haya interactuado.
3. Detección de plagio:
Comparar las incorporaciones de dos fragmentos de texto 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 entrenado previamente que ofrece Google Cloud Platform (GCP) a través de Vertex AI y su conjunto 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:
- Usar la API de Vertex para llamar a textembedding-gecko@003 y transformar texto en incorporaciones de texto (vectores)
- Crear una base de datos simulada hecha de texto y sus vectores
- Realizar una consulta a nuestra base de datos de vectores simulada comparando los vectores y 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 ejecutarlo 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 mediante la consola de Google Cloud, gcloud CLI o Terraform. Para los fines de este instructivo, la crearemos con la consola de Google Cloud. Puedes encontrar 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 Create new.
- 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 hasta 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 lo siguiente:
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 del 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 Abrir JupyterLab. Haz clic en ella.
Crea un notebook de Python 3
- Dentro de Jupyterlab, desde el iniciador, 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 Untitled y la extensión ipynb.
- Puedes cambiarle el nombre con la sección del explorador de archivos en el lado izquierdo o puedes dejarlo como está.
Ahora, podemos comenzar a colocar nuestro código en el notebook.
3. Importa las bibliotecas necesarias
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 de 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 hecha 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 así:
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, con 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 en nuestra base de datos de documentos simulada.
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 así:
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 agregaremos el texto codificado de cada fila.
Con el método iterrows de pandas, podemos iterar cada fila del DataFrame 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 la variable model, que es donde configuramos el modelo que se usará llamando a la función TextEmbeddingModel.from_pretrained.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
Luego, en la variable embeddings, 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 columna nueva en el DataFrame llamada Embedded text, 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. Haz 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 algo así:
Analicemos el código
De manera similar a la función del paso anterior, primero inicializamos la variable question con lo que queremos preguntar a nuestra base de datos.
question='How do you shift gears in the Google car?'
Luego, en la variable model, 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 text_to_search contiene la lista de vectores traducidos de la pregunta.
Imprimimos la longitud del vector como referencia.
text_to_search=embeddings[0].values
len(text_to_search)
7. Compara 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 averiguar 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 distancias entre vectores. Para 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 en una lista la columna que contiene el texto incorporado o los vectores de nuestra base de datos 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
Conocer la posición en la lista del vector que contiene la distancia más corta entre la pregunta y la base de datos nos permite 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: