Chunk embedding, Embedding de bloques de textos


from sentence_transformers import SentenceTransformer
import json

def get_vectors(chunk):
#model_name = "sentence-transformers/all-mpnet-base-v2"
model_name = "all-MiniLM-L6-v2"
model = SentenceTransformer(model_name)

texts = [data['text'] for data in chunk] # Obtener la lista de textos del chunk

embeddings = model.encode(texts, batch_size=100).tolist() # Obtener los embeddings

vector_data = {
"vectors": [{
"id": data['id'],
"metadata": data['metadata'],
"values": embedding
} for data, embedding in zip(chunk, embeddings)]
}

json_data = json.dumps(vector_data)
return json_data

 

  1. Importa las bibliotecas necesarias: SentenceTransformer para obtener los embeddings de las oraciones y json para trabajar con formato JSON.
  2. Define el modelo de transformación de oraciones que se utilizará. En este caso, el modelo se llama «all-MiniLM-L6-v2».
  3. Extrae los textos de cada elemento en el chunk y los guarda en una lista llamada texts.
  4. Utiliza el modelo de transformación de oraciones para generar los embeddings de los textos en el chunk. Los embeddings se generan en lotes de tamaño 100.
  5. Convierte los embeddings generados en una lista de Python utilizando el método tolist().
  6. Crea un diccionario llamado vector_data que contiene la lista de vectores generados. Cada vector está representado por un diccionario que contiene las claves «id», «metadata» y «values».
  7. Convierte el diccionario vector_data a formato JSON utilizando el método json.dumps().
  8. Devuelve el resultado como una cadena JSON.

En resumen, esta función toma un chunk de datos que contiene textos y metadatos, utiliza un modelo de transformación de oraciones para generar embeddings para cada texto y devuelve los resultados en formato JSON.

https://colab.research.google.com/drive/1aO_itojfM1u4IyHKwuz9oHEBq_pKk12i#scrollTo=jzatIfVCj7_Y

Generar embeddings para miles de documentos

https://github.com/ray-project/langchain-ray/tree/main/embedding_pdf_documents

Scaling Embedding Generation with LangChain and Ray

Este es un paso a paso más detallado que explica cómo crear un clúster multi-nodo de Ray y ejecutar el código para el artículo de nuestro blog «Scaling Embedding Generation with LangChain and Ray».

Paso 1: Instala Ray localmente ejecutando el siguiente comando: pip install 'ray[default]'

Paso 2: Clona el repositorio ejecutando el siguiente comando: git clone https://github.com/ray-project/langchain-ray/ y luego ingresa al directorio con el siguiente comando: cd langchain-ray. Si es necesario, puedes editar el archivo YAML del clúster para realizar cambios.

Paso 3: Configura las credenciales necesarias de AWS (establece las variables de entorno AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY y AWS_SESSION_TOKEN). Luego, puedes iniciar un clúster de Ray utilizando el archivo YAML con el siguiente comando: ray up -y llm-batch-inference.yaml

Paso 4: Puedes acceder al panel de control remoto de Ray mediante el siguiente comando: ray dashboard llm-batch-inference.yaml. Esto configurará el reenvío de puertos necesario.

El panel de control se puede ver visitando la dirección http://localhost:8265

Paso 5: Puedes ver el progreso del inicio de los nodos trabajadores mediante el estado del escalador automático en el panel de control de Ray.

Paso 6: Copia el archivo requirements.txt y el código de inferencia por lotes de Ray al clúster de Ray utilizando los siguientes comandos:

arduino
ray rsync_up llm-batch-inference.yaml 'embedding_ray.py' 'embedding_ray.py'
ray rsync_up llm-batch-inference.yaml 'requirements.txt' 'requirements.txt'

Paso 7: En una ventana separada, accede al clúster de Ray mediante SSH con el siguiente comando: ray attach llm-batch-inference.yaml

Paso 8: Instala los requisitos en el nodo principal del clúster ejecutando el siguiente comando: pip install -r requirements.txt

Paso 9: Una vez que todos los nodos trabajadores hayan iniciado, ¡ejecuta el código de inferencia por lotes de Ray en el clúster!

python embedding_ray.py

Paso 10: ¡Después de que se complete la carga de trabajo, desmantela el clúster! Esto debe ejecutarse desde tu laptop, así que si aún estás en la terminal del clúster, asegúrate de salir con Control-C.

ray down llm-batch-inference.yaml

Estos pasos te guiarán a través del proceso de configuración y ejecución de un clúster de Ray para generar incrustaciones de manera escalable utilizando LangChain y Ray.

 

Cómo funcionan los json y las funciones de serializar y convertir a texto

JSON, que significa JavaScript Object Notation, es un formato ligero para intercambiar datos. JSON es fácil de leer y escribir. Además, es fácil de generar y analizar para las máquinas. JSON es un formato de datos que tiene una sintaxis muy sencilla y en su forma básica define objetos (entre llaves {}) y arrays (entre corchetes []).

Un objeto JSON puede contener varios tipos de datos, como números, strings, booleanos, listas, objetos o null.

Aquí hay un ejemplo de un objeto JSON:

json
{
"nombre": "Juan",
"edad": 30,
"casado": false,
"hijos": ["Ana", "Luis"],
"mascotas": null,
"coche": {
"marca": "Ford",
"modelo": "Fiesta"
}
}

En muchos lenguajes de programación, existen métodos o funciones para serializar y deserializar JSON.

Serialización

Para serializar datos en formato JSON, puedes usar el método json.dumps(). Este método convierte los datos de Python en una cadena en formato JSON.

Aquí tienes un ejemplo:

python
import json

data = {
"nombre": "Juan",
"edad": 30,
"casado": False,
"hijos": ["Ana", "Luis"],
"mascotas": None,
"coche": {
"marca": "Ford",
"modelo": "Fiesta"
}
}

json_str = json.dumps(data)

print(json_str)
# Imprimirá:
# {"nombre": "Juan", "edad": 30, "casado": false, "hijos": ["Ana", "Luis"], "mascotas": null, "coche": {"marca": "Ford", "modelo": "Fiesta"}}

Deserialización

Para deserializar datos JSON, puedes usar el método json.loads(). Este método convierte una cadena en formato JSON en un objeto Python.

Aquí tienes un ejemplo:

python
import json

json_str = '{"nombre": "Juan", "edad": 30, "casado": false, "hijos": ["Ana", "Luis"], "mascotas": null, "coche": {"marca": "Ford", "modelo": "Fiesta"}}'

data = json.loads(json_str)

print(data)
# Imprimirá:
# {'nombre': 'Juan', 'edad': 30, 'casado': False, 'hijos': ['Ana', 'Luis'], 'mascotas': None, 'coche': {'marca': 'Ford', 'modelo': 'Fiesta'}}

Como puedes ver, los datos ahora están en un formato que Python puede trabajar, como diccionarios y listas.

La diferencia entre un objeto JSON y una cadena de texto (string) que representa un JSON es más que solo el carácter inicial. El objeto JSON es una estructura de datos, mientras que la cadena de texto es solo una representación de esa estructura.

Veamos las diferencias en más detalle:

  1. Tipo de dato: En Python, un objeto JSON es un tipo de dato nativo de Python (como un diccionario o una lista), mientras que una cadena JSON es una cadena de texto.
  2. Cómo se accede a los datos: Puedes acceder a los elementos de un objeto JSON usando la notación de punto o corchetes, como en objeto['clave'] en Python. Pero si intentas hacer esto con una cadena JSON, obtendrás un error, porque la cadena es solo texto y no tiene la estructura de los objetos o las listas.
  3. Cómo se ve: Los objetos JSON se visualizan como estructuras de datos, con llaves y corchetes. Las cadenas JSON se ven como texto, entre comillas, y todas las claves y valores están entre comillas.

Por ejemplo, considera el siguiente objeto JSON en Python:

python
data = {
"nombre": "Juan",
"edad": 30
}

Y la cadena JSON correspondiente:

python
json_str = '{"nombre": "Juan", "edad": 30}'

Si imprimes data['nombre'], obtendrás Juan, porque data es un objeto y puedes acceder a sus elementos. Pero si intentas imprimir json_str['nombre'], obtendrás un error, porque json_str es una cadena de texto, no un objeto.

Espero que esto aclare las diferencias entre un objeto JSON y una cadena JSON. La serialización y deserialización son procesos que nos permiten convertir entre estas dos formas, según nuestras necesidades.

 

El formato JSON no soporta todos los tipos de datos de Python. Los tipos de datos que pueden ser serializados a JSON incluyen diccionarios, listas, números, strings, booleanos y None. No puedes serializar otros tipos de datos más complejos, como conjuntos (sets), archivos o conexiones a bases de datos.

Cuando intentas serializar un conjunto (set), te encuentras con este error porque JSON no sabe cómo representar un conjunto.

Para resolver este problema, tendrías que convertir el conjunto a un tipo de datos que sea serializable. Por ejemplo, podrías convertir el conjunto a una lista:

python
import json

data = {
"nombre": "Juan",
"edad": 30,
"hobbies": {"fútbol", "cine", "música"} # Esto es un set
}

# Convertir el conjunto a una lista
data["hobbies"] = list(data["hobbies"])

json_str = json.dumps(data)

print(json_str)
# Imprimirá algo como:
# {"nombre": "Juan", "edad": 30, "hobbies": ["fútbol", "cine", "música"]}

De esta manera, puedes serializar tus datos sin problemas. Recuerda que cuando deserialices los datos, los «hobbies» serán una lista, no un conjunto.

La línea data["hobbies"] = list(data["hobbies"]) está convirtiendo el valor asociado a la clave «hobbies» de un conjunto (set) a una lista.

Inicialmente, data["hobbies"] es un conjunto:

python
{"fútbol", "cine", "música"}

La función list() toma un iterable (como un conjunto) y crea una nueva lista que contiene los mismos elementos. Entonces list(data["hobbies"]) crea una lista:

python
["fútbol", "cine", "música"]

Luego, esta nueva lista se asigna de vuelta a la clave «hobbies» en el diccionario data. Así que después de esta línea de código, data["hobbies"] es una lista, no un conjunto.

El contenido del diccionario data después de esa línea de código sería algo como esto:

python
{
"nombre": "Juan",
"edad": 30,
"hobbies": ["fútbol", "cine", "música"] # Esto es ahora una lista
}

Y cuando se convierte a una cadena JSON utilizando json.dumps(data), obtienes:

json
{
"nombre": "Juan",
"edad": 30,
"hobbies": ["fútbol", "cine", "música"]
}

De esta manera, has convertido el conjunto en una lista, que es un tipo de dato que JSON puede manejar.

como puedo identificar que tipo de objeto o dato es un parametro que me llega a la funcion?

En Python, puedes usar la función incorporada type() para identificar el tipo de un objeto. Aquí tienes un ejemplo:

python
def identificar_tipo(obj):
return type(obj)

print(identificar_tipo(5)) # <class 'int'>
print(identificar_tipo('hola')) # <class 'str'>
print(identificar_tipo([1, 2, 3])) # <class 'list'>
print(identificar_tipo({'nombre': 'Juan'})) # <class 'dict'>

La función type() devuelve el tipo del objeto que se le pasa como argumento.

Además, Python también proporciona la función isinstance() que puedes usar para comprobar si un objeto es de un tipo determinado:

python
def es_lista(obj):
return isinstance(obj, list)

print(es_lista(5)) # False
print(es_lista('hola')) # False
print(es_lista([1, 2, 3])) # True

En este caso, isinstance(obj, list) comprueba si obj es una lista y devuelve True si lo es y False en caso contrario.

Subir un .py a lambda de AWS

Primero, te daré el código de «Hola Mundo» en Python, ya que AWS Lambda soporta Python entre otros lenguajes. Luego, te proporcionaré los pasos para subir este código a la función Lambda «test01».

El código de «Hola Mundo» en Python es el siguiente:

python
def lambda_handler(event, context):
return {
'statusCode': 200,
'body': 'Hola Mundo'
}

Puedes copiar este código en VSCode y guardarlo como lambda_function.py.

Los pasos para subir este código a la función Lambda «test01» son los siguientes:

  1. Empaquetar el código: Necesitas comprimir tu archivo lambda_function.py en un archivo .zip. Puedes hacer esto con una herramienta de compresión de archivos o mediante la línea de comandos. En la línea de comandos, puedes navegar hasta el directorio que contiene tu archivo y luego ejecutar el siguiente comando:
bash
zip function.zip lambda_function.py
  1. Subir el paquete a Lambda: Necesitas utilizar el AWS CLI (Command Line Interface) para subir este archivo .zip a Lambda. Si aún no lo tienes, necesitarás instalarlo y configurarlo con tus credenciales de AWS. Una vez que hayas hecho eso, puedes ejecutar el siguiente comando para subir tu código:
bash
aws lambda update-function-code --function-name test01 --zip-file fileb://function.zip

Este comando le dice a AWS que quieres actualizar el código de la función Lambda «test01» y que el nuevo código está en el archivo function.zip.

Si recibes un error que dice que la función «test01» no existe, debes asegurarte de que la función se creó correctamente y de que tu CLI de AWS está configurado para utilizar la misma región en la que se creó la función.

Como creo un entorno de desarrollo con env en VScode

Los entornos virtuales de Python se utilizan para crear espacios de trabajo aislados para los proyectos de Python. Esto permite que los proyectos tengan sus propias dependencias, independientemente de lo que otras dependencias se hayan instalado a nivel de sistema.

Para crear un entorno virtual en VSCode utilizando venv, puedes seguir estos pasos:

  1. Crear el entorno virtual: Primero, necesitas abrir un terminal. Puedes hacerlo en VSCode seleccionando «Terminal» en la barra de menú y luego «Nuevo Terminal». Luego, navega hasta la carpeta donde deseas crear tu entorno virtual. Una vez que estés en la carpeta correcta, puedes crear el entorno virtual utilizando el siguiente comando:
bash
python3 -m venv nombre_del_entorno

Aquí, nombre_del_entorno es el nombre que deseas darle a tu entorno virtual. Este comando creará una nueva carpeta con ese nombre, que contendrá el entorno virtual.

  1. Activar el entorno virtual: Para utilizar el entorno virtual, necesitas activarlo. Puedes hacer esto con el siguiente comando:
  • En Windows:
bash
nombre_del_entorno\Scripts\activate
  • En Unix o MacOS:
bash
source nombre_del_entorno/bin/activate
  1. Configurar VSCode para usar el entorno virtual: Para configurar VSCode para usar este entorno virtual, primero necesitas abrir la paleta de comandos de VSCode. Puedes hacerlo pulsando F1. Luego, escribe «Python: Select Interpreter» y selecciona ese comando. Esto abrirá una lista de interpretadores de Python disponibles. Deberías ver tu entorno virtual en esta lista. Si no lo ves, puede que necesites reiniciar VSCode. Una vez que veas tu entorno virtual, selecciona ese interpretador. VSCode ahora utilizará este entorno virtual para ejecutar cualquier archivo de Python.
  2. Instalar paquetes: Ahora puedes instalar paquetes en tu entorno virtual utilizando pip. Estos paquetes solo estarán disponibles en este entorno virtual, y no afectarán a tus otros proyectos o a tu sistema Python.
bash
pip install nombre_del_paquete
  1. Salir del entorno virtual: Cuando hayas terminado de trabajar en tu proyecto, puedes salir del entorno virtual utilizando el comando deactivate.
bash
deactivate

Recursos estáticos a S3 de AWS

Para subir archivos a un bucket de S3, puedes usar la AWS Management Console, el AWS CLI o las AWS SDKs. Aquí te mostraré cómo hacerlo usando la AWS CLI.

Paso 1: Instalar y configurar AWS CLI

Si aún no has instalado la AWS CLI, puedes hacerlo siguiendo las instrucciones en la página oficial de AWS CLI. Una vez instalada, puedes configurarla con el comando aws configure. Este comando te pedirá tu ID de clave de acceso AWS, tu clave de acceso secreta, tu región predeterminada y el formato de salida que prefieras.

Paso 2: Crear un bucket de S3

Si aún no tienes un bucket de S3 donde subir tus archivos, puedes crear uno con el comando aws s3 mb, seguido del nombre de tu bucket. Por ejemplo:

arduino
aws s3 mb s3://nombre-de-tu-bucket

Paso 3: Subir tus archivos a S3

Para subir un archivo a tu bucket de S3, puedes usar el comando aws s3 cp seguido de la ruta al archivo que quieres subir y la ubicación de S3 donde quieres subirlo. Por ejemplo:

bash
aws s3 cp /ruta/a/tu/archivo.jpg s3://nombre-de-tu-bucket/

Si quieres subir todos los archivos en un directorio, puedes usar el comando aws s3 sync. Por ejemplo:

bash
aws s3 sync /ruta/a/tu/directorio/ s3://nombre-de-tu-bucket/

Este comando sincronizará todos los archivos en el directorio especificado con tu bucket de S3.

Paso 4: Configurar permisos en S3

Por defecto, los archivos que subas a S3 serán privados. Si quieres hacerlos públicos para que puedan ser accedidos desde tu página HTML, necesitas cambiar sus permisos. Puedes hacer esto en la AWS Management Console, seleccionando los archivos que quieres hacer públicos, haciendo clic en «Actions» (Acciones), luego en «Change public access settings» (Cambiar configuración de acceso público) y finalmente permitiendo el acceso público a los archivos.

Ten en cuenta que hacer públicos tus archivos en S3 puede tener implicaciones de seguridad y costos, así que asegúrate de entender las consecuencias antes de hacerlo.

Una vez que tus archivos están en S3 y son accesibles públicamente, puedes enlazarlos en tu HTML con su URL pública. La URL de un archivo en S3 generalmente tiene el formato https://nombre-de-tu-bucket.s3.amazonaws.com/nombre-del-archivo.

Espero que esto te ayude a subir tus archivos a S3! Si tienes alguna otra pregunta, no dudes en hacerla.