dass lineare Modelle … nun ja, steif sein können. Haben Sie sich jemals ein Streudiagramm angesehen und festgestellt, dass eine gerade Linie einfach nicht ausreicht? Wir waren alle dort.

Daten aus der realen Welt sind immer eine Herausforderung. Meistens hat man das Gefühl, dass die Ausnahme die Regel ist. Die Daten, die Sie in Ihrem Job erhalten, haben nichts mit den wunderschönen linearen Datensätzen zu tun, die wir während unserer jahrelangen Ausbildung an der Akademie verwendet haben.

Sie betrachten beispielsweise etwas wie „Energiebedarf vs. Temperatur“. Es ist keine Linie; es ist eine Kurve. Normalerweise besteht unser erster Instinkt darin, zur polynomialen Regression zu greifen. Aber das ist eine Falle!

Wenn Sie jemals gesehen haben, wie eine Modellkurve an den Rändern Ihres Diagramms wild wird, sind Sie Zeuge des „Runge-Phänomen.„Hochgradige Polynome sind wie ein Kleinkind mit einem Buntstift, da sie zu flexibel sind und keine Disziplin haben.

Deshalb zeige ich Ihnen diese Possibility namens Splines. Sie sind eine nette Lösung: flexibler als eine Linie, aber weitaus disziplinierter als ein Polynom.

Splines sind mathematische Funktionen, die durch Polynome definiert werden und zum Glätten einer Kurve verwendet werden.

Das Drawback mit Polynomen

Stellen Sie sich vor, wir haben einen nichtlinearen Development und wenden ein Polynom an x² oder x³ dazu. Vor Ort sieht es in Ordnung aus, aber wenn wir uns die Ränder Ihrer Daten ansehen, stellt sich heraus, dass die Kurve weit daneben verläuft. Entsprechend Runges Phänomen (2), Bei Polynomen höheren Grades besteht das Drawback, dass ein seltsamer Datenpunkt an einem Ende die gesamte Kurve am anderen Ende aus dem Gleichgewicht bringen kann.

Warum Splines die „genau richtige“ Wahl sind

Splines versuchen nicht, eine riesige Gleichung an alles anzupassen. Stattdessen unterteilen sie Ihre Daten mithilfe sogenannter Punkte in Segmente Knoten. Wir haben einige Vorteile der Verwendung von Knoten.

• Lokale Steuerung: Was in einem Phase passiert, bleibt in diesem Phase. Da diese Blöcke lokal sind, beeinträchtigt ein seltsamer Datenpunkt an einem Ende Ihres Diagramms nicht die Anpassung am anderen Ende.
• Glätte: Sie verwenden „B-Splines“ (Foundation-Splines), um sicherzustellen, dass die Kurve dort, wo sich die Segmente treffen, vollkommen glatt ist.
• Stabilität: Im Gegensatz zu Polynomen geraten sie an den Grenzen nicht ins Wanken.

OK. Genug geredet, jetzt implementieren wir diese Lösung.

Umsetzung mit Scikit-Study

Scikit-Learns SplineTransformer ist hierfür die erste Wahl. Es verwandelt ein einzelnes numerisches Merkmal in mehrere Grundfunktionen mit deren Hilfe ein einfaches lineares Modell dann komplexe, nichtlineare Formen lernen kann.

Lassen Sie uns einige Module importieren.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import SplineTransformer
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV

Als nächstes erstellen wir einige gekrümmte oszillierende Daten.

# 1. Create some 'wiggly' artificial knowledge (e.g., seasonal gross sales)
rng = np.random.RandomState(42)
X = np.type(rng.rand(100, 1) * 10, axis=0)
y = np.sin(X).ravel() + rng.regular(0, 0.1, X.form(0))

# Plot the information
plt.determine(figsize=(12, 5))
plt.scatter(X, y, colour='grey', alpha=0.5, label='Information')
plt.legend()
plt.title("Information")
plt.present()

OK. Jetzt erstellen wir eine Pipeline, die das ausführt SplineTranformer mit den Standardeinstellungen, gefolgt von einer Ridge-Regression.

# 2. Construct a pipeline: Splines + Linear Mannequin
# n_knots=5 (default) creates 4 segments; diploma=3 makes it a cubic spline
mannequin = make_pipeline(
    SplineTransformer(n_knots=5, diploma=3),
    Ridge(alpha=0.1)
    )

Als nächstes werden wir die Anzahl der Knoten für unser Modell anpassen. Wir verwenden GridSearchCV um mehrere Versionen des Modells auszuführen und verschiedene Knotenzahlen zu testen, bis diejenige gefunden wird, die auf unseren Daten am besten abschneidet.

# We tune 'n_knots' to search out the very best tune
param_grid = {'splinetransformer__n_knots': vary(3, 12)}
grid = GridSearchCV(mannequin, param_grid, cv=5)
grid.match(X, y)

print(f"Greatest knot depend: {grid.best_params_('splinetransformer__n_knots')}")

Greatest knot depend: 8

Dann trainieren wir unser Spline-Modell mit dem neu beste Knotenzahl, Vorhersagen und Plotten der Daten. Lassen Sie uns mit dieser kurzen Aufschlüsselung auch verstehen, was wir hier tun SplineTransformer Klassenargumente:

• n_knots: Anzahl der Gelenke in der Kurve. Je mehr Sie haben, desto flexibler wird die Kurve.
• diploma: Dies definiert die „Glätte“ der Segmente. Es bezieht sich auf den Grad des Polynoms, das zwischen Knoten verwendet wird (1 ist eine Linie; 2 ist glatter; 3 ist die Standardeinstellung).
• knots: Das sagt man dem Modell Wo um die Gelenke zu platzieren. Zum Beispiel, uniform unterteilt die Kurve in gleiche Räume, während das Quantil dort mehr Knoten zuweist, wo die Daten dichter sind.
  • Tipp: Verwenden 'quantile' wenn Ihre Daten geclustert sind.
• extrapolation: Teilt dem Modell mit, was es tun soll, wenn es auf Daten trifft draußen die Reichweite, die es während des Trainings gesehen hat.
  • Tipp: verwenden 'periodic' für zyklische Daten wie Kalender oder Uhr.
• include_bias: Ob eine „Bias“-Spalte (eine Spalte mit allen Einsen) eingefügt werden soll. Wenn Sie a verwenden LinearRegression oder Ridge Wenn Sie später in Ihrer Pipeline ein Modell erstellen möchten, verfügen diese Modelle normalerweise über ein eigenes Modell fit_intercept=Truesodass Sie dies oft auf einstellen können False Redundanz zu vermeiden.

# 2. Construct the optimized Spline
mannequin = make_pipeline(
    SplineTransformer(n_knots=8,
                      diploma=3,
                      knots= 'uniform',
                      extrapolation='fixed',
                      include_bias=False),
    Ridge(alpha=0.1)
    ).match(X, y)

# 3. Predict and Visualize
y_plot = mannequin.predict(X)

# Plot
plt.determine(figsize=(12, 5))
plt.scatter(X, y, colour='grey', alpha=0.5, label='Information')
plt.plot(X, y_plot, colour='teal', linewidth=3, label='Spline Mannequin')
plt.plot(X, y_plot_10, colour='purple', linewidth=2, label='Polynomial Match (Diploma 20)')
plt.legend()
plt.title("Splines: Versatile but Disciplined")
plt.present()

Hier ist das Ergebnis. Mit Splines haben wir eine bessere Kontrolle und ein glatteres Modell, wodurch das Drawback an den Enden umgangen wird.

Wir vergleichen ein Polynommodell von diploma=20 mit dem Spline-Modell. Man kann argumentieren, dass niedrigere Grade eine viel bessere Modellierung dieser Daten ermöglichen, und sie wären richtig. Ich habe bis zum 13. Grad getestet und es passt intestine zu diesem Datensatz.

Doch genau darum geht es in diesem Artikel. Wenn das Modell nicht so intestine zu den Daten passt und wir den Grad des Polynoms weiter erhöhen müssen, werden wir mit Sicherheit in die State of affairs geraten wilde Kanten Drawback.

Anwendungen aus dem wirklichen Leben

Wo würden Sie das eigentlich geschäftlich nutzen?

• Zeitreihenzyklen: Verwenden extrapolation='periodic' für Merkmale wie „Tagesstunde“ oder „Monat des Jahres“. Dadurch wird sichergestellt, dass das Modell weiß, dass 23:59 Uhr direkt neben 00:01 Uhr liegt. Mit diesem Argument sagen wir das SplineTransformer dass sich das Ende unseres Zyklus (Stunde 23) umschließen und auf den Anfang (Stunde 0) treffen sollte. Somit stellt der Spline sicher, dass Steigung und Wert am Ende des Tages perfekt mit dem Beginn des nächsten Tages übereinstimmen.
• Dosis-Wirkungs-Verhältnis in der Medizin: Modellieren, wie sich ein Medikament auf einen Patienten auswirkt. Die meisten Medikamente folgen einer nichtlinearen Kurve, bei der sich der Nutzen schließlich einpendelt (Sättigung) oder, schlimmer noch, in Toxizität umschlägt. Splines sind hier der „Goldstandard“, da sie diese komplexen biologischen Veränderungen abbilden können, ohne die Daten in eine starre Kind zu zwingen.
• Einkommen vs. Erfahrung: Das Gehalt steigt oft früh schnell an und erreicht dann ein Plateau; Splines erfassen diese „Kurve“ perfekt.

Bevor Sie gehen

Wir haben hier viel besprochen, von der Frage, warum Polynome eine „wilde“ Wahl sein können, bis hin zur Frage, wie periodische Splines die Mitternachtslücke lösen. Hier ist eine kurze Zusammenfassung, die Sie in Ihrer Gesäßtasche aufbewahren sollten:

• Die goldene Regel: Verwenden Sie Splines, wenn eine gerade Linie zu einfach ist, ein Polynom höheren Grades jedoch zu oszillieren und zu überpassen beginnt.
• Knoten sind der Schlüssel: Knoten sind die „Gelenke“ Ihres Modells. Die richtige Nummer finden über GridSearchCV ist der Unterschied zwischen einer glatten Kurve und einem gezackten Durcheinander.
• Periodische Leistung: Für jede Funktion, die zyklisch läuft (Stunden, Tage, Monate), verwenden Sie extrapolation='periodic'. Dadurch wird sichergestellt, dass das Modell versteht, dass das Ende des Zyklus perfekt in den Anfang übergeht.
• Characteristic Engineering > Komplexe Modelle: Oftmals ein einfaches Ridge Regression kombiniert mit SplineTransformer übertrifft ein komplexes „Black-Field“-Modell und bleibt Ihrem Chef viel einfacher zu erklären.

Wenn Ihnen dieser Inhalt gefallen hat, finden Sie auf meiner Web site mehr über meine Arbeit und meine Kontakte.

https://gustavorsantos.me

GitHub-Repository

Hier ist der vollständige Code dieser Übung und ein paar Extras.

https://github.com/gurezende/Finding out/blob/grasp/Python/sklearn/SplineTransformer.ipynb

Referenzen

(1. SplineTransformer-Dokumentation) https://scikit-learn.org/steady/modules/generated/sklearn.preprocessing.SplineTransformer.html

(2. Runges Phänomen) https://en.wikipedia.org/wiki/Rungepercent27s_phenomenon

(3. Pipeline-Dokumente erstellen) https://scikit-learn.org/steady/modules/generated/sklearn.pipeline.make_pipeline.html

Bild vom Herausgeber

# Einführung

Dask ist eine Reihe von Paketen, die parallele Rechenfunktionen nutzen – äußerst nützlich bei der Verarbeitung großer Datenmengen oder beim Erstellen effizienter, datenintensiver Anwendungen wie fortschrittlicher Analyse- und maschineller Lernsysteme. Zu den hervorstechendsten Vorteilen gehört die nahtlose Integration von Dask in bestehende Python-Frameworks, einschließlich der Unterstützung für die gleichzeitige Verarbeitung großer Datenmengen scikit-lernen Module durch parallelisierte Arbeitsabläufe. In diesem Artikel erfahren Sie, wie Sie Dask für eine skalierbare Datenverarbeitung nutzen können, selbst unter begrenzten {Hardware}-Einschränkungen.

# Schritt-für-Schritt-Anleitung

Obwohl es nicht besonders massiv ist, ist das Datensatz zum kalifornischen Wohnungsbau ist relativ groß und daher eine gute Wahl für ein einfaches, anschauliches Codierungsbeispiel, das zeigt, wie Dask und scikit-learn gemeinsam für die Datenverarbeitung in großem Maßstab genutzt werden können.

Dask bietet eine dataframe Modul, das viele Aspekte der Pandas nachahmt DataFrame Objekte zur Verarbeitung großer Datenmengen, die möglicherweise nicht vollständig in den Speicher passen. Wir werden dieses Dask verwenden DataFrame Struktur zum Laden unserer Daten aus einer CSV in ein GitHub-Repository wie folgt:

import dask.dataframe as dd

url = "https://uncooked.githubusercontent.com/gakudo-ai/open-datasets/refs/heads/major/housing.csv"
df = dd.read_csv(url)

df.head()

Hier ein wichtiger Hinweis. Wenn Sie die „Type“ des Datensatzes sehen möchten – die Anzahl der Zeilen und Spalten – ist die Methode etwas schwieriger als nur die Verwendung df.form. Stattdessen sollten Sie Folgendes tun:

num_rows = df.form(0).compute()
num_cols = df.form(1)
print(f"Variety of rows: {num_rows}")
print(f"Variety of columns: {num_cols}")

Ausgabe:

Variety of rows: 20640
Variety of columns: 10

Beachten Sie, dass wir Dasks verwendet haben compute() um träge die Anzahl der Zeilen zu berechnen, aber nicht die Anzahl der Spalten. Die Metadaten des Datensatzes ermöglichen es uns, die Anzahl der Spalten (Merkmale) sofort zu ermitteln, wohingegen die Bestimmung der Anzahl der Zeilen in einem Datensatz, die (hypothetisch) größer als der Speicher – und somit partitioniert – sein könnten, eine verteilte Berechnung erfordert: etwas, das compute() wickelt für uns clear ab.

Datenvorverarbeitung ist meist ein vorheriger Schritt zum Aufbau eines Modells oder Schätzers für maschinelles Lernen. Bevor wir zu diesem Teil übergehen und da der Schwerpunkt dieses praktischen Artikels darauf liegt, zu zeigen, wie Dask zur Verarbeitung von Daten verwendet werden kann, bereinigen und bereiten wir es vor.

Ein häufiger Schritt bei der Datenaufbereitung ist Umgang mit fehlenden Werten. Mit Dask ist der Prozess so nahtlos, als ob wir nur Pandas verwenden würden. Der folgende Code entfernt beispielsweise Zeilen für Instanzen, die fehlende Werte in einem ihrer Attribute enthalten:

df = df.dropna()

num_rows = df.form(0).compute()
num_cols = df.form(1)
print(f"Variety of rows: {num_rows}")
print(f"Variety of columns: {num_cols}")

Jetzt wurde der Datensatz um über 200 Instanzen reduziert und umfasst insgesamt 20433 Zeilen.

Als Nächstes können wir einige numerische Merkmale im Datensatz skalieren, indem wir Scikit-Learns integrieren StandardScaler oder irgendein anderes geeignetes Skalierungsmethode:

from sklearn.preprocessing import StandardScaler

numeric_df = df.select_dtypes(embrace=("quantity"))
X_pd = numeric_df.drop("median_house_value", axis=1).compute()

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_pd)

Beachten Sie vor allem, dass wir in Dask eine Folge von datensatzintensiven Vorgängen ausführen, z. B. das Löschen von Zeilen mit fehlenden Werten und das anschließende Löschen der Zielspalte "median_house_value"müssen wir hinzufügen compute() am Ende der Folge verketteter Operationen. Das liegt daran Datensatztransformationen in Dask werden träge durchgeführt. Einmal compute() aufgerufen wird, wird das Ergebnis der verketteten Transformation des Datensatzes als Pandas materialisiert DataFrame (Dask hängt von Pandas ab, daher müssen Sie die Pandas-Bibliothek nicht explizit in Ihren Code importieren, es sei denn, Sie rufen direkt eine Pandas-exklusive Funktion auf.)

Was ist, wenn wir wollen? Trainieren Sie ein Modell für maschinelles Lernen? Dann sollten wir die Zielvariable extrahieren "median_house_value" und wenden Sie dasselbe Prinzip an, um es in ein Pandas-Objekt zu konvertieren:

y = df("median_house_value")
y_pd = y.compute()

Von nun an besteht der Prozess darin, den Datensatz in Trainings- und Testsätze aufzuteilen und ein Regressionsmodell zu trainieren RandomForestRegressorund die Bewertung seines Fehlers anhand der Testdaten ähnelt vollständig einem traditionellen Ansatz, bei dem Pandas und Scikit-Be taught auf orchestrierte Weise verwendet werden. Da baumbasierte Modelle unempfindlich gegenüber der Function-Skalierung sind, können Sie entweder die unskalierten Options (X_pd) oder die skalierten (X_scaled). Im Folgenden fahren wir mit den oben berechneten skalierten Merkmalen fort:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import numpy as np

# Use the scaled function matrix produced earlier
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_pd, test_size=0.2, random_state=42)

mannequin = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
mannequin.match(X_train, y_train)

y_pred = mannequin.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(f"RMSE: {rmse:.2f}")

Ausgabe:

# Zusammenfassung

Dask und scikit-learn können zusammen verwendet werden, um skalierbare, parallelisierte Datenverarbeitungsabläufe zu nutzen, um beispielsweise große Datensätze für die Erstellung von Modellen für maschinelles Lernen effizient vorzuverarbeiten. In diesem Artikel wurde gezeigt, wie man Daten mit Dask lädt, bereinigt, vorbereitet und transformiert und anschließend Commonplace-Scikit-Be taught-Instruments für die Modellierung maschinellen Lernens anwendet – und das alles bei gleichzeitiger Optimierung der Speichernutzung und Beschleunigung der Pipeline bei der Verarbeitung großer Datenmengen.

Iván Palomares Carrascosa ist führend, Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Bild vom Herausgeber

# Einführung

Ich freue mich darauf, Ihr erstes, überschaubares maschinelles Lernprojekt mit den beliebten Python-Bibliotheken zu starten Pandas Und Scikit-lernenaber Sie wissen nicht, wo Sie anfangen sollen? Suchen Sie nicht weiter.

In diesem Artikel werde ich Sie durch ein sanftes, einsteigerfreundliches Projekt zum maschinellen Lernen führen, in dem wir gemeinsam ein Regressionsmodell erstellen, das das Mitarbeitereinkommen auf der Grundlage sozioökonomischer Merkmale vorhersagt. Unterwegs lernen wir einige wichtige Konzepte und wichtige Methods des maschinellen Lernens kennen.

# Vom Rohdatensatz zum sauberen DataFrame

Zunächst empfiehlt es sich, wie bei jedem Python-basierten Projekt, zunächst die erforderlichen Bibliotheken, Module und Komponenten zu importieren, die wir während des gesamten Prozesses verwenden werden:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
import joblib

Mit den folgenden Anweisungen wird ein öffentlich verfügbarer Datensatz geladen dieses Repository in einen Panda DataFrame Objekt: eine übersichtliche Datenstruktur zum Laden, Analysieren und Verwalten vollständig strukturierter Daten, d. h. Daten im Tabellenformat. Nach dem Laden betrachten wir seine grundlegenden Eigenschaften und Datentypen in seinen Attributen.

url = "https://uncooked.githubusercontent.com/gakudo-ai/open-datasets/important/employees_dataset_with_missing.csv"
df = pd.read_csv(url)
print(df.head())
print(df.data())

Sie werden feststellen, dass der Datensatz 1.000 Einträge oder Instanzen enthält – additionally Daten, die 1.000 Mitarbeiter beschreiben –, aber für die meisten Attribute wie Alter, Einkommen usw. gibt es weniger als 1.000 tatsächliche Werte. Warum? Weil In diesem Datensatz fehlen Werteein häufiges Drawback bei realen Daten, das behoben werden muss.

In unserem Projekt setzen wir uns zum Ziel, das Einkommen eines Mitarbeiters anhand der übrigen Merkmale vorherzusagen. Daher werden wir den Ansatz verfolgen, Zeilen (Mitarbeiter) zu verwerfen, deren Wert für dieses Attribut fehlt. Während es bei Prädiktorattributen manchmal in Ordnung ist, mit fehlenden Werten umzugehen und sie zu schätzen oder zu imputieren, benötigen wir für die Zielvariable vollständig bekannte Bezeichnungen zum Trainieren unseres maschinellen Lernmodells: Der Haken daran ist, dass unser maschinelles Lernmodell lernt, indem es Beispielen mit bekannten Vorhersageausgaben ausgesetzt wird.

Es gibt auch eine spezielle Anweisung, nur nach fehlenden Werten zu suchen:

Additionally, lasst uns unsere reinigen DataFrame um von fehlenden Werten für die Zielvariable Einkommen ausgenommen zu sein. Dieser Code entfernt Einträge mit fehlenden Werten, insbesondere für dieses Attribut.

goal = "earnings"
train_df = df.dropna(subset=(goal))

X = train_df.drop(columns=(goal))
y = train_df(goal)

Wie wäre es additionally mit den fehlenden Werten in den restlichen Attributen? Wir werden uns in Kürze darum kümmern, aber zuerst müssen wir unseren Datensatz in zwei große Teilmengen aufteilen: einen Trainingssatz zum Trainieren des Modells und einen Testsatz zur Bewertung der Leistung unseres Modells nach dem Coaching, bestehend aus Beispielen, die sich von denen unterscheiden, die das Modell während des Trainings gesehen hat. Scikit-learn bietet eine einzelne Anweisung, um diese Aufteilung nach dem Zufallsprinzip durchzuführen:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Der nächste Schritt geht noch einen Schritt weiter, um die Daten in eine großartige Kind für das Coaching eines Modells für maschinelles Lernen umzuwandeln: den Aufbau einer Vorverarbeitungspipeline. Normalerweise sollte diese Vorverarbeitung zwischen numerischen und kategorialen Merkmalen unterscheiden, sodass jeder Merkmalstyp unterschiedlichen Vorverarbeitungsaufgaben entlang der Pipeline unterliegt. Beispielsweise sollen numerische Merkmale typischerweise skaliert werden, während kategoriale Merkmale in numerische Merkmale abgebildet oder kodiert werden können, damit das Modell des maschinellen Lernens sie verarbeiten kann. Zur Veranschaulichung zeigt der folgende Code den gesamten Prozess des Aufbaus einer Vorverarbeitungspipeline. Es umfasst die automatische Identifizierung numerischer und kategorialer Merkmale, sodass jeder Typ korrekt verarbeitet werden kann.

numeric_features = X.select_dtypes(embody=("int64", "float64")).columns
categorical_features = X.select_dtypes(exclude=("int64", "float64")).columns

numeric_transformer = Pipeline((
    ("imputer", SimpleImputer(technique="median"))
))

categorical_transformer = Pipeline((
    ("imputer", SimpleImputer(technique="most_frequent")),
    ("onehot", OneHotEncoder(handle_unknown="ignore"))
))

preprocessor = ColumnTransformer((
    ("num", numeric_transformer, numeric_features),
    ("cat", categorical_transformer, categorical_features)
))

Weitere Informationen zu Datenvorverarbeitungspipelines finden Sie unter dieser Artikel.

Diese Pipeline wurde einmal auf die angewendet DataFrameführt zu einer sauberen, gebrauchsfertigen Model für maschinelles Lernen. Wir werden es jedoch im nächsten Schritt anwenden, indem wir sowohl die Datenvorverarbeitung als auch das Modelltraining für maschinelles Lernen in einer einzigen übergreifenden Pipeline zusammenfassen.

# Vom sauberen DataFrame zum einsatzbereiten Modell

Jetzt definieren wir eine übergreifende Pipeline, die:

1. Wendet den zuvor definierten Vorverarbeitungsprozess an – gespeichert im preprocessor Variable – sowohl für numerische als auch für kategoriale Attribute.
2. Trainiert ein Regressionsmodell, nämlich eine zufällige Waldregression, um das Einkommen anhand vorverarbeiteter Trainingsdaten vorherzusagen.

mannequin = Pipeline((
    ("preprocessor", preprocessor),
    ("regressor", RandomForestRegressor(random_state=42))
))

mannequin.match(X_train, y_train)

Wichtig ist, dass die Trainingsphase nur die Trainingsteilmenge erhält, die wir zuvor bei der Aufteilung erstellt haben, nicht den gesamten Datensatz.

Jetzt nehmen wir die andere Teilmenge der Daten, den Testsatz, und bewerten damit die Leistung des Modells an diesen Beispielmitarbeitern. Wir verwenden den mittleren absoluten Fehler (MAE) als unsere Bewertungsmetrik:

preds = mannequin.predict(X_test)
mae = mean_absolute_error(y_test, preds)
print(f"nModel MAE: {mae:.2f}")

Möglicherweise erhalten Sie einen MAE-Wert von etwa 13.000, was akzeptabel, aber nicht brillant ist, wenn man bedenkt, dass die meisten Einkommen im Bereich von 60.000 bis 90.000 liegen. Auf jeden Fall nicht schlecht für ein erstes Modell für maschinelles Lernen!

Abschließend möchte ich Ihnen zeigen, wie Sie Ihr trainiertes Modell für die zukünftige Bereitstellung in einer Datei speichern.

joblib.dump(mannequin, "employee_income_model.joblib")
print("Mannequin saved as employee_income_model.joblib")

Speichern Sie Ihr trainiertes Modell in einem .joblib Die Datei ist für zukünftige Bereitstellungen nützlich, da Sie sie sofort neu laden und wiederverwenden können, ohne sie erneut von Grund auf trainieren zu müssen. Stellen Sie sich das so vor, als würden Sie Ihre gesamte Vorverarbeitungspipeline und das trainierte Modell in einem tragbaren Objekt „einfrieren“. Zu den schnellen Optionen für die zukünftige Verwendung und Bereitstellung gehören das Einbinden in ein einfaches Python-Skript oder -Pocket book oder die Erstellung einer schlanken Net-App, die mit Instruments wie erstellt wurde Streamlit, Gradiooder Flasche.

# Zusammenfassung

In diesem Artikel haben wir ein einführendes Modell für maschinelles Lernen für die Regression zusammengestellt, insbesondere zur Vorhersage des Mitarbeitereinkommens, und die notwendigen Schritte vom Rohdatensatz bis zum sauberen, vorverarbeiteten Datensatz skizziert DataFrameund von DataFrame zum einsatzbereiten Modell.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Bäume sind ein beliebter beaufsichtigter Lernalgorithmus mit Vorteilen, darunter auch für Regression und Klassifizierung verwendet werden und leicht zu interpretieren sind. Entscheidungsbäume sind jedoch nicht der leistungsstärkste Algorithmus und sind aufgrund kleiner Unterschiede in den Trainingsdaten zu Überanpassung anfällig. Dies kann zu einem völlig anderen Baum führen. Aus diesem Grund wenden sich Menschen oft an Ensemble -Modelle wie gepackte Bäume und zufällige Wälder. Diese bestehen aus mehreren Entscheidungsbäumen, die auf Bootstrap -Daten geschult und aggregiert sind, um eine bessere prädiktive Leistung zu erzielen, als jeder einzelne Baum bieten könnte. Dieses Tutorial enthält Folgendes:

• Was ist einsackt
• Was macht zufällige Wälder unterschiedlich
• Coaching und Stimmen eines zufälligen Waldes mit Scikit-Study
• Berechnung und Interpretation der Merkmals Bedeutung
• Visualisieren individueller Entscheidungsbäume in einem zufälligen Wald

Wie immer ist der in diesem Tutorial verwendete Code in meinem verfügbar Github. A Videoversion Von diesem Tutorial ist auch auf meinem YouTube -Kanal für diejenigen verfügbar, die es vorziehen, visuell mitzugehen. Bemerken wir damit!

Was ist ein Sacking (Bootstrap -Aggregation)

Zufällige Wälder können als Bagging -Algorithmen eingestuft werden (BOotstrap AggRegating). Das Sacken besteht aus zwei Schritten:

1.) Bootstrap -Sampling: Erstellen Sie mehrere Trainingssätze, indem Sie Stichproben mit Ersatz aus dem ursprünglichen Datensatz zufällig zeichnen. Diese neuen Trainingseinsätze, die als Bootstrapt -Datensätze bezeichnet werden, enthalten normalerweise die gleiche Anzahl von Zeilen wie der ursprüngliche Datensatz, aber einzelne Zeilen können mehrmals oder gar nicht angezeigt werden. Im Durchschnitt enthält jeder Bootstrap -Datensatz etwa 63,2% der eindeutigen Zeilen aus den Originaldaten. Die verbleibenden ~ 36,8% der Zeilen werden ausgelassen und können für die Auswertung außerhalb des Baggage (OOB) verwendet werden. Weitere Informationen zu diesem Konzept finden Sie in meinem Probenahme mit und ohne Ersatz -Weblog -Beitrag.

2.) Aggregation Vorhersagen: Jeder Bootstrap -Datensatz wird verwendet, um ein anderes Entscheidungsbaummodell zu trainieren. Die endgültige Vorhersage erfolgt durch die Kombination der Ausgaben aller einzelnen Bäume. Für die Klassifizierung erfolgt dies normalerweise durch Mehrheitsabstimmung. Für die Regression werden Vorhersagen gemittelt.

Das Coaching jedes Baumes auf einer anderen Stiefelprobe führt zu Variationen über Bäume. Während dies die Korrelation nicht vollständig beseitigt – insbesondere wenn bestimmte Merkmale dominieren, hilft es, die Überanpassung in Kombination mit der Aggregation zu verringern. Durchschnitt der Vorhersagen vieler solcher Bäume reduziert den Gesamt Varianz des Ensembles, Verbesserung der Verallgemeinerung.

Was macht zufällige Wälder unterschiedlich

Angenommen, es gibt eine einzige starke Funktion in Ihrem Datensatz. In SackbäumeJeder Baum kann dieses Merkmal wiederholt teilen, was zu korrelierten Bäumen führt und weniger von der Aggregation profitiert. Zufällige Wälder reduzieren dieses Downside, indem sie weitere Zufälligkeit einführen. Insbesondere verändern sie, wie Spaltungen während des Trainings ausgewählt werden:

1). Erstellen Sie N -Bootstrap -Datensätze. Beachten Sie, dass das Bootstrapping in zufälligen Wäldern üblicherweise verwendet wird, es ist jedoch nicht streng erforderlich, da Schritt 2 (Auswahl der zufälligen Merkmale) eine ausreichende Vielfalt der Bäume einführt.

2). Für jeden Baum wird bei jedem Knoten eine zufällige Untergruppe von Merkmalen als Kandidaten ausgewählt, und die beste Spaltung wird aus dieser Teilmenge ausgewählt. In Scikit-Study wird dies von der gesteuert max_features Parameter, der standardmäßig angeht 'sqrt' für Klassifikatoren und 1 für Regressoren (gleichwertig mit abgesackten Bäumen).

3). Aggregation Vorhersagen: Stimmen Sie für Klassifizierung und Durchschnitt für die Regression.

Hinweis: Zufällige Wälder verwenden Probenahme mit Ersatz für Bootstrap -Datensätze und Abtastung ohne Ersatz Zur Auswahl einer Untergruppe von Funktionen.

OB-of-Bag (OOB) Rating

Da ~ 36,8% der Schulungsdaten von einem bestimmten Baum ausgeschlossen sind, können Sie diesen Holdout -Teil verwenden, um die Vorhersagen dieses Baumes zu bewerten. Scikit-Study ermöglicht dies über den Parameter OOB_SCORE = True, und bietet einen effizienten Weg, um die Verallgemeinerungsfehler abzuschätzen. Sie werden diesen Parameter im Trainingsbeispiel später im Tutorial sehen.

Coaching und Stimmen eines zufälligen Waldes in Scikit-Study

Zufällige Wälder bleiben dank ihrer Einfachheit, Interpretierbarkeit und Fähigkeit zu einer starken Grundlinie für tabellarische Daten parallelisieren Da wird jeder Baum unabhängig trainiert. Dieser Abschnitt zeigt, wie Daten geladen werden. Führen Sie einen Zugtest geteilt durchtrainieren Sie ein Basismodell, stimmen Sie Hyperparameter mit der Gittersuche ab und bewerten Sie das endgültige Modell im Testsatz.

Schritt 1: Trainieren Sie ein Basismodell

Vor dem Einstellen ist es eine gute Praxis, ein Basismodell mit angemessenen Standardeinstellungen zu trainieren. Dies gibt Ihnen ein anfängliches Leistungsgefühl und ermöglicht es Ihnen, die Generalisierung mithilfe des OB-Bag-Scores (OB-BAG) zu validieren, der in magebasierte Modelle wie zufällige Wälder integriert ist. In diesem Beispiel werden die Hausverkäufe in King County Dataset (CCO 1.0 Common Lizenz) verwendet, die zwischen Mai 2014 und Mai 2015 den Verkauf von Immobilien aus dem Gebiet von Seattle enthält. Mit diesem Ansatz können wir den Testsatz für die endgültige Bewertung nach dem Tuning reservieren.

Python"># Import libraries

# Some imports are solely used later within the tutorial
import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

# Dataset: Breast Most cancers Wisconsin (Diagnostic)
# Supply: UCI Machine Studying Repository
# License: CC BY 4.0
from sklearn.datasets import load_breast_cancer

from sklearn.ensemble import RandomForestClassifier

from sklearn.ensemble import RandomForestRegressor

from sklearn.inspection import permutation_importance

from sklearn.model_selection import GridSearchCV, train_test_split

from sklearn import tree

# Load dataset
# Dataset: Home Gross sales in King County (Might 2014–Might 2015)
# License CC0 1.0 Common
url = 'https://uncooked.githubusercontent.com/mGalarnyk/Tutorial_Data/grasp/King_County/kingCountyHouseData.csv'

df = pd.read_csv(url)

columns = ('bedrooms',

            'loos',

            'sqft_living',

            'sqft_lot',

             'flooring',

             'waterfront',

             'view',

             'situation',

             'grade',

             'sqft_above',

             'sqft_basement',

             'yr_built',

             'yr_renovated',

             'lat',

             'lengthy',

             'sqft_living15',

             'sqft_lot15',

             'value')

df = df(columns)

# Outline options and goal

X = df.drop(columns='value')

y = df('value')

# Prepare/take a look at break up

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

# Prepare baseline Random Forest

reg = RandomForestRegressor(

    n_estimators=100,        # variety of timber

    max_features=1/3,        # fraction of options thought of at every break up

    oob_score=True,          # permits out-of-bag analysis

    random_state=0

)

reg.match(X_train, y_train)

# Consider baseline efficiency utilizing OOB rating

print(f"Baseline OOB rating: {reg.oob_score_:.3f}")

Schritt 2: Schalten Sie Hyperparameter mit der Gittersuche ab

Während das Basismodell einen starken Ausgangspunkt liefert, kann die Leistung häufig durch Tuning von Schlüsselhyperparametern verbessert werden. Grid-Suche Kreuzvalidierung, wie durch implementiert von GridSearchCVsystematisch untersucht Kombinationen von Hyperparametern und verwendet eine Kreuzvalidierung, um die einzelnen zu bewerten, wobei die Konfiguration mit der höchsten Validierungsleistung ausgewählt wird. Zu den am häufigsten abgestimmten Hyperparametern gehören:

• n_estimators: Die Anzahl der Entscheidungsbäume im Wald. Mehr Bäume können die Genauigkeit verbessern, aber die Trainingszeit erhöhen.
• max_features: Die Anzahl der Funktionen zu berücksichtigen, wenn Sie nach dem besten Cut up suchen. Niedrigere Werte verringern die Korrelation zwischen Bäumen.
• max_depth: Die maximale Tiefe jedes Baumes. Flachere Bäume sind schneller, können aber unterbinden.
• min_samples_split: Die minimale Anzahl von Proben, die zum Aufteilen eines internen Knotens erforderlich sind. Höhere Werte können die Überanpassung verringern.
• min_samples_leaf: Die minimale Anzahl von Proben, die erforderlich sind, um sich an einem Blattknoten zu befinden. Hilft bei der Kontrolle der Baumgröße.
• bootstrap: Ob Bootstrap -Proben beim Bau von Bäumen verwendet werden. Wenn falsch, wird der gesamte Datensatz verwendet.

param_grid = {

    'n_estimators': (100),

    'max_features': ('sqrt', 'log2', None),

    'max_depth': (None, 5, 10, 20),

    'min_samples_split': (2, 5),

    'min_samples_leaf': (1, 2)

}

# Initialize mannequin

rf = RandomForestRegressor(random_state=0, oob_score=True)

grid_search = GridSearchCV(

    estimator=rf,

    param_grid=param_grid,

    cv=5,             # 5-fold cross-validation

    scoring='r2',     # analysis metric

    n_jobs=-1         # use all obtainable CPU cores

)

grid_search.match(X_train, y_train)

print(f"Finest parameters: {grid_search.best_params_}")

print(f"Finest R^2 rating: {grid_search.best_score_:.3f}")

Schritt 3: Bewerten Sie das endgültige Modell im Testsatz

Nachdem wir nun das auf Foundation von Quervalidierung basierende Modell ausgewählt haben, können wir es am Maintain-Out-Take a look at-Set bewerten, um seine Generalisierungsleistung abzuschätzen.

# Consider ultimate mannequin on take a look at set

best_model = grid_search.best_estimator_

print(f"Take a look at R^2 rating (ultimate mannequin): {best_model.rating(X_test, y_test):.3f}")

Berechnung der Wichtigkeit des zufälligen Waldmerkmals

Einer der Hauptvorteile zufälliger Wälder ist ihre Interpretierbarkeit – etwas, das große Sprachmodelle (LLMs) häufig fehlen. Während LLMs leistungsfähig sind, fungieren sie normalerweise als schwarze Kisten und können Zeigen Sie Verzerrungen auf, die schwer zu identifizieren sind. Im Gegensatz dazu unterstützt Scikit-Study zwei Hauptmethoden zur Messung der Merkmals Bedeutung in zufälligen Wäldern: mittlere Abnahme von Verunreinigungen und Permutation.

1). Durch die mittlere Verringerung der Verunreinigung (MDI): Diese Methode auch als Gini -Bedeutung bezeichnet. Diese Methode berechnet die Gesamtreduktion der Verunreinigung, die jedes Merkmal über alle Bäume übertragen wird. Dies ist schnell und in das Modell integriert über through reg.feature_importances_. Unreinheitsbasierte Merkmalsimporte können jedoch irreführend sein, insbesondere für Funktionen mit hoher Kardinalität (viele einzigartige Werte), da diese Funktionen eher ausgewählt werden, nur weil sie mehr potenzielle Cut up-Punkte liefern.

importances = reg.feature_importances_

feature_names = X.columns

sorted_idx = np.argsort(importances)(::-1)

for i in sorted_idx:

    print(f"{feature_names(i)}: {importances(i):.3f}")

2). Permutation Bedeutung: Diese Methode bewertet die Abnahme der Modellleistung, wenn die Werte eines einzelnen Merkmals zufällig gemischt werden. Im Gegensatz zu MDI berücksichtigt es Function -Interaktionen und Korrelation. Es ist zuverlässiger, aber auch rechenintensiver.

# Carry out permutation significance on the take a look at set

perm_importance = permutation_importance(reg, X_test, y_test, n_repeats=10, random_state=0)

sorted_idx = perm_importance.importances_mean.argsort()(::-1)

for i in sorted_idx:

    print(f"{X.columns(i)}: {perm_importance.importances_mean(i):.3f}")

Es ist wichtig zu beachten, dass unsere geografischen Merkmale Lat und Lengthy auch für die Visualisierung nützlich sind, wie das folgende Diagramm zeigt. Es ist wahrscheinlich, dass Unternehmen wie Zillow die Standortinformationen in ihren Bewertungsmodellen ausgiebig einsetzen.

Visualisieren individueller Entscheidungsbäume in einem zufälligen Wald

Ein zufälliger Wald besteht aus mehreren Entscheidungsbäumen – einer für jeden über die angegebenen Schätzer n_estimators Parameter. Nach dem Coaching des Modells können Sie diese einzelnen Bäume über das Attribut .Sestimators_ zugreifen. Das Visualisieren einiger dieser Bäume kann helfen, zu veranschaulichen, wie unterschiedlich jeder die Daten aufgrund von Bootstrap -Trainingsproben und zufälligen Merkmalsauswahl bei jedem Cut up spaltet. Während das frühere Beispiel einen zufälligen ForestRegressor verwendete, zeigen wir hier diese Visualisierung anhand eines auf dem Breast Most cancers Wisconsin -Datensatzes (CC nach 4.0 -Lizenz) ausgebildeten RandomforestClassifiers, um die Vielseitigkeit von zufälligen Wäldern für Regressions- und Klassifizierungsaufgaben hervorzuheben. Dieses kurze Video zeigt, wie 100 geschulte Schätzer aus diesem Datensatz aussehen.

Passen Sie ein zufälliges Waldmodell mit Scikit-Study an

# Load the Breast Most cancers (Diagnostic) Dataset

knowledge = load_breast_cancer()

df = pd.DataFrame(knowledge.knowledge, columns=knowledge.feature_names)

df('goal') = knowledge.goal

# Organize Knowledge into Options Matrix and Goal Vector

X = df.loc(:, df.columns != 'goal')

y = df.loc(:, 'goal').values

# Cut up the information into coaching and testing units

X_train, X_test, Y_train, Y_test = train_test_split(X, y, random_state=0)

# Random Forests in `scikit-learn` (with N = 100)

rf = RandomForestClassifier(n_estimators=100,

                            random_state=0)

rf.match(X_train, Y_train)

Zeichnen einzelner Schätzer (Entscheidungsbäume) aus einem zufälligen Wald unter Verwendung von Matplotlib

Sie können jetzt alle einzelnen Bäume aus dem montierten Modell anzeigen.

rf.estimators_

Sie können jetzt einzelne Bäume visualisieren. Der folgende Code visualisiert den ersten Entscheidungsbaum.

fn=knowledge.feature_names

cn=knowledge.target_names

fig, axes = plt.subplots(nrows = 1,ncols = 1,figsize = (4,4), dpi=800)

tree.plot_tree(rf.estimators_(0),

               feature_names = fn, 

               class_names=cn,

               stuffed = True);

fig.savefig('rf_individualtree.png')

Obwohl es schwierig zu interpretieren ist, viele Bäume zu planen, möchten Sie möglicherweise die Vielfalt zwischen den Schätzern untersuchen. Das folgende Beispiel zeigt, wie die ersten fünf Entscheidungsbäume im Wald visualisieren:

# This will likely not one of the best ways to view every estimator as it's small

fig, axes = plt.subplots(nrows=1, ncols=5, figsize=(10, 2), dpi=3000)

for index in vary(5):

    tree.plot_tree(rf.estimators_(index),

                   feature_names=fn,

                   class_names=cn,

                   stuffed=True,

                   ax=axes(index))

    axes(index).set_title(f'Estimator: {index}', fontsize=11)

fig.savefig('rf_5trees.png')

Abschluss

Zufällige Wälder bestehen aus mehreren Entscheidungsbäumen, die auf Bootstrap -Daten ausgebildet sind, um eine bessere prädiktive Leistung zu erzielen, als aus einer der einzelnen Entscheidungsbäume erhalten werden könnten. Wenn Sie Fragen oder Gedanken zum Tutorial haben, können Sie sich gerne durchgehen YouTube oder X.

Bild vom Autor

Wir alle kennen das beliebte Scikit-Be taught-Paket, das in Python verfügbar ist. Das Basispaket für maschinelles Lernen wird immer noch häufig zum Erstellen von Modellen und Klassifikatoren für industrielle Anwendungsfälle verwendet. Allerdings fehlte dem Paket die Fähigkeit zum Sprachverständnis und es battle immer noch auf die TF-IDF und frequenzbasierte Methoden für Aufgaben in natürlicher Sprache angewiesen. Mit der zunehmenden Beliebtheit von LLMs ist die Scikit-LLM Die Bibliothek möchte diese Lücke schließen. Es kombiniert große Sprachmodelle, um Klassifikatoren für textbasierte Eingaben zu erstellen, wobei es dieselbe funktionale API wie die herkömmlichen Scikit-Be taught-Modelle verwendet.

In diesem Artikel erkunden wir die Scikit-LLM-Bibliothek und implementieren einen Zero-Shot-Textklassifikator für einen Demodatensatz.

Einrichtung und Set up

Das Scikit-LLM-Paket ist als PyPI-Paket verfügbar und lässt sich daher einfach mit pip installieren. Führen Sie den folgenden Befehl aus, um das Paket zu installieren.

Backend-LLM-Unterstützung
Das Scikit-LLM unterstützt derzeit API-Integrationen und lokal unterstützte große Sprachmodelle. Wir können auch benutzerdefinierte APIs integrieren, die vor Ort oder auf Cloud-Plattformen gehostet werden. In den nächsten Abschnitten erfahren Sie, wie Sie die einzelnen Elemente einrichten.

&nbsp

OpenAI

Die GPT-Modelle sind die am weitesten verbreiteten Sprachmodelle weltweit und verfügen über zahlreiche darauf aufbauende Anwendungen. Um ein OpenAI-Modell mit dem Scikit-LLM-Paket einzurichten, müssen wir die API-Anmeldeinformationen konfigurieren und den Modellnamen festlegen, den wir verwenden möchten.

from skllm.config import SKLLMConfig

SKLLMConfig.set_openai_key("")
SKLLMConfig.set_openai_org("")

Sobald die API-Anmeldeinformationen konfiguriert sind, können wir den Zero-Shot-Klassifikator aus dem Scikit-LLM-Paket verwenden, der standardmäßig das OpenAI-Modell verwendet.

from skllm.fashions.gpt.classification.zero_shot import ZeroShotGPTClassifier
clf = ZeroShotGPTClassifier(mannequin="gpt-4")

&nbsp

LlamaCPP- und GGUF-Modelle

Obwohl OpenAI sehr beliebt ist, kann seine Verwendung in manchen Fällen teuer und unpraktisch sein. Daher bietet das Scikit-LLM-Paket integrierte Unterstützung für die lokale Ausführung quantisierter GGUF- oder GGML-Modelle. Wir müssen unterstützende Pakete installieren, die bei der Verwendung des llama-cpp-Pakets zum Ausführen der Sprachmodelle helfen.

Führen Sie die folgenden Befehle aus, um die erforderlichen Pakete zu installieren:

pip set up 'scikit-llm(gguf)' --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu --no-cache-dir
pip set up 'scikit-llm(llama-cpp)'

Jetzt können wir dasselbe Zero-Shot-Klassifikatormodell von Scikit-LLM verwenden, um GGUF-Modelle zu laden. Beachten Sie, dass derzeit nur wenige Modelle unterstützt werden. Hier finden Sie die Liste der unterstützten Modelle Hier.

Für unseren Zweck verwenden wir die GGUF-quantisierte Model von Gemma-2B. Die allgemeine Syntax folgt gguf:: um ein gguf-quantisiertes Modell in Scikit-LLM zu laden.

Verwenden Sie den folgenden Code, um das Modell zu laden:

from skllm.fashions.gpt.classification.zero_shot import ZeroShotGPTClassifier
clf = ZeroShotGPTClassifier(mannequin="gguf::gemma2-2b-q6")

&nbsp

Externe Modelle

Schließlich können wir selbst gehostete Modelle verwenden, die dem OpenAI-API-Normal folgen. Es kann lokal ausgeführt oder in der Cloud gehostet werden. Wir müssen lediglich die API-URL für das Modell angeben.

Laden Sie das Modell mit dem angegebenen Code von einer benutzerdefinierten URL:

from skllm.config import SKLLMConfig
SKLLMConfig.set_gpt_url("http://localhost:8000/")
clf = ZeroShotGPTClassifier(mannequin="custom_url::")

Modell und Inferenz mit der Fundamental Scikit-Be taught API

Wir können das Modell jetzt mithilfe der Scikit-Be taught-API anhand eines Klassifizierungsdatensatzes trainieren. Wir werden eine grundlegende Implementierung anhand eines Demodatensatzes von Stimmungsvorhersagen zu Filmkritiken sehen.

&nbsp

Datensatz

Der Datensatz wird vom scikit-llm-Paket bereitgestellt. Es enthält 100 Beispiele von Filmkritiken und die dazugehörigen Bezeichnungen als constructive, neutrale oder unfavorable Stimmung. Wir werden den Datensatz laden und ihn für unsere Demo in Trainings- und Testdatensätze aufteilen.

Wir können die herkömmlichen Scikit-Be taught-Methoden verwenden, um den Datensatz zu laden und aufzuteilen.

from skllm.datasets import get_classification_dataset
X, y = get_classification_dataset()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)

Anpassen und vorhersagen

Das Coaching und die Vorhersage mithilfe des großen Sprachmodells folgen derselben Scikit-Be taught-API. Zuerst passen wir das Modell an unseren Trainingsdatensatz an und können es dann verwenden, um Vorhersagen zu ungesehenen Testdaten zu treffen.

clf.match(X_train, y_train)
predictions = clf.predict(X_test)

Auf dem Testset erhalten wir 100 % Genauigkeit mit dem Gemma2-2B-Modell da es sich um einen relativ einfachen Datensatz handelt.

Beispiele finden Sie in den folgenden Beispielen für Testmuster:

Pattern Assessment: "Below the Similar Sky was an okay film. The plot was respectable, and the performances have been fantastic, but it surely lacked depth and originality. It isn't a film I might watch once more."
Predicted Sentiment: ('impartial')

Pattern Assessment: "The cinematography in Awakening was nothing wanting spectacular. The visuals alone are well worth the ticket worth. The storyline was distinctive and the performances have been strong. An general improbable movie."
Predicted Sentiment: ('constructive')

Pattern Assessment: "I discovered Hole Echoes to be an entire mess. The plot was non-existent, the performances have been overdone, and the pacing was all over. Not well worth the hype."
Predicted Sentiment: ('unfavorable')

Zusammenfassung

Das scikit-llm-Paket erfreut sich aufgrund seiner vertrauten API immer größerer Beliebtheit und lässt sich leicht in bestehende Pipelines integrieren. Es bietet verbesserte Antworten für textbasierte Modelle und verbessert die ursprünglich verwendeten grundlegenden frequenzbasierten Methoden. Durch die Integration von Sprachmodellen werden Argumente und Verständnis für die Texteingabe hinzugefügt, was die Leistung von Standardmodellen steigern kann.

Darüber hinaus bietet es Optionen zum Trainieren von Wenig-Schuss- und Gedankenketten-Klassifikatoren neben anderen Textmodellierungsaufgaben wie der Zusammenfassung. Entdecken Sie das auf der offiziellen Web site verfügbare Paket und die Dokumentation, um herauszufinden, was für Ihren Zweck geeignet ist.

Kanwal Mehreen Kanwal ist Ingenieur für maschinelles Lernen und technischer Redakteur mit einer großen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Technology Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Variety in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter von Veränderungen und hat FEMCodes gegründet, um Frauen in MINT-Bereichen zu stärken.

1. Bestes VPN für Ingenieure – 3 Monate kostenlos – Bleiben Sie on-line sicher mit einer kostenlosen Testversion

2. Bestes Projektmanagement-Device für Tech-Groups – Steigern Sie noch heute die Effizienz Ihres Groups

4. Bestes Passwortverwaltungstool für Tech-Groups – Zero-Belief- und Zero-Information-Sicherheit

Bild vom Herausgeber | Midjourney & Canva

Lernen wir, wie man den Imputer von Scikit-learn zum Verarbeiten fehlender Daten verwendet.

Vorbereitung

Stellen Sie sicher, dass Numpy, Pandas und Scikit-Study in Ihrer Umgebung installiert sind. Wenn nicht, können Sie sie über Pip mit dem folgenden Code installieren:

pip set up numpy pandas scikit-learn

Anschließend können wir die Pakete in Ihre Umgebung importieren:

import numpy as np
import pandas as pd
import sklearn
from sklearn.experimental import enable_iterative_imputer

Fehlende Daten mit Imputer verarbeiten

Ein scikit-Study-Imputer ist eine Klasse, die zum Ersetzen fehlender Daten durch bestimmte Werte verwendet wird. Er kann Ihren Datenvorverarbeitungsprozess optimieren. Wir werden verschiedene Strategien zum Umgang mit den fehlenden Daten untersuchen.

Lassen Sie uns ein Datenbeispiel für unser Beispiel erstellen:

sample_data = {'First': (1, 2, 3, 4, 5, 6, 7, np.nan,9), 'Second': (np.nan, 2, 3, 4, 5, 6, np.nan, 8,9)}
df = pd.DataFrame(sample_data)
print(df)

    First  Second
0    1.0     NaN
1    2.0     2.0
2    3.0     3.0
3    4.0     4.0
4    5.0     5.0
5    6.0     6.0
6    7.0     NaN
7    NaN     8.0
8    9.0     9.0

Sie können die fehlenden Werte der Spalten mit dem Scikit-Study Easy Imputer unter Verwendung des Mittelwerts der jeweiligen Spalte füllen.

    First  Second
0   1.00    5.29
1   2.00    2.00
2   3.00    3.00
3   4.00    4.00
4   5.00    5.00
5   6.00    6.00
6   7.00    5.29
7   4.62    8.00
8   9.00    9.00

Zur Beachtung: Wir runden das Ergebnis auf 2 Dezimalstellen.

Es ist auch möglich, die fehlenden Daten mit Median mithilfe von Easy Imputer zu imputieren.

imputer = sklearn.SimpleImputer(technique='median')
df_imputed = spherical(pd.DataFrame(imputer.fit_transform(df), columns=df.columns),2)

print(df_imputed)

   First  Second
0    1.0     5.0
1    2.0     2.0
2    3.0     3.0
3    4.0     4.0
4    5.0     5.0
5    6.0     6.0
6    7.0     5.0
7    4.5     8.0
8    9.0     9.0

Der Mittelwert- und Median-Imputationsansatz ist einfach, kann jedoch die Datenverteilung verzerren und zu einer Verzerrung einer Datenbeziehung führen.

Es besteht auch die Möglichkeit, einen Okay-NN-Imputer zu verwenden, um die fehlenden Daten mit dem Nearest-Neighbor-Ansatz zu ergänzen.

knn_imputer = sklearn.KNNImputer(n_neighbors=2)
knn_imputed_data = knn_imputer.fit_transform(df)
knn_imputed_df = pd.DataFrame(knn_imputed_data, columns=df.columns)

print(knn_imputed_df)

    First  Second
0    1.0     2.5
1    2.0     2.0
2    3.0     3.0
3    4.0     4.0
4    5.0     5.0
5    6.0     6.0
6    7.0     5.5
7    7.5     8.0
8    9.0     9.0

Der KNN-Imputer würde den Mittelwert oder Median der Werte des Nachbarn aus dem ok nächste Nachbarn.

Schließlich gibt es noch die Methode der iterativen Impute, die auf der Modellierung jedes Options mit fehlenden Werten als Funktion anderer Options basiert. Wie in diesem Artikel erwähnt, handelt es sich dabei um eine experimentelle Funktion, die wir additionally zunächst aktivieren müssen.

iterative_imputer = IterativeImputer(max_iter=10, random_state=0)
iterative_imputed_data = iterative_imputer.fit_transform(df)
iterative_imputed_df = spherical(pd.DataFrame(iterative_imputed_data, columns=df.columns),2)

print(iterative_imputed_df)

    First  Second
0    1.0     1.0
1    2.0     2.0
2    3.0     3.0
3    4.0     4.0
4    5.0     5.0
5    6.0     6.0
6    7.0     7.0
7    8.0     8.0
8    9.0     9.0

Wenn Sie den Imputer richtig verwenden können, kann dies zur Verbesserung Ihres Information-Science-Projekts beitragen.

Weitere Ressourcen

Cornellius Yudha Wijaya ist Information Science Assistant Supervisor und Datenautor. Während seiner Vollzeitbeschäftigung bei Allianz Indonesien teilt er gerne Python- und Datentipps über soziale Medien und in den Medien. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.

Verwenden Sie Fälle und Code, um die neue Klasse zu erkunden, die dabei hilft, Entscheidungsschwellen in scikit-learn anzupassen.

Die Model 1.5 von scikit-learn enthält eine neue Klasse, TunedThresholdClassifierCVwodurch die Optimierung von Entscheidungsschwellen von Scikit-Be taught-Klassifikatoren einfacher wird. Eine Entscheidungsschwelle ist ein Grenzwert, der die von einem maschinellen Lernmodell ausgegebenen vorhergesagten Wahrscheinlichkeiten in diskrete Klassen umwandelt. Die Standardentscheidungsschwelle des .predict() Methode von scikit-learn-Klassifikatoren in einer binären Klassifizierungseinstellung ist 0,5. Obwohl dies ein sinnvoller Standardwert ist, ist es selten die beste Wahl für Klassifizierungsaufgaben.

Dieser Beitrag stellt die Klasse TunedThresholdClassifierCV vor und zeigt, wie sie Entscheidungsschwellen für verschiedene binäre Klassifizierungsaufgaben optimieren kann. Diese neue Klasse wird dazu beitragen, die Lücke zwischen Datenwissenschaftlern, die Modelle erstellen, und Geschäftspartnern zu schließen, die Entscheidungen auf Grundlage der Ergebnisse des Modells treffen. Durch die Feinabstimmung der Entscheidungsschwellen können Datenwissenschaftler die Modellleistung verbessern und sie besser an Geschäftsziele anpassen.

In diesem Beitrag werden die folgenden Situationen behandelt, in denen die Anpassung der Entscheidungsschwellenwerte von Vorteil ist:

1. Maximieren einer Metrik: Verwenden Sie dies, wenn Sie einen Schwellenwert auswählen, der eine Bewertungsmetrik maximiert, wie etwa die F1-Bewertung.
2. Kostensensibles Lernen: Passen Sie den Schwellenwert an, wenn die Kosten für die Fehlklassifizierung eines falsch positiven Ergebnisses nicht den Kosten für die Fehlklassifizierung eines falsch negativen Ergebnisses entsprechen und Sie über eine Kostenschätzung verfügen.
3. Tuning unter Zwängen: Optimieren Sie den Betriebspunkt auf der ROC- oder Präzisions-Recall-Kurve, um bestimmte Leistungseinschränkungen zu erfüllen.

Der in diesem Beitrag verwendete Code und Hyperlinks zu Datensätzen sind verfügbar unter GitHub.

Lass uns anfangen! Importiere zunächst die notwendigen Bibliotheken, lies die Daten und teile Trainings- und Testdaten auf.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.compose import make_column_selector as selector
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
RocCurveDisplay,
f1_score,
make_scorer,
recall_score,
roc_curve,
confusion_matrix,
)
from sklearn.model_selection import TunedThresholdClassifierCV, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
RANDOM_STATE = 26120

Maximieren einer Metrik

Bevor Sie mit dem Modellerstellungsprozess in einem Machine-Studying-Projekt beginnen, müssen Sie unbedingt gemeinsam mit den Beteiligten bestimmen, welche Metrik(en) optimiert werden soll(en). Wenn Sie diese Entscheidung frühzeitig treffen, stellen Sie sicher, dass das Projekt seinen beabsichtigten Zielen entspricht.

Die Verwendung einer Genauigkeitsmetrik in Anwendungsfällen zur Betrugserkennung zur Bewertung der Modellleistung ist nicht superb, da die Daten oft unausgewogen sind und die meisten Transaktionen nicht betrügerisch sind. Der F1-Rating ist das harmonische Mittel aus Präzision und Rückruf und ist eine bessere Metrik für unausgewogene Datensätze wie die Betrugserkennung. Verwenden wir den TunedThresholdClassifierCV Klasse zur Optimierung der Entscheidungsschwelle eines logistischen Regressionsmodells, um den F1-Rating zu maximieren.

Wir verwenden die Kaggle-Datensatz zur Erkennung von Kreditkartenbetrug um die erste State of affairs vorzustellen, in der wir einen Entscheidungsschwellenwert anpassen müssen. Teilen Sie zunächst die Daten in Trainings- und Testsätze auf und erstellen Sie dann eine Scikit-Be taught-Pipeline, um die Daten zu skalieren und ein logistisches Regressionsmodell zu trainieren. Passen Sie die Pipeline an die Trainingsdaten an, damit wir die ursprüngliche Modellleistung mit der optimierten Modellleistung vergleichen können.

creditcard = pd.read_csv("knowledge/creditcard.csv")
y = creditcard("Class")
X = creditcard.drop(columns=("Class"))
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=RANDOM_STATE, stratify=y
)
# Solely Time and Quantity should be scaled
original_fraud_model = make_pipeline(
ColumnTransformer(
(("scaler", StandardScaler(), ("Time", "Quantity"))),
the rest="passthrough",
force_int_remainder_cols=False,
),
LogisticRegression(),
)
original_fraud_model.match(X_train, y_train)

Es ist noch keine Feinabstimmung erfolgt, aber sie kommt im nächsten Codeblock. Die Argumente für TunedThresholdClassifierCV sind ähnlich wie andere CV Klassen in scikit-learn, wie zum Beispiel GridSearchCVDer Benutzer muss lediglich den ursprünglichen Schätzer übergeben und TunedThresholdClassifierCV speichert den Entscheidungsschwellenwert, der die ausgewogene Genauigkeit maximiert (Customary) unter Verwendung einer 5-fach geschichteten Okay-fachen Kreuzvalidierung (Customary). Dieser Schwellenwert wird auch beim Aufrufen von verwendet .predict(). Allerdings kann jede beliebige scikit-learn Metrik (oder aufrufbare Metrik) als scoring Metrik. Zusätzlich kann der Benutzer die bekannte cv Argument zum Anpassen der Kreuzvalidierungsstrategie.

Erstellen Sie die TunedThresholdClassifierCV Instanz und passen Sie das Modell an die Trainingsdaten an. Übergeben Sie das ursprüngliche Modell und setzen Sie die Bewertung auf „f1“. Wir möchten auch festlegen store_cv_results=True um auf die während der Kreuzvalidierung ausgewerteten Schwellenwerte zuzugreifen und diese zu visualisieren.

tuned_fraud_model = TunedThresholdClassifierCV(
original_fraud_model,
scoring="f1",
store_cv_results=True,
)
tuned_fraud_model.match(X_train, y_train)
# common F1 throughout folds
avg_f1_train = tuned_fraud_model.best_score_
# Examine F1 within the take a look at set for the tuned mannequin and the unique mannequin
f1_test = f1_score(y_test, tuned_fraud_model.predict(X_test))
f1_test_original = f1_score(y_test, original_fraud_model.predict(X_test))
print(f"Common F1 on the coaching set: {avg_f1_train:.3f}")
print(f"F1 on the take a look at set: {f1_test:.3f}")
print(f"F1 on the take a look at set (authentic mannequin): {f1_test_original:.3f}")
print(f"Threshold: {tuned_fraud_model.best_threshold_: .3f}")

Common F1 on the coaching set: 0.784
F1 on the take a look at set: 0.796
F1 on the take a look at set (authentic mannequin): 0.733
Threshold:  0.071

Nachdem wir nun den Schwellenwert gefunden haben, der den F1-Rating maximiert, überprüfen Sie tuned_fraud_model.best_score_ um herauszufinden, was der beste durchschnittliche F1-Rating über alle Folds hinweg in der Kreuzvalidierung warfare. Wir können auch sehen, welcher Schwellenwert diese Ergebnisse erzeugt hat, indem wir tuned_fraud_model.best_threshold_Sie können die Metrikwerte über die Entscheidungsschwellenwerte während der Kreuzvalidierung mithilfe der objective_scores_ Und decision_thresholds_ Attribute:

fig, ax = plt.subplots(figsize=(5, 5))
ax.plot(
tuned_fraud_model.cv_results_("thresholds"),
tuned_fraud_model.cv_results_("scores"),
marker="o",
linewidth=1e-3,
markersize=4,
colour="#c0c0c0",
)
ax.plot(
tuned_fraud_model.best_threshold_,
tuned_fraud_model.best_score_,
"^",
markersize=10,
colour="#ff6700",
label=f"Optimum cut-off level = {tuned_fraud_model.best_threshold_:.2f}",
)
ax.plot(
0.5,
f1_test_original,
label="Default threshold: 0.5",
colour="#004e98",
linestyle="--",
marker="X",
markersize=10,
)
ax.legend(fontsize=8, loc="decrease heart")
ax.set_xlabel("Resolution threshold", fontsize=10)
ax.set_ylabel("F1 rating", fontsize=10)
ax.set_title("F1 rating vs. Resolution threshold -- Cross-validation", fontsize=12)

# Verify that the coefficients from the unique mannequin and the tuned mannequin are the identical
assert (tuned_fraud_model.estimator_(-1).coef_ ==
original_fraud_model(-1).coef_).all()

Wir haben dasselbe zugrunde liegende logistische Regressionsmodell verwendet, um zwei verschiedene Entscheidungsschwellenwerte zu bewerten. Die zugrunde liegenden Modelle sind dieselben, was durch die Koeffizientengleichheit in der obigen Assert-Anweisung belegt wird. Optimierung in TunedThresholdClassifierCV wird durch Nachbearbeitungstechniken erreicht, die direkt auf die vom Modell ausgegebenen vorhergesagten Wahrscheinlichkeiten angewendet werden. Es ist jedoch wichtig zu beachten, dass TunedThresholdClassifierCV verwendet standardmäßig die Kreuzvalidierung, um die Entscheidungsschwelle zu finden und eine Überanpassung der Trainingsdaten zu vermeiden.

Kostensensibles Lernen

Kostensensitives Lernen ist eine Artwork maschinellen Lernens, bei dem jeder Artwork von Fehlklassifizierung Kosten zugewiesen werden. Dadurch wird die Modellleistung in Einheiten übersetzt, die die Beteiligten verstehen, z. B. eingesparte Dollarbeträge.

Wir verwenden die TELCO-Kundenabwanderungsdatensatzein binärer Klassifizierungsdatensatz, um den Wert kostensensitiven Lernens zu demonstrieren. Ziel ist es, vorherzusagen, ob ein Kunde abwandern wird oder nicht, basierend auf Merkmalen der demografischen Daten des Kunden, Vertragsdetails und anderen technischen Informationen über das Konto des Kunden. Die Motivation, diesen Datensatz (und einen Teil des Codes) zu verwenden, ist von Dan Beckers Kurs zur Entscheidungsschwellenoptimierung.

knowledge = pd.read_excel("knowledge/Telco_customer_churn.xlsx")
drop_cols = (
"Rely", "Nation", "State", "Lat Lengthy", "Latitude", "Longitude",
"Zip Code", "Churn Worth", "Churn Rating", "CLTV", "Churn Cause"
)
knowledge.drop(columns=drop_cols, inplace=True)
# Preprocess the information
knowledge("Churn Label") = knowledge("Churn Label").map({"Sure": 1, "No": 0})
knowledge.drop(columns=("Complete Fees"), inplace=True)
X_train, X_test, y_train, y_test = train_test_split(
knowledge.drop(columns=("Churn Label")),
knowledge("Churn Label"),
test_size=0.2,
random_state=RANDOM_STATE,
stratify=knowledge("Churn Label"),
)

Richten Sie eine grundlegende Pipeline zur Verarbeitung der Daten und zur Generierung von Vorhersagewahrscheinlichkeiten mit einem Random-Forest-Modell ein. Dies dient als Grundlage für den Vergleich mit TunedThresholdClassifierCV.

preprocessor = ColumnTransformer(
transformers=(("one_hot", OneHotEncoder(),
selector(dtype_include="object"))),
the rest="passthrough",
)
original_churn_model = make_pipeline(
preprocessor, RandomForestClassifier(random_state=RANDOM_STATE)
)
original_churn_model.match(X_train.drop(columns=("customerID")), y_train);

Die Wahl der Vorverarbeitung und des Modelltyps ist für dieses Tutorial nicht wichtig. Das Unternehmen möchte Kunden, bei denen eine Abwanderung vorhergesagt wird, Rabatte anbieten. Während der Zusammenarbeit mit Stakeholdern erfahren Sie, dass es 80 $ kosten würde, einem Kunden, der nicht abwandern wird (ein falsch positives Ergebnis), einen Rabatt zu gewähren. Sie erfahren auch, dass es 200 $ wert ist, einem Kunden, der abgewandert wäre, einen Rabatt anzubieten. Sie können diese Beziehung in einer Kostenmatrix darstellen:

def cost_function(y, y_pred, neg_label, pos_label):
cm = confusion_matrix(y, y_pred, labels=(neg_label, pos_label))
cost_matrix = np.array(((0, -80), (0, 200)))
return np.sum(cm * cost_matrix)
cost_scorer = make_scorer(cost_function, neg_label=0, pos_label=1)

Wir haben die Kostenfunktion auch in einen benutzerdefinierten scikit-learn-Scorer eingebunden. Dieser Scorer wird als scoring Argument im TunedThresholdClassifierCV und um den Gewinn im Testsatz zu bewerten.

tuned_churn_model = TunedThresholdClassifierCV(
original_churn_model,
scoring=cost_scorer,
store_cv_results=True,
)
tuned_churn_model.match(X_train.drop(columns=("CustomerID")), y_train)
# Calculate the revenue on the take a look at set
original_model_profit = cost_scorer(
original_churn_model, X_test.drop(columns=("CustomerID")), y_test
)
tuned_model_profit = cost_scorer(
tuned_churn_model, X_test.drop(columns=("CustomerID")), y_test
)
print(f"Unique mannequin revenue: {original_model_profit}")
print(f"Tuned mannequin revenue: {tuned_model_profit}")

Unique mannequin revenue: 29640
Tuned mannequin revenue: 35600

Der Gewinn ist im optimierten Modell höher als im Unique. Auch hier können wir die objektive Metrik gegenüber den Entscheidungsschwellenwerten darstellen, um die Auswahl der Entscheidungsschwellenwerte für Trainingsdaten während der Kreuzvalidierung zu visualisieren:

fig, ax = plt.subplots(figsize=(5, 5))
ax.plot(
tuned_churn_model.cv_results_("thresholds"),
tuned_churn_model.cv_results_("scores"),
marker="o",
markersize=3,
linewidth=1e-3,
colour="#c0c0c0",
label="Goal rating (utilizing cost-matrix)",
)
ax.plot(
tuned_churn_model.best_threshold_,
tuned_churn_model.best_score_,
"^",
markersize=10,
colour="#ff6700",
label="Optimum cut-off level for the enterprise metric",
)
ax.legend()
ax.set_xlabel("Resolution threshold (likelihood)")
ax.set_ylabel("Goal rating (utilizing cost-matrix)")
ax.set_title("Goal rating as a operate of the choice threshold")

In Wirklichkeit ist es aus geschäftlicher Sicht nicht realistisch, allen Instanzen, die auf die gleiche Weise falsch klassifiziert wurden, statische Kosten zuzuweisen. Es gibt fortgeschrittenere Methoden, um den Schwellenwert anzupassen, indem jeder Instanz im Datensatz ein Gewicht zugewiesen wird. Dies wird behandelt in Beispiel für kostensensitives Lernen von scikit-learn.

Tuning unter Zwängen

Diese Methode wird derzeit nicht in der scikit-learn-Dokumentation behandelt, ist aber ein gängiger Geschäftsfall für Anwendungsfälle der binären Klassifizierung. Die Methode „Tuning unter Einschränkung“ findet eine Entscheidungsschwelle, indem sie einen Punkt auf den ROC- oder Präzisions-Recall-Kurven identifiziert. Der Punkt auf der Kurve ist der Maximalwert einer Achse bei Einschränkung der anderen Achse. Für diese exemplarische Vorgehensweise verwenden wir den Diabetes-Datensatz der Pima-Indianer. Dies ist eine binäre Klassifizierungsaufgabe, um vorherzusagen, ob eine Individual Diabetes hat.

Stellen Sie sich vor, Ihr Modell wird als Screeningtest für eine Bevölkerung mit durchschnittlichem Risiko verwendet, der auf Millionen von Menschen angewendet wird. In den USA gibt es schätzungsweise 38 Millionen Menschen mit Diabetes. Das sind etwa 11,6 % der Bevölkerung. Die Spezifität des Modells sollte additionally hoch sein, damit es Millionen von Menschen nicht falsch diagnostiziert und sie unnötigen Bestätigungstests zuweist. Nehmen wir an, Ihr imaginärer CEO hat mitgeteilt, dass er eine Falsch-Positiv-Charge von mehr als 2 % nicht tolerieren wird. Lassen Sie uns ein Modell erstellen, das dies erreicht, indem wir TunedThresholdClassifierCV.

Für diesen Teil des Tutorials definieren wir eine Einschränkungsfunktion, die verwendet wird, um die maximale True-Optimistic-Charge bei einer False-Optimistic-Charge von 2 % zu ermitteln.

def max_tpr_at_tnr_constraint_score(y_true, y_pred, max_tnr=0.5):
fpr, tpr, thresholds = roc_curve(y_true, y_pred, drop_intermediate=False)
tnr = 1 - fpr
tpr_at_tnr_constraint = tpr(tnr >= max_tnr).max()
return tpr_at_tnr_constraint
max_tpr_at_tnr_scorer = make_scorer(
max_tpr_at_tnr_constraint_score, max_tnr=0.98)
knowledge = pd.read_csv("knowledge/diabetes.csv")
X_train, X_test, y_train, y_test = train_test_split(
knowledge.drop(columns=("Final result")),
knowledge("Final result"),
stratify=knowledge("Final result"),
test_size=0.2,
random_state=RANDOM_STATE,
)

Erstellen Sie zwei Modelle, ein logistisches Regressionsmodell, das als Basismodell dient, und das andere TunedThresholdClassifierCV Dies wird das Foundation-Logistik-Regressionsmodell umschließen, um das vom CEO festgelegte Ziel zu erreichen. Im abgestimmten Modell setzen Sie scoring=max_tpr_at_tnr_scorer. Auch hier ist die Wahl des Modells und der Vorverarbeitung für dieses Tutorial nicht wichtig.

# A baseline mannequin
original_model = make_pipeline(
StandardScaler(), LogisticRegression(random_state=RANDOM_STATE)
)
original_model.match(X_train, y_train)
# A tuned mannequin
tuned_model = TunedThresholdClassifierCV(
original_model,
thresholds=np.linspace(0, 1, 150),
scoring=max_tpr_at_tnr_scorer,
store_cv_results=True,
cv=8,
random_state=RANDOM_STATE,
)
tuned_model.match(X_train, y_train)

Vergleichen Sie die Differenz zwischen dem Standardentscheidungsschwellenwert von 0,5 der Scikit-Be taught-Schätzer und dem Wert, der mithilfe des Tuning-under-Constraint-Ansatzes auf der ROC-Kurve ermittelt wurde.

# Get the fpr and tpr of the unique mannequin
original_model_proba = original_model.predict_proba(X_test)(:, 1)
fpr, tpr, thresholds = roc_curve(y_test, original_model_proba)
closest_threshold_to_05 = (np.abs(thresholds - 0.5)).argmin()
fpr_orig = fpr(closest_threshold_to_05)
tpr_orig = tpr(closest_threshold_to_05)
# Get the tnr and tpr of the tuned mannequin
max_tpr = tuned_model.best_score_
constrained_tnr = 0.98
# Plot the ROC curve and examine the default threshold to the tuned threshold
fig, ax = plt.subplots(figsize=(5, 5))
# Be aware that this would be the similar for each fashions
disp = RocCurveDisplay.from_estimator(
original_model,
X_test,
y_test,
identify="Logistic Regression",
colour="#c0c0c0",
linewidth=2,
ax=ax,
)
disp.ax_.plot(
1 - constrained_tnr,
max_tpr,
label=f"Tuned threshold: {tuned_model.best_threshold_:.2f}",
colour="#ff6700",
linestyle="--",
marker="o",
markersize=11,
)
disp.ax_.plot(
fpr_orig,
tpr_orig,
label="Default threshold: 0.5",
colour="#004e98",
linestyle="--",
marker="X",
markersize=11,
)
disp.ax_.set_ylabel("True Optimistic Charge", fontsize=8)
disp.ax_.set_xlabel("False Optimistic Charge", fontsize=8)
disp.ax_.tick_params(labelsize=8)
disp.ax_.legend(fontsize=7)

Die Methode „Tuned Underneath Constraint“ ergab einen Schwellenwert von 0,80, was bei der Kreuzvalidierung der Trainingsdaten zu einer durchschnittlichen Sensitivität von 19,2 % führte. Vergleichen Sie Sensitivität und Spezifität, um zu sehen, wie sich der Schwellenwert im Testsatz verhält. Hat das Modell die Spezifitätsanforderung des CEO im Testsatz erfüllt?

# Common sensitivity and specificity on the coaching set
avg_sensitivity_train = tuned_model.best_score_
# Name predict from tuned_model to calculate sensitivity and specificity on the take a look at set
specificity_test = recall_score(
y_test, tuned_model.predict(X_test), pos_label=0)
sensitivity_test = recall_score(y_test, tuned_model.predict(X_test))
print(f"Common sensitivity on the coaching set: {avg_sensitivity_train:.3f}")
print(f"Sensitivity on the take a look at set: {sensitivity_test:.3f}")
print(f"Specificity on the take a look at set: {specificity_test:.3f}")

Common sensitivity on the coaching set: 0.192
Sensitivity on the take a look at set: 0.148
Specificity on the take a look at set: 0.990

Abschluss

Das neue TunedThresholdClassifierCV Der Kurs ist ein leistungsstarkes Device, mit dem Sie ein besserer Datenwissenschaftler werden können, indem Sie mit Unternehmensleitern teilen, wie Sie zu einer Entscheidungsschwelle gekommen sind. Sie haben gelernt, wie Sie das neue scikit-learn verwenden TunedThresholdClassifierCV Klasse, um eine Metrik zu maximieren, kostensensitives Lernen durchzuführen und eine Metrik unter Einschränkungen zu optimieren. Dieses Tutorial sollte weder umfassend noch fortgeschritten sein. Ich wollte die neue Funktion vorstellen und ihre Leistungsfähigkeit und Flexibilität bei der Lösung binärer Klassifizierungsprobleme hervorheben. Ausführliche Anwendungsbeispiele finden Sie in der scikit-learn-Dokumentation, im Benutzerhandbuch und in den Beispielen.

Ein großes Dankeschön an Guillaume Lemaître für seine Arbeit an diesem Function.

Danke fürs Lesen. Viel Spaß beim Tunen.

Datenlizenzen:
Kreditkartenbetrug: DbCL
Diabetes der Pima-Indianer: CC0
Telko-Abwanderung: gewerbliche Nutzung OK