Wissensdatenbank

Was ist Scikit-learn (sklearn) und warum sollte man es verwenden?

Scikit-learn ist eine Open-Source-Bibliothek für maschinelles Lernen für die Programmiersprache Python. Sie zielt darauf ab, Datenanalyse- und Modellierungsaufgaben zu vereinfachen, indem sie einfache und effiziente Werkzeuge bereitstellt. Scikit-learn umfasst eine breite Palette von Algorithmen, darunter Klassifizierung, Regression, Clustering, Dimensionsreduktion, Modellauswahl und Vorverarbeitung.

Warum Scikit-learn verwenden?

• Benutzerfreundlichkeit: Es verfügt über eine saubere und konsistente API, die das Erlernen und Verwenden erleichtert.
• Breite Algorithmusauswahl: Es enthält verschiedene Algorithmen für maschinelles Lernen, sodass Sie problemlos geeignete Modelle für verschiedene Datensätze und Problemtypen ausprobieren können.
• Dokumentation: Es verfügt über eine umfassende und gut strukturierte Dokumentation, die das Verständnis von Algorithmusdetails und Anwendungsbeispielen erleichtert.
• Community-Unterstützung: Es verfügt über eine große und aktive Community, was Vorteile bei der Fehlerbehebung und dem Erhalt von Hilfe bietet.
• Integration: Es lässt sich nahtlos in andere wissenschaftliche Python-Bibliotheken wie NumPy, SciPy und Matplotlib integrieren.
• Leistung: Dank einiger in Cython geschriebener Teile bietet es eine hohe Leistung.

Was sind die grundlegenden Komponenten von Scikit-learn?

Die Scikit-learn-Bibliothek verfügt über viele verschiedene Module und Klassen, die zur Durchführung verschiedener Aufgaben des maschinellen Lernens verwendet werden können. Hier sind einige der grundlegendsten Komponenten:

• Estimators (Schätzer): Dies sind die grundlegenden Klassen, die zum Trainieren von Modellen für maschinelles Lernen und zum Erstellen von Vorhersagen verwendet werden. Beispiel: LinearRegression, LogisticRegression, DecisionTreeClassifier.
• Transformers (Transformierer): Dies sind Klassen, die zum Vorverarbeiten und Transformieren von Daten verwendet werden. Beispiel: StandardScaler, MinMaxScaler, PCA.
• Datasets (Datensätze): Scikit-learn enthält einige integrierte Datensätze, die für Experimentier- und Lernzwecke verwendet werden können. Beispiel: load_iris, load_digits, make_classification.
• Model Selection (Modellauswahl): Dies sind Tools, die zum Bewerten von Modellen und zum Finden der besten Parameter verwendet werden. Beispiel: train_test_split, cross_val_score, GridSearchCV.
• Metrics (Metriken): Dies sind Funktionen, die zum Messen der Modellleistung verwendet werden. Beispiel: accuracy_score, mean_squared_error, r2_score.

Beispielcode: Ein einfaches lineares Regressionsmodell

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# Datenerstellung
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 5, 4, 5])

# Aufteilen der Daten in Trainings- und Testdatensätze
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Erstellen und Trainieren des linearen Regressionsmodells
model = LinearRegression()
model.fit(X_train, y_train)

# Vorhersage auf Testdaten
y_pred = model.predict(X_test)

# Berechnung der Fehlermetriken
mse = mean_squared_error(y_test, y_pred)
print(f"Mittlerer quadratischer Fehler (MSE): {mse}")

Warum ist Datenvorverarbeitung (Preprocessing) wichtig und welche Techniken werden verwendet?

Die Datenvorverarbeitung kann die Leistung von Modellen des maschinellen Lernens erheblich beeinflussen. Rohdaten enthalten oft fehlende Werte, Ausreißer und inkonsistente Formate. Daher sind Vorverarbeitungsschritte erforderlich, um die Daten für die Modellierung geeignet zu machen.

Datenvorverarbeitungstechniken:

• Umgang mit fehlenden Werten: Es gibt verschiedene Methoden, um fehlende Werte zu ersetzen.
  • Ersetzen durch Mittelwert/Median: Fehlende Werte in numerischen Spalten können durch den Mittelwert oder Median dieser Spalte ersetzt werden.
  • Ersetzen durch einen konstanten Wert: Fehlende Werte können durch einen bestimmten konstanten Wert (z. B. 0 oder -1) ersetzt werden.
  • Ersetzen durch den häufigsten Wert: Fehlende Werte in kategorialen Spalten können durch den häufigsten Wert in dieser Spalte ersetzt werden.
  • KNN-Imputation: Fehlende Werte können mithilfe des K-Nearest Neighbors-Algorithmus geschätzt werden.
• Feature Scaling: Wird verwendet, um Features unterschiedlicher Skalen in denselben Bereich zu bringen.
  • Standardisierung (StandardScaler): Skaliert Features so, dass der Mittelwert 0 und die Standardabweichung 1 beträgt.
  • Min-Max-Skalierung (MinMaxScaler): Skaliert Features in einen bestimmten Bereich (normalerweise zwischen 0 und 1).
  • RobustScaler: Ist robuster gegenüber Ausreißern und verwendet den Median.
• Kategoriale Kodierung (Categorical Encoding): Wird verwendet, um kategoriale Daten in numerische Daten umzuwandeln.
  • One-Hot Encoding: Erstellt für jede Kategorie eine separate Spalte und weist der entsprechenden Zeile den Wert 1 und allen anderen den Wert 0 zu.
  • Label Encoding: Weist jeder Kategorie eine eindeutige numerische Bezeichnung zu.
  • Ordinal Encoding: Wenn es eine Reihenfolge zwischen den Kategorien gibt, werden numerische Bezeichnungen entsprechend dieser Reihenfolge zugewiesen.
• Umgang mit Ausreißern (Outlier Handling): Wird verwendet, um Ausreißer zu erkennen und zu korrigieren.
  • Z-Score-Methode: Werte, deren Z-Score einen bestimmten Schwellenwert überschreitet, werden als Ausreißer betrachtet.

Beispielcode: Datenvorverarbeitung

from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
import pandas as pd

# Beispiel Datensatz
data = {'cinsiyet': ['erkek', 'kadın', 'erkek', 'kadın', None],
        'yas': [25, 30, None, 35, 40],
        'maas': [50000, 60000, 70000, 80000, 90000]}
df = pd.DataFrame(data)

# Fehlende Werte füllen
imputer_yas = SimpleImputer(strategy='mean')
df['yas'] = imputer_yas.fit_transform(df[['yas']])

imputer_cinsiyet = SimpleImputer(strategy='most_frequent')
df['cinsiyet'] = imputer_cinsiyet.fit_transform(df[['cinsiyet']])

# Kategorische Daten kodieren
encoder = OneHotEncoder(sparse_output=False)
encoded_cinsiyet = encoder.fit_transform(df[['cinsiyet']])
encoded_df = pd.DataFrame(encoded_cinsiyet, columns=encoder.get_feature_names_out(['cinsiyet']))
df = pd.concat([df, encoded_df], axis=1)
df.drop('cinsiyet', axis=1, inplace=True)

# Feature Skalierung
scaler = StandardScaler()
df['maas'] = scaler.fit_transform(df[['maas']])

print(df)

Wie wählt man ein Modell aus und bewertet es?

Modellauswahl und -bewertung sind kritische Schritte in einem Machine-Learning-Projekt. Sie werden verwendet, um die Leistung verschiedener Algorithmen und Parameter zu vergleichen, das beste Modell auszuwählen und die Leistung des Modells in der realen Welt vorherzusagen.

Methoden zur Modellauswahl:

• Train-Test-Split: Der Datensatz wird in Trainings- und Testdatensätze aufgeteilt. Das Modell wird auf dem Trainingsdatensatz trainiert und auf dem Testdatensatz bewertet.
• Kreuzvalidierung: Der Datensatz wird in mehrere Schichten aufgeteilt. Das Modell wird für jede Schicht mit einer anderen Kombination trainiert und bewertet. Dies hilft, die Generalisierungsfähigkeit des Modells besser vorherzusagen.
  • K-Fold-Kreuzvalidierung: Der Datensatz wird in K gleiche Teile aufgeteilt. Jeder Teil wird nacheinander als Testdatensatz verwendet, während die restlichen Teile als Trainingsdatensatz verwendet werden.
  • Stratifizierte K-Fold-Kreuzvalidierung: Wird in Fällen verwendet, in denen die Klassenverteilungen erhalten bleiben müssen. Die Klassenverhältnisse bleiben in jeder Schicht gleich.
• Gittersuche: Wird verwendet, um die Hyperparameter des Modells zu optimieren. Es werden alle möglichen Kombinationen innerhalb eines bestimmten Parameterbereichs ausprobiert und die Parameter ausgewählt, die die beste Leistung erbringen.
• Randomisierte Suche: Ähnlich wie bei der Gittersuche, wählt aber Parameterkombinationen zufällig aus. Kann besonders in großen Parameterbereichen effizienter sein.

Metriken zur Modellbewertung:

• Klassifikationsmetriken:
  • Accuracy (Genauigkeit): Der Anteil der insgesamt korrekten Vorhersagen.
  • Precision (Präzision): Wie viele der als positiv vorhergesagten Beispiele tatsächlich positiv sind.
  • Recall (Trefferquote/Sensitivität): Wie viele der tatsächlich positiven Beispiele korrekt als positiv vorhergesagt wurden.
  • F1-Score: Das harmonische Mittel von Präzision und Trefferquote.
  • AUC-ROC: Die Fläche unter der ROC-Kurve, die zur Bewertung der Klassifikationsleistung des Modells verwendet wird.
• Regressionsmetriken:
  • Mean Squared Error (MSE): Der Durchschnitt der quadrierten Differenzen zwischen den vorhergesagten und den tatsächlichen Werten.
  • Root Mean Squared Error (RMSE): Die Quadratwurzel des MSE.
  • Mean Absolute Error (MAE): Der Durchschnitt der absoluten Differenzen zwischen den vorhergesagten und den tatsächlichen Werten.
  • R-squared (R²): Gibt den Prozentsatz der Varianz an, der durch die unabhängigen Variablen des Modells erklärt wird.

Beispielcode: Modellauswahl und -bewertung

from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
from sklearn.datasets import load_iris

# Laden des Datensatzes
iris = load_iris()
X, y = iris.data, iris.target

# Aufteilen der Daten in Trainings- und Testmengen
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Erstellen des logistischen Regressionsmodells
model = LogisticRegression(max_iter=1000)

# Bewertung der Modellleistung durch Kreuzvalidierung
cv_scores = cross_val_score(model, X_train, y_train, cv=5, scoring='accuracy')
print(f"Kreuzvalidierungs-Genauigkeiten: {cv_scores}")
print(f"Durchschnittliche Kreuzvalidierungs-Genauigkeit: {cv_scores.mean()}")

# Hyperparameteroptimierung mit Grid Search
param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100]}
grid_search = GridSearchCV(model, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print(f"Beste Parameter: {grid_search.best_params_}")
print(f"Beste Kreuzvalidierungs-Genauigkeit: {grid_search.best_score_}")

# Vorhersage auf den Testdaten mit dem besten Modell
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)

# Bewertung der Modellleistung
accuracy = accuracy_score(y_test, y_pred)
print(f"Testgenauigkeit: {accuracy}")
print(classification_report(y_test, y_pred))

Wie führt man Clustering mit Scikit-learn durch?

Clustering ist der Prozess der Gruppierung von Datenpunkten mit ähnlichen Eigenschaften. Scikit-learn bietet verschiedene Clustering-Algorithmen wie K-Means, hierarchisches Clustering, DBSCAN.

K-Means-Clustering:

K-Means ist ein Algorithmus, der darauf abzielt, Datenpunkte in K Cluster zu unterteilen. Jedes Cluster wird durch einen Mittelpunkt (Zentroid) repräsentiert, und Datenpunkte werden dem Cluster zugewiesen, das den nächstgelegenen Mittelpunkt hat. Der Algorithmus optimiert die Cluster, indem er die Position der Mittelpunkte iterativ aktualisiert.

Schritt für Schritt K-Means-Clustering:

1. K-Wert bestimmen: Entscheiden Sie, wie viele Cluster Sie erstellen möchten.
2. Anfangsmittelpunkte auswählen: Wählen Sie zufällig K Datenpunkte als Anfangsmittelpunkte aus.
3. Datenpunkte Clustern zuordnen: Ordnen Sie jeden Datenpunkt dem Cluster zu, das den nächstgelegenen Mittelpunkt hat.
4. Mittelpunkte aktualisieren: Aktualisieren Sie den Mittelpunkt jedes Clusters als den Durchschnitt der Datenpunkte in diesem Cluster.
5. Wiederholen: Wiederholen Sie die Schritte 3 und 4, bis sich die Mittelpunkte nicht mehr ändern oder eine bestimmte Anzahl von Iterationen abgeschlossen ist.

Hierarchical Clustering (Hierarchische Clusteranalyse):

Hierarchische Clusteranalyse ist ein Algorithmus, der darauf abzielt, Datenpunkte in einer hierarchischen Struktur in Gruppen zu unterteilen. Es gibt zwei Haupttypen: Agglomerativ (zusammenführend) und Divisive (teilend).

DBSCAN (Density-Based Spatial Clustering of Applications with Noise):

DBSCAN ist ein Algorithmus, der darauf abzielt, Cluster basierend auf der Dichte von Datenpunkten zu erstellen. Es ist effektiv im Umgang mit verrauschten Daten und erfordert keine vorherige Angabe der Anzahl der Cluster.

Beispielcode: K-Means-Clustering

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# Erstellung eines Beispieldatensatzes
X, y = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# Erstellung und Training des K-Means-Modells
kmeans = KMeans(n_clusters=4, init='k-means++', max_iter=300, n_init=10, random_state=0)
y_kmeans = kmeans.fit_predict(X)

# Visualisierung der Clustering-Ergebnisse
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')

centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75);
plt.show()

Was sind Dimensionsreduktionstechniken und wozu dienen sie?

Dimensionsreduktion ist der Prozess der Reduzierung der Anzahl der Merkmale in einem Datensatz. Sie wird verwendet, um die Komplexität des Modells zu reduzieren, die Rechenkosten zu senken und Overfitting zu vermeiden, wenn mit hochdimensionalen Daten gearbeitet wird.

Dimensionsreduktionstechniken:

• Hauptkomponentenanalyse (PCA): Findet die Hauptkomponenten, die die Varianz im Datensatz am besten erklären, und transformiert die ursprünglichen Merkmale in diese Komponenten.
• Lineare Diskriminanzanalyse (LDA): Findet die linearen Kombinationen, die die Trennung zwischen den Klassen am besten gewährleisten. Wird bei Klassifizierungsproblemen verwendet.
• t-verteilte stochastische Nachbareinbettung (t-SNE): Betten Sie hochdimensionale Daten in einen niedrigdimensionalen Raum (normalerweise 2- oder 3-dimensional) ein, um die Visualisierung zu erleichtern.
• Merkmalsauswahl (Feature Selection): Wählt die wichtigsten Merkmale im Datensatz aus und verwirft die restlichen Merkmale.
  • Varianzschwellenwert (Variance Thresholding): Verwirft Merkmale mit geringer Varianz.
  • SelectKBest: Wählt eine bestimmte Anzahl der besten Merkmale aus.
  • Rekursive Merkmalseliminierung (RFE): Eliminiert Merkmale iterativ basierend auf der Leistung des Modells.

Beispielcode: Dimensionsreduktion mit PCA

from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# Laden des Datensatzes
iris = load_iris()
X, y = iris.data, iris.target

# Erstellen und Trainieren des PCA-Modells
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

# Visualisierung der dimensionsreduzierten Daten
plt.scatter(X_reduced[:, 0], X_reduced[:, 1], c=y, cmap='viridis')
plt.xlabel('Hauptkomponente 1')
plt.ylabel('Hauptkomponente 2')
plt.show()

Vergleich von Scikit-learn Algorithmen

Verwendung von Pipeline mit Scikit-learn

Pipeline ist ein Werkzeug, das es ermöglicht, die Schritte im Machine-Learning-Workflow (Datenvorverarbeitung, Feature Engineering, Modelltraining usw.) unter einem einzigen Objekt zu kombinieren. Dies sorgt dafür, dass der Code übersichtlicher, lesbarer und wartungsfreundlicher ist.

Vorteile von Pipeline:

• Organisation des Codes: Definiert die Schritte im Workflow an einem einzigen Ort.
• Fehlervermeidung: Stellt Konsistenz sicher, indem die gleichen Vorverarbeitungsschritte auf Trainings- und Testdaten angewendet werden.
• Modellauswahl und Hyperparameter-Optimierung: Ermöglicht die einfachere Verwendung von Techniken wie Cross-Validation und Grid Search.
• Wiederverwendbarkeit des Codes: Sie können denselben Workflow einfach auf verschiedene Datensätze anwenden.

Beispielcode: Verwendung von Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.compose import ColumnTransformer
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

# Datensatz laden
iris = load_iris()
X, y = iris.data, iris.target

# Daten in Trainings- und Testsets aufteilen
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Numerische und kategoriale Spalten definieren
numeric_features = [0, 1, 2, 3]
# Da es keine kategorialen Merkmale gibt, ist die Liste leer
categorical_features = []

# Vorverarbeitungsschritte definieren
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

# Vorverarbeitungsschritte mit ColumnTransformer kombinieren
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ])

# Modell definieren
model = LogisticRegression(solver='liblinear', random_state=0)

# Pipeline erstellen
pipeline = Pipeline(steps=[('preprocessor', preprocessor),
                       ('classifier', model)])

# Modell trainieren
pipeline.fit(X_train, y_train)

# Vorhersagen auf Testdaten treffen
y_pred = pipeline.predict(X_test)

# Modellleistung bewerten
from sklearn.metrics import accuracy_score, classification_report
accuracy = accuracy_score(y_test, y_pred)
print(f"Genauigkeit: {accuracy}")
print(classification_report(y_test, y_pred))

Häufig verwendete Datensätze in Scikit-learn

Beispiele aus dem echten Leben und Fallstudien

• Kundensegmentierung: Ein Einzelhandelsunternehmen möchte möglicherweise seine Kunden anhand von Kundendaten (Kaufhistorie, demografische Daten usw.) in verschiedene Segmente einteilen. Clustering-Algorithmen (K-Means, DBSCAN) in Scikit-learn können für diesen Zweck verwendet werden.
• Betrugserkennung: Ein Finanzinstitut möchte möglicherweise betrügerische Aktivitäten erkennen, indem es Kreditkartentransaktionen analysiert. Klassifizierungsalgorithmen (Logistische Regression, Random Forest) in Scikit-learn können für diesen Zweck verwendet werden.
• Medizinische Diagnose: Ein Krankenhaus möchte möglicherweise anhand von Patientendaten (Symptome, Testergebnisse usw.) Krankheiten diagnostizieren. Klassifizierungsalgorithmen (Support Vector Machine, Decision Tree) in Scikit-learn können für diesen Zweck verwendet werden.
• Natural Language Processing: Ein Unternehmen möchte möglicherweise die Qualität seiner Produkte oder Dienstleistungen verbessern, indem es Kundenfeedback analysiert. Textklassifizierungsalgorithmen in Scikit-learn können für diesen Zweck verwendet werden.

Tipps und Tricks zu Scikit-learn

• Achten Sie auf die Datenvorverarbeitung: Die Datenvorverarbeitung kann die Modellleistung erheblich beeinflussen. Achten Sie auf Schritte wie den Umgang mit fehlenden Werten, die Merkmalskalierung und die Kodierung kategorischer Daten.
• Wählen Sie den richtigen Algorithmus: Beachten Sie, dass verschiedene Algorithmen für verschiedene Datensätze und Problemtypen besser geeignet sind. Versuchen Sie, den besten Algorithmus durch Ausprobieren zu finden.
• Optimieren Sie die Hyperparameter: Die Optimierung der Hyperparameter des Modells kann seine Leistung verbessern. Verwenden Sie Techniken wie Grid Search und Randomized Search, um die besten Parameter zu finden.
• Bewerten Sie das Modell: Verwenden Sie geeignete Metriken, um die Leistung des Modells zu bewerten. Für Klassifizierungsprobleme können Sie Metriken wie Genauigkeit, Präzision, Rückruf und F1-Score verwenden, für Regressionsprobleme Metriken wie MSE, RMSE und R².
• Verwenden Sie Pipelines: Pipelines sorgen dafür, dass der Code übersichtlicher, lesbarer und wartungsfreundlicher wird. Verwenden Sie Pipelines, um die Schritte im Machine-Learning-Workflow unter einem einzigen Objekt zu vereinen.
• Lesen Sie die Dokumentation: Die umfassende Dokumentation von Scikit-learn kann Ihnen helfen, Algorithmusdetails und Anwendungsbeispiele zu verstehen.