Upload 5 files

README.md

@@ -1,75 +1,151 @@
-
-# Parkinson's Disease Detection API
-
-This API provides predictions for detecting Parkinson's disease based on voice recordings.
-
-## Overview
-
-The model analyzes 22 acoustic features extracted from sustained phonations (holding the sound 'ahhh'), 
-including jitter, shimmer, and various voice measures to predict if the voice sample indicates Parkinson's disease.
-
-## API Usage
-
-### Endpoint: `/api/predict`
-
-Send a POST request with the following acoustic parameters (all are optional, defaults will be used for missing values):
-
-- `fo_hz`: Fundamental frequency (Hz)
-- `fhi_hz`: Maximum fundamental frequency (Hz)
-- `flo_hz`: Minimum fundamental frequency (Hz)
-- `jitter_percent`: Relative jitter percentage
-- `jitter_abs`: Absolute jitter in microseconds
-- `rap`: Relative amplitude perturbation
-- `ppq`: Five-point period perturbation quotient
-- `ddp`: Average absolute difference of differences between jitter cycles
-- `shimmer`: Local shimmer
-- `shimmer_db`: Shimmer in decibels
-- `apq3`: Three-point amplitude perturbation quotient
-- `apq5`: Five-point amplitude perturbation quotient
-- `apq`: 11-point amplitude perturbation quotient
-- `dda`: Average absolute differences between consecutive differences of amplitudes
-- `nhr`: Noise-to-harmonics ratio
-- `hnr`: Harmonics-to-noise ratio
-- `rpde`: Recurrence period density entropy measure
-- `dfa`: Signal fractal scaling exponent
-- `spread1`: Nonlinear measure of fundamental frequency variation
-- `spread2`: Nonlinear measure of fundamental frequency variation
-- `d2`: Correlation dimension
-- `ppe`: Pitch period entropy
-
-### Response
-
-The API returns a JSON object with:
-
-- `prediction`: Binary classification (0 = healthy, 1 = Parkinson's)
-- `prediction_label`: Text description of the prediction
-- `confidence`: Model confidence in the prediction (0-1)
-- `using_model`: Whether the ML model was used or fallback logic
-- `execution_time_ms`: Execution time in milliseconds
-- `model_type`: Type of model used (SVM or Fallback)
-
-## Example
-
-```python
-import requests
-
-url = "https://yourusername-parkinsons-model.hf.space/api/predict"
-data = {
-    "fo_hz": 120.0,
-    "fhi_hz": 150.0,
-    "flo_hz": 100.0,
-    "jitter_percent": 0.009,
-    "shimmer": 0.05,
-    "hnr": 19.0
-}
-
-response = requests.post(url, data=data)
-result = response.json()
-print(result)
-```
-
-## Model Information
-
-- Model Type: Support Vector Machine (SVM)
-- Accuracy: ~87%
-- Dataset: UCI ML Parkinson's Dataset
+# BrainWise
+
+BrainWise is a comprehensive web application designed to help users with brain health monitoring, stroke prediction, and cognitive enhancement through health tracking, personalized goals, and educational resources.
+
+## 🧠 Features
+
+- **Health Metrics Tracking**: Monitor vital signs and health indicators that affect brain health
+- **Stroke Risk Prediction**: AI-powered stroke risk assessment using machine learning models
+- **Brain Scan Analysis**: Detect brain tumors and Alzheimer's disease from MRI scans
+- **Research & Studies**: Access to latest peer-reviewed research on brain health and stroke prevention
+- **Educational Resources**: Curated guides and video content from trusted sources
+- **Cognitive Training Tools**: Interactive exercises for brain health improvement
+- **Data Visualization**: View your progress through interactive charts and visualizations
+
+## 🚀 Getting Started
+
+### Prerequisites
+
+- Node.js 18+ 
+- npm or yarn
+- MongoDB instance (local or Atlas)
+- Uploadcare account (for image handling)
+- Hugging Face account (for ML model hosting)
+
+### Installation
+
+1. Clone the repository
+   ```bash
+   git clone https://github.com/AbdullahSaeed1211/brainwise.git
+   cd brainwise
+   ```
+
+2. Install dependencies
+   ```bash
+   npm install
+   # or
+   yarn install
+   ```
+
+3. Set up environment variables
+   ```
+   # Create a .env.local file with the following variables
+   MONGODB_URI=your_mongodb_connection_string
+   NEXT_PUBLIC_UPLOADCARE_PUBLIC_KEY=your_uploadcare_public_key
+   UPLOADCARE_SECRET_KEY=your_uploadcare_secret_key
+   SEMANTIC_SCHOLAR_API_KEY=your_api_key
+   ```
+
+4. Run the development server
+   ```bash
+   npm run dev
+   # or
+   yarn dev
+   ```
+
+5. Open [http://localhost:3000](http://localhost:3000) in your browser
+
+## 📚 Documentation
+
+Detailed documentation can be found in the `/docs` directory:
+
+- [Architecture Overview](docs/architecture-overview.md)
+- [Authentication System](docs/authentication-system.md)
+- [Health Metrics System](docs/health-metrics-system.md)
+- [ML Model Hosting](docs/ml-hosting-architecture.md)
+- [Brain Scan Analysis](docs/ml-hosting-guide.md)
+- [Data Visualization](docs/data-visualization.md)
+- [Research Integration](docs/research-integration.md)
+
+## 🧩 Project Structure
+
+```
+brainwise/
+├── app/                  # Next.js 14 App Router pages & API routes
+│   ├── api/             # API routes for ML models and data
+│   ├���─ predictors/      # Brain scan analysis tools (tumor, alzheimers)
+│   ├── research/        # Research papers and studies
+│   ├── tools/           # Brain health tools and assessments
+│   └── dashboard/       # User dashboard and metrics
+├── components/          # React components
+│   ├── ui/             # Shadcn UI components
+│   ├── charts/         # Data visualization components
+│   └── forms/          # Form components
+├── lib/                 # Utility functions and shared logic
+├── public/              # Static assets
+├── types/               # TypeScript type definitions
+└── docs/                # Documentation
+```
+
+## 🔧 Technology Stack
+
+- **Frontend**: Next.js 14, React, TypeScript, Tailwind CSS, Shadcn UI
+- **Backend**: Next.js API Routes, MongoDB
+- **Machine Learning**: Hugging Face Spaces, TensorFlow.js
+- **Image Handling**: Uploadcare CDN
+- **Research API**: Semantic Scholar API
+- **Visualization**: Recharts, Framer Motion
+- **Authentication**: Custom auth (with plans to migrate to Clerk)
+
+## 🌱 Development Roadmap
+
+- [x] Health metrics tracking system
+- [x] Stroke risk prediction model
+- [x] Brain tumor detection model
+- [x] Alzheimer's detection model
+- [x] Research paper integration
+- [x] Educational resources
+- [x] Cognitive training tools
+- [ ] Advanced data analytics dashboard
+- [ ] Mobile optimization
+- [ ] Newsletter system
+
+## 🔒 Security & Privacy
+
+BrainWise prioritizes the security and privacy of health data:
+
+- All health data is associated with user IDs
+- Authentication required for all sensitive operations
+- Medical images are securely stored using Uploadcare's HIPAA-compliant storage
+- No third-party access to health information
+- HIPAA-informed practices for handling sensitive data
+- Secure API key management
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 📱 Contact
+
+Project Link: [https://github.com/AbdullahSaeed1211/brainwise](https://github.com/AbdullahSaeed1211/brainwise)
+
+## 🙏 Acknowledgements
+
+- [Next.js](https://nextjs.org/)
+- [Tailwind CSS](https://tailwindcss.com/)
+- [Shadcn UI](https://ui.shadcn.com/)
+- [Uploadcare](https://uploadcare.com/)
+- [Hugging Face](https://huggingface.co/)
+- [Recharts](https://recharts.org/)
+- [Semantic Scholar](https://www.semanticscholar.org/)
+- [TensorFlow.js](https://www.tensorflow.org/js)

app.py

@@ -1,183 +1,433 @@
-
-import joblib
-import pandas as pd
+import gradio as gr
 import numpy as np
-from fastapi import FastAPI, Form, Request
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional
+import pandas as pd
 import time
+import random
 import os
+import joblib
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.preprocessing import StandardScaler
+from fastapi import FastAPI, Query
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any, Union
 
-# Load model
-print("Loading Parkinson's Disease detection model...")
-model_path = "/app/model.joblib"
-print(f"Model file exists: {os.path.exists(model_path)}")
-print(f"Model file size: {os.path.getsize(model_path) / 1024:.2f} KB")
-
-try:
-    model_package = joblib.load(model_path)
-    print("Model loaded successfully!")
-    model = model_package['model']
-    scaler = model_package['scaler']
-    feature_names = model_package['feature_names']
-    print(f"Model details: Type: {type(model)}")
-    print(f"Number of features: {len(feature_names)}")
-except Exception as e:
-    print(f"Error loading model: {e}")
-    model_package = None
-
-# Create FastAPI app
-app = FastAPI(title="Parkinson's Disease Detection API")
+# Define model paths - try both Hugging Face and local paths
+hf_model_path = "/app/model.joblib"
+local_model_path = "model.joblib"
+current_dir_model_path = "./model.joblib"
+relative_model_path = "hf-spaces/parkinsons-model/model.joblib"
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+print("Loading Parkinson's disease prediction model...")
+# Try to load the model from various paths
+for path in [hf_model_path, local_model_path, current_dir_model_path, relative_model_path]:
+    try:
+        if os.path.exists(path):
+            print(f"Found model at: {path}")
+            model_package = joblib.load(path)
+            model = model_package['model']
+            scaler = model_package['scaler']
+            feature_names = model_package.get('feature_names', [])
+            
+            # Check if it's our model or the UCI Parkinson's dataset model
+            is_uci_model = len(feature_names) > 0 and 'MDVP:Fo(Hz)' in feature_names[0]
+            
+            if is_uci_model:
+                print("Loaded UCI Parkinson's dataset model.")
+            else:
+                print("Loaded custom Parkinson's risk model.")
+                
+            using_trained_model = True
+            print("Pre-trained model loaded successfully!")
+            break
+    except Exception as e:
+        print(f"Could not load model from {path}: {e}")
+else:
+    # No model found, create a fallback
+    print("No model found. Creating fallback model.")
+    model = RandomForestClassifier(n_estimators=100, random_state=42)
+    using_trained_model = False
+    
+    # Generate mock data for training
+    np.random.seed(42)
+    
+    # Generate synthetic data
+    X_mock = pd.DataFrame({
+        'age': np.random.uniform(40, 85, 500),
+        'tremor': np.random.choice([0, 1], size=500, p=[0.3, 0.7]),
+        'stiffness': np.random.choice([0, 1], size=500, p=[0.4, 0.6]),
+        'balance_problems': np.random.choice([0, 1], size=500, p=[0.5, 0.5]),
+        'slow_movement': np.random.choice([0, 1], size=500, p=[0.4, 0.6]),
+        'sleep_issues': np.random.choice([0, 1], size=500, p=[0.7, 0.3]),
+        'tremor_severity': np.random.uniform(0, 10, 500),
+        'family_history': np.random.choice([0, 1], size=500, p=[0.8, 0.2]),
+        'symptom_duration': np.random.uniform(0, 60, 500),
+        'gender_Male': np.random.choice([0, 1], size=500)
+    })
+    
+    # Create a simple rule-based target
+    prob = (X_mock['age'] > 70).astype(int) * 0.2 + \
+           X_mock['tremor'] * 0.2 + \
+           X_mock['stiffness'] * 0.15 + \
+           X_mock['balance_problems'] * 0.1 + \
+           X_mock['slow_movement'] * 0.2 + \
+           X_mock['gender_Male'] * 0.05 + \
+           X_mock['family_history'] * 0.1 + \
+           (X_mock['symptom_duration'] > 24).astype(int) * 0.1
+    
+    y_mock = (prob > 0.5).astype(int)
+    
+    # Fit the model
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X_mock)
+    model.fit(X_scaled, y_mock)
+    feature_names = X_mock.columns.tolist()
 
-# Define a class for the request body
-class ParkinsonsInput(BaseModel):
-    fo_hz: float
-    fhi_hz: float
-    flo_hz: float
-    jitter_percent: float
-    jitter_abs: float
-    rap: float
-    ppq: float
-    ddp: float
-    shimmer: float
-    shimmer_db: float
-    apq3: float
-    apq5: float
-    apq: float
-    dda: float
-    nhr: float
-    hnr: float
-    rpde: float
-    dfa: float
-    spread1: float
-    spread2: float
-    d2: float
-    ppe: float
-
-@app.post("/api/predict")
-async def predict_parkinsons(
-    fo_hz: Optional[float] = Form(None), 
-    fhi_hz: Optional[float] = Form(None),
-    flo_hz: Optional[float] = Form(None),
-    jitter_percent: Optional[float] = Form(None),
-    jitter_abs: Optional[float] = Form(None),
-    rap: Optional[float] = Form(None),
-    ppq: Optional[float] = Form(None),
-    ddp: Optional[float] = Form(None),
-    shimmer: Optional[float] = Form(None),
-    shimmer_db: Optional[float] = Form(None),
-    apq3: Optional[float] = Form(None),
-    apq5: Optional[float] = Form(None),
-    apq: Optional[float] = Form(None),
-    dda: Optional[float] = Form(None),
-    nhr: Optional[float] = Form(None),
-    hnr: Optional[float] = Form(None),
-    rpde: Optional[float] = Form(None),
-    dfa: Optional[float] = Form(None),
-    spread1: Optional[float] = Form(None),
-    spread2: Optional[float] = Form(None),
-    d2: Optional[float] = Form(None),
-    ppe: Optional[float] = Form(None)
-):
-    start_time = time.time()
+print("Model loaded successfully!")
+
+def calculate_risk_factors(data):
+    risk_factors = []
     
-    # Create a dictionary from the input parameters
-    input_data = {
-        'MDVP:Fo(Hz)': fo_hz or 119.992,
-        'MDVP:Fhi(Hz)': fhi_hz or 157.302,
-        'MDVP:Flo(Hz)': flo_hz or 74.997,
-        'MDVP:Jitter(%)': jitter_percent or 0.00784,
-        'MDVP:Jitter(Abs)': jitter_abs or 0.00007,
-        'MDVP:RAP': rap or 0.00370,
-        'MDVP:PPQ': ppq or 0.00554,
-        'Jitter:DDP': ddp or 0.01109,
-        'MDVP:Shimmer': shimmer or 0.04374,
-        'MDVP:Shimmer(dB)': shimmer_db or 0.426,
-        'Shimmer:APQ3': apq3 or 0.02182,
-        'Shimmer:APQ5': apq5 or 0.02971,
-        'MDVP:APQ': apq or 0.02971,
-        'Shimmer:DDA': dda or 0.06545,
-        'NHR': nhr or 0.02211,
-        'HNR': hnr or 21.033,
-        'RPDE': rpde or 0.414783,
-        'DFA': dfa or 0.815285,
-        'spread1': spread1 or -4.813031,
-        'spread2': spread2 or 0.266482,
-        'D2': d2 or 2.301442,
-        'PPE': ppe or 0.284654
+    # Age is a risk factor
+    if data['age'] > 80:
+        risk_factors.append("Advanced age (80+)")
+    elif data['age'] > 65:
+        risk_factors.append("Senior age (65+)")
+    elif data['age'] > 55:
+        risk_factors.append("Higher age risk (55+)")
+    
+    # Symptoms
+    if data['tremor'] == 1:
+        risk_factors.append("Presence of tremor")
+        
+        if data['tremor_severity'] > 7:
+            risk_factors.append("Severe tremor")
+        elif data['tremor_severity'] > 4:
+            risk_factors.append("Moderate tremor")
+        
+        if data['tremor_frequency'] == "constant":
+            risk_factors.append("Constant tremor")
+        elif data['tremor_frequency'] == "frequent":
+            risk_factors.append("Frequent tremor")
+    
+    if data['stiffness'] == 1:
+        risk_factors.append("Muscle stiffness")
+    
+    if data['balance_problems'] == 1:
+        risk_factors.append("Balance problems")
+    
+    if data['slow_movement'] == 1:
+        risk_factors.append("Slowness of movement (bradykinesia)")
+    
+    if data.get('sleep_issues', 0) == 1:
+        risk_factors.append("Sleep disturbances")
+    
+    # Family history
+    if data['family_history'] == 1:
+        risk_factors.append("Family history of Parkinson's disease")
+    
+    # Symptom duration
+    if data['symptom_duration'] > 36:
+        risk_factors.append("Long-standing symptoms (3+ years)")
+    elif data['symptom_duration'] > 12:
+        risk_factors.append("Sustained symptoms (1+ year)")
+    
+    # Gender factor
+    if data['gender'] == "Male":
+        risk_factors.append("Male gender (higher risk)")
+    
+    return risk_factors
+
+def process_input_data(data):
+    # Create a feature vector from the input data
+    X_test = {
+        'age': float(data['age']),
+        'tremor': int(data['tremor']),
+        'stiffness': int(data['stiffness']),
+        'balance_problems': int(data['balance_problems']),
+        'slow_movement': int(data['slow_movement']),
+        'sleep_issues': int(data.get('sleep_issues', 0)),
+        'tremor_severity': float(data['tremor_severity']),
+        'family_history': int(data['family_history']),
+        'symptom_duration': float(data['symptom_duration']),
+        'gender_Male': 1 if data['gender'] == 'Male' else 0
     }
     
-    print("Received data:", input_data)
+    # Convert to DataFrame for easy processing
+    X_test_df = pd.DataFrame([X_test])
+    
+    # Scale the test data (use the appropriate scaler)
+    X_test_scaled = scaler.transform(X_test_df)
     
     try:
-        if model_package is None:
-            raise ValueError("Model not loaded")
-        
-        # Convert to DataFrame and ensure column order
-        input_df = pd.DataFrame([input_data])
-        input_df = input_df[feature_names]  # Reorder columns to match training data
-        
-        # Standardize the input data
-        input_scaled = scaler.transform(input_df)
-        
-        # Make prediction
-        prediction = model.predict(input_scaled)[0]
-        prediction_proba = model.predict_proba(input_scaled)[0]
-        
-        # Interpretation
-        result = {
-            "prediction": int(prediction),
-            "prediction_label": "Parkinson's Disease" if prediction == 1 else "Healthy",
-            "confidence": float(prediction_proba[int(prediction)]),
-            "using_model": True,
-            "execution_time_ms": (time.time() - start_time) * 1000,
-            "model_type": "SVM"
-        }
+        # Get model predictions
+        prediction_proba = model.predict_proba(X_test_scaled)[0][1]
+        prediction_class = int(prediction_proba > 0.5)
         
+        # Determine risk level
+        if prediction_proba > 0.6:
+            risk_level = "High Risk"
+        elif prediction_proba > 0.3:
+            risk_level = "Moderate Risk"
+        else:
+            risk_level = "Low Risk"
     except Exception as e:
-        print("Error in prediction:", e)
-        
-        # Fallback calculation - basic rule-based
-        # Higher shimmer and jitter values, low HNR often indicate Parkinson's
-        high_jitter = input_data['MDVP:Jitter(%)'] > 0.008
-        high_shimmer = input_data['MDVP:Shimmer'] > 0.05
-        low_hnr = input_data['HNR'] < 20
+        print(f"Error in prediction: {e}")
+        # Fallback to a simple calculation if the model fails
+        risk_score = sum([
+            1 if data['age'] > 70 else 0,
+            1 if data['tremor'] == 1 else 0,
+            1 if data['stiffness'] == 1 else 0,
+            1 if data['balance_problems'] == 1 else 0,
+            1 if data['slow_movement'] == 1 else 0,
+            1 if data['tremor_severity'] > 5 else 0,
+            1 if data['family_history'] == 1 else 0,
+            1 if data['symptom_duration'] > 12 else 0
+        ])
         
-        # Count risk factors
-        risk_factors = sum([high_jitter, high_shimmer, low_hnr])
+        prediction_proba = min(0.1 * risk_score, 0.95)
+        prediction_class = 1 if risk_score >= 4 else 0
         
-        # Simple fallback prediction
-        fallback_prediction = 1 if risk_factors >= 2 else 0
-        fallback_confidence = 0.5 + (risk_factors * 0.1)  # Simple scaling
+        if risk_score >= 5:
+            risk_level = "High Risk"
+        elif risk_score >= 3:
+            risk_level = "Moderate Risk"
+        else:
+            risk_level = "Low Risk"
+    
+    # Calculate risk factors
+    risk_factors = calculate_risk_factors(data)
+    
+    return {
+        "probability": float(prediction_proba),
+        "prediction": risk_level,
+        "parkinsons_prediction": prediction_class,
+        "using_model": using_trained_model,  # Show whether we're using the trained model or mock
+        "risk_factors": risk_factors,
+        "execution_time_ms": int(random.uniform(50, 200)),
+        "model_version": "parkinsons-v1" if using_trained_model else "mock-model-v1"
+    }
+
+def predict_parkinsons(gender, age, tremor, stiffness, balance_problems, slow_movement, 
+                        sleep_issues, tremor_severity, tremor_frequency, family_history, 
+                        symptom_duration):
+    # Simulate processing time
+    start_time = time.time()
+    
+    # Format the input data
+    input_data = {
+        "gender": gender,
+        "age": age,
+        "tremor": 1 if tremor else 0,
+        "stiffness": 1 if stiffness else 0,
+        "balance_problems": 1 if balance_problems else 0,
+        "slow_movement": 1 if slow_movement else 0,
+        "sleep_issues": 1 if sleep_issues else 0,
+        "tremor_severity": tremor_severity,
+        "tremor_frequency": tremor_frequency,
+        "family_history": 1 if family_history else 0,
+        "symptom_duration": symptom_duration
+    }
+    
+    # Process the data and get predictions
+    result = process_input_data(input_data)
+    
+    # Update execution time
+    execution_time = (time.time() - start_time) * 1000
+    result["execution_time_ms"] = int(execution_time)
+    
+    return result
+
+def api_predict(
+    gender, 
+    age, 
+    tremor=0, 
+    stiffness=0, 
+    balance_problems=0, 
+    slow_movement=0, 
+    sleep_issues=0, 
+    tremor_severity=0, 
+    tremor_frequency="none", 
+    family_history=0, 
+    symptom_duration=0
+):
+    # Convert string values to appropriate types
+    if isinstance(tremor, str):
+        tremor = int(tremor)
+    if isinstance(stiffness, str):
+        stiffness = int(stiffness)
+    if isinstance(balance_problems, str):
+        balance_problems = int(balance_problems)
+    if isinstance(slow_movement, str):
+        slow_movement = int(slow_movement)
+    if isinstance(sleep_issues, str):
+        sleep_issues = int(sleep_issues)
+    if isinstance(family_history, str):
+        family_history = int(family_history)
+    if isinstance(age, str):
+        age = float(age)
+    if isinstance(tremor_severity, str):
+        tremor_severity = float(tremor_severity)
+    if isinstance(symptom_duration, str):
+        symptom_duration = float(symptom_duration)
+    
+    result = predict_parkinsons(
+        gender, 
+        age, 
+        bool(tremor), 
+        bool(stiffness), 
+        bool(balance_problems), 
+        bool(slow_movement), 
+        bool(sleep_issues), 
+        tremor_severity, 
+        tremor_frequency, 
+        bool(family_history), 
+        symptom_duration
+    )
+    
+    return result
+
+# Create Gradio interface
+with gr.Blocks(title="Parkinson's Disease Prediction") as demo:
+    gr.Markdown("# Parkinson's Disease Risk Prediction")
+    gr.Markdown("Fill in the details below to assess Parkinson's disease risk factors.")
+    
+    with gr.Row():
+        with gr.Column():
+            gender = gr.Radio(["Male", "Female"], label="Gender")
+            age = gr.Slider(30, 95, value=65, label="Age")
+            tremor = gr.Checkbox(label="Resting Tremor")
+            stiffness = gr.Checkbox(label="Muscle Stiffness")
+            balance_problems = gr.Checkbox(label="Balance Problems")
+            slow_movement = gr.Checkbox(label="Slowness of Movement (Bradykinesia)")
+            sleep_issues = gr.Checkbox(label="Sleep Disturbances")
+            tremor_severity = gr.Slider(0, 10, value=0, label="Tremor Severity (0-10)")
+            tremor_frequency = gr.Dropdown(
+                ["none", "rare", "occasional", "frequent", "constant"], 
+                label="Tremor Frequency",
+                value="none"
+            )
+            family_history = gr.Checkbox(label="Family History of Parkinson's")
+            symptom_duration = gr.Slider(0, 60, value=0, label="Symptom Duration (months)")
+            
+            submit_btn = gr.Button("Predict Risk")
         
-        result = {
-            "prediction": fallback_prediction,
-            "prediction_label": "Parkinson's Disease" if fallback_prediction == 1 else "Healthy",
-            "confidence": float(fallback_confidence),
-            "using_model": False,
-            "execution_time_ms": (time.time() - start_time) * 1000,
-            "model_type": "Fallback"
-        }
-    
-    print("Prediction result:", result)
+        with gr.Column():
+            output = gr.JSON(label="Prediction Results")
+            
+            with gr.Accordion("Model Info", open=True):
+                gr.Markdown(f"""
+                ## Model Information
+                
+                - Model status: {"Using trained model" if using_trained_model else "Using fallback model"}
+                - Model type: {type(model).__name__}
+                """)
+            
+            with gr.Accordion("API Information", open=False):
+                gr.Markdown("""
+                ## API Usage
+                
+                This model can be accessed via API at `/api/predict` with the following parameters:
+                
+                - `gender`: "Male" or "Female"
+                - `age`: Numerical age in years
+                - `tremor`: 0 or 1 
+                - `stiffness`: 0 or 1
+                - `balance_problems`: 0 or 1
+                - `slow_movement`: 0 or 1
+                - `sleep_issues`: 0 or 1
+                - `tremor_severity`: 0-10
+                - `tremor_frequency`: "none", "rare", "occasional", "frequent", or "constant"
+                - `family_history`: 0 or 1
+                - `symptom_duration`: Duration in months
+                """)
+    
+    submit_btn.click(
+        predict_parkinsons,
+        inputs=[
+            gender, age, tremor, stiffness, balance_problems, slow_movement, 
+            sleep_issues, tremor_severity, tremor_frequency, family_history, 
+            symptom_duration
+        ],
+        outputs=output
+    )
+
+# Mount the API endpoint
+demo.queue()
+app = gr.mount_gradio_app(app=gr.routes.App(), blocks=demo, path="/")
+
+# Create a FastAPI app
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+# Initialize FastAPI
+fastapi_app = FastAPI(title="Parkinson's Disease Prediction API")
+
+# Add CORS middleware
+fastapi_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Define the request model
+class PredictionRequest(BaseModel):
+    gender: str
+    age: float
+    tremor: int = 0
+    stiffness: int = 0
+    balance_problems: int = 0
+    slow_movement: int = 0
+    sleep_issues: int = 0
+    tremor_severity: float = 0
+    tremor_frequency: str = "none"
+    family_history: int = 0
+    symptom_duration: float = 0
+
+# Define the response model
+class PredictionResponse(BaseModel):
+    probability: float
+    prediction: str
+    parkinsons_prediction: int
+    using_model: bool
+    risk_factors: List[str]
+    execution_time_ms: int
+    model_version: str
+
+@fastapi_app.get("/api/predict", response_model=PredictionResponse)
+async def predict_get(
+    gender: str = Query(..., description="Gender ('Male' or 'Female')"),
+    age: float = Query(..., description="Age in years"),
+    tremor: int = Query(0, description="Presence of tremor (0 or 1)"),
+    stiffness: int = Query(0, description="Muscle stiffness (0 or 1)"),
+    balance_problems: int = Query(0, description="Balance problems (0 or 1)"),
+    slow_movement: int = Query(0, description="Slowness of movement (0 or 1)"),
+    sleep_issues: int = Query(0, description="Sleep disturbances (0 or 1)"),
+    tremor_severity: float = Query(0, description="Tremor severity (0-10)"),
+    tremor_frequency: str = Query("none", description="Tremor frequency"),
+    family_history: int = Query(0, description="Family history of Parkinson's (0 or 1)"),
+    symptom_duration: float = Query(0, description="Symptom duration in months")
+):
+    result = api_predict(
+        gender, age, tremor, stiffness, balance_problems, slow_movement,
+        sleep_issues, tremor_severity, tremor_frequency, family_history, symptom_duration
+    )
+    return result
+
+@fastapi_app.post("/api/predict", response_model=PredictionResponse)
+async def predict_post(request: PredictionRequest):
+    result = api_predict(
+        request.gender, request.age, request.tremor, request.stiffness,
+        request.balance_problems, request.slow_movement, request.sleep_issues,
+        request.tremor_severity, request.tremor_frequency, request.family_history,
+        request.symptom_duration
+    )
     return result
 
-@app.get("/")
-async def root():
-    return {"message": "Parkinson's Disease Detection API is running! Use /api/predict endpoint for predictions."}
+# Mount the FastAPI app
+app.mount("/", fastapi_app)
 
-# Run the application
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

model.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c15fdacbe8fc951161076e34f2d70b66cfa29a1f115351d211da32eb8eadc7d1
+oid sha256:9b339816fef395f170b7a359a41222f73461fcb352a7b84f05c7e096a0aafa55
 size 18791