रैंडम फ़ॉरेस्ट, प्रमुख घटकों की विधि और हाइपरपरमेटर्स के अनुकूलन: पायथन में वर्गीकरण समस्या को हल करने का एक उदाहरण

1. आरएफ एल्गोरिथ्म पर आधारित बुनियादी मॉडल (हम इस आरएफ मॉडल को संक्षिप्त करेंगे)।
2. नंबर 1 के रूप में एक ही मॉडल, लेकिन एक जिसमें प्रमुख घटक विधि (आरएफ + पीसीआर) का उपयोग करके सुविधा स्थान के आयाम में कमी लागू की जाती है।
3. नंबर 2 के रूप में एक ही मॉडल, लेकिन हाइपरपरमीटर ऑप्टिमाइज़ेशन (आरएफ + पीसीए + एचटी) का उपयोग करके बनाया गया।

1. आयात डेटा

• df.head() - नए डेटा फ़्रेम को देखने के लिए और यह देखें कि क्या यह अपेक्षित है।
• df.info()- डेटा प्रकार और स्तंभ सामग्री की सुविधाओं का पता लगाने के लिए। जारी रखने से पहले डेटा प्रकार रूपांतरण करना आवश्यक हो सकता है।
• df.isna()- यह सुनिश्चित करने के लिए कि डेटा में कोई मान नहीं हैं NaN। संबंधित मान, यदि कोई हो, को किसी तरह संसाधित करने की आवश्यकता हो सकती है, या यदि आवश्यक हो, तो डेटा फ़्रेम से संपूर्ण पंक्तियों को निकालना आवश्यक हो सकता है।
• df.describe() - स्तंभों में संकेतक के न्यूनतम, अधिकतम, औसत मूल्यों का पता लगाने के लिए, स्तंभों में औसत वर्ग और संभावित विचलन के संकेतकों का पता लगाने के लिए।

import pandas as pd
from sklearn.datasets import load_breast_cancer
columns = ['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension']
dataset = load_breast_cancer()
data = pd.DataFrame(dataset['data'], columns=columns)
data['cancer'] = dataset['target']
display(data.head())
display(data.info())
display(data.isna().sum())
display(data.describe())

2.

from sklearn.model_selection import train_test_split
X = data.drop('cancer', axis=1)  
y = data['cancer'] 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.50, random_state = 2020, stratify=y)

3. डेटा स्केलिंग

import numpy as np
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
X_train_scaled = ss.fit_transform(X_train)
X_test_scaled = ss.transform(X_test)
y_train = np.array(y_train)

4. मूल मॉडल का प्रशिक्षण (मॉडल नंबर 1, आरएफ)

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import recall_score
rfc = RandomForestClassifier()
rfc.fit(X_train_scaled, y_train)
display(rfc.score(X_train_scaled, y_train))
# 1.0

feats = {}
for feature, importance in zip(data.columns, rfc_1.feature_importances_):
    feats[feature] = importance
importances = pd.DataFrame.from_dict(feats, orient='index').rename(columns={0: 'Gini-Importance'})
importances = importances.sort_values(by='Gini-Importance', ascending=False)
importances = importances.reset_index()
importances = importances.rename(columns={'index': 'Features'})
sns.set(font_scale = 5)
sns.set(style="whitegrid", color_codes=True, font_scale = 1.7)
fig, ax = plt.subplots()
fig.set_size_inches(30,15)
sns.barplot(x=importances['Gini-Importance'], y=importances['Features'], data=importances, color='skyblue')
plt.xlabel('Importance', fontsize=25, weight = 'bold')
plt.ylabel('Features', fontsize=25, weight = 'bold')
plt.title('Feature Importance', fontsize=25, weight = 'bold')
display(plt.show())
display(importances)

5. प्रमुख घटकों की विधि

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.decomposition import PCA
pca_test = PCA(n_components=30)
pca_test.fit(X_train_scaled)
sns.set(style='whitegrid')
plt.plot(np.cumsum(pca_test.explained_variance_ratio_))
plt.xlabel('number of components')
plt.ylabel('cumulative explained variance')
plt.axvline(linewidth=4, color='r', linestyle = '--', x=10, ymin=0, ymax=1)
display(plt.show())
evr = pca_test.explained_variance_ratio_
cvr = np.cumsum(pca_test.explained_variance_ratio_)
pca_df = pd.DataFrame()
pca_df['Cumulative Variance Ratio'] = cvr
pca_df['Explained Variance Ratio'] = evr
display(pca_df.head(10))

pca = PCA(n_components=10)
pca.fit(X_train_scaled)
X_train_scaled_pca = pca.transform(X_train_scaled)
X_test_scaled_pca = pca.transform(X_test_scaled)

pca_dims = []
for x in range(0, len(pca_df)):
    pca_dims.append('PCA Component {}'.format(x))
pca_test_df = pd.DataFrame(pca_test.components_, columns=columns, index=pca_dims)
pca_test_df.head(10).T

6. मूल घटक मॉडल को डेटा (मॉडल नंबर 2, आरएफ + पीसीए) में लागू करने के बाद बुनियादी आरएफ मॉडल का प्रशिक्षण

rfc = RandomForestClassifier()
rfc.fit(X_train_scaled_pca, y_train)
display(rfc.score(X_train_scaled_pca, y_train))
# 1.0

7. हाइपरपरमेटर्स का अनुकूलन। राउंड 1: रैंडमाइंडसर्च सीवीसी

• n_estimators - "यादृच्छिक वन" में "पेड़" की संख्या।
• max_features - बंटवारे का चयन करने के लिए सुविधाओं की संख्या।
• max_depth - पेड़ों की अधिकतम गहराई।
• min_samples_split - विभाजित करने के लिए ट्री नोड के लिए आवश्यक वस्तुओं की न्यूनतम संख्या।
• min_samples_leaf - पत्तियों में वस्तुओं की न्यूनतम संख्या।
• bootstrap - वापसी के साथ उप-वृक्षों के निर्माण के लिए उपयोग करें।

from sklearn.model_selection import RandomizedSearchCV
n_estimators = [int(x) for x in np.linspace(start = 100, stop = 1000, num = 10)]
max_features = ['log2', 'sqrt']
max_depth = [int(x) for x in np.linspace(start = 1, stop = 15, num = 15)]
min_samples_split = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]
min_samples_leaf = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]
bootstrap = [True, False]
param_dist = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}
rs = RandomizedSearchCV(rfc_2, 
                        param_dist, 
                        n_iter = 100, 
                        cv = 3, 
                        verbose = 1, 
                        n_jobs=-1, 
                        random_state=0)
rs.fit(X_train_scaled_pca, y_train)
rs.best_params_
# {'n_estimators': 700,
# 'min_samples_split': 2,
# 'min_samples_leaf': 2,
# 'max_features': 'log2',
# 'max_depth': 11,
# 'bootstrap': True}

rs_df = pd.DataFrame(rs.cv_results_).sort_values('rank_test_score').reset_index(drop=True)
rs_df = rs_df.drop([
            'mean_fit_time', 
            'std_fit_time', 
            'mean_score_time',
            'std_score_time', 
            'params', 
            'split0_test_score', 
            'split1_test_score', 
            'split2_test_score', 
            'std_test_score'],
            axis=1)
rs_df.head(10)

fig, axs = plt.subplots(ncols=3, nrows=2)
sns.set(style="whitegrid", color_codes=True, font_scale = 2)
fig.set_size_inches(30,25)
sns.barplot(x='param_n_estimators', y='mean_test_score', data=rs_df, ax=axs[0,0], color='lightgrey')
axs[0,0].set_ylim([.83,.93])axs[0,0].set_title(label = 'n_estimators', size=30, weight='bold')
sns.barplot(x='param_min_samples_split', y='mean_test_score', data=rs_df, ax=axs[0,1], color='coral')
axs[0,1].set_ylim([.85,.93])axs[0,1].set_title(label = 'min_samples_split', size=30, weight='bold')
sns.barplot(x='param_min_samples_leaf', y='mean_test_score', data=rs_df, ax=axs[0,2], color='lightgreen')
axs[0,2].set_ylim([.80,.93])axs[0,2].set_title(label = 'min_samples_leaf', size=30, weight='bold')
sns.barplot(x='param_max_features', y='mean_test_score', data=rs_df, ax=axs[1,0], color='wheat')
axs[1,0].set_ylim([.88,.92])axs[1,0].set_title(label = 'max_features', size=30, weight='bold')
sns.barplot(x='param_max_depth', y='mean_test_score', data=rs_df, ax=axs[1,1], color='lightpink')
axs[1,1].set_ylim([.80,.93])axs[1,1].set_title(label = 'max_depth', size=30, weight='bold')
sns.barplot(x='param_bootstrap',y='mean_test_score', data=rs_df, ax=axs[1,2], color='skyblue')
axs[1,2].set_ylim([.88,.92])
axs[1,2].set_title(label = 'bootstrap', size=30, weight='bold')
plt.show()

• n_estimators: 300, 500, 700 के मूल्य, जाहिरा तौर पर, सबसे अच्छा औसत परिणाम दिखाते हैं।
• min_samples_split: 2 और 7 जैसे छोटे मूल्य सर्वोत्तम परिणाम दिखाते हैं। मान 23 भी अच्छा लगता है। आप इस हाइपरपरमीटर के कई मानों को 2 से अधिक के साथ-साथ लगभग 23 के कई मानों की जाँच कर सकते हैं।
• min_samples_leaf: एक भावना है कि इस हाइपरपरमीटर के छोटे मूल्य बेहतर परिणाम देते हैं। इसका मतलब है कि हम 2 और 7 के बीच मूल्यों का अनुभव कर सकते हैं।
• max_features: विकल्प sqrtउच्चतम औसत परिणाम देता है।
• max_depth: हाइपरपरमीटर के मूल्य और मॉडल के परिणाम के बीच कोई स्पष्ट संबंध नहीं है, लेकिन एक भावना है कि मान 2, 3, 7, 11, 15 अच्छे लगते हैं।
• bootstrap: मूल्य Falseसबसे अच्छा औसत परिणाम दिखाता है।

8. हाइपरपरमेटर्स का अनुकूलन। राउंड 2: ग्रिडसर्च सीवी (मॉडल नंबर 3, आरएफ + पीसीए + एचटी के लिए मापदंडों की अंतिम तैयारी)

from sklearn.model_selection import GridSearchCV
n_estimators = [300,500,700]
max_features = ['sqrt']
max_depth = [2,3,7,11,15]
min_samples_split = [2,3,4,22,23,24]
min_samples_leaf = [2,3,4,5,6,7]
bootstrap = [False]
param_grid = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}
gs = GridSearchCV(rfc_2, param_grid, cv = 3, verbose = 1, n_jobs=-1)
gs.fit(X_train_scaled_pca, y_train)
rfc_3 = gs.best_estimator_
gs.best_params_
# {'bootstrap': False,
# 'max_depth': 7,
# 'max_features': 'sqrt',
# 'min_samples_leaf': 3,
# 'min_samples_split': 2,
# 'n_estimators': 500}

9. सत्यापन डेटा पर मॉडल की गुणवत्ता का मूल्यांकन

y_pred = rfc.predict(X_test_scaled)
y_pred_pca = rfc.predict(X_test_scaled_pca)
y_pred_gs = gs.best_estimator_.predict(X_test_scaled_pca)

from sklearn.metrics import confusion_matrix
conf_matrix_baseline = pd.DataFrame(confusion_matrix(y_test, y_pred), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
conf_matrix_baseline_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_pca), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
conf_matrix_tuned_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_gs), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
display(conf_matrix_baseline)
display('Baseline Random Forest recall score', recall_score(y_test, y_pred))
display(conf_matrix_baseline_pca)
display('Baseline Random Forest With PCA recall score', recall_score(y_test, y_pred_pca))
display(conf_matrix_tuned_pca)
display('Hyperparameter Tuned Random Forest With PCA Reduced Dimensionality recall score', recall_score(y_test, y_pred_gs))

सारांश