Fusión de modelos de competencia de ciencia de datos de Python

Fusión de modelos

La idea de la fusión de modelos es que la combinación de varios modelos puede mejorar el rendimiento general. El modelo de conjunto es una técnica poderosa que puede mejorar la precisión en varias tareas de aprendizaje automático. La fusión de modelos es una parte importante de la etapa posterior de la competencia kaggle. En términos generales, existen los siguientes tipos:

1. Fusión ponderada simple:
regresión (probabilidad de clasificación): Media aritmética, fusión de media geométrica
Clasificación:
Síntesis de votación : Promedio de rango, fusión logarítmica

2. Apilamiento / combinación:
cree un modelo de varias capas y use los resultados de la predicción para ajustar la predicción

3. Impulso / ensacado:
método de impulso de múltiples árboles, que se ha utilizado en xgboost, Adaboost, GBDT, etc.

Promediando

Idea básica: Para problemas de regresión, una idea simple y directa es promediar. Un método ligeramente mejorado es realizar un promedio ponderado. Las ponderaciones se pueden determinar mediante el método de clasificación. Por ejemplo, para los tres modelos básicos de A, B y C, los efectos del modelo se clasifican. Suponiendo que las clasificaciones son 1, 2, 3, entonces las ponderaciones asignadas a los tres modelos Es 3/6, 2/6, 1/6.

El método de promedio o método de promedio ponderado parece simple, de hecho, también se puede decir que los algoritmos avanzados posteriores se basan en esto.Empaquetado o Impulso es una idea de fusionar muchos clasificadores débiles en clasificadores fuertes.

1. Método de promedio aritmético simple: el método de promedio promedia los resultados predichos por múltiples modelos. Este método se puede utilizar tanto para problemas de regresión como para promediar las probabilidades de problemas de clasificación.
2. Método de promedio aritmético ponderado: este método es una extensión del método de promedio. Teniendo en cuenta que las habilidades de los diferentes modelos son diferentes y sus contribuciones al resultado final también son diferentes, se necesitan pesos para representar la importancia de los diferentes modelos.

Votación

Idea básica: Supongamos que hay 3 modelos básicos para un problema de clasificación de dos. Ahora podemos obtener un clasificador de votación basado en estos alumnos básicos y tomar la clase con más votos como la categoría que queremos predecir.

1. Método de votación por mayoría absoluta: El resultado final debe representar más de la mitad de los votos.
2. Método de votación por mayoría relativa: el resultado final tiene la mayor cantidad de votos en la votación.
3. Voto ponderado
4. Votación dura: votar directamente sobre múltiples modelos sin distinguir la importancia relativa de los resultados del modelo La clase con más votos finales es la clase que finalmente se predice.
5. Votación suave: se ha agregado la función de establecer pesos. Se pueden establecer diferentes pesos para diferentes modelos para distinguir la importancia de diferentes modelos.

Código de implementación del método de votación: `

from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import VotingClassifier

model1 = LogisticRegression(random_state=2020)
model2 = DecisionTreeClassifier(random_state=2020)
model = VotingClassifier(estimators=[('lr', model1), ('dt', model2)], voting='hard')
model.fit(x_train, y_train)
model.score(x_test, y_test)

Apilado

Idea básica: apilar es usar los datos de entrenamiento inicial para aprender varios alumnos básicos y usar los resultados de predicción de estos alumnos como un nuevo conjunto de entrenamiento para aprender a un nuevo alumno. Modele los resultados predichos por diferentes modelos.

En el método de apilamiento, llamamos al alumno individual un alumno primario, el alumno utilizado para la combinación se denomina alumno secundario o metaaprendiz, y los datos utilizados por el alumno secundario para la formación se denominan conjunto de formación secundaria. El conjunto de formación secundaria se obtiene utilizando al alumno principal en el conjunto de formación.

El apilamiento es esencialmente una idea tan sencilla, pero a veces es un problema si la distribución del conjunto de entrenamiento y el conjunto de prueba no son tan consistentes. El problema es usar las etiquetas entrenadas por el modelo inicial y luego usar las etiquetas reales para el reentrenamiento. Sin duda, hará que un determinado modelo se sobreajuste al conjunto de entrenamiento, por lo que tal vez la capacidad de generalización o el efecto del modelo en el conjunto de prueba se reduzca hasta cierto punto, por lo que el problema ahora es cómo reducir el sobreajuste del reentrenamiento , Aquí generalmente tenemos dos métodos:

1. Intente elegir un modelo lineal simple para el modelo secundario, pero el modelo lineal no funciona bien después de la práctica. Se recomienda LightGBM
2. Utilice la validación cruzada de K-fold

Llame a APi para implementar el apilamiento:

from heamy.dataset import Dataset
from heamy.estimator import Regressor, Classifier
from heamy.pipeline import ModelsPipeline
from sklearn import cross_validation
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error
#加载数据集
from sklearn.datasets import load_boston
data = load_boston()
X, y = data['data'], data['target']
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.1, random_state=111)
#创建数据集
dataset = Dataset(X_train,y_train,X_test)
#创建RF模型和LR模型
model_rf = Regressor(dataset=dataset, estimator=RandomForestRegressor, parameters={
    
    'n_estimators': 50},name='rf')
model_lr = Regressor(dataset=dataset, estimator=LinearRegression, parameters={
    
    'normalize': True},name='lr')
# Stack两个模型
# Returns new dataset with out-of-fold predictions
pipeline = ModelsPipeline(model_rf,model_lr)
stack_ds = pipeline.stack(k=10,seed=111)
#第二层使用lr模型stack
stacker = Regressor(dataset=stack_ds, estimator=LinearRegression)
results = stacker.predict()
# 使用5折交叉验证结果
results10 = stacker.validate(k=5,scorer=mean_absolute_error)

Implementación manual: simplemente cree un alumno base como ejemplo:

from sklearn.model_selection import StratifiedKFold,KFold,RepeatedKFold
import xgboost.sklearn import XGBClassifier
import numpy as np

skf = StratifiedKFold(n_splits = 5, shuffle = True ,random_state=16)
oof_xgb = np.zeros(len(train))  #创建数组
pre_xgb = np.zeros(len(test))

for k,(train_in,test_in) in enumerate(skf.split(train,train_y)):
    X_train,X_test,y_train,y_test = X[train_in],X[test_in],y[train_in],y[test_in]
    params = {
    
    'learning_rate': 0.008, 
              'n_estimators': 1000
              'max_depth': 5,
              'subsample': 0.8, 
              'colsample_bytree': 0.8, 
              'objective':'binary:logistic',
              'eval_metric':'auc',
              'silent': True, 
              'nthread': 4,
              }
    # train
    clf = XGBClassifier(params)
    clf.fit(trn_x, trn_y,eval_set=[(val_x, val_y)],eval_metric='auc',early_stopping_rounds=100,verbose=100)
    print('Start predicting...')
    oof_xgb[test_in] = clf.predict(X_test)
    pre_xgb += clf.predict(test) / skf.n_splits
    
print('XGB predict over')

Mezcla

Idea básica: la combinación utiliza el mismo método que el apilamiento, pero solo selecciona un resultado de pliegue del conjunto de entrenamiento y luego se conecta con la característica original como característica del metaaprendiz metaaprendiz, y realiza la misma operación en el conjunto de prueba.
Divida el conjunto de entrenamiento original en dos partes, como el 70% de los datos como el nuevo conjunto de entrenamiento y el 30% restante como el conjunto de prueba.

1. En la primera capa, entrenamos varios modelos en el 70% de los datos y luego predecimos la etiqueta de los datos del 30% y también predecimos la etiqueta del conjunto de prueba.
2. En la segunda capa, usamos directamente los datos del 30% predichos en la primera capa como una nueva característica para continuar el entrenamiento, luego usamos la etiqueta predicha por la primera capa del conjunto de prueba como característica y usamos el modelo entrenado en la segunda capa para hacer más predicciones

Comparación de mezcla y apilamiento:
ventajas:

1. Combinar es más simple que apilar porque no es necesario realizar k veces de validación cruzada para obtener la función de apilador
2. La combinación evita un problema de fuga de información: los generadores y apiladores utilizan diferentes conjuntos de datos

Desventajas:

1. La mezcla usa muy pocos datos (la segunda etapa de Blender solo usa el 10% del conjunto de entrenamiento) y Blender puede sobreajustarse
2. El apilamiento mediante validación cruzada múltiple será más sólido