Update app.py

app.py

@@ -1,25 +1,28 @@
+
 import gradio as gr
+import nltk
+from nltk.tokenize import sent_tokenize
+from transformers import AutoTokenizer, AutoModel
+import torch
 import faiss
 import numpy as np
 import openai
-from sentence_transformers import SentenceTransformer
-from nltk.tokenize import sent_tokenize
-import nltk
 
-# Download the required NLTK data
+# Set up OpenAI API key
+openai.api_key = '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'
+# Download NLTK data
 nltk.download('punkt')
-nltk.download('punkt_tab')
+nltk.download('punkt-tab')
 
-# Paths to your files
-faiss_path = "manual_chunked_faiss_index_500.bin"
-manual_path = "ubuntu_manual.txt"
+# Load the tokenizer and model
+tokenizer = AutoTokenizer.from_pretrained("microsoft/MiniLM-L12-H384-uncased")
+model = AutoModel.from_pretrained("microsoft/MiniLM-L12-H384-uncased")
+
+manual_path="ubuntu_manual.txt"
 
 # Load the Ubuntu manual from a .txt file
-try:
-    with open(manual_path, "r", encoding="utf-8") as file:
-        full_text = file.read()
-except FileNotFoundError:
-    raise FileNotFoundError(f"The file {manual_path} was not found.")
+with open(manual_path, "r", encoding="utf-8") as file:
+    full_text = file.read()
 
 # Function to chunk the text into smaller pieces
 def chunk_text(text, chunk_size=500):
@@ -42,99 +45,84 @@ def chunk_text(text, chunk_size=500):
 # Apply chunking to the entire text
 manual_chunks = chunk_text(full_text, chunk_size=500)
 
-# Load your FAISS index
-try:
-    index = faiss.read_index(faiss_path)
-except Exception as e:
-    raise RuntimeError(f"Failed to load FAISS index: {e}")
+# Function to generate embeddings for each chunk
+def embed_text(texts):
+    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt", max_length=512)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    embeddings = outputs.last_hidden_state[:, 0, :].cpu().numpy()  # CLS token representation
+    return embeddings
 
-# Load the tokenizer and model for embeddings
-from transformers import AutoTokenizer, AutoModel
-tokenizer = AutoTokenizer.from_pretrained("microsoft/MiniLM-L12-H384-uncased")
-model = AutoModel.from_pretrained("microsoft/MiniLM-L12-H384-uncased")
+# Generate embeddings for the chunks
+chunk_embeddings = embed_text(manual_chunks)
 
-embedding_model = SentenceTransformer('microsoft/MiniLM-L12-H384-uncased')
+# Convert embeddings to a numpy array
+chunk_embeddings_np = np.array(chunk_embeddings)
 
-# OpenAI API key
-openai.api_key = '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'
-
-# Function to create embeddings
-def embed_text(text_list):
-    return np.array(embedding_model.encode(text_list), dtype=np.float32)
+# Create a FAISS index and add the embeddings
+dimension = chunk_embeddings_np.shape[1]
+index = faiss.IndexFlatL2(dimension)
+index.add(chunk_embeddings_np)
 
 # Function to retrieve relevant chunks for a user query
 def retrieve_chunks(query, k=5):
     query_embedding = embed_text([query])
+    distances, indices = index.search(query_embedding, k=k)
+    valid_indices = [i for i in indices[0] if i < len(manual_chunks)]
+    relevant_chunks = [manual_chunks[i] for i in valid_indices]
+    return relevant_chunks
+
+# Function to perform RAG: Retrieve chunks and generate a response using GPT-3.5
+def rag_response_gpt3_5(query, k=3, max_tokens=150):
+    relevant_chunks = retrieve_chunks(query, k=k)
+    if not relevant_chunks:
+        return "Sorry, I couldn't find relevant information."
+
+    # Combine the query with a limited number of retrieved chunks
+    augmented_input = query + "\n" + "\n".join(relevant_chunks)
+
+    # Tokenize the augmented input and ensure it fits within model token limits
+    input_ids = tokenizer(augmented_input, return_tensors="pt").input_ids[0]
     
-    try:
-        distances, indices = index.search(query_embedding, k=k)
-        print("Distances:", distances)
-        print("Indices:", indices)
-    except Exception as e:
-        raise RuntimeError(f"FAISS search failed: {e}")
+    if len(input_ids) > 512:
+        input_ids = input_ids[:512]
+        augmented_input = tokenizer.decode(input_ids, skip_special_tokens=True)
+
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": augmented_input}
+        ],
+        max_tokens=max_tokens,
+        temperature=0.7
+    )
+
+    return response.choices[0].message['content'].strip()
+
+# Chat history to maintain conversation context
+history = []
+
+# Define Gradio interface function with chat history
+def chatbot(query, history):
+    response = rag_response_gpt3_5(query)
+    history.append((query, response))
     
-    if len(indices[0]) == 0:
-        return [], distances, indices
+    # Combine all messages into a single string
+    chat_history = ""
+    for user_input, bot_response in history:
+        chat_history += f"User: {user_input}\nBot: {bot_response}\n\n"
+    
+    return chat_history, history
 
-    valid_indices = [i for i in indices[0] if i < len(manual_chunks)]
-    if not valid_indices:
-        return [], distances, indices
-
-    relevant_chunks = [manual_chunks[i] for i in valid_indices]
-    return relevant_chunks, distances, indices
-
-# Function to truncate long inputs
-def truncate_input(text, max_length=16385):
-    tokens = tokenizer.encode(text, truncation=True, max_length=max_length, return_tensors="pt")
-    return tokens
-
-# Function to perform RAG: Retrieve chunks and generate a response
-def rag_response(query, k=5, max_tokens=150):
-    try:
-        relevant_chunks, distances, indices = retrieve_chunks(query, k=k)
-        
-        if not relevant_chunks:
-            return "Sorry, I couldn't find relevant information.", distances, indices
-
-        # Combine the query with retrieved chunks
-        augmented_input = query + "\n\n" + "\n\n".join(relevant_chunks)
-        
-        # Truncate the input if it exceeds token limits
-        input_tokens = tokenizer.encode(augmented_input, return_tensors="pt")
-        if input_tokens.shape[1] > 16385:
-            # Truncate to fit within the model's maximum input length
-            augmented_input = tokenizer.decode(input_tokens[0, :16385])
-
-        # Generate response using OpenAI API
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": augmented_input}
-            ],
-            max_tokens=max_tokens,
-            temperature=0.7
-        )
-        generated_text = response.choices[0].message['content'].strip()
-        return generated_text, distances, indices
-    except Exception as e:
-        return f"An error occurred: {e}", [], []
-
-# Gradio Interface
-
-# Gradio Interface
-def format_output(response, distances, indices):
-    formatted_response = f"Response: {response}\n\nDistances: {distances}\n\nIndices: {indices}"
-    return formatted_response
-
-iface = gr.Interface(
-    fn=rag_response,
-    inputs="text",
-    outputs="text",
-    title="RAG Chatbot with FAISS and GPT-3.5",
-    description="Ask me anything!",
-    live=True
-)
+# Create the Gradio interface
+iface = gr.Interface(fn=chatbot, 
+                     inputs=["text", "state"], 
+                     outputs=["text", "state"], 
+                     title="Ubuntu Manual Chatbot",
+                     description="Ask me anything about the Ubuntu manual.")
 
+# Launch the app
 if __name__ == "__main__":
     iface.launch()
+