पायथन में मौसम पूर्वानुमान के लिए निर्णय वृक्ष, रैंडम फॉरेस्ट, XGBoost और AdaBoost का कार्यान्वयन

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

परिचय
डेटासेट अवलोकन
डेटा पूर्व-संसाधन
मॉडल कार्यान्वयन और मूल्यांकन
निर्णय क्षेत्रों का विज़ुअलाइजेशन
निष्कर्ष
संदर्भ

परिचय

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

डेटासेट अवलोकन

Weather Australia डेटासेट, जिसे Kaggle से प्राप्त किया गया है, में ऑस्ट्रेलिया के विभिन्न स्थानों पर दर्ज किए गए मौसम की स्थितियों से संबंधित 24 विशेषताएँ हैं। प्रमुख लक्ष्य RainTomorrow विशेषता की भविष्यवाणी करना है, जो यह संकेत देती है कि क्या अगले दिन बारिश होगी।

डेटासेट विशेषताएँ

Date: अवलोकन तिथि।
Location: मौसम स्टेशन का भौगोलिक स्थान।
MinTemp: °C में न्यूनतम तापमान।
MaxTemp: °C में अधिकतम तापमान।
Rainfall: मिमी में वर्षा की मात्रा।
Evaporation: मिमी में वाष्पीकरण।
Sunshine: धूप के घंटे।
WindGustDir: सबसे तेज़ हवा के झोंके का दिशा।
WindGustSpeed: सबसे तेज़ हवा के झोंके की गति km/h में।
WindDir9am: सुबह 9 बजे की हवा की दिशा।
WindDir3pm: दोपहर 3 बजे की हवा की दिशा।
…और भी बहुत कुछ।

डेटा पूर्व-संसाधन

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

गुम मानों को संभालना

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

संख्यात्मक डेटा

संख्यात्मक स्तंभों के लिए, हम गुम मानों को भरने के लिए मीन इम्प्यूटेशन का उपयोग करेंगे।

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

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

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

# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])

import numpy as np

import pandas as pd

from sklearn.impute import SimpleImputer

# Load data

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

# Identify numerical columns

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

# Impute missing values with mean

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

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

वर्गीकृत डेटा

वर्गीकृत स्तंभों के लिए, हम सबसे अधिक सामान्य इम्प्यूटेशन का उपयोग करेंगे।

# Identify categorical columns
categorical_cols = data.select_dtypes(include=['object']).columns

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

# Identify categorical columns

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

# Impute missing values with the most frequent value

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

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

वर्गीकृत चर की कोडिंग

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

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

def encode_features(df, threshold=10):
    label_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() <= threshold]
    onehot_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() > threshold]
    
    # Label Encoding
    le = LabelEncoder()
    for col in label_enc_cols:
        df[col] = le.fit_transform(df[col])
    
    # One-Hot Encoding
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), onehot_enc_cols)], remainder='passthrough')
    df = ct.fit_transform(df)
    
    return df

X = data.drop('RainTomorrow', axis=1)
y = data['RainTomorrow']

X = encode_features(X)

from sklearn.preprocessing import LabelEncoder, OneHotEncoder

from sklearn.compose import ColumnTransformer

def encode_features(df, threshold=10):

label_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() <= threshold]

onehot_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() > threshold]

# Label Encoding

le = LabelEncoder()

for col in label_enc_cols:

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

# One-Hot Encoding

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

df = ct.fit_transform(df)

return df

X = data.drop('RainTomorrow', axis=1)

y = data['RainTomorrow']

X = encode_features(X)

फ़ीचर चयन

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

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

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

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

# Further reduce to top 2 features for visualization
best_features = selector.get_support(indices=True)
X_final = X_selected[:, :2]

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.preprocessing import MinMaxScaler

# Scale features

scaler = MinMaxScaler()

X_scaled = scaler.fit_transform(X)

# Select top 10 features

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

X_selected = selector.fit_transform(X_scaled, y)

# Further reduce to top 2 features for visualization

best_features = selector.get_support(indices=True)

X_final = X_selected[:, :2]

ट्रेन-टेस्ट विभाजन और फीचर स्केलिंग

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

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

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

# Feature Scaling
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

# Split the data

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

# Feature Scaling

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_test = scaler.transform(X_test)

मॉडल कार्यान्वयन और मूल्यांकन

हम विभिन्न मशीन लर्निंग मॉडल लागू करेंगे और उनके प्रदर्शन का एक्युरेसी स्कोर का उपयोग करके मूल्यांकन करेंगे।

के-निकटतम पड़ोसी (KNN)

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

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
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

knn = KNeighborsClassifier(n_neighbors=3)

knn.fit(X_train, y_train)

y_pred_knn = knn.predict(X_test)

knn_accuracy = accuracy_score(y_pred_knn, y_test)

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

KNN की एक्युरेसी: 0.80

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

from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.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

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

log_reg.fit(X_train, y_train)

y_pred_lr = log_reg.predict(X_test)

lr_accuracy = accuracy_score(y_pred_lr, y_test)

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

लॉजिस्टिक रिग्रेशन की एक्युरेसी: 0.83

गॉसियन नायव बेयस

from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
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

gnb = GaussianNB()

gnb.fit(X_train, y_train)

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}')

गॉसियन नायव बेयस की एक्युरेसी: 0.80

सपोर्ट वेक्टर मशीन (SVM)

from sklearn.svm import SVC

svm = SVC()
svm.fit(X_train, y_train)
y_pred_svm = svm.predict(X_test)
svm_accuracy = accuracy_score(y_pred_svm, y_test)
print(f'SVM Accuracy: {svm_accuracy:.2f}')

from sklearn.svm import SVC

svm = SVC()

svm.fit(X_train, y_train)

y_pred_svm = svm.predict(X_test)

svm_accuracy = accuracy_score(y_pred_svm, y_test)

print(f'SVM Accuracy: {svm_accuracy:.2f}')

SVM की एक्युरेसी: 0.83

निर्णय वृक्ष

from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
y_pred_dtc = dtc.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {dtc_accuracy:.2f}')

from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()

dtc.fit(X_train, y_train)

y_pred_dtc = dtc.predict(X_test)

dtc_accuracy = accuracy_score(y_pred_dtc, y_test)

print(f'Decision Tree Accuracy: {dtc_accuracy:.2f}')

निर्णय वृक्ष की एक्युरेसी: 0.83

रैंडम फॉरेस्ट

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, max_depth=5)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
rf_accuracy = accuracy_score(y_pred_rf, y_test)
print(f'Random Forest Accuracy: {rf_accuracy:.2f}')

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, max_depth=5)

rf.fit(X_train, y_train)

y_pred_rf = rf.predict(X_test)

rf_accuracy = accuracy_score(y_pred_rf, y_test)

print(f'Random Forest Accuracy: {rf_accuracy:.2f}')

रैंडम फॉरेस्ट की एक्युरेसी: 0.83

XGBoost और AdaBoost

हालांकि प्रारंभिक कार्यान्वयन में XGBoost और AdaBoost शामिल नहीं हैं, ये एंसेंबल विधियाँ मॉडल के प्रदर्शन को और बेहतर बना सकती हैं। यहाँ इन्हें लागू करने का संक्षिप्त उदाहरण दिया गया है:

XGBoost

from xgboost import XGBClassifier

xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
xgb.fit(X_train, y_train)
y_pred_xgb = xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {xgb_accuracy:.2f}')

from xgboost import XGBClassifier

xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss')

xgb.fit(X_train, y_train)

y_pred_xgb = xgb.predict(X_test)

xgb_accuracy = accuracy_score(y_pred_xgb, y_test)

print(f'XGBoost Accuracy: {xgb_accuracy:.2f}')

AdaBoost

from sklearn.ensemble import AdaBoostClassifier

ada = AdaBoostClassifier(n_estimators=100, random_state=0)
ada.fit(X_train, y_train)
y_pred_ada = ada.predict(X_test)
ada_accuracy = accuracy_score(y_pred_ada, y_test)
print(f'AdaBoost Accuracy: {ada_accuracy:.2f}')

from sklearn.ensemble import AdaBoostClassifier

ada = AdaBoostClassifier(n_estimators=100, random_state=0)

ada.fit(X_train, y_train)

y_pred_ada = ada.predict(X_test)

ada_accuracy = accuracy_score(y_pred_ada, y_test)

print(f'AdaBoost Accuracy: {ada_accuracy:.2f}')

नोट: यह सुनिश्चित करें कि आपने xgboost लाइब्रेरी को pip install xgboost का उपयोग करके इंस्टॉल किया है।

निर्णय क्षेत्रों का विज़ुअलाइजेशन

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

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

# Load Iris dataset
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target

# Train KNN
knn_vis = KNeighborsClassifier(n_neighbors=3)
knn_vis.fit(X_vis, y_vis)

# Plot decision regions
plot_decision_regions(X_vis, y_vis, clf=knn_vis)

plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.legend()
plt.show()

from mlxtend.plotting import plot_decision_regions

import matplotlib.pyplot as plt

from sklearn import datasets

# Load Iris dataset

iris = datasets.load_iris()

X_vis = iris.data[:, :2]

y_vis = iris.target

# Train KNN

knn_vis = KNeighborsClassifier(n_neighbors=3)

knn_vis.fit(X_vis, y_vis)

# Plot decision regions

plot_decision_regions(X_vis, y_vis, clf=knn_vis)

plt.xlabel('Feature 1')

plt.ylabel('Feature 2')

plt.title('KNN Decision Regions')

plt.legend()

plt.show()

विज़ुअलाइजेशन आउटपुट: KNN क्लासिफायर द्वारा बनाए गए निर्णय सीमाओं को दर्शाने वाला एक प्लॉट।

निष्कर्ष

इस मार्गदर्शिका में, हमने विभिन्न मशीन लर्निंग मॉडलों—निर्णय वृक्ष, रैंडम फॉरेस्ट, लॉजिस्टिक रिग्रेशन, KNN, गॉसियन नायव बेयस, और SVM—को लागू करके Weather Australia डेटासेट का उपयोग करके मौसम की स्थितियों की भविष्यवाणी करने का पता लगाया है। प्रत्येक मॉडल ने प्रतिस्पर्धी एक्युरेसी स्कोर दिखाई, जिसमें लॉजिस्टिक रिग्रेशन, SVM, निर्णय वृक्ष, और रैंडम फॉरेस्ट ने लगभग 83% की एक्युरेसी हासिल की।

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