Python Machine Learning: Scikit-Learn Tutorial

Maschinelles Lernen ist ein Teilgebiet der künstlichen Intelligenz, das sich mit dem Verständnis und der Entwicklung von Methoden befasst, die die Art und Weise, wie Menschen lernen, nachahmen. Diese Methoden beinhalten die Verwendung von Algorithmen und Daten, um die Leistung bei einer Reihe von Aufgaben zu verbessern, und fallen oft unter eine der drei häufigsten Lernarten: 

• Überwachtes Lernen: Eine Art des maschinellen Lernens, bei dem die Beziehung zwischen Eingabe und Ausgabe gelernt wird. 
• Unüberwachtes Lernen: Eine Art des maschinellen Lernens, bei dem die zugrundeliegende Struktur eines nicht beschrifteten Datensatzes erlernt wird.   
• Verstärkungslernen: Eine Methode des maschinellen Lernens, bei der der Software-Agent lernt, bestimmte Handlungen in einer Umgebung auszuführen, die ihn zu einer maximalen Belohnung führen.

Scikit-learn, auch bekannt als sklearn, ist eine robuste Open-Source-Bibliothek für maschinelles Lernen in Python. Es wurde entwickelt, um die Implementierung von Machine Learning und statistischen Modellen in Python zu vereinfachen. 

Die Bibliothek ermöglicht es Praktikern, eine breite Palette von überwachten und unüberwachten maschinellen Lernalgorithmen über eine einheitliche Schnittstelle schnell zu implementieren. Sklearn wurde auf SciPy aufgebaut und funktioniert mit allen Arten von numerischen Daten, die entweder als NumPy-Arrays, SciPy-Sparse-Matrizen oder als alle anderen Datentypen gespeichert sind, die in numerische Arrays wie Pandas DataFrames umgewandelt werden können.  

In diesem praktischen Sklearn-Tutorial werden wir verschiedene Aspekte des Lebenszyklus des maschinellen Lernens behandeln, z. B. die Datenverarbeitung, das Modelltraining und die Modellbewertung.  

Schau dir diesen DataCamp-Arbeitsbereich an, um dem Code zu folgen. 

Daten

Der erste Aspekt von Scikit-learn, den wir untersuchen werden, sind die Daten. Scikit-learn wird mit einigen Standarddatensätzen für maschinelles Lernen geliefert, sodass du sie nicht von einer externen Website oder Datenbank herunterladen musst. 

Beispiele für die Spielzeug-Datensätze die in sklearn verfügbar sind, sind der Iris-Datensatz für die Klassifizierung und der Diabetes-Datensatz für die Regression. Für unser Beispiel werden wir den den Wein-Datensatz.

Lass es uns in den Speicher laden:

from sklearn.datasets import load_wine

wine_data = load_wine() 

Die Ausführung des obigen Codes gibt ein wörterbuchähnliches Objekt zurück, das die Daten zusammen mit Metadaten über die darin enthaltenen Daten enthält. 

Die Daten, die wir brauchen, befinden sich in der .data Schlüssel des wörterbuchähnlichen Objekts, aber da es sich nicht um ein echtes Wörterbuch handelt, können wir auf sie als ein Attribut der wine_data Instanz wie folgt zugreifen:

wine_data.data

Das Ergebnis ist ein N x M-Array, wobei N die Anzahl der Proben und M die Anzahl der Merkmale ist.  

Nutzen wir dieses Wissen, um unsere Daten in einen pandas DataFramezu laden, der viel einfacher zu manipulieren und zu analysieren ist.

import pandas as pd
from sklearn.datasets import load_wine

wine_data = load_wine()

# Convert data to pandas dataframe
wine_df = pd.DataFrame(wine_data.data, columns=wine_data.feature_names)

# Add the target label
wine_df["target"] = wine_data.target

# Take a preview
wine_df.head()

Jetzt kannst du mit der Datenerforschung beginnen. 

Datenexploration

Pandas DataFrames sind als zweidimensionale, beschriftete Datenstrukturen definiert, die aus Spalten bestehen, die verschiedene Datenschritte enthalten können. Am einfachsten kann man sich einen DataFrame als drei Komponenten vorstellen, die miteinander verschmolzen sind: 1) Daten, 2) ein Index und 3) Spalten. 

Die Datenexploration ist nicht das Hauptthema dieses Artikels, aber sie ist ein extrem wichtiger Schritt in jedem Datenprojekt - du kannst mehr darüber in unserem Python-Tutorial zur explorativen Datenanalyse. Wir werden eine kurze Erkundung durchführen, um eine bessere Vorstellung davon zu bekommen, was unser Datensatz enthält; das gibt uns eine bessere Vorstellung davon, wie wir die Daten verarbeiten können. 

Als erstes werden wir die Funktion info() Methode für unseren Pandas DataFrame auf; damit wird eine kurze Zusammenfassung der im DataFrame enthaltenen Weindaten ausgegeben.

wine_df.info()

"""

RangeIndex: 178 entries, 0 to 177
Data columns (total 14 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   alcohol                       178 non-null    float64
 1   malic_acid                    178 non-null    float64
 2   ash                           178 non-null    float64
 3   alcalinity_of_ash             178 non-null    float64
 4   magnesium                     178 non-null    float64
 5   total_phenols                 178 non-null    float64
 6   flavanoids                    178 non-null    float64
 7   nonflavanoid_phenols          178 non-null    float64
 8   proanthocyanins               178 non-null    float64
 9   color_intensity               178 non-null    float64
 10  hue                           178 non-null    float64
 11  od280/od315_of_diluted_wines  178 non-null    float64
 12  proline                       178 non-null    float64
 13  target                        178 non-null    int64  
dtypes: float64(13), int64(1)
memory usage: 19.6 KB
"""

Nachdem du diese Zelle ausgeführt hast, wirst du lernen: 

• Die Daten enthalten 178 Datenproben
• Es gibt insgesamt 14 Spalten, einschließlich der Zielspalte (was wir vorhersagen wollen)
• Es gibt 0 Spalten mit fehlenden Werten; das kannst du der Spalte "Non-Null Count" entnehmen. 
• Alle Merkmale sind vom Datentyp float64, während das Ziellabel ein int64.
• Die Daten benötigen 19,6 KB Speicherplatz. 

Wir können auch die Methode describe() für unseren DataFrame aufrufen, um beschreibende Statistiken über jedes Merkmal im Datensatz zu erhalten. 

Zum Beispiel: 

wine_df.describe() 

Du willst auch eine Vorstellung davon haben, welche Art von Werten in jedem Merkmal enthalten ist. Am schnellsten lernst du das, indem du die Methode head() verwendest, um die ersten fünf Datenzeilen anzuzeigen, oder die Methode tail(), um die letzten fünf Datenzeilen zu sehen. 

wine_df.tail()

Die Ausführung dieses Codes zeigt uns, dass unsere Merkmale auf unterschiedlichen Skalen liegen, was zu Problemen führen kann, wenn wir mit Gradient Descent-basierten Algorithmen wie der logistischen Regression und mit Distanz-basierten Algorithmen wie Support Vector Machines arbeiten. Das liegt daran, dass sie empfindlich auf die Bandbreite der Datenpunkte reagieren. 

In einem normalen Lernpfad für maschinelles Lernen würde sich dieser Prozess viel länger hinziehen, aber wir werden die Datenverarbeitung überspringen, um zum Hauptthema dieses Tutorials, Scikit-learn, zurückzukehren. 

Mehr über Pandas erfährst du im Python Pandas Tutorial: Der ultimative Leitfaden für Einsteiger. 

Scikit-learn Beispiel: Vorverarbeitung der Daten

Wir haben eine gute Vorstellung davon, wie unsere Daten aussehen. Wenn du an diesem Punkt angelangt bist, bedeutet das in der Regel, dass du damit beginnen kannst, die Daten für ein maschinelles Lernmodell vorzubereiten. 

Die Datenverarbeitung ist ein wichtiger Schritt im Workflow des maschinellen Lernens, denn die Daten aus der realen Welt sind chaotisch. Es kann enthalten: 

• Fehlende Werte,
• Redundante Werte
• Ausreißer
• Fehler
• Lärm

Du musst all dies in den Griff bekommen, bevor du die Daten an ein maschinelles Lernmodell weitergibst. Andernfalls wird das Modell diese Fehler in seine Näherungsfunktion einbauen - es wird lernen, bei neuen Fällen Fehler zu machen. Daraus entstand das berühmte Sprichwort zum maschinellen Lernen: "Garbage in, garbage out". 

Ein weiterer Grund ist, dass maschinelle Lernmodelle in der Regel numerische Daten benötigen.  

Abgesehen davon, dass unsere Daten auf unterschiedlichen Skalen liegen, gibt es auf den ersten Blick nicht viel, was mit unseren Daten nicht stimmt. Um dieses Problem zu bekämpfen, standardisieren wir die Merkmale mit derKlasse StandardScaler von sklearn; so stellen wir sicher, dass der Mittelwert jedes Merkmals ungefähr gleich Null ist .

Hier ist der Code: 

from sklearn.preprocessing import StandardScaler

# Split data into features and label 
X = wine_df[wine_data.feature_names].copy()
y = wine_df["target"].copy() 

# Instantiate scaler and fit on features
scaler = StandardScaler()
scaler.fit(X)

# Transform features
X_scaled = scaler.transform(X.values)

# View first instance
print(X_scaled[0])

"""
[ 1.51861254 -0.5622498   0.23205254 -1.16959318  1.91390522  0.80899739
  1.03481896 -0.65956311  1.22488398  0.25171685  0.36217728  1.84791957
  1.01300893]
"""

Lass uns mit dem Training des Modells fortfahren. 

Scikit-learn Beispiel: Model Ausbildung

Bevor ein maschinelles Lernmodell Vorhersagen machen kann, muss es auf einem Datensatz trainiert werden, um eine Näherungsfunktion zu lernen. 

Aber woher sollen wir wissen, ob das Modell bei Daten, die es noch nie gesehen hat, gut funktioniert? Das werden wir erst wissen, wenn wir es ausprobiert haben. 

Eine Möglichkeit, ein Modell für maschinelles Lernen zu testen, bevor es in einer Umgebung eingesetzt wird, in der es Auswirkungen auf andere hat, besteht darin, die Trainingsdaten in einen Trainings- und einen Testsatz aufzuteilen und den Testsatz zu verwenden, um zu bewerten, was das Modell gelernt hat; dies wird als Offline-Evaluation bezeichnet. 

Es gibt verschiedene Möglichkeiten, die Daten in Trainings- und Testsets aufzuteilen, aber scikit-learn hat eine eingebaute Funktion, die dies für uns erledigt, nämlich train_test_split().

Wir verwenden diese Funktion, um unsere Daten so aufzuteilen, dass 70 % zum Trainieren des Modells verwendet werden und 30 %, um die Fähigkeit des Modells zur Generalisierung auf ungesehene Instanzen zu bewerten. 

from sklearn.model_selection import train_test_split

# Split data into train and test
X_train_scaled, X_test_scaled, y_train, y_test = train_test_split(X_scaled,
                                                                  y,
                                                             train_size=.7,
                                                           random_state=25)

# Check the splits are correct
print(f"Train size: {round(len(X_train_scaled) / len(X) * 100)}% \n\
Test size: {round(len(X_test_scaled) / len(X) * 100)}%")

"""
Train size: 70% 
Test size: 30%

Jetzt lass uns ein paar Modelle bauen. 

Das Modell bauen

Dank sklearn ist es extrem einfach, ein Modell für maschinelles Lernen zu erstellen. 

Wir werden drei Modelle erstellen, um die Klasse des Weins vorherzusagen: 

1. Logistische Regression
2. Support-Vektor-Maschine 
3. Entscheidungsbaum-Klassifikator

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

# Instnatiating the models 
logistic_regression = LogisticRegression()
svm = SVC()
tree = DecisionTreeClassifier()

# Training the models 
logistic_regression.fit(X_train_scaled, y_train)
svm.fit(X_train_scaled, y_train)
tree.fit(X_train_scaled, y_train)

# Making predictions with each model
log_reg_preds = logistic_regression.predict(X_test_scaled)
svm_preds = svm.predict(X_test_scaled)
tree_preds = tree.predict(X_test_scaled)

Der nächste Schritt ist die Bewertung der Verallgemeinerbarkeit der Modelle für ungesehene Fälle. 

Scikit-learn Beispiel: Modellbewertung

Die Modellevaluierung wird durchgeführt, um zu testen, wie gut das Modell auf ungesehene Instanzen verallgemeinert. Scikit-learn bietet eine Reihe von Klassifizierungs- und Regressionsmetriken, um die Leistung eines trainierten Modells zu bewerten. 

Für unseren Anwendungsfall werden wir Folgendes verwenden klassifizierung_bericht() aus den metrics Modul, um einen Textbericht zu erstellen, der die wichtigsten Klassifizierungskennzahlen wie Precision, Recall, f1_score, Accuracy usw. enthält.

So sieht es im Code aus:

from sklearn.metrics import classification_report

# Store model predictions in a dictionary
# this makes it's easier to iterate through each model
# and print the results. 
model_preds = {
    "Logistic Regression": log_reg_preds,
    "Support Vector Machine": svm_preds,
    "Decision Tree": tree_preds
}

for model, preds in model_preds.items():
    print(f"{model} Results:\n{classification_report(y_test, preds)}", sep="\n\n")

"""
Logistic Regression Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      0.92      0.96        25
           2       0.86      1.00      0.92        12

    accuracy                           0.96        54
   macro avg       0.95      0.97      0.96        54
weighted avg       0.97      0.96      0.96        54

Support Vector Machine Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      1.00      1.00        25
           2       1.00      1.00      1.00        12

    accuracy                           1.00        54
   macro avg       1.00      1.00      1.00        54
weighted avg       1.00      1.00      1.00        54

Decision Tree Results:
              precision    recall  f1-score   support

           0       0.94      0.94      0.94        17
           1       0.96      0.88      0.92        25
           2       0.86      1.00      0.92        12

    accuracy                           0.93        54
   macro avg       0.92      0.94      0.93        54
weighted avg       0.93      0.93      0.93        54
"""

Auf den ersten Blick sieht es so aus, als ob die Support-Vektor-Maschine das beste Modell ist. In einem typischen Arbeitsablauf würde dies die Neugier auf das Modell wecken - ist es wirklich so gut, wie es aussieht, oder haben wir irgendwo einen Fehler gemacht? Du solltest neugierig sein, mehr über deine Modelle zu erfahren und was sie lernen, denn so kannst du ihre Stärken und Schwächen besser einschätzen. 

Die Kenntnis dieser Informationen ist für die Interessengruppen äußerst aufschlussreich, da sie so Lösungen finden können, um die Defizite des Modells auszugleichen. 

Fazit

Die scikit-learn-Bibliothek besteht aus mehreren Modulen, die die Implementierung von Machine-Learning-Modellen erleichtern. Diese Module reichen von Vorverarbeitungswerkzeugen, mit denen du dein Modell für die Einspeisung in ein maschinelles Lernmodell vorbereiten kannst, über Modelle, mit denen du Muster in deinen Daten finden kannst, bis hin zu Bewertungsmetriken, mit denen du die Leistung deines Modells beurteilen kannst. 

In diesem Lernprogramm haben wir nur an der Oberfläche der Möglichkeiten von sklearn gekratzt. Um mehr über die Möglichkeiten der Bibliothek zu erfahren, haben wir einige Ressourcen, die dir den Einstieg erleichtern. Hier sind ein paar für den Anfang: 

• Überwachtes Lernen mit Scikit-Learn
• Unüberwachtes Lernen in Python
• K-Nächste-Nachbarn-Klassifizierung (KNN) mit Scikit-Learn