पायथन में लॉजिस्टिक रिग्रेशन को लागू करना: एक व्यापक मार्गदर्शिका

पायथन के Scikit-Learn लाइब्रेरी के साथ लॉजिस्टिक रिग्रेशन की शक्ति को अनलॉक करें। जानें कैसे डेटा को प्रीप्रोसेस करें, लापता मानों को संभालें, फीचर चयन करें, और कुशल वर्गीकरण मॉडल बनाएं। इस चरण-दर-चरण ट्यूटोरियल के साथ अपनी मशीन लर्निंग क्षमताओं को बढ़ाएं।

Logistic Regression

लॉजिस्टिक रिग्रेशन का परिचय

लॉजिस्टिक रिग्रेशन मशीन लर्निंग में एक बुनियादी एल्गोरिदम है, जो मुख्य रूप से बाइनरी वर्गीकरण कार्यों के लिए उपयोग किया जाता है। रैखिक रिग्रेशन के विपरीत, जो सतत परिणामों की भविष्यवाणी करता है, लॉजिस्टिक रिग्रेशन एक या अधिक पूर्वानुमान चर के आधार पर बाइनरी परिणाम की संभावना का अनुमान लगाता है।

इस व्यापक मार्गदर्शिका में, हम Scikit-Learn का उपयोग करके पायथन में लॉजिस्टिक रिग्रेशन मॉडल को लागू करने के कदमों के माध्यम से चलेंगे। हम डेटा प्रीप्रोसेसिंग, लापता मानों को संभालना, श्रेणीबद्ध चर को एन्कोड करना, फीचर चयन, स्केलिंग, और मॉडल मूल्यांकन को कवर करेंगे। इसके अतिरिक्त, हम लॉजिस्टिक रिग्रेशन के प्रदर्शन की तुलना K-Nearest Neighbors (KNN) क्लासिफायर के साथ करेंगे।

लॉजिस्टिक रिग्रेशन को समझना

लॉजिस्टिक रिग्रेशन एक रैखिक मॉडल है जिसका उपयोग वर्गीकरण कार्यों के लिए किया जाता है। यह एक दिए गए इनपुट के विशेष वर्ग से संबंधित होने की संभावना की भविष्यवाणी करता है। आउटपुट को लॉजिस्टिक फंक्शन (सिग्मॉइड) का उपयोग करके परिवर्तित किया जाता है, जो यह सुनिश्चित करता है कि आउटपुट मान 0 और 1 के बीच हों।

मुख्य विशेषताएँ:

बाइनरी वर्गीकरण: उन परिदृश्यों के लिए आदर्श जहां लक्ष्य चर के दो वर्ग होते हैं।
संभाव्यता अनुमान: वर्ग सदस्यों के लिए संभावनाएँ प्रदान करता है।
रैखिक निर्णय सीमा: इनपुट फीचर्स और परिणाम के लॉग-ऑड्स के बीच एक रैखिक संबंध मानता है।

पर्यावरण सेट करना

कोडिंग में जाने से पहले, सुनिश्चित करें कि आपके पास आवश्यक लाइब्रेरी स्थापित हैं। हम डेटा मैनिपुलेशन के लिए Pandas, संख्यात्मक ऑपरेशनों के लिए NumPy, मशीन लर्निंग एल्गोरिदम के लिए Scikit-Learn, और डेटा विज़ुअलाइज़ेशन के लिए Seaborn का उपयोग करेंगे।

import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt

import pandas as pd

import numpy as np

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.impute import SimpleImputer

from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler

from sklearn.compose import ColumnTransformer

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier

from sklearn.linear_model import LogisticRegression

import matplotlib.pyplot as plt

डेटा अन्वेषण और प्रीप्रोसेसिंग

इस ट्यूटोरियल के लिए, हम वेदर ऑस्ट्रेलिया डेटासेट का उपयोग करेंगे। यह डेटासेट विभिन्न ऑस्ट्रेलियाई शहरों में मौसम अवलोकनों के रिकॉर्ड शामिल करता है।

डेटा लोड करना

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

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

डेटा संरचना को समझने के लिए अंतिम कुछ पंक्तियों पर एक नजर डालते हैं:

data.tail()

1	data.tail()

नमूना आउटपुट:

तारीख	स्थान	न्यूनतम तापमान	अधिकतम तापमान	वाष्पीकरण	…	आज वर्षा	कल वर्षा
2017-06-20	Uluru	3.5	21.8	NaN	…	No	No
2017-06-21	Uluru	2.8	23.4	NaN	…	No	No
2017-06-22	Uluru	3.6	25.3	NaN	…	No	No
2017-06-23	Uluru	5.4	26.9	NaN	…	No	No
2017-06-24	Uluru	7.8	27.0	NaN	…	No	No

फीचर्स और लक्ष्य चर को अलग करना

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

# Target variable
y = data.iloc[:, -1]

# Features

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

# Target variable

y = data.iloc[:, -1]

विशिष्ट डेटासेट आवश्यकता को संभालना:

यदि आप विशेष रूप से वेदर ऑस्ट्रेलिया डेटासेट के साथ काम कर रहे हैं, तो आपको विशिष्ट कॉलम ड्रॉप करने की आवश्यकता हो सकती है:

X.drop('RISK_MM', axis=1, inplace=True)

1	X.drop('RISK_MM', axis=1, inplace=True)

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

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

संख्यात्मक डेटा को संभालना

हम Scikit-Learn से SimpleImputer का उपयोग करेंगे प्रत्येक कॉलम के माध्य के साथ लापता संख्यात्मक मानों को बदलने के लिए।

from sklearn.impute import SimpleImputer

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

# Initialize the imputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform the data
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

from sklearn.impute import SimpleImputer

# Identify numerical columns

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

# Initialize the imputer

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

# Fit and transform the data

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

श्रेणीबद्ध डेटा को संभालना

श्रेणीबद्ध चर के लिए, हम लापता मानों को सबसे अधिक बार आने वाली श्रेणी के साथ बदलेंगे।

# Identify string columns
string_cols = X.select_dtypes(include=['object']).columns

# Initialize the imputer
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data
X[string_cols] = imp_mode.fit_transform(X[string_cols])

# Identify string columns

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

# Initialize the imputer

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

# Fit and transform the data

X[string_cols] = imp_mode.fit_transform(X[string_cols])

श्रेणीबद्ध चर को एन्कोड करना

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

वन-हॉट एन्कोडिंग

कम संख्या में अद्वितीय श्रेणियों वाले श्रेणीबद्ध चर के लिए आदर्श।

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        transformers=[('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)

one_hot_indices = [X.columns.get_loc(col) for col in string_cols if X[col].nunique() &lt;= 10]
X = OneHotEncoderMethod(one_hot_indices, X)

def OneHotEncoderMethod(indices, data):

columnTransformer = ColumnTransformer(

transformers=[('encoder', OneHotEncoder(), indices)],

remainder='passthrough'

)

return columnTransformer.fit_transform(data)

one_hot_indices = [X.columns.get_loc(col) for col in string_cols if X[col].nunique() <= 10]

X = OneHotEncoderMethod(one_hot_indices, X)

लेबल एन्कोडिंग

बाइनरी श्रेणीबद्ध चर के लिए उपयुक्त।

def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)

binary_cols = [col for col in string_cols if X[col].nunique() == 2]
for col in binary_cols:
    X[col] = LabelEncoderMethod(X[col])

def LabelEncoderMethod(series):

le = LabelEncoder()

return le.fit_transform(series)

binary_cols = [col for col in string_cols if X[col].nunique() == 2]

for col in binary_cols:

X[col] = LabelEncoderMethod(X[col])

X के लिए एन्कोडिंग चयन

दो से अधिक श्रेणियों वाले (और एक निश्चित सीमा से ऊपर) श्रेणीबद्ध चर के लिए, हम लेबल एन्कोडिंग का उपयोग करेंगे। अन्यथा, हम वन-हॉट एन्कोडिंग लागू करेंगे।

def EncodingSelection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_count = X[col].nunique()
        if unique_count == 2 or unique_count &gt; threshold:
            X[col] = LabelEncoderMethod(X[col])
        else:
            one_hot_encoding_indices.append(X.columns.get_loc(col))
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

X = EncodingSelection(X)

def EncodingSelection(X, threshold=10):

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

one_hot_encoding_indices = []

for col in string_cols:

unique_count = X[col].nunique()

if unique_count == 2 or unique_count > threshold:

X[col] = LabelEncoderMethod(X[col])

else:

one_hot_encoding_indices.append(X.columns.get_loc(col))

X = OneHotEncoderMethod(one_hot_encoding_indices, X)

return X

X = EncodingSelection(X)

फीचर चयन

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

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

# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)

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

# Fit SelectKBest
kbest.fit(X_scaled, y)

# Get top features
best_features = np.argsort(kbest.scores_)[-2:]  # Selecting top 2 features
features_to_delete = np.argsort(kbest.scores_)[:-2]
X = np.delete(X, features_to_delete, axis=1)

print(f"Shape after feature selection: {X.shape}")

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.preprocessing import MinMaxScaler

# Initialize SelectKBest

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

# Scale features

scaler = MinMaxScaler()

X_scaled = scaler.fit_transform(X)

# Fit SelectKBest

kbest.fit(X_scaled, y)

# Get top features

best_features = np.argsort(kbest.scores_)[-2:] # Selecting top 2 features

features_to_delete = np.argsort(kbest.scores_)[:-2]

X = np.delete(X, features_to_delete, axis=1)

print(f"Shape after feature selection: {X.shape}")

आउटपुट:

Shape after feature selection: (142193, 2)

1	Shape after feature selection: (142193, 2)

फीचर्स को स्केल करना

स्केलिंग यह सुनिश्चित करता है कि फीचर्स मॉडल के प्रदर्शन में समान रूप से योगदान दें।

मानकीकरण

डेटा को ऐसा परिवर्तित करता है कि उसका माध्य शून्य और मानक विचलन एक हो।

from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)
sc.fit(X_train)

X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)

sc.fit(X_train)

X_train = sc.transform(X_train)

X_test = sc.transform(X_test)

मॉडलों को प्रशिक्षण देना

हम दो वर्गीकरण मॉडलों की तुलना करेंगे: K-Nearest Neighbors (KNN) और लॉजिस्टिक रिग्रेशन।

ट्रेन-टेस्ट विभाजन

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

from sklearn.model_selection import train_test_split

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

print(f"Training set shape: {X_train.shape}")
print(f"Testing set shape: {X_test.shape}")

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.20, random_state=1

)

print(f"Training set shape: {X_train.shape}")

print(f"Testing set shape: {X_test.shape}")

आउटपुट:

Training set shape: (113754, 2)
Testing set shape: (28439, 2)

1 2	Training set shape: (113754, 2) Testing set shape: (28439, 2)

K-Nearest Neighbors (KNN)

KNN एक सरल, उदाहरण-आधारित लर्निंग एल्गोरिदम है जिसका उपयोग वर्गीकरण और रिग्रेशन के लिए किया जाता है।

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

# Initialize KNN with 3 neighbors
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)

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

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

# Initialize KNN with 3 neighbors

knnClassifier = KNeighborsClassifier(n_neighbors=3)

knnClassifier.fit(X_train, y_train)

# Predict and evaluate

y_pred_knn = knnClassifier.predict(X_test)

knn_accuracy = accuracy_score(y_pred_knn, y_test)

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

आउटपुट:

KNN Accuracy: 80.03%

1	KNN Accuracy: 80.03%

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

बाइनरी वर्गीकरण कार्यों के लिए एक शक्तिशाली एल्गोरिदम, लॉजिस्टिक रिग्रेशन एक बाइनरी परिणाम की संभावना का अनुमान लगाता है।

from sklearn.linear_model import LogisticRegression

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

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

from sklearn.linear_model import LogisticRegression

# Initialize Logistic Regression

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

LRM.fit(X_train, y_train)

# Predict and evaluate

y_pred_lr = LRM.predict(X_test)

lr_accuracy = accuracy_score(y_pred_lr, y_test)

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

आउटपुट:

Logistic Regression Accuracy: 82.97%

1	Logistic Regression Accuracy: 82.97%

मॉडल प्रदर्शन का मूल्यांकन

KNN और लॉजिस्टिक रिग्रेशन दोनों डेटासेट पर पर्याप्त सटीकता प्रदान करते हैं, लेकिन इस परिदृश्य में लॉजिस्टिक रिग्रेशन KNN से बेहतर प्रदर्शन करता है।

मॉडल	सटीकता
K-Nearest Neighbors	80.03%
लॉजिस्टिक रिग्रेशन	82.97%

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

हाइपरपैरामीटर को अनुकूलित करने से मॉडल प्रदर्शन को और अधिक बढ़ाया जा सकता है। लॉजिस्टिक रिग्रेशन के लिए, C (रेगुलराइज़ेशन स्ट्रेंथ का इनवर्स) और solver जैसे पैरामीटर को ट्यून किया जा सकता है। इसी प्रकार, KNN के n_neighbors को बदला जा सकता है।

उदाहरण: लॉजिस्टिक रिग्रेशन के लिए GridSearchCV

from sklearn.model_selection import GridSearchCV

# Define parameter grid
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],
    'solver': ['liblinear', 'lbfgs']
}

# Initialize GridSearchCV
grid = GridSearchCV(LogisticRegression(max_iter=200), param_grid, cv=5)
grid.fit(X_train, y_train)

print(f"Best Parameters: {grid.best_params_}")
print(f"Best Cross-Validation Accuracy: {grid.best_score_:.2%}")

from sklearn.model_selection import GridSearchCV

# Define parameter grid

param_grid = {

'C': [0.01, 0.1, 1, 10, 100],

'solver': ['liblinear', 'lbfgs']

}

# Initialize GridSearchCV

grid = GridSearchCV(LogisticRegression(max_iter=200), param_grid, cv=5)

grid.fit(X_train, y_train)

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

print(f"Best Cross-Validation Accuracy: {grid.best_score_:.2%}")

आउटपुट:

Best Parameters: {'C': 1, 'solver': 'lbfgs'}
Best Cross-Validation Accuracy: 83.25%

1 2	Best Parameters: {'C': 1, 'solver': 'lbfgs'} Best Cross-Validation Accuracy: 83.25%

सर्वश्रेष्ठ पैरामीटर को लागू करना:

# Initialize Logistic Regression with best parameters
best_lr = grid.best_estimator_
best_lr.fit(X_train, y_train)

# Predict and evaluate
y_pred_best_lr = best_lr.predict(X_test)
best_lr_accuracy = accuracy_score(y_pred_best_lr, y_test)
print(f"Optimized Logistic Regression Accuracy: {best_lr_accuracy:.2%}")

# Initialize Logistic Regression with best parameters

best_lr = grid.best_estimator_

best_lr.fit(X_train, y_train)

# Predict and evaluate

y_pred_best_lr = best_lr.predict(X_test)

best_lr_accuracy = accuracy_score(y_pred_best_lr, y_test)

print(f"Optimized Logistic Regression Accuracy: {best_lr_accuracy:.2%}")

आउटपुट:

Optimized Logistic Regression Accuracy: 83.00%

1	Optimized Logistic Regression Accuracy: 83.00%

निष्कर्ष

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

मुख्य बिंदु:

डेटा प्रीप्रोसेसिंग: उच्च मॉडल सटीकता प्राप्त करने के लिए महत्वपूर्ण।
फीचर चयन: ओवरफिटिंग को कम करने और प्रदर्शन में सुधार करने में मदद करता है।
मॉडल तुलना: सर्वोत्तम प्रदर्शनकर्ता की पहचान के लिए हमेशा कई मॉडलों की तुलना करें।
हाइपरपैरामीटर ट्यूनिंग: मॉडल प्रदर्शन को अनुकूलित करने के लिए आवश्यक।

इन तकनीकों को अपनाएं ताकि आप अपने विशेष डेटासेट और आवश्यकताओं के लिए मजबूत और कुशल वर्गीकरण मॉडल बना सकें।

कीवर्ड्स: Logistic Regression, Python, Scikit-Learn, Machine Learning, Data Preprocessing, Classification Models, K-Nearest Neighbors, Feature Selection, Hyperparameter Tuning, Data Science Tutorial

मेटा विवरण: Scikit-Learn के साथ पायथन में लॉजिस्टिक रिग्रेशन को लागू करना सीखें। यह व्यापक मार्गदर्शिका डेटा प्रीप्रोसेसिंग, लापता मानों को संभालना, फीचर चयन, और मॉडल मूल्यांकन को कवर करती है, सर्वोत्तम प्रदर्शन के लिए लॉजिस्टिक रिग्रेशन की तुलना KNN के साथ करती है।