[PYTHON] Ich habe meine eigene AML gemacht

Eine Welt, in der jeder leicht KI erschaffen kann

Mit der Veröffentlichung des Windows95-Betriebssystems im Jahr 1995 und der Verbreitung von Hardwareprodukten für die breite Öffentlichkeit ist das Internet zu einem Werkzeug geworden, das jeder problemlos nutzen kann. Ich denke, dies wird als "Entwicklung der Internetinfrastruktur" beschrieben.

Dasselbe wird mit der Technologie des maschinellen Lernens passieren. Dienste wie DataRobot und Azure Machine Learning Dies ist ein typisches Beispiel. In der Vergangenheit war die Datenanalyse durch maschinelles Lernen meines Erachtens ein ** exklusives Patent ** nur für professionelle Berufe wie Ingenieure und Datenwissenschaftler. Mit dem Aufkommen von Auto ML hat jedoch die Welle der "Demokratisierung des maschinellen Lernens" begonnen.

Dieses Mal ist der Zweck, es zu machen (einfach).

Was ist ML?

Bevor wir über AML sprechen Was ist maschinelles Lernen (ML)? Ich werde von reden.

Die englische Version von Wikipedia hatte die folgende Beschreibung.

Machine learning (ML) is the study of computer algorithms that improve automatically through experience. It is seen as a subset of artificial intelligence. Machine learning algorithms build a mathematical model based on sample data, known as "training data", in order to make predictions or decisions without being explicitly programmed to do so.

Mit anderen Worten kann gesagt werden, dass "die Zukunft aus vergangenen Erfahrungen (Daten) ohne menschliches Eingreifen ** vorhergesagt ** wird". Siehe die Abbildung unten. Bereiten Sie Rohdaten vor und prognostizieren Sie das "Ziel" über den gesamten Ablauf der "Vorverarbeitung" -> "Feature Engineering" -> "Lernen" -> "Modellauswahl / -bewertung" ** Es heißt maschinelles Lernen **.

Wenn Sie beispielsweise das Wetter von morgen vorhersagen möchten, können Sie es anhand des Wetters von gestern oder heute, der Temperatur, der Luftfeuchtigkeit, der Windrichtung und anderer Informationen vorhersagen. Zu diesem Zeitpunkt wird "Wetter von morgen" als "Ziel" ausgedrückt, und frühere Informationen wie "Informationen von gestern und heute" werden als "Rohdaten" ausgedrückt. (In diesem Fall sind viele andere Dinge zu beachten, da es sich um Zeitreihendaten handelt.)

Durch maschinelles Lernen müssen zwei Aufgaben gelöst werden: "Klassifizierungsproblem" und "Rückgabeproblem". Dieses Mal konzentrieren wir uns auf das "Klassifizierungsproblem".

Auto ML

Was ist Auto ML? Es bezieht sich auf maschinelles Lernen, das in der obigen Erläuterung "Vorverarbeitung" → "Feature Quantity Engineering" automatisiert.

Es gibt viele Möglichkeiten, Auto ML auf den Punkt zu bringen, aber das Ziel dieses Mal ist es, Auto ML zu entwickeln, das die folgenden Funktionen hat und die Genauigkeit jedes Modells vergleicht. Normalerweise ist es notwendig, Aufgaben wie die Parametereinstellung zu automatisieren, aber bitte verzeihen Sie mir diesmal> <

--Laden Sie Daten aus dem Datenpfad --onehot Codierung

• Ergänzen Sie fehlende Werte mit "Mittelwert", "Median" und "am häufigsten".
• Auswahl der Feature-Menge --Grid Research
• Zufällige Forschung
• Gemischte Matrix
• ROC-Kurve
• Wertung

Ganzer Code

Dieser Code befindet sich auf github

Datenaufbereitung

Dieses Mal verwenden wir den bekannten Titanic-Datensatz.

Verzeichnisaufbau

aml
|----data
 |      |---train.csv
 |      |---test.csv
|
|----model
 |      |---Das Modell wird hier gespeichert
|
|----myaml.inpynb

Vorbehandlung und Feature Quantity Engineering und Lernen

Ich werde Ihnen zuerst den Verwendungscode zeigen. Entspricht dem API-Beispiel.

model_data = 'data/train.csv'
scoring_data = 'data/test.csv'

aml = MyAML(model_data, scoring_data, onehot_columns=None)
 aml.drop_cols (['Name', 'Ticket', 'Kabine']) #Verwenden Sie keine Informationen zu Name, Ticket und Kabine
# Vorbehandlung und Feature-Quantity-Engineering (Feature-Mengenauswahl)
aml.preprocessing(target_col='Survived', index_col='PassengerId', feature_selection=False)
# Anzeige der Trainings- und Modellvergleichsergebnisse (übernimmt die Holdout-Methode)
aml.holdout_method(pipelines=pipelines_pca, scoring='auc')

Vorverarbeitung

Die Vorverarbeitung bezieht sich hier auf die folgenden beiden. Außerdem hoffe ich, dass der folgende Code erklärt werden kann, indem nur die wichtigen Teile abgekratzt werden.

--onehot Codierung

• Ergänzen Sie fehlende Werte mit "Mittelwert", "Median" und "am häufigsten".

Onehot-Codierung

    def _one_hot_encoding(self, X: pd.DataFrame) -> pd.DataFrame:
        ...

        # one_hot_encoding
 Wenn self.ohe_columns None ist: # obejct oder Kategoriespalten nur one_hot_encoding
            X_ohe = pd.get_dummies(X,
 dummy_na = True, # NULL wird ebenfalls zu einer Dummy-Variablen gemacht
 drop_first = True) # Die erste Kategorie ausschließen
        
 sonst: nur die durch # self.ohe_columns one_hot_encoding angegebenen Spalten
            X_ohe = pd.get_dummies(X,
 dummy_na = True, # NULL wird ebenfalls zu einer Dummy-Variablen gemacht
 drop_first = True, # Die erste Kategorie ausschließen
                                   columns=self.ohe_columns)
        ...

Bei der Initialisierung der MyAML-Klasse erhält "onehot_columns", das in der Instanzvariablen gespeichert ist, den "in onehot zu codierenden Spaltennamen" in einer Liste. Wenn nichts angegeben ist, werden die Spalten des empfangenen Datenrahmens vom Typ Objekt oder Kategorie nicht codiert.

Fehlende Wertvervollständigung

    def _impute_null(self, impute_null_strategy):
        """
 Ergänzen Sie fehlende Werte mit impute_null_strategy
 Arten von impute_null_strategy
 Mittelwert ... Ergänzung mit Durchschnittswert
 Median ... ergänzt durch Median
 most_frequent ... Ergänzung mit dem häufigsten Wert
        """
        self.imp = SimpleImputer(strategy=impute_null_strategy)
        self.X_model_columns = self.X_model.columns.values
        self.X_model = pd.DataFrame(self.imp.fit_transform(self.X_model),
                                    columns=self.X_model_columns)

Die Vervollständigung fehlender Werte wird mit der SimpleImputer-Klasse von scikit-learn durchgeführt. impute_null_strategy ist ein Argument, das angibt, was zu vervollständigen ist. Die entsprechende Komplementmethode ist wie folgt.

--mean ... Ergänzt durch Durchschnittswert -- median ... ergänzt durch median --most_frequent ... Ergänzung mit dem häufigsten Wert

Feature Quantity Engineering

Das Feature-Quantity-Engineering ist ebenfalls tiefgreifend, aber dieses Mal werden wir es vereinfachen und "Feature-Mengenauswahl durch ** zufällige Gesamtstruktur **" in Betracht ziehen.

    def _feature_selection(self, estimator=RandomForestClassifier(n_estimators=100, random_state=0), cv=5):
        """
 Merkmalsauswahl
 @param Estimator: Lernender für die Funktionsauswahl
        """
        self.selector = RFECV(estimator=estimator, step=.05, cv=cv)
        self.X_model = pd.DataFrame(self.selector.fit_transform(self.X_model, self.y_model),
                              columns=self.X_model_columns[self.selector.support_])
        self.selected_columns = self.X_model_columns[self.selector.support_]

Die erste Zeile initialisiert die RFECV-Klasse. In diesem Fall gibt der Schätzer "RandomForestClassifier" als Standard an. Wählen Sie in der nächsten Zeile die wichtigsten Merkmalsmengen aus. Speichern Sie abschließend ** ausgewählte Dinge ** in der Instanzvariablen selected_columns.

Lernen

Die Holdout-Methode vergleicht die Kompatibilität des Modells mit den Daten. Die Holdout-Methode ist eine Methode zum Trennen von Trainingsdaten (Daten, die zum Trainieren des Modells verwendet werden) und Testdaten (Daten zur Verifizierung, die nicht für das Training verwendet werden). Bei diesem Verfahren sind die Trainingsdaten immer Trainingsdaten und die Testdaten sind immer Testdaten.

Die Kreuzvalidierung wird auch als eine andere Möglichkeit implementiert, um die Kompatibilität des Modells und der Daten zu vergleichen, aber die Erklärung wird weggelassen.

    def holdout_method(self, pipelines=pipelines_pca, scoring='acc'):
        """
 Überprüfen Sie die Genauigkeit des Modells mit der Holdout-Methode
 @param piplines: Pipeline (Wörterbuch der zu versuchenden Modelle)
 @param Scoring: Bewertungsindex
 acc: Richtige Antwortrate
 auc: ROC-Kurvenfläche
        """
        X_train, X_test, y_train, y_test = train_test_split(self.X_model,
                                                            self.y_model,
                                                            test_size=.2,
                                                            random_state=1)
        y_train=np.reshape(y_train,(-1))
        y_test=np.reshape(y_test,(-1))

        scores={}
        for pipe_name, pipeline in pipelines.items():
            pipeline.fit(X_train, y_train)
            joblib.dump(pipeline, './model/'+ pipe_name + '.pkl')
            if scoring == 'acc':
                scoring_method = accuracy_score
            elif scoring == 'auc':
                scoring_method = roc_auc_score
            scores[(pipe_name, 'train')] = scoring_method(y_train, pipeline.predict(X_train))
            scores[(pipe_name, 'test')] = scoring_method(y_test, pipeline.predict(X_test))
        display(pd.Series(scores).unstack())

Hier hat die Variable piplines das folgende Format.

 make pipelines for PCA
pipelines_pca={
    """
 'Modellname': Pipeline ([('scl', Standardisierungsklasse))
 , ('pca', Klasse für die Hauptkomponentenanalyse)
 , ('est', Modell)])
    """
    'knn': Pipeline([('scl', StandardScaler())
                      , ('pca', PCA(random_state=1))
                      , ('est', KNeighborsClassifier())]),
    
    'logistic': Pipeline([('scl', StandardScaler())
                            , ('pca', PCA(random_state=1))
                            , ('est', LogisticRegression(random_state=1))]), 
    
     ...
}

Jede der drei Klassen, die auf die Pipeline-Klasse beschränkt sind, führt die folgenden Funktionen aus.

• 'scl': Standardisieren
• 'pca': Führen Sie eine Hauptkomponentenanalyse durch
• 'est': Modell

Daher wird zum Zeitpunkt von "Pipeline.fit (X_train, y_train)" eine Reihe von Abläufen von "Standardisierung" -> "Analyse der Merkmalsmenge durch Hauptkomponentenanalyse" -> "Lernen" durchgeführt.

My Dream

Ich habe einen Traum. "Es ist die Verwirklichung einer Gesellschaft, in der jeder leicht Modelle für maschinelles Lernen und tiefes Lernen erstellen kann, damit das Internet von jedem genutzt werden kann." Als ersten Schritt bei der Entwicklung der KI-Infrastruktur haben wir ein "System implementiert, in dem eine Reihe von maschinellen Lernprozessen einfach durch Überqueren eines Pfades ausgeführt werden können". Es gibt noch viele Orte, die ich noch nicht erreicht habe, aber ich werde weiterhin mein Bestes geben.