Modèle d'empilage d'apprentissage automatique (retour)

Empilement d'apprentissage automatique (problème de retour)

Chez kaggle, la plupart des meilleurs utilisateurs utilisent l'empilement. Je veux aussi entrer dans les rangs supérieurs, j'ai donc étudié l'empilement. Ici, lors de l'empilement, le code à utiliser peut être utilisé par copie. (Cependant, il est limité au problème de régression)

Cette fois, il s'agit d'un empilement à deux couches.

Apprentissage automatique utilisé

L'apprentissage automatique utilisé était en quelque sorte

・ XGBoost ・ LightGBM ・ Catboost ・ MLP (couche cachée 2) ・ SVR linéaire ・ SVR du noyau (rbf) ・ KNN ・ Lasso · Crête ・ ElasticNet ・ Forêt aléatoire

À propos des hyper paramètres

Les hyper paramètres ne sont pas correctement ajustés. Cependant, dans le cas de l'empilement, si vous ajustez trop la collection, vous en apprendrez trop. Il est possible que la précision des données de test soit réduite. C'est un endroit difficile.

modèle

Ci-dessous le modèle. En créant une classe ・ Lors de l'apprentissage de la forme ・ Lors de la prédiction, prédire C'est très pratique car il peut être unifié avec (je viens de l'imiter)

De plus, tout peut être utilisé par copier-coller (devrait).

XGBoost

import xgboost as xgb

class Model1Xgb:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        xgb_params = {'objective': 'reg:squarederror', #binary:logistic #multi:softprob,
                  'random_state': 10,
                  #'eval_metric': 'rmse'
                     }
        dtrain = xgb.DMatrix(tr_x, label=tr_y)
        dvalid = xgb.DMatrix(va_x, label=va_y)
        evals = [(dtrain, 'train'), (dvalid, 'eval')]
        self.model = xgb.train(xgb_params, dtrain, num_boost_round=10000,early_stopping_rounds=50, evals=evals)

    def predict(self, x):
        data = xgb.DMatrix(x)
        pred = self.model.predict(data)
        return pred

LightGBM

import lightgbm as lgb

class Model1lgb:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        lgb_params = {'objective': 'rmse',
                  'random_state': 10,
                  'metric': 'rmse'}
        lgb_train = lgb.Dataset(tr_x, label=tr_y)
        lgb_eval = lgb.Dataset(va_x, label=va_y,reference=lgb_train)
        self.model = lgb.train(lgb_params, lgb_train, valid_sets=lgb_eval, num_boost_round=10000,early_stopping_rounds=50)

    def predict(self, x):
        pred = self.model.predict(x,num_iteration=self.model.best_iteration)
        return pred

Catboost

import catboost
class Model1catboost:

    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        #https://catboost.ai/docs/concepts/python-reference_catboostregressor.html
        #catb = catboost.CatBoostClassifier(
        catb = catboost.CatBoostRegressor(
                                    iterations=10000, 
                                    use_best_model=True, 
                                    random_seed=10, 
                                    l2_leaf_reg=3,
                                    depth=6,
                                    loss_function="RMSE",#"CrossEntropy",
                                    #eval_metric = "RMSE", #'AUC',
                                    #classes_coun=3
                                  )
        self.model = catb.fit(tr_x,tr_y,eval_set=(va_x,va_y),early_stopping_rounds=50)
        print(self.model.score(va_x,va_y))
    def predict(self, x):
        pred = self.model.predict(x)
        return pred

Multi-layer Perceptron(MLP) Cette fois, il s'agit d'un réseau neuronal à 4 couches.

rom keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.callbacks import EarlyStopping

class Model1NN:
    def __init__(self):
        self.model = None
        self.scaler = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        
        batch_size = 128
        epochs = 10000

        tr_x = self.scaler.transform(tr_x)
        va_x = self.scaler.transform(va_x)
        
        early_stopping =  EarlyStopping(
                            monitor='val_loss',
                            min_delta=0.0,
                            patience=20,
        )

        model = Sequential()
        model.add(Dense(32, activation='relu', input_shape=(tr_x.shape[1],)))
        model.add(Dropout(0.5))
        model.add(Dense(32, activation='relu'))
        model.add(Dropout(0.5))
        model.add(Dense(1, activation='sigmoid'))

        model.compile(loss='mean_squared_error', 
                      #'categorical_crossentropy',#categorical_crossentropy
                      optimizer='adam')

        history = model.fit(tr_x, tr_y,
                            batch_size=batch_size, epochs=epochs,
                            verbose=1,
                            validation_data=(va_x, va_y),
                            callbacks=[early_stopping])
        self.model = model

    def predict(self, x):
        x = self.scaler.transform(x)
        pred = self.model.predict_proba(x).reshape(-1)
        return pred

Linear SVR

from sklearn.svm import LinearSVR

class Model1LinearSVR:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        #params = {"C":np.logspace(0,1,params_cnt),"epsilon":np.logspace(-1,1,params_cnt)}
        self.model = LinearSVR(max_iter=1000,
                               random_state=10,
                               C = 1.0, #Coefficient de perte (inverse du coefficient de régularisation)
                               epsilon = 5.0
                               
                              )
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

Kernel SVR

from sklearn.svm import SVR

class Model1KernelSVR:

    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        #params = {"kernel":['rbf'],"C":np.logspace(0,1,params_cnt), "epsilon":np.logspace(-1,1,params_cnt)}
        self.model = SVR(kernel='rbf',
                         gamma='auto',
                         max_iter=1000,
                         C = 1.0, #Coefficient de perte (inverse du coefficient de régularisation)
                         epsilon = 5.0
                         
                              )
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

Lasso

from sklearn.linear_model import Lasso

class Model1Lasso:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        '''
        (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1
        #https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html
        '''
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        self.model = Lasso(
            alpha=1, #Coefficient L1
            fit_intercept=True,
            max_iter=1000,
            random_state=10,
            )
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

Ridge

from sklearn.linear_model import Ridge

class Model1Ridge:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        '''
        |y - Xw||^2_2 + alpha * ||w||^2_2
        #https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html
        '''
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        self.model = Ridge(
            alpha=1, #Coefficient L2
            max_iter=1000,
            random_state=10,
                              )
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

ElasticNet

from sklearn.linear_model import ElasticNet

class Model1ElasticNet:

    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        '''1 / (2 * n_samples) * ||y - Xw||^2_2
        + alpha * l1_ratio * ||w||_1
        + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2
       ref)  https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html
        '''
        
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        self.model = ElasticNet(
            alpha=1, #Coefficient L1
            l1_ratio=0.5,
                              )
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

RandomForest

from sklearn.ensemble import RandomForestRegressor

class Model1RF:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        self.model = RandomForestRegressor(
            max_depth=5,
            n_estimators=100,
            random_state=10,
        )
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

KNN (méthode de voisinage K)

from sklearn.neighbors import KNeighborsRegressor

class Model1KNN:
    def __init__(self):
        self.model = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        #params = {"kernel":['rbf'],"C":np.logspace(0,1,params_cnt), "epsilon":np.logspace(-1,1,params_cnt)}
        self.model = KNeighborsRegressor(n_neighbors=5,
                                         #weights='uniform'
                                        )
        
        self.model.fit(tr_x,tr_y)
        
    def predict(self,x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

Régression linéaire

from sklearn.linear_model import LinearRegression

class Model2Linear:
    def __init__(self):
        self.model = None
        self.scaler = None

    def fit(self, tr_x, tr_y, va_x, va_y):
        self.scaler = StandardScaler()
        self.scaler.fit(tr_x)
        tr_x = self.scaler.transform(tr_x)
        self.model = LinearRegression()
        self.model.fit(tr_x, tr_y)

    def predict(self, x):
        x = self.scaler.transform(x)
        pred = self.model.predict(x)
        return pred

Out-of-fold Cette fois, il est divisé en 4 plis et hors pli. Il semble que le pli soit généralement d'environ 2 à 5 plis. Quand je l'ai essayé avec 10 fois avec des données appropriées, la précision a chuté. Si vous augmentez le nombre de plis, vous n'apprendrez qu'avec des ensembles de données similaires. Je me demande si je vais surapprendre les données de validation.

from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler

def predict_cv(model, train_x, train_y, test_x):
    preds = []
    preds_test = []
    va_idxes = []

    kf = KFold(n_splits=4, shuffle=True, random_state=10)

    #Apprenez et prédisez grâce à la validation croisée et enregistrez les valeurs et les index prédits
    for i, (tr_idx, va_idx) in enumerate(kf.split(train_x)):
        tr_x, va_x = train_x.iloc[tr_idx], train_x.iloc[va_idx]
        tr_y, va_y = train_y.iloc[tr_idx], train_y.iloc[va_idx]
        model.fit(tr_x, tr_y, va_x, va_y)
        pred = model.predict(va_x)
        preds.append(pred)
        pred_test = model.predict(test_x)
        preds_test.append(pred_test)
        va_idxes.append(va_idx)

    #Concaténez les valeurs prévues pour les données de validation, puis réorganisez-les dans leur ordre d'origine
    va_idxes = np.concatenate(va_idxes)
    preds = np.concatenate(preds, axis=0)
    order = np.argsort(va_idxes)
    pred_train = preds[order]

    #Prendre la moyenne des valeurs prédites pour les données de test
    preds_test = np.mean(preds_test, axis=0)

    return pred_train, preds_test

Faire la quantité de fonction de la deuxième couche

Lors de la création de train_x_2 et test_x_2 (ligne inférieure), la précision changera considérablement en fonction des données utilisées. Il est étonnamment intéressant d'essayer diverses combinaisons et de vérifier la précision par vous-même. Cette fois, il était plus précis d'exclure pred_1d (LinearSVR), je l'ai donc supprimé.

model_1a = Model1Xgb()
pred_train_1a, pred_test_1a = predict_cv(model_1a, df_trainval, y_trainval, df_test)

model_1b = Model1lgb()
pred_train_1b, pred_test_1b = predict_cv(model_1b, df_trainval, y_trainval, df_test)

model_1c = Model1NN()
pred_train_1c, pred_test_1c = predict_cv(model_1c, df_trainval, y_trainval, df_test)

model_1d = Model1LinearSVR()
pred_train_1d, pred_test_1d = predict_cv(model_1d, df_trainval, y_trainval, df_test)

model_1e = Model1KernelSVR()
pred_train_1e, pred_test_1e = predict_cv(model_1e, df_trainval, y_trainval, df_test)

model_1f = Model1catboost()
pred_train_1f, pred_test_1f = predict_cv(model_1f, df_trainval, y_trainval, df_test)

model_1g = Model1KNN()
pred_train_1g, pred_test_1g = predict_cv(model_1g, df_trainval, y_trainval, df_test)

model_1h = Model1Lasso()
pred_train_1h, pred_test_1h = predict_cv(model_1h, df_trainval, y_trainval, df_test)

model_1i = Model1Ridge()
pred_train_1i, pred_test_1i = predict_cv(model_1i, df_trainval, y_trainval, df_test)

model_1j = Model1ElasticNet()
pred_train_1j, pred_test_1j = predict_cv(model_1j, df_trainval, y_trainval, df_test)

model_1k = Model1RF()
pred_train_1k, pred_test_1k = predict_cv(model_1k, df_trainval, y_trainval, df_test)


from sklearn.metrics import mean_absolute_error
'''
#Calculate RMSE
from sklearn.metrics import mean_square_error
def rmse(y_true,y_pred):
    rmse = np.sqrt(mean_squared_error(y_true,y_pred))
    print('rmse',rmse)
    return rmse
'''

'''
Ci-dessous, la précision de chaque modèle de prédiction dans la première couche est confirmée.
Cette fois, je veux dire_absolute_error(MAE)Vérifiez la précision avec
'''
print(f'a LGBM mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1a):.4f}')
print(f'b XGBoostmean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1b):.4f}')
print(f'c MLP mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1c):.4f}')
print(f'd LinearSVR mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1d):.4f}')
print(f'e KernelSVR mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1e):.4f}')
print(f'f Catboost mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1f):.4f}')
print(f'g KNN mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1g):.4f}')
print(f'h Lasso mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1h):.4f}')
print(f'i Ridge mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1i):.4f}')
print(f'j ElasticNet mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1j):.4f}')
print(f'k RandomForest mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1k):.4f}')

'''
Ci-dessous, les valeurs prédites de la première couche sont résumées dans une trame de données.
Collecté dans un bloc de données et résumé en tant que quantité d'entités de la deuxième couche
'''
train_x_2 = pd.DataFrame({'pred_1a': pred_train_1a,
                          'pred_1b': pred_train_1b,
                          'pred_1c': pred_train_1c,
                          #'pred_1d': pred_train_1d,
                          'pred_1e': pred_train_1e,
                          'pred_1f': pred_train_1f,
                          'pred_1g': pred_train_1g,
                          'pred_1h': pred_train_1h,
                          'pred_1i': pred_train_1i,
                          'pred_1j': pred_train_1j,
                          'pred_1k': pred_train_1k,
                         })
test_x_2 = pd.DataFrame({'pred_1a': pred_test_1a,
                          'pred_1b': pred_test_1b,
                          'pred_1c': pred_test_1c,
                          #'pred_1d': pred_test_1d,
                          'pred_1e': pred_test_1e,
                          'pred_1f': pred_test_1f,
                          'pred_1g': pred_test_1g,
                          'pred_1h': pred_test_1h,
                          'pred_1i': pred_test_1i,
                          'pred_1j': pred_test_1j,
                          'pred_1k': pred_test_1k
                         })

Définir une régression linéaire sur la deuxième couche d'empilement

Cette fois, seule la valeur prévue de chaque modèle de la première couche a été définie comme quantité d'entités dans la deuxième couche. Il existe plusieurs façons de créer la quantité d'entités pour la deuxième couche.

  1. Seule la valeur prévue de la première couche est utilisée comme quantité d'entités (cette fois)
  2. Valeur prédite de la première couche + quantité d'entités d'origine
  3. Valeur prédite de la première couche + quantité de caractéristiques d'origine ou moyenne / dispersion (statistiques) de la valeur prédite, etc.
  4. Valeur prédite de la première couche + quantité d'entité originale ou moyenne / dispersion (statistiques) de la valeur prédite, etc. ou quantité d'entité originale traitée (PCA, t-SNE, etc.)
model2 = Model2Linear()
pred_train_2, pred_test_2 = predict_cv(model2, train_x_2, y_trainval, test_x_2)

#Vérifiez la précision après avoir empilé les deux couches.
print(f'mean_absolute_error: {mean_absolute_error(y_trainval, pred_train_2):.4f}')

finalement

En empilant, la précision s'améliorera. Un kaggler fort relie l'empilement à 3 ou 4 couches. La précision augmentera en augmentant le nombre de couches à 3 ou 4. En général, le degré d'amélioration diminue avec chaque couche.

Aussi, plutôt que d'essayer de réfléchir aux méthodes d'empilement Il est plus facile d'améliorer la précision lorsque vous créez vous-même une quantité d'entités et trouvez une bonne quantité d'entités. Au lieu de me fier à l'empilement, je veux faire de mon mieux pour créer moi-même de bonnes fonctionnalités.

référence) Technologie d'analyse de données qui gagne avec Kaggle https://github.com/ghmagazine/kagglebook/tree/master/ch07

Si vous faites une erreur Merci pour votre commentaire.

Recommended Posts

Modèle d'empilage d'apprentissage automatique (retour)
Régression logistique d'apprentissage automatique
Régression linéaire d'apprentissage automatique
Machine Learning: Supervision - Régression linéaire
Comprendre l'apprentissage automatique ~ régression de crête ~.
Algorithme d'apprentissage automatique (régression logistique)
Apprentissage automatique
Les débutants en apprentissage automatique essaient la régression linéaire
Algorithme d'apprentissage automatique (analyse de régression multiple)
Algorithme d'apprentissage automatique (analyse de régression unique)
Classification et régression dans l'apprentissage automatique
Algorithme d'apprentissage automatique (généralisation de la régression linéaire)
Apprentissage automatique avec python (2) Analyse de régression simple
<Cours> Machine learning Chapitre 1: Modèle de régression linéaire
[Memo] Apprentissage automatique
Classification de l'apprentissage automatique
Prévision du cours des actions à l'aide de l'apprentissage automatique (édition de retour)
Algorithme d'apprentissage automatique (résumé de régression linéaire et régularisation)
Exemple d'apprentissage automatique
EV3 x Python Machine Learning Partie 2 Régression linéaire
Résumé du didacticiel d'apprentissage automatique
Apprentissage automatique sur le surapprentissage
Apprentissage automatique: supervisé - AdaBoost
Machine de vecteur de support d'apprentissage automatique
Mémo du cours d'apprentissage automatique
Bibliothèque d'apprentissage automatique dlib
Apprentissage automatique (TensorFlow) + Lotto 6
Apprenez en quelque sorte le machine learning
Apprendre avec un enseignant (retour) 1 Bases
Python: apprentissage supervisé (retour)
Bibliothèque d'apprentissage automatique Shogun
Défi de lapin d'apprentissage automatique
Introduction à l'apprentissage automatique
Apprentissage automatique: k-voisins les plus proches
Qu'est-ce que l'apprentissage automatique?
Défis d'apprentissage automatique de Coursera en Python: ex2 (retour logistique)
Python Scikit-learn Analyse de régression linéaire Analyse de régression simple non linéaire Apprentissage automatique
Coursera Machine Learning Challenge en Python: ex1 (régression linéaire)
Modèle d'apprentissage automatique prenant en compte la maintenabilité
L'apprentissage automatique appris avec Pokemon
Ensemble de données pour l'apprentissage automatique
Essayez d'évaluer les performances du modèle d'apprentissage automatique / de régression
Apprentissage automatique dans Delemas (s'entraîner)
Une introduction à l'apprentissage automatique
Techniques liées à l'apprentissage automatique / à la classification
Bases de l'apprentissage automatique (mémoire)
Un débutant en apprentissage automatique a essayé la RBM
[Apprentissage automatique] Comprendre la forêt aléatoire
Apprentissage automatique avec Python! Préparation
Bloc-notes de ressources d'étude d'apprentissage automatique
Apprentissage automatique ② Résumé Naive Bayes
Résumé de l'article sur l'apprentissage automatique (auto-écrit)
À propos de la matrice mixte d'apprentissage automatique
Apprentissage automatique: forêt supervisée - aléatoire
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer Chapitre 7 Analyse de régression
Mémo pratique du système d'apprentissage automatique
Créer un environnement d'apprentissage automatique
Programmation Python Machine Learning> Mots-clés