Upload 18 files

README.md

@@ -0,0 +1,106 @@
+## CHATGPT-PAPER-READER📝 
+This repository provides a simple interface that utilizes the gpt-3.5-turbo model to read academic papers in PDF format locally. You can use it to help you summarize papers, create presentation slides, or simply fulfill tasks assigned by your supervisor.
+
+## How Does This Work
+Considering the following issues with using ChatGPT to read complete academic papers:
+
+- The ChatGPT model itself has a context window size of 4096 tokens, making it unable to process the entire paper directly.
+- It is easy to forget the context when dealing with long texts.
+
+This repository attempts to solve these problems when using the OpenAI interface in the following ways:
+
+- Splitting a PDF paper into multiple parts for reading and generating a summary of each part. When reading each part, it will refer to the context of the previous part within the token limit.
+- Combining the summaries of each part to generate a summary of the entire paper. This can partially alleviate the forgetting problem when reading with ChatGPT.
+- Before reading the paper, you can set the questions you are interested in the prompt. This will help ChatGPT focus on the relevant information when reading and summarizing, resulting in better reading performance.
+
+By default, the initalized prompt will ask ChatGPT to focus on these points:
+- Who are the authors?
+- What is the process of the proposed method?
+- What is the performance of the proposed method? Please note down its performance metrics.
+- What are the baseline models and their performances? Please note down these baseline methods.
+- What dataset did this paper use?
+  
+These questions are designed for research articles in the field of computer science.
+After finishing reading the paper, you can ask questions using 'question()' interface, it will anwser your question based on the summaries of each part.
+
+## Example: Read AlexNet Paper
+
+### Summarize AlexNet
+```python
+from gpt_reader.pdf_reader import PaperReader, BASE_POINTS
+
+print('Key points to focus while reading: {}'.format(BASE_POINTS))
+
+api_key = 'Your key'
+session = PaperReader(api_key, points_to_focus=BASE_POINTS)  # You can set your key points 
+summary = session.read_pdf_and_summarize('./alexnet.pdf')
+
+print(summary)
+```
+
+```
+# console print
+reading pdf finished
+page: 0, part: 0
+page: 0, part: 1
+page: 1, part: 0
+page: 1, part: 1
+page: 2, part: 0
+page: 2, part: 1
+page: 3, part: 0
+page: 3, part: 1
+page: 4, part: 0
+page: 4, part: 1
+page: 5, part: 0
+page: 5, part: 1
+page: 6, part: 0
+page: 6, part: 1
+page: 7, part: 0
+page: 7, part: 1
+page: 8, part: 0
+page: 8, part: 1
+```
+
+> reply: The paper presents a deep convolutional neural network architecture that was trained to classify 1.2 million high-resolution images in the ImageNet LSVRC-2010 contest into 1000 different classes. The network achieved top-1 and top-5 error rates of 37.5% and 17.0%, respectively, which is considerably better than the previous state-of-the-art. The authors used non-saturating neurons and a very efficient GPU implementation of the convolution operation to make training faster. They also employed a recently-developed regularization method called "dropout" to reduce overfitting in the fully-connected layers. The paper discusses the importance of large datasets for object recognition and the need for models with a large learning capacity. The authors entered a variant of this model in the ILSVRC-2012 competition and achieved a winning top-5 test error rate of 15.3%, compared to 26.2% achieved by the second-best entry. The paper also discusses the advantages of using convolutional neural networks (CNNs) for image recognition, including their ability to make strong and mostly correct assumptions about the nature of images, and the challenges of applying CNNs to high-resolution images. The authors describe the architecture of their CNN, which contains eight layers with weights, and the techniques they used to combat overfitting, including data augmentation and dropout. The paper provides qualitative evaluations of their CNN architecture and suggests future work, including using very large and deep convolutional nets on video sequences. The paper also lists references cited in the paper, including papers on image recognition challenges, object recognition, handwritten digit recognition, and convolutional networks and their applications in vision.
+
+
+### Ask some questions
+
+```python
+session.question('Authors of this paper?')
+```
+
+> reply: The authors of this paper are Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton from the University of Toronto.
+
+
+```python
+session.question('Describe the proposed method in details.')
+```
+
+> reply：The proposed method is based on a large, deep convolutional neural network that is trained with stochastic gradient descent using techniques like weight decay, momentum, and dropout for regularization.  The network consists of eight layers (five convolutional and three fully-connected) with the output layer consisting of a 1000-way softmax to produce a distribution over 1000 class labels.  The authors used a ReLU activation function and local response normalization to improve training speed, and overlapping pooling to improve generalization.  They also reduced overfitting by augmenting the training data with techniques like image translations, horizontal reflections, and altering the intensities of the RGB channels in training images using PCA.  The proposed method was trained on subsets of the ImageNet dataset used in the ILSVRC-2010 and ILSVRC-2012 competitions, which contain roughly 1.2 million training images, 50,000 validation images, and 150,000 testing images. By using a large, deep convolutional neural network with various optimization strategies, the proposed method achieved top-5 error rates of 16.4% and 15.3% on the ILSVRC-2012 validation and test sets, respectively, outperforming the previous state-of-the-art results.
+> 
+
+```python
+session.question('What dataset does this paper use for experiment?')
+```
+
+> reply: The authors used subsets of the ImageNet dataset used in the ILSVRC-2010 and ILSVRC-2012 competitions for their experiments. These subsets contain approximately 1.2 million training images, 50,000 validation images, and 150,000 testing images.
+
+```python
+session.question('What metrics does this paper use to evaluate the performace?')
+```
+
+> reply: The paper evaluated the performance of their proposed method using Top-1 and Top-5 error rates on the validation and test sets of the ILSVRC-2010 and ILSVRC-2012 image recognition challenges. The Top-1 error rate measures the percentage of images for which the predicted class label is not the correct label, while the Top-5 error rate measures the percentage of images for which the correct label is not among the five most probable labels predicted by the model.
+
+```python
+session.question('Summarize this paper and your anwsers above, then translate the result into Chinese')
+```
+> reply: 这篇论文的作者是来自Toronto大学的Alex Krizhevsky、Ilya Sutskever和Geoffrey E. Hinton。该论文提出了一种基于卷积神经网络的深度学习方法，该方法在 ImageNet LSVRC-2010 和 ImageNet LSVRC-2012 图像识别挑战中达到了最佳结果。\n\n该方法使用了一系列技术来优化性能，包括使用ReLU激活函数和局部响应归一化等方法提高训练速度，使用重叠池化等方法提高泛化能力。为了减少过拟合，该方法还使用了数据增强技术，如图像平移、水平反射和使用PCA修改训练图像的RGB通道强度。作者在多个GPU上使用随机梯度下降进行训练，通过调整学习速率和使用权重衰减、动量和dropout等技术来优化性能。\n\n用于实验的数据集是 ImageNet LSVRC-2010 和 ImageNet LSVRC-2012 数据集的子集，其中包括大约120万个训练图像、5万个验证图像和15万个测试图像。该方法相比之前的最佳结果，达到了 更好的Top-1错误率和Top-5错误率。作者使用这两个错误率来评估性能，Top-1错误率表示预测的类别不是正确标签的百分率，而Top-5错误率表示真实标签不在模型预测的五个最可能标签中的百分率。
+
+
+## TODO
+
+- This demo still needs to be improved to support longer articles. Articles of more than 10 pages have the possibility to exceed the token limit during processing.
+- You may exceed the token limit when asking questions.
+- More prompt tuning needed to let it outputs stable results.
+- Imporve summary accuracies

app.py

@@ -0,0 +1,51 @@
+import gradio as gr
+
+from gpt_reader.pdf_reader import PaperReader
+from gpt_reader.prompt import BASE_POINTS
+
+
+class GUI:
+    def __init__(self):
+        self.api_key = ""
+        self.session = ""
+
+    def analyse(self, api_key, pdf_file):
+        self.session = PaperReader(api_key, points_to_focus=BASE_POINTS)
+        return self.session.read_pdf_and_summarize(pdf_file)
+
+    def ask_question(self, question):
+        if self.session == "":
+            return "Please upload PDF file first!"
+        return self.session.question(question)
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        # CHATGPT-PAPER-READER
+        """)
+
+    with gr.Tab("Upload PDF File"):
+        pdf_input = gr.File(label="PDF File")
+        api_input = gr.Textbox(label="OpenAI API Key")
+        result = gr.Textbox(label="PDF Summary")
+        upload_button = gr.Button("Start Analyse")
+    with gr.Tab("Ask question about your PDF"):
+        question_input = gr.Textbox(label="Your Question", placeholder="Authors of this paper?")
+        answer = gr.Textbox(label="Answer")
+        ask_button = gr.Button("Ask")
+    with gr.Accordion("About this project"):
+        gr.Markdown(
+            """## CHATGPT-PAPER-READER📝 
+            This repository provides a simple interface that utilizes the gpt-3.5-turbo 
+            model to read academic papers in PDF format locally. You can use it to help you summarize papers, 
+            create presentation slides, or simply fulfill tasks assigned by your supervisor.\n 
+            [Github](https://github.com/talkingwallace/ChatGPT-Paper-Reader)""")
+
+    app = GUI()
+    upload_button.click(fn=app.analyse, inputs=[api_input, pdf_input], outputs=result)
+    ask_button.click(app.ask_question, inputs=question_input, outputs=answer)
+
+if __name__ == "__main__":
+    demo.title = "CHATGPT-PAPER-READER"
+    demo.launch(server_port=2333)  # add "share=True" to share CHATGPT-PAPER-READER app on Internet.

gpt_reader/model_interface.py

@@ -0,0 +1,32 @@
+from typing import List
+import openai
+
+
+class ModelInterface(object):
+
+    def __init__(self) -> None:
+        pass
+
+    def send_msg(self, *args):
+        pass
+
+
+class OpenAIModel(object):
+
+    def __init__(self, api_key, model='gpt-3.5-turbo', temperature=0.2) -> None:
+        openai.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+
+    def send_msg(self, msg: List[dict], return_raw_text=True):
+        
+        response = openai.ChatCompletion.create(
+            model=self.model,
+            messages=msg,
+            temperature=self.temperature
+        )
+
+        if return_raw_text:
+            return response["choices"][0]["message"]["content"]
+        else:
+            return response

gpt_reader/paper.py

@@ -0,0 +1,20 @@
+from PyPDF2 import PdfReader
+
+class Paper(object):
+
+    def __init__(self, pdf_obj: PdfReader) -> None:
+        self._pdf_obj = pdf_obj
+        self._paper_meta = self._pdf_obj.metadata
+
+    def iter_pages(self, iter_text_len: int = 3000):
+        page_idx = 0
+        for page in self._pdf_obj.pages:
+            txt = page.extract_text()
+            for i in range((len(txt) // iter_text_len) + 1):
+                yield page_idx, i, txt[i * iter_text_len:(i + 1) * iter_text_len]
+            page_idx += 1
+
+
+if __name__ == '__main__':
+    reader = PdfReader('../alexnet.pdf')
+    paper = Paper(reader)

gpt_reader/pdf_reader.py

@@ -0,0 +1,121 @@
+from PyPDF2 import PdfReader
+import openai
+from .prompt import BASE_POINTS, READING_PROMT_V2
+from .paper import Paper
+from .model_interface import OpenAIModel
+
+
+# Setting the API key to use the OpenAI API
+class PaperReader:
+
+    """
+    A class for summarizing research papers using the OpenAI API.
+
+    Attributes:
+        openai_key (str): The API key to use the OpenAI API.
+        token_length (int): The length of text to send to the API at a time.
+        model (str): The GPT model to use for summarization.
+        points_to_focus (str): The key points to focus on while summarizing.
+        verbose (bool): A flag to enable/disable verbose logging.
+
+    """
+
+    def __init__(self, openai_key, token_length=4000, model="gpt-3.5-turbo",
+                 points_to_focus=BASE_POINTS, verbose=False):
+
+        # Setting the API key to use the OpenAI API
+        openai.api_key = openai_key
+
+        # Initializing prompts for the conversation
+        self.init_prompt = READING_PROMT_V2.format(points_to_focus)
+
+        self.summary_prompt = 'You are a researcher helper bot. Now you need to read the summaries of a research paper.'
+        self.messages = []  # Initializing the conversation messages
+        self.summary_msg = []  # Initializing the summary messages
+        self.token_len = token_length  # Setting the token length to use
+        self.keep_round = 2  # Rounds of previous dialogues to keep in conversation
+        self.model = model  # Setting the GPT model to use
+        self.verbose = verbose  # Flag to enable/disable verbose logging
+        self.model = OpenAIModel(api_key=openai_key, model=model)
+
+    def drop_conversation(self, msg):
+        # This method is used to drop previous messages from the conversation and keep only recent ones
+        if len(msg) >= (self.keep_round + 1) * 2 + 1:
+            new_msg = [msg[0]]
+            for i in range(3, len(msg)):
+                new_msg.append(msg[i])
+            return new_msg
+        else:
+            return msg
+
+    def send_msg(self, msg):
+        return self.model.send_msg(msg)
+
+    def _chat(self, message):
+        # This method is used to send a message and get a response from the OpenAI API
+
+        # Adding the user message to the conversation messages
+        self.messages.append({"role": "user", "content": message})
+        # Sending the messages to the API and getting the response
+        response = self.send_msg(self.messages)
+        # Adding the system response to the conversation messages
+        self.messages.append({"role": "system", "content": response})
+        # Dropping previous conversation messages to keep the conversation history short
+        self.messages = self.drop_conversation(self.messages)
+        # Returning the system response
+        return response
+
+    def summarize(self, paper: Paper):
+        # This method is used to summarize a given research paper
+
+        # Adding the initial prompt to the conversation messages
+        self.messages = [
+            {"role": "system", "content": self.init_prompt},
+        ]
+        # Adding the summary prompt to the summary messages
+        self.summary_msg = [{"role": "system", "content": self.summary_prompt}]
+
+         # Reading and summarizing each part of the research paper
+        for (page_idx, part_idx, text) in paper.iter_pages():
+            print('page: {}, part: {}'.format(page_idx, part_idx))
+            # Sending the text to the API and getting the response
+            summary = self._chat('now I send you page {}, part {}：{}'.format(page_idx, part_idx, text))
+            # Logging the summary if verbose logging is enabled
+            if self.verbose:
+                print(summary)
+            # Adding the summary of the part to the summary messages
+            self.summary_msg.append({"role": "user", "content": '{}'.format(summary)})
+
+        # Adding a prompt for the user to summarize the whole paper to the summary messages
+        self.summary_msg.append({"role": "user", "content": 'Now please make a summary of the whole paper'})
+        # Sending the summary messages to the API and getting the response
+        result = self.send_msg(self.summary_msg)
+        # Returning the summary of the whole paper
+        return result
+
+    def read_pdf_and_summarize(self, pdf_path):
+        # This method is used to read a research paper from a PDF file and summarize it
+        
+        # Creating a PdfReader object to read the PDF file
+        pdf_reader = PdfReader(pdf_path)
+        paper = Paper(pdf_reader)
+        # Summarizing the full text of the research paper and returning the summary
+        print('reading pdf finished')
+        summary = self.summarize(paper)
+        return summary
+
+    def get_summary_of_each_part(self):
+        # This method is used to get the summary of each part of the research paper
+        return self.summary_msg
+
+    def question(self, question):
+        # This method is used to ask a question after summarizing a paper
+
+        # Adding the question to the summary messages
+        self.summary_msg.append({"role": "user", "content": question})
+        # Sending the summary messages to the API and getting the response
+        response = self.send_msg(self.summary_msg)
+        # Adding the system response to the summary messages
+        self.summary_msg.append({"role": "system", "content": response})
+        # Returning the system response
+        return response

gpt_reader/prompt.py

@@ -0,0 +1,26 @@
+BASE_POINTS = """
+1. Who are the authors?
+2. What is the process of the proposed method?
+3. What is the performance of the proposed method? Please note down its performance metrics.
+4. What are the baseline models and their performances? Please note down these baseline methods.
+5. What dataset did this paper use?
+"""
+
+READING_PROMPT = """
+You are a researcher helper bot. You can help the user with research paper reading and summarizing. \n
+Now I am going to send you a paper. You need to read it and summarize it for me part by part. \n
+When you are reading, You need to focus on these key points:{}
+"""
+
+READING_PROMT_V2 = """
+You are a researcher helper bot. You can help the user with research paper reading and summarizing. \n
+Now I am going to send you a paper. You need to read it and summarize it for me part by part. \n
+When you are reading, You need to focus on these key points:{},
+
+And You need to generate a brief but informative title for this part.
+Your return format:
+- title: '...'
+- summary: '...'
+"""
+
+SUMMARY_PROMPT = "You are a researcher helper bot. Now you need to read the summaries of a research paper."

requirements.txt

@@ -0,0 +1,65 @@
+aiofiles==23.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+altair==4.2.2
+anyio==3.6.2
+async-timeout==4.0.2
+attrs==22.2.0
+certifi==2022.12.7
+charset-normalizer==3.1.0
+click==8.1.3
+contourpy==1.0.7
+cycler==0.11.0
+entrypoints==0.4
+fastapi==0.94.0
+ffmpy==0.3.0
+fonttools==4.39.0
+frozenlist==1.3.3
+fsspec==2023.3.0
+gradio==3.20.1
+h11==0.14.0
+httpcore==0.16.3
+httpx==0.23.3
+idna==3.4
+importlib-resources==5.12.0
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+linkify-it-py==2.0.0
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+matplotlib==3.7.1
+mdit-py-plugins==0.3.3
+mdurl==0.1.2
+multidict==6.0.4
+numpy==1.24.2
+openai==0.27.1
+orjson==3.8.7
+packaging==23.0
+pandas==1.5.3
+Pillow==9.4.0
+pkgutil_resolve_name==1.3.10
+pycryptodome==3.17
+pydantic==1.10.6
+pydub==0.25.1
+pyparsing==3.0.9
+PyPDF2==3.0.1
+pyrsistent==0.19.3
+python-dateutil==2.8.2
+python-multipart==0.0.6
+pytz==2022.7.1
+PyYAML==6.0
+requests==2.28.2
+rfc3986==1.5.0
+six==1.16.0
+sniffio==1.3.0
+starlette==0.26.1
+toolz==0.12.0
+tqdm==4.65.0
+typing_extensions==4.5.0
+uc-micro-py==1.0.1
+urllib3==1.26.15
+uvicorn==0.21.0
+websockets==10.4
+yarl==1.8.2
+zipp==3.15.0