Duplicate from hbui/RegBotBeta2.3

.gitattributes

@@ -0,0 +1,39 @@
+*.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
+.*pdf filter=lfs diff=lfs merge=lfs -text
+assets/pdf/calregs.pdf filter=lfs diff=lfs merge=lfs -text
+assets/pdf/CADWReg.pdf filter=lfs diff=lfs merge=lfs -text
+vectorStores/bloom-560m/vector_store.json filter=lfs diff=lfs merge=lfs -text
+vectorStores/langOpen/index.faiss filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+venv
+data/__pycache__
+models/__pycache__
+.env
+__pycache__
+vectorStores
+.vscode

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.9
+
+WORKDIR /docker
+
+ADD . /docker
+
+COPY requirements.txt requirements.txt
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Set the working directory to the user's home directory
+COPY --chown=user . $HOME/app
+
+EXPOSE 8501
+
+HEALTHCHECK CMD --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# CMD [ "streamlit" , "run", "app.py"]
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,13 @@
+---
+title: RegBotBeta
+emoji: 😻
+colorFrom: green
+colorTo: red
+sdk: docker
+app_file: app.py
+app_port: 8501
+pinned: false
+duplicated_from: hbui/RegBotBeta2.3
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,31 @@
+# https://docs.streamlit.io/knowledge-base/tutorials/build-conversational-apps
+
+import os
+
+import openai
+import requests
+import streamlit as st
+
+from utils.util import *
+
+st.set_page_config(page_title="RegBotBeta", page_icon="📜🤖")
+
+st.title("Welcome to RegBotBeta2.0")
+st.header("Powered by `LlamaIndex🦙`, `Langchain🦜🔗 ` and `OpenAI API`")
+
+#api_key = st.text_input("Enter your OpenAI API key here:", type="password")
+api_key = os.environ['OPENAI_API_KEY']
+
+if api_key:
+    resp = validate(api_key)
+    if "error" in resp.json():
+        st.info("Invalid Token! Try again.")
+    else:
+        #st.info("Success")
+        os.environ["OPENAI_API_KEY"] = api_key
+        openai.api_key = api_key
+
+        if "openai_api_key" not in st.session_state:
+            st.session_state.openai_api_key = ""
+
+        st.session_state.openai_api_key = api_key

assets/pdf/CADWReg.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a80bdec9f2f6c15ca5d9181723b711bb7428fa48babaf87bab3f3b690055f54
+size 3724564

assets/prompts/custom_prompts.py

@@ -0,0 +1,22 @@
+text_qa_template_str = (
+    "Assistant Message: I'm here to assist you with information about California water regulations."
+    "Feel free to ask questions based on the context below, and I'll do my best to provide accurate answers.\n\n"
+    "Context: {context_str}\n\n"
+    "Your Question: {query_str}\n\n"
+    "Answer: \n\n"
+    "If the question is pertinent, I'll provide you with the chapter, article, and section of the information"
+    "from the PDF document 'Title 17 and 22, California Code of Regulations'. Additionally, I'll strive to include"
+    "the corresponding page number for your reference.\n\n"
+    "Please note that my knowledge is up to date as of September 2021."
+)
+
+refine_template_str = (
+    "The original question is as follows: {query_str}\n"
+    "We have provided an existing answer: {existing_answer}\n"
+    "We have the opportunity to refine the existing answer "
+    "(only if needed) with some more context below.\n"
+    "------------\n"
+    "{context_msg}\n"
+    "------------\n"
+    "Using both the new context and your own knowledege, update or repeat the existing answer.\n"
+)

models/langOpen.py

@@ -0,0 +1,48 @@
+import os
+
+import openai
+from dotenv import load_dotenv
+from langchain.chains import LLMChain
+from langchain.chat_models import ChatOpenAI
+from langchain.document_loaders import PyPDFLoader
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain.vectorstores import FAISS
+
+loader = PyPDFLoader("./assets/pdf/CADWReg.pdf")
+pages = loader.load_and_split()
+
+load_dotenv()
+
+prompt_template = """Answer the question using the given context to the best of your ability. 
+If you don't know, answer I don't know.
+Context: {context}
+Topic: {topic}"""
+
+PROMPT = PromptTemplate(template=prompt_template, input_variables=["context", "topic"])
+
+
+class LangOpen:
+    def __init__(self, model_name: str) -> None:
+        self.index = self.initialize_index("langOpen")
+        self.llm = ChatOpenAI(temperature=0.3, model=model_name)
+        self.chain = LLMChain(llm=self.llm, prompt=PROMPT)
+
+    def initialize_index(self, index_name):
+        path = f"./vectorStores/{index_name}"
+        embeddings = OpenAIEmbeddings()
+        
+        if os.path.exists(path=path):
+            return FAISS.load_local(folder_path=path, embeddings=embeddings)
+        else:
+            faiss = FAISS.from_documents(pages, embeddings)
+            faiss.save_local(path)
+            return faiss
+
+    def get_response(self, query_str):
+        print("query_str: ", query_str)
+        print("model_name: ", self.llm.model_name)
+        docs = self.index.similarity_search(query_str, k=4)
+        inputs = [{"context": doc.page_content, "topic": query_str} for doc in docs]
+        result = self.chain.apply(inputs)[0]["text"]
+        return result

models/llamaCustom.py

@@ -0,0 +1,152 @@
+import os
+import pickle
+from json import dumps, loads
+from typing import Any, List, Mapping, Optional
+
+import numpy as np
+import openai
+import pandas as pd
+import streamlit as st
+from dotenv import load_dotenv
+from huggingface_hub import HfFileSystem
+from langchain.llms.base import LLM
+from llama_index import (
+    Document,
+    GPTVectorStoreIndex,
+    LLMPredictor,
+    PromptHelper,
+    ServiceContext,
+    SimpleDirectoryReader,
+    StorageContext,
+    load_index_from_storage,
+)
+from llama_index.llms import CompletionResponse, CustomLLM, LLMMetadata
+from llama_index.prompts import Prompt
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+
+from assets.prompts import custom_prompts
+
+load_dotenv()
+# openai.api_key = os.getenv("OPENAI_API_KEY")
+fs = HfFileSystem()
+
+# define prompt helper
+# set maximum input size
+CONTEXT_WINDOW = 2048
+# set number of output tokens
+NUM_OUTPUT = 525
+# set maximum chunk overlap
+CHUNK_OVERLAP_RATION = 0.2
+
+text_qa_template = Prompt(custom_prompts.text_qa_template_str)
+
+refine_template = Prompt(custom_prompts.refine_template_str)
+
+
+@st.cache_resource
+def load_model(model_name: str):
+    # llm_model_name = "bigscience/bloom-560m"
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForCausalLM.from_pretrained(model_name, config="T5Config")
+
+    pipe = pipeline(
+        task="text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        # device=0, # GPU device number
+        # max_length=512,
+        do_sample=True,
+        top_p=0.95,
+        top_k=50,
+        temperature=0.7,
+    )
+
+    return pipe
+
+
+class OurLLM(CustomLLM):
+    def __init__(self, model_name: str, model_pipeline):
+        self.model_name = model_name
+        self.pipeline = model_pipeline
+
+    @property
+    def metadata(self) -> LLMMetadata:
+        """Get LLM metadata."""
+        return LLMMetadata(
+            context_window=CONTEXT_WINDOW,
+            num_output=NUM_OUTPUT,
+            model_name=self.model_name,
+        )
+
+    def complete(self, prompt: str, **kwargs: Any) -> CompletionResponse:
+        prompt_length = len(prompt)
+        response = self.pipeline(prompt, max_new_tokens=NUM_OUTPUT)[0]["generated_text"]
+
+        # only return newly generated tokens
+        text = response[prompt_length:]
+        return CompletionResponse(text=text)
+
+    def stream_complete(self, prompt: str, **kwargs: Any) -> CompletionResponse:
+        raise NotImplementedError()
+
+
+class LlamaCustom:
+    def __init__(self, model_name: str) -> None:
+        self.vector_index = self.initialize_index(model_name=model_name)
+
+    def initialize_index(self, model_name: str):
+        index_name = model_name.split("/")[-1]
+
+        file_path = f"./vectorStores/{index_name}"
+
+        if os.path.exists(path=file_path):
+            # rebuild storage context
+            storage_context = StorageContext.from_defaults(persist_dir=file_path)
+
+            # local load index access
+            index = load_index_from_storage(storage_context)
+
+            # huggingface repo load access
+            # with fs.open(file_path, "r") as file:
+            #     index = pickle.loads(file.readlines())
+            return index
+        else:
+            prompt_helper = PromptHelper(
+                context_window=CONTEXT_WINDOW,
+                num_output=NUM_OUTPUT,
+                chunk_overlap_ratio=CHUNK_OVERLAP_RATION,
+            )
+
+            # define llm
+            pipe = load_model(model_name=model_name)
+            llm = OurLLM(model_name=model_name, model_pipeline=pipe)
+
+            llm_predictor = LLMPredictor(llm=llm)
+            service_context = ServiceContext.from_defaults(
+                llm_predictor=llm_predictor, prompt_helper=prompt_helper
+            )
+
+            # documents = prepare_data(r"./assets/regItems.json")
+            documents = SimpleDirectoryReader(input_dir="./assets/pdf").load_data()
+
+            index = GPTVectorStoreIndex.from_documents(
+                documents, service_context=service_context
+            )
+
+            # local write access
+            index.storage_context.persist(file_path)
+
+            # huggingface repo write access
+            # with fs.open(file_path, "w") as file:
+            #     file.write(pickle.dumps(index))
+            return index
+
+    def get_response(self, query_str):
+        print("query_str: ", query_str)
+        # query_engine = self.vector_index.as_query_engine()
+        query_engine = self.vector_index.as_query_engine(
+            text_qa_template=text_qa_template, refine_template=refine_template
+        )
+        response = query_engine.query(query_str)
+        print("metadata: ", response.metadata)
+        return str(response)

pages/langchain_demo.py

@@ -0,0 +1,26 @@
+import os
+
+import openai
+import streamlit as st
+
+from models.langOpen import LangOpen
+from utils.chatbox import chatbox
+
+st.set_page_config(page_title="Langchain", page_icon="")
+
+st.subheader("Langchain with OpenAI Demo")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "openai_api_key" not in st.session_state:
+    st.info("Enter your openai key to access the chatbot.")
+else:
+    option = st.selectbox(
+        label="Select your model:", options=("gpt-3.5-turbo", "gpt-4")
+    )
+
+    with st.spinner(f"Initializing {option} ..."):
+        langOpen = LangOpen(model_name=option)
+
+    chatbox("lang_open", langOpen)

pages/llama_custom_demo.py

@@ -0,0 +1,26 @@
+import os
+
+import openai
+import streamlit as st
+
+from models.llamaCustom import LlamaCustom
+from utils.chatbox import chatbox
+
+st.set_page_config(page_title="Llama", page_icon="🦙")
+
+st.subheader("Llama Index with Custom LLM Demo")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "openai_api_key" not in st.session_state:
+    st.info("Enter your openai key to access the chatbot.")
+else:
+    option = st.selectbox(
+        label="Select your model:", options=("bigscience/bloom-560m",)
+    )
+
+    # with st.spinner("Initializing vector index"):
+    model = LlamaCustom(model_name=option)
+
+    chatbox("llama_custom", model)

requirements.txt

@@ -0,0 +1,13 @@
+llama_index
+torch
+transformers
+panda
+numpy
+langchain
+openai
+faiss-cpu
+python-dotenv
+streamlit>=1.24.0
+huggingface_hub
+xformers
+pypdf

utils/chatbox.py

@@ -0,0 +1,93 @@
+import time
+
+import streamlit as st
+
+def display_chat_history(model_name: str):
+    for message in st.session_state[model_name]:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+def chat_input(model_name: str):
+    if prompt := st.chat_input("Say something"):
+        # Display user message in chat message container
+        st.chat_message("user").markdown(prompt)
+
+        # Add user message to chat history
+        st.session_state[model_name].append({"role": "user", "content": prompt})
+
+        return prompt
+
+def display_bot_msg(model_name: str, bot_response: str):
+    # Display assistant response in chat message container
+    with st.chat_message("assistant"):
+        message_placeholder = st.empty()
+        full_response = ""
+
+        # simulate the chatbot "thinking" before responding
+        # (or stream its response)
+        for chunk in bot_response.split():
+            full_response += chunk + " "
+            time.sleep(0.05)
+
+            # add a blinking cursor to simulate typing
+            message_placeholder.markdown(full_response + "▌")
+
+        message_placeholder.markdown(full_response)
+        # st.markdown(response)
+
+    # Add assistant response to chat history
+    st.session_state[model_name].append(
+        {"model_name": model_name, "role": "assistant", "content": full_response}
+    )
+
+def chatbox(model_name: str, model: None):
+    # Display chat messages from history on app rerun
+    for message in st.session_state.messages:
+        if (message["model_name"] == model_name):
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+    if prompt := st.chat_input("Say something"):
+        # Display user message in chat message container
+        st.chat_message("user").markdown(prompt)
+
+        # Add user message to chat history
+        st.session_state.messages.append({"model_name": model_name, "role": "user", "content": prompt})
+
+        with st.spinner("Processing your query..."):
+            bot_response = model.get_response(prompt)
+
+        print("bot: ", bot_response)
+
+        # Display assistant response in chat message container
+        with st.chat_message("assistant"):
+            message_placeholder = st.empty()
+            full_response = ""
+
+            # simulate the chatbot "thinking" before responding
+            # (or stream its response)
+            for chunk in bot_response.split():
+                full_response += chunk + " "
+                time.sleep(0.05)
+
+                # add a blinking cursor to simulate typing
+                message_placeholder.markdown(full_response + "▌")
+
+            message_placeholder.markdown(full_response)
+            # st.markdown(response)
+
+        # Add assistant response to chat history
+        st.session_state.messages.append(
+            {"model_name": model_name, "role": "assistant", "content": full_response}
+        )
+
+        # Scroll to the bottom of the chat container
+        # st.markdown(
+        #     """
+        #     <script>
+        #     const chatContainer = document.getElementsByClassName("css-1n76uvr")[0];
+        #     chatContainer.scrollTop = chatContainer.scrollHeight;
+        #     </script>
+        #     """,
+        #     unsafe_allow_html=True,
+        # )

utils/util.py

@@ -0,0 +1,15 @@
+import requests
+
+
+def validate(token: str):
+    api_endpoint = "https://api.openai.com/v1/chat/completions"
+    api_key = token
+
+    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+
+    messages = [{"role": "user", "content": "Say this is a test!"}]
+
+    data = {"model": "gpt-3.5-turbo", "messages": messages}
+
+    response = requests.post(api_endpoint, json=data, headers=headers)
+    return response