Upload 6 files

pages/ChatPDF_Ingestion.py

@@ -0,0 +1,52 @@
+# File Selection Drop Down
+import streamlit as st
+import os
+from langchain.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import UnstructuredFileLoader, DirectoryLoader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.llms import HuggingFaceHub
+from langchain.vectorstores import Chroma
+from langchain_community.vectorstores import Chroma
+from langchain.chains import ConversationalRetrievalChain
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import sys,yaml,Utilities as ut
+
+
+st.set_page_config(page_title="ChatPDF Ingestion", page_icon="📈")
+
+def load_pdf():
+   
+   # Load the pdf file and split it into smaller chunks
+   initdict={}
+   initdict = ut.get_tokens()
+   hf_token = initdict["hf_token"]
+   embedding_model_id = initdict["embedding_model"]
+   chromadbpath = initdict["chatPDF_chroma_db"]
+   
+   embeddings = HuggingFaceEmbeddings(model_name=embedding_model_id)
+   
+   loader = DirectoryLoader('data/', glob="**/*.pdf", show_progress=True, loader_cls=UnstructuredFileLoader)
+
+   documents = loader.load()
+   #print (len(documents))
+   
+   # Split the documents into smaller chunks 
+
+   text_splitter = RecursiveCharacterTextSplitter(chunk_size=700, chunk_overlap=70)
+   texts = text_splitter.split_documents(documents)
+    
+   #Using Chroma vector database to store and retrieve embeddings of our text
+   db = Chroma.from_documents(texts, embeddings, persist_directory=chromadbpath)
+   return db
+
+st.title("PatentGuru  - Document Ingestion ")
+# Main chat form
+with st.form("chat_form"):
+    #query = st.text_input("You: ")
+    submit_button = st.form_submit_button("Upload..")    
+
+if submit_button:
+    load_pdf()
+        
+    st.write ("Uploaded successfully")

pages/ChatPDF_Reader.py

@@ -0,0 +1,64 @@
+# import required libraries
+from langchain.document_loaders import PyPDFLoader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.llms import HuggingFaceHub
+from langchain.vectorstores import Chroma
+from langchain_community.vectorstores import Chroma
+from langchain.chains import ConversationalRetrievalChain
+#from langchain.text_splitter import NLTKTextSplitter
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+import streamlit as st
+import sys,yaml,Utilities as ut
+
+def get_data(query):
+    chat_history = []
+    initdict={}
+    initdict = ut.get_tokens()
+    hf_token = initdict["hf_token"]
+    embedding_model_id = initdict["embedding_model"]
+    chromadbpath = initdict["chatPDF_chroma_db"]
+    llm_repo_id = initdict["llm_repoid"]
+    
+    
+    # We will use HuggingFace embeddings 
+    embeddings = HuggingFaceEmbeddings(model_name=embedding_model_id)
+
+    #retriever = db.as_retriever(search_type="mmr", search_kwargs={'k': 1})
+    # load from disk
+    db = Chroma(persist_directory=chromadbpath, embedding_function=embeddings)
+    retriever = db.as_retriever(search_type="mmr", search_kwargs={'k': 2})
+
+    llm = HuggingFaceHub(huggingfacehub_api_token=hf_token, 
+                        repo_id=llm_repo_id, model_kwargs={"temperature":0.2, "max_new_tokens":50})
+
+    # Create the Conversational Retrieval Chain
+    qa_chain = ConversationalRetrievalChain.from_llm(llm, retriever,return_source_documents=True)
+    result = qa_chain({'question': query, 'chat_history': chat_history})
+    chat_history.append(result)
+    print('Answer: ' + result['answer'] + '\n')
+    print (result)
+    return result['answer']
+    
+st.title("PatentGuru Document Reader")
+
+# Main chat form
+with st.form("chat_form"):
+    query = st.text_input("Chat with PDF: ")
+    clear_history = st.checkbox('Clear Chat History') 
+    submit_button = st.form_submit_button("Send")    
+
+if submit_button:
+    if clear_history:
+        st.write("Cleared previous chat history")
+    
+    response = get_data(query)
+    if len(response)>0: 
+        response  = str(response.partition("Answer: ")[-1])
+    else: response = "No results"
+    
+    # write results
+    st.write (response)
+
+

pages/Intelligent Chatbot.py

@@ -0,0 +1,41 @@
+from langchain_community.llms import HuggingFaceEndpoint
+import streamlit as st, Utilities as ut
+from langchain import hub
+from langchain.agents import AgentExecutor, create_react_agent, load_tools
+from langchain_community.chat_models.huggingface import ChatHuggingFace
+#from langchain_openai import OpenAI
+
+from langchain_community.callbacks.streamlit import (
+    StreamlitCallbackHandler,
+)
+
+st_callback = StreamlitCallbackHandler(st.container())
+
+initdict={}
+initdict = ut.get_tokens()
+hf_token = initdict["hf_token"]
+reactstyle_prompt = initdict["reactstyle_prompt"]
+serpapi_api_key = initdict["serpapi_api_key"]
+llm_repoid = initdict["llm_repoid"]
+
+llm = HuggingFaceEndpoint(repo_id=llm_repoid,huggingfacehub_api_token=hf_token,temperature=0.9,verbose=True)
+
+tools = load_tools(["serpapi"],llm=llm,serpapi_api_key=serpapi_api_key)   
+prompt = hub.pull(reactstyle_prompt)
+agent = create_react_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True,handle_parsing_errors=True)
+
+chat_model = ChatHuggingFace(llm=llm)
+chat_model_with_stop = chat_model.bind(stop=["\nObservation"])
+
+st.title("PatentGuru - Intelligent Chatbot")
+
+if prompt := st.chat_input():
+    st.chat_message("user").write(prompt)
+    with st.chat_message("assistant"):
+        st_callback = StreamlitCallbackHandler(st.container())
+        
+        response = agent_executor.invoke(
+            {"input": prompt}, {"callbacks": [st_callback], "handle_parsing_errors":True}
+        )
+        st.write(response["output"])

pages/Patent_Ingestion.py

@@ -0,0 +1,84 @@
+# import required libraries
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.llms import HuggingFaceHub
+#from langchain.vectorstores import Chroma
+from langchain_community.vectorstores import Chroma
+import tensorflow_datasets as tfds
+from sentence_transformers import SentenceTransformer
+from datasets import load_dataset
+from transformers import BartForConditionalGeneration, BartTokenizer
+import textwrap
+import chromadb
+import streamlit as st
+import sys,yaml
+import uuid
+import Utilities as ut
+
+
+def text_summarizer(text):
+    initdict = ut.get_tokens()
+    BART_Model_Name = initdict["BART_model"]
+    #model_name = "facebook/bart-large-cnn"
+    model = BartForConditionalGeneration.from_pretrained(BART_Model_Name)
+    tokenizer = BartTokenizer.from_pretrained(BART_Model_Name)
+
+    inputs = tokenizer.encode("summarize: " + text, return_tensors="pt", max_length=1024, truncation=True)
+    summary_ids = model.generate(inputs, max_length=150, min_length=50, length_penalty=2.0, num_beams=4, early_stopping=True)
+
+    summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+    formatted_summary = "\n".join(textwrap.wrap(summary, width=80))
+    
+    return formatted_summary
+
+def load_patentBIGdata():
+    
+    initdict={}
+    initdict = ut.get_tokens()
+    
+    embedding_model_id = initdict["embedding_model"]
+    chromadbpath = initdict["dataset_chroma_db"]
+    chromadbcollname = initdict["dataset_chroma_db_collection_name"]
+       
+    embedding_model = SentenceTransformer(embedding_model_id)
+    
+    chroma_client = chromadb.PersistentClient(path= chromadbpath)
+
+    collection = chroma_client.get_or_create_collection(name=chromadbcollname)
+
+    
+    # Load the Big patent dataset
+    ds = load_dataset("big_patent", "a", split="validation[:1%]",trust_remote_code=True)
+
+    for record in ds.take(10):
+        abstract, desc = record ["abstract"], record["description"]
+        # Summarize to 150 words
+        abstract = text_summarizer(abstract)
+        textembeddings = embedding_model.encode(abstract).tolist()
+        
+        genguid=str(uuid.uuid4())
+        #take 8 characters
+        uniqueid = genguid[:8]
+        # Now we will store the expert explanation field of first 10 questions from dataset into collection. 
+        collection.add(
+            documents=[
+                abstract
+            ],
+            embeddings=[textembeddings],
+            ids=[uniqueid]
+        )
+        #print(abstract)
+    
+st.title("Patent Ingestion - BIG Patent")
+
+# Main chat form
+with st.form("chat_form"):
+   
+    submit_button = st.form_submit_button("Upload BIG Patent data...")    
+
+if submit_button:
+    load_patentBIGdata()
+    response = "BIG Patent dataset was successfully loaded"
+
+    st.write (response)
+    
+    

pages/Patent_Search.py

@@ -0,0 +1,109 @@
+# import required libraries
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.llms import HuggingFaceHub
+from langchain_community.vectorstores import Chroma
+from sentence_transformers import SentenceTransformer
+from langchain_core.prompts import ChatPromptTemplate
+from langchain import PromptTemplate
+
+import streamlit as st
+import sys,yaml
+import chromadb
+import Utilities as ut
+
+hf_token=""
+chromadbpath=""
+chromadbcollname=""
+embedding_model_id=""
+llm_repo_id=""
+#embeddings=None
+#chroma_client=None
+
+
+def filterdistance(distcoll):
+    myemptydict={}
+    if len(distcoll) < 0:myemptydict
+    for distances in distcoll['distances']:
+        for distance in distances:
+            if distance<50: return distcoll
+            else: return myemptydict
+           
+def get_collections(query):
+    #myemptydict={}
+    result=""
+    initdict={}
+    initdict = ut.get_tokens()
+    hf_token = initdict["hf_token"]
+    embedding_model_id = initdict["embedding_model"]
+    chromadbpath = initdict["dataset_chroma_db"]
+    chromadbcollname = initdict["dataset_chroma_db_collection_name"]
+    llm_repo_id = initdict["llm_repoid"]
+    
+    embedding_model = SentenceTransformer(embedding_model_id)
+    #print(chromadbpath)
+    #print(chromadbcollname)
+    chroma_client = chromadb.PersistentClient(path = chromadbpath)
+    collection = chroma_client.get_collection(name = chromadbcollname)
+ 
+    #collection = chroma_client.get_or_create_collection(name=chromadbcollname)
+    query_vector = embedding_model.encode(query).tolist()
+    output = collection.query(
+        query_embeddings=[query_vector],
+        n_results=1,
+        #where={"distances": "is_less_than_1"},
+        include=['documents','distances'],
+        
+        )
+    #Filter for distances
+    output = filterdistance(output)
+    
+    if len(output)>0: 
+        template = """
+        <s>[INST] <<SYS>>
+        Act as a patent assistant who is helping summarize and neatly format the results for better readability. Ensure the output is gramatically correct and easily understandable 
+        <</SYS>>
+
+        {text} [/INST]
+        """
+        #Build the prompt template
+        prompt = PromptTemplate(
+            input_variables=["text"],
+            template=template,
+        )
+        text = output
+        
+        llm = HuggingFaceHub(huggingfacehub_api_token=hf_token, 
+                        repo_id=llm_repo_id, model_kwargs={"temperature":0.2, "max_new_tokens":50})
+
+        result = llm.invoke(prompt.format(text=text))
+        print (result)
+    return result
+  
+    return output
+    # extract and apply distance condition
+
+st.title("BIG Patent Search")
+
+# Main chat form
+with st.form("chat_form"):
+    query = st.text_input("Enter the abstract search for similar patents: ")
+    #LLM_Summary = st.checkbox('Summarize results with LLM') 
+    submit_button = st.form_submit_button("Send")    
+
+if submit_button:
+    st.write("Fetching results..\n")
+    results =  get_collections(query)
+    
+    if len(results)>0: 
+        #docids = results["documents"]
+        response = "There are existing patents related to -    "
+        substring = results.partition("[/ASSistant]")[-1]
+        if len(substring)>0:
+            response  = response + str(substring)
+        else: 
+            response = response + results.partition("[/INST]")[-1]
+            
+    else: response = "No results"
+    
+    st.write (response)
+    

pages/Prompt_Engineer.py

@@ -0,0 +1,85 @@
+
+from langchain.callbacks.manager import CallbackManager
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+from langchain import PromptTemplate
+from langchain_community.llms import LlamaCpp
+#from langchain.chains import RetrievalQA
+#from langchain_community.embeddings import SentenceTransformerEmbeddings
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.callbacks.base import BaseCallbackHandler
+
+#from langchain.schema import HumanMessage
+
+import os
+import json,streamlit as st
+from pathlib import Path
+
+class StreamHandler(BaseCallbackHandler):
+    def __init__(self, container, initial_text=""):
+        self.container = container
+        self.text=initial_text
+    def on_llm_new_token(self, token: str, **kwargs) -> None:
+        # "/" is a marker to show difference 
+        # you don't need it 
+        #self.text+=token+"/" 
+        self.text+=token
+        self.container.markdown(self.text) 
+
+st.title("Prompt Engineer")
+
+# Main chat form
+with st.form("chat_form"):
+    query = st.text_input("Enter the topic you want to generate prompt for?: ")
+    #LLM_Summary = st.checkbox('Summarize results with LLM') 
+    submit_button = st.form_submit_button("Send")    
+
+     
+    template = """
+    <s>[INST] <<SYS>>
+    Act as a patent advisor by providing subject matter expertise on any topic. Provide detailed and elaborate answers
+    <</SYS>>
+
+    {text} [/INST]
+    """
+    response=""
+    prompt = PromptTemplate(
+        input_variables=["text"],
+        template=template,
+    )
+    text = "Help me create a good prompt for the following: Information that is needed to file a US patent application for " + query
+    #print(prompt.format(text=query))
+
+    # Callbacks support token-wise streaming
+    callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
+
+    #model_path = "C:\Rajesh\AI-ML-Training\LLM\llama-2-7b.Q4_K_M.gguf"\
+    model_path = "C:\Rajesh\AI-ML-Training\LLM\zephyr-7b-beta.Q5_K_S.gguf"
+    chat_box=st.empty() 
+    stream_handler = StreamHandler(chat_box)
+    
+    llm = LlamaCpp(
+        model_path=model_path,
+        temperature=0.8,
+        max_tokens=500,
+        top_p=1,
+        #streaming=True,
+        #callback_manager=callback_manager,
+        callback_manager = [stream_handler],
+        verbose=True,  # Verbose is required to pass to the callback manager
+    )
+
+if submit_button:
+    #st.write("Fetching results..\n")
+    output = llm.invoke(prompt.format(text=text))
+    #response = response+output
+    #st.write(response)
+    #response = output([HumanMessage(content=query)])    
+    #llm_response = output.content
+    #st.markdown(output)
+
+
+
+
+    
+