Parkinson's Detection

AI-Powered Voice Analysis

Initializing...

Advanced Parkinson's Disease Detection

Leverage cutting-edge machine learning to analyze voice measurements and detect early signs of Parkinson's disease with remarkable accuracy.

94.9%

Accuracy

ML Models

Features

Upload Voice Data

Upload your CSV file containing voice measurement data for analysis

Drop your CSV file here

or click to browse files

CSV format required Voice measurement data Secure processing

Model Performance

Our ensemble of machine learning models provides robust and accurate predictions

Loading model information...

Why Choose Our Platform?

Secure & Private

Your data is processed securely and never stored permanently

Lightning Fast

Get results in seconds with our optimized ML pipeline

Detailed Analysis

Comprehensive results with confidence scores and explanations

Mobile Friendly

Works perfectly on desktop, tablet, and mobile devices

How Our AI Models Work

Explore the machine learning algorithms powering our Parkinson's detection system

LogisticRegression.py

RandomForest.py

SupportVectorMachine.py

/models/LogisticRegression.py

83.3% Accuracy Linear Model

How it works (Simple)

Logistic Regression is like a smart decision-making calculator. It looks at voice measurements and draws a line to separate healthy voices from those showing Parkinson's symptoms. Think of it as finding the best boundary line to distinguish between two groups of data points.

Technical Implementation

1. Algorithm Overview

# Logistic Regression uses the sigmoid function to map any input to (0,1)
# P(y=1|x) = 1 / (1 + e^(-(β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ)))

def logistic_regression_predict(features, weights, bias):
    """
    Predict Parkinson's probability using logistic regression
    """
    # Linear combination of features
    linear_output = bias + sum(w * f for w, f in zip(weights, features))
    
    # Apply sigmoid function
    probability = 1 / (1 + exp(-linear_output))
    
    # Classification threshold at 0.5
    prediction = 1 if probability > 0.5 else 0
    return prediction, probability

2. Feature Preprocessing

# Standardize features for optimal logistic regression performance
from sklearn.preprocessing import StandardScaler

def preprocess_features(voice_data):
    """
    Normalize voice measurements for logistic regression
    """
    scaler = StandardScaler()
    
    # Key features: jitter, shimmer, fundamental frequency, etc.
    features = voice_data[['MDVP:Jitter(%)', 'MDVP:Shimmer', 
                          'NHR', 'HNR', 'RPDE', 'DFA', 'PPE']]
    
    # Standardize: mean=0, std=1
    normalized_features = scaler.fit_transform(features)
    
    return normalized_features

3. Model Training

# Scikit-learn implementation with cross-validation
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

def train_logistic_model(X_train, y_train):
    """
    Train logistic regression with optimal parameters
    """
    # Initialize with regularization to prevent overfitting
    model = LogisticRegression(
        C=1.0,              # Regularization strength
        solver='liblinear',  # Optimization algorithm
        random_state=42,
        max_iter=1000
    )
    
    # Train the model
    model.fit(X_train, y_train)
    
    # Cross-validation for performance estimation
    cv_scores = cross_val_score(model, X_train, y_train, 
                               cv=5, scoring='accuracy')
    
    print(f"CV Accuracy: {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")
    
    return model

Performance Characteristics:

Speed: Very fast training and prediction
Interpretability: Excellent - coefficients show feature importance
Memory: Low memory footprint
Best for: Linear relationships, baseline comparisons

/models/RandomForest.py

91.7% Accuracy Ensemble Model

How it works (Simple)

Random Forest is like consulting a panel of expert doctors. It creates many decision trees (like different doctors' opinions) and combines their votes to make the final diagnosis. Each tree looks at different aspects of the voice data, making the overall decision more reliable and accurate.

Technical Implementation

1. Algorithm Overview

# Random Forest builds multiple decision trees with randomness
def random_forest_predict(features, trees):
    """
    Ensemble prediction from multiple decision trees
    """
    predictions = []
    
    # Get prediction from each tree
    for tree in trees:
        tree_prediction = tree.predict(features)
        predictions.append(tree_prediction)
    
    # Majority voting for final decision
    positive_votes = sum(predictions)
    total_votes = len(predictions)
    
    # Probability is the proportion of positive votes
    probability = positive_votes / total_votes
    final_prediction = 1 if probability > 0.5 else 0
    
    return final_prediction, probability

2. Feature Selection & Importance

# Random Forest automatically ranks feature importance
def analyze_feature_importance(model, feature_names):
    """
    Extract most important voice features for Parkinson's detection
    """
    # Get feature importances from trained model
    importances = model.feature_importances_
    
    # Create importance ranking
    feature_importance = list(zip(feature_names, importances))
    feature_importance.sort(key=lambda x: x[1], reverse=True)
    
    # Top features for our Parkinson's detection
    print("Most Important Voice Features:")
    for feature, importance in feature_importance[:5]:
        print(f"{feature}: {importance:.4f}")
    
    return feature_importance

# Typical results show: PPE, spread1, MDVP:Fo(Hz) as top features

3. Model Training

# Scikit-learn Random Forest with optimized parameters
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

def train_random_forest(X_train, y_train):
    """
    Train Random Forest with hyperparameter tuning
    """
    # Base model configuration
    rf = RandomForestClassifier(
        n_estimators=100,    # Number of trees
        max_depth=10,        # Maximum tree depth
        min_samples_split=5, # Minimum samples to split
        min_samples_leaf=2,  # Minimum samples per leaf
        random_state=42,
        n_jobs=-1           # Use all CPU cores
    )
    
    # Optional: Hyperparameter tuning
    param_grid = {
        'n_estimators': [50, 100, 200],
        'max_depth': [5, 10, None],
        'min_samples_split': [2, 5, 10]
    }
    
    # Grid search for best parameters
    grid_search = GridSearchCV(rf, param_grid, cv=5, 
                              scoring='accuracy', n_jobs=-1)
    grid_search.fit(X_train, y_train)
    
    return grid_search.best_estimator_

Performance Characteristics:

Accuracy: Highest among our models (91.7%)
Robustness: Handles outliers and noise well
Feature Selection: Built-in importance ranking
Best for: Complex patterns, high accuracy requirements

/models/SupportVectorMachine.py

87.2% Accuracy Kernel-based Model

How it works (Simple)

Support Vector Machine (SVM) is like finding the best fence between two neighborhoods. It draws the optimal boundary that separates healthy voices from Parkinson's voices with the maximum safety margin. It can even handle curved boundaries using mathematical tricks called kernels.

Technical Implementation

1. Algorithm Overview

# SVM finds the optimal hyperplane with maximum margin
def svm_decision_function(features, support_vectors, alphas, kernel='rbf'):
    """
    SVM decision function using kernel trick
    """
    decision_value = 0
    
    # Sum over all support vectors
    for i, sv in enumerate(support_vectors):
        # Apply kernel function (RBF in our case)
        kernel_value = rbf_kernel(features, sv, gamma=0.1)
        decision_value += alphas[i] * kernel_value
    
    # Add bias term
    decision_value += bias
    
    # Convert to probability using Platt scaling
    probability = 1 / (1 + exp(-decision_value))
    prediction = 1 if decision_value > 0 else 0
    
    return prediction, probability

def rbf_kernel(x1, x2, gamma):
    """Radial Basis Function kernel"""
    return exp(-gamma * np.sum((x1 - x2) ** 2))

2. Feature Scaling (Critical for SVM)

# SVM requires careful feature scaling for optimal performance
from sklearn.preprocessing import StandardScaler

def prepare_svm_features(voice_data):
    """
    Prepare features specifically for SVM classifier
    """
    # SVM is sensitive to feature scales - must normalize
    scaler = StandardScaler()
    
    # Select voice features with high discriminative power
    feature_columns = [
        'MDVP:Jitter(%)', 'MDVP:Shimmer', 'NHR', 'HNR',
        'RPDE', 'DFA', 'spread1', 'spread2', 'D2', 'PPE'
    ]
    
    features = voice_data[feature_columns]
    
    # Critical: Scale to mean=0, std=1
    scaled_features = scaler.fit_transform(features)
    
    print(f"Feature scaling completed: {scaled_features.shape}")
    return scaled_features, scaler

3. Model Training with RBF Kernel

# Scikit-learn SVM with RBF kernel optimization
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV

def train_svm_model(X_train, y_train):
    """
    Train SVM with optimized hyperparameters
    """
    # SVM with RBF kernel for non-linear decision boundaries
    svm = SVC(
        kernel='rbf',           # Radial Basis Function kernel
        C=1.0,                 # Regularization parameter
        gamma='scale',         # Kernel coefficient
        probability=True,      # Enable probability estimates
        random_state=42
    )
    
    # Hyperparameter tuning for optimal performance
    param_grid = {
        'C': [0.1, 1, 10, 100],         # Regularization strength
        'gamma': ['scale', 'auto', 0.01, 0.1, 1]  # Kernel parameter
    }
    
    # Grid search with cross-validation
    grid_search = GridSearchCV(
        svm, param_grid, cv=5, 
        scoring='accuracy', n_jobs=-1
    )
    
    # Train with best parameters
    grid_search.fit(X_train, y_train)
    
    best_svm = grid_search.best_estimator_
    print(f"Best parameters: {grid_search.best_params_}")
    
    return best_svm

Performance Characteristics:

Boundary Complexity: Handles non-linear patterns excellently
Precision: High precision with proper tuning
Memory Efficiency: Only stores support vectors
Best for: Complex decision boundaries, high-precision needs

Advanced Parkinson's Disease Detection

Upload Voice Data

Drop your CSV file here

Analysis Results

Model Performance

Why Choose Our Platform?

Secure & Private

Lightning Fast

Detailed Analysis

Mobile Friendly

How Our AI Models Work

How it works (Simple)

Technical Implementation

1. Algorithm Overview

2. Feature Preprocessing

3. Model Training

How it works (Simple)

Technical Implementation

1. Algorithm Overview

2. Feature Selection & Importance

3. Model Training

How it works (Simple)

Technical Implementation

1. Algorithm Overview

2. Feature Scaling (Critical for SVM)

3. Model Training with RBF Kernel

Processing Your Data

Analysis Complete!

Analysis Error