Duplicate from davila7/filegpt

Co-authored-by: Daniel Avila <[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

README 2.md

@@ -0,0 +1,54 @@
+<h1 align="center">
+FileGPT 🤖
+</h1>
+
+Read the article to know how it works: <a href="">Medium Article</a>
+
+With File GPT you will be able to extract all the information from a file.
+You will obtain the transcription, the embedding of each segment and also ask questions to the file through a chat.
+
+All code was written with the help of <a href="https://codegpt.co">Code GPT</a>
+
+<a href="https://codegpt.co" target="_blank"><img width="753" alt="Captura de Pantalla 2023-02-08 a la(s) 9 16 43 p  m" src="https://user-images.githubusercontent.com/6216945/217699939-eca3ae47-c488-44da-9cf6-c7caef69e1a7.png"></a>
+
+<hr>
+<br>
+
+# Features
+
+- Read any pdf, docx, txt or csv file
+- Embedding texts segments with Langchain and OpenAI (**text-embedding-ada-002**)
+- Chat with the file using **streamlit-chat** and LangChain QA with source and (**text-davinci-003**)
+
+# Running Locally
+
+1. Clone the repository
+
+```bash
+git clone https://github.com/davila7/file-gpt
+cd file-gpt
+```
+2. Install dependencies
+
+These dependencies are required to install with the requirements.txt file:
+
+* openai
+* pypdf
+* scikit-learn
+* numpy
+* tiktoken
+* docx2txt
+* langchain
+* pydantic
+* typing
+* faiss-cpu
+* streamlit_chat
+
+```bash
+pip install -r requirements.txt
+```
+3. Run the Streamlit server
+
+```bash
+streamlit run app.py
+```

README.md

@@ -0,0 +1,14 @@
+---
+title: FileGPT
+emoji: 🐢
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.17.0
+app_file: app.py
+pinned: false
+license: mit
+duplicated_from: davila7/filegpt
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,128 @@
+import streamlit as st
+from streamlit_chat import message
+import os
+from utils import (
+    parse_docx,
+    parse_pdf,
+    parse_txt,
+    parse_csv,
+    parse_pptx,
+    search_docs,
+    embed_docs,
+    text_to_docs,
+    get_answer,
+    parse_any,
+    get_sources,
+    wrap_text_in_html,
+)
+from openai.error import OpenAIError
+
+def clear_submit():
+    st.session_state["submit"] = False
+
+def set_openai_api_key(api_key: str):
+    st.session_state["OPENAI_API_KEY"] = api_key
+
+st.markdown('<h1>File GPT 🤖<small> by <a href="https://codegpt.co">Code GPT</a></small></h1>', unsafe_allow_html=True)
+
+# Sidebar
+index = None
+doc = None
+with st.sidebar:
+    user_secret = st.text_input(
+        "OpenAI API Key",
+        type="password",
+        placeholder="Paste your OpenAI API key here (sk-...)",
+        help="You can get your API key from https://platform.openai.com/account/api-keys.",
+        value=st.session_state.get("OPENAI_API_KEY", ""),
+    )
+    if user_secret:
+        set_openai_api_key(user_secret)
+
+    uploaded_file = st.file_uploader(
+        "Upload a pdf, docx, or txt file",
+        type=["pdf", "docx", "txt", "csv", "pptx", "js", "py", "json", "html", "css", "md"],
+        help="Scanned documents are not supported yet!",
+        on_change=clear_submit,
+    )
+
+    if uploaded_file is not None:
+        if uploaded_file.name.endswith(".pdf"):
+            doc = parse_pdf(uploaded_file)
+        elif uploaded_file.name.endswith(".docx"):
+            doc = parse_docx(uploaded_file)
+        elif uploaded_file.name.endswith(".csv"):
+            doc = parse_csv(uploaded_file)
+        elif uploaded_file.name.endswith(".txt"):
+            doc = parse_txt(uploaded_file)
+        elif uploaded_file.name.endswith(".pptx"):
+            doc = parse_pptx(uploaded_file)
+        else:
+            doc = parse_any(uploaded_file)
+            #st.error("File type not supported")
+            #doc = None
+        text = text_to_docs(doc)
+        st.write(text)
+        try:
+            with st.spinner("Indexing document... This may take a while⏳"):
+                index = embed_docs(text)
+                st.session_state["api_key_configured"] = True
+        except OpenAIError as e:
+            st.error(e._message)
+
+tab1, tab2 = st.tabs(["Intro", "Chat with the File"])
+with tab1:
+    st.markdown("### How does it work?")
+    st.write("File GPT is a tool that allows you to ask questions about a document and get answers from the document. The tool uses the OpenAI API to embed the document and then uses the Embedding API to find the most similar documents to the question. The tool then uses LangChain to obtain the answer from the most similar documents.")
+    st.write("The tool is currently in beta and is not perfect. It is recommended to use it with short documents.")
+    st.write("""---""")
+    st.markdown("### How to use it?")
+    st.write("To use the tool you must first add your OpenAI API Key and then upload a document. The tool currently supports the following file types: pdf, docx, txt, csv, pptx. Once the document is uploaded, the tool will index the document and embed it. This may take a while depending on the size of the document. Once the document is indexed, you can ask questions about the document. The tool will return the answer to the question and the source of the answer.")
+    st.markdown('<p>Read the article to know more details: <a target="_blank" href="https://medium.com/@dan.avila7/file-gpt-conversaci%C3%B3n-por-chat-con-un-archivo-698d17570358">Medium Article (Spanish)</a></p>', unsafe_allow_html=True)
+    st.write("## File GPT was written with the following tools:")
+    st.markdown("#### Code GPT")
+    st.write('All code was written with the help of Code GPT. Visit https://codegpt.co to get the extension.')
+    st.markdown("#### Streamlit")
+    st.write('The design was written with <a target="_blank" href="https://streamlit.io/">Streamlit</a>.', unsafe_allow_html=True)
+    st.markdown("#### LangChain")
+    st.write('Question answering with source <a target="_blank" href="https://langchain.readthedocs.io/en/latest/use_cases/question_answering.html#adding-in-sources">Langchain QA</a>.', unsafe_allow_html=True)
+    st.markdown("#### Embedding")
+    st.write('<a target="_blank" href="https://platform.openai.com/docs/guides/embeddings">Embedding</a> is done via the OpenAI API with "text-embedding-ada-002"', unsafe_allow_html=True)
+    st.write("Please note that you must have credits in your OpenAI account to use this tool. Each file uploaded to the platform consumes credits for embedding and each query consumes credits to obtain the response.")
+    st.markdown("""---""")
+    st.write('Author:  <a target="_blank" href="https://www.linkedin.com/in/daniel-avila-arias/">Daniel Avila</a>', unsafe_allow_html=True)
+    st.write('Repo: <a target="_blank" href="https://github.com/davila7/file-gpt">Github</a>', unsafe_allow_html=True)
+    st.write("This software was developed with Code GPT, for more information visit: https://codegpt.co", unsafe_allow_html=True)
+
+with tab2:
+    st.write('To obtain an API Key you must create an OpenAI account at the following link: https://openai.com/api/')
+    if 'generated' not in st.session_state:
+        st.session_state['generated'] = []
+
+    if 'past' not in st.session_state:
+        st.session_state['past'] = []
+
+    def get_text():
+        if user_secret:
+            st.header("Ask me something about the document:")
+            input_text = st.text_area("You:", on_change=clear_submit)
+            return input_text
+    user_input = get_text()
+
+    button = st.button("Submit")
+    if button or st.session_state.get("submit"):
+        if not user_input:
+            st.error("Please enter a question!")
+        else:
+            st.session_state["submit"] = True
+            sources = search_docs(index, user_input)
+            try:
+                answer = get_answer(sources, user_input)
+                st.session_state.past.append(user_input)
+                st.session_state.generated.append(answer["output_text"].split("SOURCES: ")[0])
+            except OpenAIError as e:
+                st.error(e._message)
+            if st.session_state['generated']:
+                for i in range(len(st.session_state['generated'])-1, -1, -1):
+                    message(st.session_state["generated"][i], key=str(i))
+                    message(st.session_state['past'][i], is_user=True, key=str(i) + '_user')

embeddings.py

@@ -0,0 +1,115 @@
+"""Wrapper around OpenAI embedding models."""
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Extra, root_validator
+
+from langchain.embeddings.base import Embeddings
+from langchain.utils import get_from_dict_or_env
+
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+from openai.error import Timeout, APIError, APIConnectionError, RateLimitError
+
+
+class OpenAIEmbeddings(BaseModel, Embeddings):
+    """Wrapper around OpenAI embedding models.
+    To use, you should have the ``openai`` python package installed, and the
+    environment variable ``OPENAI_API_KEY`` set with your API key or pass it
+    as a named parameter to the constructor.
+    Example:
+        .. code-block:: python
+            from langchain.embeddings import OpenAIEmbeddings
+            openai = OpenAIEmbeddings(openai_api_key="my-api-key")
+    """
+
+    client: Any  #: :meta private:
+    document_model_name: str = "text-embedding-ada-002"
+    query_model_name: str = "text-embedding-ada-002"
+    openai_api_key: Optional[str] = None
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        extra = Extra.forbid
+
+    # TODO: deprecate this
+    @root_validator(pre=True, allow_reuse=True)
+    def get_model_names(cls, values: Dict) -> Dict:
+        """Get model names from just old model name."""
+        if "model_name" in values:
+            if "document_model_name" in values:
+                raise ValueError(
+                    "Both `model_name` and `document_model_name` were provided, "
+                    "but only one should be."
+                )
+            if "query_model_name" in values:
+                raise ValueError(
+                    "Both `model_name` and `query_model_name` were provided, "
+                    "but only one should be."
+                )
+            model_name = values.pop("model_name")
+            values["document_model_name"] = f"text-search-{model_name}-doc-001"
+            values["query_model_name"] = f"text-search-{model_name}-query-001"
+        return values
+
+    @root_validator(allow_reuse=True)
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        openai_api_key = get_from_dict_or_env(
+            values, "openai_api_key", "OPENAI_API_KEY"
+        )
+        try:
+            import openai
+
+            openai.api_key = openai_api_key
+            values["client"] = openai.Embedding
+        except ImportError:
+            raise ValueError(
+                "Could not import openai python package. "
+                "Please it install it with `pip install openai`."
+            )
+        return values
+
+    @retry(
+        reraise=True,
+        stop=stop_after_attempt(100),
+        wait=wait_exponential(multiplier=1, min=10, max=60),
+        retry=(
+            retry_if_exception_type(Timeout)
+            | retry_if_exception_type(APIError)
+            | retry_if_exception_type(APIConnectionError)
+            | retry_if_exception_type(RateLimitError)
+        ),
+    )
+    def _embedding_func(self, text: str, *, engine: str) -> List[float]:
+        """Call out to OpenAI's embedding endpoint with exponential backoff."""
+        # replace newlines, which can negatively affect performance.
+        text = text.replace("\n", " ")
+        return self.client.create(input=[text], engine=engine)["data"][0]["embedding"]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to OpenAI's embedding endpoint for embedding search docs.
+        Args:
+            texts: The list of texts to embed.
+        Returns:
+            List of embeddings, one for each text.
+        """
+        responses = [
+            self._embedding_func(text, engine=self.document_model_name)
+            for text in texts
+        ]
+        return responses
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to OpenAI's embedding endpoint for embedding query text.
+        Args:
+            text: The text to embed.
+        Returns:
+            Embeddings for the text.
+        """
+        embedding = self._embedding_func(text, engine=self.query_model_name)
+        return embedding

prompts.py

@@ -0,0 +1,26 @@
+from langchain.prompts import PromptTemplate
+
+## Use a shorter template to reduce the number of tokens in the prompt
+template = """Create a final answer to the given questions using the provided document excerpts(in no particular order) as references. ALWAYS include a "SOURCES" section in your answer including only the minimal set of sources needed to answer the question. If you are unable to answer the question, simply state that you do not know. Do not attempt to fabricate an answer and leave the SOURCES section empty.
+---------
+QUESTION: What  is the purpose of ARPA-H?
+=========
+Content: More support for patients and families. \n\nTo get there, I call on Congress to fund ARPA-H, the Advanced Research Projects Agency for Health. \n\nIt’s based on DARPA—the Defense Department project that led to the Internet, GPS, and so much more.  \n\nARPA-H will have a singular purpose—to drive breakthroughs in cancer, Alzheimer’s, diabetes, and more.
+Source: 1-32
+Content: While we’re at it, let’s make sure every American can get the health care they need. \n\nWe’ve already made historic investments in health care. \n\nWe’ve made it easier for Americans to get the care they need, when they need it. \n\nWe’ve made it easier for Americans to get the treatments they need, when they need them. \n\nWe’ve made it easier for Americans to get the medications they need, when they need them.
+Source: 1-33
+Content: The V.A. is pioneering new ways of linking toxic exposures to disease, already helping  veterans get the care they deserve. \n\nWe need to extend that same care to all Americans. \n\nThat’s why I’m calling on Congress to pass legislation that would establish a national registry of toxic exposures, and provide health care and financial assistance to those affected.
+Source: 1-30
+=========
+FINAL ANSWER: The purpose of ARPA-H is to drive breakthroughs in cancer, Alzheimer’s, diabetes, and more.
+SOURCES: 1-32
+---------
+QUESTION: {question}
+=========
+{summaries}
+=========
+FINAL ANSWER:"""
+
+STUFF_PROMPT = PromptTemplate(
+    template=template, input_variables=["summaries", "question"]
+)

requirements.txt

@@ -0,0 +1,12 @@
+openai
+pypdf
+scikit-learn
+numpy
+tiktoken
+docx2txt
+langchain
+pydantic
+typing
+faiss-cpu
+streamlit_chat
+python-pptx

utils.py

@@ -0,0 +1,183 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores.faiss import FAISS
+from langchain import OpenAI, Cohere
+from langchain.chains.qa_with_sources import load_qa_with_sources_chain
+from embeddings import OpenAIEmbeddings
+from langchain.llms import OpenAI
+from langchain.docstore.document import Document
+from langchain.vectorstores import FAISS, VectorStore
+import docx2txt
+from typing import List, Dict, Any
+import re
+import numpy as np
+from io import StringIO
+from io import BytesIO
+import streamlit as st
+from prompts import STUFF_PROMPT
+from pypdf import PdfReader
+from openai.error import AuthenticationError
+import pptx
+
+@st.experimental_memo()
+def parse_docx(file: BytesIO) -> str:
+    text = docx2txt.process(file)
+    # Remove multiple newlines
+    text = re.sub(r"\n\s*\n", "\n\n", text)
+    return text
+
+
+@st.experimental_memo()
+def parse_pdf(file: BytesIO) -> List[str]:
+    pdf = PdfReader(file)
+    output = []
+    for page in pdf.pages:
+        text = page.extract_text()
+        # Merge hyphenated words
+        text = re.sub(r"(\w+)-\n(\w+)", r"\1\2", text)
+        # Fix newlines in the middle of sentences
+        text = re.sub(r"(?<!\n\s)\n(?!\s\n)", " ", text.strip())
+        # Remove multiple newlines
+        text = re.sub(r"\n\s*\n", "\n\n", text)
+
+        output.append(text)
+
+    return output
+
+
+@st.experimental_memo()
+def parse_txt(file: BytesIO) -> str:
+    text = file.read().decode("utf-8")
+    # Remove multiple newlines
+    text = re.sub(r"\n\s*\n", "\n\n", text)
+    return text
+
+@st.experimental_memo()
+def parse_pptx(file: BytesIO) -> str:
+    
+    ppt_file = pptx.Presentation(file)
+
+    string_data = ""
+    
+    for slide in ppt_file.slides:
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                string_data += shape.text_frame.text + '\n'
+    return string_data
+
+@st.experimental_memo()
+def parse_csv(uploaded_file):
+    # To read file as bytes:
+    #bytes_data = uploaded_file.getvalue()
+    #st.write(bytes_data)
+
+    # To convert to a string based IO:
+    stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+    #st.write(stringio)
+
+    # To read file as string:
+    string_data = stringio.read()
+    #st.write(string_data)
+
+    # Can be used wherever a "file-like" object is accepted:
+    # dataframe = pd.read_csv(uploaded_file)
+    return string_data
+
+@st.experimental_memo()
+def parse_any(uploaded_file):
+    stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+    string_data = stringio.read()
+    return string_data
+
+@st.cache(allow_output_mutation=True)
+def text_to_docs(text: str) -> List[Document]:
+    """Converts a string or list of strings to a list of Documents
+    with metadata."""
+    if isinstance(text, str):
+        # Take a single string as one page
+        text = [text]
+    page_docs = [Document(page_content=page) for page in text]
+
+    # Add page numbers as metadata
+    for i, doc in enumerate(page_docs):
+        doc.metadata["page"] = i + 1
+
+    # Split pages into chunks
+    doc_chunks = []
+
+    for doc in page_docs:
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=800,
+            separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""],
+            chunk_overlap=0,
+        )
+        chunks = text_splitter.split_text(doc.page_content)
+        for i, chunk in enumerate(chunks):
+            doc = Document(
+                page_content=chunk, metadata={"page": doc.metadata["page"], "chunk": i}
+            )
+            # Add sources a metadata
+            doc.metadata["source"] = f"{doc.metadata['page']}-{doc.metadata['chunk']}"
+            doc_chunks.append(doc)
+    return doc_chunks
+
+
+@st.cache(allow_output_mutation=True, show_spinner=False)
+def embed_docs(docs: List[Document]) -> VectorStore:
+    """Embeds a list of Documents and returns a FAISS index"""
+
+    if not st.session_state.get("OPENAI_API_KEY"):
+        raise AuthenticationError(
+            "Enter your OpenAI API key in the sidebar. You can get a key at https://platform.openai.com/account/api-keys."
+        )
+    else:
+        # Embed the chunks
+        embeddings = OpenAIEmbeddings(openai_api_key=st.session_state.get("OPENAI_API_KEY"))  # type: ignore
+        index = FAISS.from_documents(docs, embeddings)
+
+        return index
+
+
+@st.cache(allow_output_mutation=True)
+def search_docs(index: VectorStore, query: str) -> List[Document]:
+    """Searches a FAISS index for similar chunks to the query
+    and returns a list of Documents."""
+
+    # Search for similar chunks
+    docs = index.similarity_search(query, k=5)
+    return docs
+
+
+@st.cache(allow_output_mutation=True)
+def get_answer(docs: List[Document], query: str) -> Dict[str, Any]:
+    """Gets an answer to a question from a list of Documents."""
+
+    # Get the answer
+    chain = load_qa_with_sources_chain(OpenAI(temperature=0, openai_api_key=st.session_state.get("OPENAI_API_KEY")), chain_type="stuff", prompt=STUFF_PROMPT)  # type: ignore
+
+    answer = chain(
+        {"input_documents": docs, "question": query}, return_only_outputs=True
+    )
+    return answer
+
+
+@st.cache(allow_output_mutation=True)
+def get_sources(answer: Dict[str, Any], docs: List[Document]) -> List[Document]:
+    """Gets the source documents for an answer."""
+
+    # Get sources for the answer
+    source_keys = [s for s in answer["output_text"].split("SOURCES: ")[-1].split(", ")]
+
+    source_docs = []
+    for doc in docs:
+        if doc.metadata["source"] in source_keys:
+            source_docs.append(doc)
+
+    return source_docs
+
+
+def wrap_text_in_html(text: str) -> str:
+    """Wraps each text block separated by newlines in <p> tags"""
+    if isinstance(text, list):
+        # Add horizontal rules between pages
+        text = "\n<hr/>\n".join(text)
+    return "".join([f"<p>{line}</p>" for line in text.split("\n")])