K-Fold क्रॉस-वैलिडेशन का कार्यान्वयन बिना GridSearchCV के कार मूल्य पूर्वानुमान के लिए

विषयसूची

परिचय
डेटासेट अवलोकन
डेटा पूर्वप्रसंस्करण
1. गुम डेटा को संभालना
2. विशेषता चयन
विशेषता अभियांत्रिकी
1. श्रेणीबद्ध चर का एन्कोडिंग
2. विशेषता स्केलिंग
प्रतिगमन मॉडल का निर्माण
K-Fold क्रॉस-वैलिडेशन का कार्यान्वयन
मॉडल प्रदर्शन का मूल्यांकन
निष्कर्ष

परिचय

कार की कीमतों की भविष्यवाणी एक क्लासिक प्रतिगमन समस्या है जिसमें इंजन का आकार, हॉर्सपावर, ईंधन प्रकार और अन्य विभिन्न विशेषताओं के आधार पर वाहन की कीमत का पूर्वानुमान लगाना शामिल है। K-Fold क्रॉस-वैलिडेशन को लागू करने से हमारे मॉडल की विश्वसनीयता बढ़ती है, यह सुनिश्चित करते हुए कि यह अप्रत्याशित डेटा पर भी अच्छा प्रदर्शन करता है। यह लेख दिखाता है कि डेटा को पूर्वप्रसंस्करण कैसे करना है, विशेषताओं को कैसे अभियांत्रित करना है, कई प्रतिगमन मॉडल कैसे बनाना है, और उनके प्रदर्शन का मूल्यांकन Python में K-Fold क्रॉस-वैलिडेशन का उपयोग करके कैसे करना है।

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

हम Kaggle से Car Price Prediction डेटासेट का उपयोग करेंगे, जिसमें विभिन्न कार मॉडलों की विस्तृत विशिष्टताएं उनके मूल्य के साथ शामिल हैं। डेटासेट में symboling, CarName, fueltype, aspiration, doornumber, carbody, और कई अन्य विशेषताएं शामिल हैं जो कार की कीमत को प्रभावित करती हैं।

डेटा पूर्वप्रसंस्करण

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

गुम डेटा को संभालना

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

संख्यात्मक विशेषताओं में गुम मानों को सांख्यिकीय उपायों का उपयोग करके संभाला जा सकता है। हम संख्यात्मक स्तंभों में गुम मानों को भरने के लिए औसत रणनीति का उपयोग करेंगे।

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

# Load the dataset
data = pd.read_csv('CarPrice.csv')
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

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

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

import numpy as np

import pandas as pd

from sklearn.impute import SimpleImputer

# Load the dataset

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

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

y = data.iloc[:, -1]

# Identify numerical columns

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

# Impute missing values with mean

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

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

श्रेणीबद्ध डेटा

श्रेणीबद्ध विशेषताओं के लिए, सबसे बारंबार मान रणनीति गुम मानों को भरने में प्रभावी है।

from sklearn.impute import SimpleImputer

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

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

from sklearn.impute import SimpleImputer

# Identify categorical columns

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

# Impute missing values with the most frequent value

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

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

विशेषता चयन

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

# Drop the 'car_ID' column as it does not contribute to price prediction
X.drop('car_ID', axis=1, inplace=True)

1 2	# Drop the 'car_ID' column as it does not contribute to price prediction X.drop('car_ID', axis=1, inplace=True)

विशेषता अभियांत्रिकी

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

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

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

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

# Identify categorical columns by their indices
string_cols = list(np.where((X.dtypes == object))[0])

# Apply One-Hot Encoding
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)
X = columnTransformer.fit_transform(X)

from sklearn.preprocessing import OneHotEncoder

from sklearn.compose import ColumnTransformer

# Identify categorical columns by their indices

string_cols = list(np.where((X.dtypes == object))[0])

# Apply One-Hot Encoding

columnTransformer = ColumnTransformer(

[('encoder', OneHotEncoder(), string_cols)],

remainder='passthrough'

)

X = columnTransformer.fit_transform(X)

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

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

from sklearn.preprocessing import StandardScaler

# Initialize the StandardScaler
sc = StandardScaler(with_mean=False)

# Fit and transform the training data
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

from sklearn.preprocessing import StandardScaler

# Initialize the StandardScaler

sc = StandardScaler(with_mean=False)

# Fit and transform the training data

sc.fit(X_train)

X_train = sc.transform(X_train)

X_test = sc.transform(X_test)

प्रतिगमन मॉडल का निर्माण

हम कार की कीमतों का पूर्वानुमान लगाने के लिए पांच विभिन्न प्रतिगमन मॉडलों का निर्माण और मूल्यांकन करेंगे:

डिसीजन ट्री रिग्रेशनर
रैंडम फ़ॉरेस्ट रिग्रेशनर
AdaBoost रिग्रेशनर
XGBoost रिग्रेशनर
सपोर्ट वेक्टर रिग्रेशनर (SVR)

डिसीजन ट्री रिग्रेशनर

डिसीजन ट्री रिग्रेशनर डेटा को विशेषताओं के मानों के आधार पर उपसमूहों में विभाजित करता है, जिससे इसे समझना आसान हो जाता है।

from sklearn.tree import DecisionTreeRegressor

# Initialize the model
decisionTreeRegressor = DecisionTreeRegressor(max_depth=4)

from sklearn.tree import DecisionTreeRegressor

# Initialize the model

decisionTreeRegressor = DecisionTreeRegressor(max_depth=4)

रैंडम फ़ॉरेस्ट रिग्रेशनर

रैंडम फ़ॉरेस्ट कई डिसीजन ट्री के पूर्वानुमानों को एकत्रित करता है, जिससे ओवरफ़िटिंग कम होती है और सटीकता में सुधार होता है।

from sklearn.ensemble import RandomForestRegressor

# Initialize the model
randomForestRegressor = RandomForestRegressor(n_estimators=25, random_state=10)

from sklearn.ensemble import RandomForestRegressor

# Initialize the model

randomForestRegressor = RandomForestRegressor(n_estimators=25, random_state=10)

AdaBoost रिग्रेशनर

AdaBoost कई कमजोर शिक्षकों को मिलाकर एक मजबूत पूर्वानुमान मॉडल बनाता है, उन उदाहरणों पर ध्यान केंद्रित करता है जिन्हें पहले गलत पूर्वानुमानित किया गया था।

from sklearn.ensemble import AdaBoostRegressor

# Initialize the model
adaBoostRegressor = AdaBoostRegressor(random_state=0, n_estimators=100)

from sklearn.ensemble import AdaBoostRegressor

# Initialize the model

adaBoostRegressor = AdaBoostRegressor(random_state=0, n_estimators=100)

XGBoost रिग्रेशनर

XGBoost एक अनुकूलित वितरित ग्रेडिएंट बूस्टिंग लाइब्रेरी है जिसे प्रदर्शन और गति के लिए डिज़ाइन किया गया है।

import xgboost as xgb

# Initialize the model
xgbRegressor = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)

import xgboost as xgb

# Initialize the model

xgbRegressor = xgb.XGBRegressor(

n_estimators=100,

reg_lambda=1,

gamma=0,

max_depth=3,

learning_rate=0.05

)

सपोर्ट वेक्टर रिग्रेशनर (SVR)

SVR प्रतिगमन कार्यों के लिए सपोर्ट वेक्टर मशीनों के सिद्धांतों का उपयोग करता है, जो उच्च-आयामी स्थानों में प्रभावी हैं।

from sklearn.svm import SVR

# Initialize the model
svr = SVR()

from sklearn.svm import SVR

# Initialize the model

svr = SVR()

K-Fold क्रॉस-वैलिडेशन का कार्यान्वयन

K-Fold क्रॉस-वैलिडेशन डेटासेट को k उपसमूहों में विभाजित करता है और मॉडल को k बार क्रमिक रूप से प्रशिक्षित और मान्य करता है, प्रत्येक बार एक अलग उपसमूह को वैलिडेशन सेट के रूप में उपयोग करता है।

from sklearn.model_selection import KFold
from sklearn.metrics import r2_score

# Define the K-Fold Cross Validator
kf = KFold(n_splits=10, random_state=42, shuffle=True)

# Function to build and evaluate the model
def build_model(X_train, X_test, y_train, y_test, model):
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    return r2_score(y_test, y_pred)

from sklearn.model_selection import KFold

from sklearn.metrics import r2_score

# Define the K-Fold Cross Validator

kf = KFold(n_splits=10, random_state=42, shuffle=True)

# Function to build and evaluate the model

def build_model(X_train, X_test, y_train, y_test, model):

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

return r2_score(y_test, y_pred)

K-Fold क्रॉस-वैलिडेशन चलाना

हम प्रत्येक मॉडल के प्रदर्शन का K-Folds में मूल्यांकन करेंगे और औसत R² स्कोर की गणना करेंगे।

# Initialize score lists
decisionTreeRegressor_scores = []
randomForestRegressor_scores = []
adaBoostRegressor_scores = []
xgbRegressor_scores = []
svr_scores = []

# Perform K-Fold Cross-Validation
for train_index, test_index in kf.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    
    # Decision Tree
    decisionTreeRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, decisionTreeRegressor)
    )
    
    # Random Forest
    randomForestRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, randomForestRegressor)
    )
    
    # AdaBoost
    adaBoostRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, adaBoostRegressor)
    )
    
    # XGBoost
    xgbRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, xgbRegressor)
    )
    
    # SVR
    svr_scores.append(
        build_model(X_train, X_test, y_train, y_test, svr)
    )

# Initialize score lists

decisionTreeRegressor_scores = []

randomForestRegressor_scores = []

adaBoostRegressor_scores = []

xgbRegressor_scores = []

svr_scores = []

# Perform K-Fold Cross-Validation

for train_index, test_index in kf.split(X):

X_train, X_test = X[train_index], X[test_index]

y_train, y_test = y[train_index], y[test_index]

# Decision Tree

decisionTreeRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, decisionTreeRegressor)

)

# Random Forest

randomForestRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, randomForestRegressor)

)

# AdaBoost

adaBoostRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, adaBoostRegressor)

)

# XGBoost

xgbRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, xgbRegressor)

)

# SVR

svr_scores.append(

build_model(X_train, X_test, y_train, y_test, svr)

)

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

K-Fold क्रॉस-वैलिडेशन चलाने के बाद, हम प्रत्येक मॉडल के लिए औसत R² स्कोर की गणना करेंगे ताकि उनके प्रदर्शन का आकलन किया जा सके।

from statistics import mean

print('Decision Tree Regressor Mean R² Score: ', mean(decisionTreeRegressor_scores))
print('Random Forest Regressor Mean R² Score: ', mean(randomForestRegressor_scores))
print('AdaBoost Regressor Mean R² Score: ', mean(adaBoostRegressor_scores))
print('XGBoost Regressor Mean R² Score: ', mean(xgbRegressor_scores))
print('SVR Mean R² Score: ', mean(svr_scores))

from statistics import mean

print('Decision Tree Regressor Mean R² Score: ', mean(decisionTreeRegressor_scores))

print('Random Forest Regressor Mean R² Score: ', mean(randomForestRegressor_scores))

print('AdaBoost Regressor Mean R² Score: ', mean(adaBoostRegressor_scores))

print('XGBoost Regressor Mean R² Score: ', mean(xgbRegressor_scores))

print('SVR Mean R² Score: ', mean(svr_scores))

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

Decision Tree Regressor Mean R² Score:  0.8786768422448108
Random Forest Regressor Mean R² Score:  0.9070724684428952
AdaBoost Regressor Mean R² Score:  0.894756851083693
XGBoost Regressor Mean R² Score:  0.9049838393114154
SVR Mean R² Score:  -0.1510507928400266

Decision Tree Regressor Mean R² Score: 0.8786768422448108

Random Forest Regressor Mean R² Score: 0.9070724684428952

AdaBoost Regressor Mean R² Score: 0.894756851083693

XGBoost Regressor Mean R² Score: 0.9049838393114154

SVR Mean R² Score: -0.1510507928400266

व्याख्या:

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

निष्कर्ष

K-Fold क्रॉस-वैलिडेशन को लागू करने से प्रतिगमन मॉडलों के प्रदर्शन का मूल्यांकन करने के लिए एक मजबूत विधि प्रदान होती है, यह सुनिश्चित करते हुए कि परिणाम सामान्यीकृत हैं और किसी विशेष ट्रेन-टेस्ट विभाजन पर निर्भर नहीं हैं। इस मार्गदर्शिका में, हमने दिखाया कि डेटा को पूर्वप्रसंस्करण कैसे करना है, श्रेणीबद्ध चर को एन्कोड कैसे करना है, विशेषताओं को स्केल कैसे करना है, कई प्रतिगमन मॉडल कैसे बनाना है, और GridSearchCV के बिना K-Fold क्रॉस-वैलिडेशन का उपयोग करके उनके प्रदर्शन का मूल्यांकन कैसे करना है।

मुख्य बिंदु:

डेटा पूर्वप्रसंस्करण: गुम डेटा को ठीक से संभालना और विशेषताओं का चयन करना मॉडल के प्रदर्शन के लिए महत्वपूर्ण हैं।
विशेषता अभियांत्रिकी: श्रेणीबद्ध चर को एन्कोड करना और विशेषताओं को स्केल करना मॉडल की पैटर्न सीखने की क्षमता पर महत्वपूर्ण प्रभाव डाल सकता है।
मॉडल मूल्यांकन: K-Fold क्रॉस-वैलिडेशन यह आकलन करने का एक विश्वसनीय तरीका प्रदान करता है कि आपका मॉडल अप्रत्याशित डेटा पर कितना अच्छा सामान्यीकरण करता है।
मॉडल चयन: परीक्षण किए गए मॉडलों में, रैंडम फ़ॉरेस्ट और XGBoost जैसे एन्सेम्बल विधियां इस विशेष मामले में डिसीजन ट्रीज़ और SVR जैसे सरल मॉडलों की तुलना में बेहतर प्रदर्शन करती हैं।

आगे की अनुकूलन के लिए, GridSearchCV या RandomizedSearchCV जैसी हायपरपैरामीटर ट्यूनिंग तकनीकों को एकीकृत करने से प्रत्येक एल्गोरिदम के लिए सर्वोत्तम सेट पैरामीटर खोजकर मॉडल के प्रदर्शन में सुधार हो सकता है।

—

इस संरचित दृष्टिकोण का पालन करके, आप विभिन्न प्रतिगमन कार्यों के लिए K-Fold क्रॉस-वैलिडेशन को प्रभावी ढंग से लागू कर सकते हैं, यह सुनिश्चित करते हुए कि आपके मॉडल सटीक और मजबूत दोनों हैं।