A Beginner's Guide to Probabilistic Classifiers

 “Naive Bayes classifiers” are a family of simple “probabilistic classifiers” that use the Bayes theorem and strong (naive) independence assumptions between the features. It’s particularly used in text classification.



It calculates the probability of each class and the conditional probability of each class given each input value. These probabilities are then used to classify a new value based on the highest probability.

Evaluation Metrics:

  • Accuracy: Measures overall correctness of the model.
  • Precision, Recall, and F1 Score: Especially important in cases where class distribution is imbalanced.

Applying with Sci-kit Learn

We’ll use the Digits dataset, which involves classifying images of handwritten digits (0–9). This is a multi-class classification problem. We’ll train the Naive Bayes model, predict digit classes, and evaluate using classification metrics. Here are the steps we’ll follow.

  1. Load the Digits Dataset:
  • The Digits dataset consists of 8x8 pixel images of handwritten digits (from 0 to 9). Each image is represented as a feature vector of 64 values (8x8 pixels), each representing the grayscale intensity of a pixel.

2. Split the Dataset:

  • Similar to previous examples, the dataset is divided into training and testing sets. We use 80% of the data for training and 20% for testing. This helps in training the model on a large portion of the data and then evaluating its performance on a separate set that it hasn’t seen before.

3. Create and Train the Naive Bayes Model:

  • A Gaussian Naive Bayes classifier is created. This variant of Naive Bayes assumes that the continuous values associated with each feature are distributed according to a Gaussian (normal) distribution.
  • The model is then trained (fitted) on the training data. It learns to associate the input features (pixel values) with the target values (digit classes).

4. Predict and Evaluate:

  • After training, the model is used to predict the class labels of the test data.

Here is the code below.

from sklearn.datasets import load_digits
from sklearn.naive_bayes import GaussianNB

# Load the Digits dataset
digits = load_digits()
X, y = digits.data, digits.target

# Splitting the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Creating and training the Naive Bayes model
model = GaussianNB()
model.fit(X_train, y_train)

# Predicting the test set results
y_pred = model.predict(X_test)

# Evaluating the model
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='macro')
recall = recall_score(y_test, y_pred, average='macro')
f1 = f1_score(y_test, y_pred, average='macro')

# Print the results
print("Accuracy:", accuracy)
print("Precision:", precision)
print("Recall:", recall)
print("F1 Score:", f1)

Here is the output.

Machine Learning Algorithms for Beginner Data Scientists

These results show that the Naive Bayes model has a good performance on this dataset, with fairly balanced precision and recall. The model is quite effective in classifying handwritten digits, though there’s room for improvement, especially in terms of accuracy and F1 score.

Comments

Post a Comment

Popular posts from this blog

Mastering the Difference Array Technique: A Simple Guide with Examples

Image
Introduction Have you ever encountered a problem where you need to update multiple ranges in an array efficiently? Updating each element one by one can be too slow , especially for large datasets. This is where the Difference Array Technique comes in! It allows us to perform range updates in O(1) time per update and compute the final array efficiently. In this blog, we’ll break it down with step-by-step explanations and visuals to make it super easy to understand. Understanding the Problem Let’s say we have an array: A = [ 0 , 0 , 0 , 0 , 0 ] A = [0, 0, 0, 0, 0] A = [ 0 , 0 , 0 , 0 , 0 ] We want to perform multiple operations like: 1️⃣ Add 10 to indices [1 to 3] 2️⃣ Add 5 to indices [2 to 4] 3️⃣ Add 20 to indices [0 to 2] A naive approach would be to loop through each range and update elements one by one , which takes O(n) per operation . For large arrays and multiple queries, this becomes very inefficient ! 🚨 What is the Difference Array? Instead of updating each ele...
Read more

Leetcode 2594. Minimum Time to Repair Cars explained clearly

When solving problems efficiently, choosing the right strategy makes all the difference. A common comparison in programming is Binary Search vs. Brute Force (or the Naïve approach ). While brute force might seem straightforward, it often becomes impractical for large inputs. Binary search, on the other hand, is a game-changer. Let's break it down in simple terms. 1. Understanding Brute Force (Naïve Approach) Imagine you have a book with 1,000 pages and you are looking for a particular word. If you start from page 1 and check each page one by one, that’s the brute force approach . This method works but is slow because you have to go through every single page before finding what you need. In coding, brute force means trying all possible solutions until you find the correct one. While this approach is easy to understand, it is very slow when the number of possibilities is huge. Example: Car Repair Problem Let’s say you have mechanics who can repair cars, and you want to find ou...
Read more

Finding a Unique Binary String in Python

IntroductionImagine you are given a list of binary strings, and your task is to find a new binary string that is not present in the list. This might seem tricky at first, but Python makes it easy to solve. In this guide, we'll break down the problem step by step and understand how to implement a simple and efficient solution. Understanding the ProblemYou are given a list of n binary strings, each of length n. Your goal is to find a new n-bit binary string that is not present in the list. Example:nums = ["00", "01", "10"] Output: "11" (since "11" is not in the list) There can be multiple valid answers. The key is to ensure that the generated binary string is unique. here is my approach to solve  from typing import List class Solution :     def findDifferentBinaryString ( self , nums : List[ str ]) -> str :         n = len (nums)         num_set = set (nums)         for i in range ( 2 **n):     ...
Read more