Compartir a través de

Extracción de entidades mediante el modo de salidas estructuradas de Azure OpenAI

En este artículo, explorará varios ejemplos para extraer diferentes tipos de entidades. En estos ejemplos se muestra cómo crear un esquema de objeto y obtener una respuesta del modelo de Azure OpenAI. Usa Python y el modo de salidas estructuradas de Azure OpenAI.

Nota

En este artículo se usan una o varias plantillas de aplicación de IA de para obtener ejemplos e instrucciones. Las plantillas de aplicación de IA proporcionan implementaciones de referencia bien mantenidas y fáciles de implementar, lo que garantiza un punto de partida de alta calidad para las aplicaciones de inteligencia artificial.

El ejemplo proporciona todo lo que necesita. Incluye la infraestructura y los archivos de Python para configurar una implementación de modelos gpt-4o de Azure OpenAI. Después, puede usarlo para realizar la extracción de entidades con el modo de salidas estructuradas de Azure OpenAI y el SDK de OpenAI de Python.

Siguiendo las instrucciones de este artículo, hará lo siguiente:

Las salidas estructuradas en Azure OpenAI aseguran que las respuestas del modelo de IA sigan un esquema JSON predefinido . Esta característica proporciona varias ventajas clave por:

  • Asegúrese de que las respuestas coinciden con el esquema definido, lo que reduce los errores e incoherencias.
  • Ayudar a convertir los datos no estructurados en formatos bien definidos y estructurados, lo que facilita la integración con otros sistemas.
  • Reducir la necesidad de posprocesamiento, optimizar el uso de tokens y mejorar la eficacia.

Las salidas estructuradas son útiles para llamar a funciones, extraer datos estructurados y crear flujos de trabajo complejos de varios pasos.

Use este mismo enfoque general para la extracción de entidades en muchos tipos de archivo, siempre que se puedan representar en un formulario de texto o imagen.

Nota

Actualmente las salidas estructuradas no están soportadas con:

Diagrama de arquitectura

Diagrama que muestra la identidad administrada de Microsoft Entra que se conecta a los servicios de Azure AI.

Costo

Para mantener los precios lo más bajos posibles en este ejemplo, la mayoría de los recursos usan un nivel de precios Básico o Consumo. Modifique el nivel según sea necesario en función del uso previsto. Para dejar de incurrir en cargos, elimine los recursos cuando haya terminado con el artículo.

Obtenga más información sobre el costo en el repositorio de muestras.

Prerrequisitos

Hay disponible un entorno contenedor de desarrollo con todas las dependencias necesarias para completar este artículo. Puede ejecutar el contenedor de desarrollo en GitHub Codespaces (en un explorador) o localmente mediante Visual Studio Code.

Para usar este artículo, debe cumplir los siguientes requisitos previos:

Apertura de un entorno de desarrollo

Siga estas instrucciones para configurar un entorno de desarrollo preconfigurado con todas las dependencias necesarias para completar este artículo.

GitHub Codespaces ejecuta un contenedor de desarrollo administrado por GitHub con Visual Studio Code para web como interfaz de usuario. Use GitHub Codespaces para el entorno de desarrollo más sencillo. Viene con las herramientas de desarrollo y las dependencias adecuadas preinstaladas para completar este artículo.

Importante

Todas las cuentas de GitHub pueden usar Codespaces durante un máximo de 60 horas gratis cada mes con dos instancias principales. Para obtener más información, consulte Almacenamiento y horas de núcleo incluidas mensualmente en GitHub Codespaces.

Siga estos pasos para crear un nuevo espacio de código de GitHub en la rama main del repositorio de GitHub de Azure-Samples/azure-openai-entity-extraction.

  1. Haga clic con el botón derecho en el botón siguiente y seleccione Abrir enlace en una nueva ventana. Esta acción hace que el entorno de desarrollo y la documentación estén disponibles para su revisión.

    Botón que dice Abrir en GitHub Codespaces.

  2. En la página Crear espacio de código, revise la información y, a continuación, seleccione Crear nuevo espacio de código.

  3. Espere a que se inicie Codespace. Este proceso de inicio puede tardar unos minutos.

  4. En el terminal de la parte inferior de la pantalla, inicie sesión en Azure mediante la CLI para desarrolladores de Azure:

    azd auth login --use-device-code

  5. Abra la dirección URL en el terminal.

  6. Copie el código del terminal y péguelo en la dirección URL que acaba de abrir.

  7. Siga las instrucciones para iniciar sesión en su cuenta de Azure.

Las tareas restantes de este artículo tienen lugar en el contexto de este contenedor de desarrollo.

Implementación y ejecución

El repositorio de ejemplo tiene todos los archivos de código y configuración de una implementación del modelo gpt-4o de Azure OpenAI. También realiza la extracción de entidades mediante el modo de salidas estructuradas y el SDK de Python openai. Siga estos pasos para llevar a cabo el proceso de implementación de ejemplo de extracción de entidades en Azure:

Ejemplo de implementación de extracción de entidades en Azure

  1. Configure la cuenta de OpenAI:

    azd provision

  2. Use la tabla siguiente para responder a cada parámetro:

    Parámetro Respuesta
    Nombre del entorno Manténgalo corto y en minúsculas. Agregue su nombre o alias. Por ejemplo, struct-output. Se usa como parte del nombre del grupo de recursos.
    Suscripción Seleccione la suscripción en la que crear los recursos.
    Ubicación del modelo de OpenAI Seleccione una ubicación cercana a usted en la lista.

    Nota

    Si se produce un error o se agota el tiempo de espera durante la implementación, pruebe a cambiar la ubicación. Puede haber restricciones de disponibilidad para el recurso de OpenAI. Para cambiar la ubicación, ejecute:

    azd env set AZURE_LOCATION "yournewlocationname"

  3. Espere hasta que se implemente la aplicación. La implementación suele tardar entre 5 y 10 minutos en completarse.

Ejecución de los ejemplos de extracción de entidades

El ejemplo incluye los ejemplos siguientes:

Tutorial de ejemplo Por ejemplo, nombreDeArchivo. Descripción
ejemplo 1 basic_azure.py Ejemplo básico que usa un recurso de Azure OpenAI implementado para extraer información de una cadena de entrada.
ejemplo 2 extract_github_issue.py En este ejemplo se captura un problema público de GitHub mediante la API de GitHub y, a continuación, se extraen los detalles.
ejemplo 3 extract_github_repo.py En este ejemplo se captura un archivo Léame público usando la API de GitHub y se extraen los detalles.
ejemplo 4 extract_image_graph.py En este ejemplo se analiza una imagen local de un grafo y se extraen detalles como título, eje, leyenda.
ejemplo 5 extract_image_table.py En este ejemplo se analiza una imagen local con tablas y se extraen datos tabulares anidados.
ejemplo 6 extract_pdf_receipt.py En este ejemplo se analiza un recibo de PDF local mediante el paquete de pymupdf para convertirlo primero en Markdown y, a continuación, extraer los detalles del pedido.
ejemplo 7 extract_webpage.py En este ejemplo se analiza una entrada de blog con el paquete de BeautifulSoup y se extraen metadatos (título, descripción y etiquetas).

Ejecute un ejemplo escribiendo python <example filename>.py o haciendo clic en el botón Ejecutar del archivo abierto.

Exploración de los ejemplos de código

Esta plantilla de aplicación de IA contiene varios ejemplos que resaltan distintos casos de uso de salida estructurados. En las secciones siguientes se explica el código pertinente en cada ejemplo.

Ejemplo 1: Uso de un recurso de Azure OpenAI implementado para extraer información de una cadena de entrada

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para extraer información estructurada de una entrada de texto. Configura la autenticación de Azure, inicializa el cliente de OpenAI, define un modelo pydantic para la salida esperada, envía una solicitud al modelo GPT y valida e imprime la respuesta. Este enfoque garantiza que la información extraída esté bien estructurada y validada, lo que facilita el trabajo con en aplicaciones descendentes.

Definición del modelo de datos

Definir un modelo Pydantic garantiza que la información extraída del servicio Azure OpenAI esté bien estructurada y validada. Los modelos pydantic proporcionan un esquema claro para la salida esperada, lo que ayuda en:

  • Asegurarse de que los datos extraídos coinciden con los tipos y formatos esperados.
  • Reducir los errores e incoherencias aplicando una estructura predefinida.
  • Facilitar el trabajo con los datos extraídos en otras aplicaciones proporcionando un modelo de datos claro y coherente.
  • Ayudar a integrar con otros sistemas mediante la conversión de datos no estructurados en formatos bien definidos y estructurados.

definición del modelo de CalendarEvent

El modelo de CalendarEvent es un modelo Pydantic que define la estructura de la salida esperada del modelo GPT.

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]
  • name: nombre del evento.
  • date: fecha del evento.
  • participants: una lista de los participantes del evento.

Cómo se usa CalendarEvent en la llamada al modelo

El modelo CalendarEvent especifica el formato de respuesta esperado al enviar una solicitud al modelo GPT. Este enfoque garantiza que la información extraída sigue un esquema específico.

El siguiente fragmento de código envía una solicitud al modelo GPT mediante el CalendarEvent para la respuesta:

completion = client.beta.chat.completions.parse(
    model=os.getenv("AZURE_OPENAI_GPT_DEPLOYMENT"),
    messages=[
        {"role": "system", "content": "Extract the event information."},
        {"role": "user", "content": "Alice and Bob are going to a science fair on Friday."},
    ],
    response_format=CalendarEvent,
)

client.beta.chat.completions.parse: envía una solicitud al modelo GPT para analizar el texto de entrada y extraer información.

  • modelo: El modelo GPT a utilizar.
  • messages: Una lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: Formato de respuesta esperado usando el modelo CalendarEvent.

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    rich.print(message.refusal)
else:
    rich.print(message.parsed)

¿Por qué es importante comprobar la denegación?

  • control de errores: el código comprueba si el modelo GPT se negó a procesar la solicitud. Si es así, imprime el mensaje de denegación. Este enfoque le ayuda (o al usuario) a comprender si la extracción se realizó correctamente o si hubo problemas para solucionar.

  • Validación de datos extraídos: el código imprime la respuesta analizada para mostrar la información extraída en un formato legible. Este enfoque ayuda a comprobar que los datos coinciden con la estructura esperada definida por el modelo de CalendarEvent.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

CalendarEvent(name='Science Fair', date='Friday', participants=['Alice', 'Bob'])

Ejemplo 2: Captura de un problema público de GitHub mediante la API de GitHub y, a continuación, extraer detalles

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para extraer información estructurada de un problema de GitHub. Este tutorial solo se centra en el código de ejemplo que trata con la salida estructurada.

Definición del modelo de Issue

El modelo de Issue es un modelo Pydantic que define la estructura de la salida esperada del modelo GPT.

class Issue(BaseModel):
    title: str
    description: str = Field(..., description="A 1-2 sentence description of the project")
    type: IssueType
    operating_system: str
  • title: título de la cuestión.
  • Descripción: una breve descripción del problema.
  • type: tipo de problema de la enumeración IssueType.
  • operating_system: sistema operativo relacionado con el problema.

IssueType Definición de enumeración

La clase IssueType Python es una enumeración que define los valores posibles para el tipo de problema (por ejemplo, Informe de errores, Característica, Documentación, Regresión).

class IssueType(str, Enum):
    BUGREPORT = "Bug Report"
    FEATURE = "Feature"
    DOCUMENTATION = "Documentation"
    REGRESSION = "Regression"

Relación entre Issue y IssueType

El modelo de Issue usa la enumeración IssueType para asegurarse de que el campo type solo contiene valores válidos. Esta relación aplica coherencia y validación en los datos extraídos.

Nota

Aunque el ejemplo 1 se centra en una entrada de texto simple y usa un modelo básico CalendarEvent Pydantic, el ejemplo 2 presenta un modelo de Issue más complejo con enumeraciones para los tipos de problema. Este enfoque garantiza que la información extraída siga los tipos y valores específicos. Muestra cómo controlar datos más detallados y variados al tiempo que mantiene el enfoque de salida estructurado del ejemplo 1.

Captura del problema de GitHub

El siguiente fragmento de código captura el problema de un repositorio de GitHub especificado.

url = "https://api.github.com/repos/Azure-Samples/azure-search-openai-demo/issues/2231"
response = requests.get(url)
if response.status_code != 200:
    logging.error(f"Failed to fetch issue: {response.status_code}")
    exit(1)
issue_body = response.json()["body"]
  • requests.get: envía una solicitud GET para obtener la incidencia de la API de GitHub.
  • response.status_code: comprueba si la solicitud se realizó correctamente.
  • issue_body: extrae el cuerpo del problema de la respuesta JSON.

Cómo se usa Issue en la llamada al modelo

El modelo de Issue se usa para especificar el formato de respuesta esperado al enviar una solicitud al modelo GPT. Este enfoque garantiza que la información extraída sigue un esquema específico.

Envío de una solicitud al modelo GPT

completion = client.beta.chat.completions.parse(
    model=model_name,
    messages=[
        {"role": "system", "content": "Extract the info from the GitHub issue markdown."},
        {"role": "user", "content": issue_body},
    ],
    response_format=Issue,
)
  • modelo: El modelo GPT a utilizar.
  • mensajes: Lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: formato de respuesta esperado mediante el modelo Issue.

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    print(message.refusal)
else:
    print(message.parsed)
  • mensaje: extrae el mensaje de la primera opción en la respuesta.
  • message.refuse: comprueba si el modelo GPT se negó a procesar la solicitud.
  • print(message.refuse): imprime el mensaje de denegación si el modelo rechazó la solicitud.
  • print(message.parsed): imprime la respuesta analizada si la extracción se realizó correctamente.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

Issue(
    title='Bug with groups metadata tag not updating in Azure Deployment',
    description='After setting up the app with authentication and access control turned on, and running necessary scripts, the groups metadata tag does not update with group IDs.',
    type=<IssueType.BUGREPORT: 'Bug Report'>,
    operating_system='Windows 10'
)

Ejemplo 3: Captura de un archivo LÉAME público mediante la API de GitHub y, a continuación, extraer detalles

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para obtener información estructurada del archivo LÉAME de un repositorio de GitHub. Este tutorial solo se centra en el código de ejemplo que trata con la salida estructurada.

Cómo RepoOverview usa los otros modelos definidos

El modelo de RepoOverview usa las enumeraciones Language, AzureServicey Framework para definir un esquema estructurado y validado para la información extraída. Este modelo se usa en la llamada al modelo GPT para asegurarse de que la respuesta cumple el formato esperado, proporcionando seguridad de tipos, validación y legibilidad. A continuación, el script analiza, valida e imprime la información extraída, lo que facilita el trabajo con aplicaciones posteriores.

definición del modelo de RepoOverview

El modelo de RepoOverview es un modelo Pydantic que define la estructura de la salida esperada del modelo GPT. Usa los otros modelos definidos (Language, AzureServicey Framework) para asegurarse de que la información extraída se adhiere a enumeraciones y tipos específicos.

class RepoOverview(BaseModel):
    name: str
    description: str = Field(..., description="A 1-2 sentence description of the project")
    languages: list[Language]
    azure_services: list[AzureService]
    frameworks: list[Framework]
  • nombre: una cadena que representa el nombre del repositorio.
  • descripción: una cadena que proporciona una breve descripción del proyecto.
  • lenguajes: una lista de valores de enumeración Language, que representan los lenguajes de programación usados en el proyecto.
  • azure_services: una lista de AzureService valores de enumeración, que representan los servicios de Azure usados en el proyecto.
  • frameworks: lista de valores de enumeración de Framework, que representan los marcos usados en el proyecto.

Enumeraciones usadas en RepoOverview

  • Language: define los valores posibles para los lenguajes de programación.

    class Language(str, Enum):
    JAVASCRIPT = "JavaScript"
    PYTHON = "Python"
    DOTNET = ".NET"

  • AzureService: define los valores posibles para los servicios de Azure.

    class AzureService(str, Enum):
    AIFOUNDRY = "AI Foundry"
    AISEARCH = "AI Search"
    POSTGRESQL = "PostgreSQL"
    COSMOSDB = "CosmosDB"
    AZURESQL = "Azure SQL"

  • Framework: define los valores posibles para los marcos de trabajo.

    class Framework(str, Enum):
    LANGCHAIN = "Langchain"
    SEMANTICKERNEL = "Semantic Kernel"
    LLAMAINDEX = "Llamaindex"
    AUTOGEN = "Autogen"
    SPRINGBOOT = "Spring Boot"
    PROMPTY = "Prompty"

Nota

El ejemplo 3 se basa en el ejemplo 2 mediante la introducción de modelos más complejos (RepoOverview) y enumeraciones (Language, AzureService, Framework) para asegurarse de que la información extraída sigue valores y tipos específicos. En el ejemplo 3 se muestra cómo controlar datos más detallados y variados, al tiempo que se mantiene el enfoque de salida estructurado del ejemplo 2.

Cómo se usa RepoOverview en la llamada al modelo

El modelo RepoOverview especifica el formato de respuesta esperado al enviar una solicitud al modelo GPT. Este enfoque garantiza que la información extraída sigue un esquema específico.

  • model: modelo GPT que se va a usar.
  • messages: Una lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: el formato de respuesta esperado mediante el modelo de RepoOverview.
completion = client.beta.chat.completions.parse(
    model=model_name,
    messages=[
        {
            "role": "system",
            "content": "Extract the info from the GitHub issue markdown.",
        },
        {"role": "user", "content": readme_content},
    ],
    response_format=RepoOverview,
)

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    print(message.refusal)
else:
    print(message.parsed)
  • mensaje: extrae el mensaje de la primera opción en la respuesta.
  • message.refuse: comprueba si el modelo GPT se negó a procesar la solicitud.
  • print(message.refuse): imprime el mensaje de denegación si el modelo rechazó la solicitud.
  • print(message.parsed): imprime la respuesta analizada si la extracción se realizó correctamente.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

RepoOverview(
    name='Job Finder Chatbot with RAG',
    description='A chatbot application aimed at helping users find job opportunities and get relevant answers using Retrieval-Augmented Generation (RAG), leveraging Azure services for efficient search results.',
    languages=[<Language.JAVASCRIPT: 'JavaScript'>],
    azure_services=[<AzureService.AISTUDIO: 'AI Studio'>, <AzureService.AISEARCH: 'AI Search'>, <AzureService.POSTGRESQL: 'PostgreSQL'>],
    frameworks=[<Framework.SPRINGBOOT: 'Spring Boot'>]
)

Ejemplo 4: Análisis de una imagen local de un grafo y extracción de detalles como título, eje y leyenda

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para obtener información estructurada de una imagen de un grafo. El modelo Graph define la estructura de salida esperada, asegurándose de que los datos están bien estructurados y validados. El script convierte la imagen en un URI codificado en base64, lo envía al modelo GPT y comprueba la respuesta con el modelo de Graph. Este enfoque garantiza que la información sea confiable y fácil de usar, proporcionando seguridad de tipos y legibilidad.

Definición del modelo de Graph

El modelo de Graph es un modelo Pydantic que define la estructura de la salida esperada del modelo GPT.

class Graph(BaseModel):
    title: str
    description: str = Field(..., description="1 sentence description of the graph")
    x_axis: str
    y_axis: str
    legend: list[str]
  • título: una cadena que muestra el título del gráfico.
  • descripción: una cadena que proporciona una breve descripción del gráfico.
  • x_axis: cadena que muestra la etiqueta del eje X.
  • y_axis: cadena que muestra la etiqueta del eje Y.
  • legend: una lista de cadenas que muestra las entradas de leyenda del gráfico.

Nota

El uso de imágenes como entrada necesita pasos adicionales para codificar y especificar el tipo de contenido, pero el proceso general es similar al uso de texto para la salida estructurada.

Preparación de la imagen para la entrada

Para usar una imagen como entrada para la salida estructurada, el script convierte la imagen en un URI codificado en base64. Este enfoque permite que la imagen se envíe como parte de la solicitud al modelo GPT.

def open_image_as_base64(filename):
    with open(filename, "rb") as image_file:
        image_data = image_file.read()
    image_base64 = base64.b64encode(image_data).decode("utf-8")
    return f"data:image/png;base64,{image_base64}"

image_url = open_image_as_base64("example_graph_treecover.png")
  • open_image_as_base64: una función que lee un archivo de imagen, la codifica en base64 y la devuelve como un URI de datos.
  • image_url: el URI codificado en base64 de la imagen, que se usa como entrada para el modelo GPT.

Nota

El ejemplo 4 se basa en el ejemplo 3 mediante la ampliación del concepto de extracción de información estructurada de orígenes de texto a la extracción de detalles de imágenes. En el ejemplo 4 se muestra cómo controlar los datos visuales mediante la conversión de una imagen de grafo a un URI codificado en base64 y su envío al modelo GPT. En el ejemplo 4 se presenta el Graph modelo Pydantic para asegurarse de que la información extraída de la imagen está bien estructurada y validada, similar al enfoque usado para el texto en el ejemplo 3.

Envío de una solicitud al modelo GPT

El script envía una solicitud al modelo GPT para extraer información de la imagen mediante salidas estructuradas. El modelo de Graph se especifica como formato de respuesta esperado. Este enfoque garantiza que la información extraída sigue un esquema específico.

completion = client.beta.chat.completions.parse(
    model=model_name,
    messages=[
        {"role": "system", "content": "Extract the information from the graph"},
        {
            "role": "user",
            "content": [
                {"image_url": {"url": image_url}, "type": "image_url"},
            ],
        },
    ],
    response_format=Graph,
)
  • model: modelo GPT que se va a usar.
  • messages: Una lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: el formato de respuesta esperado mediante el modelo de Graph.

Uso de imágenes para la entrada frente al uso de texto

El uso de imágenes como entrada para la salida estructurada difiere del uso de texto de varias maneras:

  • Formato de Entrada: Convierta las imágenes en un URI codificado en base64 antes de enviarlas al modelo GPT, y el texto se puede enviar directamente.
  • tipo de contenido: debe especificar el tipo de contenido para las imágenes como image_url, mientras que el texto se envía como texto sin formato.
  • Procesamiento: el modelo GPT procesa imágenes de forma diferente del texto, la extracción de información visual y la conversión en datos estructurados basados en el esquema proporcionado.

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    print(message.refusal)
else:
    print(message.parsed)
  • mensaje: extrae el mensaje de la primera opción en la respuesta.
  • message.refuse: comprueba si el modelo GPT se negó a procesar la solicitud.
  • print(message.refuse): imprime el mensaje de denegación si el modelo rechazó la solicitud.
  • print(message.parsed): imprime la respuesta analizada si la extracción se realizó correctamente.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

Graph(
    title='Global tree cover: annual loss',
    description='This graph shows the annual loss of global tree cover by region from 2000 to 2020.',
    x_axis='Year (2000-2020)',
    y_axis='Thousand square kilometers/miles of tree cover lost',
    legend=['Boreal', 'Temperate', 'Subtropical', 'Tropical']
)

Ejemplo 5: Análisis de una imagen local con tablas y extracción de datos tabulares anidados

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para extraer información estructurada de una imagen de una tabla. En el ejemplo se convierte la imagen en un URI codificado en base64, se envía al modelo GPT y se valida la respuesta en el modelo de PlantInventory. Los modelos Plant y PlantInventory definen la estructura de salida esperada, lo que garantiza que los datos extraídos están bien estructurados y validados.

Definir los modelos de Plant y PlantInventory

Los modelos Plant y PlantInventory son modelos Pydantic que definen la estructura de la salida esperada del modelo GPT. Este enfoque garantiza que la información extraída sigue un esquema específico.

  • Planta: representa entradas vegetales individuales con campos para especies, nombre común, cantidad, tamaño, precio, condado y notas.

    class Plant(BaseModel):
    species: str
    common_name: str
    quantity: int
    size: str
    price: float
    county: str
    notes: str
    • species: la especie de la planta.
    • common_name: nombre común de la planta.
    • quantity: El número de plantas.
    • size: tamaño de la planta.
    • price: el precio de la planta.
    • condado: el condado donde se encuentra la planta.
    • notes: cualquier otra nota sobre la planta.

  • PlantInventory: representa el inventario general, clasificando las plantas en listas de anuales, bulbos y gramíneas.

    class PlantInventory(BaseModel):
    annuals: list[Plant]
    bulbs: list[Plant]
    grasses: list[Plant]
    • annuals: una lista de objetos de Plant que son anuales.
    • bombillas: una lista de objetos Plant que son bombillas.
    • grasses: una lista de objetos Plant que son hierbas.

Cómo PlantInventory usa el modelo de Plant

El modelo PlantInventory agrupa varios objetos Plant en listas. Cada categoría (anuales, bulbos, gramíneas) es una lista de Plant objetos. Esta estructura ayuda al modelo a organizar y verificar los datos de la planta.

Preparación de la imagen para la entrada

Para usar una imagen como entrada, el siguiente fragmento de código convierte la imagen en un URI codificado en base64. Este enfoque permite enviar la imagen en la solicitud al modelo GPT.

def open_image_as_base64(filename):
    with open(filename, "rb") as image_file:
        image_data = image_file.read()
    image_base64 = base64.b64encode(image_data).decode("utf-8")
    return f"data:image/png;base64,{image_base64}"

image_url = open_image_as_base64("example_table_plants.png")
  • open_image_as_base64: una función que lee un archivo de imagen, la codifica en base64 y la devuelve como un URI de datos.
  • image_url: el URI codificado en base64 de la imagen, que se usa como entrada para el modelo GPT.

Nota

En el ejemplo 5 se muestra cómo extraer información estructurada de una imagen de una tabla. Presenta los modelos de Plant y PlantInventory Pydantic para definir la estructura de salida esperada, lo que garantiza que los datos extraídos están bien organizados y validados. Este enfoque muestra cómo controlar datos más detallados y anidados al tiempo que mantiene el método de salida estructurado usado en el ejemplo 4.

Utilizar modelos en la llamada al modelo GPT

El siguiente fragmento de código envía una solicitud al modelo GPT para extraer información de una imagen de una tabla mediante salidas estructuradas. El modelo PlantInventory se especifica como el formato de respuesta esperado, lo que garantiza que los datos extraídos se estructuran según el esquema definido.

Envío de una solicitud al modelo GPT

completion = client.beta.chat.completions.parse(
    model=model_name,
    messages=[
        {"role": "system", "content": "Extract the information from the table"},
        {
            "role": "user",
            "content": [
                {"image_url": {"url": image_url}, "type": "image_url"},
            ],
        },
    ],
    response_format=PlantInventory,
)
  • model: modelo GPT que se va a usar.
  • messages: Una lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: el formato de respuesta esperado mediante el modelo de PlantInventory.

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    print(message.refusal)
else:
    print(message.parsed)
  • mensaje: extrae el mensaje de la primera opción en la respuesta.
  • message.refuse: comprueba si el modelo GPT se negó a procesar la solicitud.
  • print(message.refuse): imprime el mensaje de denegación si el modelo rechazó la solicitud.
  • print(message.parsed): imprime la respuesta analizada si la extracción se realizó correctamente.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

PlantInventory(
    annuals=[
        Plant(species='Centromadia pungens', common_name='Common tarweed', quantity=8, size='4"S', price=1.83, county='Unknown', notes='75% off sale'),
        Plant(species='Epilobium densiflorum', common_name='Dense Spike-primrose', quantity=3, size='4"S', price=3.65, county='San Mateo', notes='50% off sale'),
        Plant(species='Eschscholzia caespitosa', common_name='Tufted Poppy', quantity=119, size='D-16S', price=3.6, county='Unknown', notes='50% off sale'),
        Plant(species='Eschscholzia californica', common_name='California poppy', quantity=85, size='D-16S', price=3.6, county='Bay Area', notes='50% off sale'),
        Plant(species="Eschscholzia californica 'Purple Gleam'", common_name='Purple Gleam Poppy', quantity=2, size='D-16S', price=3.6, county='Unknown', notes='50% off sale'),
        Plant(species='Eschscholzia californica var. maritima', common_name='Coastal California Poppy', quantity=137, size='D-16S', price=3.6, county='Unknown', notes='50% off sale'),
        Plant(species='Madia elegans', common_name='Tarweed', quantity=6, size='4"S', price=1.83, county='Unknown', notes='75% off sale'),
        Plant(species='Menzelia lindleyi', common_name="Lindley's Blazing Star", quantity=35, size='4"S', price=3.65, county='Unknown', notes='50% off sale'),
        Plant(species='Symphyotrichum subulatum', common_name='Slim marsh aster', quantity=10, size='D-16S', price=5.4, county='Contra Costa', notes='25% off sale'),
        Plant(species='Trichostema lanceolatum', common_name='Vinegar weed', quantity=11, size='D-16S', price=5.4, county='Contra Costa', notes='25% off sale'),
        Plant(species='Trichostema lanceolatum', common_name='Vinegar weed', quantity=20, size='D-16S', price=5.4, county='Stanislaus', notes='25% off sale')
    ],
    bulbs=[
        Plant(species='Brodiaea californica', common_name='California brodiaea', quantity=31, size='D-16', price=7.3, county='Bay Area', notes=''),
        Plant(species='Chlorogalum pomeridianum', common_name='Soap plant', quantity=20, size='1-Gal', price=15.7, county='E. Marin', notes=''),
        Plant(species='Epipactis gigantea', common_name='Stream orchid', quantity=19, size='1-Gal', price=15.7, county='Unknown', notes=''),
        Plant(species='Wyethia angustifolia', common_name='Narrowleaf mule ears', quantity=31, size='D-16', price=7.3, county='Marin', notes=''),
        Plant(species='Wyethia angustifolia', common_name='Narrowleaf mule ears', quantity=43, size='D-16', price=7.3, county='Sonoma', notes=''),
        Plant(species='Wyethia angustifolia', common_name='Narrowleaf mule ears', quantity=2, size='D-40', price=10.9, county='Sonoma', notes=''),
        Plant(species='Wyethia mollis', common_name="Woolly Mule's Ear's", quantity=2, size='D-40', price=10.9, county='Sonoma', notes='')
    ],
    grasses=[
        Plant(species='Agrostis pallens', common_name='Thingrass', quantity=564, size='StubS', price=0.58, county='Unknown', notes='75% off sale'),
        Plant(species='Anthoxanthum occidentale', common_name='Vanilla grass', quantity=146, size='Stub', price=2.3, county='Unknown', notes=''),
        Plant(species='Bouteloua gracilis', common_name='Blue grama', quantity=111, size='StubS', price=1.15, county='Unknown', notes='50% off sale'),
        Plant(species='Bouteloua gracilis', common_name='Blue grama', quantity=57, size='D-16S', price=5.4, county='Unknown', notes='25% off sale')
    ]
)

Ejemplo 6: Análisis de una recepción de PDF local mediante la conversión a Markdown y, a continuación, la extracción de detalles del pedido

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para extraer información estructurada de un recibo pdf. Los modelos Item y Receipt definen la estructura de salida esperada, lo que garantiza que los datos están bien estructurados y validados. El ejemplo convierte el PDF en texto markdown, lo envía al modelo GPT y comprueba la respuesta en el modelo de Receipt. El uso de archivos PDF como entrada necesita pasos adicionales para la extracción y conversión de contenido, pero el proceso es similar al uso de texto para la salida estructurada.

Extracción de archivos PDF

De forma similar al uso de imágenes como entrada, se extrae el PDF como texto. Puede usar un servicio hospedado como azure Document Intelligence o un paquete de Python local, como pymupdf.

Uso de archivos PDF para la entrada frente al uso de texto

El uso de archivos PDF como entrada para la salida estructurada difiere del uso de texto de varias maneras:

  • Formato de entrada: Convierta archivos PDF en texto de markdown antes de enviarlos al modelo GPT. El texto se puede enviar directamente.
  • Extracción de Contenido: Extraer y convertir el contenido del PDF a formato markdown que pueda ser procesado por el modelo GPT.
  • Processing: el modelo GPT procesa el texto extraído del PDF y lo convierte en datos estructurados basados en el esquema proporcionado.

Definir los modelos de Item y Receipt

Los modelos Item y Receipt son modelos Pydantic que definen la estructura de la salida esperada del modelo GPT. Este enfoque garantiza que la información extraída sigue un esquema específico.

  • item: representa elementos individuales en el recibo con campos para el nombre del producto, el precio y la cantidad.

    class Item(BaseModel):
    product: str
    price: float
    quantity: int
    • producto: el nombre del producto.
    • price: el precio del producto.
    • cantidad: la cantidad del producto.

  • recibo: representa el recibo general, incluidos los campos del importe total, el costo de envío, el método de pago, una lista de artículos y el número de pedido. El modelo de Receipt usa el modelo de Item para representar un recibo estructurado con información detallada sobre cada elemento.

    class Receipt(BaseModel):
    total: float
    shipping: float
    payment_method: str
    items: list[Item]
    order_number: int
    • total: el importe total del recibo.
    • shipping: el coste de envío.
    • payment_method: método de pago utilizado.
    • items: una lista de los objetos Item que aparecen en el recibo.
    • order_number: número de pedido.

Nota

El ejemplo 6 se basa en el ejemplo 5 mediante la extensión del concepto de extracción de información estructurada de imágenes para controlar archivos PDF. En el ejemplo 6 se muestra un paso adicional que convierte el archivo PDF en texto markdown como entrada en el modelo GPT, al tiempo que mantiene el método de salida estructurado usado en el ejemplo 5.

Utilizar los modelos durante la llamada al modelo GPT

En el ejemplo se envía una solicitud al modelo GPT para extraer información de un recibo PDF mediante salidas estructuradas. El modelo Receipt se especifica como el formato de respuesta esperado, lo que garantiza que los datos extraídos se estructuran según el esquema definido.

completion = client.beta.chat.completions.parse(
    model=model_name,
    messages=[
        {"role": "system", "content": "Extract the information from the receipt"},
        {"role": "user", "content": md_text},
    ],
    response_format=Receipt,
)
  • model: modelo GPT que se va a usar.
  • messages: Una lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: formato de respuesta esperado utilizando el modelo Receipt.

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    print(message.refusal)
else:
    print(message.parsed)
  • mensaje: extrae el mensaje de la primera opción en la respuesta.
  • message.refuse: comprueba si el modelo GPT se negó a procesar la solicitud.
  • print(message.refuse): imprime el mensaje de denegación si el modelo rechazó la solicitud.
  • print(message.parsed): imprime la respuesta analizada si la extracción se realizó correctamente.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

Receipt(total=242.05, shipping=0.0, payment_method='Credit Card', items=[Item(product='Die Cut ID: 158484 • 3 × 3 • Lamination: Glossy • Shape: Contour', price=242.05, quantity=500)], order_number=43962)

Ejemplo 7: Análisis de una entrada de blog y extracción de metadatos

En este ejemplo se muestra cómo usar el servicio Azure OpenAI para extraer información estructurada de una entrada de blog. El modelo de BlogPost define la estructura de salida esperada, lo que garantiza que los datos extraídos están bien estructurados y validados. En el ejemplo se captura la página web, se extrae el contenido pertinente, se envía al modelo GPT y se valida la respuesta con el modelo de BlogPost.

Uso de páginas web para la entrada frente al uso de texto

El uso de páginas web como entrada para la salida estructurada difiere del uso de texto de varias maneras:

  • Formato de Entrada: Capturar y analizar páginas web para extraer contenido relevante antes de enviarlas al modelo GPT. El texto se puede enviar directamente.
  • extracción de contenido: extraiga y convierta el contenido de la página web en un formato de texto que el modelo GPT pueda procesar.
  • Processing: el modelo GPT procesa el texto extraído de la página web y lo convierte en datos estructurados basados en el esquema proporcionado.

Definición del modelo de BlogPost

El modelo de BlogPost es un modelo Pydantic que define la estructura de la salida esperada del modelo GPT. Este enfoque garantiza que la información extraída sigue un esquema específico.

class BlogPost(BaseModel):
    title: str
    summary: str = Field(..., description="A 1-2 sentence summary of the blog post")
    tags: list[str] = Field(..., description="A list of tags for the blog post, like 'python' or 'openai'")
  • título: título de la entrada de blog.
  • resumen: breve resumen de la entrada de blog.
  • etiquetas: etiquetas asociadas a la entrada de blog.

Prepare la página web para la entrada

Para usar una página web como entrada para la salida estructurada, el siguiente fragmento de código captura el contenido de la página web y extrae las partes pertinentes (título y cuerpo) mediante la biblioteca de Python BeautifulSoup. Este proceso prepara el contenido de la página web que se enviará al modelo GPT.

url = "https://blog.pamelafox.org/2024/09/integrating-vision-into-rag-applications.html"
response = requests.get(url)
if response.status_code != 200:
    print(f"Failed to fetch the page: {response.status_code}")
    exit(1)
soup = BeautifulSoup(response.content, "html.parser")
post_title = soup.find("h3", class_="post-title")
post_contents = soup.find("div", class_="post-body").get_text(strip=True)
  • requests.get: envía una solicitud GET para capturar el contenido de la página web.
  • BeautifulSoup: analiza el contenido HTML de la página web.
  • post_title: extrae el título de una entrada de blog.
  • post_contents: extrae el cuerpo del artículo de blog".

Nota

El ejemplo 7 se basa en el ejemplo 6 mediante la extensión del concepto de extracción de información estructurada de archivos PDF para controlar páginas web. Este enfoque muestra cómo controlar el contenido web mediante el análisis de la página web con BeautifulSoup. A continuación, el contenido analizado se envía al modelo GPT y devuelve la salida estructurada como el modelo de BlogPost.

Uso de BlogPost en la llamada al modelo

El siguiente fragmento de código envía una solicitud al modelo GPT para extraer información del texto de la página web preparada (post_title y post_contents) mediante salidas estructuradas. El modelo BlogPost se especifica como el formato de respuesta esperado, lo que garantiza que los datos extraídos se estructuran según el esquema definido.

completion = client.beta.chat.completions.parse(
    model=model_name,
    messages=[
        {"role": "system", "content": "Extract the information from the blog post"},
        {"role": "user", "content": f"{post_title}\n{post_contents}"},
    ],
    response_format=BlogPost,
)
  • model: modelo GPT que se va a usar.
  • messages: Una lista de mensajes para el modelo. El mensaje del sistema proporciona instrucciones y el mensaje de usuario tiene la dirección URL de la imagen.
  • response_format: el formato de respuesta esperado mediante el modelo de BlogPost.

Análisis y validación de la respuesta

El siguiente fragmento de código controla la respuesta del modelo GPT. Primero extrae el mensaje de la respuesta. A continuación, comprueba si el modelo se negó a procesar la solicitud. Si hay una negativa, imprime el mensaje de denegación. De lo contrario, imprime la respuesta analizada, que contiene la información estructurada extraída. Este enfoque garantiza que el script pueda controlar las respuestas correctas y incorrectas del modelo GPT.

message = completion.choices[0].message
if (message.refusal):
    print(message.refusal)
else:
    print(message.parsed)
  • mensaje: extrae el mensaje de la primera opción en la respuesta.
  • message.refuse: comprueba si el modelo GPT se negó a procesar la solicitud.
  • print(message.refuse): imprime el mensaje de denegación si el modelo rechazó la solicitud.
  • print(message.parsed): imprime la respuesta analizada si la extracción se realizó correctamente.

Visualización de la respuesta

La respuesta analizada debe ser similar al fragmento de código siguiente:

BlogPost(
    title='Integrating Vision into RAG Applications',
    summary='This blog post discusses the integration of vision into Retrieval Augmented Generation (RAG) applications, allowing models to utilize image sources alongside text. It introduces multimodal LLMs and embedding models via Azure, demonstrating how these enable RAG to process both text and images, improving responses to queries that involve image data.',
    tags=['RAG', 'LLM', 'Azure', 'AI', 'Multimodal', 'OpenAI', 'GPT-4', 'Machine Learning', 'Image Processing']
)

Limpieza de recursos

Limpieza de recursos de Azure

Los recursos de Azure que creó en este artículo se facturan a la suscripción de Azure. Si no espera necesitar estos recursos en el futuro, elimínelos para evitar incurrir en más cargos.

Para eliminar los recursos de Azure y quitar el código fuente, ejecute el siguiente comando de la CLI para desarrolladores de Azure:

azd down --purge

Limpieza de GitHub Codespaces

La eliminación del entorno de GitHub Codespaces le ayuda a maximizar la cantidad de derechos de horas gratuitas por núcleo que obtiene para su cuenta.

Importante

Para obtener más información sobre los derechos de la cuenta de GitHub, consulte Almacenamiento y horas de núcleo incluidas mensualmente en GitHub Codespaces.

  1. Inicie sesión en el panel de GitHub Codespaces.

  2. Busque el codespace que se ejecuta actualmente procedente del repositorio de GitHub Azure-Samples//azure-openai-entity-extraction.

  3. Abra el menú contextual del espacio de código y seleccione Eliminar.

Obtener ayuda

Registre el problema en la página de problemas del repositorio.

Recursos