[PYTHON] Grundlegendes maschinelles Lernverfahren: ④ Klassifikatorlernen + Ensemble-Lernen

Einführung

Grundlegendes maschinelles Lernverfahren: (1) Klassifizierungsmodell organisiert das Verfahren zum Erstellen eines grundlegenden Klassifizierungsmodells. Dieses Mal möchte ich mich auf das Lernen von Klassifikatoren konzentrieren und die Auswahl von Klassifikatoren und das Lernen von Ensembles realisieren.

Verfahren bisher

• Grundlegendes maschinelles Lernverfahren: ① Klassifizierungsmodell
• Grundlegendes maschinelles Lernverfahren: ② Daten vorbereiten
• Grundlegendes maschinelles Lernverfahren: ③ Vergleichen und Untersuchen von Methoden zur Funktionsauswahl

Analyseumgebung

Google BigQuery Google Colaboratory

Zieldaten

(1) Ähnlich wie beim Klassifizierungsmodell werden Kaufdaten in der folgenden Tabellenstruktur gespeichert.

0. Zielklassifikator

Zuerst habe ich versucht, die Leistung von Klassifikatoren zu vergleichen, aber es ist schwierig zu entscheiden, dass dies absolut ist. Ich denke, dass jedes seine eigenen Merkmale hat und es wichtig ist, diese Merkmale bestmöglich zu nutzen, daher lerne ich vorerst die folgenden vier Klassifikatoren.

--RandomForestClassifier: Zufällige Gesamtstruktur (leicht, schnell, mit einiger Genauigkeit) --LogisticRegression: Logistische Regression (dies ist enthalten, da es sich um eine Null-Ichi-Klassifikation handelt) --KNeighborsClassifier: k Nachbarschaftsmethode (leicht verständlich mit einem einfachen Modell) --LGBMClassifier: LightGBM (aktueller Trend, höhere Genauigkeit)

1. Lernen jedes Klassifikators

Bereiten Sie den oben angegebenen Klassifikator vor. Die Liste wird in der Reihenfolge von Name, Klassifizierer und Parameter erstellt. Das Gewicht, das wir später verwenden werden, ist das Gewicht des Ensemble-Lernens.

#Sorter

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]

Wir werden die oben definierten Einzelmodelle ausführen und trainieren. Hier dauert es lange, bis eine nach der anderen seriell ausgeführt wird. Weitere Informationen finden Sie unter "Parallele Verarbeitung mit Parallelen von Scikit-Learn" und parallel Laufen

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)

Sie haben jetzt die besten Parameter für jeden Klassifikator in Ihrer Modellliste.

2. Ensemble lernen

Mit diesem Parameter können Sie das Lernen von Ensembles lernen, indem Sie mehrere Klassifikatoren kombinieren. "Berühren Sie das sckit-learn-Ensemble-Lernen" Voting Classifier " Wird unter Bezugnahme auf durchgeführt.

Es fühlt sich an, als würden Sie die in # 1 erstellten Modelle während des Loopings in den Voting Classifier einfügen. Wir werden sowohl Ensemble-Lernen als auch Lernen mit einzelnen Klassifikatoren durchführen.

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)

  #Geschätzt vom Ensemble
  pred_target = voting.predict(test_features)
  ms = metrics.confusion_matrix(test_target.astype(int), pred_target.astype(int))
  mss['voting'].append(ms)

  #Geschätzt von einzelnen Klassifikatoren
  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. Modellbewertung

Und schließlich die Bewertung des Modells. Dies liegt daran, dass sich das Programm von Anfang an nicht geändert hat.

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, "%")

Beim Erlernen des Ensembles ist der LGBMClassifier in der Genauigkeit einfach höher und der RandomForestClassifier in Recall höher. Die insgesamt gute Balance kann jedoch das Ergebnis des Ensemble-Lernens sein. In diesem Fall werden wir das Lernen von Ensembles als Modell verwenden.

abschließend

Beginnend mit Grundlegendes maschinelles Lernverfahren: ① Klassifizierungsmodell, nach meinem Verständnis des Klassifizierungsmodells das gesamte Verfahren + individuelles Tiefgraben Ich bin weitergekommen. Vorerst möchte ich mit diesem nächsten Absatz als Absatz über das Klassifizierungsmodell fortfahren.