Erstellen Sie Pipelines in Python

1. Erstellen Sie eine Pipeline in Python für ein benutzerdefiniertes Dataset
2. Erstellen Sie eine Pipeline in Python für einen Scikit-Learn-Datensatz

In diesem Artikel wird das Erstellen einer Python-Pipeline für maschinelles Lernen für Sklearn-Datasets und benutzerdefinierte Datasets demonstriert.

Erstellen Sie eine Pipeline in Python für ein benutzerdefiniertes Dataset

Wir benötigen zwei Importpakete, um eine Python-Pipeline zu erstellen, Pandas, um Datenrahmen zu generieren, und sklearn für Pipelines. Daneben setzen wir zwei weitere Unterpakete ein, Pipeline und lineare Regression.

Nachfolgend finden Sie eine Liste aller verwendeten Pakete.

import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression

Bilden Sie einen Datensatz mit Werten einer Gleichung

Dieses Programm beabsichtigt, eine Pipeline zu erstellen, die die Folgewerte einer Gleichung vorhersagt, wenn genügend Folgewerte das Modell trainieren.

Die hier verwendete Gleichung lautet:

c = a + 3*\sqrt[3]{b}

Wir erstellen einen Pandas-Datensatz mit den Werten der linearen Gleichung.

df = pd.DataFrame(columns=["col1", "col2", "col3"], val=[[15, 8, 21], [16, 27, 25]])

Teilen Sie Daten in Trainings- und Testsätze auf

Jedes maschinelle Lernmodell erfordert die Aufteilung der Daten in zwei ungleiche Hälften. Nach der Trennung verwenden wir diese beiden Sätze, um das Modell zu trainieren und zu testen.

Der wichtigere Teil wird zum Trainieren und der andere zum Testen des Modells verwendet.

Im folgenden Codeausschnitt werden die ersten 8 Werte zum Trainieren des Modells und der Rest zum Testen verwendet.

learn = df.iloc[:8]
evaluate = df.iloc[8:]

Die scikit-learn-Pipeline funktioniert, indem sie Werte in die Pipeline nimmt und dann die Ergebnisse ausgibt. Werte werden über zwei Eingabevariablen bereitgestellt - X und y.

In der verwendeten Gleichung ist c eine Funktion von a und b. Um die Pipeline also an die Werte im linearen Regressionsmodell anzupassen, übertragen wir a-, b-Werte in X und c-Werte in y.

Es ist wichtig zu beachten, dass X und y Variablen zum Lernen und Auswerten sind. Also übergeben wir die Variablen a und b an die Train-Funktion und weisen die Variable c der Test-Funktion zu.

learn_X = learn.drop("col3", axis=1)
learn_y = learn.col3

evaluate_X = evaluate.drop("col3", axis=1)
evaluate_y = evaluate.col3

Im obigen Code entfernt die Pandas-Funktion drop() die Werte von Spalte c, wenn Werte in die Variable learn_X eingegeben werden. In der Variable learn_y werden Werte der Spalte c übertragen.

Achse = 1 steht für die Spalte, während ein 0-Wert Zeilen darstellt.

Erstellen Sie eine Python-Pipeline und passen Sie Werte darin an

Wir erstellen eine Pipeline in Python mit der Pipeline-Funktion. Wir müssen es vor der Verwendung in einer Variablen speichern.

Hier wird zu diesem Zweck eine Variable namens rock deklariert.

Innerhalb der Pipeline müssen wir ihren Namen und das zu verwendende Modell angeben - ('Model for Linear Regression', LinearRegression()).

rock = Pipeline(steps=[("Model for Linear Regression", LinearRegression())])

Sobald die Schritte zum Erstellen der Pipeline in Python abgeschlossen sind, muss sie mit den Lernwerten angepasst werden, damit das lineare Modell die Pipeline mit den bereitgestellten Werten trainieren kann.

rock.fit(learn_X, learn_y)

Nachdem die Pipeline trainiert wurde, sagt die Variable evaluate_X die folgenden Werte durch die Funktion pipe1.predict() voraus.

Die vorhergesagten Werte werden in einer neuen Variablen evalve gespeichert und gedruckt.

evalve = rock.predict(evaluate_X)
print(f"\n{evalve}")

Lassen Sie uns alles zusammenfügen, um zu beobachten, wie eine Pipeline erstellt wird und wie sie funktioniert.

import pandas as pd

# import warnings
# warnings.filterwarnings('ignore')

from sklearn.pipeline import Pipeline

from sklearn.linear_model import LinearRegression

df = pd.DataFrame(
    columns=["col1", "col2", "col3"],
    data=[
        [15, 8, 21],
        [16, 27, 25],
        [17, 64, 29],
        [18, 125, 33],
        [19, 216, 37],
        [20, 343, 41],
        [21, 512, 45],
        [22, 729, 49],
        [23, 1000, 53],
        [24, 1331, 57],
        [25, 1728, 61],
        [26, 2197, 65],
    ],
)

learn = df.iloc[:8]
evaluate = df.iloc[8:]

learn_X = learn.drop("col3", axis=1)
learn_y = learn.col3

evaluate_X = evaluate.drop("col3", axis=1)
evaluate_y = evaluate.col3

print("\n step: Here, the pipeline is formed")
rock = Pipeline(steps=[("Model for Linear Regression", LinearRegression())])
print("\n Step: Fitting the data inside")
rock.fit(learn_X, learn_y)
print("\n Searching for outcomes after evaluation")
evalve = rock.predict(evaluate_X)
print(f"\n{evalve}")

Ausgabe:

"C:/Users/Win 10/pipe.py"

 step: Here, the pipeline is formed

 Step: Fitting the data inside

 Searching for outcomes after evaluation

[53. 57. 61. 65.]

Process finished with exit code 0

Wie wir sehen, sagt die Pipeline die genauen Werte voraus.

Erstellen Sie eine Pipeline in Python für einen Scikit-Learn-Datensatz

Dieses Beispiel zeigt, wie Sie in Python eine Pipeline für ein Scikit-Lern-Dataset erstellen. Das Ausführen von Pipeline-Vorgängen für große Datasets unterscheidet sich ein wenig von kleinen.

Die Pipeline muss zusätzliche Modelle verwenden, um die Daten zu bereinigen und zu filtern, wenn es um große Datasets geht.

Nachfolgend finden Sie die Importpakete, die wir benötigen.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn import datasets

Es wird ein Datensatz von sklearn verwendet. Es hat mehrere Spalten und Werte, aber wir werden speziell zwei Spalten verwenden – Daten und Ziel.

Laden Sie den Datensatz und teilen Sie ihn in Trainings- und Testsätze auf

Wir laden den Datensatz in die Variable bc und speichern die einzelnen Spaltenwerte in den Variablen X und y.

bc = datasets.load_breast_cancer()
X = bc.data
y = bc.target

Sobald der Datensatz geladen ist, definieren wir die Lern- und Auswertungsvariablen. Der Datensatz muss in Trainings- und Testsätze aufgeteilt werden.

a_learn, a_evaluate, b_learn, b_evaluate = train_test_split(
    X, y, test_size=0.40, random_state=1, stratify=y
)

Wir teilen den Datensatz in 4 primäre Variablen auf – X_learn, X_evaluate, y_learn und y_evaluate. Im Gegensatz zum vorherigen Programm erfolgt hier die Zuordnung über die Funktion train_test_split().

test_size=0.4 weist die Funktion an, 40 % des Datensatzes für Tests zu reservieren, und die restliche Hälfte wird für das Training aufbewahrt.

random_state=1 stellt sicher, dass die Aufteilung des Datensatzes gleichmäßig erfolgt, sodass die Vorhersage bei jeder Ausführung der Funktion dieselbe Ausgabe liefert. random_state=0 liefert jedes Mal, wenn die Funktion ausgeführt wird, ein anderes Ergebnis.

stratify=y stellt sicher, dass die gleiche Datengröße in der Stichprobengröße verwendet wird, wie sie zum Stratifizieren von Parametern bereitgestellt wird. Wenn es 15 % 1er und 85 % 0er gibt, stellt stratify sicher, dass das System 15 % 1er und 85 % 0er in jeder zufälligen Teilung hat.

Erstellen Sie eine Python-Pipeline und passen Sie Werte darin an

pipeline = make_pipeline(StandardScaler(),
RandomForestClassifier (n_estimators=10, max_features=5, max_depth=2, random_state=1))

Woher:

• make_pipeline() ist eine Scikit-Learn-Funktion zum Erstellen von Pipelines.
• Standard scaler() entfernt die Werte von einem Mittelwert und verteilt sie auf seine Einheitswerte.
• RandomForestClassifier() ist ein Entscheidungsfindungsmodell, das einige Stichprobenwerte aus dem Datensatz nimmt, mit jedem Stichprobenwert einen Entscheidungsbaum erstellt und dann Ergebnisse aus jedem Entscheidungsbaum vorhersagt. Dann hat das Modell die vorhergesagten Ergebnisse auf ihre Genauigkeit bewertet, und das Ergebnis mit den meisten Stimmen wird als endgültige Vorhersage ausgewählt.
• n_estimators geben die Anzahl der Entscheidungsbäume an, die vor der Abstimmung erstellt werden sollen.
• max_features entscheidet, wie viele zufällige Zustände gebildet werden, wenn die Teilung eines Knotens ausgeführt wird.
• max_depth gibt an, wie tief der Knoten des Baums geht.

Nach dem Erstellen der Pipeline werden die Werte angepasst und das Ergebnis vorhergesagt.

pipeline.fit(a_learn, b_learn)
y_pred = pipeline.predict(a_evaluate)

Schauen wir uns das komplette Programm an.

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline
from sklearn import datasets

bc = datasets.load_breast_cancer()
X = bc.data
y = bc.target

a_learn, a_evaluate, b_learn, b_evaluate = train_test_split(
    X, y, test_size=0.40, random_state=1, stratify=y
)

# Create the pipeline

pipeline = make_pipeline(
    StandardScaler(),
    RandomForestClassifier(
        n_estimators=10, max_features=5, max_depth=2, random_state=1
    ),
)


pipeline.fit(a_learn, b_learn)

y_pred = pipeline.predict(a_evaluate)

print(y_pred)

Ausgabe:

"C:/Users/Win 10/test_cleaned.py"
[0 0 0 1 1 1 1 0 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 0 1 0 0 0 1 1 1 1 1 1 1 1
 1 1 0 1 1 1 1 0 1 1 0 0 0 1 1 1 0 1 1 1 0 1 1 1 1 1 1 0 0 1 1 1 1 0 1 1 1
 1 1 0 1 1 0 1 0 1 1 1 1 0 0 0 1 0 0 1 0 1 1 1 0 1 1 0 1 0 1 1 1 1 0 1 1 1
 1 1 0 0 1 1 0 0 1 0 0 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 1 0 0 1 1 1 1 1 0 1 1
 0 0 1 0 1 0 0 1 1 0 1 0 0 0 1 0 1 1 1 0 0 1 0 1 1 1 1 0 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 1 0 1 0 0 1 1 0 1 1
 1 1 1 1 1 0]

Process finished with exit code 0