Update app.py

app.py

@@ -4,7 +4,7 @@
 #   HuggingFace Spaces application to provide honeybee expertise
 #           with open-source models
 #
-#   Mike Pastor  February 22, 2024
+#   Mike Pastor  February 23, 2024
 
 
 import streamlit as st
@@ -13,20 +13,11 @@ from streamlit.components.v1 import html
 from PyPDF2 import PdfReader
 from PIL import Image
 
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+
 # Local file
 from htmlTemplates import css, bot_template, user_template
 
-#  from langchain.embeddings import HuggingFaceInstructEmbeddings
-from langchain_community.embeddings import HuggingFaceInstructEmbeddings
-
-# from langchain.vectorstores import FAISS
-from langchain_community.vectorstores import FAISS
-from langchain.text_splitter import CharacterTextSplitter
-from langchain.memory import ConversationBufferMemory
-from langchain.chains import ConversationalRetrievalChain
-
-#  from langchain.llms import HuggingFaceHub
-from langchain_community.llms import HuggingFaceHub
 
 ##################################################################################
 #  Admin flags
@@ -35,77 +26,20 @@ DISPLAY_DIALOG_LINES = 6
 SESSION_STARTED = False
 
 # MODEL_NAME="deepset/roberta-base-squad2"
-#MODEL_NAME="BEE-spoke-data/TinyLlama-3T-1.1bee"
+# MODEL_NAME="BEE-spoke-data/TinyLlama-3T-1.1bee"
 
-MODEL_NAME='HuggingFaceH4/zephyr-7b-beta'
+# MODEL_NAME='HuggingFaceH4/zephyr-7b-beta'
 
-##################################################################################
-def extract_pdf_text(pdf_docs):
-    text = ""
-    for pdf in pdf_docs:
-        pdf_reader = PdfReader(pdf)
-        for page in pdf_reader.pages:
-            text += page.extract_text()
-    return text
-
-
-##################################################################################
-#  Chunk size and overlap must not exceed the models capacity!
+##############################################################
+#   Our model and tokenizer
 #
-def extract_bitesize_pieces(text):
-    text_splitter = CharacterTextSplitter(
-        separator="\n",
-        chunk_size=800,  # 1000
-        chunk_overlap=200,
-        length_function=len
-    )
-    chunks = text_splitter.split_text(text)
-    return chunks
+MODEL_NAME = "facebook/blenderbot-400M-distill"
 
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
 
-##################################################################################
-def prepare_embedding_vectors(text_chunks):
-    st.write('Here in vector store....', unsafe_allow_html=True)
-    # embeddings = OpenAIEmbeddings()
-
-    #  pip install InstructorEmbedding
-    #  pip install sentence-transformers==2.2.2
-    embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")
-
-    st.write('Here in vector store - got embeddings ', unsafe_allow_html=True)
-    #  from InstructorEmbedding import INSTRUCTOR
-    # model = INSTRUCTOR('hkunlp/instructor-xl')
-    # sentence = "3D ActionSLAM: wearable person tracking in multi-floor environments"
-    # instruction = "Represent the Science title:"
-    # embeddings = model.encode([[instruction, sentence]])
-
-    # embeddings = model.encode(text_chunks)
-    print('have Embeddings:   ')
-
-    # text_chunks="this is a test"
-    #   FAISS,  Chroma and other vector databases
-    #
-    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
-    st.write('FAISS succeeds:   ')
-
-    return vectorstore
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 
 
-##################################################################################
-def prepare_conversation(vectorstore):
-    # llm = ChatOpenAI()
-    #  llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
-    #  google/bigbird-roberta-base     facebook/bart-large
-    llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature": 0.7, "max_length": 512})
-
-    memory = ConversationBufferMemory(
-        memory_key='chat_history', return_messages=True)
-    conversation_chain = ConversationalRetrievalChain.from_llm(
-        llm=llm,
-        retriever=vectorstore.as_retriever(),
-        memory=memory,
-    )
-    return conversation_chain
 
 
 ##################################################################################
@@ -133,58 +67,6 @@ def process_user_question(user_question):
     print('question is: ', user_question)
     print('\nsession is: ', st)
 
-    # try:
-    #     response = st.session_state.conversation({'question': user_question})
-    #     # response = st.session_state.conversation({'summarization': user_question})
-    #     st.session_state.chat_history = response['chat_history']
-    # Exception:
-    #     st.write( 'Please upload and analyze your PDF files first!')
-    #     return
-
-    # st.empty()
-
-    # try:
-    #     st.session_state.conversation({'question': "Summarize the document"})
-    #     # if "key" not in st.session_state:
-    #     #     st.write('Good')
-    # except:
-    #     st.error("Please upload and analyze your PDF files first!")
-    #     return
-
-    # if st.session_state.conversation == None:
-    #     st.error("Please upload and analyze your PDF files first!")
-    #     return
-
-    #
-    # response = st.session_state.conversation({'question': user_question})
-    # st.session_state.chat_history = response['chat_history']
-    # results_size = len(response['chat_history'])
-    #
-    # results_string = ""
-    #
-    # print('results_size is: ', results_size)
-    #
-    # for i, message in enumerate(st.session_state.chat_history):
-    #
-    #     #  Scrolling does not display the last printed line,
-    #     #    so only print the last 6 lines
-    #     #
-    #     print('results_size on msg: ', results_size, i, (results_size - DISPLAY_DIALOG_LINES))
-    #     if results_size > DISPLAY_DIALOG_LINES:
-    #         if i < (results_size - DISPLAY_DIALOG_LINES):
-    #             continue
-    #
-    #     if i % 2 == 0:
-    #         # st.write(user_template.replace(
-    #         #     "{{MSG}}", message.content), unsafe_allow_html=True)
-    #
-    #         results_string += ("<p>" + message.content + "</p>")
-    #
-    #     else:
-    #         # st.write(bot_template.replace(
-    #         #     "{{MSG}}", message.content), unsafe_allow_html=True)
-    #
-    #         results_string += ("<p>" + "-- " + message.content + "</p>")
 
 
     #################################################################
@@ -194,106 +76,66 @@ def process_user_question(user_question):
     global_now = datetime.now()
     global_current_time = global_now.strftime("%H:%M:%S")
     print("# app.py Starting up...  - Current Time =", global_current_time)
-    st.write(('Question: ' + user_question + ' | ' + str( global_current_time )), unsafe_allow_html=True)
 
-    from transformers import pipeline
+    st.write(('Question:    ' + user_question ), unsafe_allow_html=True)
 
-    pipe = pipeline("conversational", "HuggingFaceH4/zephyr-7b-beta")
 
-    # "Question: which technology is most recent?   A)Cell phones  B)Television C)Airplane  Answer: "
-    messages = [
-        {
-            "role": "system",
-            "content": "You are a friendly chatbot who always responds in the style of a personal assistant",
-        },
-        {"role": "user",
-         "content": user_question },
-    ]
+    #  input_text = input('Say something-->  ')
 
-    st.write('Sending message to Model->  ', messages )
-    results_string = pipe(messages)
+    print( 'history--> ', st.session_state.history_string)
+    ################################################################
+    #  Tokenize the user prompt and conversation history
+    inputs = tokenizer.encode_plus( st.session_state.history_string, user_question, return_tensors="pt" )
 
-    # st.write('results type= ', type( results_string) )
-    st.write('results= ', results_string)
-    # st.write('results ans= ', results_string[0])
+    # st.write('Len of inputs= ', len( inputs))
+    #  Generate a response
+    outputs = model.generate( **inputs )
 
-    # Mission Complete!
-    ##################################################################################
-    global_later = datetime.now()
-    st.write("# Total EXECUTION Time =", (global_later - global_now), global_later)
+    # decode the response
+    response = tokenizer.decode( outputs[0], skip_special_tokens=True).strip()
 
-    #
-    # # Choose a question answering pipeline (e.g., 'question-answering')
-    # nlp = pipeline("question-answering")
-    #
-    # # Specify the model name or identifier (e.g., 'deepset/roberta-base-squad2')
-    # model_name = MODEL_NAME
-    #
-    # # Prepare the question and context (optional)
-    # # question = "What is the capital of France?"
-    # # context = "France is a country located in Western Europe. It is bordered by the Atlantic Ocean to the west, the Mediterranean Sea to the south, and Belgium, Luxembourg, Germany, Switzerland, Italy, and Spain to the east and north."
-    #
-    # context = "You are an expert Apiarist and answer all questions regarding Honeybees."
-    # # context = " "
-    #
-    # # Ask the question
-    # answer = nlp(question= ('Question: '+user_question), context=context, model=model_name)
-    #
-    # # Print the answer
-    # print(f"Answer: {answer['answer']}")
-    # print(f"Score: {answer['score']}")
-    #
-    # st.write( ('Answer= '+answer['answer']), unsafe_allow_html=True)
-    #
-    # results_string = answer['answer'] + '     - Probability= ' + str( answer['score'] )
+    #  append history
+    st.session_state.conversation_history.append(user_question)
+    st.session_state.conversation_history.append(response)
 
-    #  html(results_string, height=300, scrolling=True)
+    # st.session_state.history_string = "/n".join(st.session_state.conversation_history)
+    st.session_state.history_string = "<br>".join( st.session_state.conversation_history )
 
+    st.write( 'Response:   ', response)
 
-###################################################################################
-def main():
-    print('Pennwick Starting up...\n')
-    # Load the environment variables - if any
-    # load_dotenv()
 
+    # Mission Complete!
     ##################################################################################
-    #  st.set_page_config(page_title="Pennwick PDF Analyzer", page_icon=":books:")
-    # im = Image.open("robot_icon.ico")
-    # st.set_page_config(page_title="Pennwick PDF Analyzer", page_icon=im )
-    # st.set_page_config(page_title="Pennwick PDF Analyzer")
+    global_later = datetime.now()
+    st.write("Total query execute Time =", (global_later - global_now), global_later)
 
-    # import base64
-    # from PIL import Image
 
-    # # Open your image
-    # image = Image.open("robot_icon.ico")
 
-    # # Convert image to base64 string
-    # with open("robot_icon.ico", "rb") as f:
-    #     encoded_string = base64.b64encode(f.read()).decode()
+#################################################################################
+def main():
+    print('Pennwick Starting up...\n')
 
-    # # Set page config with base64 string
-    # st.set_page_config(page_title="Pennwick File Analyzer 2", page_icon=f"data:image/ico;base64,{encoded_string}")
+    ##################################################################
+    #  Initial conversation tracking
+    if not hasattr(st.session_state, "conversation_history"):
+        st.session_state.conversation_history  = []
+    if not hasattr(st.session_state, "history_string"):
+        st.session_state.history_string  = "\n".join(st.session_state.conversation_history)
 
-    st.set_page_config(page_title="Pennwick Honeybee Robot", page_icon="./HoneybeeLogo.ico")
 
-    print('prepared page...\n')
+    # Load the environment variables - if any
+    # load_dotenv()
 
-    ###################
+    st.set_page_config(page_title="Pennwick Honeybee Robot",
+                       page_icon="./HoneybeeLogo.ico")
 
     st.write(css, unsafe_allow_html=True)
 
-    if "conversation" not in st.session_state:
-        st.session_state.conversation = None
-    if "chat_history" not in st.session_state:
-        st.session_state.chat_history = None
+    st.image("./HoneybeeLogo.png", width=96)
+    st.header(f"Pennwick Honeybee Robot       - BETA VERSION")
 
-    # st.header("Pennwick File Analyzer :shark:")
-    # st.header("Pennwick File Analyzer 2")
+    print('Prepared page...\n')
 
-    # st.image("robot_icon.png", width=96)
-    st.image("./HoneybeeLogo.png", width=96)
-    st.header(f"Pennwick Honeybee Robot")
 
     user_question = None
     user_question = st.text_input("Ask the  Open Source - "+MODEL_NAME+" - Model  any question about Honeybees...")
@@ -301,6 +143,13 @@ def main():
         print('calling process question', user_question)
         process_user_question(user_question)
 
+    html_history_string = ""
+    if len( st.session_state.history_string ) > 100:
+        html_history_string = st.session_state.history_string[-100:]
+    else:
+        html_history_string = st.session_state.history_string
+
+    html(html_history_string , height=150, scrolling=True)
     # st.write( user_template, unsafe_allow_html=True)
     # st.write(user_template.replace( "{{MSG}}", "Hello robot!"), unsafe_allow_html=True)
     # st.write(bot_template.replace( "{{MSG}}", "Hello human!"), unsafe_allow_html=True)