Machine Learning Algorithms

Overview

This is the most important Wiki section for explaining your AI model.

VoxShield uses supervised machine learning for binary classification.

The primary candidate algorithms are:

1. Random Forest Classifier
2. Gradient Boosting Classifier

The final deployed classifier should be documented based on the actual training results.

Do not claim that one algorithm is superior until your evaluation confirms it.

Supervised Learning

Definition

Supervised learning trains a model using examples containing both input data and corresponding labels.

For VoxShield:

Audio Features → Label

Example:

[0.21, 0.45, 0.67, ...] → REAL
[0.82, 0.31, 0.95, ...] → FAKE

The model learns patterns in the training dataset and uses them to predict the label of previously unseen audio samples.

Classification Task VoxShield performs binary classification:

Class 0 → REAL
Class 1 → FAKE

The exact label encoding should match the implementation.

---

Random Forest Classifier

Overview

Random Forest is an ensemble learning algorithm that combines multiple decision trees.

Instead of relying on one decision tree, it trains multiple trees using randomized training samples and feature selection.

The final prediction is obtained by combining the outputs of the trees.

Reference: Scikit-learn Random Forest documentation

How Random Forest Works

Step 1: Bootstrap Sampling

Random Forest creates different training subsets through sampling with replacement. Each tree receives a different sample of the training data.

Step 2: Decision Tree Construction

Each tree learns decision rules based on the input features. Example:

Is MFCC_12 < threshold?
        |
        +-- Yes → Continue to another decision
        |
        +-- No  → Continue to another decision

These are illustrative decision rules, not actual rules learned by VoxShield.

Step 3: Random Feature Selection

At each split, the algorithm considers a subset of features.

This introduces diversity among the trees.

Step 4: Ensemble Prediction

Each tree produces a prediction.

The ensemble combines the trees' outputs to determine the final classification.

Why Random Forest for VoxShield?

Potential advantages:

• Works with tabular numerical features.
• Can model nonlinear relationships.
• Requires relatively little feature scaling for tree-based splits.
• Provides feature importance estimates.
• Suitable for an initial classical ML implementation.

Limitations

• Feature importance does not establish causation.
• Trees can overfit, especially with unsuitable parameters.
• Performance depends on the training dataset and feature quality.
• It does not automatically learn robust voice-cloning representations from raw audio.

Example Implementation

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(
    n_estimators=200,
    random_state=42,
    class_weight="balanced"
)

model.fit(X_train, y_train)

Note: Parameters above are an example configuration. Your Wiki should reflect the actual training script.

---

Gradient Boosting Classifier

Overview

Gradient Boosting is an ensemble learning algorithm that builds models sequentially.

Each new tree attempts to improve the combined model by addressing errors from earlier stages.

Unlike Random Forest, which generally trains trees independently, Gradient Boosting builds an additive model in stages.

Reference: Scikit-learn Gradient Boosting documentation

How Gradient Boosting Works

Step 1: Initial Prediction

The algorithm starts with an initial prediction.

Step 2: Identify Prediction Errors

The model evaluates how well its predictions match the training labels.

Step 3: Train a New Tree

A new tree is trained to improve the current model's performance.

Step 4: Update the Combined Model

The new tree contributes to the overall prediction.

This process repeats for a specified number of estimators.

Initial Model
     |
     v
Tree 1
     |
     v
Tree 2 → Corrects previous errors
     |
     v
Tree 3 → Further improves predictions
     |
     v
Final Ensemble

This is a simplified conceptual representation.

Why Gradient Boosting for VoxShield?

Potential advantages:

• Captures nonlinear feature relationships.
• Can perform well on structured numerical data.
• Sequential learning allows later trees to focus on residual errors.
• Provides an alternative to compare with Random Forest.

Limitations

• Can overfit with unsuitable parameters.
• Training is sequential, which can increase training time.
• Performance is sensitive to parameters such as learning rate and tree count.
• Strong performance on a particular dataset does not guarantee robustness to new recording environments.

Example Implementation

from sklearn.ensemble import GradientBoostingClassifier

model = GradientBoostingClassifier(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=3,
    random_state=42
)

model.fit(X_train, y_train)

Note: This is an example configuration, not a claim about your final trained model.

---

Random Forest vs Gradient Boosting

VoxShield can compare both algorithms using the same dataset splits and evaluation procedure.

Characteristic	Random Forest	Gradient Boosting
Learning approach	Parallel tree ensemble	Sequential tree ensemble
Tree construction	Independent randomized trees	Successive error-reducing stages
Nonlinear relationships	Supported	Supported
Feature scaling	Generally not required for tree splits	Generally not required for tree splits
Main tuning parameters	Trees, depth, feature selection	Trees, learning rate, depth
Potential concern	Overfitting and biased importance estimates	Overfitting and parameter sensitivity

Selection Method

The final model should be selected using documented evaluation criteria, including:

• Validation performance
• Class-wise recall
• False positive rate
• False negative rate
• Performance on microphone recordings
• Generalization to unseen speakers

Accuracy alone should not determine the final model.