Genera incorporaciones con MLTransform

En esta página, se explica por qué y cómo usar la función MLTransform para preparar tus datos para entrenar modelos de aprendizaje automático (AA). Específicamente, en esta página, se muestra cómo procesar datos generando embeddings con MLTransform.

Mediante la combinación de varias transformaciones de procesamiento de datos en una clase, MLTransform optimiza el proceso de aplicación de operaciones de procesamiento de datos de AA de Apache Beam en tu flujo de trabajo.

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

Figure 1. El flujo de trabajo completo de AA de Dataflow. Usa MLTransform en el paso de procesamiento previo del flujo de trabajo.

Descripción general de las incorporaciones

Los embeddings son esenciales para las aplicaciones modernas de búsqueda semántica y de generación aumentada por recuperación (RAG). Las incorporaciones permiten que los sistemas comprendan la información y se relacionen con ella en un nivel más profundo y conceptual. En la búsqueda semántica, los embeddings transforman las búsquedas y los documentos en representaciones vectoriales. Estas representaciones capturan su significado y sus relaciones subyacentes. Por lo tanto, esto te permite encontrar resultados relevantes incluso cuando las palabras clave no coinciden directamente. Esto representa un avance significativo en comparación con la búsqueda estándar basada en palabras clave. También puedes usar las incorporaciones para las recomendaciones de productos. Esto incluye búsquedas multimodales que usan imágenes y texto, análisis de registros y tareas como la deduplicación.

En la RAG, las incorporaciones desempeñan un papel fundamental en la recuperación del contexto más pertinente de una base de conocimiento para fundamentar las respuestas de los modelos de lenguaje grandes (LLM). Al incorporar tanto la búsqueda del usuario como los fragmentos de información en la base de conocimiento, los sistemas de RAG pueden identificar y recuperar de manera eficiente las partes más similares semánticamente. Esta correlación semántica garantiza que el LLM tenga acceso a la información necesaria para generar respuestas precisas e informativas.

Transfiere y procesa datos para las incorporaciones

Diagrama de la transferencia de conocimiento de la incorporación con los pasos de procesamiento de datos de fragmentación y generación de incorporaciones destacados.

Figura 2. Diagrama de la incorporación de conocimiento. En este diagrama, se muestran los datos de documentos multimodales de entrada y dos pasos de procesamiento: la fragmentación y la generación de incorporaciones. La fragmentación es un paso de procesamiento previo que se usa para datos complejos antes de la generación de la incorporación. Después de procesar los datos, los embeddings se almacenan en una base de datos de vectores.

Para los casos de uso principales de la incorporación, la consideración clave es cómo transferir y procesar el conocimiento. Esta transferencia puede realizarse por lotes o por transmisión. La fuente de este conocimiento puede variar mucho. Por ejemplo, esta información puede provenir de archivos almacenados en Cloud Storage o de fuentes de transmisión, como Pub/Sub o Google Cloud Managed Service para Apache Kafka.

En el caso de las fuentes de transmisión, los datos en sí pueden ser el contenido sin procesar (por ejemplo, texto sin formato) o URIs que apuntan a documentos. Independientemente de la fuente, la primera etapa suele implicar el preprocesamiento de la información. En el caso del texto sin procesar, esto podría ser mínimo, como la limpieza básica de datos. Sin embargo, para documentos más grandes o contenido más complejo, un paso fundamental es la división en fragmentos. El chunking implica dividir el material de origen en unidades más pequeñas y manejables. La estrategia de fragmentación óptima no está estandarizada y depende de los datos y la aplicación específicos. Las plataformas como Dataflow ofrecen capacidades integradas para controlar diversas necesidades de fragmentación, lo que simplifica esta etapa esencial de procesamiento previo.

Beneficios

La clase MLTransform proporciona los siguientes beneficios:

  • Generar incorporaciones que puedas usar para enviar datos a bases de datos vectoriales o ejecutar inferencias.
  • Transforma tus datos sin tener que escribir código complejo ni administrar bibliotecas subyacentes.
  • Encadenar de manera eficiente varios tipos de operaciones de procesamiento con una interfaz.

Asistencia 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 incorporación de texto:

Casos de uso

Los notebooks de ejemplo demuestran cómo usar MLTransform para casos de uso específicos.

Quiero generar incorporaciones de texto para mi LLM con Vertex AI
Usa la clase MLTransform de Apache Beam con la API de incorporaciones de texto de Vertex AI para generar incorporaciones de texto. Las incorporaciones de texto son una forma de representar texto como vectores numéricos, lo que es necesario para muchas tareas de procesamiento de lenguaje natural (PLN).
Quiero generar incorporaciones de texto para mi LLM con Hugging Face
Usa la clase MLTransform de Apache Beam con los modelos de Hugging Face Hub para generar incorporaciones de texto. El framework de Hugging Face SentenceTransformers usa Python para generar incorporaciones de imágenes, texto y oraciones.
Quiero generar embeddings de texto y transferirlos a AlloyDB para PostgreSQL
Usa Apache Beam, específicamente su clase MLTransform con los modelos de Hugging Face Hub para generar incorporaciones de texto. Luego, usa VectorDatabaseWriteTransform para cargar estos embeddings y los metadatos asociados en AlloyDB para PostgreSQL. En este notebook, se muestra cómo compilar canalizaciones de datos de Beam escalables por lotes y de transmisión para completar una base de datos de vectores de AlloyDB para PostgreSQL. Esto incluye el procesamiento de datos de diversas fuentes, como Pub/Sub o tablas de bases de datos existentes, la creación de esquemas personalizados y la actualización de datos.
Quiero generar incorporaciones de texto y transferirlas a BigQuery
Usa la clase MLTransform de Apache Beam con los modelos de Hugging Face Hub para generar incorporaciones de texto a partir de datos de la aplicación, 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 incorporaciones de oraciones y texto. Luego, estas incorporaciones generadas y sus metadatos se transfieren a BigQuery con el VectorDatabaseWriteTransform de Apache Beam. Además, el notebook muestra búsquedas de similitud de vectores en BigQuery con la transformación de enriquecimiento.

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

Usa MLTransform para la generación de embeddings

Para usar la clase MLTransform para dividir la información en fragmentos y generar embeddings, 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()

¿Qué sigue?