Dieses Tutorial umfasst zwei Hauptabschnitte. First, you will create a machine learning model using a template within JupyterLab Notebook. Next, you will exercise the notebook to recipe workflow within JupyterLab to create a recipe within Data Science Workspace.
Creating a recipe from scratch can be done within Data Science Workspace. Navigieren Sie zum Beginn zu Adobe Experience Platform und klicken Sie auf der linken Seite auf die Registerkarte Notebooks . Erstellen Sie ein neues Notebook, indem Sie die Vorlage Rezept-Builder aus dem JupyterLab Launcher.
The Recipe Builder notebook allows you to run training and scoring runs inside the notebook. So können Sie zwischen laufenden Experimenten für Trainings- und Scoring-Daten flexibel Änderungen an den train()
- und score()
-Methoden vorzunehmen. Once you are happy with the outputs of the training and scoring, you can create a recipe to be used in Data Science Workspace using the notebook to recipe functionality built in to the Recipe Builder notebook.
Das Recipe Builder-Notebook erlaubt ein Arbeiten mit allen Dateiformaten, die Funktion „Rezept erstellen“ unterstützt derzeit jedoch nur Python.
Wenn Sie vom Starter auf das Rezept Builder-Notebook klicken, wird das Notebook in der Registerkarte geöffnet. Die im Notebook verwendete Vorlage ist das Rezept „Python Retail Sales Forecasting“, das auch in diesem öffentlichen Repository zu finden ist.
You will notice that in the toolbar there are three additional actions namely – Train, Score, and Create Recipe. These icons only appear in the Recipe Builder notebook. Weiterführende Informationen zu diesen Aktionen erhalten Sie im Abschnitt Training und Scoring, nachdem Sie Ihr Rezept im Notebook erstellt haben.
Um Änderungen an den Rezeptdateien vorzunehmen, navigieren Sie in Jupyter zu der Zelle, die dem Dateipfad entspricht. Wenn Sie zum Beispiel Änderungen an evaluator.py
vornehmen möchten, suchen Sie nach %%writefile demo-recipe/evaluator.py
.
Nehmen Sie die erforderlichen Änderungen in der Zelle vor und führen Sie die Zelle dann einfach aus. Der %%writefile filename.py
-Befehl schreibt den Inhalt der Zelle in die Datei filename.py
. Sie müssen die Zelle für jede Datei mit Änderungen manuell ausführen.
Sie sollten die Zellen gegebenenfalls manuell ausführen.
Now that you know the basics for the JupyterLab notebook environment, you can begin looking at the files that make up a machine learning model recipe. Die Dateien, über die wir reden werden, sind hier dargestellt:
Die Anforderungsdatei dient zum Deklarieren zusätzlicher Bibliotheken, die Sie im Rezept verwenden möchten. Sie können die Versionsnummer angeben, wenn eine Abhängigkeit vorliegt. To look for additional libraries, visit anaconda.org. Informationen zum Formatieren der Anforderungsdatei finden Sie unter Conda. Die Liste der bereits verwendeten Hauptbibliotheken umfasst:
python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python
Bibliotheken oder spezifische Versionen, die Sie hinzufügen, sind möglicherweise nicht mit den oben genannten Bibliotheken kompatibel. Wenn Sie sich außerdem dafür entscheiden, eine Umgebung manuell zu erstellen, darf das name
Feld nicht überschrieben werden.
Mit den Konfigurationsdateien training.conf
und scoring.conf
werden die Datensätze angegeben, die Sie für das Training und Scoring sowie das Hinzufügen von Hyperparametern nutzen möchten. Es gibt separate Konfigurationen für Training und Scoring.
Benutzer müssen die folgenden Variablen ausfüllen, bevor sie ein Training und Scoring durchführen können:
trainingDataSetId
ACP_DSW_TRAINING_XDM_SCHEMA
scoringDataSetId
ACP_DSW_SCORING_RESULTS_XDM_SCHEMA
scoringResultsDataSetId
Um die Datensatz- und Schemakennungen zu suchen, rufen Sie in Notebooks in der linken Navigationsleiste (unter dem Ordnersymbol) die Registerkarte „Daten“ auf.
Dieselben Daten finden Sie in Adobe Experience Platform unter den Registerkarten Schema und Datensätze.
Standardmäßig sind für den Zugriff auf Daten die folgenden Konfigurationsparameter festgelegt:
ML_FRAMEWORK_IMS_USER_CLIENT_ID
ML_FRAMEWORK_IMS_TOKEN
ML_FRAMEWORK_IMS_ML_TOKEN
ML_FRAMEWORK_IMS_TENANT_ID
Der Zweck des Ladeprogramms für Trainings-Daten besteht darin, Daten zu instanziieren, die zum Erstellen des maschinellen Lernmodells verwendet werden. In der Regel gibt es zwei Aufgaben, die das Ladeprogramm für Trainings-Daten erledigen wird:
Die folgenden beiden Abschnitte liefern Informationen über das Laden und Vorbereiten von Daten.
In diesem Schritt wird der pandas-Dataframe verwendet. Data can be loaded from files in Adobe Experience Platform using either the Platform SDK (platform_sdk
), or from external sources using pandas' read_csv()
or read_json()
functions.
Im Recipe Builder-Notebook werden Daten über das Datenladeprogramm platform_sdk
geladen.
Eine ausführliche Anleitung zur Verwendung des Datenladeprogramms platform_sdk
finden Sie im Handbuch zum Platform-SDK. Dieses Tutorial enthält Informationen zur Build-Authentifizierung, zum grundlegenden Lesen von Daten sowie zum grundlegenden Schreiben von Daten.
Dieser Abschnitt veranschaulicht, wie Sie eine JSON- oder CSV-Datei in ein pandas-Objekt importieren können. Die offizielle Dokumentation der pandas-Bibliothek finden Sie hier:
Zunächst finden Sie hier ein Beispiel für den Import einer CSV-Datei. Das data
-Argument ist der Pfad zur CSV-Datei. Diese Variable wurde aus den configProperties
im vorherigen Abschnitt importiert.
df = pd.read_csv(data)
Sie können auch aus einer JSON-Datei importieren. Das data
-Argument ist der Pfad zur CSV-Datei. Diese Variable wurde aus den configProperties
im vorherigen Abschnitt importiert.
df = pd.read_json(data)
Jetzt befinden sich Ihre Daten im Dataframe-Objekt und können im nächsten Abschnitt analysiert und bearbeitet werden.
Sie können Daten mit dem Plattform-SDK laden. Die Bibliothek kann oben auf der Seite importiert werden, indem die folgende Zeile eingefügt wird:
from platform_sdk.dataset_reader import DatasetReader
Anschließend nutzen wir die load()
-Methode, um den Trainings-Datensatz aus der trainingDataSetId
wie in unserer Konfiguration (recipe.conf
) festgelegt zu erfassen.
def load(config_properties):
print("Training Data Load Start")
#########################################
# Load Data
#########################################
client_context = get_client_context(config_properties)
dataset_reader = DatasetReader(client_context, config_properties['trainingDataSetId'])
timeframe = config_properties.get("timeframe")
tenant_id = config_properties.get("tenant_id")
As mentioned in the Configuration File section, the following configuration parameters are set for you when you access data from Experience Platform using client_context
:
ML_FRAMEWORK_IMS_USER_CLIENT_ID
ML_FRAMEWORK_IMS_TOKEN
ML_FRAMEWORK_IMS_ML_TOKEN
ML_FRAMEWORK_IMS_TENANT_ID
Jetzt, da Sie über Ihre Daten verfügen, können Sie mit der Datenvorbereitung und Funktionsentwicklung beginnen.
Nach dem Laden werden die Daten vorbereitet und auf die Datensätze train
und val
aufgeteilt. Betrachten Sie folgenden Beispiel-Code:
#########################################
# Data Preparation/Feature Engineering
#########################################
dataframe.date = pd.to_datetime(dataframe.date)
dataframe['week'] = dataframe.date.dt.week
dataframe['year'] = dataframe.date.dt.year
dataframe = pd.concat([dataframe, pd.get_dummies(dataframe['storeType'])], axis=1)
dataframe.drop('storeType', axis=1, inplace=True)
dataframe['isHoliday'] = dataframe['isHoliday'].astype(int)
dataframe['weeklySalesAhead'] = dataframe.shift(-45)['weeklySales']
dataframe['weeklySalesLag'] = dataframe.shift(45)['weeklySales']
dataframe['weeklySalesDiff'] = (dataframe['weeklySales'] - dataframe['weeklySalesLag']) / dataframe['weeklySalesLag']
dataframe.dropna(0, inplace=True)
dataframe = dataframe.set_index(dataframe.date)
dataframe.drop('date', axis=1, inplace=True)
In diesem Beispiel werden auf den ursprünglichen Datensatz fünf Aktionen angewendet:
week
und year
storeType
in eine IndikatorvariableisHoliday
in eine numerische VariableweeklySales
für zukünftige und vorherige Umsatzwertetrain
und val
First, week
and year
columns are created and the original date
column converted to Python datetime. Wochen- und Jahreswerte werden aus dem datetime-Objekt extrahiert.
Dann wird storeType
in drei Spalten konvertiert, die die drei verschiedenen Speichertypen (A
, B
und C
) darstellen. Jede wird einen booleschen Wert für den Status enthalten, wobei storeType
„true“ lautet. Die storeType
-Spalte wird verworfen.
Gleichermaßen ändert weeklySales
den booleschen Wert isHoliday
in eine numerische Darstellung (eins oder null).
Diese Daten werden auf die Datensätze train
und val
aufgeteilt.
Die load()
-Funktion sollte mit den Datensätzen train
und val
als Ausgabe abgeschlossen werden.
Das Laden von Daten zum Scoring ähnelt dem Laden von Trainings-Daten in der split()
-Funktion. Wir verwenden das Data Access-SDK, um Daten aus der scoringDataSetId
in unserer recipe.conf
-Datei zu laden.
def load(config_properties):
print("Scoring Data Load Start")
#########################################
# Load Data
#########################################
client_context = get_client_context(config_properties)
dataset_reader = DatasetReader(client_context, config_properties['scoringDataSetId'])
timeframe = config_properties.get("timeframe")
tenant_id = config_properties.get("tenant_id")
Nach dem Laden der Daten erfolgen die Datenvorbereitung und Funktionsentwicklung.
#########################################
# Data Preparation/Feature Engineering
#########################################
if '_id' in dataframe.columns:
#Rename columns to strip tenantId
dataframe = dataframe.rename(columns = lambda x : str(x)[str(x).find('.')+1:])
#Drop id, eventType and timestamp
dataframe.drop(['_id', 'eventType', 'timestamp'], axis=1, inplace=True)
dataframe.date = pd.to_datetime(dataframe.date)
dataframe['week'] = dataframe.date.dt.week
dataframe['year'] = dataframe.date.dt.year
dataframe = pd.concat([dataframe, pd.get_dummies(dataframe['storeType'])], axis=1)
dataframe.drop('storeType', axis=1, inplace=True)
dataframe['isHoliday'] = dataframe['isHoliday'].astype(int)
dataframe['weeklySalesAhead'] = dataframe.shift(-45)['weeklySales']
dataframe['weeklySalesLag'] = dataframe.shift(45)['weeklySales']
dataframe['weeklySalesDiff'] = (dataframe['weeklySales'] - dataframe['weeklySalesLag']) / dataframe['weeklySalesLag']
dataframe.dropna(0, inplace=True)
dataframe = dataframe.set_index(dataframe.date)
dataframe.drop('date', axis=1, inplace=True)
print("Scoring Data Load Finish")
return dataframe
Da der Zweck unseres Modells darin besteht, zukünftige Wochenumsätze vorherzusagen, müssen Sie einen Scoring-Datensatz erstellen, um zu bewerten, wie gut die Prognosen des Modells funktionieren.
Dieses Recipe Builder-Notebook erlaubt das, indem unser Wochenumsatz (weeklySales) um 7 Tage nach vorne versetzt wird. Beachten Sie, dass es wöchentliche Messwerte für 45 Filialen gibt, sodass Sie die weeklySales
-Werte in einer neuen Spalte namens weeklySalesAhead
um 45 Datensätze nach vorne verschieben können.
df['weeklySalesAhead'] = df.shift(-45)['weeklySales']
Auf ähnliche Weise können Sie eine Spalte weeklySalesLag
erstellen, indem Sie eine Verschiebung um 45 nach hinten vornehmen. So können Sie auch den Unterschied bei Wochenumsätzen berechnen und in der Spalte weeklySalesDiff
speichern.
df['weeklySalesLag'] = df.shift(45)['weeklySales']
df['weeklySalesDiff'] = (df['weeklySales'] - df['weeklySalesLag']) / df['weeklySalesLag']
Da Sie die weeklySales
-Datenpunkte um 45 Datensätze nach vorne und 45 Datensätze nach hinten versetzen, um neue Spalten zu erstellen, weisen die ersten und letzten 45 Datenpunkte NaN-Werte auf. Sie können diese Punkte aus unserem Datensatz entfernen, indem Sie die df.dropna()
-Funktion verwenden, um alle Zeilen mit NaN-Werten zu entfernen.
df.dropna(0, inplace=True)
Die load()
-Funktion in Ihrem Ladeprogramm für Scoring-Daten sollte mit dem Scoring-Datensatz als Ausgabe abschließen.
Die pipeline.py
-Datei enthält Logiken für Training und Scoring.
Der Zweck von Training besteht darin, mithilfe von Funktionen und Bezeichnungen in Ihrem Trainings-Datensatz ein Modell zu erstellen.
Funktionen bezieht sich auf die Eingabevariable, die vom maschinellen Lernmodell zur Vorhersage der Bezeichnungen verwendet wird.
Die train()
-Funktion sollte das Trainings-Modell enthalten und das trainierte Modell zurückgeben. Beispiele für verschiedene Modelle finden Sie in der Dokumentation Benutzerhandbuch zu scikit-learn.
Nach der Auswahl Ihres Trainings-Modells passen Sie Ihren x- und y-Trainings-Datensatz an das Modell an und die Funktion gibt das trainierte Modell zurück. Folgendes Beispiel veranschaulicht zeigt dies:
def train(configProperties, data):
print("Train Start")
#########################################
# Extract fields from configProperties
#########################################
learning_rate = float(configProperties['learning_rate'])
n_estimators = int(configProperties['n_estimators'])
max_depth = int(configProperties['max_depth'])
#########################################
# Fit model
#########################################
X_train = data.drop('weeklySalesAhead', axis=1).values
y_train = data['weeklySalesAhead'].values
seed = 1234
model = GradientBoostingRegressor(learning_rate=learning_rate,
n_estimators=n_estimators,
max_depth=max_depth,
random_state=seed)
model.fit(X_train, y_train)
print("Train Complete")
return model
Beachten Sie, dass je nach Anwendung Argumente in Ihrer GradientBoostingRegressor()
-Funktion vorhanden sind. xTrainingDataset
sollte Ihre für das Training genutzten Funktionen enthalten, während yTrainingDataset
die Bezeichnungen beinhalten sollte.
Die score()
-Funktion sollte den Scoring-Algorithmus enthalten und einen Messwert zurückgeben, der angibt, wie gut das Modell funktioniert. Die score()
-Funktion nutzt die Bezeichnungen des Scoring-Datensatzes und das trainierte Modell, um eine Reihe von prognostizierten Funktionen zu generieren. Die prognostizierten Werte werden dann mit den tatsächlichen Funktionen im Scoring-Datensatz abgeglichen. In diesem Beispiel verwendet die Funktion score()
das trainierte Modell, um Funktionen mithilfe der Bezeichnungen aus dem Scoring-Datensatz vorherzusagen. Die prognostizierten Funktionen werden zurückgegeben.
def score(configProperties, data, model):
print("Score Start")
X_test = data.drop('weeklySalesAhead', axis=1).values
y_test = data['weeklySalesAhead'].values
y_pred = model.predict(X_test)
data['prediction'] = y_pred
data = data[['store', 'prediction']].reset_index()
data['date'] = data['date'].astype(str)
print("Score Complete")
return data
Die evaluator.py
-Datei enthält eine Logik dafür, wie Sie Ihr trainiertes Rezept bewerten und die Trainings-Daten aufteilen wollen. Für das Einzelhandelsbeispiel wird die Logik zum Laden und Vorbereiten der Trainings-Daten einbezogen. Wir sehen uns die beiden folgenden Abschnitte an.
Die Vorbereitung der Daten für das Training erfordert eine Aufteilung des Datensatzes, damit er sich für Training und Tests verwenden lässt. Diese val
-Daten dienen implizit dazu, das Modell nach dem Trainieren zu bewerten. Dieser Prozess erfolgt getrennt vom Scoring.
Dieser Abschnitt veranschaulicht die split()
-Funktion, die zuerst Daten in das Notebook lädt und dann bereinigt, indem nicht verwandte Spalten im Datensatz entfernt werden. Nun können Sie mit der Funktionsentwicklung fortfahren; sie erlaubt die Erstellung zusätzlicher relevanter Funktionen aus vorhandenen Rohfunktionen in den Daten. Ein Beispiel für diesen Vorgang sowie eine entsprechende Erklärung finden Sie im Folgenden.
Die split()
-Funktion ist unten dargestellt. Der im Argument bereitgestellte Dataframe wird in die zurückzugebenden Variablen train
und val
aufgeteilt.
def split(self, configProperties={}, dataframe=None):
train_start = '2010-02-12'
train_end = '2012-01-27'
val_start = '2012-02-03'
train = dataframe[train_start:train_end]
val = dataframe[val_start:]
return train, val
Die evaluate()
-Funktion wird ausgeführt, nachdem das Modell trainiert wurde, und gibt einen Messwert zurück, der angibt, wie gut das Modell funktioniert. Die evaluate()
-Funktion nutzt die Testdatensatzbezeichnungen und das trainierte Modell, um eine Reihe von Funktionen vorherzusagen. Die prognostizierten Werte werden dann mit den tatsächlichen Funktionen im Testdatensatz abgeglichen. Häufige Scoring-Algorithmen sind:
Die evaluate()
-Funktion im Beispiel für Einzelhandelsumsätze ist unten dargestellt:
def evaluate(self, data=[], model={}, configProperties={}):
print ("Evaluation evaluate triggered")
val = data.drop('weeklySalesAhead', axis=1)
y_pred = model.predict(val)
y_actual = data['weeklySalesAhead'].values
mape = np.mean(np.abs((y_actual - y_pred) / y_actual))
mae = np.mean(np.abs(y_actual - y_pred))
rmse = np.sqrt(np.mean((y_actual - y_pred) ** 2))
metric = [{"name": "MAPE", "value": mape, "valueType": "double"},
{"name": "MAE", "value": mae, "valueType": "double"},
{"name": "RMSE", "value": rmse, "valueType": "double"}]
return metric
Beachten Sie, dass die Funktion ein metric
-Objekt zurückgibt, das eine Gruppe von Bewertungsmetriken enthält. Anhand dieser Metriken lässt sich bewerten, wie gut das trainierte Modell funktioniert.
Die datasaver.py
-Datei enthält die save()
-Funktion zum Speichern Ihrer Prognose beim Testen des Scoring. The save()
function will take your prediction and using Experience Platform Catalog APIs, write the data to the scoringResultsDataSetId
you specified in your scoring.conf
file.
Das Beispiel, das im Rezept für Einzelhandelsumsätze verwendet wird, ist hier dargestellt. Beachten Sie den Einsatz der DataSetWriter
-Bibliothek zum Schreiben von Daten in Platform:
from data_access_sdk_python.writer import DataSetWriter
def save(configProperties, prediction):
print("Datasaver Start")
print("Setting up Writer")
catalog_url = "https://platform.adobe.io/data/foundation/catalog"
ingestion_url = "https://platform.adobe.io/data/foundation/import"
writer = DataSetWriter(catalog_url=catalog_url,
ingestion_url=ingestion_url,
client_id=configProperties['ML_FRAMEWORK_IMS_USER_CLIENT_ID'],
user_token=configProperties['ML_FRAMEWORK_IMS_TOKEN'],
service_token=configProperties['ML_FRAMEWORK_IMS_ML_TOKEN'])
print("Writer Configured")
writer.write(data_set_id=configProperties['scoringResultsDataSetId'],
dataframe=prediction,
ims_org=configProperties['ML_FRAMEWORK_IMS_TENANT_ID'])
print("Write Done")
print("Datasaver Finish")
print(prediction)
Wenn Sie die Änderungen an Ihrem Notebook abgeschlossen haben und Ihr Rezept trainieren möchten, können Sie oben in der Leiste auf die entsprechenden Schaltflächen klicken, um einen Trainings-Lauf in der Zelle zu erstellen. Nach dem Klicken auf die Schaltfläche wird ein Protokoll mit Befehlen und Ausgaben aus dem Trainings-Skript im Notebook angezeigt (unter der Zelle evaluator.py
). Conda installiert zunächst alle Abhängigkeiten, dann wird das Training initiiert.
Beachten Sie, dass Sie ein Training mindestens einmal ausführen müssen, bevor Sie mit dem Scoring fortfahren können. Wenn Sie auf die Schaltfläche Scoring ausführen klicken, wird das trainierte Modell, das beim Trainieren erzeugt wurde, bewertet. Das Scoring-Skript wird unter datasaver.py
angezeigt.
Wenn Sie zum Debuggen die ausgeblendete Ausgabe anzeigen möchten, fügen Sie debug
am Ende der Ausgabenzelle hinzu und führen Sie das Scoring erneut aus.
When you are done editing the recipe and satisfied with the training/scoring output, you can create a recipe from the notebook by pressing Create Recipe in the top-right navigation.
Nach dem Klicken auf die Schaltfläche werden Sie aufgefordert, einen Rezeptnamen einzugeben. Dieser Name stellt das eigentliche Rezept dar, das am Platform.
Wenn Sie auf OK klicken, können Sie in Adobe Experience Platform zum neuen Rezept navigieren. Sie können auf die Schaltfläche Rezepte anzeigen klicken, um zur Registerkarte Rezepte unter ML-Modelle zu gelangen.
Sobald der Prozess abgeschlossen ist, sieht das Rezept in etwa wie folgt aus:
%%writefile
-Zeile oben in den Dateizellen.In diesem Tutorial haben Sie gelernt, wie Sie im Recipe Builder-Notebook ein Modell für maschinelles Lernen einrichten können. You have also learned how to exercise the notebook to recipe workflow within the notebook to create a recipe within Data Science Workspace.
To continue learning how to work with resources within Data Science Workspace, please visit the Data Science Workspace recipes and models dropdown.
Das folgende Video hilft Ihnen beim Einrichten und Bereitstellen von Modellen.