Update app.py

app.py

@@ -17,18 +17,17 @@ logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
+
 def proc_submission(
     input_text: str,
-    summary_type: str,
-    model_type: str,
+    model_size: str,
     num_beams,
     token_batch_length,
     length_penalty,
-    max_input_length: int = 2000,
+    max_input_length: int = 768,
 ):
     """
     proc_submission - a helper function for the gradio module to process submissions
-    
     Args:
         input_text (str): the input text to summarize
         model_size (str): the size of the model to use
@@ -38,93 +37,62 @@ def proc_submission(
         repetition_penalty (float): the repetition penalty to use
         no_repeat_ngram_size (int): the no repeat ngram size to use
         max_input_length (int, optional): the maximum input length to use. Defaults to 768.
-        
     Returns:
-        str in HTML format, string of the summary, str of compression rate in %
+        str in HTML format, string of the summary, str of score
     """
 
-    settings_tldr = {
-        "length_penalty": float(length_penalty),#0.6,
-        "repetition_penalty": 3.5,
-        "no_repeat_ngram_size": 3,
-        "encoder_no_repeat_ngram_size": 4,
-        "num_beams": int(num_beams),
-        "min_length": 11,
-        "max_length": 62,
-        "early_stopping": True,
-    }
-    settings_det = {
-        "length_penalty": float(length_penalty),#2.0 if (model_type == "LED") else 0.8,
+    settings = {
+        "length_penalty": float(length_penalty),
         "repetition_penalty": 3.5,
         "no_repeat_ngram_size": 3,
         "encoder_no_repeat_ngram_size": 4,
         "num_beams": int(num_beams),
-        "min_length": 100,
-        "max_length": 512,#int(token_batch_length // 4) if (token_batch_length <500) else 512,
+        "min_length": 4,
+        "max_length": int(token_batch_length // 4),
         "early_stopping": True,
+        "do_sample": False,
     }
     st = time.perf_counter()
     history = {}
     clean_text = clean(input_text, lower=False)
-    #max_input_length = 2048 if model_type == "tldr" else max_input_length
+    max_input_length = 2048 if model_size == "tldr" else max_input_length
     processed = truncate_word_count(clean_text, max_input_length)
 
     if processed["was_truncated"]:
         tr_in = processed["truncated_text"]
-        msg = f"Input text was truncated to {max_input_length} words to fit within computational constraints"
+        msg = f"Input text was truncated to {max_input_length} words to fit within the computational constraints"
         logging.warning(msg)
         history["WARNING"] = msg
     else:
         tr_in = input_text
         msg = None
-        
-    #if (summary_type == "TLDR"):
-        #_summaries = summarize_via_tokenbatches(
-            #tr_in,
-            #model_led_tldr if (model_type == "LED") else model_tldr,
-            #tokenizer_led_tldr if (model_type == "LED") else tokenizer_tldr,
-            #batch_length=token_batch_length,
-            #**settings_tldr,
-        #)
-        
-    #else:
-        #_summaries = summarize_via_tokenbatches(
-            #tr_in,
-            #model_led_det if (model_type == "LED") else model_det,
-            #tokenizer_led_det if (model_type == "LED") else tokenizer_det,
-            #batch_length=token_batch_length,
-            #**settings_det,
-        #)
-        
-    settings = settings_tldr if summary_type == 'tldr' else settings_det
-           
+
     _summaries = summarize_via_tokenbatches(
         tr_in,
-        model_tldr if (summary_type == "tldr") else model_det,
-        tokenizer_tldr if (summary_type == "tldr") else tokenizer_det,
+        model_sm if model_size == "tldr" else model,
+        tokenizer_sm if model_size == "tldr" else tokenizer,
         batch_length=token_batch_length,
         **settings,
     )
-    
     sum_text = [f"Section {i}: " + s["summary"][0] for i, s in enumerate(_summaries)]
-    compression_rate = [
-        f" - Section {i}: {round(s['compression_rate'],3)}"
+    sum_scores = [
+        f" - Section {i}: {round(s['summary_score'],4)}"
         for i, s in enumerate(_summaries)
     ]
 
     sum_text_out = "\n".join(sum_text)
-    history["compression_rate"] = "<br><br>"
-    rate_out = "\n".join(compression_rate)
+    history["Summary Scores"] = "<br><br>"
+    scores_out = "\n".join(sum_scores)
     rt = round((time.perf_counter() - st) / 60, 2)
     print(f"Runtime: {rt} minutes")
     html = ""
-    html += f"<p>Runtime: {rt} minutes on CPU inference</p>"
+    html += f"<p>Runtime: {rt} minutes on CPU</p>"
     if msg is not None:
         html += f"<h2>WARNING:</h2><hr><b>{msg}</b><br><br>"
 
     html += ""
 
-    return html, sum_text_out, rate_out
+    return html, sum_text_out, scores_out
 
 
 def load_single_example_text(
@@ -172,10 +140,8 @@ def load_uploaded_file(file_obj):
 
 if __name__ == "__main__":
 
-    model_det, tokenizer_det = load_model_and_tokenizer("Blaise-g/longt5_tglobal_large_sumpubmed")
-    model_tldr, tokenizer_tldr = load_model_and_tokenizer("Blaise-g/longt5_tglobal_large_scitldr")
-    #model_led_det, tokenizer_led_det = #load_model_and_tokenizer("Blaise-g/led_pubmed_sumpubmed_1")
-    #model_led_tldr, tokenizer_led_tldr = load_model_and_tokenizer("Blaise-g/led_large_sumpbumed_scitldr")
+    model, tokenizer = load_model_and_tokenizer("Blaise-g/longt5_tglobal_large_sumpubmed")
+    model_sm, tokenizer_sm = load_model_and_tokenizer("Blaise-g/longt5_tglobal_large_scitldr")
 
     name_to_path = load_example_filenames(_here / "examples")
     logging.info(f"Loaded {len(name_to_path)} examples")
@@ -185,20 +151,17 @@ if __name__ == "__main__":
 
         gr.Markdown("# Automatic summarization of biomedical research papers with neural abstractive methods into a long and comprehensive synopsis or extreme TLDR summary version")
         gr.Markdown(
-            "A rather simple demo (developed for my Master Thesis project) using an ad-hoc fine-tuned LongT5 or LED model to summarize long biomedical articles (or any scientific text related to the biomedical domain) into a detailed, explanatory synopsis or extreme TLDR summary."
+            "A rather simple demo developed for my Master Thesis project using ad-hoc fine-tuned abstractive summarization models to summarize long biomedical articles (or any scientific text related to the biomedical domain) into a detailed, explanatory synopsis or extreme TLDR summary."
         )
         with gr.Column():
 
-            gr.Markdown("### Load Text Inputs, Select Model & Summary Type")
+            gr.Markdown("### Select Summary type and text generation parameters then load input text")
             gr.Markdown(
-                "Enter text below in the text area. The text will be summarized [using the selected text generation parameters](https://huggingface.co/blog/how-to-generate). Optionally load an available example below or upload a file."
+                "Enter text below in the text area. The text will be summarized [using the selected parameters](https://huggingface.co/blog/how-to-generate). Optionally load an example below or upload a file."
             )
             with gr.Row():
-                summary_type = gr.Radio(
-                    choices=["tldr", "detailed"], label="Summary Type", value="tldr"
-                )
-                model_type = gr.Radio(
-                    choices=["LongT5", "LED"], label="Model Architecture", value="LongT5"
+                model_size = gr.Radio(
+                    choices=["tldr", "detailed"], label="Summary type", value="detailed"
                 )
                 num_beams = gr.Radio(
                     choices=[2, 3, 4],
@@ -206,7 +169,7 @@ if __name__ == "__main__":
                     value=2,
                 )
             gr.Markdown(
-                "_The LED model is less performant than the LongT5 model, but it's smaller in terms of size and therefore all other parameters being equal allows for a longer input sequence._"
+                "_The base model is less performant than the large model, but is faster and will accept up to 2048 words per input (Large model accepts up to 768)._"
             )
             with gr.Row():
                 length_penalty = gr.inputs.Slider(
@@ -219,9 +182,8 @@ if __name__ == "__main__":
                 token_batch_length = gr.Radio(
                     choices=[512, 768, 1024],
                     label="token batch length",
-                    value=1024,
+                    value=512,
                 )
-
             with gr.Row():
                 example_name = gr.Dropdown(
                     list(name_to_path.keys()),
@@ -233,7 +195,7 @@ if __name__ == "__main__":
             input_text = gr.Textbox(
                 lines=6,
                 label="Input Text (for summarization)",
-                placeholder="Enter any scientific text to be condensed into a long and comprehensive digested format or an extreme TLDR summary version, the text will be preprocessed and truncated if necessary to fit within the computational constraints. The models were trained to handle long scientific papers but generalize reasonably well also to shorter text documents like abstracts with an appropriate. Might take a while to produce long summaries :)",
+                placeholder="Enter text to summarize, the text will be cleaned and truncated on Spaces. Narrative, academic (both papers and lecture transcription), and article text work well. May take a bit to generate depending on the input text :)",
             )
             gr.Markdown("Upload your own file:")
             with gr.Row():
@@ -249,7 +211,7 @@ if __name__ == "__main__":
         with gr.Column():
             gr.Markdown("## Generate Summary")
             gr.Markdown(
-                "Summary generation should take approximately less than 2 minutes for most settings."
+                "Summary generation should take approximately 1-2 minutes for most settings."
             )
             summarize_button = gr.Button(
                 "Summarize!",
@@ -259,24 +221,24 @@ if __name__ == "__main__":
             output_text = gr.HTML("<p><em>Output will appear below:</em></p>")
             gr.Markdown("### Summary Output")
             summary_text = gr.Textbox(
-                label="Summary 📝", placeholder="The generated 📝 will appear here"
+                label="Summary", placeholder="The generated summary will appear here"
             )
             gr.Markdown(
-                "The compression rate indicates the ratio between the machine-generated summary length and the input text (from 0% to 100%). The higher the compression rate the more extreme the summary is."
+                "The summary scores can be thought of as representing the quality of the summary. less-negative numbers (closer to 0) are better:"
             )
-            compression_rate = gr.Textbox(
-                label="Compression rate 🗜", placeholder="The 🗜 will appear here"
+            summary_scores = gr.Textbox(
+                label="Summary Scores", placeholder="Summary scores will appear here"
             )
 
             gr.Markdown("---")
 
         with gr.Column():
-            gr.Markdown("## About the Models")
+            gr.Markdown("## About the Model")
             gr.Markdown(
                 "- [Blaise-g/longt5_tglobal_large_sumpubmed](https://huggingface.co/Blaise-g/longt5_tglobal_large_sumpubmed) is a fine-tuned checkpoint of [Stancld/longt5-tglobal-large-16384-pubmed-3k_steps](https://huggingface.co/Stancld/longt5-tglobal-large-16384-pubmed-3k_steps) on the [SumPubMed dataset](https://aclanthology.org/2021.acl-srw.30/). [Blaise-g/longt5_tglobal_large_scitldr](https://huggingface.co/Blaise-g/longt5_tglobal_large_scitldr) is a fine-tuned checkpoint of [Blaise-g/longt5_tglobal_large_sumpubmed](https://huggingface.co/Blaise-g/longt5_tglobal_large_sumpubmed) on the [Scitldr dataset](https://arxiv.org/abs/2004.15011). The goal was to create two models capable of handling the complex information contained in long biomedical documents and subsequently producing scientific summaries according to one of the two possible levels of conciseness: 1) A long explanatory synopsis that retains the majority of domain-specific language used in the original source text. 2)A one sentence long, TLDR style summary."
             )
             gr.Markdown(
-                "- The two most important parameters-empirically-are the `num_beams` and `token_batch_length`. However, increasing these will also increase the amount of time it takes to generate a summary."
+                "- The two most important text generation parameters are the `num_beams` and `token_batch_length`. However, increasing them will also increase the amount of execution time needed to generate a summary."
             )
             gr.Markdown("---")
 
@@ -292,13 +254,12 @@ if __name__ == "__main__":
             fn=proc_submission,
             inputs=[
                 input_text,
-                summary_type,
-                model_type,
-                length_penalty,
+                model_size,
                 num_beams,
                 token_batch_length,
+                length_penalty,
             ],
-            outputs=[output_text, summary_text, compression_rate],
+            outputs=[output_text, summary_text, summary_scores],
         )
 
     demo.launch(enable_queue=True, share=False)