Update src/streamlit_app.py

src/streamlit_app.py

@@ -5,6 +5,7 @@ import torch
 import pickle
 import random
 from collections import defaultdict
+import json
 
 # Label encoder faylını yükləmək
 def load_label_encoder():
@@ -16,57 +17,94 @@ def load_label_encoder():
         label_encoder = pickle.load(f)
     return label_encoder
 
+# Model və tokenizer yükləmə
 @st.cache_resource
 def load_model():
     label_encoder = load_label_encoder()
     model_path = os.path.join(os.getcwd(), "best_model")
 
-    # Tokenizer və modelin yüklənməsi
     tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
     model = BertForSequenceClassification.from_pretrained(model_path, num_labels=len(label_encoder.classes_))
     model.eval()
     return tokenizer, model, label_encoder
 
+# Prediction funksiyası
+def predict_disease(symptoms_text, tokenizer, model, label_encoder):
+    symptoms = [s.strip() for s in symptoms_text.split(",") if s.strip()]
+    
+    agg_probs = defaultdict(float)
+    n_shuffles = 10
+    
+    for _ in range(n_shuffles):
+        random.shuffle(symptoms)
+        shuffled_text = ", ".join(symptoms)
+        
+        inputs = tokenizer(shuffled_text, return_tensors="pt", truncation=True, padding=True, max_length=128)
+        with torch.no_grad():
+            outputs = model(**inputs)
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1).squeeze()
+        
+        for i, p in enumerate(probs):
+            agg_probs[i] += p.item()
+    
+    for k in agg_probs:
+        agg_probs[k] /= n_shuffles
+    
+    top_3 = sorted(agg_probs.items(), key=lambda x: x[1], reverse=True)[:3]
+    
+    results = []
+    for idx, prob in top_3:
+        label = label_encoder.classes_[idx] if idx < len(label_encoder.classes_) else f"Unknown label {idx}"
+        results.append({"disease": label, "probability": prob})
+    
+    return results
+
+# Page config
+st.set_page_config(page_title="Disease API", layout="wide")
+
+# API mode detection
+query_params = st.experimental_get_query_params()
+is_api_mode = "api" in query_params
+
+# Load model
 tokenizer, model, label_encoder = load_model()
 
-st.title("Disease NLP Classifier")
+if is_api_mode:
+    st.markdown("### API Mode")
+    symptoms = query_params.get("symptoms", [""])[0]
+    if symptoms:
+        results = predict_disease(symptoms, tokenizer, model, label_encoder)
+        st.json({
+            "status": "success",
+            "input": symptoms,
+            "predictions": results
+        })
+    else:
+        st.json({
+            "status": "error",
+            "message": "symptoms parameter required"
+        })
 
-# Siniflərin sırasını göstərək (Debug məqsədilə)
-st.write("Available classes:", list(label_encoder.classes_))
+else:
+    st.title("🏥 Disease Prediction")
+    st.success("Model yükləndi!")
 
-text = st.text_area("Enter your symptoms separated by commas (e.g. fever, cough, headache):")
+    # Debug: Siniflər
+    st.write("Available classes:", list(label_encoder.classes_))
 
-def predict(text_input):
-    inputs = tokenizer(text_input, return_tensors="pt", truncation=True, padding=True, max_length=128)
-    with torch.no_grad():
-        outputs = model(**inputs)
-        probs = torch.nn.functional.softmax(outputs.logits, dim=-1).squeeze()
-    return probs
+    # API usage info
+    st.markdown("### API İstifadəsi")
+    space_url = "https://your-username-your-space-name.hf.space"
+    api_example = f"{space_url}/?api=true&symptoms=fever,cough,headache"
+    st.code(api_example)
 
-if st.button("Predict"):
-    if not text.strip():
-        st.warning("Please enter some symptoms!")
-    else:
-        symptoms = [s.strip() for s in text.split(",") if s.strip()]
-        if not symptoms:
-            st.warning("Please enter valid symptoms separated by commas!")
-        else:
-            agg_probs = defaultdict(float)
-            n_shuffles = 10
-            for _ in range(n_shuffles):
-                random.shuffle(symptoms)
-                shuffled_text = ", ".join(symptoms)
-                probs = predict(shuffled_text)
-                for i, p in enumerate(probs):
-                    agg_probs[i] += p.item()
-            for k in agg_probs:
-                agg_probs[k] /= n_shuffles
-            top_3 = sorted(agg_probs.items(), key=lambda x: x[1], reverse=True)[:3]
+    text = st.text_area("Simptomları daxil edin (vergüllə ayırın):")
 
-            st.subheader("Top 3 Predicted Diseases (averaged over shuffled inputs):")
-            for idx, prob in top_3:
-                try:
-                    label = label_encoder.classes_[idx]
-                except IndexError:
-                    label = f"Unknown label idx {idx}"
-                st.write(f"**{label}** — Probability: `{prob * 100:.2f}%`")
+    if st.button("Predict"):
+        if not text.strip():
+            st.warning("Simptomları daxil edin!")
+        else:
+            results = predict_disease(text, tokenizer, model, label_encoder)
+            st.subheader("🔍 Nəticələr:")
+            for result in results:
+                st.write(f"**{result['disease']}** — {result['probability']*100:.2f}%")