Generar inserciones con MLTransform

En esta página se explica por qué y cómo usar la función MLTransform para preparar los datos para entrenar modelos de aprendizaje automático (ML). En concreto, en esta página se explica cómo procesar datos generando inserciones con MLTransform.

Al combinar varias transformaciones de procesamiento de datos en una clase, MLTransform simplifica el proceso de aplicar operaciones de procesamiento de datos de aprendizaje automático de Apache Beam a tu flujo de trabajo.

Diagrama del flujo de trabajo de Dataflow ML con el paso de procesamiento de datos destacado.

Imagen 1. Flujo de trabajo completo de Dataflow ML. Usa MLTransform en el paso de preprocesamiento del flujo de trabajo.

Descripción general de las inserciones

Las inserciones son esenciales para las aplicaciones modernas de búsqueda semántica y de generación aumentada por recuperación (RAG). Las incrustaciones permiten que los sistemas comprendan e interactúen con la información a un nivel más profundo y conceptual. En la búsqueda semántica, las incrustaciones transforman las consultas y los documentos en representaciones vectoriales. Estas representaciones captan su significado y sus relaciones subyacentes. Por lo tanto, puedes encontrar resultados relevantes aunque las palabras clave no coincidan directamente. Se trata de un avance significativo con respecto a la búsqueda estándar basada en palabras clave. También puedes usar las inserciones para hacer recomendaciones de productos. Esto incluye búsquedas multimodales que usan imágenes y texto, analíticas de registros y tareas como la deduplicación.

En la RAG, las inserciones desempeñan un papel fundamental a la hora de obtener el contexto más pertinente de una base de conocimientos para fundamentar las respuestas de los modelos de lenguaje extensos (LLMs). Al insertar tanto la consulta del usuario como los fragmentos de información de la base de conocimientos, los sistemas RAG pueden identificar y recuperar de forma eficiente los fragmentos más similares semánticamente. Esta coincidencia semántica asegura que el LLM tenga acceso a la información necesaria para generar respuestas precisas e informativas.

Ingerir y procesar datos para las inserciones

Diagrama de la ingestión de conocimientos de embeddings con los pasos de procesamiento de datos de la fragmentación y la generación de embeddings resaltados.

Imagen 2. Un diagrama de ingestión de conocimientos. En él se muestran los datos de documentos multimodales de entrada y dos pasos de procesamiento: la fragmentación y la generación de incrustaciones. La fragmentación es un paso de preprocesamiento que se usa para datos complejos antes de generar las inserciones. Una vez procesados los datos, las inserciones se almacenan en una base de datos de vectores.

En los casos prácticos principales de inserción, lo más importante es cómo incorporar y procesar el conocimiento. La ingestión puede realizarse por lotes o en streaming. La fuente de este conocimiento puede variar mucho. Por ejemplo, esta información puede proceder de archivos almacenados en Cloud Storage o de fuentes de streaming como Pub/Sub o Google Cloud Managed Service para Apache Kafka.

En el caso de las fuentes de streaming, los datos pueden ser el contenido sin procesar (por ejemplo, texto sin formato) o URIs que apunten a documentos. Independientemente de la fuente, la primera fase suele consistir en preprocesar la información. En el caso del texto sin formato, puede ser mínima, como la limpieza básica de datos. Sin embargo, en el caso de documentos más grandes o contenido más complejo, un paso fundamental es la división en fragmentos. La fragmentación consiste en dividir el material de origen en unidades más pequeñas y fáciles de gestionar. La estrategia de fragmentación óptima no está estandarizada y depende de los datos y la aplicación específicos. Plataformas como Dataflow ofrecen funciones integradas para gestionar diversas necesidades de fragmentación, lo que simplifica esta fase de preprocesamiento esencial.

Ventajas

La clase MLTransform ofrece las siguientes ventajas:

  • Genera incrustaciones que puedes usar para insertar datos en bases de datos vectoriales o para ejecutar inferencias.
  • Transforma tus datos sin tener que escribir código complejo ni gestionar bibliotecas subyacentes.
  • Encadena de forma eficiente varios tipos de operaciones de procesamiento con una sola interfaz.

Compatibilidad y limitaciones

La clase MLTransform tiene las siguientes limitaciones:

  • Disponible para las canalizaciones que usan las versiones 2.53.0 y posteriores del SDK de Apache Beam para Python.
  • Las canalizaciones deben usar ventanas predeterminadas.

Transformaciones de embeddings de texto:

Casos prácticos

En los cuadernos de ejemplo se muestra cómo usar MLTransform en casos prácticos específicos.

Quiero generar incrustaciones de texto para mi LLM usando Vertex AI
Usa la clase MLTransform de Apache Beam con la API de inserciones de texto de Vertex AI para generar inserciones de texto. Las incrustaciones de texto son una forma de representar texto como vectores numéricos, lo que es necesario para muchas tareas de procesamiento del lenguaje natural (PLN).
Quiero generar incrustaciones de texto para mi LLM usando Hugging Face
Usa la clase MLTransform de Apache Beam con modelos de Hugging Face Hub para generar representaciones de texto. El framework Hugging Face SentenceTransformers usa Python para generar incrustaciones de frases, texto e imágenes.
Quiero generar inserciones de texto e insertarlas en AlloyDB para PostgreSQL
Usa Apache Beam, concretamente su clase MLTransform con modelos de Hugging Face Hub para generar inserciones de texto. A continuación, usa VectorDatabaseWriteTransform para cargar estas inserciones y los metadatos asociados en AlloyDB para PostgreSQL. En este cuaderno se muestra cómo crear canalizaciones de datos de Beam escalables por lotes y de streaming para rellenar una base de datos de vectores de AlloyDB para PostgreSQL. Esto incluye la gestión de datos de varias fuentes, como Pub/Sub o tablas de bases de datos, la creación de esquemas personalizados y la actualización de datos.
Quiero generar inserciones de texto e incorporarlas a BigQuery
Usa la clase MLTransform de Apache Beam con los modelos de Hugging Face Hub para generar inserciones de texto a partir de datos de aplicaciones, como un catálogo de productos. Para ello, se usa la transformación HuggingfaceTextEmbeddings de Apache Beam. Esta transformación usa el framework SentenceTransformers de Hugging Face, que proporciona modelos para generar representaciones de frases y texto. Estas incrustaciones generadas y sus metadatos se insertan en BigQuery mediante Apache Beam VectorDatabaseWriteTransform. En el cuaderno se muestra cómo realizar búsquedas por similitud de vectores en BigQuery mediante la transformación Enrichment.

Para ver una lista completa de las transformaciones disponibles, consulta Transformaciones en la documentación de Apache Beam.

Usar MLTransform para generar inserciones

Para usar la clase MLTransform para dividir la información en fragmentos y generar las inserciones, incluye el siguiente código en tu canalización:

  
  def create_chunk(product: Dict[str, Any]) -> Chunk:
    return Chunk(
        content=Content(
            text=f"{product['name']}: {product['description']}"
        ),
        id=product['id'],  # Use product ID as chunk ID
        metadata=product,  # Store all product info in metadata
    )

  [...]
  with beam.Pipeline() as p:
    _ = (
            p
            | 'Create Products' >> beam.Create(products)
            | 'Convert to Chunks' >> beam.Map(create_chunk)
            | 'Generate Embeddings' >> MLTransform(
  write_artifact_location=tempfile.mkdtemp())
  .with_transform(huggingface_embedder)
            | 'Write to AlloyDB' >> VectorDatabaseWriteTransform(alloydb_config)
        )

En el ejemplo anterior se crea un solo fragmento por elemento, pero también puedes usar LangChain para crear fragmentos:

splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=20)
provider = beam.ml.rag.chunking.langchain.LangChainChunker(
document_field='content', metadata_fields=[], text_splitter=splitter)

with beam.Pipeline() as p:
_ = (
p
| 'Create Products' >> beam.io.textio.ReadFromText(products)
| 'Convert to Chunks' >> provider.get_ptransform_for_processing()

Siguientes pasos