Prosperidad de sistemas de trapo con integridades nómicas

La intersección de inteligencia sintético y el procesamiento de datos ha evolucionado significativamente con el aumento de Vivientes de recuperación de engendramiento sistemas. El trapo multimodal va más allá de los modelos tradicionales que se centran solo en el texto. Integra varios tipos de datos como texto, imágenes, audio y video. Esto permite respuestas más matizadas y conscientes del contexto. Una innovación secreto son las integridades de la visión nómica. Crean un espacio unificado para datos visuales y textuales. Esto permite una interacción perfecta en diferentes formatos. Mediante el uso de modelos avanzados para difundir incrustaciones de reincorporación calidad, el trapo multimodal restablecimiento la recuperación de información. Cerrojo la brecha entre diferentes formularios de contenido. El resultado son experiencias de afortunado más ricas y más informativas.

Objetivos de educación

• Comprenda los fundamentos de los sistemas de engendramiento de recuperación multimodal y sus ventajas sobre el trapo tradicional.
• Explore el papel de las integridades de la visión nómica en la creación de un espacio de incrustación unificado para texto e imágenes.
• Compare incrustaciones de visión nómica con modelos de clip y analice sus puntos de relato de rendimiento.
• Implemente un sistema de trapo multimodal en Python utilizando visión nómica e incrustaciones de texto.
• Aprenda cómo extraer y procesar datos textuales y visuales de PDF para recuperación multimodal.

Este artículo fue publicado como parte del Blogathon de ciencias de datos.

¿Qué es el trapo multimodal?

El rag multimodal representa un avance significativo en la inteligencia sintético. Se friso en sistemas tradicionales de RAG al incorporar diversos tipos de datos, como texto, imágenes, audio y video. A diferencia de los sistemas RAG convencionales que procesan principalmente información textual, el RAG multimodal está diseñado para manejar e integrar múltiples formas de datos simultáneamente. Esta capacidad permite una comprensión más integral y una engendramiento de respuestas que son conscientes del contexto en diferentes modalidades.

Componentes secreto del trapo multimodal

• Ingestión de datos: El proceso comienza con la ingestión de varios tipos de datos a través de procesadores especializados para cada formato. Esto asegura que el sistema pueda validar, robar y ordenar los datos entrantes al tiempo que preserva sus características esenciales.
• Representación vectorial: Se procesan diferentes modalidades utilizando respectivas redes neuronales (por ejemplo, clip para imágenes o BERT para texto) para difundir representaciones o incrustaciones vectoriales unificadas. Estas integridades mantienen relaciones semánticas en diferentes modalidades.
• Almacenamiento de la cojín de datos vectorial: Las integridades generadas se almacenan en bases de datos de vectores optimizadas con técnicas de indexación como HNSW o FAISS para una recuperación válido
• Procesamiento de consultas: Las consultas entrantes se analizan y se transforman en el mismo espacio vectorial que los datos almacenados para determinar las modalidades relevantes y difundir integridades apropiadas para la búsqueda

Incrustaciones de visión nómica

Una innovación significativa en este campo de integridades multimodales es la incorporación de incrustaciones de visión nómica, que crean un espacio de incrustación cohesivo para datos visuales y textuales.

Visión de incrustación nómica V1 y V1.5 Uno y otro son modelos de incrustación de visión de reincorporación calidad desarrollados por Nomic AI, diseñados para compartir el mismo espacio velado que sus modelos de incrustación de texto correspondientes, el texto Nomic Inbred V1 y V1.5, respectivamente. Funciona internamente del mismo espacio que el texto Nomic Insbrit, lo que lo hace admisiblemente adecuado para tareas multimodales, como la recuperación de texto a imagen. Con un codificador de visión que comprende solo 92 millones de parámetros, la visión de incrustación Nomic es muy adecuada para aplicaciones de producción de detención cuerpo, lo que complementa los 137 m de los parámetros de texto de incrustación Nomic.

Los modelos de clip sufren en tareas unimodales

Los modelos multimodales como el clip demuestran capacidades notables de disparo cero en diferentes modalidades. Sin secuestro, los codificadores de texto de Clip luchan con tareas más allá de la recuperación de imágenes, como se ve en puntos de relato como MTEB, que evalúa la efectividad de los modelos de incrustación de texto. La visión de inserción nomic tiene como objetivo invadir estas limitaciones alineando un codificador de visión con el espacio velado de texto de incrustación nomic existente.

Para invadir el tema del bajo rendimiento en tareas unimodales, como la similitud semántica, la visión de incrustación nomic, un codificador de visión, fue entrenado unido con el texto de la incrustación nomic, un codificador de texto con contexto dispendioso. El método de capacitación implicó congelar el codificador de texto y capacitar al codificador de visión en pares de texto de imagen. Este enfoque no solo produjo resultados óptimos, sino que igualmente garantizó la compatibilidad en dirección a a espaldas con los incrustaciones del texto de incrustación nomic.

Pantalla de relato de incrustaciones de visión nómica

Como se mencionó anteriormente, los modelos multimodales existentes como Clip exhiben impresionantes capacidades de disparo cero en diferentes modalidades. Sin secuestro, el rendimiento de los codificadores de texto de Clip es deficiente fuera de tareas como la recuperación de imágenes, como lo demuestran los puntos de relato como MTEB, que evalúa la calidad de los modelos de incrustación de texto. La visión de incrustación Nomic está diseñada específicamente para invadir estas deficiencias alineando un codificador de visión con el espacio velado de texto de incrustación nomic existente. Esta formación da como resultado un espacio velado multimodal unificado que ofrece un rendimiento robusto en la imagen, el texto y las tareas multimodales, como lo demuestran los puntos de relato de Imagenet Zero-Shot, MTEB y DataComp.

Hands on Python Implementación de trapo multimodal con incrustaciones de visión nómica

En este tutorial, construiremos un sistema de RAG multimodal que pueda recuperar eficientemente información de un PDF que contiene contenido textual y visual. Construiremos esto en Google Colab usando T4 GPU (nivel regalado).

Paso 1: Instalación de las bibliotecas necesarias

Instale todas las bibliotecas de Python requeridas, incluidas OpenAi, Qdrant, Transformers, Torch y Pymupdf.

!pip install openai==1.55.3 httpx==0.27.2 
!pip install qdrant_client
!pip install transformers
!pip install transformers torch pillow
!pip install --upgrade nltk
!pip install sentence-transformers
!pip install --upgrade qdrant-client fastembed Pillow
!pip install PyMuPDF

Paso 2: Configuración de la tecla API de OpenAI y la importación de las bibliotecas necesarias

Configure la secreto API de OpenAI e valor bibliotecas esenciales como Pymupdf, PIL, Langchain y OpenAI.

from openai import ChatCompletion
import openai
import os
from openai import AzureOpenAI
from PIL import Image
import torch
import numpy as np
import fitz  # PyMuPDF
import os
import time
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
from openai import ChatCompletion
import openai
import base64
from base64 import b64decode

os.environ("OPENAI_API_KEY") = ''

Configure la secreto API de OpenAI e valor bibliotecas esenciales como Pymupdf, PIL, Langchain y OpenAI.

#images

def extract_images_from_pdf(pdf_path, output_folder):
    pdf_document = fitz.open(pdf_path)
    os.makedirs(output_folder, exist_ok=True)
    #Iterating throught the pages in the PDF
    for page_number in range(len(pdf_document)):
        page = pdf_document(page_number)
        #Function For Getting Images From the PDF Pages
        images = page.get_images(full=True)

        for image_index, img in enumerate(images):
            xref = img(0)
            base_image = pdf_document.extract_image(xref)
            image_bytes = base_image("image")
            image_ext = base_image("ext")
            image_filename = f"page_{page_number+1}_image_{image_index+1}.{image_ext}"
            image_path = os.path.join(output_folder, image_filename)
            with open(image_path, "wb") as image_file:
                image_file.write(image_bytes)
    pdf_document.close()

Use PymUpDF para extraer texto de todas las páginas del PDF y guárdelo en una inventario.

def extract_text_pdf(path):
    """Extracts text from a PDF using PyMuPDF."""
    doc = fitz.open(path)
    text_results = ()
    for page in doc:
        text = page.get_text()
        text_results.append(text)
    return text_results

Paso 5: Guarecer texto e imágenes extraídos de PDF

Guarde las imágenes en el directorio de «prueba» y extraiga el texto para su posterior procesamiento.

def get_contents(pdf_path, output_directory):
  """Extracts text and images from a PDF, saves images, and returns text and elapsed time."""

  extract_images_from_pdf(pdf_path, output_directory)
  text_results=extract_text_pdf(pdf_path)
  return(text_results)
  
pdf_path = "/content/retailcoffee.pdf"
output_directory = "/content/test"
text_results=get_contents(pdf_path, output_directory)

Usamos esto Pdf Eso tiene texto e imágenes o gráficos para probar el trapo multimodal.

Guardamos las imágenes extraídas del PDF utilizando la biblioteca PymUpDF en el directorio «Prueba». En los próximos pasos, cree integridades de estas imágenes para poder recuperar información del futuro en función de una consulta de afortunado.

Paso 6. Datos de texto de Chunking para trapo

Dividido el texto extraído en trozos más pequeños usando RecursIvecharacter de Langchain.

text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=2048,
        chunk_overlap=50,
        length_function=len,
        is_separator_regex=False,
        separators=(
            "nn",
            "n",
            " ",
            ".",
            ",",
            "u200b",  # Zero-width space
            "uff0c",  # Fullwidth comma
            "u3001",  # Ideographic comma
            "uff0e",  # Fullwidth full stop
            "u3002",  # Ideographic full stop
            "",
        ),
    )

doc_texts = text_splitter.create_documents(text_results)

Paso 7: Maniquí de incrustación de texto gnómico y maniquí de incrustación de visión nómica

Cargue el texto y la visión de Nomic que incrustan los modelos utilizando la biblioteca Transformers de Hugging Face.

from transformers import AutoTokenizer, AutoModel

# Load the tokenizer and model
text_tokenizer = AutoTokenizer.from_pretrained("nomic-ai/nomic-embed-text-v1.5", trust_remote_code=True)
text_model = AutoModel.from_pretrained("nomic-ai/nomic-embed-text-v1.5", trust_remote_code=True)

def text_embeddings(text):
    inputs = text_tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    outputs = text_model(**inputs)
    embeddings = outputs.last_hidden_state.mean(dim=1)
    return embeddings(0).detach().numpy()
    
from transformers import AutoModel, AutoProcessor
from PIL import Image
import torch
model = AutoModel.from_pretrained("nomic-ai/nomic-embed-vision-v1.5", trust_remote_code=True)
processor = AutoProcessor.from_pretrained("nomic-ai/nomic-embed-vision-v1.5")

Paso 8: Vivientes de incrustaciones de texto e imágenes para nuestros datos

Convierta el texto e imágenes en integridades del vector para una recuperación válido.

#Text Embeddins
texts_embeded = (text_embeddings(document.page_content) for document in doc_texts)

#Image Embeddings
image_embeddings = ()
for img in image_files:
    try:
        image = Image.open(os.path.join(output_directory, img))
        inputs = processor(images=image, return_tensors="pt")
        with torch.no_grad():
            outputs = model(**inputs)
        embeddings = outputs.last_hidden_state
        if embeddings.size(0) > 0:  # Ensure the batch size is non-zero

            image_embedding = embeddings.mean(dim=1).squeeze().cpu().numpy()
            image_embeddings.append(image_embedding)
        else:
            print(f"No Embeddings For {img}")

    except Exception as e:
        print(e)

#SIZE OF Text & Image Embeddings
text_embeddings_size=len(texts_embeded(0))
image_embeddings_size=len(image_embeddings(0))

Paso 9: Almacenamiento de incrustaciones de texto en Qdrant

QDRANT es una cojín de datos de vectores de código hendido y un motor de búsqueda diseñado para acumular, mandar y consultar de modo válido vectores de reincorporación dimensión. Guardamos nuestras incrustaciones en este DB vectorial.

from qdrant_client import QdrantClient, models

client = QdrantClient(":memory:")

if not client.collection_exists("text1"): #creating a Collection
 client.create_collection(
        collection_name ="text1",
      vectors_config=models.VectorParams(
        size=text_embeddings_size,  # Vector size is defined by used model
        distance=models.Distance.COSINE,
    ),
 )
 
 client.upload_points(
    collection_name="text1",
    points=(
        models.PointStruct(
            id=str(uuid.uuid4()),
            vector=np.array(texts_embeded(idx)),
            payload={
                "metadata": doc.metadata,
                "content": doc.page_content
            }
        )
        for idx, doc in enumerate(doc_texts)
    )
)

Paso 10: Jardín de infantes de imagen de almacenamiento en Qdrant

Guarecer embedidas de imagen en una colección Qdrant separada para la recuperación multimodal.

if not client.collection_exists("images1"):
    client.create_collection(
        collection_name="images1",
        vectors_config=models.VectorParams(
        size=image_embeddings_size,  # Vector size is defined by used model
        distance=models.Distance.COSINE,
    ),
  )
  
# Ensure that image_embeddings are not empty
if len(image_embeddings) > 0:
    client.upload_points(
        collection_name="images1",
        points=(
            models.PointStruct(
                id=str(uuid.uuid4()),  # unique id
                vector= np.array(image_embeddings(idx))  ,
                payload={"image_path": output_directory+'/'+str(image_files(idx))}  # Image path as metadata
            )
            for idx in range(len(image_embeddings))  
    )
else:
    print("No embeddings found")

Paso 11: Creación de un retriever multimodal para recuperar imágenes y texto

Recupere los incrustaciones de texto e imagen más relevantes basados ​​en una consulta de afortunado.

def MultiModalRetriever(query):

    query = text_embeddings(query)

    # Retrieve text hits
    text_hits = client.query_points(
        collection_name="text1",
        query=query,
        limit=3,3
    ).points
    # Retrieve image hits
    Image_hits = client.query_points(
        collection_name="images1",
        query=query,
        limit=5,
    ).points

    return text_hits, Image_hits

Paso 12: Creación de un trapo multimodal usando Langchain

Use Langchain para procesar texto e imágenes recuperados, generando respuestas conscientes de contexto utilizando GPT-4O.

def MultiModalRAG(context,images,user_query,model):  
    # Helper function to encode an image as a base64 string
    def encode_image(image_path):
        if image_path:
            with open(image_path, "rb") as image_file:
                return base64.b64encode(image_file.read()).decode()
        return None


    image_paths = images   
    #three images based on retrived images
    img_base64 = encode_image(image_paths(0))        
    img_base641 = encode_image(image_paths(1))  
    img_base642 = encode_image(image_paths(2))  

    message = HumanMessage(
            content=(
                {"type": "text", "text": "BASED ON RETRIEVED CONTEXT %s ONLY, ANSWER THE FOLLOWING QUERY %s. Context can be tables, texts or Images"%(context,user_query)},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"},
                },
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{img_base641}"},
                },
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{img_base642}"},
                },
            ),)

    model = ChatOpenAI(model=model)    
    response = model.invoke((message))
    return response.content


def RAG(query):
  text_hits, Image_hits=MultiModalRetriever(query)

  retrieved_images=(i.payload('image_path') for i in Image_hits)
  print(retrieved_images)
  answer=MultiModalRAG(text_hits,retrieved_images,query,"gpt-4o")
  return(answer)

Consulta del maniquí

Consultemos ahora nuestro sistema de trapo multimodal con diferentes consultas para probar su capacidad multimodal,

RAG("Revenue of Starbucks in billion dollars of Food in 2020?")

Producción:

'Based on the chart showing Starbucks' revenue by product for 2020, the revenue from
food is approximately $3 billion.'

La respuesta a esta consulta solo está presente en la subsiguiente tabla (Fig. 4) en el Pdf y no en ningún texto. Entonces, nuestro trapo multimodal puede recuperar esta información con precisión.

RAG("Explain what the Ansoff Matrix is for Starbucks.")

Producción:

'The Ansoff Matrix is a strategic tool that helps businesses like Starbucks analyze
their growth strategies. For Starbucks, it can be broken down as follows: 
1. **Market Penetration:** Starbu cks focuses on increasing sales of existing
products in current markets. This includes enhancing the customer experience, leveraging their mobile app for convenience, and promoting existing offerings.
2. **Product Development:** Starbucks introduces new products for existing markets. Examples include launching new beverage options or introducing meatless breakfast
items to adapt to changing consumer preferences.
3. **Market Development:** This involves Starbucks expanding into new geographical
locations or market segments with existing products. It selects high-traffic
locations and creates a consistent brand image and store experience to attract customers.
4. **Diversification:** Introducing entirely new products to new markets. This could
involve Starbuck s exploring areas like offering alcoholic beverages to attract 
different customer demographics. 
Overall, the Ansoff Matrix helps Starbucks strategically plan how to grow and adapt
in various market conditions by focusing on either current or new products and 
markets.

La respuesta a esta consulta igualmente solo está presente en el subsiguiente diagrama (Fig. 3) en el Pdf y no en ningún texto. Entonces, nuestro trapo multimodal puede recuperar esta información con precisión.

RAG("Completo coffee consumption in 2017")

Producción:

'The mundial coffee consumption in 2017 was 161.37 million bags.'

La respuesta a esta consulta igualmente solo está presente en el subsiguiente cuadro (Fig. 1) en el Pdf y no en ningún texto. Entonces, nuestro trapo multimodal puede recuperar esta información con precisión.

Conclusión

La integración de los incrustaciones de la visión nómica en los sistemas de RAG multimodal representa un brinco importante en la IA, lo que permite una interacción perfecta entre los datos visuales y textuales para una mejor comprensión y engendramiento de respuesta. Al exceder las limitaciones vistas en modelos como Clip, Nomic Inquish Vision ofrece un espacio de incrustación unificado, lo que aumenta el rendimiento en tareas multimodales. Este crecimiento allana el camino para experiencias de afortunado más ricas y conscientes de contexto en entornos de producción de detención cuerpo.

Control de espita

• Los sistemas de engendramiento de recuperación multimodal (RAG) integran varios tipos de datos, como texto, imágenes, audio y video, lo que permite futuro más conscientes de contexto y matizadas en comparación con los sistemas de RAG tradicionales centrados solo en el texto.
• Las incrustaciones de la visión nómica juegan un papel secreto al despersonalizar los datos visuales y textuales en un solo espacio de incrustación, mejorando la capacidad del sistema para recuperar y sintetizar información en múltiples modalidades.
• El sistema de RAG multimodal procesa los datos a través de la ingestión especializada, la representación del vector y las técnicas de almacenamiento, asegurando la recuperación válido y las respuestas significativas en diversos formatos de contenido.
• Mientras que los modelos de clip se destacan en capacidades de disparo cero, luchan con tareas unimodales como la similitud semántica. La visión de incrustación nomic aborda esto al alinear los codificadores de visión y texto, mejorando el rendimiento en una amplia variedad de tareas.

Preguntas frecuentes

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se usan a discreción del autor.