Dummy Classifiers using Sklearn - ML

Dummy classifier is a classifier that classifies data with basic rules without producing any insight from the training data. It entirely disregards data trends and outputs the class label based on pre-specified strategies. A dummy classifier is designed to act as a baseline, with which more sophisticated classifiers are compared. It is especially helpful for class-imbalanced datasets since it shows the performance of a random or naive method. The philosophy behind it is that any useful classification method should be better than random guessing.

Types of Dummy Classifiers in Scikit-learn

Scikit-learn's DummyClassifier offers several strategies for making predictions:

• most_frequent: Predicts the most frequent label, useful for imbalanced datasets.
• stratified: Randomly predicts labels based on their distribution in the training data, preserving class percentages.
• uniform: Randomly selects a class with equal probability.
• constant: Always predicts the same label, which can be specified for fixed output scenarios.

How to Implement Dummy Classifiers Using Scikit-learn (Sklearn)

Now, let's see the implementation of dummy classifiers using the sklearn library

Step 1: Importing the required Libraries

• numpy and pandas for data manipulation.
• train_test_split from sklearn.model_selection for splitting the dataset into training and testing sets.
• KNeighborsClassifier for training the KNN classifier.
• matplotliband seaborn for plotting the results.
• DummyClassifier from sklearn.dummy for creating dummy classifiers.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.dummy import DummyClassifier # Import DummyClassifier

Step 2: Reading the Dataset

• Import the Breast Cancer dataset from a CSV file via pandas.
• Split the dependent (y, the diagnosis column) and independent (X, the remaining features).
• Split data into test set and train set using train_test_split with test data 30% and training data 70%.

df = pd.read_csv('https://www.kaggle.com/datasets/yasserh/breast-cancer-dataset.csv')

y = df['diagnosis']
X = df.drop('diagnosis', axis = 1)
X = X.drop('id', axis = 1)

X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size = 0.3, random_state = 0)

Step 3: Training the dummy model

In this step, we:

• Define a list of strategies: 'most_frequent', 'stratified', 'uniform', and 'constant'.
• For each strategy, we initialize the DummyClassifier and train it using the training data (X_train, y_train).
• The classifier predicts the test data (X_test), and we append the accuracy score to the test_scores list.

strategies = ['most_frequent', 'stratified', 'uniform', 'constant']

test_scores = []
for s in strategies:
    if s =='constant':
        dclf = DummyClassifier(strategy = s, random_state = 0, constant ='M')
    else:
        dclf = DummyClassifier(strategy = s, random_state = 0)
    dclf.fit(X_train, y_train)
    score = dclf.score(X_test, y_test)
    test_scores.append(score)

Step 4: Analyzing our results

In this step:

• We use seaborn.stripplot to plot the test scores for each strategy.
• x = strategies and y = test_scores specify the strategies and their corresponding test scores on the plot.

ax = sns.stripplot(x=strategies, y=test_scores)  # Use x and y as keyword arguments
ax.set(xlabel='Strategy', ylabel='Test Score')
plt.show()

Output

Step 5: Training the KNN model

In this step:

• We initialize and train a KNN classifier with n_neighbors=5.
• The model is trained using X_train and y_train, and the accuracy is printed for the test data (X_test).

clf = KNeighborsClassifier(n_neighbors = 5)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))

Output

0.9473684210526315

On comparing the scores of the KNN classifier with the dummy classifier, we come to the conclusion that the KNN classifier is, in fact, a good classifier for the given data.

When to Use Dummy Classifiers

Dummy classifiers are mainly useful when:

• You need a simple baseline model for comparison.
• You are evaluating the effectiveness of more complex machine learning algorithms.
• You want to check if your data contains any simple patterns.