Resumir PDF con Python y OpenAI

Actualmente, los documentos PDF son una parte fundamental para el intercambio de información. Siendo un formato omnipresente. Es normal encontrarse con ellos en una amplia gama de contextos como los informes empresariales, los documentos académicos y la publicación de normativa. Por ello es habitual encontrarse con la necesidad de extraer la información relevante de miles de páginas en formato PDF. Una tarea que, incluso con las herramientas de búsqueda de los lectores de PDF, es tediosa. Los modelos grandes de lenguaje (LLM) pueden ser de gran ayuda en estos casos, pudiendo leer y resumir PDF con Python de miles de páginas en pocos segundos. En esta entrada, se mostrará como se puede usar Python y el API de OpenAI para resumir PDF y preguntar sobre el contenido de este.

Instalar e importar las bibliotecas necesarias

Antes de poder resumir en PDF con Python es necesario instalar las bibliotecas necesarias para ello. Generalmente será necesario instalar nltk y las diferentes partes de langchain que facilitan en trabajo con documentos de texto. Todas estas librerías, como es habitual en Python, se pueden instalar desde línea de comandos con pip. Generalmente la siguiente línea debería ser suficiente.

pip install langchain langchain_openai unstructured "unstructured[pdf]"

Ahora en Python se pueden importar las librerías y asignar el API Key de OpenAI para poder acceder a GPT.

import langchain
from langchain import VectorDBQA
from langchain.vectorstores import Chroma
from langchain.document_loaders import UnstructuredFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, OpenAI
import nltk

nltk.download("punkt")

OPENAI_API_KEY = "MY-OPENAI-KEY"

En este código se debe reemplazar MY-OPENAI-KEY por la clave que se obtiene en la web de OpenAI como se explica en esta entrada.

Cargar el archivo PDF y dividirlo en fragmentos

Una vez importadas las librerías se puede usar la clase UnstructuredFileLoader para cargar en memoria el archivo PDF que se desea analizar. Debido a que los documentos PDF suelen ser extensos, es necesario dividir estos en fragmentos más pequeños para su análisis. Lo que se puede conseguir con la clase CharacterTextSplitter, lo que dividirá el documento en textos de tamaño más manejables. Esto es lo que se muestra en el siguiente código.

# Nombre del archivo PDF a cargar
filename = 'document.pdf'

# Importación del archivo PDF
loader = UnstructuredFileLoader(filename)
documents= loader.load()

# División del archivo PDF en partes
text_splitter = CharacterTextSplitter(chunk_size=800, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

Preparar el modelo y los embeddings

En esta parte es en donde entra en juego el API de OpenAI. Se utilizan los embeddings proporcionados por OpenAI para asociarlos con el texto del PDF y luego se indicará un modelo de lenguaje.

embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
doc_search = Chroma.from_documents(texts, embeddings)
chain = VectorDBQA.from_chain_type(llm=OpenAI(api_key=OPENAI_API_KEY),
                                   chain_type="stuff",
                                   vectorstore=doc_search)

Crear una consulta y obtener una respuesta

Finalmente, el modelo ya está listo para realizar consultas sobre el PDF. Solamente se tienen que escribir la pregunta en leguaje natural y esperar la respuesta del modelo LLM. Por ejemplo, en nuestro caso se ha cargado el libro de Richard S. Sutton y Andrew G. Barto y se le ha preguntado que es Q-Learning.

query = "Can you summarize what the book says about Q-Learning?"
chain.run(query)

' The book presents Q-learning as a solution to the reinforcement learning problem, where the agent learns how to behave in order to achieve a goal through interactions with its environment. Q-learning is a method for estimating the optimal action-value function, Q, which approximates the best possible actions to take in a given state. The book outlines the Q-learning algorithm and its convergence properties, and also discusses its applications in various fields such as biology and other real-world scenarios.'

Incluso, se le puede preguntar al modelo que resuma la respuesta en otro idioma.

query = "¿Puedes resumir lo que dice el libro sobre Q-Learning en español?"
chain.run(query)

' El libro presenta el concepto de Q-Learning como uno de los métodos básicos para resolver problemas de aprendizaje por refuerzo. También menciona que R-Learning es una variante de Q-Learning y que se ha estudiado en la literatura bajo diferentes nombres, como el caso de maximizar la "recompensa promedio por paso de tiempo" o el "caso de recompensa promedio". Además, el libro menciona que el ejemplo de control de acceso en la cola fue sugerido por el trabajo de Carlström y Nordström.'

Una capacidad que facilita poder obtener información y resumir documentos PDF que este en un idioma que no conozcamos.

Crear una clase para preguntar sobre un documento

Ahora, se puede crear una clase que cargue el PDF, prepare los datos y nos de un método sencillo para preguntar sobre el contenido de los PDF. Una posible implementación de esta clase en la que se muestra en el siguiente código.

import langchain
import nltk
from langchain import VectorDBQA
from langchain.vectorstores import Chroma
from langchain.document_loaders import UnstructuredFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, OpenAI


nltk.download("punkt")


class PDFAnalyzer:
    """
    Clase para analizar documentos PDF utilizando OpenAI.

    Args:
        pdf_path (str): Ruta del archivo PDF a analizar.
        openai_api_key (str): Clave de la API de OpenAI.

    Attributes:
        pdf_path (str): Ruta del archivo PDF a analizar.
        openai_api_key (str): Clave de la API de OpenAI.
        documents: Documentos cargados desde el PDF.
        texts: Textos divididos en fragmentos.
        doc_search: Representación de los documentos para búsqueda.
        chain: Cadena para consultas y respuestas.

    """
    def __init__(self, pdf_path, openai_api_key):
        self.pdf_path = pdf_path
        self.openai_api_key = openai_api_key
        self.load_pdf()

        
    def load_pdf(self):
        """
        Carga el archivo PDF y prepara los datos para análisis.
        """
        # Cargar el PDF
        loader = UnstructuredFileLoader(self.pdf_path)
        documents = loader.load()

        # Dividir los documentos en fragmentos
        text_splitter = CharacterTextSplitter(chunk_size=800, chunk_overlap=0)
        texts = text_splitter.split_documents(documents)

        # Preparar los modelos y los embeddings
        embeddings = OpenAIEmbeddings(openai_api_key=self.openai_api_key)
        doc_search = Chroma.from_documents(texts, embeddings)
        self.chain = VectorDBQA.from_chain_type(llm=OpenAI(api_key=self.openai_api_key),
                                                chain_type="stuff",
                                                vectorstore=doc_search)


    def ask_question(self, question):
        """
        Realiza una pregunta sobre el contenido del PDF.

        Args:
            question (str): Pregunta a realizar.

        Returns:
            str: Respuesta a la pregunta.
        """
        response = self.chain.run(question)
        return response

analyzer = PDFAnalyzer(pdf_path, openai_api_key)
response = analyzer.ask_question("¿Puedes resumir lo que dice el libro sobre el método de MonteCarlo en español?")
print(response)       

' El método de MonteCarlo es una técnica que se utiliza para estimar valores en situaciones complejas. Se llama así porque fue usado por físicos en los años 40 para entender fenómenos relacionados con la bomba atómica. Una ventaja de este método es que no se ve afectado por violaciones de la propiedad de Markov, ya que no actualiza sus estimaciones de valor en función de las estimaciones de valor de los estados sucesores.'

Conclusiones

En este artículo, se ha visto cómo utilizar Python en conjunto con OpenAI para realizar análisis automático de los datos contenidos en cualquier documento PDF. Creando con ello la clase PDFAnalyzer con la que se puede resumir PDF con Python de una forma sencilla.

Imagen de PublicDomainPictures en Pixabay