Modelo de entrenamiento
Esta sección incluye:
- El uso de sklearn del modelo de árbol: Decision Tree \ Random Forest \ GBDT
- Descripción del índice de evaluación de clasificación: Precisión \ TPR y FPR \ Curva ROC \ Curva PR \ AP \ Puntuación F1
- Validación cruzada: validación cruzada de k veces \ dejar una validación cruzada
- Búsqueda de hiperparámetros: búsqueda de cuadrícula \ búsqueda aleatoria \ búsqueda automatizada de hiperparámetros
Tabla de contenido
1. Importe el kit de herramientas:
import numpy as np
import pandas as pd
from matplotlib.pyploy as plt
import time
import warnings
warnings.filterwarnings('ignore')
2. Generación de datos experimentales
Para generar datos experimentales, make_blobs generará los datos deseados de acuerdo con el número total de muestras especificadas por el usuario, el número de puntos centrales y el grado de dispersión de la distribución.
Parámetros de la función make_blobs:
- n_samples: el número total de muestras;
- centros: el número de centros agrupados;
- random_state: Determine la semilla aleatoria para asegurarse de que los datos sean los mismos en todo momento;
- cluster_std: El grado de dispersión de cada grupo, cuanto mayor es la dispersión, menor es la concentración.
from sklearn.datasets.samples_generator import make_blobs
X,y=make_blobs(n_samples=500,centers=2,random_state=21,cluster_std=3.5)
# 画出数据散点图
plt.scatter(X[:,0],X[:,1],c=y,s=50)
plt.show()
3. División del conjunto de datos
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3,random_state=32)
print(X_train.shape,X_test.shape)
(350, 2) (150, 2)# print 输出结果
4. Uso del modelo de árbol
Los modelos de aprendizaje automático utilizados incluyen:
- Árbol de decisión
- Bosque aleatorio
- Gradient Boosting Tree (GBDT), el marco lightGBM más utilizado
4.1 Árbol de decisión
from sklearn.tree import DecisionTreeClassifier
dt=DecisionTreeClassifier(
critterion='entropy',
splitter='best',
max_depth=4,
max_leaf_nodes=12,
min_samples_leaf=30,
presort=True,# 此参数项在实际代码运行时可以不写，默认为False
)
dt.fit(X_train,y_train)
y_pred_dt=dt.predict(X_test)
# 画出样本的散点图
plt.scatter(X_test[:,0],X_test[:,1],c=y_pred_dt,s=20)
plt.title('Decision tree classification result')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
4.2 Bosque aleatorio
from sklearn.ensemble import RandomForestClassifier
rf=RandomForestClassifier(
n_estimators=10,
criterion='entropy',
max_depth=4,
max_leaf_nodes=12,
min_samples_leaf=30,
bootstrap=True,
n_jobs=1,
max_samples=0.8
)
rf.fit(X_train,y_train)
y_pred_rf=rf.predict(X_test)
# 画出样本的散点图
plt.scatter(X_test[:,0],X_test[:,1],c=y_pred_rf,s=20)
plt.title('Random forest classification result')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
4.3 GBM ligero
- LightGBM es un marco de impulso de gradiente basado en árbol de decisiones rápido, distribuido y de alto rendimiento desarrollado por Microsoft, que es la implementación de ingeniería de algoritmos GBDT. Tiene las siguientes ventajas:
- Eficiencia de entrenamiento rápida
- Bajo uso de memoria
- Alta precisión
- Apoyar el aprendizaje paralelo
- Puede manejar datos a gran escala
- Ejecute el siguiente comando para instalar lightgbm:
- pip3 instalar lightgbm
- Por lo general, es necesario configurar los siguientes parámetros:
- boosting_type: tipo de algoritmo de impulso, el gbdt predeterminado es el algoritmo GBDT tradicional. Si la cantidad de datos es grande, se puede configurar en "bruto", lo que acelerará el entrenamiento del modelo a expensas de cierta precisión.
- objetivo: Especificar la tarea de aprendizaje, las opciones son:
- Para LGBMRegressor (tarea de regresión), seleccione '';
- Para LGBMClassifier (tarea de clasificación), si es una clasificación de dos clases, seleccione 'binaria', si es una clasificación múltiple, seleccione 'multiclase';
- Para LGBMRanker (tarea de clasificación), seleccione'lambdarank '.
import lightgbm as lgb
params={
'boosting_type':'gbdt',
'objective':'binary',
'n_estimators':200,
'learning_rate':0.1,
'max_depth':5,
'num_leaves':25,
'min_child_samples':14,
'subsample':0.8,
'colsample_bytree':0.7,
'subsample_freq':10,
'reg_alpha':1.0,
'reg_lambda':0.1,
}
model=lgb.LGBMClassifier(**params,random_state=50)
#训练模型
model.fit(X_train,y_train,eval_metric='auc',eval_set=[(X_test,y_test)],eval_names=['test'])
y_pred_lgb=model.predict(X_test)
y_pred_proba_lgb=model.predict_proba(X_test)
# 画出样本的散点图
plt.scatter(X_test[],X_test[],c=y_pred_lgb,s=20)
plt.title('LightGBM classification result')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
5. Índice de evaluación del modelo de clasificación
Los indicadores de evaluación utilizados incluyen:
Tasa de precisión de la matriz de confusión- \ Tasa de verdaderos positivos y tasa de falsos positivos \ ROC \ AUC \ curva PR \ AP \ F1 puntaje
5.1 Matriz de confusión
from sklearn.metrics import confusion_matrix
c_matric_dt=confusion_matrix(y_test,y_pred_dt)
c_matric_rf=confusion_matrix(y_test,y_pred_rf)
c_matric_lgb=confusion_matrix(y_test,y_pred_lgb)
print('Decison tree confusion_matrix:\n{}\n'.format(c_matric_dt))
print('Random Forest confusion_matrix:\n{}\n'.format(c_matric_rf))
print('LightGBM confusion_matrix:\n{}\n'.format(c_matric_lgb))
# print的输出结果
Decison tree confusion_matrix:
[[77 2]
[ 3 68]]
Random Forest confusion_matrix:
[[79 0]
[ 6 65]]
LightGBM confusion_matrix:
[[77 2]
[ 3 68]]
5.2 Precisión
from sklearn.metrics import accuracy_score
accuracy_dt=accuracy_score(y_test,y_pred_dt)
accuracy_rf=accuracy_score(y_test,y_pred_rf)
accuracy_lgb=accuracy_score(y_test,y_pred_lgb)
print('Decison tree accuracy:\n{}\n'.format(accuracy_dt))
print('Random Forest accuracy:\n{}\n'.format(accuracy_rf))
print('LightGBM accuracy:\n{}\n'.format(accuracy_lgb))
# print输出结果
Decison tree accuracy:
0.9666666666666667
Random Forest accuracy:
0.96
LightGBM accuracy:
0.9666666666666667
5.3 Tasa de verdaderos positivos y tasa de falsos positivos
import pandas as pd
from sklearn.metrics import roc_curve
# 计算fpr和tpr
fpr,tpr,thresholds=roc_cure(y_test,y_pred_proba_lgb[:,1])
# 把fpr,tpr,thresholds用DataFrame表格保存，方便显示
result=pd.DataFrame([thresholds,tpr,fpr],index=['thresholds','tpr','fpr'])
print(result)
# print输出结果：
0 1 2 3 4 5 \
thresholds 1.992467 0.992467 0.943519 0.937773 0.813253 0.407940
tpr 0.000000 0.887324 0.915493 0.929577 0.957746 0.957746
fpr 0.000000 0.000000 0.012658 0.025316 0.025316 0.037975
6 7 8 9 10
thresholds 0.343985 0.185725 0.132040 0.044848 0.00497
tpr 0.971831 0.985915 0.985915 0.985915 1.00000
fpr 0.037975 0.075949 0.101266 0.227848 1.00000
5.4 República de China
import matplotlib.pyplot as plt
plt.figure()
# 画出散点图，标出点的位置
plt.scatter(fpr,tpr)
# 画出ROC曲线图
plt.plot(fpr,tpr,color='darkorange',lw=2,label='ROC curve')
plt.xlim([-0.05,1.0])
plt.ylim([0.0,1.05])
plt.xlable('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('LightGBM ROC')
plt.legend(loc='lower right')
plt.show()
5,5 AUC
from sklearn.metrics import roc_auc_score
auc_dt=roc_auc_score(y_test,y_pred_dt)
auc_rf=roc_auc_score(y_test,y_pred_rf)
auc_lgb=roc_auc_score(y_test,y_pred_lgb)
print('Decision tree AUC:{:.3f}\n'.format(auc_dt))
print('Random Forest AUC:{:.3f}\n'.format(auc_rf))
print('LightGBM AUC:{:.3f}\n'.format(auc_lgb))
# print 输出结果
Decision tree AUC:0.966
Random Forest AUC:0.958
LightGBM AUC:0.966
5.6 Tasa de precisión y tasa de recuperación
from sklearn.metrcis import precision_recall_curve
# 计算precision和recall
precision,recall,thresholds=precision_recall_curve(y_test,y_pred_proba_lgb[:,1])
# 把precision，recall，thresholds用DataFrame表格保存，方便显示
result=pd.DataFrame([thresholds,precision,recall],index=['thresholds','precision','recall'])
print(result)
# print输出显示
0 1 2 3 4 5 \
thresholds 0.004970 0.044848 0.132040 0.185725 0.343985 0.407940
precision 0.473333 0.795455 0.897436 0.921053 0.958333 0.957746
recall 1.000000 0.985915 0.985915 0.985915 0.971831 0.957746
6 7 8 9 10 11
thresholds 0.813253 0.897236 0.937773 0.943519 0.992467 NaN
precision 0.971429 0.971014 0.970588 0.984848 1.000000 1.0
recall 0.957746 0.943662 0.929577 0.915493 0.887324 0.0
5.7 Curva PR
#规定画布大小
plt.figure(figsize=(12,8))
# 画填充图
plt.fill_between(recall,precision,alpha=0.2,color='b',step='post')
# 画散点图，凸显坐标点位置
plt.scatter(recall,precision,alpha=0.8,color='r')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0,1.05])
plt.xlim([0.0,1.05])
plt.show()
5.8 AP
from sklearn.metrics import average_precision_score
ap_dt=average_precision_score(y_test,y_pred_dt)
ap_rf=average_precision_score(y_test,y_pred_rf)
ap_glb=average_precision_score(y_test,y_pred_glb)
print('Decision tree AP:{:3f}\n'.formata(ap_dt))
print('Random Forest AP:{:3f}\n'.formata(ap_rf))
print('LightGBM AP:{:3f}\n'.formata(ap_glb))
# print 输出结果
Decision tree AP:0.950382
Random Forest AP:0.955493
LightGBM AP:0.950382
5.9 Puntuación F1
from sklearn.metrics import f1_score
f1_score_dt=f1_score(y_test,y_pred_dt)
f1_score_rf=f1_score(y_test,y_pred_rf)
f1_score_lgb=f1_score(y_test,y_pred_lgb)
print('Decision tree f1_score:{:3f}\n'.format(f1_score_dt))
print('Random Forest f1_score:{:3f}\n'.format(f1_score_rf))
print('LightGBM f1_score:{:3f}\n'.format(f1_score_lgb))
# print 输出结果
Decision tree f1_score:0.964539
Random Forest f1_score:0.955882
LightGBM f1_score:0.964539
6. Validación cruzada
- Pensamiento de preguntas: Separar una parte de los datos generales como un conjunto de verificación reducirá los datos que el modelo puede entrenar, especialmente cuando la cantidad de datos es pequeña. ¿Hay alguna mejor manera de usar eficazmente el conjunto de datos para el entrenamiento?
- Respuesta: validación cruzada
- Definición de validación cruzada:
- La idea de la validación cruzada es en realidad reutilizar los datos, dividir los datos de muestra obtenidos y combinarlos en diferentes conjuntos de entrenamiento y conjuntos de prueba. El conjunto de entrenamiento se usa para entrenar el modelo, y el conjunto de prueba se usa para evaluar el predicción del modelo.
- Cuándo utilizar la validación cruzada:
- La validación cruzada se usa generalmente cuando los datos no son suficientes. Si el tamaño de la muestra de datos es menor de 10,000, se necesita una validación cruzada para evaluar el modelo. Si la muestra es mayor de 10,000, solo una parte de los datos se usa como un conjunto de verificación para la evaluación del modelo.
- Según los diferentes métodos de segmentación de datos, la validación cruzada de uso común se puede dividir en 2 situaciones:
- Validación cruzada de K-fold
- Deje uno para realizar una validación cruzada
6.1 Validación cruzada de K-fold
- El proceso de verificación también es una gran cantidad de ingeniería, este artículo continuará actualizándose