Upload 14 files

.dockerignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+venv/
+env/
+.env
+.venv
+*.egg-info/
+dist/
+build/
+.git/
+.gitignore
+*.md
+!README.md
+.DS_Store
+Thumbs.db
+*.log
+cleaned_dataset.csv
+*.csv

Dockerfile

@@ -0,0 +1,40 @@
+# Use Python 3.10 slim image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY symptom_checker.py .
+COPY api_server.py .
+
+# Copy model artifacts
+COPY symptom_model.json .
+COPY symptom_model.labels.npy .
+COPY symptom_model.features.txt .
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Create a non-root user for security
+RUN useradd -m -u 1000 appuser
+USER appuser
+
+# Run the FastAPI server
+CMD ["uvicorn", "api_server:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,60 @@
----
-title: Final Text Classify
-emoji: 📊
-colorFrom: gray
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Symptom Checker (XGBoost)
+
+This folder contains the standalone symptom checker based on XGBoost.
+
+## Contents
+- `symptom_checker.py` — Train, save artifacts, evaluate, and interactive prediction
+- `preprocess_data.py` — Clean the raw dataset into `cleaned_dataset.csv`
+- `evaluate_symptom_checker.py` — Train/test split evaluation
+- `requirements.txt` — Minimal dependencies
+- (Optional) `cleaned_dataset.csv` — Cleaned dataset for evaluation
+- Artifacts after saving:
+  - `symptom_model.json` — Trained model
+  - `symptom_model.labels.npy` — Label encoder classes
+  - `symptom_model.features.txt` — Feature order used by the model
+
+## Setup
+```bash
+pip install -r requirements.txt
+```
+
+## Preprocess (optional)
+```bash
+python preprocess_data.py --input "Disease and symptoms dataset.csv" --output cleaned_dataset.csv
+```
+
+## Train and Save Artifacts (one-time)
+```bash
+python symptom_checker.py --csv cleaned_dataset.csv --save-prefix symptom_model
+```
+Creates:
+- `symptom_model.json`
+- `symptom_model.labels.npy`
+- `symptom_model.features.txt`
+
+## Evaluate Saved Model (no retraining)
+```bash
+python symptom_checker.py --eval-only --csv cleaned_dataset.csv --artifacts-prefix symptom_model
+```
+
+## Interactive Predictions (No Training Needed)
+```bash
+python symptom_checker.py --interactive-only --artifacts-prefix symptom_model
+```
+Enter symptoms separated by commas (e.g., `fever, cough, headache`). Type `list` to see features, or `quit` to exit.
+
+## API-Style Predictions (Multiple Output Formats)
+```bash
+# JSON format (best for web apps/APIs)
+python api_symptom_checker.py --symptoms fever cough headache --format json
+
+# CSV format (best for data analysis)
+python api_symptom_checker.py --symptoms fever cough headache --format csv
+
+# Simple format (best for CLI)
+python api_symptom_checker.py --symptoms fever cough headache --format simple
+```
+
+## Notes
+- GPU is used automatically if supported by your XGBoost build; otherwise CPU.
+- Keep the three artifact files together for evaluation and interactive use.

README_HF.md

@@ -0,0 +1,53 @@
+---
+title: Symptom Checker API
+emoji: 🩺
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860
+---
+
+# Symptom Checker API
+
+AI-powered symptom checker using XGBoost machine learning model.
+
+## API Endpoints
+
+### Health Check
+- **GET** `/` - Check if API is running
+
+### Get Available Symptoms
+- **GET** `/api/symptoms` - Returns list of all symptoms the model recognizes
+
+### Check Symptoms
+- **POST** `/api/check-symptoms` - Analyze symptoms and get disease predictions
+
+#### Request Body:
+```json
+{
+  "symptoms": ["fever", "cough", "headache"]
+}
+```
+
+#### Response:
+```json
+{
+  "success": true,
+  "predictions": [
+    {
+      "rank": 1,
+      "disease": "Disease Name",
+      "confidence": 0.85,
+      "confidence_percent": "85.00%"
+    }
+  ],
+  "input_symptoms": ["fever", "cough", "headache"],
+  "error": null
+}
+```
+
+## Documentation
+
+Visit `/docs` for interactive Swagger documentation.

api_server.py

@@ -0,0 +1,194 @@
+"""
+FastAPI server for Symptom Checker ML model.
+Provides endpoints compatible with Flutter mobile app.
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import numpy as np
+from contextlib import asynccontextmanager
+
+# Import from symptom_checker module
+from symptom_checker import load_artifacts, build_feature_vector
+
+# Global variables for model artifacts
+model = None
+label_encoder = None
+feature_names = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Load model artifacts on startup."""
+    global model, label_encoder, feature_names
+    try:
+        model, label_encoder, feature_names = load_artifacts("symptom_model")
+        print(f"✅ Model loaded successfully!")
+        print(f"   - Features: {len(feature_names)}")
+        print(f"   - Classes: {len(label_encoder.classes_)}")
+    except FileNotFoundError as e:
+        print(f"❌ Error loading model: {e}")
+        raise RuntimeError("Failed to load model artifacts. Ensure symptom_model.* files exist.")
+    yield
+    # Cleanup (if needed)
+    print("👋 Shutting down API server...")
+
+
+app = FastAPI(
+    title="Symptom Checker API",
+    description="AI-powered symptom checker using XGBoost",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Enable CORS for Flutter app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your app's domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ============== Pydantic Models ==============
+
+class SymptomCheckRequest(BaseModel):
+    symptoms: List[str]
+
+
+class SymptomPrediction(BaseModel):
+    rank: int
+    disease: str
+    confidence: float
+    confidence_percent: str
+
+
+class SymptomCheckResponse(BaseModel):
+    success: bool
+    predictions: List[SymptomPrediction]
+    input_symptoms: List[str]
+    error: Optional[str] = None
+
+
+class AvailableSymptomsResponse(BaseModel):
+    success: bool
+    symptoms: List[str]
+    total_symptoms: int
+    error: Optional[str] = None
+
+
+# ============== API Endpoints ==============
+
+@app.get("/")
+async def root():
+    """Health check endpoint."""
+    return {
+        "status": "online",
+        "message": "Symptom Checker API is running",
+        "endpoints": {
+            "check_symptoms": "/api/check-symptoms",
+            "available_symptoms": "/api/symptoms"
+        }
+    }
+
+
+@app.get("/api/symptoms", response_model=AvailableSymptomsResponse)
+async def get_available_symptoms():
+    """Get list of all available symptoms the model recognizes."""
+    try:
+        if feature_names is None:
+            raise HTTPException(status_code=503, detail="Model not loaded")
+        
+        return AvailableSymptomsResponse(
+            success=True,
+            symptoms=feature_names,
+            total_symptoms=len(feature_names),
+            error=None
+        )
+    except Exception as e:
+        return AvailableSymptomsResponse(
+            success=False,
+            symptoms=[],
+            total_symptoms=0,
+            error=str(e)
+        )
+
+
+@app.post("/api/check-symptoms", response_model=SymptomCheckResponse)
+async def check_symptoms(request: SymptomCheckRequest):
+    """
+    Check symptoms and return disease predictions.
+    
+    Request body:
+    {
+        "symptoms": ["fever", "cough", "headache"]
+    }
+    """
+    try:
+        if model is None or label_encoder is None or feature_names is None:
+            raise HTTPException(status_code=503, detail="Model not loaded")
+        
+        symptoms = request.symptoms
+        
+        if not symptoms:
+            return SymptomCheckResponse(
+                success=False,
+                predictions=[],
+                input_symptoms=[],
+                error="No symptoms provided"
+            )
+        
+        # Build feature vector from symptoms
+        x = build_feature_vector(feature_names, symptoms)
+        
+        # Get predictions
+        proba = model.predict_proba(x)[0]
+        
+        # Get top predictions (all classes sorted by probability)
+        top_indices = np.argsort(proba)[::-1]
+        
+        # Build predictions list (top 5 most likely)
+        predictions = []
+        for rank, idx in enumerate(top_indices[:5], start=1):
+            disease_name = label_encoder.inverse_transform([idx])[0]
+            confidence = float(proba[idx])
+            predictions.append(SymptomPrediction(
+                rank=rank,
+                disease=disease_name,
+                confidence=confidence,
+                confidence_percent=f"{confidence * 100:.2f}%"
+            ))
+        
+        return SymptomCheckResponse(
+            success=True,
+            predictions=predictions,
+            input_symptoms=symptoms,
+            error=None
+        )
+        
+    except Exception as e:
+        return SymptomCheckResponse(
+            success=False,
+            predictions=[],
+            input_symptoms=request.symptoms if request.symptoms else [],
+            error=str(e)
+        )
+
+
+# ============== Run Server ==============
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    
+    # Use PORT env variable for Hugging Face Spaces, default to 8000 for local dev
+    port = int(os.environ.get("PORT", 8000))
+    host = os.environ.get("HOST", "127.0.0.1")
+    
+    print("🚀 Starting Symptom Checker API server...")
+    print(f"📍 Access the API at: http://{host}:{port}")
+    print(f"📖 API docs at: http://{host}:{port}/docs")
+    uvicorn.run(app, host=host, port=port)

api_symptom_checker.py

@@ -0,0 +1,142 @@
+import argparse
+import json
+import os
+from typing import List, Dict, Any
+
+import numpy as np
+import xgboost as xgb
+from sklearn.preprocessing import LabelEncoder
+
+
+def load_artifacts(prefix: str):
+    """Load the trained model artifacts."""
+    model_path = f"{prefix}.json"
+    labels_path = f"{prefix}.labels.npy"
+    features_path = f"{prefix}.features.txt"
+
+    if not (os.path.exists(model_path) and os.path.exists(labels_path) and os.path.exists(features_path)):
+        raise FileNotFoundError(f"Missing artifacts. Expected: {model_path}, {labels_path}, {features_path}")
+
+    model = xgb.XGBClassifier()
+    model.load_model(model_path)
+
+    label_encoder = LabelEncoder()
+    classes = np.load(labels_path, allow_pickle=True)
+    label_encoder.classes_ = classes
+
+    with open(features_path, "r", encoding="utf-8") as f:
+        feature_names = [line.strip() for line in f if line.strip()]
+
+    return model, label_encoder, feature_names
+
+
+def build_feature_vector(symptom_names: List[str], selected_symptoms: List[str]) -> np.ndarray:
+    """Convert symptom list to feature vector."""
+    features = np.zeros(len(symptom_names), dtype=float)
+    name_to_index = {name.lower().strip(): idx for idx, name in enumerate(symptom_names)}
+    
+    for symptom in selected_symptoms:
+        key = symptom.lower().strip()
+        if key in name_to_index:
+            features[name_to_index[key]] = 1.0
+    
+    return features.reshape(1, -1)
+
+
+def predict_symptoms_json(symptoms: List[str], model, label_encoder, feature_names: List[str]) -> Dict[str, Any]:
+    """Return predictions in JSON format for API integration."""
+    if not symptoms:
+        return {"error": "No symptoms provided"}
+    
+    # Build feature vector
+    x = build_feature_vector(feature_names, symptoms)
+    
+    # Get predictions
+    proba = model.predict_proba(x)[0]
+    top3_idx = np.argsort(proba)[-3:][::-1]
+    
+    # Format results
+    predictions = []
+    for rank, idx in enumerate(top3_idx, 1):
+        disease_name = label_encoder.inverse_transform([idx])[0]
+        confidence = float(proba[idx])
+        predictions.append({
+            "rank": rank,
+            "disease": disease_name,
+            "confidence": confidence,
+            "confidence_percent": round(confidence * 100, 2)
+        })
+    
+    return {
+        "input_symptoms": symptoms,
+        "primary_diagnosis": predictions[0],
+        "top_predictions": predictions,
+        "model_confidence": "high" if predictions[0]["confidence"] > 0.7 else "medium" if predictions[0]["confidence"] > 0.4 else "low"
+    }
+
+
+def predict_symptoms_csv(symptoms: List[str], model, label_encoder, feature_names: List[str]) -> str:
+    """Return predictions in CSV format."""
+    if not symptoms:
+        return "error,No symptoms provided"
+    
+    x = build_feature_vector(feature_names, symptoms)
+    proba = model.predict_proba(x)[0]
+    top3_idx = np.argsort(proba)[-3:][::-1]
+    
+    csv_lines = ["rank,disease,confidence,confidence_percent"]
+    for rank, idx in enumerate(top3_idx, 1):
+        disease_name = label_encoder.inverse_transform([idx])[0]
+        confidence = proba[idx]
+        csv_lines.append(f"{rank},{disease_name},{confidence:.4f},{confidence*100:.2f}")
+    
+    return "\n".join(csv_lines)
+
+
+def predict_symptoms_simple(symptoms: List[str], model, label_encoder, feature_names: List[str]) -> str:
+    """Return simple text format."""
+    if not symptoms:
+        return "Error: No symptoms provided"
+    
+    x = build_feature_vector(feature_names, symptoms)
+    proba = model.predict_proba(x)[0]
+    top1_idx = np.argmax(proba)
+    
+    disease_name = label_encoder.inverse_transform([top1_idx])[0]
+    confidence = proba[top1_idx]
+    
+    return f"Diagnosis: {disease_name} (Confidence: {confidence*100:.1f}%)"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="API-style symptom checker using saved model")
+    parser.add_argument("--symptoms", nargs="+", required=True, help="List of symptoms")
+    parser.add_argument("--format", choices=["json", "csv", "simple"], default="json", help="Output format")
+    parser.add_argument("--artifacts-prefix", default="symptom_checker/symptom_model", help="Path to model artifacts")
+    args = parser.parse_args()
+
+    try:
+        # Load the trained model
+        model, label_encoder, feature_names = load_artifacts(args.artifacts_prefix)
+        
+        # Get predictions in requested format
+        if args.format == "json":
+            result = predict_symptoms_json(args.symptoms, model, label_encoder, feature_names)
+            print(json.dumps(result, indent=2))
+        elif args.format == "csv":
+            result = predict_symptoms_csv(args.symptoms, model, label_encoder, feature_names)
+            print(result)
+        elif args.format == "simple":
+            result = predict_symptoms_simple(args.symptoms, model, label_encoder, feature_names)
+            print(result)
+            
+    except Exception as e:
+        error_result = {"error": str(e), "input_symptoms": args.symptoms}
+        if args.format == "json":
+            print(json.dumps(error_result, indent=2))
+        else:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

evaluate_symptom_checker.py

@@ -0,0 +1,103 @@
+import argparse
+import os
+from typing import Tuple
+
+import numpy as np
+import pandas as pd
+import xgboost as xgb
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+
+
+def load_data(csv_path: str) -> pd.DataFrame:
+    if not os.path.exists(csv_path):
+        raise FileNotFoundError(f"CSV not found: {csv_path}")
+    df = pd.read_csv(csv_path)
+    if df.shape[1] < 2:
+        raise ValueError("CSV must have at least 2 columns (target + features)")
+    return df
+
+
+def split_encode(df: pd.DataFrame, test_size: float, seed: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, LabelEncoder, list]:
+    target = df.columns[0]
+    X = df.iloc[:, 1:]
+    y = df[target]
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=seed, stratify=y
+    )
+
+    label_encoder = LabelEncoder()
+    y_train_enc = label_encoder.fit_transform(y_train)
+    y_test_enc = label_encoder.transform(y_test)
+
+    return X_train.values, X_test.values, y_train_enc, y_test_enc, label_encoder, X.columns.tolist()
+
+
+def build_model(num_classes: int):
+    common_kwargs = dict(
+        objective="multi:softprob",
+        num_class=num_classes,
+        eval_metric="mlogloss",
+        tree_method="hist",
+        n_estimators=300,
+        max_depth=6,
+        learning_rate=0.05,
+        subsample=0.8,
+        colsample_bytree=0.8,
+        random_state=42,
+    )
+    try:
+        model = xgb.XGBClassifier(device="cuda", **common_kwargs)
+    except TypeError:
+        try:
+            model = xgb.XGBClassifier(tree_method="gpu_hist", **{k: v for k, v in common_kwargs.items() if k != "tree_method"})
+        except Exception:
+            model = xgb.XGBClassifier(**common_kwargs)
+    return model
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate XGBoost Symptom Checker accuracy")
+    parser.add_argument("--csv", required=True, help="Path to cleaned CSV (target + binary features)")
+    parser.add_argument("--test-size", type=float, default=0.2, help="Test set fraction (default 0.2)")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed (default 42)")
+    args = parser.parse_args()
+
+    print("Loading data...")
+    df = load_data(args.csv)
+    print(f"Shape: {df.shape}")
+
+    print("Splitting and encoding labels...")
+    X_train, X_test, y_train, y_test, label_enc, feature_names = split_encode(df, args.test_size, args.seed)
+    num_classes = len(np.unique(y_train))
+    print(f"Classes: {num_classes}; Features: {len(feature_names)}")
+
+    print("Training model...")
+    model = build_model(num_classes)
+    try:
+        model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=50, early_stopping_rounds=30)
+    except TypeError:
+        model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=50)
+
+    print("Evaluating...")
+    y_proba = model.predict_proba(X_test)
+    y_pred = np.argmax(y_proba, axis=1)
+
+    acc = accuracy_score(y_test, y_pred)
+    print(f"\nAccuracy: {acc:.4f} ({acc*100:.2f}%)")
+
+    print("\nClassification report:")
+    target_names = label_enc.inverse_transform(np.arange(num_classes))
+    print(classification_report(y_test, y_pred, target_names=target_names, zero_division=0))
+
+    print("Confusion matrix (rows=true, cols=pred):")
+    cm = confusion_matrix(y_test, y_pred)
+    print(cm)
+
+
+if __name__ == "__main__":
+    main()
+
+

main.py

@@ -0,0 +1,257 @@
+"""
+FastAPI Backend for Symptom Checker
+Provides REST API endpoints for the Flutter mobile application.
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import numpy as np
+import xgboost as xgb
+from sklearn.preprocessing import LabelEncoder
+import os
+
+# ============================================================================
+# Pydantic Models (matching Flutter frontend expectations)
+# ============================================================================
+
+class SymptomsRequest(BaseModel):
+    symptoms: List[str]
+
+
+class SymptomPrediction(BaseModel):
+    rank: int
+    disease: str
+    confidence: float
+    confidence_percent: str
+
+
+class SymptomCheckResponse(BaseModel):
+    success: bool
+    predictions: List[SymptomPrediction]
+    input_symptoms: List[str]
+    error: Optional[str]
+
+
+class AvailableSymptomsResponse(BaseModel):
+    success: bool
+    symptoms: List[str]
+    total_symptoms: int
+    error: Optional[str]
+
+
+# ============================================================================
+# Model Loading (same as symptom_checker.py)
+# ============================================================================
+
+class LoadedModel:
+    """Wrapper for loaded XGBoost model that provides predict_proba functionality."""
+    def __init__(self, booster: xgb.Booster, n_classes: int, feature_names: List[str] = None):
+        self.booster = booster
+        self.n_classes = n_classes
+        self.feature_names = feature_names
+    
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Return probability predictions using the booster."""
+        dmatrix = xgb.DMatrix(X, feature_names=self.feature_names)
+        preds = self.booster.predict(dmatrix)
+        if len(preds.shape) == 1:
+            return np.column_stack([1 - preds, preds])
+        return preds
+
+
+def load_artifacts(prefix: str):
+    """Load model artifacts from files."""
+    model_path = f"{prefix}.json"
+    labels_path = f"{prefix}.labels.npy"
+    features_path = f"{prefix}.features.txt"
+
+    if not (os.path.exists(model_path) and os.path.exists(labels_path) and os.path.exists(features_path)):
+        raise FileNotFoundError(
+            f"Missing artifacts. Expected: '{model_path}', '{labels_path}', '{features_path}'."
+        )
+
+    # Load label encoder classes
+    label_encoder = LabelEncoder()
+    classes = np.load(labels_path, allow_pickle=True)
+    label_encoder.classes_ = classes
+    n_classes = len(classes)
+
+    # Load feature names
+    with open(features_path, "r", encoding="utf-8") as f:
+        feature_names = [line.strip() for line in f if line.strip()]
+
+    # Load model using Booster
+    booster = xgb.Booster()
+    booster.load_model(model_path)
+    
+    model = LoadedModel(booster, n_classes, feature_names)
+
+    return model, label_encoder, feature_names
+
+
+def build_feature_vector(symptom_names: List[str], selected: List[str]) -> np.ndarray:
+    """Build a binary feature vector from selected symptoms."""
+    features = np.zeros(len(symptom_names), dtype=float)
+    name_to_index = {name.lower().strip(): idx for idx, name in enumerate(symptom_names)}
+    for s in selected:
+        key = s.lower().strip()
+        if key in name_to_index:
+            features[name_to_index[key]] = 1.0
+    return features.reshape(1, -1)
+
+
+# ============================================================================
+# FastAPI App Setup
+# ============================================================================
+
+app = FastAPI(
+    title="Symptom Checker API",
+    description="AI-powered symptom checker using XGBoost",
+    version="1.0.0"
+)
+
+# Enable CORS for Flutter app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your app's domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for model (loaded on startup)
+model = None
+label_encoder = None
+feature_names = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Load model artifacts on startup."""
+    global model, label_encoder, feature_names
+    
+    # Get the directory where this script is located
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    artifacts_prefix = os.path.join(script_dir, "symptom_model")
+    
+    try:
+        model, label_encoder, feature_names = load_artifacts(artifacts_prefix)
+        print(f"✅ Model loaded successfully!")
+        print(f"   - Features: {len(feature_names)}")
+        print(f"   - Classes: {len(label_encoder.classes_)}")
+    except Exception as e:
+        print(f"❌ Failed to load model: {e}")
+        raise
+
+
+# ============================================================================
+# API Endpoints
+# ============================================================================
+
+@app.get("/")
+async def root():
+    """Health check endpoint."""
+    return {"status": "healthy", "message": "Symptom Checker API is running"}
+
+
+@app.get("/api/symptoms", response_model=AvailableSymptomsResponse)
+async def get_available_symptoms():
+    """
+    Get list of all available symptoms the model recognizes.
+    """
+    try:
+        if feature_names is None:
+            return AvailableSymptomsResponse(
+                success=False,
+                symptoms=[],
+                total_symptoms=0,
+                error="Model not loaded"
+            )
+        
+        # Return symptoms with proper capitalization
+        formatted_symptoms = [s.replace("_", " ").title() for s in feature_names]
+        
+        return AvailableSymptomsResponse(
+            success=True,
+            symptoms=formatted_symptoms,
+            total_symptoms=len(formatted_symptoms),
+            error=None
+        )
+    except Exception as e:
+        return AvailableSymptomsResponse(
+            success=False,
+            symptoms=[],
+            total_symptoms=0,
+            error=str(e)
+        )
+
+
+@app.post("/api/check-symptoms", response_model=SymptomCheckResponse)
+async def check_symptoms(request: SymptomsRequest):
+    """
+    Check symptoms and return disease predictions.
+    """
+    try:
+        if model is None or label_encoder is None or feature_names is None:
+            return SymptomCheckResponse(
+                success=False,
+                predictions=[],
+                input_symptoms=request.symptoms,
+                error="Model not loaded"
+            )
+        
+        if not request.symptoms:
+            return SymptomCheckResponse(
+                success=False,
+                predictions=[],
+                input_symptoms=[],
+                error="No symptoms provided"
+            )
+        
+        # Build feature vector
+        x = build_feature_vector(feature_names, request.symptoms)
+        
+        # Get predictions
+        proba = model.predict_proba(x)[0]
+        
+        # Get top predictions (all classes sorted by probability)
+        top_indices = np.argsort(proba)[::-1]
+        
+        # Build predictions list (top 5 by default)
+        predictions = []
+        for rank, idx in enumerate(top_indices[:5], start=1):
+            disease_name = label_encoder.inverse_transform([idx])[0]
+            confidence = float(proba[idx])
+            
+            predictions.append(SymptomPrediction(
+                rank=rank,
+                disease=str(disease_name),
+                confidence=round(confidence, 4),
+                confidence_percent=f"{confidence * 100:.2f}%"
+            ))
+        
+        return SymptomCheckResponse(
+            success=True,
+            predictions=predictions,
+            input_symptoms=request.symptoms,
+            error=None
+        )
+    
+    except Exception as e:
+        return SymptomCheckResponse(
+            success=False,
+            predictions=[],
+            input_symptoms=request.symptoms,
+            error=str(e)
+        )
+
+
+# ============================================================================
+# Run with: uvicorn main:app --reload --host 0.0.0.0 --port 8000
+# ============================================================================
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

preprocess_data.py

@@ -0,0 +1,102 @@
+import argparse
+import os
+import sys
+import pandas as pd
+import numpy as np
+
+
+def standardize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Lowercase, strip, and replace spaces with underscores in column names."""
+    df = df.copy()
+    df.columns = [c.strip().lower().replace(" ", "_") for c in df.columns]
+    return df
+
+
+def drop_invalid_rows(df: pd.DataFrame) -> pd.DataFrame:
+    """Drop rows with missing target (first column) and fully empty feature rows."""
+    df = df.copy()
+    target_col = df.columns[0]
+    df = df[~df[target_col].isna()]
+    feature_df = df.iloc[:, 1:]
+    non_empty_mask = ~(feature_df.isna().all(axis=1) | (feature_df.sum(axis=1) == 0))
+    df = df.loc[non_empty_mask]
+    return df
+
+
+def remove_constant_and_sparse_features(df: pd.DataFrame, min_positive_frac: float = 0.0005):
+    """Remove columns that are constant or extremely sparse (near-zero variance)."""
+    target = df.columns[0]
+    X = df.iloc[:, 1:]
+    keep_cols = []
+    for col in X.columns:
+        series = X[col]
+        if series.nunique(dropna=True) <= 1:
+            continue
+        # If binary-like, compute positive ratio
+        try:
+            pos_frac = (series.fillna(0) > 0).mean()
+        except Exception:
+            pos_frac = 1.0
+        if pos_frac < min_positive_frac:
+            continue
+        keep_cols.append(col)
+    cleaned = pd.concat([df[[target]], X[keep_cols]], axis=1)
+    return cleaned
+
+
+def impute_missing(df: pd.DataFrame) -> pd.DataFrame:
+    """Impute missing values in features with 0, keep target as is."""
+    target = df.columns[0]
+    X = df.iloc[:, 1:].fillna(0)
+    return pd.concat([df[[target]], X], axis=1)
+
+
+def limit_classes(df: pd.DataFrame, min_samples: int = 5) -> pd.DataFrame:
+    """Keep only classes with at least min_samples samples."""
+    target = df.columns[0]
+    counts = df[target].value_counts()
+    keep = counts[counts >= min_samples].index
+    return df[df[target].isin(keep)]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Preprocess disease-symptom CSV for training.")
+    parser.add_argument("--input", required=True, help="Path to raw CSV")
+    parser.add_argument("--output", default="cleaned_dataset.csv", help="Path to save cleaned CSV")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input):
+        print(f"❌ Input CSV not found: {args.input}")
+        sys.exit(1)
+
+    print("Loading CSV...")
+    df = pd.read_csv(args.input)
+    print(f"Raw shape: {df.shape}")
+
+    print("Standardizing column names...")
+    df = standardize_columns(df)
+
+    print("Dropping invalid/empty rows...")
+    df = drop_invalid_rows(df)
+    print(f"After row cleanup: {df.shape}")
+
+    print("Removing constant and sparse features...")
+    df = remove_constant_and_sparse_features(df)
+    print(f"After feature cleanup: {df.shape}")
+
+    print("Imputing missing values (0 for symptoms)...")
+    df = impute_missing(df)
+
+    print("Limiting classes with very few samples...")
+    df = limit_classes(df, min_samples=5)
+    print(f"After class filtering: {df.shape}")
+
+    print(f"Saving cleaned CSV to: {args.output}")
+    df.to_csv(args.output, index=False)
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()
+
+

requirements.txt

@@ -0,0 +1,6 @@
+xgboost
+pandas
+scikit-learn
+numpy
+fastapi
+uvicorn[standard]

symptom_checker.py

@@ -0,0 +1,304 @@
+import argparse
+import os
+from typing import List, Tuple
+
+import numpy as np
+import pandas as pd
+import xgboost as xgb
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+
+
+def load_dataset(csv_path: str) -> pd.DataFrame:
+    if not os.path.exists(csv_path):
+        raise FileNotFoundError(
+            f"CSV not found at '{csv_path}'. Provide a valid path with --csv <path>."
+        )
+    data = pd.read_csv(csv_path)
+    if data.shape[1] < 2:
+        raise ValueError("Dataset must have at least 2 columns: target then feature columns.")
+    return data
+
+
+def train_model(data: pd.DataFrame):
+    y = data.iloc[:, 0]
+
+    # Remove diseases with only 1 record
+    value_counts = y.value_counts()
+    rare_diseases = value_counts[value_counts < 2].index
+    data_filtered = data[~data.iloc[:, 0].isin(rare_diseases)]
+
+    X = data_filtered.iloc[:, 1:]
+    y = data_filtered.iloc[:, 0]
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=y
+    )
+
+    label_encoder = LabelEncoder()
+    y_train_encoded = label_encoder.fit_transform(y_train)
+    y_test_encoded = label_encoder.transform(y_test)
+
+    # Prefer GPU if available, but fall back to CPU if not supported
+    common_kwargs = dict(
+        objective="multi:softprob",
+        num_class=len(np.unique(y_train_encoded)),
+        eval_metric="mlogloss",
+        tree_method="hist",
+        n_estimators=400,
+        max_depth=6,
+        learning_rate=0.05,
+        subsample=0.8,
+        colsample_bytree=0.8,
+        random_state=42,
+    )
+
+    try:
+        model = xgb.XGBClassifier(device="cuda", **common_kwargs)
+    except TypeError:
+        # Older xgboost: no 'device' param. Try GPU via tree_method if supported, else CPU.
+        try:
+            model = xgb.XGBClassifier(tree_method="gpu_hist", **{k: v for k, v in common_kwargs.items() if k != "tree_method"})
+        except Exception:
+            model = xgb.XGBClassifier(**common_kwargs)
+
+    try:
+        model.fit(
+            X_train,
+            y_train_encoded,
+            eval_set=[(X_test, y_test_encoded)],
+            verbose=50,
+            early_stopping_rounds=50,
+        )
+    except TypeError:
+        # Older xgboost versions do not support early_stopping_rounds in sklearn API
+        model.fit(
+            X_train,
+            y_train_encoded,
+            eval_set=[(X_test, y_test_encoded)],
+            verbose=50,
+        )
+
+    return model, label_encoder, X.columns.tolist()
+
+
+def save_artifacts(model: xgb.XGBClassifier, label_encoder: LabelEncoder, feature_names: List[str], prefix: str) -> Tuple[str, str, str]:
+    os.makedirs(os.path.dirname(prefix) or ".", exist_ok=True)
+    model_path = f"{prefix}.json"
+    labels_path = f"{prefix}.labels.npy"
+    features_path = f"{prefix}.features.txt"
+
+    try:
+        model.save_model(model_path)
+    except Exception:
+        model.get_booster().save_model(model_path)
+
+    # Save label encoder classes with allow_pickle=True since they contain strings
+    np.save(labels_path, label_encoder.classes_, allow_pickle=True)
+
+    with open(features_path, "w", encoding="utf-8") as f:
+        for name in feature_names:
+            f.write(f"{name}\n")
+
+    return model_path, labels_path, features_path
+
+
+class LoadedModel:
+    """Wrapper for loaded XGBoost model that provides predict_proba functionality."""
+    def __init__(self, booster: xgb.Booster, n_classes: int, feature_names: List[str] = None):
+        self.booster = booster
+        self.n_classes = n_classes
+        self.feature_names = feature_names
+    
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Return probability predictions using the booster."""
+        dmatrix = xgb.DMatrix(X, feature_names=self.feature_names)
+        preds = self.booster.predict(dmatrix)
+        # For multi-class, preds is already (n_samples, n_classes)
+        if len(preds.shape) == 1:
+            # Binary classification case
+            return np.column_stack([1 - preds, preds])
+        return preds
+    
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Return class predictions."""
+        proba = self.predict_proba(X)
+        return np.argmax(proba, axis=1)
+
+
+def load_artifacts(prefix: str) -> Tuple[LoadedModel, LabelEncoder, List[str]]:
+    model_path = f"{prefix}.json"
+    labels_path = f"{prefix}.labels.npy"
+    features_path = f"{prefix}.features.txt"
+
+    if not (os.path.exists(model_path) and os.path.exists(labels_path) and os.path.exists(features_path)):
+        raise FileNotFoundError(
+            f"Missing artifacts. Expected: '{model_path}', '{labels_path}', '{features_path}'."
+        )
+
+    # Load label encoder classes
+    label_encoder = LabelEncoder()
+    classes = np.load(labels_path, allow_pickle=True)
+    label_encoder.classes_ = classes
+    n_classes = len(classes)
+
+    # Load feature names first (needed for model)
+    with open(features_path, "r", encoding="utf-8") as f:
+        feature_names = [line.strip() for line in f if line.strip()]
+
+    # Load model using Booster directly
+    booster = xgb.Booster()
+    booster.load_model(model_path)
+    
+    # Wrap in our custom class that provides predict_proba (with feature names)
+    model = LoadedModel(booster, n_classes, feature_names)
+
+    return model, label_encoder, feature_names
+
+
+def build_feature_vector(symptom_names: List[str], selected: List[str]) -> np.ndarray:
+    features = np.zeros(len(symptom_names), dtype=float)
+    name_to_index = {name.lower().strip(): idx for idx, name in enumerate(symptom_names)}
+    for s in selected:
+        key = s.lower().strip()
+        if key in name_to_index:
+            features[name_to_index[key]] = 1.0
+    return features.reshape(1, -1)
+
+
+def interactive_loop(model, label_encoder, symptom_names: List[str]):
+    print("\n" + "=" * 60)
+    print("🩺 Symptom Checker (XGBoost)")
+    print("=" * 60)
+    print("Enter symptoms separated by commas. Example: fever, cough, headache")
+    print("Type 'list' to see all available symptoms, or 'quit' to exit.")
+    print("=" * 60)
+
+    while True:
+        try:
+            user = input("\n💬 Symptoms: ").strip()
+            if user.lower() in {"quit", "exit", "q"}:
+                print("👋 Goodbye!")
+                break
+            if user == "":
+                continue
+            if user.lower() == "list":
+                print("\nAvailable symptoms (features):")
+                print(", ".join(symptom_names))
+                continue
+
+            selected = [s for s in user.split(",") if s.strip()]
+            if not selected:
+                print("⚠️  Please enter at least one symptom.")
+                continue
+
+            x = build_feature_vector(symptom_names, selected)
+            proba = model.predict_proba(x)[0]
+            top3_idx = np.argsort(proba)[-3:][::-1]
+            top1 = top3_idx[0]
+
+            top1_label = label_encoder.inverse_transform([top1])[0]
+            top1_conf = proba[top1]
+
+            print("\n📊 Prediction Results")
+            print("-" * 60)
+            print(f"🏥 Primary Diagnosis: {top1_label}")
+            print(f"📈 Confidence: {top1_conf:.4f} ({top1_conf*100:.2f}%)")
+            print("\n🏆 Top 3 Possible Conditions:")
+            for rank, idx in enumerate(top3_idx, start=1):
+                label = label_encoder.inverse_transform([idx])[0]
+                print(f"  {rank}. {label}: {proba[idx]:.4f} ({proba[idx]*100:.2f}%)")
+
+        except KeyboardInterrupt:
+            print("\n👋 Interrupted. Goodbye!")
+            break
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Symptom checker using an XGBoost classifier.")
+    parser.add_argument(
+        "--csv",
+        type=str,
+        required=False,
+        help="Path to CSV dataset. First column must be target (disease), remaining columns symptoms.",
+    )
+    parser.add_argument(
+        "--save-prefix",
+        type=str,
+        default=None,
+        help="Prefix to save artifacts (creates .json/.labels.npy/.features.txt)",
+    )
+    parser.add_argument(
+        "--eval-only",
+        action="store_true",
+        help="Evaluate previously saved artifacts on --csv and exit (no training).",
+    )
+    parser.add_argument(
+        "--artifacts-prefix",
+        type=str,
+        default="symptom_checker/symptom_model",
+        help="Prefix path to load artifacts (default: symptom_checker/symptom_model)",
+    )
+    parser.add_argument(
+        "--interactive-only",
+        action="store_true",
+        help="Start interactive mode using saved artifacts only (no training).",
+    )
+    args = parser.parse_args()
+
+    if args.interactive_only:
+        try:
+            model, label_encoder, feature_names = load_artifacts(args.artifacts_prefix)
+        except FileNotFoundError as e:
+            print(str(e))
+            print("Train and save first, e.g.:\n  python symptom_checker/symtom_checker.py --csv cleaned_dataset.csv --save-prefix symptom_checker/symptom_model")
+            return
+        interactive_loop(model, label_encoder, feature_names)
+        return
+
+    if args.eval_only:
+        if not args.csv:
+            print("Provide CSV for evaluation. Example:\n  python symptom_checker/symtom_checker.py --eval-only --csv cleaned_dataset.csv --artifacts-prefix symptom_checker/symptom_model")
+            return
+        data = load_dataset(args.csv)
+        try:
+            model, label_encoder, feature_names = load_artifacts(args.artifacts_prefix)
+        except FileNotFoundError as e:
+            print(str(e))
+            return
+        target_col = data.columns[0]
+        missing = [c for c in feature_names if c not in data.columns]
+        if missing:
+            print(f"CSV missing {len(missing)} feature columns from training. Example missing: {missing[:10]}")
+            return
+        X = data.loc[:, feature_names].fillna(0).values
+        y = data[target_col].values
+        y_enc = label_encoder.transform(y)
+        proba = model.predict_proba(X)
+        y_pred = np.argmax(proba, axis=1)
+        acc = (y_pred == y_enc).mean()
+        print(f"Accuracy on provided CSV: {acc:.4f} ({acc*100:.2f}%)")
+        return
+
+    if not args.csv:
+        print("❗ No CSV provided. Run: python symptom_checker/symtom_checker.py --csv path/to/dataset.csv")
+        return
+
+    data = load_dataset(args.csv)
+    print("Shape of dataset:", data.shape)
+    model, label_encoder, symptom_names = train_model(data)
+
+    if args.save_prefix:
+        print("Saving artifacts...")
+        paths = save_artifacts(model, label_encoder, symptom_names, args.save_prefix)
+        for p in paths:
+            print(f" - {p}")
+
+    interactive_loop(model, label_encoder, symptom_names)
+
+
+if __name__ == "__main__":
+    main()
+

symptom_model.features.txt

@@ -0,0 +1,297 @@
+anxiety_and_nervousness
+depression
+shortness_of_breath
+depressive_or_psychotic_symptoms
+sharp_chest_pain
+dizziness
+insomnia
+abnormal_involuntary_movements
+chest_tightness
+palpitations
+irregular_heartbeat
+breathing_fast
+hoarse_voice
+sore_throat
+difficulty_speaking
+cough
+nasal_congestion
+throat_swelling
+diminished_hearing
+lump_in_throat
+throat_feels_tight
+difficulty_in_swallowing
+skin_swelling
+retention_of_urine
+groin_mass
+leg_pain
+hip_pain
+suprapubic_pain
+blood_in_stool
+lack_of_growth
+emotional_symptoms
+elbow_weakness
+back_weakness
+symptoms_of_the_scrotum_and_testes
+swelling_of_scrotum
+pain_in_testicles
+flatulence
+pus_draining_from_ear
+jaundice
+mass_in_scrotum
+white_discharge_from_eye
+irritable_infant
+abusing_alcohol
+fainting
+hostile_behavior
+drug_abuse
+sharp_abdominal_pain
+feeling_ill
+vomiting
+headache
+nausea
+diarrhea
+vaginal_itching
+vaginal_dryness
+painful_urination
+involuntary_urination
+pain_during_intercourse
+frequent_urination
+lower_abdominal_pain
+vaginal_discharge
+blood_in_urine
+hot_flashes
+intermenstrual_bleeding
+hand_or_finger_pain
+wrist_pain
+hand_or_finger_swelling
+arm_pain
+wrist_swelling
+arm_stiffness_or_tightness
+arm_swelling
+hand_or_finger_stiffness_or_tightness
+wrist_stiffness_or_tightness
+lip_swelling
+toothache
+abnormal_appearing_skin
+skin_lesion
+acne_or_pimples
+dry_lips
+facial_pain
+mouth_ulcer
+skin_growth
+eye_deviation
+diminished_vision
+double_vision
+cross-eyed
+symptoms_of_eye
+pain_in_eye
+eye_moves_abnormally
+abnormal_movement_of_eyelid
+foreign_body_sensation_in_eye
+irregular_appearing_scalp
+swollen_lymph_nodes
+back_pain
+neck_pain
+low_back_pain
+pain_of_the_anus
+pain_during_pregnancy
+pelvic_pain
+impotence
+vomiting_blood
+regurgitation
+burning_abdominal_pain
+restlessness
+symptoms_of_infants
+wheezing
+peripheral_edema
+neck_mass
+ear_pain
+jaw_swelling
+mouth_dryness
+neck_swelling
+knee_pain
+foot_or_toe_pain
+ankle_pain
+bones_are_painful
+knee_weakness
+elbow_pain
+knee_swelling
+skin_moles
+knee_lump_or_mass
+weight_gain
+problems_with_movement
+knee_stiffness_or_tightness
+leg_swelling
+foot_or_toe_swelling
+heartburn
+smoking_problems
+muscle_pain
+infant_feeding_problem
+recent_weight_loss
+difficulty_eating
+vaginal_pain
+vaginal_redness
+vulvar_irritation
+weakness
+decreased_heart_rate
+increased_heart_rate
+bleeding_or_discharge_from_nipple
+ringing_in_ear
+plugged_feeling_in_ear
+itchy_ear(s)
+frontal_headache
+fluid_in_ear
+neck_stiffness_or_tightness
+spots_or_clouds_in_vision
+eye_redness
+lacrimation
+itchiness_of_eye
+blindness
+eye_burns_or_stings
+itchy_eyelid
+decreased_appetite
+excessive_appetite
+excessive_anger
+loss_of_sensation
+focal_weakness
+slurring_words
+symptoms_of_the_face
+disturbance_of_memory
+paresthesia
+side_pain
+fever
+shoulder_pain
+shoulder_stiffness_or_tightness
+shoulder_weakness
+shoulder_swelling
+tongue_lesions
+leg_cramps_or_spasms
+ache_all_over
+lower_body_pain
+problems_during_pregnancy
+spotting_or_bleeding_during_pregnancy
+cramps_and_spasms
+upper_abdominal_pain
+stomach_bloating
+changes_in_stool_appearance
+unusual_color_or_odor_to_urine
+kidney_mass
+swollen_abdomen
+symptoms_of_prostate
+leg_stiffness_or_tightness
+difficulty_breathing
+rib_pain
+joint_pain
+muscle_stiffness_or_tightness
+hand_or_finger_lump_or_mass
+chills
+groin_pain
+fatigue
+abdominal_distention
+regurgitation.1
+symptoms_of_the_kidneys
+melena
+coughing_up_sputum
+seizures
+delusions_or_hallucinations
+pain_or_soreness_of_breast
+excessive_urination_at_night
+bleeding_from_eye
+rectal_bleeding
+constipation
+temper_problems
+coryza
+hemoptysis
+lymphedema
+skin_on_leg_or_foot_looks_infected
+allergic_reaction
+congestion_in_chest
+muscle_swelling
+sleepiness
+apnea
+abnormal_breathing_sounds
+blood_clots_during_menstrual_periods
+absence_of_menstruation
+pulling_at_ears
+gum_pain
+redness_in_ear
+fluid_retention
+flu-like_syndrome
+sinus_congestion
+painful_sinuses
+fears_and_phobias
+recent_pregnancy
+uterine_contractions
+burning_chest_pain
+back_cramps_or_spasms
+stiffness_all_over
+muscle_cramps,_contractures,_or_spasms
+back_mass_or_lump
+nosebleed
+long_menstrual_periods
+heavy_menstrual_flow
+unpredictable_menstruation
+painful_menstruation
+infertility
+frequent_menstruation
+sweating
+mass_on_eyelid
+swollen_eye
+eyelid_swelling
+eyelid_lesion_or_rash
+symptoms_of_bladder
+irregular_appearing_nails
+itching_of_skin
+hurts_to_breath
+skin_dryness,_peeling,_scaliness,_or_roughness
+skin_on_arm_or_hand_looks_infected
+skin_irritation
+itchy_scalp
+warts
+bumps_on_penis
+too_little_hair
+skin_rash
+mass_or_swelling_around_the_anus
+ankle_swelling
+dry_or_flaky_scalp
+foot_or_toe_stiffness_or_tightness
+elbow_swelling
+early_or_late_onset_of_menopause
+bleeding_from_ear
+hand_or_finger_weakness
+low_self-esteem
+itching_of_the_anus
+swollen_or_red_tonsils
+irregular_belly_button
+hip_stiffness_or_tightness
+mouth_pain
+arm_weakness
+penis_pain
+loss_of_sex_drive
+obsessions_and_compulsions
+antisocial_behavior
+neck_cramps_or_spasms
+sneezing
+leg_weakness
+penis_redness
+penile_discharge
+shoulder_lump_or_mass
+cloudy_eye
+hysterical_behavior
+arm_lump_or_mass
+nightmares
+bleeding_gums
+pain_in_gums
+bedwetting
+diaper_rash
+lump_or_mass_of_breast
+postpartum_problems_of_the_breast
+hesitancy
+throat_redness
+joint_swelling
+redness_in_or_around_nose
+wrinkles_on_skin
+back_stiffness_or_tightness
+wrist_lump_or_mass
+low_urine_output
+sore_in_nose

symptom_model.labels.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a75f3ff2598b2868f33d82be336e32dee0793e863e426887ceb7aa62f36d813
+size 15480