8.2 Authoring e operazionalizzazione dei modelli

Nell’esercizio 8.1 hai generato i dati di formazione necessari per alimentare il modello di apprendimento automatico. In questa lezione imparerai come utilizzare questi dati per creare un modello di apprendimento automatico. Nel mondo reale, la creazione di un set di dati e di un modello di apprendimento automatico sarà un processo iterativo.

L'URL per accedere a Adobe Experience Platform è: https://experience.adobe.com/platform.

Obiettivi

• Analizzare i dati di formazione utilizzando i notebook
• Esplora la ricetta Recommendations del prodotto
• Scopri come creare la composizione Recommendations del prodotto

8.2.1 Analizzare i dati

In Jupyter Notebooks, apri la Launcher facendo clic su + nella barra delle applicazioni.

Vedrai questo:

Apri una pagina vuota Pitone 3 blocco appunti facendo clic sul pulsante Vuoto nel modulo di avvio.

Avrete quindi un nuovo notebook Python 3 vuoto e vuoto. Prima di continuare, assegnare un nome descrittivo al blocco appunti. Fai clic con il pulsante destro del mouse sul pulsante Senza titolo.ipynb e fai clic su Rinomina.

Invio luma-recommendations-data-exploration.ipynb come nome del blocco appunti e premi Invio. A quel punto avrai questo:

Carica librerie

Fare clic sulla prima cella vuota del blocco appunti.

Copiare il codice seguente e incollarlo nella prima cella del blocco appunti.

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)

Nella cella 1 si trova questo:

Fare clic sul pulsante di riproduzione per eseguire la cella.

Attendere che l'indicatore si presenti come segue prima di continuare:

Il risultato si presenta così:

Carica dati

Fare clic nella cella vuota successiva del blocco appunti.

Copiare il codice seguente e incollarlo nella prima cella del blocco appunti.

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)

Poi ci sarà questo in quella cella:

Fare clic sul pulsante di riproduzione per eseguire la cella.

L'esecuzione di questa cella potrebbe richiedere 1-2 minuti.

Attendere che l'indicatore si presenti come segue prima di continuare:

Questo è il risultato:

Riepilogo dei dati

Fare clic nella cella vuota successiva del blocco appunti.

Copiare il codice seguente e incollarlo nella prima cella del blocco appunti.

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

Poi ci sarà questo in quella cella:

Fare clic sul pulsante di riproduzione per eseguire la cella.

Questo è il risultato:

Riepilogo statistico

Fare clic nella cella vuota successiva del blocco appunti.

Copiare il codice seguente e incollarlo nella prima cella del blocco appunti.

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

Poi ci sarà questo in quella cella:

Fare clic sul pulsante di riproduzione per eseguire la cella.

Quindi fare clic nella cella vuota successiva del blocco appunti.

Copiare il codice seguente e incollarlo nella prima cella del blocco appunti.

df.describe()

Poi ci sarà questo in quella cella:

Fare clic sul pulsante di riproduzione per eseguire la cella.

Questo è il risultato:

Raggruppamento elementi per ID articolo

Fare clic nella cella vuota successiva del blocco appunti.

Copiare il codice seguente e incollarlo nella prima cella del blocco appunti.

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

Poi ci sarà questo in quella cella:

Fare clic sul pulsante di riproduzione per eseguire la cella.

Questo è il risultato:

Notebook per il generatore di ricette 8.2.2

Il notebook Recipe Builder è una delle nostre recenti innovazioni che modellano il modello per assemblarlo automaticamente e renderlo operativo. Il blocco appunti contiene più celle di modello in cui è possibile inserire il codice del modello:

• I requisiti e le celle di configurazione ti consentono di aggiungere librerie aggiuntive e configurare set di dati e parametri di ottimizzazione per il modello
• La cella valutatore consente di suddividere i dati e valutare le prestazioni del modello
• Le celle del caricatore dati di formazione e punteggio consentono di caricare i dati necessari per la formazione e il punteggio
• Infine, la cella pipeline contiene la logica necessaria sia per l’addestramento che per il punteggio del modello.

Abbiamo semplificato i passaggi necessari per l'operazionalizzazione di un modello, fornendo la possibilità di addestrarlo, valutarlo e segnarlo su larga scala e poi impacchettarlo in un unico flusso senza soluzione di continuità su Adobe Experience Platform. La creazione di pacchetti in una composizione consente inoltre di utilizzare lo stesso codice con set di dati diversi per alimentare diversi casi d’uso nelle organizzazioni. Il nostro caso d’uso specifico ruota intorno all’utilizzo del codice del modello di consigli per gli utenti che cercano prodotti da acquistare sul sito web.

In Jupyter Notebooks, apri la Launcher facendo clic su + nella barra delle applicazioni.

Vedrai questo:

Apri una pagina vuota Generatore di ricette facendo clic sul pulsante Ricetta Builder nel modulo di avvio.

Avrete quindi un nuovo blocco appunti di Recipe Builder vuoto e vuoto. Prima di continuare, assegnare un nome descrittivo al blocco appunti. Fai clic con il pulsante destro del mouse sul pulsante [Pitone 3] Ricipe Builder.ipynb e fai clic su Rinomina.

Invio luma-recommendations-popolarity-recipe.ipynb come nome del blocco appunti e premi Invio. A quel punto avrai questo:

In questo blocco appunti, eseguirai le seguenti operazioni:

• Addestrare un modello
• Punteggio di un modello
• Crea una ricetta dal modello

Configuriamo tutti i passaggi in dettaglio.

File di configurazione

Scorri verso il basso nel blocco appunti del Generatore di ricette fino a visualizzare File di configurazione.

È ora necessario aggiornare le celle per Configurazione della formazione e Configurazione del punteggio.

Configurazione della formazione

Fai clic nella cella per Configurazione della formazione.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

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

Vedrai anche un codice simile nella stessa cella:

{
   "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"
}

Sostituisci il codice con questo codice:

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

Ora dovresti avere qualcosa di simile nel Configurazione della formazione cella:

Configurazione del punteggio

Fai clic nella cella per Configurazione del punteggio.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

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

Vedrai anche un codice simile nella stessa cella:

{
   "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>"
}

Sostituisci il codice con questo codice:

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

Ora dovresti avere qualcosa di simile nel Configurazione del punteggio cella:

File di caricamento dati di formazione

Scorri verso il basso nel blocco appunti del Generatore di ricette fino a visualizzare File di caricamento dati di formazione.

È ora necessario aggiornare il codice per File di caricamento dati di formazione.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

In quella cella troverai un codice simile a questo:

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

Sostituisci tale codice (senza sovrascrivere il %%writefile con questo codice:

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

Ora dovresti avere qualcosa di simile nel File di caricamento dati di formazione cella:

File del caricatore dati di valutazione

Scorri verso il basso nel blocco appunti del Generatore di ricette fino a visualizzare File del caricatore dati di valutazione.

È ora necessario aggiornare il codice per File del caricatore dati di valutazione.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

In quella cella troverai un codice simile a questo:

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

Sostituisci tale codice (senza sovrascrivere il %%writefile con questo codice:

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

Ora dovresti avere qualcosa di simile nel File del caricatore dati di valutazione cella:

File di pipeline

Scorri verso il basso nel blocco appunti del Generatore di ricette fino a visualizzare File di pipeline.

È ora necessario aggiornare il codice per File di pipeline.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

In quella cella troverai un codice simile a questo:

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

Sostituisci tale codice (senza sovrascrivere il %%writefile con questo codice:

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

Ora dovresti avere qualcosa di simile nel File di pipeline cella:

File valutatore

Scorri verso il basso nel blocco appunti del Generatore di ricette fino a visualizzare File valutatore.

È ora necessario aggiornare il codice per File valutatore.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

In quella cella troverai un codice simile a questo:

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

Sostituisci tale codice (senza sovrascrivere il %%writefile con questo codice:

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

Ora dovresti avere qualcosa di simile nel File valutatore cella:

File di Data Saver

Scorri verso il basso nel blocco appunti del Generatore di ricette fino a visualizzare File di Data Saver.

È ora necessario aggiornare il codice per File di Data Saver.

Prima di fare qualsiasi cosa, prestate attenzione!! Qualsiasi cosa tu faccia, non eliminare o sovrascrivere la riga che inizia con %%writefile. Questa linea è richiesta dal notebook di generazione ricette.

In quella cella troverai un codice simile a questo:

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)

Sostituisci tale codice (senza sovrascrivere il %%writefile con questo codice:

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

Ora dovresti avere qualcosa di simile nel File di Data Saver cella:

Ora hai configurato tutto il codice necessario per eseguire il blocco appunti.

8.2.3 Esecuzione del notebook del generatore di ricette

Addestrare un modello

La formazione di un modello viene eseguita facendo clic sul pulsante Treno pulsante .

Fai clic su Treno sulla barra degli strumenti superiore per creare un’esecuzione di formazione nella cella. In questo modo vengono eseguite le celle del caricatore dati di formazione, della pipeline e del valutatore e vengono generate metriche di valutazione per misurare le prestazioni del modello. Nel blocco appunti viene visualizzato un registro dei comandi e degli output dello script di addestramento (sotto la cella Valutatore - ).

Dopo aver fatto clic su Treno, la procedura di formazione inizierà e avrà bisogno di un paio di minuti per essere completata.

…

…

Quando fai clic su Treno, vengono eseguite le seguenti celle:

• File dei requisiti
• File di configurazione - Formazione
• File di caricamento dati di formazione
• File di pipeline
• File valutatore

Punteggio di un modello

Per eseguire il punteggio di un modello, fai clic sul pulsante Punteggio pulsante .

Fai clic su Punteggio sulla barra degli strumenti superiore per creare un’esecuzione del punteggio nella cella. In questo modo vengono eseguite le celle del caricatore dati di punteggio, della pipeline e del valutatore e vengono generate metriche di valutazione per misurare le prestazioni del modello. Nel blocco appunti viene visualizzato un registro di comandi e output dello script di punteggio (sotto la cella pipeline.py).

Dopo aver fatto clic su Punteggio, l’esecuzione del punteggio avrà inizio e avrà bisogno di un paio di minuti per essere completata.

…

…

…

Quando fai clic su Punteggio, vengono eseguite le seguenti celle:

• File dei requisiti
• File di configurazione - Punteggio
• File del caricatore dati di valutazione
• File di pipeline
• File valutatore

Inoltre, alla fine dell’esecuzione del punteggio, l’output con i consigli viene memorizzato in Adobe Experience Platform, nella sezione Sistema di demo - Set di dati del profilo per le previsioni ML (Global v1.1).

Puoi verificare questo aprendo il Demo System - Profile Dataset for ML Predictions (Global v1.1) in Adobe Experience Platform.

Crea una ricetta dal modello

Per creare una ricetta, fai clic sul pulsante Crea ricetta pulsante .

Quando sei soddisfatto dei risultati della formazione e del punteggio, puoi creare una ricetta. Fai clic sul pulsante Crea ricetta per avviare il processo.

La creazione di una ricetta consente di testare il modello in scala.

Dopo aver fatto clic sul pulsante Crea ricetta pulsante, è necessario inserire un nome per la ricetta.

Come convenzione di denominazione, utilizza:

• ldapRecommendations

Sostituisci ldap con il tuo ldap.

Esempio: per ldap vangeluw, il nome della tua ricetta dovrebbe essere: vangeluwRecommendations.

Dopo aver inserito un Nome composizione, fare clic su OK.

Viene visualizzata una seconda finestra a comparsa che indica che la Ricetta è in fase di creazione. L'operazione potrebbe richiedere fino a 5 minuti. Attendere il completamento del processo.

Per il momento, fai clic su Elimina pulsante .

È possibile visualizzare l'avanzamento del processo di creazione delle ricette nell'angolo in alto a destra di Jupyter Notebooks.

…

Dopo un paio di minuti, la creazione della ricetta è finita e si può trovare la vostra ricetta sotto Modelli > Ricette. Per andarci, fai clic su Ricette in Modelli menu.

Troverete la vostra ricetta nell'elenco.

Ora che hai creato la tua ricetta, continuiamo con il prossimo esercizio, in cui inizierai la formazione e la sperimentazione scalabili.

Passaggio successivo: 8.3 - Modello di formazione e sperimentazione

Torna al modulo 8

Torna a tutti i moduli