Procédure d'apprentissage automatique de base: ④ Apprentissage du classificateur + apprentissage d'ensemble

introduction

Procédure d'apprentissage automatique de base: (1) Modèle de classification organise la procédure de création d'un modèle de classification de base. Cette fois, je voudrais me concentrer sur l'apprentissage des classificateurs et réaliser la sélection des classificateurs et l'apprentissage d'ensemble.

Procédure jusqu'à présent

• Procédure d'apprentissage automatique de base: ① Modèle de classification
• Procédure d'apprentissage automatique de base: ② Préparer les données
• Procédure d'apprentissage automatique de base: ③ Comparez et examinez les méthodes de sélection des fonctionnalités

Environnement analytique

Google BigQuery Google Colaboratory

Données cibles

(1) Semblable au modèle de classification, les données d'achat sont stockées dans la structure de tableau suivante.

0. Classificateur cible

Au début, j'ai essayé de comparer les performances des classificateurs, mais il est difficile de décider que c'est absolu. Je pense qu'il est important que chacun ait ses propres caractéristiques et utilise au mieux ces caractéristiques, c'est pourquoi j'apprends les quatre classificateurs suivants pour le moment.

--RandomForestClassifier: forêt aléatoire (légère, rapide, précise dans une certaine mesure) --LogisticRegression: régression logistique (ceci est inclus car il s'agit d'une classification zéro-ichi) --KNeighborsClassifier: méthode de voisinage k (facile à comprendre avec un modèle simple) --LGBMClassifier: LightGBM (tendance récente, précision plus élevée)

1. Apprentissage de chaque classificateur

Préparez le classificateur spécifié ci-dessus. La liste est faite dans l'ordre du nom, du classificateur et du paramètre. Le poids, que nous utiliserons plus tard, est le poids de l'apprentissage d'ensemble.

#Trieur

from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from lightgbm import LGBMClassifier

model_names=["RandomForestClassifier", "LogisticRegression", "KNeighborsClassifier", "LGBMClassifier"]
estimators=[RandomForestClassifier(), LogisticRegression(), KNeighborsClassifier(), LGBMClassifier()]
parameters=[
  {
    'n_estimators': [5, 10, 50, 100, 300],
    'max_depth': [5, 10, 20],
  },
  {
    'C': list(np.logspace(0, 4, 10))
  },
  {
    'weights': ['uniform','distance'],
    'n_neighbors': [3,5,10,20,30,50],
  },
  {
    'objective': ['binary'],
    'learning_rate': [0.01, 0.03, 0.05], 
    'n_estimators': [100, 150, 200], 
    'max_depth':[4, 6, 8]      
  }
]

weights=[1,1,1,1]

Nous exécuterons et formerons les modèles individuels définis ci-dessus. Ici, il faut beaucoup de temps pour s'exécuter un par un en série, alors reportez-vous à "Traitement parallèle avec parallélisme de scikit-learn" et en parallèle Fonctionnement

from sklearn.model_selection import GridSearchCV
from sklearn.externals.joblib import Parallel, delayed

models = []

def tuneParams(n):

  estimator = estimators[n]
  param = parameters[n]
  
  clf = GridSearchCV(
      estimator,
      param_grid=param,
      cv=5
      )
  
  clf = clf.fit(train_features, train_target)
  model = clf.best_estimator_

  return model

model = Parallel(n_jobs=-1)( delayed(tuneParams)(n) for n in range(len(estimators)) )
models.append(model)

Vous avez maintenant les meilleurs paramètres pour chaque classificateur dans la liste des modèles.

2. Apprentissage d'ensemble

En utilisant ce paramètre, vous pouvez apprendre l'apprentissage d'ensemble en combinant plusieurs classificateurs. "Appuyez sur l'apprentissage d'ensemble sckit-learn" Voting Classifier " Sera effectué en référence à.

On a l'impression de mettre les modèles créés en n ° 1 dans le classificateur de vote en boucle. Nous effectuerons à la fois l'apprentissage et l'apprentissage d'ensemble avec des classificateurs individuels.

from collections import defaultdict
from sklearn.ensemble import VotingClassifier
import sklearn.metrics as metrics

def modelingEnsembleLearning(train_features, test_features, train_target, test_target, models):

  mss = defaultdict(list)

  voting = VotingClassifier(list(zip([n for n in model_names],[m for m in models[0]])), voting='soft', weights=list([w for w in weights]))
  voting.fit(train_features,train_target)

  #Estimé par l'ensemble
  pred_target = voting.predict(test_features)
  ms = metrics.confusion_matrix(test_target.astype(int), pred_target.astype(int))
  mss['voting'].append(ms)

  #Estimé par des classificateurs individuels
  for name, estimator in voting.named_estimators_.items():
      pred_target = estimator.predict(test_features)
      ms = metrics.confusion_matrix(test_target.astype(int), pred_target.astype(int))
      mss[name].append(ms)
      
  return voting, mss

voting, mss = modelingEnsembleLearning(train_features, test_features, train_target, test_target, models)

3. Évaluation du modèle

Et enfin, l'évaluation du modèle. C'est parce que le programme n'a pas changé depuis le début.

from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score

accuracy=accuracy_score(test_target, voting.predict(test_features))
precision=precision_score(test_target.astype(int), voting.predict(test_features).astype(int))
recall=recall_score(test_target.astype(int), voting.predict(test_features).astype(int))

print("Voting")
print("Accuracy : ", accuracy*100, "%")
print("Precision : ", precision*100, "%")
print("Recall : ", recall*100, "%")

Lors de l'apprentissage d'un ensemble, LGBMClassifier est simplement plus précis en précision et RandomForestClassifier est plus élevé en rappel. Cependant, le bon équilibre global peut être le résultat d'un apprentissage d'ensemble. Lorsque cela se produira, nous utiliserons l'apprentissage d'ensemble comme modèle.

en conclusion

À partir de Procédure d'apprentissage automatique de base: ① Modèle de classification, selon ma compréhension du modèle de classification, toute la procédure + fouille individuelle en profondeur J'ai progressé. Pour le moment, je voudrais passer à l'étape suivante avec ceci comme paragraphe sur le modèle de classification.