Kurs
Wie man Modelle für maschinelles Lernen visualisiert: Von der linearen Regression zu neuronalen Netzen
Maschinelles Lernen ist komplex und erfordert viel Mathe.
Als Anfänger wirst du mit Sicherheit Schwierigkeiten haben, das Innenleben der dutzenden verschiedenen Modelle zu lernen, die dir zur Verfügung stehen. Dieses Problem wird auf 11 erhöht, wenn du keinen mathematischen Hintergrund hast. Aber selbst wenn du einen Doktortitel hast, wird es dir schwerfallen, die Modellergebnisse einem Geschäftsmann zu erklären. Sie teilen in der Regel nicht deinen Enthusiasmus für technische Details, aber sie wollen sicher sein, dass deine Modelle dierichtigen Entscheidungen treffen.
Wie kannst du also die Lücke schließen?
Es gibt eine universelle Sprache, die von Technikern und Geschäftsleuten gesprochen wird: Datenvisualisierung. Diagramme sind leicht zu verstehen und machen das Erklären komplexer Themen überschaubarer, unabhängig von deinem Hintergrund.
In diesem Artikel erkläre ich dir die grundlegenden und fortgeschrittenen Konzepte zur Visualisierung von überwachten Machine Learning-Modellen. Wenn du auf der Suche nach guten Materialien zum unüberwachten Lernen bist, ist unser Kurs "Unüberwachtes Lernen mit Python " genau das Richtige für dich.
Nach dem Lesen werden die Begriffe koeffizienten, Residuen, Bedeutung des Merkmals, SHAP, LIME, und Grad-CAM nicht wie eine Fremdsprache klingen wird.
Lass uns reinhauen!
Häufigste Visualisierungsarten für Machine Learning Modelle
Ich beginne mit einem kleinen Theorieteil über die gängigsten Visualisierungsarten für Machine Learning-Modelle. Es soll uns auf die gleiche Stufe bringen.
Wenn du mit diesen bereits vertraut bist, kannst du diesen Abschnitt überspringen.
Bedeutung der Funktion
Wenn du verstehen willst, welche Attribute deines Datensatzes am meisten zu den Vorhersagen eines maschinellen Lernmodells beitragen, ist dies der richtige Ort dafür.
Stell dir das wie beim Backen eines Kuchens vor: Zutaten wie Mehl und Zucker sind unverzichtbar, während andere, wie z.B. Streusel, nicht so viel beitragen. Mit anderen Worten: Du kannst einen Kuchen ohne Streusel haben, aber nicht ohne Mehl und Zucker.
Wenn du ein Merkmal mit einem hohen Wichtigkeitswert entfernst, sinkt die Leistung deines Modells erheblich.
Eine Merkmalswichtigkeitsdarstellung wird oft mit baumbasierten Modellen (Entscheidungsbaum, Random Forest, Gradient Boosting) verbunden. Die tatsächlichen Werte stehen nach dem Training des Modells zur Verfügung und ihre Visualisierung erfordert nur ein paar Zeilen Code.
Leistungskennzahlen für das Modell
Die gebräuchlichsten Metriken zur Bewertung von Machine-Learning-Modellen (z. B. für die Klassifizierung) sind die Konfusionsmatrix, die ROC-Kurve und die PR-Kurve (Precision-Recall).
Die erste zeigt die Anzahl der richtigen Vorhersagen pro Klasse auf einer Diagonale von oben links nach unten rechts. Alles, was außerhalb dieses Bereichs liegt, wird als Fehler betrachtet (entweder falsch positiv oder falsch negativ).
Die zweite zeigt einen Kompromiss zwischen den Wahr-Positiv-Raten und den Falsch-Positiv-Raten für eine Reihe von Klassifizierungsschwellenwerten.
Und die dritte zeigt das Gleichgewicht zwischen korrekten positiven Vorhersagen (Precision) und der Fähigkeit des Modells, alle positiven Fälle zu identifizieren (Recall). Sowohl die ROC- als auch die PR-Kurve funktionieren nur bei binären Klassifizierungsdatensätzen. Bei Mehrklassenproblemen musst du zwei Klassen auf einmal vergleichen.
Natürlich gibt es noch andere Bewertungsmaßstäbe, aber diese drei sind die gängigsten. Sie sind in scikit-learn integriert, einer Bibliothek, die du zum Trainieren von Machine-Learning-Modellen verwendest.
Fehlerdiagramme
Wenn du mit linearen Modellen arbeitest (z. B. lineare Regression), möchtest du normalerweise die Residuen.
Diese stellen die Differenz zwischen den tatsächlichen und den vorhergesagten Wertendar . Wenn du diese aufzeichnest, solltest du auf sichtbare Muster achten. Im Idealfall sollten sie zufällig um den Wert Null herum gestreut sein (Normalverteilung). Wenn das nicht der Fall ist, macht das Modell voreingenommene Vorhersagen, und du hast noch einiges zu tun.
Alles in allem ist es eine kinderleichte Darstellung, die dir viel über dein Regressionsmodell verraten kann.
Erklärungen zur Vorhersage
Modelle für maschinelles Lernen werden oft als Blackboxen behandelt, aber das müssen sie nicht sein.
Fortgeschrittene Interpretationstechniken wie SHAP (SHapely Additive exPlanations) und LIME (Local Interpretable Model-agnostic Explanations) helfen dabei, die Frage zu beantworten, wie das Modell zu einer bestimmten Entscheidung gekommen ist.
SHAP weist jedem Merkmal den Wichtigkeitswert für eine individuelle Vorhersage zu (z. B.: Diese Person ist Raucher, also wird ihre Versicherungssumme höher sein), während LIME ein einfacheres Modell erstellt, das die Vorhersage eines komplexen Modells für einen bestimmten Fall annähert.
Wie sie genau funktionieren, zeige ich dir später im Artikel.
Doch bevor wir uns den guten Dingen widmen, wollen wir ein paar Python-Bibliotheken besprechen, die du brauchst, um weiterzukommen.
Werde ein ML-Wissenschaftler
Python-Bibliotheken zur Visualisierung von Machine Learning-Modellen
In diesem kurzen Abschnitt zeige ich dir, wie du systemweite Abhängigkeiten und Python-Bibliotheken installierst, die für die Visualisierung von Machine Learning-Modellen benötigt werden.
Graphviz
Die einzige systemweite Abhängigkeit, die du brauchst, um mitzumachen, ist Graphviz. Du wirst ihn später verwenden, um einen Entscheidungsbaum zu visualisieren, und der Code wird ohne Graphviz nicht funktionieren.
Es ist eine Open-Source-Software, mit der du Diagramme, abstrakte Graphen und Netzwerke erstellen kannst. Du wirst es nicht direkt verwenden, sondern nur über scikit-Learn.
scikit-learn
Diese Python-Bibliothek wird häufig für Aufgaben des maschinellen Lernens in Python verwendet.
In diesem Artikel lernst du, wie du damit Modelle für maschinelles Lernen trainierst, Datensätze aufteilst, numerische Merkmale skalierst und die Modellleistung visualisierst. Es ist ein Muss, also installiere es mit dem folgenden Befehl (abhängig von deiner Python-Umgebung):
pip install scikit-learn
conda install scikit-learn
Wenn du ganz neu in scikit-learn bist, empfehlen wir dir unseren beliebten Kurs zum überwachten maschinellen Lernen.
SHAP (SHapely Additive exPlanations)
Die SHAP-Bibliothek in Python ist ein beliebtes Werkzeug, um die Vorhersagen von Machine-Learning-Modellen zu erklären. Es nutzt spieltheoretische Konzepte (z.B. Shapely-Werte), um den Beitrag jedes Attributs zur Vorhersage des Modells zu messen.
Noch besser: Sie ist vollgepackt mit nützlichen Visualisierungen, die dir helfen, die Funktionsweise deiner Modelle zu verstehen.
Installiere sie mit dem folgenden Befehl:
pip install shap
conda install -c conda-forge shap
LIME (Local Interpretable Model-agnostic Explanations)
Diese Python-Bibliothek wird von vielen genutzt, wenn es darum geht, eine einzelne Modellvorhersage zu erklären. Es funktioniert anders als SHAP. Es approximiert das ursprüngliche Modell lokal mit einem interpretierbaren, einfacheren Modell. Dann wird der Beitrag jedes Merkmals des Datensatzes zur Vorhersage angezeigt.
Wie LIME funktioniert, erfährst du in einer Minute, aber zuerst musst du ihn installieren:
pip install lime
conda install conda-forge::lime
TensorBoard
Wenn du neuronale Netzwerkmodelle mit TensorFlow entwickelst, dann ist TensorBoard ein Muss für dich.
Es ist ein Visualisierungstool, mit dem du Experimente zum maschinellen Lernen verfolgen und Trainingskennzahlen (z. B. Verlust und Genauigkeit) überwachen kannst. Es visualisiert und aktualisiert Modellgrafiken für dich in Echtzeit und zeigt, wie sich die Modellparameter während des Trainings verändern.
TensorBoard kann auch mit anderen Deep-Learning-Frameworks wie PyTorch verwendet werden, aber in diesem Artikel werde ich mich auf TensorFlow konzentrieren.
Installiere sie, indem du den folgenden Befehl ausführst:
pip install tensorboard
conda install -c conda-forge tensorboard
Datensatz und Datenvorverarbeitung
Der letzte Schritt in dieser Vorbereitungsphase besteht darin, sich um die Daten zu kümmern.
Ich werde heute zwei Datensätze verwenden: MBA-Zulassungen für die Klassifizierung und Insurance für die Regression. Beide sind kostenlos und stehen auf Kaggle zum Download bereit.
Um zu beginnen, importiere diese Python-Bibliotheken:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
Klassifizierungsdatensatz
Was den Klassifizierungsdatensatz angeht, so habe ich nur minimale Vorverarbeitungen an den Daten vorgenommen. Es läuft auf Folgendes hinaus:
- Weglassen der Sequenzspalte
- Fehlende Werte auffüllen
- Spalten mit zwei Kategorien in Boolesche Werte umwandeln
- Erstellen von Dummy-Spalten für hochkardinale Merkmale
Es handelt sich keineswegs um eine umfassende Pipeline zur Datenvorverarbeitung. Wenn du die Zeit hast, kannst du sie gerne verbessern.
Kopiere diese Funktion trotzdem, um den Klassifizierungsdatensatz in Ordnung zu bringen:
def load_classification_dataset() -> pd.DataFrame:
# https://www.kaggle.com/datasets/taweilo/mba-admission-dataset?resource=download
df = pd.read_csv("MBA.csv")
# Just an arbitrary ID
df = df.drop(["application_id"], axis=1)
# Fill unknown
df["race"] = df["race"].fillna("Unknown")
# Assume these are denied
df["admission"] = df["admission"].fillna("Deny")
# Convert boolean cols to 0/1
df["gender"] = df["gender"].replace({"Male": 0, "Female": 1})
df["international"] = df["international"].replace({False: 0, True: 1})
# Create dummy columns for categorical features
cols_for_dummy = ["major", "race", "work_industry"]
for col in cols_for_dummy:
dummies = pd.get_dummies(df[col], prefix=col)
df = pd.concat([df, dummies], axis=1)
# To drop
cols_to_drop = ["major", "race", "work_industry", "major_Humanities", "race_Unknown", "work_industry_Other"]
df = df.drop(cols_to_drop, axis=1)
return df
load_classification_dataset().sample(5)
Ein Beispiel für den geänderten MBA-Datensatz. Bild vom Autor.
Das Gleiche mache ich jetzt mit dem Regressionsdatensatz.
Regressionsdatensatz
Der gewählte Regressionsdatensatz enthält einen Versicherungsbetrag ($) als kontinuierliches Merkmal, das das maschinelle Lernmodell auf der Grundlage anderer Attribute vorherzusagen versucht.
Die Datenvorverarbeitung, die ich vorgenommen habe, ist wieder einmal ziemlich minimal. Es läuft auf Folgendes hinaus:
- Skalierung numerischer Merkmale (Mittelwert von Null, Standardabweichung von Eins)
- Spalten mit zwei Kategorien in binäre Attribute umwandeln
- Erstellen von Dummy-Spalten für hochkardinale Merkmale
Wenn du Zeit hast, kannst du gerne weitere Schritte in die Pipeline einbauen.
Kopiere die folgende Funktion, um den Versicherungsdatensatz zu laden und vorzuverarbeiten:
def load_regression_dataset() -> pd.DataFrame:
# https://www.kaggle.com/datasets/mirichoi0218/insurance
df = pd.read_csv("MedicalCostPersonal.csv")
# Scale numerical features
cols_to_scale = ["age", "bmi", "children"]
scaler = StandardScaler()
df[cols_to_scale] = scaler.fit_transform(df[cols_to_scale])
# Binary features
df["sex"] = df["sex"].replace({"male": 0, "female": 1})
df["smoker"] = df["smoker"].replace({"no": 0, "yes": 1})
# Dummies
dummies_region = pd.get_dummies(df["region"], prefix="region", drop_first=True)
df = pd.concat([df, dummies_region], axis=1)
df = df.drop("region", axis=1)
return df
load_regression_dataset().sample(5)
Ein Beispiel für den geänderten Versicherungsdatensatz. Bild vom Autor.
Und das war's!
Im folgenden Abschnitt zeige ich dir, wie du anfängst, Modelle für maschinelles Lernen zu visualisieren.
Baum-basierte Modelle visualisieren
Baumbasierte Modelle werden oft für die Klassifizierung verwendet, aber die meisten von ihnen können auch Regressionsaufgaben bewältigen.
In diesem Abschnitt zeige ich dir, wie du einen Entscheidungsbaum visualisierst, die Bedeutung der Merkmale aus einem Random Forest Modell und Erklärungen zur Vorhersage mit SHAP und LIME.
Denke daran, dass Entscheidungsbaum- und Random-Forest-Modelle schwer zu verstehen sein können. Wir haben einen kompletten Kurs, der die Grundlagenvon baumbasierten maschinellen Lernmodellen in Python abdeckt.
Um loszulegen, lädst du den Klassifizierungsdatensatz und teilst ihn in Trainings- und Testteilmengen auf:
df = load_classification_dataset()
X = df.drop("admission", axis=1)
y = df["admission"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
Als Nächstes wollen wir einen Entscheidungsbaum visualisieren!
Entscheidungsbäume
Stell dir einen Entscheidungsbaum als eine Reihe von verschachtelten if
Anweisungen vor, in denen die Bedingungen durch ein maschinelles Lernmodell bestimmt werden.
Die Geschichte hat noch mehr zu bieten, aber anhand dieser Analogie kannst du sehen, dass die Visualisierung von Entscheidungen ein einfacher Prozess sein sollte. Und das ist es auch: Die Funktion plot_tree()
von sklearn
übernimmt den größten Teil der schweren Arbeit.
Beginne mit dem Training eines Entscheidungsbaummodells. Der Parameter max_depth
ist optional und dient nur zur Veranschaulichung. Ohne sie wird der Baum zu tief und du verlierst dich in der schieren Menge der Entscheidungen, die das Modell trifft, vor allem bei größeren Datensätzen.
Das folgende Snippet trainiert das Entscheidungsbaum-Klassifizierungsmodell auf der Trainingsuntermenge:
from sklearn import tree
decision_tree = tree.DecisionTreeClassifier(random_state=42, max_depth=4)
decision_tree.fit(X_train, y_train)
Und zur Visualisierung kopierst du einfach den folgenden Ausschnitt. Die optionalen Parameter filled
und feature_names
machen den Baum einfacher zu interpretieren:
plt.figure(figsize=(12,8))
tree.plot_tree(decision_tree, filled=True, feature_names=X.columns, class_names=y.unique())
plt.title("Decision Tree Visualization", size=20, loc="left", y=1.04, weight="bold")
plt.show()
Vierstufiger tiefer Entscheidungsbaum. Bild vom Autor.
Beachte, dass die Entscheidungen, die das Modell trifft, nichts bedeuten, wenn das Modell nicht genau ist. Später im Artikel zeige ich dir, wie du die Genauigkeit einschätzen kannst.
Zufällige Wälder und Bedeutung von Merkmalen
Erinnerst du dich an den Vergleich mit dem Kuchen von vorhin? Es ist an der Zeit, sie in die Praxis umzusetzen.
Jedes Mal, wenn du ein Baummodell mit sklearn
trainierst, erhältst du Zugriff auf die Eigenschaft feature_importances_
. Verbinde das mit den Namen der Merkmale und du hast alle Daten, die du brauchst, um herauszufinden, welche Merkmale am meisten zur Vorhersage beitragen.
Lass es uns in Aktion sehen! Trainiere zunächst einen Random-Forest-Klassifikator auf der Trainingsuntermenge:
from sklearn.ensemble import RandomForestClassifier
random_forest = RandomForestClassifier(n_estimators=25, random_state=42)
random_forest.fit(X_train, y_train)
Die Visualisierung läuft nun darauf hinaus das Extrahieren und Sortieren von Merkmalsbedeutungen und die Indizes durch die Namen der Merkmale zu ersetzen:
importances = random_forest.feature_importances_
indices = np.argsort(importances)[::-1]
plt.figure(figsize=(10,6))
bars = plt.bar(range(X.shape[1]), importances[indices], edgecolor="#008031", linewidth=1)
for bar in bars:
height = bar.get_height()
plt.text(bar.get_x() + bar.get_width() / 2, height, f"{height:.2f}", ha="center", va="bottom", size=8)
plt.title("Feature Importances", size=20, loc="left", y=1.04, weight="bold")
plt.ylabel("Importance")
plt.xticks(range(X.shape[1]), np.array(X.columns)[indices], rotation=90, size=12)
plt.show()
Random Forest Feature Importance Plot. Bild vom Autor.
Es sieht so aus, als würden ein Notendurchschnitt von 4,0 und ein GMAT-Ergebnis am meisten dazu beitragen, zu einem MBA-Programm zugelassen zu werden. Danach folgt die Berufserfahrung, die eine Voraussetzung für das MBA-Studium ist. Was die Person studiert hat und in welcher Branche sie arbeitet, ist weit weniger wichtig.
Baum SHAP
Die Bedeutung von Merkmalen vermittelt ein Gesamtbild, aber was ist, wenn du Modelle für maschinelles Lernen auf der Ebene einzelner Vorhersagen visualisieren willst? einzelnen Vorhersage?
Hier kommen SHAP und LIME ins Spiel. Ich werde zuerst über SHAP sprechen. Du weißt schon, was es ist, also überspringe ich die Theorie.
Ich werde ein Gradient-Boosting-Modell auf unseren Regressionsdatensatz anwenden, um zu sehen, welchen Einfluss einzelne Merkmale auf die Versicherungskosten haben. Das folgende Snippet zeigt dir, wie du das Modell anpasst und die SHAP-Werte aus einem shap.Explainer()
Modell berechnest:
import shap
from xgboost import XGBRegressor
df = load_regression_dataset()
# No need for train-test splits
X = df.drop("charges", axis=1)
y = df["charges"]
model = XGBRegressor().fit(X, y)
# Shap explainer
explainer = shap.Explainer(model)
shap_values = explainer(X)
Mit SHAP gibt es eine Reihe von Plots, die du machen kannst.
Ich beginne mit waterfall()
und untersuche die SHAP-Werte für die erste Vorhersage:
shap.plots.waterfall(shap_values[0])
Erste Erklärungen zur Vorhersage. Bild vom Autor.
In diesem speziellen Fall erhöht das Rauchen die Versicherungskosten drastisch. Die Merkmale, die sich am stärksten auf die Senkung der Kosten auswirken, sind der BMI (in Verbindung mit dem Gewicht) und das Alter. Andere Funktionen haben nur minimale oder gar keine Auswirkungen.
Du kannst die obige Tabelle in einem kompakteren Format darstellen kompakteren Format darstellen:
shap.plots.force(shap_values[0])
Prägnante Erklärungen zur ersten Vorhersage. Bild vom Autor.
Die Information ist immer noch dieselbe: Rote Merkmale erhöhen die Gebühren und blaue Merkmale verringern sie. Der Punkt, an dem sie sich treffen, zeigt die Versicherungskosten für einen einzelnen Fall an.
Der Beeswarm Plot zeigt dir, welche Merkmale am wichtigsten sind, indem er die SHAP-Werte jedes Merkmals für jede Probe aufzeichnet. Die Merkmale werden nach der Summe der SHAP-Werte über alle Stichproben sortiert. Die Farbe steht für den Wert des Merkmals (rot bedeutet hoch und blau niedrig):
shap.plots.beeswarm(shap_values)
Zusammenfassende Wirkung aller Merkmale. Bild vom Autor.
Wenn du ein junger Nichtraucher mit einem angemessenen BMI bist, senkt das die Versicherungskosten.
Die letzte SHAP-Visualisierung, die ich zeigen möchte, ist das Balkendiagrammdes mittleren absoluten Werts . Sie berechnet den mittleren absoluten Wert aller SHAP-Werte für jedes Merkmal:
shap.plots.bar(shap_values)
Der mittlere absolute Wert aller SHAP-Werte für alle Merkmale. Bild vom Autor.
Mit anderen Worten: Es ist eine schicke Art, die globale Bedeutung von Merkmalen zu berechnen - die Grafik ist nicht an eine einzelne Vorhersage gebunden.
Und das war's dann für SHAP. Als Nächstes werde ich den Fokus auf LIME legen.
LIME
Genau wie bei SHAP dreht sich bei LIME alles um interpretierbares maschinelles Lernen.
Es hat zwar nicht so viele Visualisierungsarten in seinem Werkzeuggürtel, aber es macht eine Sache gut - zumindest bei tabellarischen Datensätzen.
Zu Demonstrationszwecken lade ich den Klassifizierungsdatensatz und wandle ihn in eine binäre Klassifizierungsaufgabe um, indem ich die Einträge auf der Warteliste durch abgelehnte Einträge ersetze. So kannst du die Leistung von LIME leichter verstehen:
from lime import lime_tabular
df = load_classification_dataset()
# Convert to binary
df["admission"] = df["admission"].replace({"Waitlist": "Deny"})
X = df.drop("admission", axis=1)
y = df["admission"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
X_train.shape, y_test.shape
random_forest = RandomForestClassifier(n_estimators=25, random_state=42)
random_forest.fit(X_train, y_train)
Die Klasse LimeTabularExplainer()
erhält nun Trainingsdaten, Spaltennamen, Namen der Kategorien in der Zielvariable und den Modus für maschinelles Lernen (Klassifizierung oder Regression):
explainer = lime_tabular.LimeTabularExplainer(
training_data=np.array(X_train),
feature_names=X_train.columns,
class_names=["Admit", "Deny"],
mode="classification"
)
Sobald dies geschehen ist, kannst du die Methode explain_instance()
aufrufen, um eine einzelne Vorhersage zu interpretieren basierend auf den Wahrscheinlichkeiten der Klassenvorhersage zu interpretieren:
exp = explainer.explain_instance(
data_row=X_test.iloc[0],
predict_fn=random_forest.predict_proba
)
exp.show_in_notebook(show_table=True)
LIME Erklärungen (1). Bild vom Autor.
Das LIME-Modell ist zu 96% sicher, dass diese MBA-Zulassung verweigert wird. Merkmale wie gmat
und gender
hatten den größten Einfluss auf die Entscheidung.
Machen wir nun dasselbe für einen Fall, der zum MBA-Programm zugelassen wurde:
exp = explainer.explain_instance(
data_row=X_test.iloc[234],
predict_fn=random_forest.predict_proba
)
exp.show_in_notebook(show_table=True)
LIME Erklärungen (2). Bild vom Autor.
Die gleichen Merkmale hatten nun den gegenteiligen Effekt! Diese Person hatte eine hohe gmat
Punktzahl, die am meisten dazu beiträgt, zum MBA-Programm zugelassen zu werden.
Und das war's dann mit den Baummodellen! Als Nächstes lernst du, wie du lineare Modelle für Regressionsaufgaben visualisieren kannst.
Lineare Modelle visualisieren
Wenn du gerade erst mit der prädiktiven Modellierung anfängst, geht es nicht einfacher als mit der linearen Regression. Es ist ein einfaches Modell, das leicht zu verstehen ist und gut funktioniert, wenn die Beziehungen in deinem Datensatz linear sind.
Es gibt noch andere lineare Modelle, aber in diesem Abschnitt werde ich nur mit der linearen Regression arbeiten.
Beginne damit, den Regressionsdatensatz zu laden, ihn in eine Trainings- und eine Testgruppe aufzuteilen und ein lineares Regressionsmodell an den Trainingsteil anzupassen:
from sklearn.linear_model import LinearRegression
df = load_regression_dataset()
X = df.drop("charges", axis=1)
y = df["charges"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
model = LinearRegression().fit(X_train, y_train)
Die erste Visualisierungsart, die ich untersuchen werde, sind die Modellkoeffizienten.
Koeffizienten des linearen Modells
Im Klartext bedeutet das, dass ein lineares Regressionsmodell auf eine einzige Gleichung hinausläuft. Vielleicht erinnerst du dich an y = mx+b
aus der Schulzeit - die Idee ist die gleiche.
Die Regressionsgleichung lässt sich auf y = w0 + w1_x1 + w2_x2 + … + wn_xn
erweitern, um mehrere Parameter zu berücksichtigen. Das Ziel des Modells ist es, die beste Schätzung der Gewichte (w
) zu finden, wenn die Menge der Eingangsmerkmale (x
) gegeben ist.
Warum ist das also wichtig?
Da du auf die Koeffizienten (Gewichte) zugreifen kannst, nachdem das Modell trainiert wurde, und ihren Beitrag analysieren kannst, haben Merkmale mit einem größeren Koeffizienten einen höheren Beitrag zur Vorhersage der Zielvariablen.
Du kannst die Koeffizienten erhalten, indem du den Parameter coef_
eines trainierten Modells aufrufst.
Das folgende Snippet ermittelt die Koeffizienten und stellt sie in einem horizontalen Balkendiagramm dar:
features = X_train.columns
coefficients = model.coef_
plt.figure(figsize=(10, 4))
bars = plt.barh(y=features, width=coefficients, edgecolor="#008031", linewidth=1)
for bar in bars:
width = bar.get_width()
plt.text(width + 1, bar.get_y() + bar.get_height()/2, f"{width:.2f}",
va="center", ha="left")
plt.xlabel("Coefficient value")
plt.title("Linear Regression Model Coefficients", y=1.05)
plt.show()
Koeffizienten des linearen Regressionsmodells. Bild vom Autor.
Die Merkmale smoker
, BMI
und age
tragen am meisten zu den Versicherungskosten bei - wenn sie steigen, steigt auch der Betrag. Es gibt auch ein paar negative Koeffizienten, die den Gesamtbetrag verringern.
Residuale Plots
Die andere gängige Art der Regressionsdarstellung ist der Residual Plot. Im Klartext: Du erstellst ein Streudiagramm mit vorhergesagten Werten auf der X-Achse und Residuen (wahre Werte - vorhergesagte Werte) auf der Y-Achse.
Im Idealfall sollten in den Residuen keine Muster zu sehen sein und sie sollten um 0 herum zentriert sein. Mit anderen Worten: Sie sollten normal verteilt sein.
Verwende dieses Codeschnipsel, um die Residuen eines linearen Regressionsmodells für den Versicherungsdatensatz zu visualisieren:
y_pred = model.predict(X_test)
residuals = y_test - y_pred
plt.figure(figsize=(10, 6))
plt.scatter(y_pred, residuals, color="#03EF62", alpha=0.6, edgecolors="#008031")
plt.axhline(0, color="red", linestyle="--")
plt.xlabel("Predicted Values")
plt.ylabel("Residuals")
plt.title("Residuals vs Predicted Values", y=1.05)
plt.grid(True)
plt.show()
Residuen des linearen Regressionsmodells. Bild vom Autor.
Es ist nicht der beste Restplot, den ich je gesehen habe. Ästhetisch sieht es gut aus, aber die Werte sind total durcheinander. Wenn du ein/e Praktiker/in für maschinelles Lernen bist und ein ähnliches Residualdiagramm erhältst, hast du noch eine Menge Arbeit vor dir.
Als Nächstes zeige ich dir 3 Möglichkeiten, neuronale Netzwerkmodelle zu visualisieren.
Neuronale Netzwerkmodelle visualisieren
Wenn es einen Bereich des maschinellen Lernens gibt, in dem Visualisierung und Interpretation am wichtigsten sind, dann sind es die neuronalen Netze.
Diese sind selbst auf der grundlegendsten Ebene kompliziert zu begreifen. Es gibt verschiedene Ebenentypen, Aktivierungsfunktionen und Backpropagation - um nur ein paar zu nennen. Aus diesem Grund werden neuronale Netze oft als Synonym für Blackbox-Modelle verwendet.
Das muss nicht so sein.
In diesem Abschnitt zeige ich dir drei Möglichkeiten, neuronale Netze zu visualisieren: Architekturdiagramme, Echtzeit-Trainingsmetriken und Grad-CAM.
Meine Bibliothek der Wahl ist TensorFlow. Wenn du noch nie etwas davon gehört hast, findest du untereinen Kurs "TensorFlow für Anfänger" , der dir den Einstieg erleichtern wird.
Architektur des neuronalen Netzes
Wenn du die Architektur deines neuronalen Netzmodells visualisierst, wird dir eine Sache entmystifiziert - Formen.
Mit anderen Worten: Du wirst sehen, wie sich die Größe der zugrunde liegenden Matrix verändert, wenn du dich durch die Ebenen bewegst. Für Neulinge kann das ein schwieriges Thema sein, deshalb ist jede Visualisierung mehr als willkommen.
Zur Demonstration verwende ich TensorFlow, um ein grundlegendes neuronales Netzwerkmodell für die Klassifizierung von handgeschriebenen Ziffern zu erstellen. Dann verwende ich die Funktion plot_model()
, um das Bild der Modellarchitektur in einer lokalen Datei zu speichern.
Sieh es dir selbst an:
from tensorflow.keras import layers, models
from tensorflow.keras.utils import plot_model
model = models.Sequential()
model.add(layers.Input(shape=(28, 28, 1)))
model.add(layers.Conv2D(32, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation="relu"))
model.add(layers.Dense(10, activation="softmax"))
plot_model(model, to_file="model_architecture.png", show_shapes=True, show_layer_names=True)
Architektur des neuronalen Netzes. Bild vom Autor.
Diese Art der Visualisierung ist zwar hilfreich, aber sie bringt dich nur bedingt weiter.
Du weißt, wie sich die Daten im Laufe der Zeit verändern, aber du hast keine Vorstellung davon, wie ein neuronales Netzwerkmodell zu seinen Schlussfolgerungen kommt. Das werde ich als Nächstes behandeln.
Grad-CAM
Grad-CAM, oder Gradient Class Activation Mapping ist eine beliebte Technik zur Visualisierung von Modellen für faltige neuronale Netze.
Genauer gesagt, hilft es dir zu verstehen , welche Teile eines Eingangsbildes am meisten zu den Vorhersagen des Modells beitragen. Stell dir vor, dass es sich dabei um die Darstellung der Wichtigkeit eines Entscheidungsbaums handelt, nur eben auf 11.
Es ist eine fortschrittliche Interpretationsmethode, die für alle Faltungsmodelle unabhängig von ihrer Architektur funktioniert und dir hilft zu verstehen, warum ein neuronales Netzwerkmodell eine bestimmte Vorhersage trifft.
Aber hier ist das Problem - es ist nicht trivial in Python zu implementieren. Hier ist ein grober Überblick über den Algorithmus:
- Vorhersage: Erhalte eine Vorhersage von einem Faltungsmodell.
- Gradienten der Ausgabe: Für die Ausgabe einer bestimmten Klasse berechnet der Algorithmus den Gradienten dieser Klassenbewertung in Bezug auf die Feature Maps in der letzten Faltungsschicht. So erfährst du, wie viel jedes Neuron in den Feature-Maps zur endgültigen Vorhersage beigetragen hat.
- Gewichtete Merkmalskarten: Die Gradienten werden dann gemittelt, um Wichtigkeitsgewichte zu berechnen, die dann auf die entsprechenden Merkmalskarten angewendet werden. Mit anderen Worten: Dieser Schritt hebt die wichtigen Regionen des Bildes hervor, die zur Vorhersage geführt haben.
- Heatmap: Die gewichteten Merkmalskarten werden kombiniert, um eine Heatmap zu erstellen, die dir die Regionen des Bildes zeigt, die den größten Einfluss auf die Vorhersage hatten.
Das ist ein ziemlich komplizierter Prozess, und um die Sache zu vereinfachen, verwende ich ein vortrainiertes ResNet50
Modell, das bereits 1000 verschiedene Bildtypen klassifizieren kann.
Aber zuerst lädst du die notwendigen Bibliotheken und das Bild, für das du eine Grad-CAM anzeigen möchtest. Ich verwende ein Bild von einem Hund:
import cv2
import tensorflow as tf
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras.preprocessing.image import load_img
image = np.array(load_img("dog.jpg", target_size=(224, 224, 3)))
plt.grid(False)
plt.imshow(image)
Beispielbild eines Hundes. Bild vom Autor.
Jetzt beginnt der spaßige Teil. Im folgenden Codeschnipsel implementiere ich den oben beschriebenen vierstufigen Prozess. Zum besseren Verständnis findest du Kommentare über jeder Codezeile:
# Load the pre-trained ResNet50 model
model = ResNet50()
# Extract the output of the last convolutional layer
last_conv_layer = model.get_layer("conv5_block3_out")
# Create a model that outputs the last convolutional layer’s activations
last_conv_layer_model = tf.keras.Model(model.inputs, last_conv_layer.output)
# Prepare the classifier model using the layers after the last convolutional layer
classifier_input = tf.keras.Input(shape=last_conv_layer.output.shape[1:])
x = classifier_input
for layer_name in ["avg_pool", "predictions"]:
# Reuse the pooling and prediction layers from the ResNet50 model
x = model.get_layer(layer_name)(x)
# Create a new model that takes in the last conv layer output and returns predictions
classifier_model = tf.keras.Model(classifier_input, x)
# Use a GradientTape to record operations for automatic differentiation
with tf.GradientTape() as tape:
# Prepare the input image and get the activations from the last conv layer
inputs = image[np.newaxis, ...]
last_conv_layer_output = last_conv_layer_model(inputs)
tape.watch(last_conv_layer_output) # Watch the conv layer output
# Get predictions from the classifier model
preds = classifier_model(last_conv_layer_output)
# Get the index of the highest predicted class
top_pred_index = tf.argmax(preds[0])
# Focus on the prediction of the top class
top_class_channel = preds[:, top_pred_index]
# Compute the gradient of the top predicted class with respect to the conv layer output
grads = tape.gradient(top_class_channel, last_conv_layer_output)
# Average the gradients over the width and height dimensions
pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
# Multiply each channel in the conv layer output by its corresponding gradient
last_conv_layer_output = last_conv_layer_output.numpy()[0]
pooled_grads = pooled_grads.numpy()
for i in range(pooled_grads.shape[-1]):
last_conv_layer_output[:, :, i] *= pooled_grads[I]
# Compute the Grad-CAM by averaging the channels and apply a ReLU activation
gradcam = np.mean(last_conv_layer_output, axis=-1)
# Normalize the Grad-CAM to be between 0 and 1
gradcam = np.clip(gradcam, 0, np.max(gradcam)) / np.max(gradcam)
# Resize the Grad-CAM heatmap to the size of the original image (224x224)
gradcam = cv2.resize(gradcam, (224, 224))
Das war zwar viel, aber jetzt kannst du endlich die Heatmap zeichnen, die der Grad-CAM-Algorithmus erzeugt:
plt.grid(False)
plt.imshow(gradcam)
Grad-CAM Heatmap. Bild vom Autor.
Hellere Punkte zeigen Bereiche an, in denen die Aktivierung am höchsten war, aber die Heatmap allein sagt dir nicht viel.
Es ist viel besser, wenn du es über das Originalbild legst und die Deckkraft etwas reduzierst:
plt.grid(False)
plt.imshow(image)
plt.imshow(gradcam, alpha=0.5)
Hundebild mit einem Grad-CAM-Overlay. Bild vom Autor.
Für die Interpretation trägt vor allem das Gesicht dazu bei, dass dieses Bild als "Golden Retriever" eingestuft wird, was auch Sinn macht.
Mit Grad-CAM kannst du sicherstellen, dass dein Modell die richtigenVorhersagen macht . In diesem Fall stell dir vor, dass die Heatmap etwas anderes, wie zum Beispiel den Stuhl im Hintergrund, als den wichtigsten Faktor anzeigt. Du würdest diesem Modell nicht trauen, oder?
Echtzeit-Visualisierungen der Modellschulung
Das Training eines neuronalen Netzwerks kann sehr lange dauern. Das Gute daran ist, dass du nicht warten musst, bis das Training abgeschlossen ist, um einen Einblick in die Leistung des Modells zu bekommen. Bibliotheken wie TensorBoard können dir das in Echtzeit zeigen.
TensorBoard wird mit TensorFlowso dass du nichts installieren musst, um mitzumachen.
Zu Demonstrationszwecken trainiere ich ein einfaches Ziffernklassifizierungsmodell für 25 Epochen. Der wichtige Teil ist der Rückruf -dort gibst du den Pfad und das Format für die Trainingsprotokolle an, die TensorBoard in einer Minute verwenden wird.
Dies ist der Code, den du brauchst, um das Modell zu trainieren und die Trainingsprotokolle zu speichern:
import tensorflow as tf
from tensorflow.keras import layers, models
from datetime import datetime
# Load MNIST dataset
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Normalize pixel values between 0 and 1
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension (for the Convolutional layer)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
# Build a simple CNN model
model = models.Sequential([
layers.Conv2D(32, kernel_size=(3, 3), activation="relu", input_shape=(28, 28, 1)),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dense(128, activation="relu"),
layers.Dense(10, activation="softmax")
])
# Compile the model
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"]
)
# Set up TensorBoard callback
log_dir = "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
# Train the model with TensorBoard monitoring
model.fit(
x_train,
y_train,
epochs=25,
validation_data=(x_test, y_test),
callbacks=[tensorboard_callback]
)
Prozess der Modellbildung. Bild vom Autor.
Während das Modell trainiert, starte TensorBoard vom Terminal aus und gib einen Pfad zum Ordner mit den Trainingsprotokollen an:
tensorboard --logdir=logs/fit
TensorBoard läuft standardmäßig auf Port 6006:
TensorBoard Metriken (1). Bild vom Autor.
Das Bild oben zeigt dir das Bias-Histogramm und die Genauigkeit pro Epoche, sowohl für die Trainings- als auch für die Validierungsmenge. Du kannst sehen, dass die Genauigkeit bei beiden sehr hoch ist, fast 100 % - nur die Skala der Y-Achse ist zu klein.
Andere Registerkarten befassen sich mit spezifischeren Metriken und ermöglichen es dir, bestimmte Dinge zu optimieren, wie du unten sehen kannst:
TensorBoard-Metriken (2). Bild vom Autor.
Zusammenfassend lässt sich sagen, dass TensorBoard ein ordentliches Werkzeug zur Visualisierung der Modellleistung ist und dir helfen kann, die Leistung zu analysieren, während das Modell trainiert wird.
Visualisiere die Leistungsmetriken des Modells
In diesem letzten Teil möchte ich einen Schritt zurückgehen und auf allgemeinere Metriken zur Visualisierung der Leistung des Modells eingehen.
Du wirst sehen drei Konfusionsmatrix, ROC-Kurvendiagramm und Precision-Recall-Kurvendiagramm.
Da sie mit Klassifizierungsproblemen verbunden sind, musst du den Klassifizierungs-MBA-Datensatzladen . Um die Sache einfacher zu machen, habe ich es auch in ein binäres Klassifizierungsproblem umgewandelt, indem ich die Einträge auf der Warteliste auf "verweigert" gesetzt habe. Der Rest des Codeschnipsels teilt die Daten in Trainings- und Testteilmengen auf und erstellt zunächst ein Random-Forest-Klassifizierungsmodell:
from sklearn.ensemble import RandomForestClassifier
df = load_classification_dataset()
df["admission"] = df["admission"].replace({"Waitlist": "Deny"})
df["admission"] = df["admission"].replace({"Deny": 0, "Admit": 1})
df.rename(columns={"admission": "is_admitted"}, inplace=True)
X = df.drop("is_admitted", axis=1)
y = df["is_admitted"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
random_forest = RandomForestClassifier(n_estimators=25, random_state=42)
random_forest.fit(X_train, y_train)
Lass uns in die erste Metrik eintauchen - die Konfusionsmatrix.
Verwirrungsmatrix
Eine Konfusionsmatrix zeigt dir, wie gut dein Modell abschneidet. Im Idealfall wären die Werte auf der Diagonale von links oben nach rechts unten die einzigen Elemente, die nicht Null sind, was bedeutet, dass das Modell keine falschen Vorhersagen getroffen hat.
Aber das passiert in der realen Welt nicht oft.
Nutze die folgenden Richtlinien, um eine Konfusionsmatrix (für binäre Klassifizierung) zu interpretieren:
- Element oben links: Echte Negative (TN), d.h. der tatsächliche Wert ist negativ und das Modell hat ihn als negativ vorhergesagt. Der Schüler wird nicht zum MBA-Programm zugelassen und das Modell sagt voraus, dass er nicht zugelassen wurde.
- Element oben rechts: Falsch positive Werte (FP), d.h. der tatsächliche Wert war negativ und das Modell hat ihn als positiv vorhergesagt. Der Schüler wird nicht zum MBA-Programm zugelassen, aber das Modell sagt voraus, dass er zugelassen wurde.
- Unteres linkes Element: Falsch-negative Werte (FN), d.h. der tatsächliche Wert war positiv und das Modell hat ihn als negativ vorhergesagt. Der/die Studierende wird zum MBA-Programm zugelassen, aber das Modell sagt voraus, dass er/sie nicht zugelassen wurde.
- Element unten rechts: True Positives (TP), d.h. der tatsächliche Wert war positiv und das Modell hat ihn als positiv vorhergesagt. Der Student wird zum MBA-Programm zugelassen und das Modell sagt voraus, dass er zugelassen wurde.
Es gibt keine allgemeine Regel dafür, ob du dich mehr um falsch-positive oder falsch-negative Ergebnisse kümmern solltest. Bei MBA-Zulassungen ist der Prior schmerzhafter, da das Modell den zuzulassenden Studenten klassifiziert hat, aber das war in der Realität nicht der Fall. In anderen Fällen, wie z. B. bei der Krebsvorhersage, ist es wichtig, die Anzahl der falsch-negativen Ergebnisse zu minimieren, denn du willst nicht, dass jemand als gesund eingestuft wird, obwohl er Krebs hat.
Hier kommt das Fachwissen ins Spiel.
Wie auch immer, zurück zum Code. Das folgende Snippet berechnet die Konfusionsmatrix unseres Random-Forest-Modells für die Testmenge und verwendet die Klasse ConfusionMatrixDisplay
, um eine Visualisierung zu erstellen:
from sklearn.metrics import confusion_matrix
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
preds = random_forest.predict(X_test)
cm = confusion_matrix(y_true=y_test, y_pred=preds, labels=random_forest.classes_)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=random_forest.classes_)
disp.plot()
plt.grid(False)
plt.title("Confusion Matrix", y=1.04)
plt.show()
Konfusionsmatrix-Plot. Bild vom Autor.
Die Klassen sind nicht ausgeglichen, aber die Zahl der falschen Vorhersagen ist erstaunlich hoch.
Schauen wir mal, was die ROC-Kurve zu sagen hat.
ROC-Kurve
ROC steht für Receiver Operating Characteristics und ist eine Kurve, die die Leistungsbewertung eines binären Klassifikationsmodells anzeigt. Bei der Mehrklassen-Klassifizierung musst du zwei Klassen gleichzeitig vergleichen.
Die ROC-Kurve zeigt einen Kompromiss zwischen der wahr-positiven Rate (TPR, Sensitivität, Recall) und der falsch-positiven Rate (FPR) bei verschiedenen Klassifizierungsschwellenwerten. Die TPR wird auf der Y-Achse gegen die FPR auf der X-Achse aufgetragen. Jeder Punkt steht für einen anderen Schwellenwert für die Klassifizierungsentscheidung (Wahrscheinlichkeitswert, mit dem eine Instanz als positiv oder negativ eingestuft wird).
Die Kurve wird normalerweise gegen eine Diagonale von (0, 0) bis (1, 1) aufgetragen, die einen zufälligen Klassifikator darstellt.
Wenn die Kurve oberhalb der Diagonale liegt, bedeutet das, dass dein Modell besser abschneidet als ein zufälliger Klassifikator. Ein einziger skalarer Wert fasst das zusammen. Sie wird AUC (Area Under the Curve) genannt und reicht von 0 bis 1, wobei ein höherer Wert besser ist und 0,5 zufällig ist.
Kurz gesagt, du willst die Kurve so nah wie möglich an der oberen linken Ecke haben.
Verwende das folgende Snippet, um ROC und AUC zu berechnen und die Kurve darzustellen:
from sklearn.metrics import roc_curve, auc
# Get predicted probabilities for the positive class
y_probs = random_forest.predict_proba(X_test)[:, 1]
fpr, tpr, roc_thresholds = roc_curve(y_test, y_probs)
roc_auc = auc(fpr, tpr)
plt.plot(fpr, tpr, label=f"AUC = {roc_auc:.2f}")
plt.plot([0, 1], [0, 1], color="navy", linestyle="--")
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve", y=1.04)
plt.legend(loc="lower right")
plt.show()
ROC-Kurven-Diagramm. Bild vom Autor.
Für die Interpretation ist das Random-Forest-Modell viel besser als ein zufälliger Klassifikator und hat ein vernünftiges Gleichgewicht zwischen wahren Positiven und falschen Positiven. Es ist immer noch ein gewisses Maß an Fehlklassifizierung vorhanden, und du solltest versuchen, die Kurve nach oben und nach links zu verschieben, indem du die Daten optimierst oder ein anderes maschinelles Lernmodell wählst.
Präzision-Rückruf-Kurve
Diese Kurve ähnelt der ROC-Kurve, zeigt aber den Kompromiss zwischen Präzision und Recall für verschiedene Klassifizierungsschwellenwerte. Sie zeigt die Genauigkeit auf der Y-Achse und die Wiedererkennung auf der X-Achse an und wird in der Regel dem ROC vorgezogen, wenn die Klassen unausgewogen sind.
Das ist auch bei den MBA-Zulassungsdaten der Fall, also klingt eine PR-Kurve nach einer guten Lösung!
Es ist wichtig zu beachten, dass sich die Kurven für die Genauigkeit des Abrufs nur auf die Minderheitenklasse konzentrieren und ein besseres Bild davon vermitteln, wie gut das Modell die wichtigsten Fälle (zugelassene Schüler, entdeckte Krebsfälle usw.) identifiziert.
Verwende das folgende Snippet, um die Precision- und Recall-Werte zu berechnen und sie in einem Diagramm darzustellen:
from sklearn.metrics import precision_recall_curve
# Get predicted probabilities for the positive class
y_probs = random_forest.predict_proba(X_test)[:, 1]
# Precision-Recall curve
precision, recall, pr_thresholds = precision_recall_curve(y_test, y_probs)
pr_auc = auc(recall, precision)
plt.plot(recall, precision, label=f"(AUC = {pr_auc:.2f})")
plt.xlabel("Recall")
plt.ylabel("Precision")
plt.title("Precision-Recall Curve", y=1.04)
plt.legend(loc="lower left")
plt.show()
Kurve für die Genauigkeit und den Abruf. Bild vom Autor.
Zur Interpretation: Das Modell schneidet schlecht ab, wie der AUC-Wert von 0,42 zeigt. Wenn das Modell versucht, die Aufklärungsquote zu erhöhen, opfert es zu viel Präzision, was zu vielen falsch positiven Ergebnissen führt. Kurz gesagt, dieses Modell ist nicht gut für diesen Datensatz geeignet oder der Datensatz selbst ist nicht ausreichend aufbereitet.
Einpacken
Abschließend lässt sich sagen, dass der Bereich des maschinellen Lernens komplex und oft nicht intuitiv ist. Wenn du ein Anfänger bist, wird es dir schwer fallen, die großen Ideen zu verstehen. Wenn du mit einem Geschäftskunden zusammenarbeitest, wird er wahrscheinlich den Fachjargon nicht verstehen.
Datenvisualisierung hilft, die Lücke in beiden Szenarien zu schließen.
Heute hast du all die verschiedenen Diagrammtypen gesehen, die du zur Visualisierung von Regressions- und Klassifizierungsmodellen verwenden kannst, sowie den Entscheidungsprozess von neuronalen Netzen und die Interpretation einzelner Vorhersagen durch SHAP und LIME. Das ist eine Menge, also kannst du dir diesen Artikel ruhig mehrmals ansehen!
Wenn du ganz neu auf dem Gebiet bist, empfehlen wir dir für den Einstieg unseren Kurs "Grundlagen des maschinellen Lernens ". Danach ist ein anwendungsorientierter Kurs mit Python genau das Richtige.
Wenn du schon etwas Erfahrung hast, aber nicht verstehst, wie das Ganze in einem größeren Maßstab funktioniert, empfehlen wir dir, unseren Kurs zum maschinellen Lernen für die Produktion auszuprobieren.
Fähigkeiten im Bereich Machine Learning aufbauen
FAQs
Warum sollte ich meine Machine-Learning-Modelle visualisieren?
Die Modellvisualisierung hilft dabei, die Kluft zwischen deinem technischen Fachwissen und dem Wissen von Geschäftsleuten zu überbrücken; sie verstehen den Fachjargon meist nicht und können von vereinfachten Erklärungen profitieren. Auch wenn du gerade erst mit dem maschinellen Lernen anfängst, kann dir die Modellvisualisierung helfen, die Grundlagen besser zu verstehen.
Ist die Modellvisualisierung zeitaufwändig?
Ganz und gar nicht! Das ist das Prinzip von "write once run anywhere". Du schreibst (oder kopierst meinen) Visualisierungscode und verwendest ihn in all deinen Projekten, ohne oder mit nur minimalen Codeänderungen.
Kann ich die gleiche Visualisierung für Regressions- und Klassifizierungsaufgaben verwenden?
Normalerweise nicht. Regressionsmodelle verwenden andere Bewertungsmaßstäbe (z. B. Koeffizientenplots, Residuenplots) als Klassifikationsmodelle (z. B. Konfusionsmatrix, ROC/PR-Kurve). Einige Kennzahlen, wie z. B. die Genauigkeit, können in beiden Szenarien verwendet werden, aber du musst in der Regel unterschiedliche Bewertungskennzahlen und Visualisierungen verwenden.
Kann ich den Entscheidungsprozess hinter einer einzelnen Vorhersage visualisieren?
Ja, das ist das Ziel des erklärenden maschinellen Lernens. Python-Bibliotheken wie SHAP und LIME übernehmen die meiste Arbeit für dich und geben an, wie viel Einfluss jede Variable bei einer einzelnen Vorhersage hat. Diese Bibliotheken sind ein Muss, wenn du den Entscheidungsprozess verstehen oder einem Geschäftsmann oder einer Geschäftsfrau den Entscheidungsprozess erklären willst.
Kann ich den Entscheidungsprozess eines faltigen neuronalen Netzes visualisieren?
Ja, eine Technik namens Grad-CAM wird verwendet, um eine Heatmap der Entscheidungspunkte des Modells zu erstellen. Du kannst die Heatmap dann über dein Originalbild legen, um zu sehen, welche Bereiche am meisten zum Entscheidungsprozess des Modells beitragen.
Lerne mehr über maschinelles Lernen mit diesen Kursen!
Kurs
Maschinelles Lernen mit baumbasierten Modellen in Python
Kurs