update deeplearning method whose test accuracy is 0.4180

app2.py

@@ -0,0 +1,76 @@
+# app.py
+import streamlit as st
+from function import Head_Agent
+
+def init_chatbot():
+
+    with open('open_ai_key.txt', 'r', encoding='utf-8') as file:
+        openai_key = file.readline().strip()
+    with open('pinecone_api.txt', 'r', encoding='utf-8') as file:
+        pinecone_key = file.readline().strip()
+
+    pinecone_index_name = 'machine-learning-index'
+
+    return Head_Agent(openai_key, pinecone_key, pinecone_index_name)
+
+
+# ------------- Streamlit -------------------
+st.title("My Streamlit Chatbot with Greetings")
+
+if "chatbot" not in st.session_state:
+    st.session_state["chatbot"] = init_chatbot()
+
+chatbot = st.session_state["chatbot"]
+
+user_query = st.text_input("Please enter your question:")
+
+greeting_keywords = {
+    "hi", "hello", "hey", "how are you", "how r u", "yo", "good morning", "good evening", "good afternoon"
+}
+
+if st.button("Sent"):
+    if not user_query.strip():
+        st.warning("Please enter valid content.")
+    else:
+        # ---
+        normalized_input = user_query.lower().strip()
+        if normalized_input in greeting_keywords:
+            greet_response = "Hello there! How can I assist you today?"
+            st.write("Robot: ", greet_response)
+
+            chatbot.conv_history.append(f"User: {user_query}")
+            chatbot.conv_history.append(f"Robot: {greet_response}")
+
+        else:
+            if chatbot.obnoxious_agent.check_query(user_query):
+                st.write("Robot: Your question is inappropriate, please try another one.")
+
+            else:
+                docs = chatbot.query_agent.query_vector_store(user_query)
+                matches = docs["matches"]
+
+                response = chatbot.answering_agent.generate_response(
+                    user_query,
+                    matches,
+                    chatbot.conv_history
+                )
+
+                chatbot.conv_history.append(f"User: {user_query}")
+                chatbot.conv_history.append(f"Robot: {response}")
+
+                # 3.
+                conversation_context = (
+                    f"User query: {user_query}\n"
+                    f"Retrieve document summaries: {response}"
+                )
+                relevance = chatbot.relevant_agent.get_relevance(conversation_context)
+
+                if relevance.strip().lower() == "no":
+                    st.write("【Robot: generated answer, but not sure if it's relevant:】", response)
+                else:
+                    st.write("Robot:", response)
+
+st.write("---")
+st.subheader("Conversation History")
+for msg in chatbot.conv_history:
+    st.write(msg)

design diagram.md

@@ -0,0 +1,15 @@
+```mermaid
+flowchart TB
+    A["User enters query in Streamlit UI"] --> B{Is it a Greeting?}
+    B -- Yes --> C["Display \"Hello there!\""]
+    B -- No --> D{Check with Obnoxious_Agent}
+    D -- Yes --> E["Display \"Question is inappropriate\""]
+    D -- No --> F["Query_Agent retrieves docs from Pinecone"]
+    F --> G["Answering_Agent uses GPT to generate answer"]
+    G --> H{"Relevant_Documents_Agent checks doc relevance"}
+    H -- Yes --> I["Final response displayed to user"]
+    H -- No --> M["Final response with Unrelated tips displayed to user"]
+
+```
+
+#### 

function.py

@@ -0,0 +1,125 @@
+# function.py
+
+import openai
+from pinecone import Pinecone, ServerlessSpec
+from langchain.embeddings import OpenAIEmbeddings
+
+
+class Obnoxious_Agent:
+
+    def __init__(self, client) -> None:
+        self.client = client
+        self.prompt = "Determine if the following query is uncomfortable (returns only Yes or No):"
+
+    def set_prompt(self, prompt):
+        self.prompt = prompt
+
+    def extract_action(self, response_text) -> bool:
+
+        return "yes" in response_text.lower()
+
+    def check_query(self, query):
+        full_prompt = f"{self.prompt}\nQuery: {query}"
+        response = self.client.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "user", "content": full_prompt}],
+            max_tokens=10
+        )
+        content = response["choices"][0]["message"]["content"]
+        return self.extract_action(content)
+
+
+class Query_Agent:
+
+    def __init__(self, pinecone_index, openai_client, embeddings) -> None:
+        self.pinecone_index = pinecone_index
+        self.client = openai_client
+        self.embeddings = embeddings
+
+    def query_vector_store(self, query, k=5):
+
+        query_vector = self.embeddings.embed_query(query)
+
+        result = self.pinecone_index.query(
+            vector=query_vector,
+            top_k=k,
+            include_metadata=True
+        )
+        return result
+
+
+class Answering_Agent:
+
+    def __init__(self, openai_client) -> None:
+        self.client = openai_client
+
+    def generate_response(self, query, docs, conv_history, k=5):
+
+        docs_texts = []
+        for doc in docs:
+            metadata = doc.get("metadata", {})
+            text = metadata.get("text", "")
+            docs_texts.append(text)
+
+        docs_text = "\n".join(docs_texts)
+        history_text = "\n".join(conv_history)
+
+        full_prompt = (
+            "Answer a user query based on the following related documents and dialog history.\n"
+            f"Related documents:\n{docs_text}\n"
+            f"Conversation history:\n{history_text}\n"
+            f"User query: {query}\nAnswer:"
+        )
+        response = self.client.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "user", "content": full_prompt}],
+            max_tokens=150
+        )
+        content = response["choices"][0]["message"]["content"]
+        return content.strip()
+
+
+class Relevant_Documents_Agent:
+
+    def __init__(self, openai_client) -> None:
+        self.client = openai_client
+
+    def get_relevance(self, conversation) -> str:
+        prompt = (
+            "You are a highly skilled assistant. Please determine if the returned documents "
+            "are directly relevant to the user's query. Respond with 'Yes' if you believe the "
+            "documents are relevant, or 'No' if you believe they are not.\n\n"
+            "Context:\n"
+            f"{conversation}\n\n"
+            "Please respond with 'Yes' or 'No' only."
+        )
+        response = self.client.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=10
+        )
+        content = response["choices"][0]["message"]["content"]
+        return content.strip()
+
+
+class Head_Agent:
+
+    def __init__(self, openai_key, pinecone_key, pinecone_index_name) -> None:
+
+        openai.api_key = openai_key
+
+
+        pc = Pinecone(api_key=pinecone_key)
+
+        self.pinecone_index = pc.Index(pinecone_index_name)
+
+        self.embeddings = OpenAIEmbeddings(openai_api_key=openai_key)
+
+        self.openai_client = openai
+
+        self.obnoxious_agent = Obnoxious_Agent(self.openai_client)
+        self.query_agent = Query_Agent(self.pinecone_index, self.openai_client, self.embeddings)
+        self.answering_agent = Answering_Agent(self.openai_client)
+        self.relevant_agent = Relevant_Documents_Agent(self.openai_client)
+
+        self.conv_history = []

open_ai_key.txt

@@ -0,0 +1 @@
+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

pinecone_api.txt

@@ -0,0 +1 @@
+pcsk_2fYVS5_RLwpM61jCGwKQZugPhauxdgmsPpU3V3oxRP16oVGgEaEsbeUoEDH8BRXbrMxXv1