Duplicate from ritikjain51/PDF-experimentation

Co-authored-by: Ritik Jain <[email protected]>

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.Chroma
+.chroma
+*.ipynb
+*.pyc
+__pycache__
+.faiss

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10-slim
+
+WORKDIR /code
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=off \
+    PIP_DISABLE_PIP_VERSION_CHECK=on \
+    PIP_DEFAULT_TIMEOUT=100 \
+    HNSWLIB_NO_NATIVE=1
+
+RUN apt-get update && apt install python3-dev libprotobuf-dev build-essential -y
+
+COPY . .
+RUN pip install --upgrade pip
+RUN pip install duckdb
+RUN pip install -r requirements.txt
+EXPOSE 8071
+CMD ["gradio", "app.py"]

README.md

@@ -0,0 +1,35 @@
+---
+license: mit
+title: PDF Experimentation
+sdk: streamlit
+emoji: 🚀
+colorFrom: purple
+colorTo: gray
+pinned: true
+app_file: app.py
+duplicated_from: ritikjain51/PDF-experimentation
+---
+
+## Next Steps
+
+- [x] Build UI using Streamlit
+- [x] Add Advance Settings in sidebar
+- [x] Build backend using Langchain
+- [x] Dockerize 
+- [ ] Add Docs
+
+
+### UI Components
+
+- [x] Add Upload PDF Tab
+- [x] Show PDF Tab
+- [x] Question Answer Tab
+- [x] Conversational Tab
+- [x] Advance Settings
+- [x] Model Settings
+
+### Backend Components
+- [x] Read PDF and ingest
+- [x] Fetch Configuration 
+- [x] Vector DB Indexing
+- []

app.py

@@ -0,0 +1,171 @@
+import base64
+
+import streamlit as st
+from streamlit_chat import message
+from streamlit_extras.colored_header import colored_header
+
+from backend import QnASystem
+from schema import TransformType, EmbeddingTypes, IndexerType, BotType
+
+kwargs = {}
+source_docs = []
+st.set_page_config(page_title="PDFChat - An LLM-powered experimentation app")
+
+if "qna_system" not in st.session_state:
+    st.session_state.qna_system = QnASystem()
+
+
+def show_pdf(f):
+    f.seek(0)
+    base64_pdf = base64.b64encode(f.read()).decode('utf-8')
+    pdf_display = f'<iframe src="data:application/pdf;base64,{base64_pdf}" width="700" height="800" ' \
+                  f'type="application/pdf"></iframe>'
+    st.markdown(pdf_display, unsafe_allow_html=True)
+
+
+def model_settings():
+    kwargs["temperature"] = st.slider("Temperature", max_value=1.0, min_value=0.0)
+    kwargs["max_tokens"] = st.number_input("Max Token", min_value=0, value=512)
+
+
+st.title("PDF Question and Answering")
+
+tab1, tab2, tab3 = st.tabs(["Upload and Ingest PDF", "Ask", "Show PDF"])
+
+with st.sidebar:
+    st.header("Advance Setting ⚙️")
+    require_pdf = st.checkbox("Show PDF", value=1)
+    st.markdown('---')
+    kwargs["bot_type"] = st.selectbox("Bot Type", options=BotType)
+    st.markdown("---")
+    st.text("Model Parameters")
+    kwargs["return_documents"] = st.checkbox("Require Source Documents", value=True)
+    text_transform = st.selectbox("Text Transformer", options=TransformType)
+    st.markdown("---")
+    selected_model = st.selectbox("Select Model", options=EmbeddingTypes)
+    match selected_model:
+        case EmbeddingTypes.OPENAI:
+            api_key = st.text_input("OpenAI API Key", placeholder="sk-...", type="password")
+            if not api_key.startswith('sk-'):
+                st.warning('Please enter your OpenAI API key!', icon='⚠')
+            model_settings()
+        case EmbeddingTypes.HUGGING_FACE:
+            api_key = st.text_input("Hugging Face API Key", placeholder="hg-...", type="password")
+            if not api_key.startswith('hg-'):
+                st.warning('Please enter your HuggingFace API key!', icon='⚠')
+            huggingface_model = st.selectbox("Choose Model", options=["google/flan-t5-xl"])
+            model_settings()
+        case EmbeddingTypes.COHERE:
+            api_key = st.text_input("Cohere API Key", placeholder="...", type="password")
+            if not api_key:
+                st.warning('Please enter your Cohere API key!', icon='⚠')
+            model_settings()
+        case _:
+            api_key = None
+    kwargs["api_key"] = api_key
+    st.markdown("---")
+
+    vector_indexer = st.selectbox("Vector Indexer", options=IndexerType)
+    match vector_indexer:
+        case IndexerType.ELASTICSEARCH:
+            kwargs["elasticsearch_url"] = st.text_input("Elastic Search URL: ")
+            if not kwargs.get("elasticsearch_url"):
+                st.warning("Please enter your elastic search url", icon='⚠')
+            kwargs["elasticsearch_index"] = st.text_input("Elastic Search Index: ")
+            if not kwargs.get("elasticsearch_index"):
+                st.warning("Please enter your elastic search index", icon='⚠')
+
+    st.markdown("---")
+    st.text("Chain Settings")
+    kwargs["chain_type"] = st.selectbox("Chain Type", options=["stuff", "map_reduce"])
+    kwargs["search_type"] = st.selectbox("Search Type", options=["similarity"])
+    st.markdown("---")
+
+with tab1:
+    uploaded_file = st.file_uploader("Upload and Ingest PDF 🚀", type="pdf")
+    if uploaded_file:
+        with st.spinner("Uploading and Ingesting"):
+            documents = st.session_state.qna_system.read_and_load_pdf(uploaded_file)
+            if selected_model == EmbeddingTypes.NA:
+                st.warning("Please select the model", icon='⚠')
+            else:
+                st.session_state.qna_system.build_chain(transform_type=text_transform, embedding_type=selected_model,
+                                                        indexer_type=vector_indexer, **kwargs)
+
+
+def generate_response(prompt):
+    if prompt and uploaded_file:
+        response = st.session_state.qna_system.ask_question(prompt)
+        return response.get("answer", response.get("result", "")), response.get("source_documents")
+    return "", []
+
+
+with tab2:
+    if not uploaded_file:
+        st.warning("Please upload PDF", icon='⚠')
+    else:
+        match kwargs["bot_type"]:
+            case BotType.qna:
+                with st.container():
+                    with st.form('my_form'):
+                        text = st.text_area("", placeholder='Ask me...')
+                        submitted = st.form_submit_button('Submit')
+                        if text:
+                            st.write(f"Question:\n{text}")
+                            response, source_docs = generate_response(text)
+                            st.write(response)
+            case BotType.conversational:
+                # Generate empty lists for generated and past.
+                ## generated stores AI generated responses
+                if 'generated' not in st.session_state:
+                    st.session_state['generated'] = ["Hi! I'm PDF Assistant 🤖, How may I help you?"]
+                ## past stores User's questions
+                if 'past' not in st.session_state:
+                    st.session_state['past'] = ['Hi!']
+
+                input_container = st.container()
+                colored_header(label='', description='', color_name='blue-30')
+                response_container = st.container()
+                response = ""
+
+
+                def get_text():
+                    input_text = st.text_input("You: ", "", key="input")
+                    return input_text
+
+
+                with input_container:
+                    user_input = get_text()
+                    if st.button("Clear"):
+                        st.session_state.generated.clear()
+                        st.session_state.past.clear()
+
+                with response_container:
+                    if user_input:
+                        response, source_docs = generate_response(user_input)
+                        st.session_state.past.append(user_input)
+                        st.session_state.generated.append(response)
+
+                    if st.session_state['generated']:
+                        for i in range(len(st.session_state['generated'])):
+                            message(st.session_state['past'][i], is_user=True, key=str(i) + '_user')
+                            message(st.session_state["generated"][i], key=str(i))
+
+        require_document = st.container()
+        if kwargs["return_documents"]:
+            with require_document:
+                with st.expander("Related Documents", expanded=False):
+                    for source in source_docs:
+                        metadata = source.metadata
+                        st.write("{source} - {page_no}".format(source=metadata.get("source"),
+                                                               page_no=metadata.get("page_no")))
+                        st.write(source.page_content)
+                        st.markdown("---")
+
+with tab3:
+    if require_pdf and uploaded_file:
+        show_pdf(uploaded_file)
+    elif uploaded_file:
+        st.warning("Feature not enabled.", icon='⚠')
+    else:
+        st.warning("Please upload PDF", icon='⚠')

backend.py

@@ -0,0 +1,146 @@
+import os
+
+from langchain import FAISS, OpenAI, HuggingFaceHub, Cohere, PromptTemplate
+from langchain.chains import RetrievalQA, ConversationalRetrievalChain
+from langchain.embeddings import OpenAIEmbeddings, HuggingFaceEmbeddings, CohereEmbeddings
+from langchain.memory import ConversationBufferMemory
+from langchain.schema import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter, CharacterTextSplitter, NLTKTextSplitter, \
+    SpacyTextSplitter
+from langchain.vectorstores import Chroma, ElasticVectorSearch
+from pypdf import PdfReader
+
+from schema import EmbeddingTypes, IndexerType, TransformType, BotType
+
+
+class QnASystem:
+
+    def read_and_load_pdf(self, f_data):
+        pdf_data = PdfReader(f_data)
+        documents = []
+        for idx, page in enumerate(pdf_data.pages):
+            documents.append(Document(page_content=page.extract_text(),
+                                      metadata={"page_no": idx, "source": f_data.name}))
+
+        self.documents = documents
+
+    def document_transformer(self, transform_type: TransformType):
+        match transform_type:
+            case TransformType.CharacterTransform:
+                t_type = CharacterTextSplitter(chunk_size=1000, chunk_overlap=20)
+            case TransformType.RecursiveTransform:
+                t_type = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=20)
+            case TransformType.NLTKTransform:
+                t_type = NLTKTextSplitter()
+            case TransformType.SpacyTransform:
+                t_type = SpacyTextSplitter()
+
+            case _:
+                raise IndexError("Invalid Transformer Type")
+
+        self.transformed_documents = t_type.split_documents(documents=self.documents)
+
+    def generate_embeddings(self, embedding_type: EmbeddingTypes = EmbeddingTypes.OPENAI,
+                            indexer_type: IndexerType = IndexerType.FAISS, **kwargs):
+        temperature = kwargs.get("temperature", 0)
+        max_tokens = kwargs.get("max_tokens", 512)
+        match embedding_type:
+            case EmbeddingTypes.OPENAI:
+                os.environ["OPENAI_API_KEY"] = kwargs.get("api_key") or os.getenv("OPENAI_API_KEY")
+                embeddings = OpenAIEmbeddings()
+                llm = OpenAI(temperature=temperature, max_tokens=max_tokens)
+            case EmbeddingTypes.HUGGING_FACE:
+                embeddings = HuggingFaceEmbeddings(model_name=kwargs.get("model_name"))
+                llm = HuggingFaceHub(repo_id=kwargs.get("model_name"),
+                                     model_kwargs={"temperature": temperature, "max_tokens": max_tokens})
+            case EmbeddingTypes.COHERE:
+                embeddings = CohereEmbeddings(model=kwargs.get("model_name"), cohere_api_key=kwargs.get("api_key"))
+                llm = Cohere(model=kwargs.get("model_name"), cohere_api_key=kwargs.get("api_key"),
+                             model_kwargs={"temperature": temperature,
+                                           "max_tokens": max_tokens})
+            case _:
+                raise IndexError("Invalid Embedding Type")
+
+        match indexer_type:
+            case IndexerType.FAISS:
+                indexer = FAISS
+            case IndexerType.CHROMA:
+                indexer = Chroma()
+
+            case IndexerType.ELASTICSEARCH:
+                indexer = ElasticVectorSearch(elasticsearch_url=kwargs.get("elasticsearch_url"))
+            case _:
+                raise IndexError("Invalid Indexer Function")
+
+        self.llm = llm
+        self.indexer = indexer
+        self.vector_store = indexer.from_documents(documents=self.transformed_documents, embedding=embeddings)
+
+    def get_retriever(self, search_type="similarity", top_k=5, **kwargs):
+        retriever = self.vector_store.as_retriever(search_type=search_type, search_kwargs={"k": top_k})
+        self.retriever = retriever
+
+    def get_prompt(self, bot_type: BotType, **kwargs):
+        match bot_type:
+            case BotType.qna:
+                prompt = """
+                You are a smart and helpful AI assistant, who answer the question given context
+                {context}
+                Question: {question}
+                """
+            case BotType.conversational:
+                prompt = """
+                Given the following conversation and a follow up question, 
+                rephrase the follow up question to be a standalone question, in its original language.
+                \nChat History:\n{chat_history}\nFollow Up Input: {question}\nStandalone question:
+                """
+        return PromptTemplate(input_variables=["context", "question", "chat_history"], template=prompt)
+
+    def build_qa(self, qa_type: BotType, chain_type="stuff",
+                 return_documents: bool = True, **kwargs):
+        match qa_type:
+            case BotType.qna:
+                self.chain = RetrievalQA.from_chain_type(llm=self.llm, retriever=self.retriever, chain_type=chain_type,
+                                                         return_source_documents=return_documents, verbose=True)
+
+            case BotType.conversational:
+                self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True,
+                                                       output_key="answer")
+                self.chain = ConversationalRetrievalChain.from_llm(llm=self.llm, retriever=self.retriever,
+                                                                   chain_type=chain_type,
+                                                                   return_source_documents=return_documents,
+                                                                   memory=self.memory, verbose=True)
+
+            case _:
+                raise IndexError("Invalid QA Type")
+
+    def ask_question(self, query):
+        if type(self.chain) == RetrievalQA:
+            data = {"query": query}
+        else:
+            data = {"question": query}
+        return self.chain(data)
+
+    def build_chain(self, transform_type, embedding_type, indexer_type, **kwargs):
+        if hasattr(self, "llm"):
+            return self.chain
+        self.document_transformer(transform_type)
+        self.generate_embeddings(embedding_type=embedding_type,
+                                 indexer_type=indexer_type, **kwargs)
+        self.get_retriever(**kwargs)
+        qa = self.build_qa(qa_type=kwargs.get("bot_type"), **kwargs)
+        return qa
+
+
+if __name__ == "__main__":
+    qna = QnASystem()
+    with open("../docs/Doc A.pdf", "rb") as f:
+        qna.read_and_load_pdf(f)
+        chain = qna.build_chain(
+            transform_type=TransformType.RecursiveTransform,
+            embedding_type=EmbeddingTypes.OPENAI, indexer_type=IndexerType.FAISS,
+            chain_type="map_reduce", bot_type=BotType.conversational, return_documents=True
+        )
+        question = qna.ask_question(query="Hi! Summarize the document.")
+        question = qna.ask_question(query="What happened from June 1984 to September 1996")
+        print(question)

configs.py

@@ -0,0 +1,4 @@
+from qna_retrival.schema import EmbeddingTypes, IndexerType
+
+indexer_type = IndexerType.FAISS
+embedding_type = EmbeddingTypes.OPENAI

requirements.txt

@@ -0,0 +1,9 @@
+langchain
+openai
+chroma
+streamlit
+streamlit-extras
+streamlit-chat
+faiss-cpu
+pypdf
+tiktoken

schema.py

@@ -0,0 +1,63 @@
+from enum import Enum, EnumMeta
+from typing import Union
+
+
+class EnumMetaClass(Enum):
+
+    def __eq__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value.upper() == other.value.upper()
+        return self.value == other
+
+    def __hash__(self):
+        return hash(self._name_)
+
+    def __str__(self):
+        return self.value
+
+    @classmethod
+    def get_enum(cls, value: str) -> Union[EnumMeta, None]:
+        return next(
+            (
+                enum_val
+                for enum_val in cls
+                if (enum_val.value == value)
+                   or (
+                           isinstance(value, str)
+                           and isinstance(enum_val.value, str)
+                           and (value.lower() == enum_val.value.lower() or value.upper() == enum_val.name.upper())
+                   )
+            ),
+            None,
+        )
+
+    @classmethod
+    def _missing_(cls, name):
+        for member in cls:
+            if isinstance(member.name, str) and isinstance(name, str) and member.name.lower() == name.lower():
+                return member
+
+
+class EmbeddingTypes(EnumMetaClass):
+    NA = "NA"
+    OPENAI = "OpenAI"
+    HUGGING_FACE = "Hugging Face"
+    COHERE = "Cohere"
+
+
+class TransformType(EnumMetaClass):
+    RecursiveTransform = "Recursive Text Splitter"
+    CharacterTransform = "Character Text Splitter"
+    SpacyTransform = "Spacy Text Splitter"
+    NLTKTransform = "NLTK Text Splitter"
+
+
+class IndexerType(EnumMetaClass):
+    FAISS = "FAISS"
+    CHROMA = "Chroma"
+    ELASTICSEARCH = "Elastic Search"
+
+
+class BotType(EnumMetaClass):
+    qna = "Question Answering Bot ❓"
+    conversational = "Chatbot 🤖"