पाइथन में गैसियन नायव बेयस कार्यान्वयन: एक व्यापक गाइड

सामग्री तालिका

गैसियन नायव बेयस का परिचय
डेटासेट को समझना
डेटा प्रीप्रोसेसिंग
1. लापता डेटा को संभालना
2. श्रेणिबद्ध चर का एनकोडिंग
3. विशेषता चयन
4. विशेषता स्केलिंग
मॉडल कार्यान्वयन
1. के-नजदीकी पड़ोसी (KNN)
2. लॉजिस्टिक रिग्रेशन
3. गैसियन नायव बेयस
मॉडल मूल्यांकन
निर्णय सीमाओं का विज़ुअलाइज़ेशन
हाइपरपैरामीटर ट्यूनिंग
निष्कर्ष
संदर्भ

1. गैसियन नायव बेयस का परिचय

गैसियन नायव बेयस (GNB) बायस प्रमेय पर आधारित एक संभाव्य वर्गीकरण एल्गोरिदम है, जो मानता है कि विशेषताएं सामान्य वितरण का पालन करती हैं। यह विशेष रूप से सतत डेटा के लिए प्रभावी है और अपेक्षाकृत कम संगणनात्मक आवश्यकताओं के साथ कार्यान्वयन में सरलता प्रदान करता है। अपनी सरल धारणाओं के बावजूद, GNB अक्सर चमत्कारी रूप से अच्छा प्रदर्शन करता है, खासकर पाठ वर्गीकरण और चिकित्सा निदान कार्यों में।

गैसियन नायव बेयस की मुख्य विशेषताएं:

संभाव्य मॉडल: भविष्यवाणियों के लिए संभावनाएं प्रदान करता है।
विशेषता स्वतंत्रता का अनुमान: विशेषताओं की स्वतंत्रता मानकर गणना को सरल बनाता है।
कुशलता: तेज प्रशिक्षण और भविष्यवाणी चरण।

2. डेटासेट को समझना

हमारे कार्यान्वयन के लिए, हम दो डेटासेट का उपयोग करेंगे:

आयरिस फ्लॉवर डेटासेट: मशीन लर्निंग में एक क्लासिक डेटासेट, जिसमें तीन विभिन्न प्रजातियों (सेटोसा, विर्जिनिका, और वर्सिकोलर) के 150 आइरिस फूल के नमूने शामिल हैं। प्रत्येक नमूने में चार विशेषताएं होती हैं: सेपल लंबाई, सेपल चौड़ाई, पंखुड़ी लंबाई, और पंखुड़ी चौड़ाई।
WeatherAUS डेटासेट: Kaggle से प्राप्त, इस डेटासेट में ऑस्ट्रेलियाई मौसम स्टेशनों का मौसम डेटा शामिल है, जिसमें तापमान, वर्षा, नमी, और वायु गति जैसी विशेषताएं शामिल हैं।

3. डेटा प्रीप्रोसेसिंग

मजबूत मशीन लर्निंग मॉडलों के निर्माण के लिए प्रभावी डेटा प्रीप्रोसेसिंग अत्यंत महत्वपूर्ण है। हम WeatherAUS डेटासेट पर लागू आवश्यक प्रीप्रोसेसिंग चरणों के माध्यम से चलेंगे।

a. लापता डेटा को संभालना

लापता डेटा आपके विश्लेषण के परिणाम को विकृत कर सकता है। हम लापता मूल्यों को संभालने के लिए दो रणनीतियों का उपयोग करते हैं:

संख्यात्मक विशेषताएं: माध्य रणनीति का उपयोग करके अनुमानित की गईं।
श्रेणिबद्ध विशेषताएं: सबसे सामान्य रणनीति का उपयोग करके अनुमानित की गईं।

import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer

# Load the dataset
data = pd.read_csv('weatherAUS.csv')

# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Identify numerical and categorical columns
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
categorical_cols = X.select_dtypes(include=['object']).columns

# Impute numerical features with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

# Impute categorical features with the most frequent value
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[categorical_cols] = imp_freq.fit_transform(X[categorical_cols])

import numpy as np

import pandas as pd

from sklearn.impute import SimpleImputer

# Load the dataset

data = pd.read_csv('weatherAUS.csv')

# Separate features and target

X = data.iloc[:, :-1]

y = data.iloc[:, -1]

# Identify numerical and categorical columns

numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns

categorical_cols = X.select_dtypes(include=['object']).columns

# Impute numerical features with mean

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

# Impute categorical features with the most frequent value

imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

X[categorical_cols] = imp_freq.fit_transform(X[categorical_cols])

b. श्रेणिबद्ध चर का एनकोडिंग

मशीन लर्निंग एल्गोरिदम को संख्यात्मक इनपुट की आवश्यकता होती है। हम श्रेणिबद्ध चर को रूपांतरित करने के लिए लेबल एनकोडिंग और वन-हॉट एनकोडिंग लागू करते हैं।

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

# Label Encoding for binary categorical variables
le = LabelEncoder()
y = le.fit_transform(y)

# Function for encoding
def EncodingSelection(X, threshold=10):
    string_cols = list(X.select_dtypes(include=['object']).columns)
    one_hot_encoding_cols = []

    for col in string_cols:
        unique_vals = len(X[col].unique())
        if unique_vals == 2 or unique_vals &gt; threshold:
            X[col] = le.fit_transform(X[col])
        else:
            one_hot_encoding_cols.append(col)
    
    # One-Hot Encoding for remaining categorical variables
    if one_hot_encoding_cols:
        ct = ColumnTransformer([('encoder', OneHotEncoder(), one_hot_encoding_cols)], remainder='passthrough')
        X = ct.fit_transform(X)
    
    return X

X = EncodingSelection(X)

from sklearn.preprocessing import LabelEncoder, OneHotEncoder

from sklearn.compose import ColumnTransformer

# Label Encoding for binary categorical variables

le = LabelEncoder()

y = le.fit_transform(y)

# Function for encoding

def EncodingSelection(X, threshold=10):

string_cols = list(X.select_dtypes(include=['object']).columns)

one_hot_encoding_cols = []

for col in string_cols:

unique_vals = len(X[col].unique())

if unique_vals == 2 or unique_vals > threshold:

X[col] = le.fit_transform(X[col])

else:

one_hot_encoding_cols.append(col)

# One-Hot Encoding for remaining categorical variables

if one_hot_encoding_cols:

ct = ColumnTransformer([('encoder', OneHotEncoder(), one_hot_encoding_cols)], remainder='passthrough')

X = ct.fit_transform(X)

return X

X = EncodingSelection(X)

c. विशेषता चयन

मॉडल के प्रदर्शन को बढ़ाने और संगणनात्मक लागत को कम करने के लिए, हम SelectKBest विधि का उपयोग करते हुए सबसे प्रासंगिक विशेषताओं का चयन करते हैं, जिसमें ची-स्क्वायर स्कोर फंक्शन शामिल है।

from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Select top 2 features
kbest = SelectKBest(score_func=chi2, k=2)
X_selected = kbest.fit_transform(X_scaled, y)

print(f"Selected Features Shape: {X_selected.shape}")

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.preprocessing import MinMaxScaler

# Scale features

scaler = MinMaxScaler()

X_scaled = scaler.fit_transform(X)

# Select top 2 features

kbest = SelectKBest(score_func=chi2, k=2)

X_selected = kbest.fit_transform(X_scaled, y)

print(f"Selected Features Shape: {X_selected.shape}")

d. विशेषता स्केलिंग

विशेषताओं का मानकीकरण यह सुनिश्चित करता है कि प्रत्येक विशेषता परिणाम में समान रूप से योगदान देती है, जो विशेष रूप से के-नजदीकी पड़ोसी जैसे दूरी-आधारित एल्गोरिदम के लिए महत्वपूर्ण है।

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler(with_mean=False)
X_scaled = scaler.fit_transform(X_selected)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler(with_mean=False)

X_scaled = scaler.fit_transform(X_selected)

4. मॉडल कार्यान्वयन

हम तीन वर्गीकरण मॉडल लागू करेंगे: के-नजदीकी पड़ोसी (KNN), लॉजिस्टिक रिग्रेशन, और गैसियन नायव बेयस।

a. के-नजदीकी पड़ोसी (KNN)

KNN एक डेटा बिंदु को इसके निकटतम पड़ोसियों के बहुमत लेबल के आधार पर वर्गीकृत करता है।

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

# Split the dataset
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.20, random_state=1)

# Initialize and train KNN
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# Predict and evaluate
y_pred_knn = knn.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2f}")

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

from sklearn.model_selection import train_test_split

# Split the dataset

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.20, random_state=1)

# Initialize and train KNN

knn = KNeighborsClassifier(n_neighbors=3)

knn.fit(X_train, y_train)

# Predict and evaluate

y_pred_knn = knn.predict(X_test)

knn_accuracy = accuracy_score(y_pred_knn, y_test)

print(f"KNN Accuracy: {knn_accuracy:.2f}")

Output:

KNN Accuracy: 0.80

1	KNN Accuracy: 0.80

b. लॉजिस्टिक रिग्रेशन

लॉजिस्टिक रिग्रेशन श्रेणीबद्ध निर्भर चर के संभावना को मॉडल करता है।

from sklearn.linear_model import LogisticRegression

# Initialize and train Logistic Regression
lr = LogisticRegression(random_state=0, max_iter=200)
lr.fit(X_train, y_train)

# Predict and evaluate
y_pred_lr = lr.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}")

from sklearn.linear_model import LogisticRegression

# Initialize and train Logistic Regression

lr = LogisticRegression(random_state=0, max_iter=200)

lr.fit(X_train, y_train)

# Predict and evaluate

y_pred_lr = lr.predict(X_test)

lr_accuracy = accuracy_score(y_pred_lr, y_test)

print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}")

Output:

Logistic Regression Accuracy: 0.83

1	Logistic Regression Accuracy: 0.83

c. गैसियन नायव बेयस

GaussianNB यह मानता है कि प्रत्येक वर्ग से संबंधित सतत मान सामान्य रूप से वितरित हैं।

from sklearn.naive_bayes import GaussianNB

# Initialize and train GaussianNB
gnb = GaussianNB()
gnb.fit(X_train, y_train)

# Predict and evaluate
y_pred_gnb = gnb.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)
print(f"Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}")

from sklearn.naive_bayes import GaussianNB

# Initialize and train GaussianNB

gnb = GaussianNB()

gnb.fit(X_train, y_train)

# Predict and evaluate

y_pred_gnb = gnb.predict(X_test)

gnb_accuracy = accuracy_score(y_pred_gnb, y_test)

print(f"Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}")

Output:

Gaussian Naive Bayes Accuracy: 0.80

1	Gaussian Naive Bayes Accuracy: 0.80

5. मॉडल मूल्यांकन

मॉडल मूल्यांकन यह समझने के लिए महत्वपूर्ण है कि आपके मॉडल अप्रत्याशित डेटा पर कितना अच्छा प्रदर्शन करते हैं। हम अपनी प्राथमिक मीट्रिक के रूप में सटीकता स्कोर का उपयोग करते हैं।

मॉडल	सटीकता
के-नजदीकी पड़ोसी (KNN)	80%
लॉजिस्टिक रिग्रेशन	83%
गैसियन नायव बेयस	80%

परीक्षित मॉडलों में, लॉजिस्टिक रिग्रेशन ने इस डेटासेट पर KNN और गैसियन नायव बेयस को पीछे छोड़ दिया है, जो डेटा की विशेषताओं के आधार पर मॉडल चयन के महत्व को उजागर करता है।

6. निर्णय सीमाओं का विज़ुअलाइज़ेशन

निर्णय सीमाओं का विज़ुअलाइज़ेशन यह समझने में मदद करता है कि विभिन्न क्लासिफायर डेटा को कैसे अलग करते हैं। हम इस उद्देश्य के लिए आयरिस फ्लॉवर डेटासेट का उपयोग करेंगे।

from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets

def visualize_decision_regions(X, y, model):
    plot_decision_regions(X, y, clf=model)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.title(f'Decision Boundary for {model.__class__.__name__}')
    plt.show()

# Load Iris dataset
iris = datasets.load_iris()
X_iris = iris.data[:, :2]  # First two features
y_iris = iris.target

# Initialize classifiers
knn_iris = KNeighborsClassifier(n_neighbors=3)
knn_iris.fit(X_iris, y_iris)

lr_iris = LogisticRegression(random_state=0, max_iter=200)
lr_iris.fit(X_iris, y_iris)

gnb_iris = GaussianNB()
gnb_iris.fit(X_iris, y_iris)

# Visualize decision boundaries
visualize_decision_regions(X_iris, y_iris, knn_iris)
visualize_decision_regions(X_iris, y_iris, lr_iris)
visualize_decision_regions(X_iris, y_iris, gnb_iris)

from mlxtend.plotting import plot_decision_regions

import matplotlib.pyplot as plt

from sklearn import datasets

def visualize_decision_regions(X, y, model):

plot_decision_regions(X, y, clf=model)

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title(f'Decision Boundary for {model.__class__.__name__}')

plt.show()

# Load Iris dataset

iris = datasets.load_iris()

X_iris = iris.data[:, :2] # First two features

y_iris = iris.target

# Initialize classifiers

knn_iris = KNeighborsClassifier(n_neighbors=3)

knn_iris.fit(X_iris, y_iris)

lr_iris = LogisticRegression(random_state=0, max_iter=200)

lr_iris.fit(X_iris, y_iris)

gnb_iris = GaussianNB()

gnb_iris.fit(X_iris, y_iris)

# Visualize decision boundaries

visualize_decision_regions(X_iris, y_iris, knn_iris)

visualize_decision_regions(X_iris, y_iris, lr_iris)

visualize_decision_regions(X_iris, y_iris, gnb_iris)

Visualizations:

के-नजदीकी पड़ोसी (KNN): निकटता के आधार पर अधिक जटिल सीमाओं को कैप्चर करता है।
लॉजिस्टिक रिग्रेशन: रैखिक निर्णय सीमाएं।
गैसियन नायव बेयस: संभाव्य धारणाओं के कारण मुड़े हुए सीमाएं।

7. हाइपरपैरामीटर ट्यूनिंग

हालांकि हमारे प्रारंभिक प्रयोग एक अच्छा प्रारंभिक बिंदु प्रदान करते हैं, हाइपरपैरामीटर को ठीक करना मॉडल के प्रदर्शन को और भी बढ़ा सकता है। ग्रिड सर्च और रैंडम सर्च जैसी तकनीकों का उपयोग करके प्रत्येक क्लासिफायर के लिए सर्वोत्तम हाइपरपैरामीटर्स का सेट खोजा जा सकता है।

from sklearn.model_selection import GridSearchCV

# Example: Hyperparameter tuning for KNN
param_grid = {'n_neighbors': range(1, 10)}
grid_knn = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)
grid_knn.fit(X_train, y_train)

print(f"Best KNN Parameters: {grid_knn.best_params_}")
print(f"Best KNN Accuracy: {grid_knn.best_score_:.2f}")

from sklearn.model_selection import GridSearchCV

# Example: Hyperparameter tuning for KNN

param_grid = {'n_neighbors': range(1, 10)}

grid_knn = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)

grid_knn.fit(X_train, y_train)

print(f"Best KNN Parameters: {grid_knn.best_params_}")

print(f"Best KNN Accuracy: {grid_knn.best_score_:.2f}")

8. निष्कर्ष

पाइथन में गैसियन नायव बेयस को कार्यान्वित करना सरल है, scikit-learn जैसी लाइब्रेरीज के कारण। अपनी सरलता के बावजूद, GNB प्रतिस्पर्धी प्रदर्शन प्रदान करता है, जिससे यह मशीन लर्निंग के शस्त्रागार में एक मूल्यवान उपकरण बन जाता है। हालांकि, जैसा कि प्रदर्शित किया गया है, मॉडल का प्रदर्शन डेटासेट की प्रकृति पर निर्भर करता है। उदाहरण के लिए, WeatherAUS डेटासेट के हमारे प्रयोगों में लॉजिस्टिक रिग्रेशन ने GNB और KNN को पीछे छोड़ दिया।

मुख्य निष्कर्ष:

डेटा प्रीप्रोसेसिंग: लापता डेटा को संभालना और श्रेणिबद्ध चर का एनकोडिंग महत्वपूर्ण चरण हैं।
विशेषता चयन: प्रासंगिक विशेषताओं का चयन मॉडल के प्रदर्शन को बढ़ा सकता है और संगणनात्मक ओवरहेड को कम कर सकता है।
मॉडल चयन: अपने विशेष डेटासेट के लिए सर्वश्रेष्ठ प्रदर्शन करने वाले मॉडल की पहचान करने के लिए हमेशा कई मॉडलों के साथ प्रयोग करें।
विज़ुअलाइज़ेशन: निर्णय सीमाओं को समझना यह समझने में अंतर्दृष्टि प्रदान करता है कि मॉडल डेटा को कैसे पृथक करते हैं।

इस गाइड में वर्णित चरणों का पालन करके, आप प्रभावी ढंग से गैसियन नायव बेयस और अन्य वर्गीकरण एल्गोरिदम को लागू और मूल्यांकन कर सकते हैं ताकि अपने मशीन लर्निंग परियोजनाओं में सूचित निर्णय ले सकें।

पाइथन में गैसियन नायव बेयस कार्यान्वयन: एक व्यापक गाइड

सामग्री तालिका

1. गैसियन नायव बेयस का परिचय

2. डेटासेट को समझना

3. डेटा प्रीप्रोसेसिंग

a. लापता डेटा को संभालना

b. श्रेणिबद्ध चर का एनकोडिंग

c. विशेषता चयन

d. विशेषता स्केलिंग

4. मॉडल कार्यान्वयन

a. के-नजदीकी पड़ोसी (KNN)

b. लॉजिस्टिक रिग्रेशन

c. गैसियन नायव बेयस

5. मॉडल मूल्यांकन

6. निर्णय सीमाओं का विज़ुअलाइज़ेशन

7. हाइपरपैरामीटर ट्यूनिंग

8. निष्कर्ष

9. संदर्भ