Update app.py

app.py

@@ -6,99 +6,65 @@ from sentence_transformers import SentenceTransformer
 from functools import lru_cache
 from huggingface_hub import AsyncInferenceClient
 from sklearn.decomposition import PCA
-from sklearn.metrics import pairwise_distances_argmin_min
 
-# ------ Enhanced Data Loading ------
-df = pd.read_csv("symbipredict_2022_filtered.csv").sample(frac=1, random_state=42)  # Shuffle data
-SYMPTOM_FIELD = 'symptoms'
-PROGNOSIS_FIELD = 'prognosis'
+# ------ Data Loading ------
+df = pd.read_csv("symbipredict_2022_filtered.csv")
 
-# ------ Optimized Model Initialization ------
-model = SentenceTransformer("all-MiniLM-L6-v2", device='cpu')
-embedding_arr = model.encode(df[SYMPTOM_FIELD], show_progress_bar=True).astype(np.float32)
+# ------ Model Initialization ------
+model = SentenceTransformer("all-MiniLM-L6-v2")
+embedding_arr = model.encode(df['symptoms']).astype(np.float32)
 
-# ------ Robust Clustering Setup ------
-kmeans = MiniBatchKMeans(
-    n_clusters=15,  # Increased for better granularity [2][13]
-    random_state=42,
-    n_init=5,       # Multiple initializations [2][10]
-    max_iter=300    # Better convergence [2]
-)
+# ------ Clustering Setup ------
+kmeans = MiniBatchKMeans(n_clusters=10, random_state=42)
 cluster_labels = kmeans.fit_predict(embedding_arr)
-centroids = kmeans.cluster_centers_
+cluster_prognosis_map = df.groupby(cluster_labels)['prognosis'].agg(lambda x: x.mode().tolist())
 
-# Cluster validation metrics
-cluster_quality = pairwise_distances_argmin_min(embedding_arr, centroids)[1].mean()
+# ------ PCA Initialization ------
+pca = PCA(n_components=2).fit(embedding_arr)
 
-# Prognosis mapping with confidence scores
-cluster_prognosis_map = df.groupby(cluster_labels)[PROGNOSIS_FIELD].agg(
-    lambda x: x.value_counts(normalize=True).head(3).to_dict()  # Top 3 prognoses with frequencies
-)
+# ------ Cached Functions ------
+@lru_cache(maxsize=100)
+def cached_encode(text):
+    return model.encode(text, convert_to_numpy=True)
 
-# ------ Session Context Management ------
-class DiagnosisSession:
-    def __init__(self):
-        self.sessions = {}
-        self.similarity_threshold = 0.82  # Optimized per [11]
-    
-    def get_cluster(self, history, query_embedding):
-        session_id = hash(frozenset(history))
-        if session_id in self.sessions:
-            prev_centroid = centroids[self.sessions[session_id]['cluster']]
-            distance = np.linalg.norm(query_embedding - prev_centroid)
-            if distance < self.similarity_threshold:
-                return self.sessions[session_id]
-        
-        new_cluster = kmeans.predict(query_embedding.reshape(1, -1))[0]
-        self.sessions[session_id] = {
-            'cluster': new_cluster,
-            'embedding': query_embedding
-        }
-        return self.sessions[session_id]
-
-session_manager = DiagnosisSession()
+# ------ Async Inference Client ------
+client = AsyncInferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
-# ------ Streaming Response Improvements ------
+# ------ Streaming Response Function ------
 async def respond(message, history, system_message, max_tokens, temperature, top_p):
     try:
+        # Encoding and clustering
         query_embedding = cached_encode(message)
-        session = session_manager.get_cluster(history, query_embedding)
-        cluster_info = cluster_prognosis_map[session['cluster']]
+        query_cluster = kmeans.predict(query_embedding.reshape(1, -1))[0]
         
-        # Validate cluster quality
-        if cluster_quality < 0.65:  # [10][13]
-            yield "System confidence low - consult a healthcare professional"
-            return
-
         # Generate streaming response
         stream = await client.chat_completion(
             messages=[{
                 "role": "system",
-                f"content": f"{system_message}\nCurrent cluster: {session['cluster']}"
+                "content": system_message
             }, {
                 "role": "user",
                 "content": message
             }],
-            max_tokens=min(max_tokens, 1024),  # Safety limit
+            max_tokens=max_tokens,
             stream=True,
-            temperature=max(0.1, min(temperature, 1.0)),  # Constrained randomness
+            temperature=temperature,
             top_p=top_p
         )
-
+        
         full_response = ""
         async for chunk in stream:
-            if chunk.choices[0].delta.content:
-                full_response += chunk.choices[0].delta.content
-                yield full_response
-
-        # Format prognosis display
-        top_diagnoses = [f"{k} ({v:.1%})" for k,v in cluster_info.items()]
-        yield f"{full_response}\n\nLikely conditions: {', '.join(top_diagnoses)}"
-
+            content = chunk.choices[0].delta.content
+            if content:
+                full_response += content
+                yield full_response  # Stream partial responses
+        
+        # Append cluster prognosis after completion
+        yield f"{full_response}\n\nCluster {query_cluster} common prognoses: {', '.join(cluster_prognosis_map[query_cluster])}"
+        
     except Exception as e:
-        yield f"⚠️ Medical system error: {str(e)}"
+        yield f"Error: {str(e)}"
 
-# ------ Enhanced Gradio Interface ------
 # ------ Gradio Interface ------
 demo = gr.ChatInterface(
     respond,
@@ -108,9 +74,7 @@ demo = gr.ChatInterface(
         gr.Slider(0.1, 2.0, value=0.7, step=0.1, label="Temperature"),
         gr.Slider(0.5, 1.0, value=0.95, step=0.05, label="Top-p")
     ]
-).queue(concurrency_limit=5)  # Updated concurrency handling
+).queue()
 
 if __name__ == "__main__":
-    demo.launch(max_threads=10)  # Add thread pool configuration
-
-
+    demo.launch()