8.2 Modell-Authoring und -Bedienung

In Übung 8.1 generierten Sie die für das maschinelle Lernmodell erforderlichen Trainings-Daten. In dieser Lektion erfahren Sie, wie Sie diese Daten verwenden können, um ein Modell für maschinelles Lernen zu erstellen. In der realen Welt wird die Erstellung eines Datensatzes und eines Modells für maschinelles Lernen ein iterativer Prozess sein.

Die URL für die Anmeldung bei Adobe Experience Platform lautet: https://experience.adobe.com/platform.

Ziele

• Analyse Ihrer Trainings-Daten mit Notebooks
• Recommendations-Rezept durchsuchen
• Erfahren Sie, wie das Produkt-Recommendations-Rezept erstellt werden kann.

8.2.1 Daten analysieren

Öffnen Sie in Jupyter Notebooks die Seite Launcher , indem Sie in der Taskleiste auf das Symbol + klicken.

Daraufhin sehen Sie Folgendes:

Öffnen Sie ein leeres Python 3-Notebook, indem Sie im Starter auf die Schaltfläche Leer klicken.

Dann haben Sie ein leeres neues Python 3 Notebook. Bevor Sie fortfahren, geben Sie Ihrem Notebook einen beschreibenden Namen. Klicken Sie mit der rechten Maustaste auf die Datei Untitled.ipynb und klicken Sie auf Umbenennen.

Geben Sie luma-recommendations-data-exploration.ipynb als Namen für Ihr Notebook ein und drücken Sie Enter. Dann haben Sie Folgendes:

Bibliotheken laden

Klicken Sie in die erste leere Zelle im Notebook.

Kopieren Sie den unten stehenden Code und fügen Sie ihn in die erste Zelle Ihres Notebooks ein.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import model_selection, linear_model, tree
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.neighbors import KNeighborsRegressor
import warnings; warnings.simplefilter('ignore')
%matplotlib inline
sns.set()
seed = 1234
inputDataset="--aepRecommendationsInputDatasetId--" # Demo System - Event Dataset for Recommendations Model Input (Global v1.1)

Sie haben dies dann in Zelle 1:

Klicken Sie auf die Wiedergabeschaltfläche , um diese Zelle auszuführen.

Warten Sie, bis der Indikator wie folgt aussieht, bevor Sie fortfahren:

Das Ergebnis sieht folgendermaßen aus:

Daten laden

Klicken Sie in die nächste leere Zelle in Ihrem Notebook.

Kopieren Sie den unten stehenden Code und fügen Sie ihn in die erste Zelle Ihres Notebooks ein.

from platform_sdk.dataset_reader import DatasetReader
from datetime import date
dataset_reader = DatasetReader(PLATFORM_SDK_CLIENT_CONTEXT, dataset_id=inputDataset)
df = dataset_reader.limit(100).read()

df.head(20)

Sie werden dies dann in der Zelle haben:

Klicken Sie auf die Wiedergabeschaltfläche , um diese Zelle auszuführen.

Die Ausführung dieser Zelle kann 1-2 Minuten dauern.

Warten Sie, bis der Indikator wie folgt aussieht, bevor Sie fortfahren:

Dies ist das Ergebnis:

Zusammenfassen der Daten

Klicken Sie in die nächste leere Zelle in Ihrem Notebook.

Kopieren Sie den unten stehenden Code und fügen Sie ihn in die erste Zelle Ihres Notebooks ein.

print("You'll see the number of lines and the number of columns:", df.shape)

Sie werden dies dann in der Zelle haben:

Klicken Sie auf die Wiedergabeschaltfläche , um diese Zelle auszuführen.

Dies ist das Ergebnis:

Statistische Zusammenfassung

Klicken Sie in die nächste leere Zelle in Ihrem Notebook.

Kopieren Sie den unten stehenden Code und fügen Sie ihn in die erste Zelle Ihres Notebooks ein.

user_id = '--aepTenantId--.recommendationsInput.ecid'
item_id = '--aepTenantId--.recommendationsInput.productSku'
interaction_type = '--aepTenantId--.interactionType'
timestamp = '--aepTenantId--.timestamp'

Sie werden dies dann in der Zelle haben:

Klicken Sie auf die Wiedergabeschaltfläche , um diese Zelle auszuführen.

Klicken Sie dann in die nächste leere Zelle in Ihrem Notebook.

Kopieren Sie den unten stehenden Code und fügen Sie ihn in die erste Zelle Ihres Notebooks ein.

df.describe()

Sie werden dies dann in der Zelle haben:

Klicken Sie auf die Wiedergabeschaltfläche , um diese Zelle auszuführen.

Dies ist das Ergebnis:

Gruppieren von Elementen nach Element-ID

Klicken Sie in die nächste leere Zelle in Ihrem Notebook.

Kopieren Sie den unten stehenden Code und fügen Sie ihn in die erste Zelle Ihres Notebooks ein.

df[[user_id, item_id]].groupby([item_id]).agg(['count'])

Sie werden dies dann in der Zelle haben:

Klicken Sie auf die Wiedergabeschaltfläche , um diese Zelle auszuführen.

Dies ist das Ergebnis:

8.2.2 Recipe Builder-Notebook

Das Recipe Builder Notebook ist eine unserer neuesten Innovationen, die Ihr Modell so vorbereiten, dass es automatisch verpackt und operationalisiert wird. Das Notebook verfügt über mehrere Vorlagenzellen, in die Sie Ihren Modellcode einpassen:

• Mithilfe der Anforderungen und Konfigurationszellen können Sie zusätzliche Bibliotheken hinzufügen und Datensätze konfigurieren und Parameter für Ihr Modell anpassen
• Mit der Auswerterzelle können Sie Ihre Daten aufteilen und die Leistung Ihres Modells bewerten
• Mithilfe der Ladezellen für Trainings- und Scoring-Daten können Sie die für Schulung und Scoring benötigten Daten laden
• Schließlich enthält die Pipeline-Zelle die Logik, die sowohl für das Trainieren als auch für das Scoring Ihres Modells erforderlich ist.

Wir haben die erforderlichen Schritte zur Inbetriebnahme eines Modells optimiert, indem wir Ihnen die Möglichkeit geben, das Modell im Maßstab zu trainieren, zu bewerten und zu bewerten und es dann in einen nahtlosen Fluss auf Adobe Experience Platform zu verpacken. Durch das Verpacken in ein Rezept können Sie auch denselben Code mit verschiedenen Datensätzen verwenden, um verschiedene Anwendungsfälle in Ihrem Unternehmen zu unterstützen. Unser spezieller Anwendungsfall dreht sich um die Verwendung des Empfehlungsmodellcodes für Benutzer, die nach Produkten suchen, die auf der Website gekauft werden sollen.

Öffnen Sie in Jupyter Notebooks die Seite Launcher , indem Sie in der Taskleiste auf das Symbol + klicken.

Daraufhin sehen Sie Folgendes:

Öffnen Sie ein leeres Recipe Builder-Notebook, indem Sie auf die Schaltfläche "Recipe Builder"im Starter klicken.

Dann haben Sie ein leeres neues Recipe Builder-Notebook. Bevor Sie fortfahren, geben Sie Ihrem Notebook einen beschreibenden Namen. Klicken Sie mit der rechten Maustaste auf die Datei [Python 3] Recipe Builder.ipynb und klicken Sie auf Umbenennen.

Geben Sie luma-recommendations-poparity-recipe.ipynb als Namen für Ihr Notebook ein und drücken Sie Enter. Dann haben Sie Folgendes:

In diesem Notebook führen Sie die folgenden Schritte aus:

• Modell trainieren
• Modell bewerten
• Rezept aus dem Modell erstellen

Konfigurieren wir alle Schritte detailliert.

Konfigurationsdateien

Scrollen Sie im Recipe Builder-Notebook nach unten, bis Sie Konfigurationsdateien sehen.

Sie müssen jetzt die Zellen für Schulungskonfiguration und Scoring-Konfiguration aktualisieren.

Schulungskonfiguration

Klicken Sie in die Zelle für Schulungskonfiguration.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

%%writefile ~/my-workspace/.recipes/recipe-pt9c03C_w/training.conf

In derselben Zelle wird auch ähnlicher Code angezeigt:

{
   "trainingDataSetId": "<replace with training dataset id>",
   "ACP_DSW_TRAINING_XDM_SCHEMA": "<replace with training xdm schema id>",
   "tenantId": "_<tenant_id>",
   "learning_rate": "0.1",
   "n_estimators": "100",
   "max_depth": "3"
}

Ersetzen Sie diesen Code durch diesen Code:

{
   "tenant_id": "--aepTenantId--",
   "trainingDataSetId": "--aepRecommendationsInputDatasetId--",
   "ACP_DSW_TRAINING_XDM_SCHEMA": "https://ns.adobe.com/--aepTenantIdSchema--/schemas/--aepRecommendationsInputSchemaRef--",
   "num_recommendations": "5",
   "sampling_fraction": "0.5"
}

Sie sollten jetzt etwas Ähnliches in der Zelle Schulungskonfiguration haben:

Scoring-Konfiguration

Klicken Sie in die Zelle für Scoring-Konfiguration.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

%%writefile ~/my-workspace/.recipes/recipe-pt9c03C_w/scoring.conf

In derselben Zelle wird auch ähnlicher Code angezeigt:

{
   "scoringDataSetId": "<replace with scoring input dataset id>",
   "scoringResultsDataSetId": "<replace with scoring results dataset id>",
   "ACP_DSW_SCORING_RESULTS_XDM_SCHEMA": "<replace with scoring results xdm schema id>",
   "tenantId": "_<tenant_id>"
}

Ersetzen Sie diesen Code durch diesen Code:

{
   "tenant_id": "--aepTenantId--",
   "scoringDataSetId": "--aepRecommendationsInputDatasetId--",
   "scoringResultsDataSetId": "--aepMlPredictionsDatasetId--",
   "ACP_DSW_SCORING_RESULTS_XDM_SCHEMA": "https://ns.adobe.com/--aepTenantIdSchema--/schemas/--aepMlPredictionsSchemaRef--"
}

Sie sollten nun etwas Ähnliches in der Zelle Scoring Configuration haben:

Datei für Trainings-Datenladeprogramm

Scrollen Sie im Recipe Builder-Notebook nach unten, bis Datei für Trainings-Datenladeprogramm angezeigt wird.

Sie müssen jetzt den Code für Training Data Loader File aktualisieren.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

In dieser Zelle finden Sie Code ähnlich dem folgenden:

import pandas as pd
from datetime import datetime, timedelta
from platform_sdk.dataset_reader import DatasetReader
from .utils import get_client_context

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")

    if (timeframe is not None):
        date_before = datetime.utcnow().date()
        date_after = date_before - timedelta(minutes=int(timeframe))
        dataframe = dataset_reader.where(dataset_reader[tenant_id + '.date'].gt(str(date_after)).And(dataset_reader[tenant_id + '.date'].lt(str(date_before)))).read()
    else:
        dataframe = dataset_reader.read()

    if '_id' in dataframe.columns:
        #Rename columns to strip tenantId
        dataframe = dataframe.rename(columns = lambda x : str(x)[str(x).find('.')+1:])
        #Drop id and timestamp
        dataframe.drop(['_id', 'timestamp'], axis=1, inplace=True)

    #########################################
    # 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)

    print("Training Data Load Finish")
    return dataframe

Ersetzen Sie diesen Code (ohne die Zeile %%writefile zu überschreiben) durch diesen Code:

import numpy as np
import pandas as pd
from platform_sdk.dataset_reader import DatasetReader
from .utils import get_client_context

def load(configProperties):
    print("Training Data Load Start")
    print(configProperties)
    client_context = get_client_context(configProperties)

    dataset_reader = DatasetReader(client_context, configProperties['trainingDataSetId'])
    df = dataset_reader.read()
    df.head()

    print("Training Data Load Finish")
    return df

Sie sollten nun etwas Ähnliches in der Zelle Training Data Loader File haben:

Datei "Scoring Data Loader"

Scrollen Sie im Recipe Builder-Notebook nach unten, bis Sie Scoring Data Loader File sehen.

Sie müssen jetzt den Code für Scoring Data Loader File aktualisieren.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

In dieser Zelle finden Sie Code ähnlich dem folgenden:

import pandas as pd
from datetime import datetime, timedelta
from .utils import get_client_context
from platform_sdk.dataset_reader import DatasetReader

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")

    if (timeframe is not None):
        date_before = datetime.utcnow().date()
        date_after = date_before - timedelta(minutes=int(timeframe))
        dataframe = dataset_reader.where(dataset_reader[tenant_id + '.date'].gt(str(date_after)).And(dataset_reader[tenant_id + '.date'].lt(str(date_before)))).read()
    else:
        dataframe = dataset_reader.read()
        print(dataframe)

    #########################################
    # 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 and timestamp
        dataframe.drop(['_id', '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

Ersetzen Sie diesen Code (ohne die Zeile %%writefile zu überschreiben) durch diesen Code:

import numpy as np
import pandas as pd
from platform_sdk.dataset_reader import DatasetReader
from .utils import get_client_context

def load(configProperties):

    print("Scoring Data Load Start")

    #########################################
    # Load Data
    #########################################
    client_context = get_client_context(configProperties)
    dataset_reader = DatasetReader(client_context, configProperties['scoringDataSetId'])
    df = dataset_reader.read()

    print("Scoring Data Load Finish")

    return df

Sie sollten nun etwas Ähnliches in der Zelle Scoring Data Loader File haben:

Pipeline-Datei

Scrollen Sie im Recipe Builder-Notebook nach unten, bis Pipeline-Datei angezeigt wird.

Sie müssen jetzt den Code für Pipeline-Datei aktualisieren.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

In dieser Zelle finden Sie Code ähnlich dem folgenden:

from sklearn.ensemble import GradientBoostingRegressor

def train(config_properties, data):

    print("Train Start")

    #########################################
    # Extract fields from configProperties
    #########################################
    learning_rate = float(config_properties['learning_rate'])
    n_estimators = int(config_properties['n_estimators'])
    max_depth = int(config_properties['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

def score(config_properties, 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

Ersetzen Sie diesen Code (ohne die Zeile %%writefile zu überschreiben) durch diesen Code:

import pandas as pd
import numpy as np
from collections import Counter

class PopularityBasedRecommendationModel():
    def __init__(self, num_to_recommend, configProperties):
        self.num_to_recommend = num_to_recommend
        self.recommendations = ['dummy']

        tenant_id='--aepTenantId--'

        self.user_id_column = '%s.recommendationsInput.ecid' % tenant_id
        self.recommendations_column = '%s.individualScoring.product.recommendations' % tenant_id
        self.item_id_column = '%s.recommendationsInput.productSku' % tenant_id
        self.user_id_output_column = '%s.identification.core.ecid' % tenant_id

    def fit(self, df):
        df = df[df[self.item_id_column].notnull()]
        self.recommendations = [item for item, freq in
                                Counter(list(df[self.item_id_column].values)).most_common(self.num_to_recommend)]


    def predict(self, df):
        # remove columns having none
        df = df[df[self.item_id_column].notnull()]

        df_grouped_by_user = df.groupby(self.user_id_column).agg(
            {self.item_id_column: lambda x: ','.join(x)})\
        .rename(columns={self.item_id_column:'interactions'}).reset_index()

        df_grouped_by_user[self.recommendations_column] = '#'.join(self.recommendations)
        df_grouped_by_user[self.user_id_output_column] = df_grouped_by_user[self.user_id_column]
        df_grouped_by_user = df_grouped_by_user.drop(['interactions'],axis=1)
        df_grouped_by_user = df_grouped_by_user.drop([self.user_id_column],axis=1)

        return df_grouped_by_user

def train(configProperties, data):

    print("Train Start")

    #########################################
    # Extract fields from configProperties
    #########################################
    num_recommendations = int(configProperties['num_recommendations'])

    #########################################
    # Fit model
    #########################################
    print('in train')
    print(configProperties)

    model = PopularityBasedRecommendationModel(num_recommendations, configProperties)

    model.fit(data)

    print("Train Complete")

    return model

def score(configProperties, data, model):

    print("Score Start")

    result = model.predict(data)

    print("Score Complete")

    return result

Sie sollten nun etwas Ähnliches in der Zelle Pipeline-Datei haben:

Evaluator-Datei

Scrollen Sie im Recipe Builder-Notebook nach unten, bis Evaluator-Datei angezeigt wird.

Sie müssen jetzt den Code für Evaluator File aktualisieren.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

In dieser Zelle finden Sie Code ähnlich dem folgenden:

from ml.runtime.python.core.regressionEvaluator import RegressionEvaluator
import numpy as np

class Evaluator(RegressionEvaluator):
    def __init__(self):
        print ("Initiate")

    def split(self, config={}, 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

    def evaluate(self, data=[], model={}, config={}):
        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"}]

        print(metric)
        return metric

Ersetzen Sie diesen Code (ohne die Zeile %%writefile zu überschreiben) durch diesen Code:

from ml.runtime.python.Interfaces.AbstractEvaluator import AbstractEvaluator
from platform_sdk.dataset_reader import DatasetReader
import numpy as np
import pandas as pd

class Evaluator(AbstractEvaluator):

    def split(self, configProperties={}, dataframe=None):
        #########################################
        # Load Data
        #########################################
        train = dataframe[:]
        test = dataframe[:]

        return train, test

    def evaluate(self, data=[], model={}, configProperties={}):
        print ("Evaluation evaluate triggered")

        tenant_id='--aepTenantId--'

        self.user_id_column = '%s.recommendationsInput.ecid' % tenant_id
        self.recommendations_column = '%s.individualScoring.product.recommendations' % tenant_id
        self.item_id_column = '%s.recommendationsInput.productSku' % tenant_id
        self.user_id_output_column = '%s.identification.core.ecid' % tenant_id

        # remove columns having none
        data = data[data[self.item_id_column].notnull()]

        data_grouped_by_user = data.groupby(self.user_id_column).agg(
            {self.item_id_column: lambda x: '#'.join(x)})\
        .rename(columns={self.item_id_column:'interactions'}).reset_index()

        data_recommendations = model.predict(data)

        data_recommendations[self.user_id_column] = data_recommendations[self.user_id_output_column]
        data_recommendations = data_recommendations.drop([self.user_id_output_column],axis=1)

        merged_df = pd.merge(data_grouped_by_user, data_recommendations, on=[self.user_id_column]).reset_index()

        def compute_recall(row):
            set_interactions = set(row['interactions'].split('#'))
            set_recommendations = set(row[self.recommendations_column].split('#'))
            inters = set_interactions.intersection(set_recommendations)
            if len(inters) > 0:
                return 1
            return 0

        def compute_precision(row):
            set_interactions = set(row['interactions'].split('#'))
            list_recommendations = row[self.recommendations_column].split('#')
            score = 0
            weight = 0.5
            for rec in list_recommendations:
                if rec in set_interactions:
                    score = score + weight
                weight = weight / 2

            return score


        merged_df['recall'] = merged_df.apply(lambda row: compute_recall(row), axis=1)
        merged_df['precision'] = merged_df.apply(lambda row: compute_precision(row), axis=1)

        recall = merged_df['recall'].mean()
        precision = merged_df['precision'].mean()

        metric = [{"name": "Recall", "value": recall, "valueType": "double"},
                 {"name": "Precision", "value": precision, "valueType": "double"}]

        print(metric)

        return metric

Sie sollten nun etwas Ähnliches in der Zelle Evaluator File haben:

Data Saver File

Scrollen Sie im Recipe Builder-Notebook nach unten, bis Data Saver File angezeigt wird.

Sie müssen jetzt den Code für Data Saver File aktualisieren.

Bevor du etwas tust, achte bitte auf! Was auch immer Sie tun, löschen oder überschreiben Sie nicht die Zeile, die mit %%writefile beginnt. Diese Zeile ist für das Recipe Builder-Notebook erforderlich.

In dieser Zelle finden Sie Code ähnlich dem folgenden:

import pandas as pd
from .utils import get_client_context
from platform_sdk.models import Dataset
from platform_sdk.dataset_writer import DatasetWriter

def save(config_properties, prediction):
  print("Datasaver Start")

  client_context = get_client_context(config_properties)
  tenant_id = config_properties.get("tenantId")
  prediction = prediction.add_prefix(tenant_id+".")

  prediction = prediction.join(pd.DataFrame(
      {
          '_id': "",
          'timestamp': '2019-01-01T00:00:00',
          'eventType': ""
      }, index=prediction.index))

  dataset = Dataset(client_context).get_by_id(config_properties['scoringResultsDataSetId'])
  dataset_writer = DatasetWriter(client_context, dataset)
  dataset_writer.write(prediction, file_format='json')

  print("Datasaver Finish")
  print(prediction)

Ersetzen Sie diesen Code (ohne die Zeile %%writefile zu überschreiben) durch diesen Code:

from platform_sdk.models import Dataset
from platform_sdk.dataset_writer import DatasetWriter
from .utils import get_client_context
from functools import reduce
import json

def save(configProperties, prediction):

    print(prediction)
    client_context = get_client_context(configProperties)
    dataset = Dataset(client_context).get_by_id(configProperties['scoringResultsDataSetId'])
    dataset_writer = DatasetWriter(client_context, dataset)
    dataset_writer.write(prediction, file_format='json')
    print("Data written successfully to platform")

Sie sollten nun etwas Ähnliches in der Zelle Data Saver File haben:

Sie haben jetzt den gesamten Code konfiguriert, den Sie zum Ausführen Ihres Notebooks benötigen.

8.2.3 Rezept Builder-Notebook ausführen

Modell trainieren

Um ein Modell zu trainieren, klicken Sie auf die Schaltfläche Trainieren .

Klicken Sie in der oberen Symbolleiste auf Trainieren , um einen Trainings-Lauf in der Zelle zu erstellen. Dadurch werden die Zellen des Ladeprogramms für Trainings-Daten, der Pipeline und der Auswerter ausgeführt und Auswertungsmetriken generiert, um die Leistung des Modells zu messen. Im Notebook wird ein Protokoll mit Befehlen und Ausgaben aus dem Trainings-Skript angezeigt (unter der Zelle Auswerter - ).

Nachdem Sie auf Training geklickt haben, beginnt der Trainings-Lauf und dauert einige Minuten, bis er abgeschlossen ist.

…

…

Wenn Sie auf Trainieren klicken, werden die folgenden Zellen ausgeführt:

• Anforderungsdatei
• Konfigurationsdateien - Schulung
• Datei für Trainings-Datenladeprogramm
• Pipeline-Datei
• Evaluator-Datei

Modell bewerten

Das Scoring eines Modells erfolgt durch Klicken auf die Schaltfläche Score .

Klicken Sie in der oberen Symbolleiste auf Score , um einen Scoring-Lauf in der Zelle zu erstellen. Dadurch werden die Zellen des Ladeprogramms für Scoring-Daten, der Pipeline und der Auswerter ausgeführt und Auswertungsmetriken generiert, um die Leistung des Modells zu messen. Im Notebook wird ein Protokoll mit Befehlen und Ausgaben aus dem Scoring-Skript angezeigt (unter der Zelle "pipeline.py").

Nachdem Sie auf Score geklickt haben, beginnt der Scoring-Lauf und dauert einige Minuten, bis er abgeschlossen ist.

…

…

…

Wenn Sie auf Score klicken, werden die folgenden Zellen ausgeführt:

• Anforderungsdatei
• Konfigurationsdateien - Scoring
• Datei "Scoring Data Loader"
• Pipeline-Datei
• Evaluator-Datei

Darüber hinaus wird am Ende des Scoring-Laufs die Ausgabe mit Empfehlungen in Adobe Experience Platform im Ordner Demo-System - Profildatensatz für ML-Prognosen (Global v1.1) gespeichert.

Sie können dies überprüfen, indem Sie in Adobe Experience Platform den Demosystem - Profildatensatz für ML-Prognosen (Global v1.1) öffnen.

Rezept aus dem Modell erstellen

Das Erstellen eines Rezepts erfolgt durch Klicken auf die Schaltfläche Rezept erstellen .

Wenn Sie mit den Trainings- und Scoring-Ausgaben zufrieden sind, können Sie ein Rezept erstellen. Klicken Sie auf die Schaltfläche Rezept erstellen , um den Prozess zu starten.

Das Erstellen eines Rezepts ermöglicht es Ihnen, Ihr Modell maßstabsgetreu zu testen.

Nachdem Sie auf die Schaltfläche Rezept erstellen geklickt haben, müssen Sie einen Namen für Ihr Rezept eingeben.

Verwenden Sie als Namenskonvention:

• ldapRecommendations

Ersetzen Sie ldap durch Ihren ldap.

Beispiel: Für ldap vangeluw sollte der Name Ihres Rezepts wie folgt lauten: vangeluwRecommendations.

Klicken Sie nach Eingabe eines Rezeptnamen auf OK.

Ein zweites Popup wird angezeigt, in dem Sie darüber informiert werden, dass Ihr Rezept gerade erstellt wird. Dies kann bis zu 5 Minuten dauern. Warten Sie bitte, bis der Prozess abgeschlossen ist.

Klicken Sie zunächst auf die Schaltfläche Dismiss .

Sie können den Fortschritt des Rezepterstellungsprozesses in der oberen rechten Ecke von Jupyter Notebooks anzeigen.

…

Nach einigen Minuten ist die Rezepterstellung abgeschlossen und Sie finden Ihr Rezept unter Modelle > Rezepte. Um dorthin zu gelangen, klicken Sie auf Rezepte im Menü Modelle .

Du wirst dein Rezept in der Liste finden.

Nachdem Sie Ihr Rezept erstellt haben, fahren wir mit der nächsten Übung fort, in der Sie mit skalierbarem Training und Experimentieren beginnen.

Nächster Schritt: 8.3 - Modellschulung und -experimentierung

Zurück zu Modul 8

Zu allen Modulen zurückkehren