In [1]:
import pandas as pd
pd.set_option('display.max_columns', 50)
import numpy as np
import os
os.chdir('D:\Data\Projects\Klassifikation\Klassifikation_West Nile Virus')
import plotly_express as px
import matplotlib.pyplot as plt
plt.style.use('Solarize_Light2')
from IPython.core.pylabtools import figsize
import seaborn as sns
from warnings import filterwarnings
filterwarnings('ignore')
In [2]:
from sklearn.model_selection import train_test_split
from imblearn.over_sampling import SMOTE
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_curve, classification_report, accuracy_score
from sklearn.metrics import f1_score, confusion_matrix, roc_auc_score
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RandomizedSearchCV
from sklearn import metrics
from sklearn.ensemble import RandomForestClassifier
Einlesen des kombinierten Datensatzes¶
In [3]:
df = pd.read_csv('combined.csv')
df.head()
Out[3]:
Aufteilen des Datensatzes in Train und Test¶
In [4]:
x = df.drop('WnvPresent', axis=1)
y = df.WnvPresent
In [5]:
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)
X_train.shape, X_test.shape, y_train.shape, y_test.shape
Out[5]:
Resampling und Skalieren¶
In [6]:
sm = SMOTE()
X_train_s, y_train_s = sm.fit_sample(X_train, y_train)
print(y_train.value_counts())
print(np.bincount(y_train_s))
In [7]:
sc = StandardScaler()
sc.fit(X_train_s)
X_train_s = sc.transform(X_train_s)
X_tests = sc.transform(X_test)
Baseline¶
Vorhersage der häufigeren Klasse. Wenn immer 0 vorhergesagt wird, ist die Accuracy bei fast 95%
In [8]:
1-((df.WnvPresent).mean())
Out[8]:
Random Forest Classifier Baseline Resampled und Skaliert¶
In [9]:
rf = RandomForestClassifier(random_state=42)
In [10]:
rf.fit(X_train_s, y_train_s)
y_pred = rf.predict(X_tests)
y_pred_proba = rf.predict_proba(X_tests)
In [11]:
accuracy_score(y_test, y_pred)
Out[11]:
In [12]:
confusion_matrix(y_test, y_pred)
Out[12]:
Random Forest Classifier Baseline Original Datensatz¶
In [13]:
rf.fit(X_train, y_train)
y_pred1 = rf.predict(X_test)
y_pred_proba1 = rf.predict_proba(X_test)
In [14]:
accuracy_score(y_test, y_pred1)
Out[14]:
In [15]:
confusion_matrix(y_test, y_pred1)
Out[15]:
Das Ergebnis war vorherzusehen, da das Ensemble aus Decision Trees aufgrund der Art des Lernens im Allgemeinen kein Oversampling und kein Skalieren braucht. Weiterhin wird der Original-Datensatz verwendet.
Hyperparameter Tuning¶
In [16]:
# Hyperparameter des Random Forest Klassifizierers
rf.get_params()
Out[16]:
In [17]:
# Hyperparameter grid erstellen
param_grid = {
'n_estimators': np.linspace(100, 150).astype(int),
'max_depth': [None] + list(np.linspace(5, 30).astype(int)),
'max_features': ['auto', 'sqrt', None] + list(np.arange(0.5, 1, 0.1)),
'max_leaf_nodes': [None] + list(np.linspace(10, 50, 500).astype(int)),
'min_samples_split': [2, 5, 10]
}
# Random Forest
estimator = RandomForestClassifier(random_state = 42)
# Das Random Search Model
random = RandomizedSearchCV(estimator, param_grid, n_jobs = -1,
scoring = 'neg_mean_absolute_error', cv = 3,
n_iter = 100, verbose = 0, random_state=42)
In [18]:
#print(random)
In [19]:
random.fit(X_train, y_train)
Out[19]:
In [20]:
model = random.best_estimator_
In [21]:
#model
In [22]:
model.n_jobs = -1
model.fit(X_train, y_train)
Out[22]:
In [23]:
test_preds = model.predict(X_test)
pred_proba = model.predict_proba(X_test)[:,1]
In [24]:
pred_proba
Out[24]:
In [25]:
accuracy_score(y_test, test_preds)
Out[25]:
In [33]:
confusion_matrix(y_test, test_preds)
Out[33]:
Ein Hauch besser als die Baseline
Test mit geringerem Threshold¶
In [26]:
from sklearn.preprocessing import binarize
In [27]:
# Threshold von 0.4
y_pred_ = model.predict_proba(X_test)
In [28]:
y_pred_class = binarize(y_pred_, 0.4)[:,1]
In [30]:
accuracy_score(y_test, y_pred_class)
Out[30]:
In [32]:
confusion_matrix(y_test, y_pred_class)
Out[32]:
Es kann sinnvoll sein, den Threshold zu verringern, um überhaupt positive Fälle zu finden.
Test mit höherem Threshold¶
In [34]:
from sklearn.preprocessing import binarize
In [35]:
# Threshold von 0.6
y_pred_ = model.predict_proba(X_test)
In [36]:
y_pred_class = binarize(y_pred_, 0.6)[:,1]
In [37]:
accuracy_score(y_test, y_pred_class)
Out[37]:
In [38]:
confusion_matrix(y_test, y_pred_class)
Out[38]:
Feature Importances¶
In [42]:
fi = pd.Series(data=model.feature_importances_, index=X_train.columns).sort_values(ascending=False)
plt.rcParams['font.size'] = 15
plt.figure(figsize=(20,18))
plt.title("Feature Importances", fontsize = 30)
plt.ylabel('Variable', fontsize = 25);
plt.xlabel('Importance', fontsize = 25);
sns.barplot(y=fi.index, x=fi.values, palette="Blues_d", orient='h');
