add initial llm4research app

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.env

README copy.md

@@ -0,0 +1,12 @@
+---
+title: Llm4research
+emoji: 🏆
+colorFrom: gray
+colorTo: red
+sdk: gradio
+sdk_version: 4.21.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,226 @@
+import gradio as gr
+import pandas as pd
+
+from extract_answer import extract_endpoint_llama
+from generate_answers_matrix import generate_answers
+
+example_queries = [
+    "What is the size, shape, and energy (watt hour) or capacity (Amp hour) of battery discussed in the paper?",
+    "What specific mechanical testing methods were used to quantify strength?",
+    "What parameters they used to quantify the benefit of their individual design (mass saving, increased run time, etc.)?",
+    "What material chemistry combination (on the anode, cathode, separator, and electrolyte) was used in these papers?",
+    "What kind of end use application they targeted?",
+]
+MAX_CATEGORIES = 10
+
+
+def change_button(text):
+    if len(text) > 0:
+        return gr.Button(interactive=True)
+    else:
+        return gr.Button(interactive=False)
+
+
+def generate_category_btn(cluster_output):
+    unique_categories = set()
+    for item in cluster_output:
+        unique_categories.update(item["categories"])
+
+    update_show = [gr.Button(visible=True, value=w) for w in unique_categories]
+    update_hide = [
+        gr.Button(visible=False, value="")
+        for _ in range(MAX_CATEGORIES - len(unique_categories))
+    ]
+    return update_show + update_hide
+
+
+def add_query(this_query, query_list):
+    if not query_list:
+        query_list = [this_query]
+    elif this_query not in query_list:
+        query_list.append(this_query)
+
+    df = pd.DataFrame(query_list, columns=["Queries"])
+    return query_list, df
+
+
+def reset_queries():
+    return [], pd.DataFrame(columns=["Queries"])
+
+
+btn_list = []
+
+
+with gr.Blocks() as app:
+    gr.Markdown(
+        """
+    # Paper Query Matrix
+    This app extracts text from papers and then searches for relevant excerpts based on user queries.
+
+    ### Input
+    1. A group of research papers that you want to run the queries on.
+    1. Queries that you would like to know about these papers.
+
+    ### Output
+    Table containing the relevant excerpts from the papers for each of the queries.
+
+    # 1. Upload + Extract
+    First, upload the papers you want to analyze. Currently, we only support PDFs. Once they're uploaded, you can extract the text data from the papers.
+    """
+    )
+    file_upload = gr.Files()
+    extract_btn = gr.Button("Extract", interactive=False)
+    with gr.Tab(label="Table"):
+        extract_df = gr.Dataframe(
+            datatype="markdown", column_widths=[100, 400], wrap=True
+        )
+    with gr.Tab(label="JSON"):
+        extract_output = gr.JSON(label="Extract Output")
+
+    gr.Markdown(
+        """
+    ----------------
+    # 2. Create Queries
+    Enter a the queries that you would like to know about these papers. This will search the papers to find the most relevant excerpts.
+    """
+    )
+
+    gr.Markdown(
+        """
+    ### Input
+    """
+    )
+    query = gr.Textbox(
+        label="Query", value=example_queries[1], lines=3, placeholder="Enter a query"
+    )
+    add_query_btn = gr.Button("Add Query", interactive=False)
+    gr.Markdown(
+        """
+    You can also select some example queries below.
+    """
+    )
+    with gr.Row():
+        q0_btn = gr.Button(example_queries[0], interactive=False)
+        q1_btn = gr.Button(example_queries[1], interactive=False)
+        q2_btn = gr.Button(example_queries[2], interactive=False)
+        q3_btn = gr.Button(example_queries[3], interactive=False)
+        q4_btn = gr.Button(example_queries[4], interactive=False)
+
+    gr.Markdown(
+        """
+    ### Output
+    """
+    )
+    with gr.Tab(label="Queries Table"):
+        query_df = gr.Dataframe(
+            datatype="markdown", column_widths=[100, 100, 300], wrap=True
+        )
+    with gr.Tab(label="JSON"):
+        query_output = gr.JSON(label="Queries")
+
+    reset_query_btn = gr.Button("Clear Queries", interactive=False)
+
+    gr.Markdown(
+        """
+    ----------------
+    # 3. Extract Answers
+    Gather the relevant excerpts from each of the papers
+    """
+    )
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(
+                """
+            ### Input
+            """
+            )
+            generate_answers_btn = gr.Button("Extract Answers", interactive=False)
+
+    gr.Markdown(
+        """
+    ### Answer Matrix
+    """
+    )
+    with gr.Tab(label="Output Table"):
+        answers_df = gr.Dataframe(
+            datatype="markdown", column_widths=[100, 100, 300], wrap=True
+        )
+    with gr.Tab(label="JSON"):
+        answers_output = gr.JSON(label="Answer Output")
+
+    # Event handlers
+    file_upload.change(fn=change_button, inputs=[file_upload], outputs=[extract_btn])
+
+    extract_output.change(
+        fn=change_button, inputs=[extract_output], outputs=[add_query_btn]
+    )
+    extract_output.change(fn=change_button, inputs=[extract_output], outputs=[q0_btn])
+    extract_output.change(fn=change_button, inputs=[extract_output], outputs=[q1_btn])
+    extract_output.change(fn=change_button, inputs=[extract_output], outputs=[q2_btn])
+    extract_output.change(fn=change_button, inputs=[extract_output], outputs=[q3_btn])
+    extract_output.change(fn=change_button, inputs=[extract_output], outputs=[q4_btn])
+    extract_output.change(
+        fn=change_button, inputs=[extract_output], outputs=[reset_query_btn]
+    )
+
+    extract_btn.click(
+        fn=extract_endpoint_llama,
+        inputs=[file_upload],
+        outputs=[extract_output, extract_df],
+    )
+
+    q0_btn.click(
+        fn=add_query,
+        inputs=[q0_btn, query_output],
+        outputs=[query_output, query_df],
+    )
+
+    q1_btn.click(
+        fn=add_query,
+        inputs=[q1_btn, query_output],
+        outputs=[query_output, query_df],
+    )
+
+    q2_btn.click(
+        fn=add_query,
+        inputs=[q2_btn, query_output],
+        outputs=[query_output, query_df],
+    )
+
+    q3_btn.click(
+        fn=add_query,
+        inputs=[q3_btn, query_output],
+        outputs=[query_output, query_df],
+    )
+
+    q4_btn.click(
+        fn=add_query,
+        inputs=[q4_btn, query_output],
+        outputs=[query_output, query_df],
+    )
+
+    add_query_btn.click(
+        fn=add_query,
+        inputs=[query, query_output],
+        outputs=[query_output, query_df],
+    )
+
+    reset_query_btn.click(
+        fn=reset_queries,
+        inputs=[],
+        outputs=[query_output, query_df],
+    )
+
+    query_output.change(
+        fn=change_button, inputs=[query_output], outputs=[generate_answers_btn]
+    )
+
+    generate_answers_btn.click(
+        fn=generate_answers,
+        inputs=[extract_output, query_output],
+        outputs=[answers_output, answers_df],
+        #     api_name="cluster",
+    )
+
+if __name__ == "__main__":
+    app.launch()

extract_answer.py

@@ -0,0 +1,57 @@
+import re
+
+import pandas as pd
+from dotenv import load_dotenv
+from llama_index.core import SimpleDirectoryReader
+from llama_parse import LlamaParse
+
+load_dotenv()
+MIN_PARAGRAPH_LENGTH = 50
+
+
+def extract_paragraphs(markdown_text):
+    """
+    Extract paragraphs from a markdown text.
+    """
+    # Split the text into paragraphs using regex
+    paragraphs = re.split(r"\n\n+", markdown_text)
+    # Remove leading and trailing whitespaces from each paragraph
+    paragraphs = [p.strip() for p in paragraphs if p.strip()]
+    paragraphs = [
+        p
+        for p in paragraphs
+        if len(p) >= MIN_PARAGRAPH_LENGTH and not p.startswith("#")
+    ]
+    print(f"created {len(paragraphs)} paragraphs\n", paragraphs)
+
+    return paragraphs
+
+
+def extract_endpoint_llama(file_paths):
+    """
+    Extract PDFs using LlamaParse.
+    """
+
+    # set up parser
+    parser = LlamaParse(result_type="markdown")  # "markdown" and "text" are available
+
+    # use SimpleDirectoryReader to parse our file
+    file_extractor = {".pdf": parser}
+    documents = SimpleDirectoryReader(
+        input_files=file_paths, file_extractor=file_extractor
+    ).load_data()
+
+    extracted_data = []
+
+    for doc in documents:
+        print(doc.text[:500])
+        paragraphs = extract_paragraphs(doc.text)
+        data = {
+            "paper": doc.metadata["file_name"],
+            "chunks": paragraphs,
+        }
+        extracted_data.append(data)
+
+    df = pd.DataFrame(extracted_data)
+
+    return [extracted_data, df]

generate_answers_matrix.py

@@ -0,0 +1,118 @@
+import gradio as gr
+import pandas as pd
+from uniflow.flow.client import TransformClient
+from uniflow.flow.config import TransformOpenAIConfig
+from uniflow.op.prompt import Context
+
+DEBUG = False
+
+
+def generate_relevant_chunks(query, input_data, progress=gr.Progress()):
+    """
+    Generate relevant chunks of text from a list of papers based on a query.
+    """
+    data_list = []
+    for paper in input_data:  # progress.tqdm(input_data, desc="Papers"):
+        data = [Context(context=query, paragraph=p) for p in paper["chunks"]]
+        data_list.append({"paper": paper["paper"], "data": data})
+
+    instruction = """
+# Task: I am a researcher trying to understand information across several research papers. You are to determine which of the chunks most directly contains information related to the query.
+## Input:
+1. context: A brief query or description of the information I am looking for.
+2. paragraph: An paragraph from a research paper.
+## Evaluation Criteria: You should pick which sentence(s) contains directly relevant information to the context. The best answer is the sentences that most directly answer or contain the information specific to the context. If there are no such sentences, you should answer with ["None"].
+## Response Format: Your response should only include two fields below:
+1. explanation: Reasoning behind your judgment, explaining why the answer is appropriate or not.
+2. answer: The best sentence(s) that meet the Evaluation Criteria as a list of strings. This should be ["None"] if no sentence answers the query. At most, include 3 sentences.
+"""
+
+    few_shot_examples = []
+
+    num_thread_batch_size = 16
+
+    config = TransformOpenAIConfig()
+    config.prompt_template.instruction = instruction
+    config.prompt_template.few_shot_prompt = few_shot_examples
+    config.model_config.model_name = "gpt-4-1106-preview"
+    config.model_config.response_format = {"type": "json_object"}
+    config.model_config.num_call = 1
+    config.model_config.temperature = 0.0
+    config.model_config.num_thread = num_thread_batch_size
+    config.model_config.batch_size = num_thread_batch_size
+
+    client = TransformClient(config)
+
+    output = []
+
+    for paper in data_list:
+        init_output = client.run(paper["data"])
+        combined_output = init_output[0]
+        combined_output["output"][0]["response"][0]["explanation"] = [
+            combined_output["output"][0]["response"][0]["explanation"]
+        ]
+        if DEBUG:
+            print(combined_output)
+        for item in init_output[1:]:
+            combined_output["output"][0]["response"][0]["answer"].extend(
+                item["output"][0]["response"][0]["answer"]
+            )
+            combined_output["output"][0]["response"][0]["explanation"].append(
+                item["output"][0]["response"][0]["explanation"]
+            )
+        output.append(combined_output)
+
+    output_answers = []
+
+    for idx, o in enumerate(output):
+        filtered_answers = [
+            item for item in o["output"][0]["response"][0]["answer"] if item != "None"
+        ]
+        if len(filtered_answers) == 0:
+            filtered_answers = ["None"]
+        output_answers.append(
+            {"paper": input_data[idx]["paper"], "answer": filtered_answers}
+        )
+
+    df = pd.DataFrame(output_answers)
+
+    return [output_answers, df]
+
+
+def generate_answers(papers, queries, progress=gr.Progress()):
+    """
+    Generate relevant chunks of text from a list of papers based on a list of queries.
+    """
+    print(len(papers), len(queries))
+    output_data = []
+    for query in progress.tqdm(queries, desc="Queries"):
+        [data, df] = generate_relevant_chunks(query, papers)
+        # print("data", data)
+        for d in data:
+            d["query"] = query
+        # data["query"] = query
+        output_data.extend(data)
+    df = create_df(output_data)
+    return output_data, df
+
+
+def create_df(data):
+    query_data = {item["query"]: {} for item in data}
+
+    # Fill in query data
+    for item in data:
+        query = item["query"]
+        paper = item["paper"]
+        answer = item["answer"][0] if item["answer"] else None
+        query_data[query][paper] = answer
+
+    # Create DataFrame from the dictionary
+    df = pd.DataFrame.from_dict(query_data, orient="index")
+
+    # Reset index to include 'Queries' as a column
+    df = df.rename_axis("Queries").reset_index()
+
+    # Reorder columns so that 'Queries' is the first column
+    cols = ["Queries"] + [col for col in df.columns if col != "Queries"]
+    df = df[cols]
+    return df

requirements.txt

@@ -0,0 +1,7 @@
+uniflow==0.0.25
+python-dotenv==1.0.1
+gradio==4.19.2
+llama-index==0.10.19
+llama-parse==0.3.9
+rapidfuzz==3.6.2
+dataclasses-json==0.6.4