Gemini AI: Extracción de datos estructurados con Gemini Pro Vision y Pydantic

AUTOR: DALL-E 3

Introducción

En estos dos artículos (1 y 2) te hablo de la rápida y constante evolución que estamos presenciando en torno a la inteligencia artificial generativa.

Herramientas como el nuevo modelo multimodal de Gemini AI de Google están redefiniendo la manera en que capturamos, interpretamos y utilizamos los datos (que siempre han estado ahí).

Este artículo voy a explorar contigo cómo esta tecnología se puede aplicar en diversos sectores, como por ejemplo el retail, para descubrir tendencias de consumo y extracción de información crucial.

Background

Gemini AI, con sus capacidades de procesamiento de datos multimodal, está demostrado ser una herramienta clave para la extracción de información (no)estructurada. Junto con Pydantic, un framework para la validación de datos y la gestión de configuraciones en Python, proporcionan un potente entorno para el análisis de datos estructurados y no estructurados, facilitando la interpretación y el análisis de grandes volúmenes de información.

Hands-On: Búsqueda en tiempo real con Google Search y extracción de información estructurada utilizando Gemini Pro Vision

Medinte un ejemplo práctico, te muestro cómo realizar búsquedas en Google en tiempo real y extraer datos estructurados utilizando Gemini AI y Pydantic. Este proceso implica la autenticación en Google Colab y la configuración de Vertex AI, y el uso de herramientas de web scraping para recopilar datos. Luego, se demuestra cómo utilizar Gemini AI para formatear y estructurar estos datos, facilitando su análisis y comprensión.

1. Autenticación en Google Cloud. Puedes seguir esta guía.

2. Configuración de Vertex AI. Puedes seguir esta guía.

3. Web Scraping.

En este punto, y a modo de ejemplo, se utiliza la biblioteca html2text que facilita la extracción de datos desde páginas web. Este proceso comienza con la identificación de la URL relevante para la búsqueda de Google. Luego, se envía la solicitud HTTP a esta dirección, obteniendo el contenido HTML de la página. Finalmente, se aplica html2text para convertir el HTML en texto plano, lo que facilita el tratamiento y análisis de los datos recogidos.

import requests
import html2text

def scrape_website(url):
    try:
        # Send an HTTP request to the URL
        response = requests.get(url)

        # Check if the request was successful (status code 200)
        if response.status_code == 200:
            return html2text.html2text(response.text)

        else:
            print(f"Failed to retrieve content. Status code: {response.status_code}")

    except Exception as e:
        print(f"An error occurred: {e}")

Esta metodología es útil para transformar el contenido de las páginas web en información estructurada y lista para ser procesada por modelos como Gemini AI.

Puedes probarlo llamando a la función de esta manera:

# puedes probarlo con culquier URL
search_query = "juguetes%20en%20Cerdanyola%20del%20Vallès%20(Barcelona)"
url = f'https://www.google.com/search?q={search_query}'

google_search_content = scrape_website(url)

google_search_content

Si quieres ver un ejemplo más avanzado, mira este artículo de “Búqueda en tiempo real automatizada con Google Maps y Selenium y este artículo de “Web scraping para extraer información utilizando requests y BeautifulSoup en Python” en dev.to.

4. Uso de Gemini AI para formatear datos.

A continuación te muestro el código para utilizar Gemini AI para procesar el contenido recogido y organizarlo en un esquema JSON predefinido basado en este post “Google Search with Structured Data Extraction”

import vertexai
from vertexai.preview.generative_models import GenerativeModel, Part

def google_search_formated_response(content, max_output_tokens=7815):
  model = GenerativeModel("gemini-pro")

  schema = """
  {
    "places": [
      {
        "name": "",
        "rating": <<float>>,
        "price": "",
        "category": "",
        "address": "",
        "city": "",
        "state": "",
        "zip": "",
        "country": "",
        "phone": "",
        "website": ""
      }
    ]
  }
  """

  responses = model.generate_content(
    f"""Format the below response to the following JSON schema.

    Here's the content:

    {content}

    """,
        generation_config={
            "max_output_tokens": max_output_tokens,
            "temperature": 0,
            "top_p": 1
        },
      stream=True,
      )

  formated_response = []

  for response in responses:
      text = response.candidates[0].content.parts[0].text
      print(text)
      formated_response.append(text)

  return formated_response

formated_response = google_search_formated_response(google_search_content)

Otra manera es utilizando la libería de validación de datos Pydantic. Utilizando esta clase fijamos todavía más la manera en la que queremos que el modelo nos devuelva los datos, incluso el tipo de datos que queramos utilizar. Este código está basado en el notebook “Multi-Modal LLM using Google’s Gemini model for image understanding and build Retrieval Augmented Generation with LlamaIndex”.

# no olvides de configurar tu GOOGLE_API_KEY

import google.generativeai as genai

genai.configure(
    api_key=GOOGLE_API_KEY,
    client_options={"api_endpoint": "generativelanguage.googleapis.com"},
)

# Define the Pydantic Class for the Structured Parser

from pydantic import BaseModel
from PIL import Image
import matplotlib.pyplot as plt


class GoogleLocal(BaseModel):
    name: str
    category: str
    address: str
    contact: str
    hours: str
    rating: float
    price: str
    description: str


google_image_url = "ruta-a-tu-imagen"
image = Image.open(google_image_url).convert("RGB")

plt.figure(figsize=(16, 5))
plt.imshow(image)

En nuestro ejemplo yo voy a utilizar esta imagen:

La imagen correspondería con uno de los resultados de la búsqueda (search_query) que hemos realizado anteriomente. En el punto 3, web scraping, utilizamos la biblioteca html2text para extraer los datos desde páginas web, pero en este caso lo hacemos extrayendo la información no directamente desde un texto, sino utilizando una imagen como input para explorar la capacidad multimodal del modelo Gemini AI.

# Call the Pydantic Program and Generate Structured Output

from llama_index.multi_modal_llms import GeminiMultiModal
from llama_index.program import MultiModalLLMCompletionProgram
from llama_index.output_parsers import PydanticOutputParser

prompt_template_str = """\
    can you summarize what is in the image\
    and return the answer with json format \
"""


def pydantic_gemini(
    model_name, output_class, image_documents, prompt_template_str
):
    gemini_llm = GeminiMultiModal(
        api_key=GOOGLE_API_KEY, model_name=model_name
    )

    llm_program = MultiModalLLMCompletionProgram.from_defaults(
        output_parser=PydanticOutputParser(output_class),
        image_documents=image_documents,
        prompt_template_str=prompt_template_str,
        multi_modal_llm=gemini_llm,
        verbose=True,
    )

    response = llm_program()
    return response

Este código utiliza la biblioteca llama_index para procesar y estructurar la salida de datos de imágenes utilizando el modelo Gemini de Google AI:

1. Se define el prompt mendiante (prompt_template_str). Muy sencillo, básicamente se le dice que resuma lo que ve en la imagen y lo devuelva en formato JSON.
2. La función pydantic_gemini utiliza el nombre del modelo (model_name), una clase (GoogleLocal en nuestro ejemplo) (output_class), imágenes (image_documents) y el prompt.

• Se inicializa GeminiMultiModal con nuestra clave API y el nombre del modelo y se crea un MultiModalLLMCompletionProgram con un PydanticOutputParser para interpretar la salida según la validación de los datos que previamente hemos definido.

from llama_index import SimpleDirectoryReader

google_image_documents = SimpleDirectoryReader(
    "ruta-a-tu-directorio-de-imagenes"
).load_data()

results = []
for img_doc in google_image_documents:
    pydantic_response = pydantic_gemini(
        "models/gemini-pro-vision",
        GoogleLocal,
        [img_doc],
        prompt_template_str,
    )
    
    results.append(pydantic_response)

    print(results)

Finalmente iteramos sobre cada imagen cargada.

Para cada imagen, se llama a la función pydantic_gemini, previamente definida, pasando el modelo Gemini AI ("models/gemini-pro-vision"), una clase de salida (GoogleLocal), la imagen actual y el prompt.

El resultado:

('name', 'Juguettos')
('category', 'Toy Store')
('address', 'Av. de Catalunya, 39 Cerdanyola del Vallés 08193 Barcelona'))
('contact', '+34 934 97 24 87')
('hours', 'Monday-Saturday: 10:00-21:00\nSunday: 11:00-20:00')
('rating', 4.4)
('price', '$')
('description', 'Juguettos es una juguetería ubicada en Cerdanyola del Vallés, Barcelona. 
Ofrece una amplia variedad de juguetes para niños de todas las edades, incluyendo juguetes educativos, juguetes de construcción, juguetes de peluche, videojuegos y mucho más. 
También cuenta con un servicio de entrega a domicilio.')

Conclusión

Con Gemini AI y la capacidad de extraer de datos de manera estructurada estamos abriendo posibilidades para nuevas aplicaciones prácticas. Imagina usar esta tecnología para conocer mejor a tus clientes o para crear apps que respondan a lo que la gente realmente quiere y necesita. Es una mezcla potente que no solo hace más fácil trabajar con muchos datos, sino que también nos acerca a resultados que antes parecían de ciencia ficción (o que como mínimo costaban mucho más de conseguir).

What’s Next, próximos pasos:

• Quick Start con Vertex AI: Paso a Paso para principiantes
• Gemini AI y Llama Index en acción: una demo práctica paso a paso
• Búqueda en tiempo real automatizada con Google Maps y Selenium
• Web scraping para extraer información utilizando requests y BeautifulSoup en Python
• Extracción de datos estructurados con Gemini Pro Vision y Pydantic
• Data mining: extracción de información, topics, keywords y etiquetas

Comparte tu experiencia:

Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:

• GitHub: https://github.com/albertgilopez
• LinkedIn: https://www.linkedin.com/in/albertgilopez/
• Inteligencia Artificial Generativa en español: https://www.codigollm.es/