testing

app.py

@@ -1,6 +1,6 @@
 import os
 from openai import OpenAI
-from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_huggingface import HuggingFaceEmbeddings
 from datasets import load_dataset, Dataset
 from sklearn.neighbors import NearestNeighbors
 import numpy as np
@@ -34,23 +34,22 @@ if model_provider.lower() == "openai":
     MODEL_NAME = os.environ['OPENAI_MODEL']
     client = OpenAI(
         base_url=os.environ.get("OPENAI_BASE"),
-        api_key=api_key
+        api_key=os.environ.get("OPENAI_API_KEY")
     )
 else:
-    MODEL_NAME = "meta-llama/Llama-3.3-70B-Instruct"
+    MODEL_NAME = "deepseek-ai/deepseek-coder-33b-instruct"
     # Initialize Hugging Face InferenceClient with GPU support
     hf_client = InferenceClient(
         model=MODEL_NAME,
         api_key=os.environ.get("HF_TOKEN"),
-        timeout=120  # Increased timeout for GPU inference
+        timeout=30  # Reduced timeout for faster response
     )
 
 # Load the Hugging Face dataset
 dataset = load_dataset('tosin2013/autogen', streaming=True)
 dataset = Dataset.from_list(list(dataset['train']))
 
-# Check GPU availability and initialize embeddings
-# Use CPU for embeddings since GPU is handled by spaces.GPU decorator
+# Initialize embeddings
 embeddings = HuggingFaceEmbeddings(
     model_name="sentence-transformers/all-MiniLM-L6-v2",
     model_kwargs={"device": "cpu"}
@@ -59,41 +58,57 @@ embeddings = HuggingFaceEmbeddings(
 # Extract texts from the dataset
 texts = dataset['input']
 
-# Create embeddings for the texts
-text_embeddings = embeddings.embed_documents(texts)
-
-# Fit a nearest neighbor model
-nn = NearestNeighbors(n_neighbors=5, metric='cosine')
-nn.fit(np.array(text_embeddings))
+# Create and cache embeddings for the texts
+if not os.path.exists('embeddings.npy'):
+    print("[LOG] Generating embeddings...")
+    text_embeddings = embeddings.embed_documents(texts)
+    np.save('embeddings.npy', text_embeddings)
+else:
+    print("[LOG] Loading cached embeddings...")
+    text_embeddings = np.load('embeddings.npy')
+
+# Fit and cache nearest neighbor model
+if not os.path.exists('nn_model.pkl'):
+    print("[LOG] Fitting nearest neighbors model...")
+    nn = NearestNeighbors(n_neighbors=5, metric='cosine')
+    nn.fit(np.array(text_embeddings))
+    import pickle
+    with open('nn_model.pkl', 'wb') as f:
+        pickle.dump(nn, f)
+else:
+    print("[LOG] Loading cached nearest neighbors model...")
+    import pickle
+    with open('nn_model.pkl', 'rb') as f:
+        nn = pickle.load(f)
 
 def get_relevant_documents(query, k=5):
     """
     Retrieves the k most relevant documents to the query.
     """
-    try:
-        # Try GPU first
-        with spaces.GPU(duration=15):
-            query_embedding = embeddings.embed_query(query)
-            distances, indices = nn.kneighbors([query_embedding], n_neighbors=k)
-            relevant_docs = [texts[i] for i in indices[0]]
-            return relevant_docs
-    except Exception as e:
-        print(f"[WARNING] GPU failed, falling back to CPU: {str(e)}")
-        # Fallback to CPU
-        embeddings.model_kwargs["device"] = "cpu"
-        query_embedding = embeddings.embed_query(query)
-        distances, indices = nn.kneighbors([query_embedding], n_neighbors=k)
-        relevant_docs = [texts[i] for i in indices[0]]
-        return relevant_docs
+    import time
+    start_time = time.time()
+    
+    query_embedding = embeddings.embed_query(query)
+    distances, indices = nn.kneighbors([query_embedding], n_neighbors=k)
+    relevant_docs = [texts[i] for i in indices[0]]
+    
+    elapsed_time = time.time() - start_time
+    print(f"[PERF] get_relevant_documents took {elapsed_time:.2f} seconds")
+    return relevant_docs
 
 def generate_response(question, history):
+    import time
+    start_time = time.time()
+    
     try:
-        # Try GPU first with reduced duration
-        with spaces.GPU(duration=60):
-            return _generate_response_gpu(question, history)
+        response = _generate_response_gpu(question, history)
     except Exception as e:
-        print(f"[WARNING] GPU failed, falling back to CPU: {str(e)}")
-        return _generate_response_cpu(question, history)
+        print(f"[WARNING] GPU failed: {str(e)}")
+        response = _generate_response_cpu(question, history)
+        
+    elapsed_time = time.time() - start_time
+    print(f"[PERF] generate_response took {elapsed_time:.2f} seconds")
+    return response
 
 def _generate_response_gpu(question, history):
     print(f"\n[LOG] Received question: {question}")
@@ -273,6 +288,7 @@ Provide the AutoGen v0.4 agent code that fulfills the user's request. Utilize fe
         history.append((question, error_msg))
         return history
 
+
 # Create Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown(f"""
@@ -318,5 +334,35 @@ with gr.Blocks() as demo:
         outputs=[chatbot, question]
     )
 
+import socket
+
+def find_available_port(start_port=7860, end_port=7900):
+    for port in range(start_port, end_port + 1):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(('', port))
+                return port
+            except OSError:
+                continue
+    raise OSError(f"No available ports between {start_port} and {end_port}")
+
 if __name__ == "__main__":
-    demo.launch()
+    try:
+        port = find_available_port()
+        print(f"[LOG] Launching application on port {port}")
+        demo.launch(
+            server_port=port,
+            share=True,
+            server_name="0.0.0.0",
+            prevent_thread_lock=True
+        )
+        # Verify server is actually running
+        import time
+        time.sleep(2)  # Give server time to start
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(('localhost', port)) == 0:
+                print(f"[SUCCESS] Server is running on port {port}")
+            else:
+                print(f"[ERROR] Failed to bind to port {port}")
+    except Exception as e:
+        print(f"[ERROR] Failed to start application: {str(e)}")

embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9538fa345c8d0006fb2cb25372e1cbcd7d761ea7c02307196878823c3d09942b
+size 1483904