pegasus

app.py

@@ -1,9 +1,11 @@
 import datetime
+import os
+import time
 import logging
 import nltk
 import validators
 import streamlit as st
-from summarizer import Summarizer
+from summarizer import summarizer_init, summarizer_summarize
 from config import MODELS
 from warnings import filterwarnings
 
@@ -15,91 +17,141 @@ from utils import (
     read_text_from_file,
 )
 
+# summarizer = None
+# from rouge import Rouge
 
-from rouge import Rouge
-
-# def filer():
-#     # return "logs/log "
-#     today = datetime.datetime.today()
-#     log_filename = f"logs/{today.year}-{today.month:02d}-{today.day:02d}.log"
-#     return log_filename
-
-# file_handler = logging.FileHandler(filer())
-# # file_handler = logging.handlers.TimedRotatingFileHandler(filer(),when="D")
-# file_handler.setLevel(logging.INFO)
-
-# logging.basicConfig(
-#     level=logging.DEBUG,
-#     format="%(asctime)s %(levelname)s (%(name)s) : %(message)s",
-#     datefmt="%Y-%m-%d %H:%M:%S",
-#     handlers=[file_handler],
-#     force=True,
-# )
 
 logger = logging.getLogger(__name__)
 
-
-if "api_key" not in st.session_state:
-    st.session_state.api_key = " "
-
-
-@st.cache_resource
 def initialize_app():
     nltk.download("punkt")
+    SESSION_DEFAULTS = {
+        "model_type": "local",
+        "model_name": "long-t5 v1",
+        "summarizer_type": "Map Reduce",
+        "is_parameters_changed":False,
+        # "user_question":'',
+        'openai_api_key':'',
+    }
 
-@st.cache_resource
-def init_summarizer(model_name,api_key=None):
+    for k, v in SESSION_DEFAULTS.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
 
-    model_type = "local"
-    if model_name == "OpenAI":
-        model_type = "openai"
+    # init_summarizer(st.session_state.model_name,api_key=None)
 
-    model_path = MODELS[model_name]
-    if model_type == "openai":
-        #validation logic
+@st.cache_resource
+def init_summarizer(model_name,api_key=None):
+    with st.spinner(
+            text="initialising the summarizer. This might take a few seconds ..."
+        ):
+        model_type = "local"
+        if model_name == "OpenAI":
+            model_type = "openai"
+
+        model_path = MODELS[model_name]
+        if model_type == "openai":
+            #validation logic
+            api_key = st.session_state.openai_api_key
+            tokenizer,base_summarizer = summarizer_init(model_path,model_type,api_key)
+        else:
+            logger.info(f"Model for summarization : {model_path}")
+            tokenizer,base_summarizer = summarizer_init(model_path, model_type)
+
+        alert =  st.success("summarizer initialised")
+        time.sleep(1) # Wait for 1 seconds
+        alert.empty() # Clear the alert
+        return model_type, tokenizer, base_summarizer
+
+def update_parameters_change():
+    st.session_state.is_parameters_changed = True
+
+
+def parameters_change_button(model_name, summarizer_type):
+    st.session_state.model_name = model_name
+    st.session_state.summarizer_type = summarizer_type
+    st.session_state.is_parameters_changed = False
+    # init_summarizer(model_name,api_key=None)
+    alert =  st.success("chat parameters updated")
+    time.sleep(2) # Wait for 1 seconds
+    alert.empty() # Clear the alert
+
+import re
+def is_valid_open_ai_api_key(secretKey):
+    if re.search("^sk-[a-zA-Z0-9]{32,}$", secretKey ): 
+        return True
+    else: return False
+
+def side_bar():
+    with st.sidebar:
+        st.subheader("Model parameters")
+
+        with st.form('param_form'):
+            # st.info('Info: use openai chat model for best results')
+            model_name = st.selectbox(
+                "Chat model",
+                MODELS,
+                #  options=["long-t5 v0", "long-t5 v1",  "pegasus-x-large v1", "OpenAI"],
+                key="Model Name",
+                help="Select the LLM model for summarization",
+                # on_change=update_parameters_change,
+            )
+
+            summarizer_type = st.selectbox(
+                "Summarizer Type for Long Text", options=["Map Reduce", "Refine"]
+            )
+
+            submitted = st.form_submit_button(
+                "Save Parameters",
+                # on_click=update_parameters_change
+                )
+       
+            if submitted:
+                parameters_change_button(model_name, summarizer_type)
+
+
+        st.markdown("\n")
+        if st.session_state.model_name == 'openai':
+            with st.form('openai api key'):
+                api_key = st.text_input(
+                    "Enter openai api key", 
+                    type="password",
+                    value=st.session_state.openai_api_key,
+                    help="enter an openai api key created from 'https://platform.openai.com/account/api-keys'",
+                )
+
+                submit_key = st.form_submit_button(
+                    "Save key",
+                    # on_click=update_parameters_change
+                    )
+        
+                if submit_key:
+                    st.session_state.openai_api_key = api_key
+                    # st.text(st.session_state.openai_api_key)
+                    alert =  st.success("openai api key updated")
+                    time.sleep(1) # Wait for 3 seconds
+                    alert.empty() # Clear the alert
+        st.markdown(
+            "### How to use\n"
+            "1. Select the LLM model\n"  # noqa: E501
+            "1. If selected model asks for a api key enter a valid api key.\n"  # noqa: E501
+            "1. Enter a text or a url to get a  summary."
+        )
+        st.markdown("---")
+        st.markdown("""
+           This app supports text in the following formats:
+            - Raw text in text box 
+            - URL of article/news to be summarized 
+            - .txt, .pdf, .docx file formats
+        """)
 
-        return Summarizer(model_path,model_type,api_key)
-    else:
-        logger.info(f"Model for summarization : {model_path}")
-        return Summarizer(model_path, model_type)
 
 def load_app():
     st.title("Text Summarizer 📝")
 
-    # st.markdown("Creator: [Atharva Ingle](https://github.com/Gladiator07)")
-    # st.markdown(
-    #     "Source code: [GitHub Repository](https://github.com/Gladiator07/Text-Summarizer)"
-    # )
-    model_name = st.sidebar.selectbox(
-        "Model Name", options=["Version 0", "Version 1","OpenAI"]
-    )
-    if model_name == "OpenAI":
-        st.sidebar.text_input("Enter a valid OpenAI API Key",key = "api_key" ,type="password")
-    
-    summarizer_type = st.sidebar.selectbox(
-        "Summarizer Type for Long Text", options=["Map Reduce", "Refine"]
-    )
-
-    st.markdown(
-        "Enter a text or a url to get a concise summary of the article while conserving the overall meaning. This app supports text in the following formats:"
-    )
-    st.markdown(
-        """- Raw text in text box 
-- URL of article/news to be summarized 
-- .txt, .pdf, .docx file formats"""
-    )
-    st.markdown(
-        """This app supports abstractive summarization of documents:
-
- **Abstractive Summarization**: The abstractive approach involves rephrasing the complete document while capturing the complete meaning of the document. This type of summarization provides more human-like summary"""
-    )
-    st.markdown("---")
-    # ---------------------------
-
-    # ---------------------------
     inp_text = st.text_input("Enter text or a url here")
     st.markdown(
-        "<h3 style='text-align: center; color: green;'>OR</h3>",
+        "<h4 style='text-align: center; color: green;'>OR</h4>",
         unsafe_allow_html=True,
     )
     uploaded_file = st.file_uploader(
@@ -125,51 +177,44 @@ def load_app():
             st.write(cleaned_txt[0])
         else:
             st.write(cleaned_txt)
-    summarize = st.button("Summarize")
-
-    if is_url:
-        text_to_summarize = " ".join([txt for txt in cleaned_txt])
-    else:
-        text_to_summarize = cleaned_txt
-
-    return text_to_summarize, model_name, summarizer_type, summarize
-
-
-
-
-def get_summary(text_to_summarize,model_name, summarizer_type, summarize):
-
-    while not summarize:
-        continue
-
-    else:
 
-        logger.info(f"Model Name: {model_name}")
-        logger.info(f"Summarization Type for Long Text: {summarizer_type}")
+    submitted = st.button("Summarize")
 
-        api_key = st.session_state.api_key
+    if submitted:
+        if is_url:
+            text_to_summarize = " ".join([txt for txt in cleaned_txt])
+        else:
+            text_to_summarize = cleaned_txt
 
+        submit_text_to_summarize(text_to_summarize)
 
-        summarizer = init_summarizer(model_name,api_key)
+def submit_text_to_summarize(text_to_summarize):
+    summarized_text, time = get_summary(text_to_summarize)
+    display_output(summarized_text,time)
 
 
-        with st.spinner(
-            text="Creating summary. This might take a few seconds ..."
-        ):
+def get_summary(text_to_summarize):
+    model_name = st.session_state.model_name
+    summarizer_type = st.session_state.summarizer_type
+    model_type, tokenizer, base_summarizer = init_summarizer(model_name,api_key=None)
 
-            if summarizer_type == "Refine":
-                summarized_text, time = summarizer.summarize(text_to_summarize,"refine")
-                return summarized_text, time
-            else : 
-                summarized_text, time = summarizer.summarize(text_to_summarize,"map_reduce")
-                return summarized_text, time
+    logger.info(f"Model Name: {model_name}")
+    logger.info(f"Summarization Type for Long Text: {summarizer_type}")
 
+    with st.spinner(
+        text="Creating summary. This might take a few seconds ..."
+    ):
+        if summarizer_type == "Refine":
+            # summarized_text, time = summarizer.summarize(text_to_summarize,"refine")
+            summarized_text, time = summarizer_summarize(model_type,tokenizer, base_summarizer, text_to_summarize ,summarizer_type = "refine")
+            return summarized_text, time
+        else : 
+            # summarized_text, time = summarizer.summarize(text_to_summarize,"map_reduce")
+            summarized_text, time = summarizer_summarize(model_type,tokenizer, base_summarizer, text_to_summarize ,summarizer_type = "map_reduce")
+            return summarized_text, time
 
-    
 
 def display_output(summarized_text,time):
-
-
     logger.info(f"SUMMARY: {summarized_text}")
     logger.info(f"Summary took {time}s")
     st.subheader("Summarized text")
@@ -177,140 +222,19 @@ def display_output(summarized_text,time):
     st.info(f"Time: {time}s")
 
 
-# def summarizer_app():
-#     # ---------------------------------
-#     # Main Application
-#     # ---------------------------------
-#     st.title("Text Summarizer 📝")
-
-#     # st.markdown("Creator: [Atharva Ingle](https://github.com/Gladiator07)")
-#     # st.markdown(
-#     #     "Source code: [GitHub Repository](https://github.com/Gladiator07/Text-Summarizer)"
-#     # )
-#     model_name = st.sidebar.selectbox(
-#         "Model Name", options=["Version 0", "Version 1","OpenAI"]
-#     )
-#     if model_name == "OpenAI":
-#         st.sidebar.text_input("Enter a valid OpenAI API Key",key = "api_key" ,type="password")
-    
-#     summarizer_type = st.sidebar.selectbox(
-#         "Summarizer Type for Long Text", options=["Map Reduce", "Refine"]
-#     )
-
-#     st.markdown(
-#         "Enter a text or a url to get a concise summary of the article while conserving the overall meaning. This app supports text in the following formats:"
-#     )
-#     st.markdown(
-#         """- Raw text in text box 
-# - URL of article/news to be summarized 
-# - .txt, .pdf, .docx file formats"""
-#     )
-#     st.markdown(
-#         """This app supports two type of summarization:
-
-# 1. **Extractive Summarization**: The extractive approach involves picking up the most important phrases and lines from the documents. It then combines all the important lines to create the summary. So, in this case, every line and word of the summary actually belongs to the original document which is summarized.
-# 2. **Abstractive Summarization**: The abstractive approach involves rephrasing the complete document while capturing the complete meaning of the document. This type of summarization provides more human-like summary"""
-#     )
-#     st.markdown("---")
-#     # ---------------------------
-#     # SETUP & Constants
-#     # nltk.download("punkt")
-#     # abs_tokenizer_name = "facebook/bart-large-cnn"
-#     # abs_model_name = "facebook/bart-large-cnn"
-#     # abs_tokenizer = AutoTokenizer.from_pretrained(abs_tokenizer_name)
-#     # abs_max_length = 90
-#     # abs_min_length = 30
-
-#     # model_name_v0 = "IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v0"
-#     # model_name_v1 = "IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v1"
-#     # ---------------------------
-#     inp_text = st.text_input("Enter text or a url here")
-#     st.markdown(
-#         "<h3 style='text-align: center; color: green;'>OR</h3>",
-#         unsafe_allow_html=True,
-#     )
-#     uploaded_file = st.file_uploader(
-#         "Upload a .txt, .pdf, .docx file for summarization"
-#     )
-
-#     is_url = validators.url(inp_text)
-#     if is_url:
-#         # complete text, chunks to summarize (list of sentences for long docs)
-#         logger.info("Text Input Type: URL")
-#         text, cleaned_txt = fetch_article_text(url=inp_text)
-#     elif uploaded_file:
-#         logger.info("Text Input Type: FILE")
-#         cleaned_txt = read_text_from_file(uploaded_file)
-#         cleaned_txt = clean_text(cleaned_txt)
-#     else:
-#         logger.info("Text Input Type: INPUT TEXT")
-#         cleaned_txt = clean_text(inp_text)
-
-#     # view summarized text (expander)
-#     with st.expander("View input text"):
-#         if is_url:
-#             st.write(cleaned_txt[0])
-#         else:
-#             st.write(cleaned_txt)
-#     summarize = st.button("Summarize")
-
-#     # called on toggle button [summarize]
-#     if summarize:
-#         if is_url:
-#             text_to_summarize = " ".join([txt for txt in cleaned_txt])
-#         else:
-#             text_to_summarize = cleaned_txt
-
-#         logger.info(f"Model Name: {model_name}")
-#         logger.info(f"Summarization Type for Long Text: {summarizer_type}")
-
-#         api_key = st.session_state.api_key
-
-#         print(api_key)
-
-#         summarizer = init_summarizer(model_name,api_key)
-
-#         with st.spinner(
-#             text="Creating summary. This might take a few seconds ..."
-#         ):
-#                 #ext_model = Summarizer()
-#                 #summarized_text = ext_model(text_to_summarize, num_sentences=5)
-
-#             if summarizer_type == "Refine":
-#                 summarized_text, time = summarizer.summarize(text_to_summarize,"refine")
-#             else : 
-#                 summarized_text, time = summarizer.summarize(text_to_summarize,"map_reduce")
-
-
-#         # elif model_name == "Version 1":
-#         #     with st.spinner(
-#         #         text="Creating summary. This might take a few seconds ..."
-#         #     ):
-#         #         if summarizer_type == "Refine":
-#         #             summarized_text, time = summarizer_v1.summarize(text_to_summarize,"refine")
-#         #         else : 
-#         #             summarized_text, time = summarizer_v1.summarize(text_to_summarize,"map_reduce")
-
-#         # final summarized output
-
-#         logger.info(f"SUMMARY: {summarized_text}")
-#         logger.info(f"Summary took {time}s")
-#         st.subheader("Summarized text")
-#         st.info(f"{summarized_text}")
-#         st.info(f"Time: {time}s")
-
-#         # st.subheader("Rogue Scores")
-#         # rouge_sc = Rouge()
-#         # ground_truth = cleaned_txt[0] if is_url else cleaned_txt
-#         # score = rouge_sc.get_scores(summarized_text, ground_truth, avg=True)
-#         # st.code(score)
+def main():
+   
+    initialize_app()
+    side_bar()
+    load_app()
+    # chat_body()
 
 
 if __name__ == "__main__":
-    initialize_app()
-    text_to_summarize, model_name, summarizer_type, summarize = load_app()
-    summarized_text,time = get_summary(text_to_summarize, model_name, summarizer_type, summarize)
-    display_output(summarized_text,time)
+    main()
+    # text_to_summarize, model_name, summarizer_type, summarize = load_app()
+    # summarized_text,time = get_summary(text_to_summarize, model_name, summarizer_type, summarize)
+    # display_output(summarized_text,time)
     
 
     

config.py

@@ -1,5 +1,6 @@
 MODELS = {
-    "Version 0":"IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v0",
-    "Version 1":"IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v1",
-    "OpenAI" : "IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v1" #for tokenizer
+    "long-t5 v0":"IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v0",
+    "long-t5 v1":"IronOne-AI-Labs/long-t5-tglobal-16k-annual-reports-v1",
+    "pegasus-x-large v1" : "IronOne-AI-Labs/pegasus-x-large-annual-report-QLoRA-fine-tuned-v1.1", #for tokenizer
+    "openai" : "IronOne-AI-Labs/pegasus-x-large-annual-report-QLoRA-fine-tuned-v1.1"
 }

summarizer.py

@@ -8,65 +8,66 @@ from logging import getLogger
 import time
 
 logger = getLogger(__name__)
-class Summarizer:
 
 
-    def __init__(self,model_name,model_type,api_key=None) -> None:
-        self.model_type = model_type
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-        self.base_summarizer = get_model(model_type,model_name,api_key) 
 
-    def summarize(self,text:str,summarizer_type = "map_reduce")->str:
+def summarizer_init(model_name,model_type,api_key=None) -> None:
+        # model_type = model_type
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        base_summarizer = get_model(model_type,model_name,api_key) 
+        return tokenizer,base_summarizer
 
-        text_to_summarize,length_type = prepare_for_summarize(text,self.tokenizer)
+def summarizer_summarize(model_type,tokenizer, base_summarizer, text:str,summarizer_type = "map_reduce")->str:
 
-        if length_type =="short":
+    text_to_summarize,length_type = prepare_for_summarize(text,tokenizer)
 
-            logger.info("Processing Input Text less than 12000 Tokens")
-            if self.model_type=="openai":
-                llm = self.base_summarizer
-                prompt = PromptTemplate.from_template(
-                    template="""Write a concise and complete summary in bullet points of the given annual report.
-                        Important:
-                        * Note that the summary should contain all important information and it should not contain any unwanted information.
-                        * Make sure to keep the summary as short as possible. And Summary should be in bullet points. Seperate each point with a new line.
-                        TEXT: {text}
-                        SUMMARY:"""
-                )
-                llm_chain = prompt|llm
-                start = time.time()
-                summary =  llm_chain.invoke({"text": text_to_summarize})
-                end = time.time()
-                print(f"Summary generation took {round((end-start),2)}s.")
-                return summary,round((end-start),2)
-            
-            elif self.model_type == "local":
-                pipe = self.base_summarizer
-                start = time.time()
-                summary = pipe(text_to_summarize)[0]['summary_text']
-                end = time.time()
-                print(f"Summary generation took {round((end-start),2)}s.")
-                return summary,round((end-start),2)
-        else:
-            if summarizer_type == "refine":
-                print("The text is too long, Running Refine Summarizer")
-                llm_chain = get_refine_chain(self.base_summarizer,self.model_type)
-                logger.info("Running Refine Chain for Summarization")
-                start = time.time()
-                summary = llm_chain.invoke({"input_documents": text_to_summarize}, return_only_outputs=True)['output_text']
-                end = time.time()
-                print(f"Summary generation took {round((end-start),2)}s.")
-                return summary,round((end-start),2)
+    if length_type =="short":
+
+        logger.info("Processing Input Text less than 12000 Tokens")
+        if model_type=="openai":
+            llm = base_summarizer
+            prompt = PromptTemplate.from_template(
+                template="""Write a concise and complete summary in bullet points of the given annual report.
+                    Important:
+                    * Note that the summary should contain all important information and it should not contain any unwanted information.
+                    * Make sure to keep the summary as short as possible. And Summary should be in bullet points. Seperate each point with a new line.
+                    TEXT: {text}
+                    SUMMARY:"""
+            )
+            llm_chain = prompt|llm
+            start = time.time()
+            summary =  llm_chain.invoke({"text": text_to_summarize})
+            end = time.time()
+            print(f"Summary generation took {round((end-start),2)}s.")
+            return summary,round((end-start),2)
+        
+        elif model_type == "local":
+            pipe = base_summarizer
+            start = time.time()
+            summary = pipe(text_to_summarize)[0]['summary_text']
+            end = time.time()
+            print(f"Summary generation took {round((end-start),2)}s.")
+            return summary,round((end-start),2)
+    else:
+        if summarizer_type == "refine":
+            print("The text is too long, Running Refine Summarizer")
+            llm_chain = get_refine_chain(base_summarizer,model_type)
+            logger.info("Running Refine Chain for Summarization")
+            start = time.time()
+            summary = llm_chain.invoke({"input_documents": text_to_summarize}, return_only_outputs=True)['output_text']
+            end = time.time()
+            print(f"Summary generation took {round((end-start),2)}s.")
+            return summary,round((end-start),2)
 
 
-            else: 
-                print("The text is too long, Running Map Reduce Summarizer")
-                
-                llm_chain = get_map_reduce_chain(self.base_summarizer,model_type=self.model_type)
-                logger.info("Running Map Reduce Chain for Summarization")
-                start = time.time()
-                summary = llm_chain.invoke({"input_documents": text_to_summarize}, return_only_outputs=True)['output_text']
-                end = time.time()
-                print(f"Summary generation took {round((end-start),2)}s.")
-                return summary,round((end-start),2)
+        else: 
+            print("The text is too long, Running Map Reduce Summarizer")
             
+            llm_chain = get_map_reduce_chain(base_summarizer,model_type=model_type)
+            logger.info("Running Map Reduce Chain for Summarization")
+            start = time.time()
+            summary = llm_chain.invoke({"input_documents": text_to_summarize}, return_only_outputs=True)['output_text']
+            end = time.time()
+            print(f"Summary generation took {round((end-start),2)}s.")
+            return summary,round((end-start),2)
+