Random Forest ist bei der Anwendung von Big Data sehr verbreitet und weist im Vergleich zu SVM, multipler linearer Regression, logistischer Regression und polynomialer Regression eine bessere Robustheit bei Vorhersage und Regression auf.
Ein Random Forest ist ein Klassifikator, der aus mehreren zufällig erstellten Entscheidungsbäumen besteht. Die Ausgabekategorie wird durch den Modus der von jedem Baum ausgegebenen Kategorie bestimmt.
Vorteil:
- Bei der Verarbeitung von Daten mit hohem Breitengrad ohne Merkmalsauswahl können natürlich auch zufällige Wälder für das Merkmalsscreening verwendet werden .
- Starke Fähigkeit zur Modellverallgemeinerung
- Bei unausgeglichenen Datensätzen können die Fehler ausgeglichen werden.
- Unempfindlich gegenüber fehlenden Werten und Ausreißern.
Mangel:
- Wenn das Datenrauschen relativ groß ist, kommt es zu einer Überanpassung.
- Bei den Daten von Attributen mit unterschiedlichen Werten haben Attribute mit mehr Wertunterteilungen einen größeren Einfluss auf die zufällige Gesamtstruktur.
Reden Sie keinen Unsinn, sondern gehen Sie direkt zur Trockenware über
Grundlegende Implementierung von Random-Forest-Code
Klassifizierungsmodell
from sklearn.ensemble import RandomForestClassifier
#模型训练
forest = RandomForestClassifier()
forest.fit(x_train.values, y_train.values) #训练集和训练集标签
#模型评估
score = forest.score(x_test, y_test)
print(score) #这里的score代表的acc，精确率
#模型预测
pre = forest.predict(x_test)
print(pre)
#模型预测--输出概率值
pre_p = forest.predict_proba(x_test)
print(pre_p)
#计算模型运行的时间
import time
start = time.time()
end = time.time()
end-start
Gleichzeitig müssen wir bei Klassifizierungsproblemen häufig Indikatoren wie Verwirrungsmatrix, Genauigkeitsrate, Präzisionsrate, Rückrufrate, F1-Index usw. verwenden.
Das Folgende ist die Berechnungsmethode des Bewertungsindex des Klassifizierungsmodells
#分类模型的评估指标
from sklearn import metrics
import seaborn as sns
import matplotlib.pyplot as plt
class ClassEval():
def __init__(self, pre,y_test):
self.pre = pre
self.y_test = y_test
self.C2 = None
'''计算混淆矩阵'''
def confusion_matrix(self):
self.C2 = metrics.confusion_matrix(self.y_test,self.pre, labels=[0,1])
return self.C2
'''绘制混淆矩阵热图'''
def C2_heatmap(self):
self.confusion_matrix()
#绘图
sns.set()
f, ax = plt.subplots(figsize=(8, 7))
TX = sns.heatmap(self.C2, annot=True, ax=ax, cmap="Spectral_r", fmt=".20g") # 热力图
#标题设置
ax.set_title("Confusion Matrix")
ax.set_xlabel("Predict")
ax.set_ylabel("Answer")
print("混淆矩阵")
'''计算准确率'''
def get_acc(self):
self.confusion_matrix()
print(type(self.C2))
#计算
acc = np.trace(self.C2)/self.C2.sum()
return acc
'''计算精准率'''
def get_precision(self):
self.confusion_matrix()
Precision = []
i = 0
for row in self.C2:
TP = row[i]
TP_FP = 0
for col in row:
TP_FP += col
Precision.append(TP/TP_FP)
i+=1
return Precision;
'''计算召回率'''
def get_Recall(self):
self.confusion_matrix()
Recall = []
i = 0
TP_FN = np.sum(self.C2, axis=0)
for row in self.C2:
TP = row[i]
Recall.append(TP/TP_FN[i])
i+=1
return Recall
'''计算F1指数'''
def get_F1(self):
self.confusion_matrix()
Precision = self.get_precision()
Recall = self.get_Recall()
F1 = []
for i in range(len(Precision)):
F1.append(2*Precision[i]*Recall[i] / (Precision[i] + Recall[i]))
return F1
'''计算kappa系数'''
def get_kappa(self):
self.confusion_matrix()
kappa = metrics.cohen_kappa_score(np.array(self.predict_label_list).astype(np.int16),np.array(self.answer_label_list).astype(np.int16))
return kappa
RF_data = ClassEval(pre, y_test.values)
# RF_data.C2_heatmap()
print("精确度",RF_data.get_acc())
print("精准率",RF_data.get_precision())
print("召回率",RF_data.get_Recall())
print("F1值",RF_data.get_F1())
Regressionsmodell
from sklearn.ensemble import RandomForestRegressor
#训练模型
forest = RandomForestRegressor()
forest.fit(x_train.values, y_train.values) #训练集和训练集标签
#模型评估
score = forest.score(x_test, y_test)
print(score) #这里的score代表的R2分数
#模型预测
pre = forest.predict(x_test)
print(pre)
#计算模型运行的时间
import time
start = time.time()
end = time.time()
end-start
Die Bewertungsindexergebnisse des Regressionsmodells sind wie folgt
MSE: mittlerer quadratischer Fehler, die Summe der Quadrate der Abweichung zwischen dem beobachteten Wert und dem wahren Wert, die die Genauigkeit des Vorhersageergebnisses widerspiegelt.
RMSE: Die arithmetische Quadratwurzel von MSE, die zur Messung der Abweichung zwischen dem beobachteten Wert und dem wahren Wert verwendet wird. (Nach dem Öffnen des Wurzelzeichens liegt das Ergebnis des Fehlers auf dem gleichen Niveau wie der wahre Wert.)
MAE: Mittlerer absoluter Fehler, der die tatsächliche Situation des vorhergesagten Wertfehlers besser widerspiegeln kann
R2: Zwischen 0 und 1 gilt: Je näher an 1, desto besser ist der Regressionsanpassungseffekt
MSE ist einfach zu berechnen, MAE weist jedoch eine bessere Robustheit gegenüber Ausreißern auf.
Vor- und Nachteile von MSE und MAE
-
MSE nimmt das Quadrat des Fehlers (es sei e = wahrer Wert – vorhergesagter Wert). Wenn also e> 1, erhöht MSE den Fehler weiter. Wenn die Daten Ausreißer enthalten, ist der Wert von e sehr groß und e ist viel größer als |e|. Daher wird das Modell, das MSE verwendet, Ausreißern mehr Gewicht beimessen als das Modell, das MAE zur Berechnung des Verlusts verwendet. Im zweiten Beispiel wird das Modell, das RMSE zur Berechnung des Verlusts verwendet, aktualisiert, um den Fehler des Ausreißers auf Kosten des Fehlers anderer Stichproben zu verringern. Allerdings verringert sich dadurch die Gesamtleistung des Modells. Der MAE-Verlust funktioniert besser, wenn die Trainingsdaten durch Ausreißer verunreinigt sind (z. B. gibt es viele falsche negative und positive Bezeichnungen in den Trainingsdaten, aber nicht im Testsatz).
-
Intuitiv kann es wie folgt verstanden werden: Wenn wir MSE minimieren, um nur einen vorhergesagten Wert für alle Stichprobenpunkte zu erhalten, muss dieser Wert der Durchschnitt aller Zielwerte sein. Wenn jedoch MAE minimiert werden soll, ist dieser Wert der Median der Zielwerte aller Stichprobenpunkte. Es ist bekannt, dass der Median gegenüber Ausreißern robuster ist als der Mittelwert, sodass MAE auch gegenüber Ausreißern stabiler ist als MSE.
-
Bei MAE gibt es ein gravierendes Problem (insbesondere bei neuronalen Netzen): Der Gradient der Aktualisierung ist immer gleich, das heißt, der Gradient ist auch bei kleinen Verlustwerten groß. Dies ist nicht förderlich für das Lernen des Modells. Um diesen Mangel zu beheben, können wir eine variable Lernrate verwenden, die die Lernrate verringert, wenn sich der Verlust seinem Minimum nähert. MSE schneidet in diesem Fall sehr gut ab und kann selbst bei einer festen Lernrate effektiv konvergieren. Der Gradient des MSE-Verlusts nimmt mit zunehmendem Verlust zu und nimmt ab, wenn sich der Verlust 0 nähert. Dadurch werden die Ergebnisse der Verwendung des MSE-Modells am Ende des Trainings genauer.
Wahl zwischen MSE und MAE
Wenn der Ausreißer eine ungewöhnliche Situation darstellt, die für das Unternehmen wichtig ist und erkannt werden muss, sollte die MSE-Verlustfunktion verwendet werden. Wenn dagegen nur Ausreißer als beschädigte Daten betrachtet werden, sollte die MAE-Verlustfunktion ausgewählt werden. Im Allgemeinen ist die MAE-Verlustfunktion beim Umgang mit Ausreißern stabiler, ihre Ableitung ist jedoch diskontinuierlich, sodass die Lösungseffizienz gering ist. Die MSE-Verlustfunktion reagiert empfindlicher auf Ausreißer, aber wenn ihre Ableitung auf 0 gesetzt wird, kann eine stabilere geschlossene Lösung erhalten werden.
from sklearn.metrics import mean_squared_error #MSE
from sklearn.metrics import mean_absolute_error #MAE
from sklearn.metrics import r2_score#R2
import numpy as np
R2 = r2_score(y_test,pre) #真实数据和预测数据
MSE = mean_squared_error(y_test,pre)
MAE = mean_absolute_error(y_test,pre)
RMSE = np.sqrt(MSE)
Optimierung der zufälligen Suche für zufällige Wälder
get_params()Die Parameter des Zufallswaldes können über die Funktion ermittelt werden
- n_esimators: Anzahl der zu verwendenden Bäume
- max_feauters: Die Anzahl der Features, die für jede Knotenaufteilung verwendet werden sollen
- max_ Depth: die Anzahl der Blätter an jedem Baum
- min_samples_split: Die Mindestanzahl an Samples, die zum Teilen eines internen Knotens erforderlich sind
- min_samples_leaf: die minimale Anzahl von Samples in jedem Blatt
- Bootstrap: Stichprobenmethode, ob ersetzt werden soll.
Scikit-learn stellt die Klasse RandomizedSearchCV zur Implementierung einer Zufallssuche bereit. Für die Erstellung sind zwei Parameter erforderlich: ein Schätzer und eine Reihe möglicher Werte für die Hyperparameter, die als Parametergitter oder -raum bezeichnet werden. Definieren wir dieses Parameterraster für unser Random-Forest-Modell:
from sklearn.model_selection import RandomizedSearchCV
#设置各类参数的范围
n_estimators = np.arange(100, 2000, step=100) #从100，2000，步长为100
max_features = ["auto", "sqrt", "log2"] #max_features的几种选择
max_depth = list(np.arange(10, 100, step=10)) + [None] #深度计算
min_samples_split = np.arange(2, 10, step=2) #最小分割
min_samples_leaf = [1, 2, 4] #最小叶子
bootstrap = [True, 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,
}
#随机参数调优
forest = RandomForestRegressor()
'''
n_iter参数，控制我们在搜索中允许的超参数组合的随机选择的迭代次数。
cv:同时也表示三折交叉验证
scoring：评分标准
n_jobs=-1：表示使用机器上的所有内核
'''
random_cv = RandomizedSearchCV(
forest, param_grid, n_iter=100, cv=3, scoring="r2", n_jobs=-1
)
random_cv.fit(X, y)
print("Best params:\n")
print(random_cv.best_params_)
Obwohl Sie verschiedene Stimmmethoden verwenden, benötigen Sie auch Ausdruck. Sie müssen Ihren Tuning-Prozess visualisieren
Optimierung der Rastersuche für zufällige Wälder
Im Vergleich zur Zufallssuche ist die Rastersuche ähnlich und umfassend.
Mit 13680 möglichen Hyperparameterkombinationen und einem dreifachen CV muss GridSearchCV 41040 Mal in den Zufallswald passen. Mit RandomizedGridSearchCV erhalten wir ziemlich gute Ergebnisse und benötigen nur 100 * 3 = 300 Trainingsepochen.
new_params = {
"n_estimators": [650, 700, 750, 800, 850, 900, 950, 1000],
"max_features": ['sqrt'],
"max_depth": [10, 15, 20, 25, 30],
"min_samples_split": [2, 4, 6],
"min_samples_leaf": [1, 2],
"bootstrap": [False],
}
from sklearn.model_selection import GridSearchCV
forest = RandomForestRegressor()
'''
这里我们不需要指定评分和CV，这里采用了默认设置
'''
grid_cv = GridSearchCV(forest, new_params, n_jobs=-1)
grid_cv.fit(X, y)
print('Best params:\n')
print(grid_cv.best_params_, '\n')
Wenn Sie in der Praxis rechenintensive Modelle verwenden, ist es besser, die Ergebnisse einer Zufallssuche zu erhalten und sie in einer Rastersuche in kleinerem Maßstab zu validieren.
k-fache Kreuzvalidierung für zufällige Wälder
Teilen Sie die Daten im Durchschnitt in k gleiche Teile auf, nehmen Sie einen Teil zum Testen in jedem Experiment und verwenden Sie den Rest zum Training.
Daher sind die von Ihnen trainierten Modelle ebenfalls k, und Sie müssen k-mal experimentieren, um den Durchschnitt zu ermitteln.
from sklearn.model_selection import KFold
import pandas as pd
import numpy as np
#数据分割
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)
#转成numpy格式
x_train = np.array(x_train)
y_train = np.array(y_train)
#这里的k表示进行几折交叉验证
k = 2
kfolder = KFold(n_splits=k, shuffle=True,random_state=0)
kfold = kfolder.split(x_train, y_train)
for train_index, val_index in kfold:
k_x_train = x_train[train_index] #训练集
k_y_train = y_train[train_index] #测试集标签
k_x_vali = x_train[val_index] #验证集
k_y_vali = y_train[val_index] #验证集标签
forest = RandomForestRegressor() #回归采用平均值
#forest = RandomForestClassifier() #分类采用投票法
forest.fit(k_x_train, k_y_train) #训练集和训练集标签
score = forest.score(x_test, y_test)
print(score) #这里的score代表的acc，精确率
Dies ist nur eine einfache Implementierung. Die Fusion der endgültigen vorhergesagten Ergebnisse erfordert Ihre eigene flexible Kombination. Sie können den Durchschnittswert oder die Stapelmethode usw. verwenden.
Zufälliges Screening von Waldmerkmalen
Der Hauptgrund ist die Bedeutung visueller Merkmale. Aufgrund der Daten der zufälligen Gesamtstruktur zu Attributen mit unterschiedlichen Werten haben Attribute mit mehr Wertunterteilungen jedoch einen größeren Einfluss auf die zufällige Gesamtstruktur.
Es wird empfohlen, mindestens zwei Methoden des maschinellen Lernens für das Feature-Screening zu verwenden. Anschließend wird anhand der Korrelations-Heatmap und der Vorhersageindikatoren beurteilt, welches Modell schließlich als Feature-Screening-Modell ausgewählt wird
# 将训练好的模型提取其特征的重要程度
import_level = model.feature_importances_ #这个方法可以调取关于特征重要程度
# 特征程度的显示
x_columns = data.columns[1:]
index = np.argsort(import_level)[::-1]
for each in range(x.shape[1]):
print('The important level of '+ x_columns[each]+ ': '+ str(import_level[index[each]]))
Wenn es viele Merkmale gibt, wird empfohlen, ein Liniendiagramm zu zeichnen. Wenn die Merkmale geeignet sind, muss das Histogramm klarer sein
Histogramm
#柱状图可视化
plt.figure(figsize=(10,6))
plt.title('title',fontsize = 18)
plt.ylabel('import level',fontsize = 15,rotation = 90)
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
for i in range(x_columns.shape[0]):
plt.bar(i,import_level[index[i]],color = 'orange',align = 'center')
plt.xticks(np.arange(x_columns.shape[0]),x_columns,rotation = 90,fontsize = 15)