Upload herbal_expert.py

herbal_expert.py

@@ -22,104 +22,6 @@ Entrez.email = "[email protected]"
 nltk.download('wordnet')
 
 
-class CustomLLM(LLM):
-    n: int
-
-    @property
-    def _llm_type(self) -> str:
-        return "custom"
-
-    def _call(
-            self,
-            prompt: str,
-            stop: Optional[List[str]] = None,
-            run_manager: Optional[CallbackManagerForLLMRun] = None,
-            **kwargs: Any,
-    ) -> str:
-        """
-        The _call function is the function that will be called by the user.
-        It should take in a prompt and return a response.
-
-        :param self: Represent the instance of the class
-        :param prompt: str: Pass the prompt to the model
-        :param stop: Optional[List[str]]: Define the stop words
-        :param run_manager: Optional[CallbackManagerForLLMRun]: Pass the run manager to the call function
-        :param **kwargs: Any: Pass in any additional parameters that may be needed for the function
-        :param : Pass the prompt to the model
-        :return: A string that is the response of gpt-3 to the prompt
-        """
-        data = {
-            "messages": [
-                {
-                    "role": "user",
-                    "content": prompt
-                }
-            ],
-            "stop": ["### Instruction:"], "temperature": 0, "max_tokens": 700, "stream": False
-        }
-
-        response = requests.post(ngrok_url + "v1/chat/completions",
-                                 headers={"Content-Type": "application/json"}, json=data)
-        return json.loads(response.text)['choices'][0]['message']['content']
-
-
-class CustomPromptTemplate(StringPromptTemplate):
-    template: str
-
-    def format(self, **kwargs) -> str:
-        return self.template.format(**kwargs)
-
-
-class CustomOutputParser(AgentOutputParser):
-    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
-        return AgentFinish(return_values={"output": llm_output}, log=llm_output)
-
-
-bare_output_parser = CustomOutputParser()
-question_decompose_prompt = """### Instruction: Identify and list the keywords that capture the essence of the 
-question. List them as a string separated by commas. Focus on the question. The first word should be the most 
-important keyword and the last word should be the least important keyword.
-
-Chat History: {history} 
-Question: {input}
-
-YOUR RESPONSE SHOULD BE A STRING OF COMMA SEPARATED KEYWORDS:
-### Response: Keywords: """
-
-prompt_with_history = CustomPromptTemplate(
-    template=question_decompose_prompt,
-    tools=[],
-    input_variables=["input", "history"]
-)
-
-
-def get_agent_executor():
-    """
-    The get_agent_executor function is a factory function that returns an AgentExecutor object.
-    The AgentExecutor object is the main interface for interacting with the agent.
-    agent.run('query') is the main method for interacting with the agent.
-
-    :return: An AgentExecutor object
-    """
-
-    llm = CustomLLM(n=10)
-    question_decompose_chain = LLMChain(llm=llm, prompt=prompt_with_history)
-    question_decompose_agent = LLMSingleActionAgent(
-        llm_chain=question_decompose_chain,
-        output_parser=bare_output_parser,
-        stop=["\nObservation:"],
-        allowed_tools=[]
-    )
-    memory = ConversationBufferWindowMemory(k=10)
-
-    return AgentExecutor.from_agent_and_tools(
-        agent=question_decompose_agent,
-        tools=[],
-        verbose=True,
-        memory=memory
-    )
-
-
 def get_num_citations(pmid: str):
     """
     The get_num_citations function takes a PubMed ID (pmid) as input and returns the number of citations for that
@@ -225,64 +127,54 @@ def format_prompt_and_query(prompt, **kwargs):
 
 
 class HerbalExpert:
-    def __init__(self, qd_chain):
-        self.qd_chain = qd_chain
+    def __init__(self):
         self.wnl = WordNetLemmatizer()
         self.default_questions = [
             "How is chamomile traditionally used in herbal medicine?",
-            "What are the potential side effects or interactions of consuming echinacea?",
+            "What are the potential side effects or interactions of consuming echinacea alongside finasteride?",
             "Can you explain the different methods of consuming lavender for health benefits?",
             "Which herbs are commonly known for their anti-inflammatory properties?",
             "I'm experiencing consistent stress and anxiety. What herbs or supplements could help alleviate these symptoms?",
             "Are there any natural herbs that could support better sleep?",
             "What cannabis or hemp products would you recommend for chronic pain relief?",
             "I'm looking to boost my immune system. Are there any specific herbs or supplements that could help?",
-            "Which herbs or supplements are recommended for enhancing cognitive functions and memory?"
+            "Which herbs or supplements are recommended for enhancing cognitive functions and memory?",
+            "What natural (herbal) medicinal molecule is the best alternative for pharmaceutical drugs, e.g., opiates?"
         ]
-        # og = Original, qa = Question Asking, ri = Response Improvement
+        # qd = Question Decompose, og = Original, qa = Question Asking, ri = Response Improvement
         self.prompts = {
-            "og_answer_prompt": """### Instruction: Answer the following question to the best of your ability. 
-                Question: {question} 
-                ### Response: Answer: """,
-
-            "ans_decompose_prompt": """### Instruction: Given the following text, identify the 2 most important 
-                keywords that capture the essence of the text. If there's a list of products, choose the top 2 products. 
-                Your response should be a list of only 2 keywords separated by commas. 
-                Text: {original_answer} 
-                ### Response: Keywords: """,
-
-            "qa_prompt": """### Instruction: Answer the following question using the given context ONLY if the 
-                context is relevant to the question. If the context doesn't help answer the question respond with "I don't know". 
-                Question: {question} 
-                Context: {context} 
-                ### Response: Answer: """,
-
-            "ri_prompt": """### Instruction: You are an caring, intelligent question answering agent. Craft a 
-                response that is more informative and intelligent than the original answer and imparts knowledge from 
-                both the old answer and from the context ONLY if it helps answer the question. 
-                Question: {question} 
-                Old Answer: {answer} 
-                Context: {answer2} 
-                ### Response: Improved Answer: """
+            "qd_prompt": """### Instruction: Identify and list the keywords that capture the essence of the question. List them as a string separated by commas. Focus on the question. Order the keyword by importance. The first keyword should be the most important keyword in the question and the last keyword should be the least important keyword.
+            Question: {input}
+
+            YOUR RESPONSE SHOULD BE A STRING OF COMMA SEPARATED KEYWORDS:
+            ### Response: Keywords: """,
+
+            "og_answer_prompt": """### Instruction: Answer the following question to the best of your ability. Question: {question} 
+            ### Response: Answer: """,
+
+            "ans_decompose_prompt": """### Instruction: Given the following text, identify the 2 most important keywords that capture the essence of the text. If there's a list of products, choose the top 2 products. Your response should be a list of only 2 keywords separated by commas. 
+            Text: {original_answer} 
+            ### Response: Keywords: """,
+
+            "qa_prompt": """### Instruction: Answer the following question using the given context ONLY if the context is relevant to the question. If the context doesn't help answer the question, ONLY respond with "I don't know". 
+
+            Question: {question} 
+            Context: {context} 
+            ### Response: Answer: """,
+
+            "ri_prompt": """### Instruction: You are an caring, intelligent question answering agent. Craft a response that is more safe, informative and intelligent than the original answer and imparts knowledge from both the old answer and from the context ONLY if it helps answer the question. 
+
+            Question: {question} 
+            Old Answer: {answer} 
+            Context: {answer2} 
+            ### Response: Improved Answer: """
         }
 
     def process_query_words(self, question_words: str, answer_words: str):
         # don't need to be searching for these in pubmed. Should we include: 'supplements', 'supplement'
-        """
-        The process_query_words function takes in a string of words and returns a list of filtered lemmatized words.
-        The function first splits the input strings into lists, then removes any duplicate entries from the list. It
-        then iterates through each word in the list and strips it of whitespace before passing it to
-        WordNetLemmatizer().lemmatize() to return its lemma (base form). The function also removes any vague words
-        that are not useful for searching PubMed.
-
-        :param self: Represent the instance of the class
-        :param question_words: str: Get the question words from the user
-        :param answer_words: str: Add the answer words to the list of words that will be searched for in pubmed
-        :return: A list of words that are not vague
-        """
-
         vague_words = ['recommendation', 'recommendations', 'products', 'product']
-        words = question_words.lower().split(",") + answer_words.lower().split(",")
+        words = question_words.lower().split(",")[:4] + answer_words.lower().split(
+            ",")  # limit question words to 4 (since the number is unbounded)
 
         final_list = []
         for word in words:
@@ -293,22 +185,10 @@ class HerbalExpert:
         return list(set(final_list))
 
     def convert_question_into_words(self, question: str):
-        """
-        The convert_question_into_words function takes a question and returns the words that are in the question.
-        The function first decomposes the original answer into its component parts, then it decomposes
-        each of those components into their own component parts. It then uses these decomposed answers to
-        find all the words that are in both questions and answers.
-
-        :param self: Make the function a method of the class
-        :param question: str: Pass in the question that is being asked
-        :return: A tuple of two elements
-        :doc-author: Trelent
-        """
-
         original_answer = format_prompt_and_query(self.prompts["og_answer_prompt"], question=question)
         print("Original Answer: ", original_answer)
 
-        question_decompose = self.qd_chain.run(question)
+        question_decompose = format_prompt_and_query(self.prompts["qd_prompt"], input=question)
         print("Question Decompose: ", question_decompose)
 
         original_answer_decompose = format_prompt_and_query(self.prompts["ans_decompose_prompt"],
@@ -319,19 +199,6 @@ class HerbalExpert:
         return words, original_answer
 
     def query_expert(self, question: str = None):
-        """
-        The query_expert function takes a question as input and returns the expert's response to that question. The
-        function first converts the question into keywords, then uses those keywords to search PubMed for relevant
-        articles. If no articles are found, it returns the original response from the expert (i.e., without context).
-        If at least one article is found, it asks two follow-up questions: 1) "What do you think of this answer
-        in light of these new findings?" and 2) "How would you improve your answer based on these new
-        findings?". It then returns both responses.
-
-        :param self: Represent the instance of the class
-        :param question: str: Pass in the question that is to be asked
-        :return: A dictionary with the question, response and run info
-        """
-
         question = random.choice(self.default_questions) if question is None else question
         print("Question: ", question)
 
@@ -339,7 +206,7 @@ class HerbalExpert:
         print("Keywords: ", keywords)
 
         context = fetch_pubmed_articles(" AND ".join(keywords), max_search=5)
-        print(context)
+        print("Context: ", context)
 
         if len(context) == 0:
             return {
@@ -349,9 +216,19 @@ class HerbalExpert:
             }
 
         contextual_response = format_prompt_and_query(self.prompts["qa_prompt"], question=question, context=context)
+        # if "I don't know" in contextual_response:
+        #     return {
+        #         "question": question,
+        #         "response": original_response,
+        #         "info": "Irrelevant context found"
+        #     }
+
+        print()
+        print("Contextual Response: ", contextual_response)
         improved_response = format_prompt_and_query(self.prompts["ri_prompt"], question=question,
                                                     answer=original_response, answer2=contextual_response)
-
+        print()
+        print("Improved Response: ", improved_response)
         return {
             "question": question,
             "response": improved_response,
@@ -359,11 +236,10 @@ class HerbalExpert:
         }
 
 
-herbal_expert = HerbalExpert(get_agent_executor())
+herbal_expert = HerbalExpert()
 
 if __name__ == '__main__':
-    herbal_expert = HerbalExpert(get_agent_executor())
-    answer = herbal_expert.query_expert(
-        "I'm experiencing consistent stress and anxiety. What herbs or supplements could help alleviate these symptoms?")
+    herbal_expert = HerbalExpert()
+    answer = herbal_expert.query_expert()
     print(answer['response'])
-    # return to api? who knows
+    # # return to api? who knows