Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

lee el siguinete codigo: import sys from PyQt5.QtWidgets import QApplication,…

  1. User

    lee el siguinete codigo:

    import sys from PyQt5.QtWidgets import QApplication, QMainWindow, QTextEdit, QVBoxLayout, QPushButton, QWidget, QFileDialog, QLabel, QTabWidget from PyQt5.QtCore import Qt from PyQt5.QtGui import QIcon import fitz # PyMuPDF import nltk import codecs # Utilizamos codecs from nltk.tokenize import word_tokenize, sent_tokenize from nltk.corpus import stopwords from nltk.stem import PorterStemmer

    class PDFReaderApp(QMainWindow): def init(self): super().init()

        self.initUI()
    
    def initUI(self):
        self.setWindowTitle('PDF Reader')
        self.setGeometry(100, 100, 1000, 600)
    
        self.central_widget = QTabWidget()  # Utilizamos un QTabWidget para tener dos pestañas
        self.setCentralWidget(self.central_widget)
    
        # Pestaña para la lectura del PDF
        pdf_tab = QWidget()
        layout_pdf = QVBoxLayout()
    
        # Botón para cargar el PDF o archivo de texto
        self.load_button = QPushButton('Cargar PDF o Texto', self)
        self.load_button.clicked.connect(self.load_file)
        layout_pdf.addWidget(self.load_button)
    
        # Espacio de lectura del PDF o archivo de texto
        self.pdf_text = QTextEdit(self)
        self.pdf_text.setReadOnly(True)
        layout_pdf.addWidget(self.pdf_text)
    
        pdf_tab.setLayout(layout_pdf)
    
        # Pestaña para la respuesta
        answer_tab = QWidget()
        layout_answer = QVBoxLayout()
    
        # Espacio para ingresar la pregunta
        self.question_label = QLabel('Ingrese su pregunta:', self)
        layout_answer.addWidget(self.question_label)
    
        self.question_input = QTextEdit(self)
        layout_answer.addWidget(self.question_input)
    
        # Botón para obtener la respuesta
        self.answer_button = QPushButton('Obtener Respuesta', self)
        self.answer_button.clicked.connect(self.answer_question)
        layout_answer.addWidget(self.answer_button)
    
        # Espacio para mostrar la respuesta organizada y resumida
        self.answer_label = QLabel('Respuesta:', self)
        layout_answer.addWidget(self.answer_label)
    
        self.answer_output = QTextEdit(self)
        self.answer_output.setReadOnly(True)
        layout_answer.addWidget(self.answer_output)
    
        answer_tab.setLayout(layout_answer)
    
        # Agregar las pestañas al QTabWidget
        self.central_widget.addTab(pdf_tab, "PDF / Texto")
        self.central_widget.addTab(answer_tab, "Respuesta")
    
        self.pdf_document = None
        self.text_data = None
    
    def load_file(self):
        options = QFileDialog.Options()
        file_path, _ = QFileDialog.getOpenFileName(self, 'Cargar PDF o Texto', '', 'Archivos de Texto (*.pdf *.txt);;Todos los Archivos (*)', options=options)
    
        if file_path:
            if file_path.endswith('.pdf'):
                self.load_pdf(file_path)
            else:
                with open(file_path, 'r', encoding='utf-8') as file:
                    text = file.read()
                    self.pdf_text.setPlainText(text)
                    self.text_data = sent_tokenize(text)
    
    def load_pdf(self, file_path):
        self.pdf_document = fitz.open(file_path)
        text = ''
        for page in self.pdf_document:
            text += page.get_text()
        self.pdf_text.setPlainText(text)
        self.text_data = sent_tokenize(text)
    
    def preprocess_text(self, text):
        # Tokenización, eliminación de stopwords y stemming
        stop_words = set(stopwords.words("english"))
        stemmer = PorterStemmer()
        words = word_tokenize(text.lower())
        words = [stemmer.stem(word) for word in words if word.isalnum()]
        words = [word for word in words if word not in stop_words]
        return " ".join(words)
    
    def answer_question(self):
        if self.pdf_document and self.text_data:
            question = self.question_input.toPlainText()
            question = self.preprocess_text(question)
            question_keywords = set(question.split())  # Palabras clave de la pregunta
    
            response = ""
            max_output_length = 1000  # Longitud máxima del output
            current_length = 0
    
            for paragraph in self.text_data:
                if any(keyword in paragraph for keyword in question_keywords):
                    if current_length + len(paragraph) + 2 <= max_output_length:
                        response += paragraph + "\n\n"
                        current_length += len(paragraph) + 2
                    else:
                        break  # Romper si excede la longitud máxima
    
            self.answer_output.setPlainText(response)
    

    def main(): app = QApplication(sys.argv) app.setWindowIcon(QIcon('icon.png')) ex = PDFReaderApp() ex.show() sys.exit(app.exec_())

    if name == 'main': main()

    necesito que lo optimices para que como respuesta, ademas de lo que esta trayendo traiga todas las palabras y contexto clave de la pregunta realizada por el usuario. esto incluye las frases que contengan palabras o referencias a la busqueda.

  2. Assistant

    Puede mejorar la función answer_question para asegurarse de que se extraigan oraciones que contengan palabras o referencias clave relacionadas con la consulta del usuario. Para hacer eso, primero se pueden extraer las palabras clave de la pregunta, luego buscar estas palabras clave en el texto y finalmente extraer las frases que contengan estas palabras clave.

    Aquí hay una versión optimizada de la función answer_question:

    def answer_question(self):
        if self.pdf_document and self.text_data:
            question = self.question_input.toPlainText()
            question_preprocessed = self.preprocess_text(question)
            question_keywords = set(question_preprocessed.split())  # Palabras clave de la pregunta
    
            # Podemos utilizar nltk para extraer nombres propios o términos técnicos que puedan haber sido descartados por stop words o stemming
            named_entities = self.extract_named_entities(question)
            question_keywords.update(named_entities)
    
            response = ""
            max_output_length = 1000  # Longitud máxima del output
            current_length = 0
    
            for paragraph in self.text_data:
                paragraph_preprocessed = self.preprocess_text(paragraph)
                paragraph_keywords = set(paragraph_preprocessed.split())
                common_keywords = question_keywords.intersection(paragraph_keywords)
    
                if common_keywords:
                    # Extraer frases que contienen las palabras clave
                    sentences = sent_tokenize(paragraph)
                    relevant_sentences = [sentence for sentence in sentences if any(keyword in sentence for keyword in question_keywords)]
    
                    for sentence in relevant_sentences:
                        sentence_length = len(sentence) + 2
                        if current_length + sentence_length <= max_output_length:
                            response += sentence + "\n\n"
                            current_length += sentence_length
                        else:
                            break  # Romper si excede la longitud máxima
    
            self.answer_output.setPlainText(response)
    
    def extract_named_entities(self, text):
        ne_tree = nltk.ne_chunk(nltk.pos_tag(word_tokenize(text)))
        named_entities = set()
        for subtree in ne_tree:
            if type(subtree) == nltk.tree.Tree:  # Si es una entidad nombrada
                entity = " ".join([leaf[0] for leaf in subtree.leaves()])  # Concatenar las partes de la entidad
                named_entities.add(entity)
        return named_entities
    

    En este código, he añadido la función extract_named_entities que utiliza nltk para extraer entidades nombradas de la pregunta que el usuario inserta en la aplicación. Estas entidades nombradas se agregan a las palabras clave de la pregunta, para considerar también información importante que no sería capturada por la tokenización, el filtrado de stopwords y el stemming.

    La búsqueda de las frases relevantes se realiza ahora comparando el conjunto de palabras clave de la pregunta preprocesada con las palabras clave de cada párrafo del documento. Si hay intersección entre los conjuntos de palabras clave, se considera relevante el párrafo, y se extraen específicamente aquellas oraciones que contengan al menos una de las palabras claves.

    Finalmente, las oraciones relevantes se agregan a la respuesta hasta alcanzar la longitud máxima permitida.

  3. User

    ahora dame TODO el codigo. Devuelve el código total completo sin omitir nada de código y dame todo el código completamente codificado el código completo. No sugieras donde debe ir el código, sino crea el código que debería ir allí. No dejes comentarios de donde deberia ir codigo sino pon el codigo que debería ir alli completo. necesito el codigo completo con la solución implementada.

  4. Assistant

    Aquí tienes el código completo con las mejoras implementadas en la función answer_question y la adición de la función extract_named_entities para extracción de entidades nombradas:

    import sys
    from PyQt5.QtWidgets import QApplication, QMainWindow, QTextEdit, QVBoxLayout, QPushButton, QWidget, QFileDialog, QLabel, QTabWidget
    from PyQt5.QtCore import Qt
    from PyQt5.QtGui import QIcon
    import fitz  # PyMuPDF
    import nltk
    import codecs  # Utilizamos codecs
    from nltk.tokenize import word_tokenize, sent_tokenize
    from nltk.corpus import stopwords
    from nltk.stem import PorterStemmer
    
    # Asegúrate de haber descargado los paquetes requeridos de nltk
    nltk.download('punkt')
    nltk.download('stopwords')
    nltk.download('maxent_ne_chunker')
    nltk.download('words')
    
    class PDFReaderApp(QMainWindow):
        def __init__(self):
            super().__init__()
    
            self.initUI()
    
        def initUI(self):
            self.setWindowTitle('PDF Reader')
            self.setGeometry(100, 100, 1000, 600)
    
            self.central_widget = QTabWidget()  # Utilizamos un QTabWidget para tener dos pestañas
            self.setCentralWidget(self.central_widget)
    
            # Pestaña para la lectura del PDF
            pdf_tab = QWidget()
            layout_pdf = QVBoxLayout()
    
            # Botón para cargar el PDF o archivo de texto
            self.load_button = QPushButton('Cargar PDF o Texto', self)
            self.load_button.clicked.connect(self.load_file)
            layout_pdf.addWidget(self.load_button)
    
            # Espacio de lectura del PDF o archivo de texto
            self.pdf_text = QTextEdit(self)
            self.pdf_text.setReadOnly(True)
            layout_pdf.addWidget(self.pdf_text)
    
            pdf_tab.setLayout(layout_pdf)
    
            # Pestaña para la respuesta
            answer_tab = QWidget()
            layout_answer = QVBoxLayout()
    
            # Espacio para ingresar la pregunta
            self.question_label = QLabel('Ingrese su pregunta:', self)
            layout_answer.addWidget(self.question_label)
    
            self.question_input = QTextEdit(self)
            layout_answer.addWidget(self.question_input)
    
            # Botón para obtener la respuesta
            self.answer_button = QPushButton('Obtener Respuesta', self)
            self.answer_button.clicked.connect(self.answer_question)
            layout_answer.addWidget(self.answer_button)
    
            # Espacio para mostrar la respuesta organizada y resumida
            self.answer_label = QLabel('Respuesta:', self)
            layout_answer.addWidget(self.answer_label)
    
            self.answer_output = QTextEdit(self)
            self.answer_output.setReadOnly(True)
            layout_answer.addWidget(self.answer_output)
    
            answer_tab.setLayout(layout_answer)
    
            # Agregar las pestañas al QTabWidget
            self.central_widget.addTab(pdf_tab, "PDF / Texto")
            self.central_widget.addTab(answer_tab, "Respuesta")
    
            self.pdf_document = None
            self.text_data = None
    
        def load_file(self):
            options = QFileDialog.Options()
            file_path, _ = QFileDialog.getOpenFileName(self, 'Cargar PDF o Texto', '', 'Archivos de Texto (*.pdf *.txt);;Todos los Archivos (*)', options=options)
    
            if file_path:
                if file_path.endswith('.pdf'):
                    self.load_pdf(file_path)
                else:
                    with open(file_path, 'r', encoding='utf-8') as file:
                        text = file.read()
                        self.pdf_text.setPlainText(text)
                        self.text_data = sent_tokenize(text)
    
        def load_pdf(self, file_path):
            self.pdf_document = fitz.open(file_path)
            text = ''
            for page in self.pdf_document:
                text += page.get_text()
            self.pdf_text.setPlainText(text)
            self.text_data = sent_tokenize(text)
    
        def preprocess_text(self, text):
            # Tokenización, eliminación de stopwords y stemming
            stop_words = set(stopwords.words("english"))
            stemmer = PorterStemmer()
            words = word_tokenize(text.lower())
            words = [stemmer.stem(word) for word in words if word.isalnum()]
            words = [word for word in words if word not in stop_words]
            return " ".join(words)
    
        def extract_named_entities(self, text):
            ne_tree = nltk.ne_chunk(nltk.pos_tag(word_tokenize(text)))
            named_entities = set()
            for subtree in ne_tree:
                if isinstance(subtree, nltk.tree.Tree):  # Si es una entidad nombrada
                    entity = " ".join([leaf[0] for leaf in subtree.leaves()])  # Concatenar las partes de la entidad
                    named_entities.add(entity)
            return named_entities
    
        def answer_question(self):
            if self.text_data:
                question = self.question_input.toPlainText()
                question_preprocessed = self.preprocess_text(question)
                question_keywords = set(question_preprocessed.split())  # Palabras clave de la pregunta
    
                # Podemos utilizar nltk para extraer nombres propios o términos técnicos que puedan haber sido descartados por stop words o stemming
                named_entities = self.extract_named_entities(question)
                question_keywords.update(named_entities)
    
                response = ""
                max_output_length = 1000  # Longitud máxima del output
                current_length = 0
    
                for paragraph in self.text_data:
                    paragraph_preprocessed = self.preprocess_text(paragraph)
                    paragraph_keywords = set(paragraph_preprocessed.split())
                    common_keywords = question_keywords.intersection(paragraph_keywords)
    
                    if common_keywords:
                        # Extraer frases que contienen las palabras clave
                        sentences = sent_tokenize(paragraph)
                        relevant_sentences = [sentence for sentence in sentences if any(keyword in sentence for keyword in question_keywords)]
    
                        for sentence in relevant_sentences:
                            sentence_length = len(sentence) + 2
                            if current_length + sentence_length <= max_output_length:
                                response += sentence + "\n\n"
                                current_length += sentence_length
                            else:
                                break  # Romper si excede la longitud máxima
    
                self.answer_output.setPlainText(response)
    
    def main():
        app = QApplication(sys.argv)
        app.setWindowIcon(QIcon('icon.png'))
        ex = PDFReaderApp()
        ex.show()
        sys.exit(app.exec_())
    
    if __name__ == '__main__':
        main()
    

    Este es el código completo con las modificaciones solicitadas. Asegúrese de tener todo listo y haber descargado los recursos necesarios para NLTK antes de ejecutar el script para evitar errores.

    Los cambios realizados se encuentran principalmente en la función answer_question y la nueva extract_named_entities que ha sido añadida al código. La ventana principal de la aplicación ("PDFReaderApp") y la función main siguen siendo las mismas que en el código original.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.