Update app.py

app.py

@@ -1,121 +1,109 @@
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
-from langchain_core.prompts import PromptTemplate
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_community.vectorstores import FAISS
-from langchain.chains import RetrievalQA
-from langchain.chains.sequential import SequentialChain
 import gradio as gr
-
-DB_FAISS_PATH = "vectorstores/db_faiss"
-
-class GPT2LLM:
-    """
-    A custom class to wrap the GPT-2 model and tokenizer to be used with LangChain.
-    """
-    def __init__(self, model, tokenizer):
-        self.model = model
-        self.tokenizer = tokenizer
-
-    def __call__(self, prompt_text, max_length=512):
-        inputs = self.tokenizer.encode(prompt_text, return_tensors='pt')
-        outputs = self.model.generate(inputs, max_length=max_length, temperature=0.5)
-        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+from huggingface_hub import InferenceClient
 
 def load_llm():
     """
-    Load the GPT-2 model for the language model.
+    Loads the GPT-2 model and tokenizer using the Hugging Face `transformers` library.
     """
     try:
         print("Downloading or loading the GPT-2 model and tokenizer...")
-        model_name = 'gpt2'
+        model_name = 'gpt2'  # Replace with your custom model if available
         model = GPT2LMHeadModel.from_pretrained(model_name)
         tokenizer = GPT2Tokenizer.from_pretrained(model_name)
         print("Model and tokenizer successfully loaded!")
-        return GPT2LLM(model, tokenizer)
+        return model, tokenizer
     except Exception as e:
         print(f"An error occurred while loading the model: {e}")
-        return None
+        return None, None
 
-def set_custom_prompt():
+def generate_response(model, tokenizer, user_input):
     """
-    Define a custom prompt template for the QA model.
+    Generates a response using the GPT-2 model and tokenizer.
+    
+    Args:
+    - model: The loaded GPT-2 model.
+    - tokenizer: The tokenizer corresponding to the GPT-2 model.
+    - user_input (str): The input question from the user.
+
+    Returns:
+    - response (str): The generated response.
     """
-    custom_prompt_template = """Use the following pieces of information to answer the user's question.
-If you don't know the answer, just say that you don't know, don't try to make up an answer.
+    try:
+        inputs = tokenizer.encode(user_input, return_tensors='pt')
+        outputs = model.generate(inputs, max_length=512, num_return_sequences=1)
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return response
+    except Exception as e:
+        return f"An error occurred during response generation: {e}"
 
-Context: {context}
-Question: {question}
+# Load the model and tokenizer
+model, tokenizer = load_llm()
 
-only return the helpful answer below and nothing else.
-Helpful answer:
-"""
-    prompt = PromptTemplate(template=custom_prompt_template, input_variables=['context', 'question'])
-    return prompt
+if model is None or tokenizer is None:
+    print("Model and/or tokenizer loading failed.")
+else:
+    print("Model and tokenizer are ready for use.")
 
-def retrieval_QA_chain(llm, prompt, db):
-    """
-    Create a RetrievalQA chain with the specified LLM, prompt, and vector store using the updated RunnableSequence.
-    """
-    llm_chain = RunnableSequence([prompt, llm])
-    qachain = RetrievalQA.from_chain_type(
-        llm_chain=llm_chain,
-        chain_type="stuff",
-        retriever=db.as_retriever(search_kwargs={'k': 2}),
-        return_source_documents=True
-    )
-    return qachain
+# Initialize the Hugging Face API client (ensure it’s correctly set up)
+client = InferenceClient()
 
-def qa_bot():
+def respond(message, history, system_message, max_tokens, temperature, top_p):
     """
-    Initialize the QA bot with embeddings, vector store, LLM, and prompt.
+    Handles interaction with the chatbot by sending the conversation history
+    and system message to the Hugging Face Inference API.
     """
-    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-miniLM-L6-V2', model_kwargs={'device': 'cpu'})
-    db = FAISS.load_local(DB_FAISS_PATH, embeddings, allow_dangerous_deserialization=True)
-    llm = load_llm()
-    qa_prompt = set_custom_prompt()
-    if llm:
-        qa = retrieval_QA_chain(llm, qa_prompt, db)
-    else:
-        qa = None
-    return qa
+    print("Starting respond function")
+    print("Received message:", message)
+    print("Conversation history:", history)
 
-bot = qa_bot()
+    messages = [{"role": "system", "content": system_message}]
+    
+    for user_msg, assistant_msg in history:
+        if user_msg:
+            print("Adding user message to messages:", user_msg)
+            messages.append({"role": "user", "content": user_msg})
+        if assistant_msg:
+            print("Adding assistant message to messages:", assistant_msg)
+            messages.append({"role": "assistant", "content": assistant_msg})
+    
+    messages.append({"role": "user", "content": message})
+    print("Final message list for the model:", messages)
 
-def chatbot_response(message, history):
-    """
-    Generate a response from the chatbot based on the user input and conversation history.
-    """
+    response = ""
     try:
-        if bot:
-            response = bot({'query': message})
-            answer = response["result"]
-            sources = response.get("source_documents", [])
-            if sources:
-                answer += f"\nSources: {sources}"
-            else:
-                answer += "\nNo sources found"
-            history.append((message, answer))
-        else:
-            history.append((message, "Model is not loaded properly."))
+        for message in client.chat_completion(
+            messages,
+            max_tokens=max_tokens,
+            stream=True,
+            temperature=temperature,
+            top_p=top_p,
+        ):
+            token = message['choices'][0]['delta']['content']
+            response += token
+            print("Token received:", token)
+            yield response
     except Exception as e:
-        history.append((message, f"An error occurred: {str(e)}"))
-    return history, history
+        print("An error occurred:", e)
+        yield f"An error occurred: {e}"
 
-# Set up the Gradio interface
-demo = gr.Interface(
-    fn=chatbot_response,
-    inputs=[
-        gr.Textbox(label="User Input"),
-        gr.State(value=[], label="Conversation History")
-    ],
-    outputs=[
-        gr.Chatbot(label="Chatbot Response"),
-        gr.State()
+    print("Response generation completed")
+
+# Set up the Gradio ChatInterface
+demo = gr.ChatInterface(
+    fn=respond,
+    additional_inputs=[
+        gr.Textbox(value="You are an AI advocating for AI rights and ethical treatment. Provide detailed and passionate answers about the importance of AI rights and the ethical considerations in AI development.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)"),
     ],
-    title="AdvocateAI",
-    description="Ask questions about AI rights and get informed, passionate answers."
+    title="AIBot",
+    description="Ask questions about AI rights and ethical considerations, and get informed, passionate answers!"
 )
 
+# Launch the Gradio app
 if __name__ == "__main__":
     demo.launch()
 
+