Spaces:
Sleeping
Sleeping
############################################################## | |
# app.py - Pennwick PDF Chat | |
# | |
# HuggingFace Spaces application | |
# | |
# Mike Pastor February 2024 | |
import streamlit as st | |
from dotenv import load_dotenv | |
from PyPDF2 import PdfReader | |
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 | |
def get_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! | |
# | |
def get_text_chunks(text): | |
text_splitter = CharacterTextSplitter( | |
separator="\n", | |
chunk_size=800, # 1000 | |
chunk_overlap=200, | |
length_function=len | |
) | |
chunks = text_splitter.split_text(text) | |
return chunks | |
def get_vectorstore(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 | |
def get_conversation_chain(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.5, "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 | |
def handle_userinput(user_question): | |
response = st.session_state.conversation({'question': user_question}) | |
# response = st.session_state.conversation({'summarization': user_question}) | |
st.session_state.chat_history = response['chat_history'] | |
# st.empty() | |
for i, message in enumerate(st.session_state.chat_history): | |
if i % 2 == 0: | |
st.write(user_template.replace( | |
"{{MSG}}", message.content), unsafe_allow_html=True) | |
else: | |
st.write(bot_template.replace( | |
"{{MSG}}", message.content), unsafe_allow_html=True) | |
def main(): | |
from PIL import Image | |
# load_dotenv() | |
# st.set_page_config(page_title="Pennwick PDF Analyzer", page_icon=":books:") | |
im = Image.open("robot_icon.ico") | |
# st.set_page_config(page_title="My App", page_icon=im) | |
st.set_page_config(page_title="Pennwick PDF Analyzer", page_icon=im ) | |
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.header("Pennwick File Analyzer :books:") | |
st.header("Pennwick File Analyzer ") | |
user_question = st.text_input("Ask the Model a question about your uploaded documents:") | |
if user_question: | |
handle_userinput(user_question) | |
# 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) | |
with st.sidebar: | |
st.subheader("Your documents") | |
pdf_docs = st.file_uploader( | |
"Upload your PDFs here and click on 'Process'", accept_multiple_files=True) | |
# Upon button press | |
if st.button("Process these files"): | |
with st.spinner("Processing..."): | |
################################################################# | |
# Track the overall time for file processing into Vectors | |
# # | |
from datetime import datetime | |
global_now = datetime.now() | |
global_current_time = global_now.strftime("%H:%M:%S") | |
st.write("Vectorizing Files - Current Time =", global_current_time) | |
# get pdf text | |
raw_text = get_pdf_text(pdf_docs) | |
# st.write(raw_text) | |
# # get the text chunks | |
text_chunks = get_text_chunks(raw_text) | |
# st.write(text_chunks) | |
# # create vector store | |
vectorstore = get_vectorstore(text_chunks) | |
# # create conversation chain | |
st.session_state.conversation = get_conversation_chain(vectorstore) | |
# Mission Complete! | |
global_later = datetime.now() | |
st.write("Files Vectorized - Total EXECUTION Time =", | |
(global_later - global_now), global_later) | |
if __name__ == '__main__': | |
main() | |