Delete paper2slides.py

paper2slides.py

@@ -1,703 +0,0 @@
-slide_datasource = {
-    'introduction': ['abstract', 'Introduction'],
-    'objective': ['abstract', 'Introduction'],
-    'methodoloy': ['abstract', 'Introduction', 'Conclusion', 'Methods'],
-    'results': ['abstract', 'Experiments', 'Conclusion'],
-    'conclusion': ['abstract', 'Introduction', 'Conclusion'],
-}
-
-from pdf_helper import PDFPaper4LLMParser, dict_to_markdown_list
-from sambaAPI import call_llama_chat, MODEL_ALIAS
-from pdf_helper import markdown_to_slide_dicts
-from pptx_utils import Dict2PPT, os
-import json
-import time
-import string
-
-SLIDE_SEP = '<slide_sep>'
-
-def trim_string(s):
-    return s.strip(string.whitespace + string.punctuation)
-
-section_title_key_phrases = {
-    'Introduction': ['introduction'],
-    'Related Works': ['related work'],
-    'Methods': ['method', 'approach'],
-    'Experiments': ['experiment'],
-    'Conclusion': ['conclusion'],
-    'Acknowledgements': ['acknowledgement'],
-    'References': ['references', ' references'], #
-}
-
-def find_string_index(string_list, target: str):
-    """
-    Returns the index of the target string in the list.
-    If the target is not found, returns -1.
-
-    Parameters:
-    string_list (list): A list of strings
-    target (str): The string to find in the list
-
-    Returns:
-    int: The index of the target string, or -1 if not found
-    """
-    try:
-        return string_list.index(target)
-    except ValueError:
-        return -1
-
-
-def get_section_category(section_name: str):
-    """
-    Scientist paper section name mapping
-    """
-    for key, phrases in section_title_key_phrases.items():
-        for phrase in phrases:
-            if phrase in section_name.lower():
-                return key
-    return 'Other'
-
-
-class PaperReader(object):
-    def __init__(self, page_chunks=False):
-        self.paper_reader = PDFPaper4LLMParser(page_chunks=page_chunks)
-
-    def pdf2text(self, paper_pdf_path: str):
-        paper_content = self.paper_reader.run(pdf_path=paper_pdf_path, verbose=False)
-        return paper_content
-    
-    def structurize(self, main_text_array: list):
-        section_names = [_['title'] for _ in main_text_array]
-        section_name_topics = [get_section_category(_) for _ in section_names]
-        introduction_idx = find_string_index(section_name_topics, target='Introduction')
-        refference_idx = find_string_index(section_name_topics, target='References')
-        experiment_idx = find_string_index(section_name_topics, target='Experiments')
-        conclusion_idx = find_string_index(section_name_topics, target='Conclusion')
-        if refference_idx > 0:
-            for idx in range(len(section_name_topics)):
-                if idx < refference_idx:
-                    if section_name_topics[idx] == 'Other':
-                        section_name_topics[idx] = 'Methods'
-                elif idx > refference_idx:
-                    if not ('appendix' in section_name_topics[idx].lower()):
-                        section_name_topics[idx] = 'Appendix: ' + section_name_topics[idx]
-                else:
-                    continue
-            # print(section_name_topics)
-            if experiment_idx > 0:
-                for idx in range(experiment_idx +1, refference_idx):
-                    if section_name_topics[idx] == 'Methods':
-                        section_name_topics[idx] = 'Experiments'
-        # print(section_name_topics)
-        experiment_idx = find_string_index(section_name_topics, target='Experiments')
-        method_idx = find_string_index(section_name_topics, target='Methods')
-        relatedwork_idx = find_string_index(section_name_topics, target='Related Works')
-        ack_idx = find_string_index(section_name_topics, target='Acknowledgements')
-        
-        paper_structure_dict = {
-            'Introduction': [introduction_idx],
-            'Related Works': [relatedwork_idx],
-            'References': [refference_idx],
-            'Conclusion': [conclusion_idx],
-            'Acknowledgements': [ack_idx]
-        }
-
-        ## Experiments and methodology
-        method_idx_array = []
-        if method_idx >=0:
-            for idx in range(method_idx, len(section_name_topics)):
-                if section_name_topics[idx] == 'Methods':
-                    method_idx_array.append(idx)
-                else:
-                    break
-        else:
-            if introduction_idx >=0 and conclusion_idx >=0:
-                for idx in range(introduction_idx+1, conclusion_idx):
-                    if section_name_topics[idx] == 'Methods':
-                        method_idx_array.append(idx)
-                    else:
-                        break
-
-        
-        exp_idx_array = []
-        if experiment_idx >=0:
-            for idx in range(experiment_idx, len(section_name_topics)):
-                if section_name_topics[idx] == 'Experiments':
-                    exp_idx_array.append(idx)
-                else:
-                    break
-        else:
-            if introduction_idx >=0 and conclusion_idx >=0:
-                for idx in range(introduction_idx+1, conclusion_idx):
-                    if section_name_topics[idx] == 'Experiments':
-                        exp_idx_array.append(idx)
-                    else:
-                        break
-        
-        paper_structure_dict['Experiments'] = exp_idx_array
-        paper_structure_dict['Methods'] = method_idx_array
-        return section_name_topics, paper_structure_dict
-
-    def run(self, paper_file_name: str):
-        start_time = time.time()
-        paper_content = self.pdf2text(paper_pdf_path=paper_file_name)
-        section_name_topics, paper_structure_dict = self.structurize(main_text_array=paper_content['main_text'])
-        paper_content['structure'] = paper_structure_dict
-        paper_content['section_topic'] = section_name_topics
-        print('Runtime for pdf2text = {:.4f} seconds.'.format(time.time() - start_time))
-        return paper_content
-
-### 1. General System Prompt
-    
-SCHOLAR_PROMPT = """
-You are an assistant being skilled at critically reading and analyzing academic papers to extract key insights, trends, and findings.
-"""
-
-### 2. Paper Outline Generation from Abstract
-
-ABSTRACT_SUMMARY_PROMPT = """
-You are given the **title** and **abstract** of an academic paper. Please first identity the research topic, and then extract the following aspects in a minimal title draft (max 15 words) for PowerPoint presentation:
-	
-    1.	**Background**: Introduces the research context and importance.
-	2.	**Research Problem**: Identifies the specific problem or knowledge gap.
-	3.	**Objectives**: States the research goals or hypotheses.
-	4.	**Methodology**: Summarizes the research design and key methods.
-	5.	**Results**: Highlights the most significant findings.
-	6.	**Conclusions**: Provides the main takeaways and their relation to the research question.
-
-Reminder: Strictly output in JSON format **only**, using the keys: "Research topic", "Background", "Research problem", "Objectives", "Methodology", "Results" and "Conclusions".
-"""
-
-### 3. Evidence extraction from main paper text for "Background"
-BACKGROUD_EVIDENCE_PROMPT = """
-You are given the **title**, briefly description of **problem backgroud** and **introduction** of a research paper. From the introduction, extract an itemized list of **1 to 3 pieces of evidence** that support the problem background, each evidence should be described in a **minimal draft (min 10 words and max 25 words)** for PowerPoint presentation.
-
-    Each piece of evidence must:
-        1.	Be directly relevant to the problem background.
-        2.	Be clear and concise.
-        3.	Be unique, not repeating other evidence.
-
-**Important**: Strictly output the itemized evidences ONLY.
-"""
-
-
-### 4. Evidence extraction from main paper text for "Research Problem"
-RESEARCH_PROBLEM_PROMPT = """
-You are given the **title**, briefly description of **research problem** and **introduction** of a research paper. Solely from the given introduction, extract the definition of the research problem for PowerPoint presentation, focusing on:
-    
-    1.	**Scope**: Define the problem’s boundaries as individual items;
-	2.	**Challenges**: Identify key gaps or obstacles the research addresses as individual items;
-    3.  **Assumptions**: State any assumptions guiding the research as individual items;
-    4.  **Relevance*: Specify who benefits from solving the problem as individual items.
-
-**Note**: Each item must be in one concise sentence. **Only** output "Scope", "Challenges", "Assumptions" and "Relevance".
-"""
-
-
-### 5. Evidence extraction from main paper text for "Objectives"
-
-OBJECTIVE_PROMPT = """
-You are given the **title**, **objectives** and **introduction** of a research paper. Solely from the given introduction, extract a list of **2 to 5 pieces of evidence** to support these objectives, each evidence should be described in a **minimal draft (min 10 words and max 20 words)** for PowerPoint presentation.
-
-    Each piece of evidence must:
-        1.	Be directly relevant to the objectives.
-        2.	Be clear and concise.
-        3.	Be unique, not repeating other evidence.
-    
-**Note**: Strictly output the itemized evidences ONLY.
-"""
-
-### 6. Evidence extraction from main paper text for "Conclusion"
-
-CONCLUSION_PROMT = """
-You are given the **title**, **birief conclusion**, and **full text conclusion** and **introduction** of a research paper. From the given conclusion and introduction, extract the **conclusion** for PowerPoint presentation, ensuring it includes:
-
-	1.	**Summary of key results**: Highlight the main results.
-	2.	**Implications**: Explain the significance or impact of these findings.
-	3.	**Future directions**: Mention any suggestions for future research or applications.
-	4.	**Final takeaway**: Provide the overall takeaway message of the study.
-
-**Note**: Only output the conclusion. Limit each point in a minimal concise draft (at least 10 words).”
-"""
-
-### 7. Evidence extraction from main paper text for "Experimental results" (iterative)
-
-RESULT_PROMPT_DICT = {
-  "system_instruction": """Given the title, the main results of an experimental study, and a paragraph from a research paper, your task is to extract and summarize evidence from the paragraph that supports the 'main results'.
-
-   Follow these steps for each paragraph:
-        1.	**Detect Evidence**: Check if the paragraph contains:
-            1) Any evidence supporting the main results, or
-            2) Experimental study information, including:
-                - **Dataset**: Details on datasets, preprocessing, or train/test splits.
-                - **Model Description**: Information of baselines, hyperparameters, and training.
-                - **Evaluation Metrics**: Relevant metrics like accuracy, F1 score, and their justification.
-                - **Comparative Analysis**: Comparisons with baselines, ablation studies, statistical significance.
-                - **Runtime & Scalability**: Computational complexity and scalability.
-        2.	**Response**: Choose 'YES' or 'NO':
-            - If 'YES', extract and summarize the evidence or experimental details in 200 words. Ensure the summary is:
-                - Clear and concise
-                - Well-formatted for easy reading
-                - Focused on key points: dataset, model Description, evaluation metrics, comparative analysis and runtime & scalability.
-            - If 'NO', just respond with 'NO EVIDENCE'.
-  """,
-
-  "iterative_prompt": """Summarize the experimental details or evidence supporting the 'main results' in 200 words from the following paragraph (with title and content) if experiment-related information is detected. Follow these instructions:
-
-	1.	List 2 to 4 itemized points.
-	2.	Each point must specify the type ('Evidence' or 'Experimental Setup') and provide a minimal draft sentence of content (max 15 words).
-
-**Note**: Only provide the itemized summary.
-  """,
-
-  "final_prompt": """Using the **title**, the **main results** of an experimental study, and a list of experiment summaries from the research paper, follow these steps to summarize the results:
-
-	1.	**Evidence Summary**: prive a numbered, itemized summary of **2-3** key points. Keep each point brief and focused (only 1 sentence).
-
-	2.	**Experimental Summary**: Based all 'Experimental Setup' points and provide a concise summary covering the following aspects:
-        1) **Datasets**: List only the names of all datasets or benchmarks used.
-        2) **Baselines**: List only the names of all models/algorithms used.
-        3) **Metrics**: List only the evaluation metrics used for model performance, such as accuracy, F1-score, recall, precision, AUC, etc.
-        4) **Results**: Summarize key comparisons and ablation results, focusing on the most important details.
-
-  **Note**: Only output the “Evidence Summary” and “Experimental Summary”
-     """
-}
-
-## Methodology extraction
-
-METHOD_PROMPT_DICT = {
-    "system_instruction": """Given the **title**, the **method overview**, and a paragraph of a research paper. You task is identify and extract text being relevant to 'method overview' from the given paragraph for PowerPoint presentation.
-
-    Follow these steps:
-    1. **Method Information Detection**: Check if the paragraph contains:
-       1) Any mention of the **method overview** or
-       2) Specific method details, such as:
-           - **Problem Definition**: The task, input, and expected output.
-           - **Model Architecture**: Structure, key components, and learning type.
-           - **Algorithm**: Steps of the method.
-           - **Training Process**: Training data, optimization method, and loss function.
-    2. **Response**: Choose 'YES' or 'NO':
-        - If 'YES', summarize the method details in a minimal draft with max 20 words, ensuring it is:
-            - Clear and concise
-            - Well-formatted for readability
-            - Focused on key points.
-        - If 'NO', simply respond with 'NO Information'.
-    """,
-    "iterative_prompt": """Summarize the method description in 200 words from the following paragraph (with title and content) if method-related information is found. Follow these steps:
-        
-        1. List **2 to 4** method steps in numbered format..
-        2. Ensure each step is related to the **method overview**.
-        3. Keep each step clear and concise (only minimal draft with max 15 words).
-    
-    **Note**: Only output the itemized method steps.
-    """,
-
-    "final_prompt": """Using **title**, **method overview**, and a list of itemized method step summary from a research paper, follow these instructions to summarize the method description::
-        
-        1. Provide a numbered list of **3-6 method steps** detailing the **method overview**.
-        2. Keep each step clear and concise (only 1 sentence).
-    
-    **Note**: Only output the itemized method steps.
-    """
-}
-
-SLIDES_REVISION_PROMPT = """You are an expert research assistant. Revise the following research paper slides to enhance clarity and readability while preserving the original markdown structure. Keep all first-level markdown headers unchanged. Sections are separated by '{}'. Follow these guidelines:
-
-	1.	Simplify language and make content more concise, especially in the outline.
-	2.	Preserve the logical flow and overall structure.
-	3.	Make key points and conclusions clear and easy to follow.
-	4.	Use bullet points where appropriate for better clarity.
-	5.	Minimize jargon to ensure accessibility for a broad academic audience.
-
-""".format(SLIDE_SEP)
-
-def make_api_call(model, messages, max_tokens, temperature):
-    try:
-        response = call_llama_chat(messages=messages, model=model, temperature=temperature, max_tokens=max_tokens)
-        return response
-    except Exception as e:
-         return f"Failed to generate final answer. Error: {str(e)}", {}
-
-def convert_to_dict(input_string: str):
-    # Split the string by the delimiter (e.g., semicolon)
-    lines = input_string.strip().split('\n')
-    # Initialize an empty dictionary
-    result_dict = {}
-    # Iterate over each line
-    for line in lines:
-        # Split each line into key and value by the delimiter (e.g., colon)
-        if ':' in line:
-            key, value = line.split(':', 1)  # Split only on the first occurrence
-            # Strip any whitespace and store in the dictionary
-            result_dict[key.strip()] = value.strip()
-    return result_dict
-
-
-class Paper2Slides(object):
-    def __init__(self, paper_contents: dict, model: str, max_tokens = 512, temprature=0.1):
-        self.paper_contents = paper_contents
-        if not self.valid_paper_checking():
-            print('Not a valid paper structure, cannot generate slides')
-            exit(1)
-        self.model = MODEL_ALIAS[model]
-        self.is_rate_limitation = ('405B' in self.model) or ('70B' in self.model)
-        self.temprature = temprature
-        self.max_failure_attempt_each_step = 3
-        if '405B' in self.model:
-            self.sleep_time = 0.25
-        else:
-            self.sleep_time = 0.25
-        self.max_tokens = max_tokens
-        print('{} model is used for slides generation!\nRate limitation = {}'.format(self.model, self.is_rate_limitation))
-        self.revise_model = MODEL_ALIAS['llama3_70b']
-    
-    def valid_paper_checking(self):
-        try:
-            assert 'abstract' in self.paper_contents, 'No abstract is detected'
-            assert 'title' in self.paper_contents, 'No title is detected'
-            paper_structure = self.paper_contents['structure']
-            introduction_idx_array = paper_structure['Introduction']
-            conclusion_idx_array = paper_structure['Conclusion']
-            assert introduction_idx_array[0] >=0, 'No introduction is detected'
-            assert conclusion_idx_array[0] >=0, 'No conclusion is detected'
-        except AssertionError as e:
-            print(f"AssertionError: {e}")
-            return False
-        return True
-
-    def step(self, messages):
-        result = self.run(messages=messages)
-        if 'Failed' in result:
-            time.sleep(self.sleep_time)
-        if self.is_rate_limitation:
-            print('sleep {} seconds'.format(self.sleep_time))
-            time.sleep(self.sleep_time)
-        return result
-    
-    def run(self, messages):
-        for attempt in range(self.max_failure_attempt_each_step):
-            try:
-                response = make_api_call(messages=messages, model=self.model, max_tokens=self.max_tokens, temperature=self.temprature)
-                return response
-            except Exception as e:
-                if attempt == self.max_failure_attempt_each_step - 1:
-                    return "Failed to generate step after {} attempts. $ERROR$: {}".format(self.max_failure_attempt_each_step, str(e))
-                else:
-                    return "Failed to generate step. $ERROR$: {}".format(str(e))
-                time.sleep(2)  # Wait for 1 second before retrying
-        return 'Failed to generate reasoning step.'
-        
-    
-    def abstract_summary(self):
-        """
-        Extract the outline for the slides from abstract
-        """
-        assert len(self.paper_contents['title']) > 0 and len(self.paper_contents['abstract']) > 512
-        prompt = "**title**: {}\n\n**abstract**: {}".format(self.paper_contents['title'], self.paper_contents['abstract'])
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": ABSTRACT_SUMMARY_PROMPT},
-            {"role": "user", "content": prompt},
-            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
-        ]
-        abstract_summary = self.step(messages=messages)
-        try:
-            abstract_summary_dict = json.loads(abstract_summary)
-        except Exception as e:
-            abstract_summary_dict = convert_to_dict(input_string=abstract_summary)
-        
-        trim_abstract_summary_dict = {}
-        for k, v in abstract_summary_dict.items():
-            trim_abstract_summary_dict[trim_string(k)] = v
-        return trim_abstract_summary_dict
-
-    def support_background(self, background: str, introduction: str):
-        """
-        Extract support evidences for background from introduction
-        """
-        prompt = "**title**: {}\n\n**promblem background**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], background, introduction)
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": BACKGROUD_EVIDENCE_PROMPT},
-            {"role": "user", "content": prompt},
-            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
-        ]
-        evidences = self.step(messages=messages)
-        # print('Background evidences = {}'.format(evidences))
-        step_num = 1
-        return evidences, step_num
-
-    def support_research_problem(self, research_problem: str, introduction: str):
-        """
-        Extract support evidences for research problem from introduction
-        """
-        prompt = "**title**: {}\n\n**research problem**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], research_problem, introduction)
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": RESEARCH_PROBLEM_PROMPT},
-            {"role": "user", "content": prompt},
-            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
-        ]
-        evidences = self.step(messages=messages)
-        step_num = 1
-        return evidences, step_num
-    
-    def support_objectives(self, objectives: str, introduction: str):
-        """
-        Extract support evidences for objectives from introduction
-        """
-        prompt = "**title**: {}\n\n**objectives**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], objectives, introduction)
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": OBJECTIVE_PROMPT},
-            {"role": "user", "content": prompt},
-            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
-        ]
-        evidences = self.step(messages=messages)
-        step_num = 1
-        return evidences, step_num
-
-    def support_conclusion(self, conclusion: str, introduction: str, conclusion_text: str, step_wise=True):
-        """
-        Expand conclusion based on full-text conclusion and introducton. 
-        If step_wise = True:
-            1. Summarize introduction while focusing on conclusion part
-            2. Extract conclusion points from introduction summary and full-context conclusion.
-        """
-        step_num = 0
-        prompt = "**title**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], introduction)
-        if step_wise:
-            messages = [
-                {"role": "system", "content": SCHOLAR_PROMPT},
-                {"role": "system", "content": "Given a **tititle** and **introduction** of a research paper, summarize and extract conclusion related information in about 200 words."},
-                {"role": "user", "content": prompt},
-                {"role": "assistant", "content": "I will extract the conclusion following my instructions."}
-            ]
-            instruction_conclusion_summary = self.step(messages=messages)
-            step_num = step_num + 1
-        else:
-            instruction_conclusion_summary = introduction
-
-        prompt = "**title**: {}\n\n**brief conclusion**: {}\n\n**conclusion**: \n\n{}**introduction**: {}".format(self.paper_contents['title'], conclusion, conclusion_text, instruction_conclusion_summary)
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": CONCLUSION_PROMT},
-            {"role": "user", "content": prompt},
-            {"role": "assistant", "content": "I will extract the conclusions following my instructions."}
-        ]
-        evidences = self.step(messages=messages)
-        step_num = step_num + 1
-        return evidences, step_num
-    
-    def support_experiment_results(self, main_results: str, paragraph_list: list):
-        step_num = 0
-        prompt = "**title**: {}\n\n**main results**: {}\n\n".format(self.paper_contents['title'], main_results)
-        iterative_sys_prompt = RESULT_PROMPT_DICT['iterative_prompt']
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": RESULT_PROMPT_DICT['system_instruction']},
-            {"role": "user", "content": prompt},
-            {"role": "system", "content": iterative_sys_prompt},
-        ]
-
-        follow_instruction = {"role": "assistant", "content": "I will extract the experimental information following my instructions."}
-
-        paragraph_summary_array = []
-        for para_idx in range(len(paragraph_list)):
-            para_input_prompt = "Paragraph title: {}\n\nContent: {}\n\n".format(paragraph_list[para_idx]['title'], paragraph_list[para_idx]['content'])
-            user_input = {'role': 'user', 'content': para_input_prompt}
-            messages.append(user_input)
-            messages.append(follow_instruction)
-            para_summary = self.step(messages=messages)
-            step_num = step_num + 1
-            paragraph_summary_array.append(para_summary)
-            messages.pop()
-            messages.pop()
-
-        ## Experimental result summary
-
-        prompt = "**title**: {}\n\n**main results**: {}\n\n".format(self.paper_contents['title'], main_results)
-        summary_prompt = '\n'.join(['**summary** {}:\n\n{}'.format(idx+1, summary) for idx, summary in enumerate(paragraph_summary_array)])
-        input_prompt = prompt + summary_prompt
-
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": RESULT_PROMPT_DICT['final_prompt']},
-            {"role": "user", "content": input_prompt},
-            {"role": "assistant", "content": "I will summarize the experimental results following my instructions."},
-        ]
-
-        result_summary = self.step(messages=messages)
-        step_num = step_num + 1
-        return result_summary, step_num
-
-    def experiment_paragraph_extraction(self,):
-        intro_idx = self.paper_contents['structure']['Introduction'][0]
-        conclusion_idx = self.paper_contents['structure']['Conclusion'][0]
-        experiment_idx_array = self.paper_contents['structure']['Experiments']
-        if len(experiment_idx_array) == 0:
-            experiment_idx_array = [_ for _ in range(intro_idx+1, conclusion_idx)]
-        assert len(experiment_idx_array) > 0 and max(experiment_idx_array) < len(self.paper_contents['main_text'])
-        experiment_idx_array = [intro_idx] + experiment_idx_array
-        paragraphs = [self.paper_contents['main_text'][_] for _ in experiment_idx_array]
-        return paragraphs
-    
-    def support_methodology(self, method_overview: str, paragraph_list: list):
-        step_num = 0
-        prompt = "**title**: {}\n\n**method overview**: {}\n\n".format(self.paper_contents['title'], method_overview)
-        iterative_sys_prompt = METHOD_PROMPT_DICT['iterative_prompt']
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": METHOD_PROMPT_DICT['system_instruction']},
-            {"role": "user", "content": prompt},
-            {"role": "system", "content": iterative_sys_prompt},
-        ]
-
-        follow_instruction = {"role": "assistant", "content": "I will extract the method information following my instructions."}
-
-        method_summary_array = []
-        for para_idx in range(len(paragraph_list)):
-            para_input_prompt = "Paragraph title: {}\n\nContent: {}\n\n".format(paragraph_list[para_idx]['title'], paragraph_list[para_idx]['content'])
-            user_input = {'role': 'user', 'content': para_input_prompt}
-            messages.append(user_input)
-            messages.append(follow_instruction)
-            method_summary = self.step(messages=messages)
-            step_num = step_num + 1
-            method_summary_array.append(method_summary)
-            messages.pop()
-            messages.pop()
-
-        ## Method summary
-        prompt = "**title**: {}\n\n**method overview**: {}\n\n".format(self.paper_contents['title'], method_overview)
-        method_summary_prompt = '\n'.join(['**method summary** {}:\n\n{}'.format(idx+1, summary) for idx, summary in enumerate(method_summary_array)])
-        input_prompt = prompt + method_summary_prompt
-
-        messages = [
-            {"role": "system", "content": SCHOLAR_PROMPT},
-            {"role": "system", "content": METHOD_PROMPT_DICT['final_prompt']},
-            {"role": "user", "content": input_prompt},
-            {"role": "assistant", "content": "I will generate a step-by-step method summary following my instructions."},
-        ]
-        method_summary = self.step(messages=messages)
-        step_num = step_num + 1
-        return method_summary, step_num
-        
-    def method_paragraph_extraction(self,):
-        intro_idx = self.paper_contents['structure']['Introduction'][0]
-        conclusion_idx = self.paper_contents['structure']['Conclusion'][0]
-        method_idx_array = self.paper_contents['structure']['Methods']
-        if len(method_idx_array) == 0:
-            method_idx_array = [_ for _ in range(intro_idx+1, conclusion_idx)]
-        assert len(method_idx_array) > 0 and max(method_idx_array) < len(self.paper_contents['main_text'])
-        method_idx_array = [intro_idx] + method_idx_array
-        paragraphs = [self.paper_contents['main_text'][_] for _ in method_idx_array]
-        return paragraphs
-
-    def generate_slides(self, verbose=False, revision=True):
-        ## Step 1: Paper content extraction
-        intro_idx = self.paper_contents['structure']['Introduction'][0]
-        introduction = self.paper_contents['main_text'][intro_idx]['content']
-        assert len(introduction) > 512, 'introduction = {}, content = {}'.format(introduction, self.paper_contents['main_text'])
-        conclusion_idx = self.paper_contents['structure']['Conclusion'][0]
-        conclusion = self.paper_contents['main_text'][conclusion_idx]['content']
-        assert len(conclusion) > 128, 'conclusion = {}, content = {}'.format(introduction, self.paper_contents['main_text'])
-        method_paragraphs = self.method_paragraph_extraction()
-        experiment_paragraphs = self.experiment_paragraph_extraction()
-
-        start_time = time.time()
-        ## Step 2: slides structure extraction from abstract
-        model_call_number = 0
-        print('Slides structure generation')
-        slides = {'Title': self.paper_contents['title']}
-        outline_dict = self.abstract_summary()
-        model_call_number += 1
-        slides['Outline'] = outline_dict
-
-        print('Slides generation...')
-        background = outline_dict.get('Background', '')
-        slides['Background'], b_steps = self.support_background(background=background, introduction=introduction)
-        model_call_number += b_steps
-
-        research_problem = outline_dict.get('Research problem', '')
-        slides['Research problem'], r_steps = self.support_research_problem(research_problem=research_problem, introduction=introduction)
-        model_call_number += r_steps
-        
-        objectives = outline_dict.get('Objectives', '')
-        slides['Objectives'], o_steps = self.support_objectives(objectives=objectives, introduction=introduction)
-        model_call_number += o_steps
-
-        brief_conclusion = outline_dict.get('Conclusions', '')
-        slides['Conclusions'], c_steps = self.support_conclusion(conclusion=brief_conclusion, introduction=introduction, conclusion_text=conclusion, step_wise=True)
-        model_call_number += c_steps
-
-        results = outline_dict.get('Results', '')
-        result_summary, res_steps = self.support_experiment_results(main_results=results, paragraph_list=experiment_paragraphs)
-        slides['Results'] = result_summary
-        model_call_number += res_steps
-
-        methodology = outline_dict.get('Methodology', '')
-        method_summary, m_steps = self.support_methodology(method_overview=methodology, paragraph_list=method_paragraphs)
-        model_call_number += m_steps
-        slides['Methodology'] = method_summary
-        runtime = time.time() - start_time
-        print('Slide generation takes {:.4f} seconds with {} function calls'.format(runtime, model_call_number))
-        if verbose:
-            slides_content = self.slides2markdown_v2(slides=slides)
-            if revision:
-                slides_content = self.slides_revision(slide_content=slides_content)
-                slides_array = markdown_to_slide_dicts(full_markdown=slides_content)
-                revised_slides = {k: v for d in slides_array for k, v in d.items()}
-                if verbose:
-                    print('Json format:\n{}'.format(json.dumps(revised_slides, indent=4)))
-                    print('\n' * 3)
-                    print('paper keywords:\n{}'.format(self.paper_contents.keys()))
-                return revised_slides
-            if verbose:
-                print('Generated slides:\n{}'.format(slides_content))
-                print('Json format:\n{}'.format(json.dumps(slides, indent=4)))
-        return slides
-    
-    def slides_revision(self, slide_content: str):
-        messages = [
-            {"role": "system", "content": SLIDES_REVISION_PROMPT},
-            {"role": "user", "content": slide_content},
-            {"role": "assistant", "content": "I will revise the representation slides following my instructions."}
-        ]
-        print('Slides final revision')
-        revised_slides = make_api_call(model=self.revise_model, messages=messages, max_tokens=2048, temperature=self.temprature)
-        return revised_slides
-
-    def slides2markdown(self, slides: dict):
-        slides_content = ''
-        slides_content += '**Title**\n{}\n\n'.format(slides['Title'])
-        slides_content += '{}\n'.format(SLIDE_SEP)
-        slides_content += '**Outline**\n\n'
-        outline_dict = slides['Outline']
-        for sect_name, sect_content in outline_dict.items():
-            slides_content += '{}\n--\t\t{}\n\n'.format(sect_name, sect_content)
-        slides_content += '{}\n'.format(SLIDE_SEP)
-        for sect_name in outline_dict.keys():
-            if sect_name in slides:
-                slides_content += '**{}**\n\n'.format(sect_name)
-                slides_content += '{}\n\n'.format(slides[sect_name])
-                slides_content += '{}\n'.format(SLIDE_SEP)
-        return slides_content
-    
-    def slides2markdown_v2(self, slides: dict, indent=0):
-        slides_content = dict_to_markdown_list(d=slides, indent=indent)
-        return slides_content
-
-    def save_to_slides(self, slides: dict, logo_path='logo.png', file_name='slides.pptx'):
-        authors = self.paper_contents.get('author', None)
-        if isinstance(authors, list):
-            authors = authors[0]
-        else:
-            authors = None
-        # print('authors', authors)
-        dict2ppt = Dict2PPT(logo_path=logo_path)
-        dict2ppt.build_slides(slide_dict=slides, authors=authors)
-        dict2ppt.save(file_name=file_name)
-        full_path = os.path.abspath(file_name)
-        return full_path
-