Add application file

app.py

@@ -1,194 +1,428 @@
-"""
-This module provides functions for working with PDF files and URLs. It uses the urllib.request library
-to download files from URLs, and the fitz library to extract text from PDF files. And GPT3 modules to generate
-text completions.
-"""
-import urllib.request
-import fitz
-import re
-import numpy as np
-import tensorflow_hub as hub
+import streamlit as st
 import openai
-import gradio as gr
+from streamlit_chat import message as st_message
+from transformers import BlenderbotTokenizer
+from transformers import BlenderbotForConditionalGeneration
+from io import StringIO
+from io import BytesIO
+import requests
+import torch
+import PyPDF2
+from transformers import GenerationConfig, LlamaTokenizer, LlamaForCausalLM
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.llms import OpenAI
+from langchain.chains import RetrievalQA
+from langchain.document_loaders import TextLoader
 import os
-from sklearn.neighbors import NearestNeighbors
-
-def download_pdf(url, output_path):
-    urllib.request.urlretrieve(url, output_path)
-
-
-def preprocess(text):
-    text = text.replace('\n', ' ')
-    text = re.sub('\s+', ' ', text)
-    return text
-
-
-def pdf_to_text(path, start_page=1, end_page=None):
-    doc = fitz.open(path)
-    total_pages = doc.page_count
-
-    if end_page is None:
-        end_page = total_pages
-
-    text_list = []
-
-    for i in range(start_page-1, end_page):
-        text = doc.load_page(i).get_text("text")
-        text = preprocess(text)
-        text_list.append(text)
-
-    doc.close()
-    return text_list
-
-
-def text_to_chunks(texts, word_length=150, start_page=1):
-    text_toks = [t.split(' ') for t in texts]
-    page_nums = []
-    chunks = []
-    
-    for idx, words in enumerate(text_toks):
-        for i in range(0, len(words), word_length):
-            chunk = words[i:i+word_length]
-            if (i+word_length) > len(words) and (len(chunk) < word_length) and (
-                len(text_toks) != (idx+1)):
-                text_toks[idx+1] = chunk + text_toks[idx+1]
-                continue
-            chunk = ' '.join(chunk).strip()
-            chunk = f'[{idx+start_page}]' + ' ' + '"' + chunk + '"'
-            chunks.append(chunk)
-    return chunks
-
-
-class SemanticSearch:
-    
-    def __init__(self):
-        self.use = hub.load('https://tfhub.dev/google/universal-sentence-encoder/4')
-        self.fitted = False
-    
-    
-    def fit(self, data, batch=1000, n_neighbors=5):
-        self.data = data
-        self.embeddings = self.get_text_embedding(data, batch=batch)
-        n_neighbors = min(n_neighbors, len(self.embeddings))
-        self.nn = NearestNeighbors(n_neighbors=n_neighbors)
-        self.nn.fit(self.embeddings)
-        self.fitted = True
+os.environ['OPENAI_API_KEY']="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"
+import warnings
+warnings.filterwarnings("ignore")
+
+
+st.markdown(
+    """
+    <style>
+    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+        width: 325px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+        width: 325px;
+        margin-left: -350px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.sidebar.title('ChatFAQ')
+st.sidebar.subheader('Parameters')
+
+@st.cache_resource
+def get_models():
+    # it may be necessary for other frameworks to cache the model
+    # seems pytorch keeps an internal state of the conversation
+    model_name = "facebook/blenderbot-400M-distill"
+    tokenizer = BlenderbotTokenizer.from_pretrained(model_name)
+    model = BlenderbotForConditionalGeneration.from_pretrained(model_name)
+    return tokenizer, model
+
+st.title("ChatFAQ")
+
+app_mode = st.sidebar.selectbox('Choose the App mode',
+['Blenderbot_1B', 'Blenderbot-400M-distill', 'ChatGPT-3.5', 'Fine-tune Alpaca 7B', 'Customized Alpaca 7B', 'Alpaca-LORA']
+)
+
+# app_mode = st.sidebar.selectbox('Choose the domain',
+# ['Law','Economic','Technology']
+# )
+
+uploaded_file = st.sidebar.file_uploader("Choose a file")
+if uploaded_file is not None:
+    string_data = ""
+    file_type = uploaded_file.type
+    if file_type == "application/pdf":
+        bytes_data = uploaded_file.getvalue()
+
+        # Create a BytesIO object from the bytes data
+        bytes_io = BytesIO(bytes_data)
+
+        # Create a PDF reader object
+        pdf_reader = PyPDF2.PdfReader(bytes_io)
+
+        # Get the number of pages in the PDF file
+        num_pages = len(pdf_reader.pages)
+        # Loop through each page and extract the text
+        for i in range(num_pages):
+            page =  pdf_reader.pages[i]
+            text = page.extract_text()
+            string_data = string_data + text
+    elif file_type == "text/plain":
+        with st.spinner('Loading the document...'):
+            # To convert to a string based IO:
+            stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+
+            # To read file as string:
+            string_data = stringio.read()
+    st.success('Loading successfully!')
     
-    
-    def __call__(self, text, return_data=True):
-        inp_emb = self.use([text])
-        neighbors = self.nn.kneighbors(inp_emb, return_distance=False)[0]
-        
-        if return_data:
-            return [self.data[i] for i in neighbors]
-        else:
-            return neighbors
-    
-    
-    def get_text_embedding(self, texts, batch=1000):
-        embeddings = []
-        for i in range(0, len(texts), batch):
-            text_batch = texts[i:(i+batch)]
-            emb_batch = self.use(text_batch)
-            embeddings.append(emb_batch)
-        embeddings = np.vstack(embeddings)
-        return embeddings
-
-
-
-def load_recommender(path, start_page=1):
-    global recommender
-    texts = pdf_to_text(path, start_page=start_page)
-    chunks = text_to_chunks(texts, start_page=start_page)
-    recommender.fit(chunks)
-    return 'Corpus Loaded.'
-
-def generate_text(openAI_key,prompt, engine="text-davinci-003"):
-    openai.api_key = openAI_key
-    completions = openai.Completion.create(
-        engine=engine,
-        prompt=prompt,
-        max_tokens=512,
-        n=1,
-        stop=None,
-        temperature=0.7,
+if app_mode =='Blenderbot_1B':
+    st.markdown('In this application, **Blenderbot_1B API** is used and **StreamLit** is to create the Web Graphical User Interface (GUI).')
+    st.markdown(
+    """
+    <style>
+    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+        width: 300px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+        width: 300px;
+        margin-left: -400px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
     )
-    message = completions.choices[0].text
-    return message
-
-def generate_answer(question,openAI_key):
-    topn_chunks = recommender(question)
-    prompt = ""
-    prompt += 'search results:\n\n'
-    for c in topn_chunks:
-        prompt += c + '\n\n'
-        
-    prompt += "Instructions: Compose a comprehensive reply to the query using the search results given. "\
-              "Cite each reference using [ Page Number] notation (every result has this number at the beginning). "\
-              "Citation should be done at the end of each sentence. If the search results mention multiple subjects "\
-              "with the same name, create separate answers for each. Only include information found in the results and "\
-              "don't add any additional information. Make sure the answer is correct and don't output false content. "\
-              "If the text does not relate to the query, simply state 'Text Not Found in PDF'. Ignore outlier "\
-              "search results which has nothing to do with the question. Only answer what is asked. The "\
-              "answer should be short and concise. Answer step-by-step. \n\nQuery: {question}\nAnswer: "
     
-    prompt += f"Query: {question}\nAnswer:"
-    answer = generate_text(openAI_key, prompt,"text-davinci-003")
-    return answer
-
-
-def question_answer(url, file, question,openAI_key):
-    if openAI_key.strip()=='':
-        return '[ERROR]: Please enter you Open AI Key. Get your key here : https://platform.openai.com/account/api-keys'
-    if url.strip() == '' and file == None:
-        return '[ERROR]: Both URL and PDF is empty. Provide atleast one.'
+    if 'history1' not in st.session_state:
+        st.session_state['history1'] = []
+
+    API_TOKEN = "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"
+    API_URL = "https://api-inference.huggingface.co/models/facebook/blenderbot-1B-distill"
+    headers = {"Authorization": f"Bearer {API_TOKEN}"}
+
+    def query(payload):
+        response = requests.post(API_URL, headers=headers, json=payload)
+        return response.json()
+
+    def generate_answer():
+        historyInputs = {"past_user_inputs": [],
+                "generated_responses": []}
+        for element in st.session_state["history1"]:
+            if element["is_user"] == True:
+                historyInputs["past_user_inputs"].append(element["message"])
+            else:
+                historyInputs["generated_responses"].append(element["message"])
+        user_message = st.session_state.input_text
+        historyInputs["text"] = user_message if user_message != "" else " "
+        print(historyInputs)   
+        output = query({
+            "inputs": historyInputs,
+        })
+        print(output)
+        print(output["generated_text"])
+        st.session_state['history1'].append({"message": user_message, "is_user": True})
+        st.session_state['history1'].append({"message": output["generated_text"], "is_user": False})
+        print(st.session_state['history1'])
+
+    for chat in st.session_state['history1']:
+        st_message(**chat)  # unpacking
+
+    st.text_input("Talk to the bot", key="input_text", on_change=generate_answer)
     
-    if url.strip() != '' and file != None:
-        return '[ERROR]: Both URL and PDF is provided. Please provide only one (eiter URL or PDF).'
+    if st.button("Clear"):
+        st.session_state["history1"] = []
+        for chat in st.session_state['history1']:
+            st_message(**chat)  # unpacking
+
+if app_mode =='Blenderbot-400M-distill':
+    st.markdown('In this application, **Blenderbot-400M-distill API** is used and **StreamLit** is to create the Web Graphical User Interface (GUI).')
+    st.markdown(
+    """
+    <style>
+    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+        width: 300px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+        width: 300px;
+        margin-left: -400px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+    )
 
-    if url.strip() != '':
-        glob_url = url
-        download_pdf(glob_url, 'corpus.pdf')
-        load_recommender('corpus.pdf')
+    if 'history2' not in st.session_state:
+        st.session_state['history2'] = []
+
+    def generate_answer():
+        tokenizer, model = get_models()
+        user_message = st.session_state.input_text
+        print(type(user_message), user_message)
+        History_inputs = []
+        for element in st.session_state["history2"]:
+            if element["is_user"] == True:
+                History_inputs.append(element["message"])
+        historyInputs = ". ".join(History_inputs)
+        print(historyInputs + " " + st.session_state.input_text)
+        inputs = tokenizer(historyInputs + " . " + st.session_state.input_text, return_tensors="pt")
+        result = model.generate(**inputs)
+        message_bot = tokenizer.decode(
+            result[0], skip_special_tokens=True
+        )  # .replace("<s>", "").replace("</s>", "")
+
+        st.session_state['history2'].append({"message": user_message, "is_user": True})
+        st.session_state['history2'].append({"message": message_bot, "is_user": False})
+
+    for chat in st.session_state['history2']:
+        st_message(**chat)  # unpacking
+
+    st.text_input("Talk to the bot", key="input_text", on_change=generate_answer)
+
+    if st.button("Clear"):
+        st.session_state["history2"] = []
+        for chat in st.session_state['history2']:
+            st_message(**chat)  # unpacking
+
+if app_mode =='ChatGPT-3.5':
+    counter = 0
+
+    def get_unique_key():
+        global counter
+        counter += 1
+        return f"chat{counter}"
+
+    OPENAI_KEY="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"
+    openai.api_key = OPENAI_KEY
+    openai_engine = openai.ChatCompletion()
+
+    if 'history3' not in st.session_state:
+        st.session_state['history3'] = []
+
+    if "messages" not in st.session_state:
+        st.session_state["messages"] = []
+
+    if "messagesDocument" not in st.session_state:
+        st.session_state["messagesDocument"] = []
+
+    def generate_answer():
+        st.session_state["messages"] += [{"role": "user", "content": st.session_state.input_text}]
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo", messages=st.session_state["messages"]
+        )
+        message_response = response["choices"][0]["message"]["content"]
+        st.session_state["messages"] += [
+            {"role": "system", "content": message_response}
+        ]
+        st.session_state['history3'].append({"message": st.session_state.input_text, "is_user": True})
+        st.session_state['history3'].append({"message": message_response, "is_user": False})
+        print(st.session_state['history3'])
+        print(st.session_state["messages"])
+
+    if st.button("Retrieve the document's content"):
+        if uploaded_file is None:
+            st.error("Please input the document!", icon="🚨")
+        else:
+            with st.spinner('Wait for processing the document...'):
+                with open("my_text.txt", "w", encoding='utf-8') as f:
+                    f.write(string_data) 
+                loader = TextLoader("my_text.txt", encoding='utf-8')
+                documents = loader.load()
+                print(type(documents), documents)
+                text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+                texts = text_splitter.split_documents(documents)
+
+                embeddings = OpenAIEmbeddings()
+                docsearch = Chroma.from_documents(texts, embeddings)
+
+                qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=docsearch.as_retriever(search_kwargs={"k": 1}))
+            st.success('Successful!')
+
+        def generate_answer():
+            query = st.session_state.input_text
+            docs = qa.run(query)
+            system_prompt_first = """
+            You are a helpful assisant that help user with answering questions over a content that was pulled from a database
+            ---CONTENT START---\n
+            """
+            system_prompt_second = """
+            \n---CONTENT END---
+            Based on information pulled from the database, answer the question below from the user. If the content pulled from the database is not related to the question, say "I do not have enough information for this question"
+            Question: 
+            """
+            system_prompt_ans = "\nAnswer:"
+            prompt = system_prompt_first + docs + system_prompt_second + query + system_prompt_ans
+            print(prompt)
+            st.session_state["messagesDocument"] += [{"role": "user", "content": prompt}]
+            message_response = openai_engine.create(model='gpt-3.5-turbo',messages=st.session_state["messagesDocument"])
+            st.session_state['history3'].append({"message": st.session_state.input_text, "is_user": True})
+            st.session_state['history3'].append({"message": message_response.choices[0].message.content, "is_user": False})
+            st.session_state["messagesDocument"] += [
+                {"role": "system", "content": message_response.choices[0].message.content}
+            ]
+            print(st.session_state["messagesDocument"])
+
+    st.markdown("""
+    <style>
+        .chatbox {
+            max-height: 300px;
+            overflow-y: auto;
+        }
+    </style>
+    """, unsafe_allow_html=True)
+
+    for chat in st.session_state['history3']:
+        st_message(**chat, key=get_unique_key())  # unpacking
+
+
+    st.text_input("Talk to the bot: ",placeholder = "Ask me anything ...", key="input_text", on_change=generate_answer)
+
+    if st.button("Clear"):
+        st.session_state["history3"] = []
+        st.session_state["messages"] = []
+        for chat in st.session_state['history3']:
+            st_message(**chat, key=get_unique_key())  # unpacking
+
+
+if app_mode =='Fine-tune Alpaca 7B':
+    st.markdown('In this application, we are using **Fine-tune Alpaca 7B API** and **StreamLit** is to create the Web Graphical User Interface (GUI). ')
+    st.markdown(
+    """
+    <style>
+    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+        width: 300px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+        width: 300px;
+        margin-left: -400px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+    )
 
-    else:
-        old_file_name = file.name
-        file_name = file.name
-        file_name = file_name[:-12] + file_name[-4:]
-        os.rename(old_file_name, file_name)
-        load_recommender(file_name)
 
-    if question.strip() == '':
-        return '[ERROR]: Question field is empty'
 
-    return generate_answer(question,openAI_key)
+if app_mode =='Customized Alpaca 7B':
+    st.markdown('In this application, we are using **PART - Part Attention Regressor for 3D Human Body Estimation [ICCV 2021]** for creating Body Mesh and **Dynamic Time Warping** for comparing poses. **StreamLit** is to create the Web Graphical User Interface (GUI). ')
+    st.markdown(
+    """
+    <style>
+    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+        width: 300px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+        width: 300px;
+        margin-left: -400px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+    )
 
+if app_mode =='Alpaca-LORA':
+    st.markdown('In this application, we are using **PART - Part Attention Regressor for 3D Human Body Estimation [ICCV 2021]** for creating Body Mesh and **Dynamic Time Warping** for comparing poses. **StreamLit** is to create the Web Graphical User Interface (GUI). ')
+    st.markdown(
+    """
+    <style>
+    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+        width: 300px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+        width: 300px;
+        margin-left: -400px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+    )
+    def generate_prompt(instruction: str, input_ctxt: str = None) -> str:
+        if input_ctxt:
+            return f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+    ### Instruction:
+    {instruction}
 
-recommender = SemanticSearch()
+    ### Input:
+    {input_ctxt}
 
-title = 'PDF GPT'
-description = """ PDF GPT allows you to chat with your PDF file using Universal Sentence Encoder and Open AI. It gives hallucination free response than other tools as the embeddings are better than OpenAI. The returned response can even cite the page number in square brackets([]) where the information is located, adding credibility to the responses and helping to locate pertinent information quickly."""
+    ### Response:"""
+        else:
+            return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
 
-with gr.Blocks() as demo:
+    ### Instruction:
+    {instruction}
 
-    gr.Markdown(f'<center><h1>{title}</h1></center>')
-    gr.Markdown(description)
+    ### Response:"""
 
-    with gr.Row():
-        
-        with gr.Group():
-            gr.Markdown(f'<p style="text-align:center">Get your Open AI API key <a href="https://platform.openai.com/account/api-keys">here</a></p>')
-            openAI_key=gr.Textbox(label='Enter your OpenAI API key here')
-            url = gr.Textbox(label='Enter PDF URL here')
-            gr.Markdown("<center><h4>OR<h4></center>")
-            file = gr.File(label='Upload your PDF/ Research Paper / Book here', file_types=['.pdf'])
-            question = gr.Textbox(label='Enter your question here')
-            btn = gr.Button(value='Submit')
-            btn.style(full_width=True)
+    tokenizer = LlamaTokenizer.from_pretrained("chainyo/alpaca-lora-7b")
+    model = LlamaForCausalLM.from_pretrained(
+        "chainyo/alpaca-lora-7b",
+        load_in_8bit=True,
+        torch_dtype=torch.float16,
+        device_map="auto",
+    )
+    generation_config = GenerationConfig(
+        temperature=0.2,
+        top_p=0.75,
+        top_k=40,
+        num_beams=4,
+        max_new_tokens=128,
+    )
 
-        with gr.Group():
-            answer = gr.Textbox(label='The answer to your question is :')
+    model.eval()
+    if torch.__version__ >= "2":
+        model = torch.compile(model)
+
+    instruction = "What is the meaning of life?"
+    input_ctxt = None  # For some tasks, you can provide an input context to help the model generate a better response.
+
+    prompt = generate_prompt(instruction, input_ctxt)
+    input_ids = tokenizer(prompt, return_tensors="pt").input_ids
+    input_ids = input_ids.to(model.device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            input_ids=input_ids,
+            generation_config=generation_config,
+            return_dict_in_generate=True,
+            output_scores=True,
+        )
+
+    response = tokenizer.decode(outputs.sequences[0], skip_special_tokens=True)
+    print(response)
+
+
+# def generate_answer():
+#     tokenizer, model = get_models()
+#     user_message = st.session_state.input_text
+#     print(type(user_message), user_message)
+#     History_inputs = []
+#     for element in st.session_state["history"]:
+#         if element["is_user"] == True:
+#             History_inputs.append(element["message"])
+#     historyInputs = ". ".join(History_inputs)
+#     print(historyInputs + " " + st.session_state.input_text)
+#     inputs = tokenizer(historyInputs + " . " + st.session_state.input_text, return_tensors="pt")
+#     result = model.generate(**inputs)
+#     message_bot = tokenizer.decode(
+#         result[0], skip_special_tokens=True
+#     )  # .replace("<s>", "").replace("</s>", "")
+
+#     st.session_state['history'].append({"message": user_message, "is_user": True})
+#     st.session_state['history'].append({"message": message_bot, "is_user": False})
+
+# for chat in st.session_state['history']:
+#     st_message(**chat)  # unpacking
+
+# st.text_input("Talk to the bot", key="input_text", on_change=generate_answer)
 
-        btn.click(question_answer, inputs=[url, file, question,openAI_key], outputs=[answer])
-#openai.api_key = os.getenv('Your_Key_Here') 
-demo.launch()