Creare una ricetta utilizzando Jupyter Notebooks

Questa esercitazione si articola su due sezioni principali. Innanzitutto, creerai un modello di apprendimento automatico utilizzando un modello all'interno di JupyterLab Notebook. Successivamente, si eserciterà il blocco appunti per creare un flusso di lavoro all'interno di JupyterLab per creare una ricetta all'interno di Data Science Workspace.

Concetti presentati:

  • Ricette: una ricetta è un termine di Adobe per una specifica di modello ed è un contenitore di primo livello che rappresenta uno specifico apprendimento automatico, un algoritmo AI o un insieme di algoritmi, logica di elaborazione e configurazione necessari per creare ed eseguire un modello addestrato e quindi contribuire a risolvere problemi di business specifici.
  • Modello: un modello è un'istanza di una ricetta di apprendimento automatico formata utilizzando dati storici e configurazioni per risolvere un caso d'uso aziendale.
  • Formazione: la formazione è il processo di apprendimento di schemi e insights dai dati etichettati.
  • Punteggio: il punteggio è il processo di generazione di informazioni dai dati che utilizza un modello addestrato.

Guida introduttiva all'ambiente JupyterLab per notebook

La creazione di una ricetta da zero può essere effettuata all'interno di Data Science Workspace. Per iniziare, passa a Adobe Experience Platform e fai clic sulla scheda Notebooks a sinistra. Crea un nuovo blocco appunti selezionando il modello Ricetta Builder dal JupyterLab Launcher.

Il notebook Recipe Builder consente di eseguire attività di formazione e valutazione all'interno del notebook. Questo ti offre la flessibilità di apportare modifiche ai metodi train() e score() tra l’esecuzione di esperimenti sui dati di formazione e valutazione. Una volta soddisfatti i risultati della formazione e del punteggio, è possibile creare una ricetta da utilizzare in Data Science Workspace utilizzando il blocco appunti per creare le funzionalità integrate nel blocco appunti di Recipe Builder.

NOTA

Il blocco appunti di Recipe Builder supporta l'utilizzo di tutti i formati di file, ma al momento la funzionalità Create Recipe supporta solo Python.

Quando si fa clic sul blocco appunti del generatore di ricette dal modulo di avvio, il blocco appunti viene aperto nella scheda . Il modello utilizzato nel blocco appunti è la Ricetta di previsione vendite al dettaglio Python che si trova anche in questo archivio pubblico

Nella barra degli strumenti sono disponibili tre azioni aggiuntive: Train, Score e Create Recipe. Queste icone vengono visualizzate solo nel blocco appunti Recipe Builder. Per ulteriori informazioni su queste azioni, consulta la sezione Formazione e valutazione dopo la creazione della composizione nel blocco appunti.

Apportare modifiche ai file di ricetta

Per apportare modifiche ai file di ricetta, passa alla cella in Jupyter corrispondente al percorso del file. Ad esempio, se desideri apportare modifiche a evaluator.py, cerca %%writefile demo-recipe/evaluator.py.

Iniziare a apportare le modifiche necessarie alla cella e, al termine, eseguire semplicemente la cella. Il comando %%writefile filename.py scriverà il contenuto della cella in filename.py. Sarà necessario eseguire manualmente la cella per ogni file con modifiche.

NOTA

Se necessario, eseguire le celle manualmente.

Guida introduttiva al blocco appunti di Recipe Builder

Ora che si conoscono le basi dell'ambiente JupyterLab per notebook, è possibile iniziare a esaminare i file che compongono una ricetta modello di apprendimento automatico. I file di cui parleremo sono mostrati qui:

File dei requisiti

Il file dei requisiti viene utilizzato per dichiarare librerie aggiuntive da utilizzare nella ricetta. Se esiste una dipendenza, è possibile specificare il numero di versione. Per cercare librerie aggiuntive, visita anaconda.org. Per informazioni su come formattare il file dei requisiti, visita Conda. L’elenco delle librerie principali già in uso include:

python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python
NOTA

Le librerie o le versioni specifiche aggiunte potrebbero essere incompatibili con le librerie di cui sopra. Inoltre, se scegli di creare manualmente un file di ambiente, il campo name non può essere ignorato.

File di configurazione

I file di configurazione training.conf e scoring.conf vengono utilizzati per specificare i set di dati da utilizzare per la formazione e il punteggio, nonché per aggiungere parametri ipertestuali. Sono disponibili configurazioni separate per la formazione e il punteggio.

Gli utenti devono compilare le seguenti variabili prima di eseguire la formazione e il punteggio:

  • trainingDataSetId
  • ACP_DSW_TRAINING_XDM_SCHEMA
  • scoringDataSetId
  • ACP_DSW_SCORING_RESULTS_XDM_SCHEMA
  • scoringResultsDataSetId

Per trovare il set di dati e gli ID dello schema, vai alla scheda dati scheda dati all’interno dei blocchi appunti nella barra di navigazione a sinistra (sotto l’icona della cartella).

Le stesse informazioni si trovano nelle schede Adobe Experience Platform Schema e Set di dati.

Per impostazione predefinita, quando accedi ai dati vengono impostati i seguenti parametri di configurazione:

  • ML_FRAMEWORK_IMS_USER_CLIENT_ID
  • ML_FRAMEWORK_IMS_TOKEN
  • ML_FRAMEWORK_IMS_ML_TOKEN
  • ML_FRAMEWORK_IMS_TENANT_ID

Caricatore dati di formazione

Lo scopo di Training Data Loader è quello di creare un'istanza dei dati utilizzati per creare il modello di apprendimento automatico. In genere, esistono due attività che il caricatore dati di formazione eseguirà:

  • Carica dati da Platform
  • Preparazione dei dati e ingegneria delle funzioni

Le due sezioni seguenti esamineranno il caricamento dei dati e la preparazione dei dati.

Caricamento dei dati

Questo passaggio utilizza il dataframe panda. I dati possono essere caricati da file in Adobe Experience Platform utilizzando l'SDK Platform (platform_sdk) o da fonti esterne utilizzando le funzioni read_csv() o read_json().

NOTA

Nel blocco appunti del Generatore di ricette, i dati vengono caricati tramite il caricatore di dati platform_sdk.

Platform SDK

Per un'esercitazione approfondita sull'utilizzo del caricatore dati platform_sdk, visita la guida SDK della piattaforma. Questa esercitazione fornisce informazioni sull’autenticazione della build, sulla lettura di base dei dati e sulla scrittura di base dei dati.

Origini esterne

Questa sezione mostra come importare un file JSON o CSV in un oggetto panda. La documentazione ufficiale della biblioteca dei panda si trova qui:

Innanzitutto, ecco un esempio di importazione di un file CSV. L’argomento data rappresenta il percorso del file CSV. Questa variabile è stata importata da configProperties nella sezione precedente.

df = pd.read_csv(data)

Puoi anche importare da un file JSON. L’argomento data rappresenta il percorso del file CSV. Questa variabile è stata importata da configProperties nella sezione precedente.

df = pd.read_json(data)

Ora i dati si trovano nell'oggetto dataframe e possono essere analizzati e manipolati nella sezione successiva.

Dall’SDK di Platform

Puoi caricare i dati utilizzando l’SDK di Platform. La libreria può essere importata nella parte superiore della pagina includendo la riga :

from platform_sdk.dataset_reader import DatasetReader

Quindi utilizziamo il metodo load() per recuperare il set di dati di formazione dal trainingDataSetId come impostato nel file di configurazione (recipe.conf).

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

Come indicato nella sezione File di configurazione, i seguenti parametri di configurazione vengono impostati automaticamente quando si accede ai dati da un Experience Platform utilizzando client_context:

  • ML_FRAMEWORK_IMS_USER_CLIENT_ID
  • ML_FRAMEWORK_IMS_TOKEN
  • ML_FRAMEWORK_IMS_ML_TOKEN
  • ML_FRAMEWORK_IMS_TENANT_ID

Ora che disponi dei tuoi dati, puoi iniziare con la preparazione dei dati e l'ingegneria delle funzioni.

Preparazione dei dati e ingegneria delle funzioni

Una volta caricati i dati, questi vengono preparati e quindi suddivisi nei set di dati train e val. Di seguito è riportato un codice di esempio:

#########################################
# 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 questo esempio, vengono eseguite cinque operazioni sul set di dati originale:

  • aggiungere colonne week e year
  • convertire storeType in una variabile indicatore
  • convertire isHoliday in una variabile numerica
  • offset weeklySales per ottenere il valore delle vendite future e passate
  • suddividere i dati, per data, in train e val set di dati

Innanzitutto, vengono create le colonne week e year e la colonna date originale viene convertita in Python datetime. I valori settimana e anno vengono estratti dall’oggetto datetime .

Successivamente, storeType viene convertito in tre colonne che rappresentano i tre diversi tipi di archivio, (A, B e C). Ciascuna contiene un valore booleano per indicare che storeType è true. La colonna storeType verrà eliminata.

Analogamente, weeklySales cambia il valore booleano isHoliday in una rappresentazione numerica, uno o zero.

Questi dati sono suddivisi tra train e val set di dati.

La funzione load() deve essere completata con il set di dati train e val come output.

Caricatore dati di punteggio

La procedura per caricare i dati per il punteggio è simile a quella per il caricamento dei dati di formazione nella funzione split() . Usiamo l'SDK per l'accesso ai dati per caricare i dati dal scoringDataSetId presente nel nostro file recipe.conf.

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

Dopo aver caricato i dati, viene eseguita la preparazione dei dati e l’ingegneria delle funzioni.

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

Poiché lo scopo del nostro modello è quello di prevedere le vendite settimanali future, dovrai creare un set di dati di valutazione utilizzato per valutare le prestazioni della previsione del modello.

Questo notebook Recipe Builder lo fa compensando la nostra vendita settimanale 7 giorni in avanti. Tieni presente che esistono misure per 45 archivi ogni settimana in modo da poter spostare i valori weeklySales 45 set di dati in avanti in una nuova colonna denominata weeklySalesAhead.

df['weeklySalesAhead'] = df.shift(-45)['weeklySales']

Allo stesso modo, è possibile creare una colonna weeklySalesLag spostando indietro di 45. Utilizzando questo strumento è inoltre possibile calcolare la differenza nelle vendite settimanali e memorizzarle nella colonna weeklySalesDiff.

df['weeklySalesLag'] = df.shift(45)['weeklySales']
df['weeklySalesDiff'] = (df['weeklySales'] - df['weeklySalesLag']) / df['weeklySalesLag']

Poiché si sta eseguendo l’offset dei weeklySales punti dati 45 in avanti e 45 in indietro per creare nuove colonne, i primi e gli ultimi 45 punti dati avranno valori NaN. Puoi rimuovere questi punti dal nostro set di dati utilizzando la funzione df.dropna() che rimuove tutte le righe con valori NaN.

df.dropna(0, inplace=True)

La funzione load() nel caricatore dati di punteggio deve essere completata con il set di dati di punteggio come output.

File della pipeline

Il file pipeline.py include logica per la formazione e il punteggio.

Formazione

Lo scopo della formazione è quello di creare un modello utilizzando caratteristiche ed etichette nel set di dati di formazione.

NOTA

Le feature si riferiscono alla variabile di input utilizzata dal modello di apprendimento automatico per prevedere le etichette.

La funzione train() deve includere il modello di addestramento e restituire il modello addestrato. Alcuni esempi di modelli diversi sono disponibili nella documentazione della guida utente scikit-learn .

Dopo aver scelto il tuo modello di formazione, inserirai il tuo set di dati x e y di formazione al modello e la funzione restituirà il modello addestrato. Un esempio che mostra questo è il seguente:

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

A seconda dell’applicazione, la funzione GradientBoostingRegressor() contiene argomenti. xTrainingDataset deve contenere le funzioni utilizzate per la formazione, mentre yTrainingDataset deve contenere le etichette.

Punteggio

La funzione score() deve contenere l'algoritmo di punteggio e restituire una misurazione per indicare il successo del modello. La funzione score() utilizza le etichette del set di dati di punteggio e il modello addestrato per generare un set di funzioni previste. Questi valori previsti vengono quindi confrontati con le funzioni effettive nel set di dati di punteggio. In questo esempio, la funzione score() utilizza il modello addestrato per prevedere le funzioni utilizzando le etichette del set di dati di punteggio. Vengono restituite le funzionalità previste.

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

File di valutazione

Il file evaluator.py contiene una logica che indica come valutare la ricetta formata e come suddividere i dati di formazione. Nell’esempio di vendita al dettaglio, sarà inclusa la logica per il caricamento e la preparazione dei dati di formazione. Passiamo ora alle due sezioni seguenti.

Dividi il set di dati

La fase di preparazione dei dati per la formazione richiede la suddivisione del set di dati da utilizzare per la formazione e il test. Questi dati val verranno utilizzati in modo implicito per valutare il modello dopo che è stato addestrato. Questo processo è separato dal punteggio.

In questa sezione viene mostrata la funzione split() che prima carica i dati nel blocco appunti, quindi pulisce i dati rimuovendo le colonne non collegate nel set di dati. Da lì, sarà possibile eseguire l'ingegneria delle funzioni, che è il processo per creare ulteriori caratteristiche rilevanti dalle caratteristiche grezze esistenti nei dati. Un esempio di questo processo può essere visto di seguito insieme a una spiegazione.

La funzione split() è mostrata di seguito. Il dataframe fornito nell'argomento verrà suddiviso nelle variabili train e val da restituire.

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

Valutare il modello addestrato

La funzione evaluate() viene eseguita dopo aver eseguito il training del modello e restituirà una metrica per indicare il successo del modello. La funzione evaluate() utilizza le etichette dei set di dati di prova e il modello Trained per prevedere un set di funzioni. Questi valori previsti vengono quindi confrontati con le funzioni effettive nel set di dati di test. Gli algoritmi di punteggio comuni includono:

La funzione evaluate() nell'esempio di vendita al dettaglio è mostrata di seguito:

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

La funzione restituisce un oggetto metric contenente una matrice di metriche di valutazione. Queste metriche verranno utilizzate per valutare le prestazioni del modello addestrato.

File di Data Saver

Il file datasaver.py contiene la funzione save() per salvare la previsione durante il test del punteggio. La funzione save() acquisirà la previsione e utilizzerà le API Experience Platform Catalog, scriverà i dati nel scoringResultsDataSetId specificato nel file scoring.conf.

L'esempio utilizzato nella ricetta di esempio per le vendite al dettaglio è riportato qui. Nota l’utilizzo della libreria DataSetWriter per scrivere dati 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)

Formazione e valutazione

Una volta apportate le modifiche al blocco appunti e desiderate addestrare la ricetta, potete fare clic sui pulsanti associati nella parte superiore della barra per creare un percorso di formazione nella cella. Facendo clic sul pulsante, nel blocco appunti (sotto la cella evaluator.py) viene visualizzato un registro di comandi e output dello script di formazione. Conda prima installa tutte le dipendenze, poi viene avviato il training.

Tieni presente che è necessario eseguire il corso di formazione almeno una volta prima di poter eseguire il punteggio. Facendo clic sul pulsante Run Scoring si otterrà un punteggio sul modello addestrato generato durante l'addestramento. Lo script di punteggio verrà visualizzato in datasaver.py.

A scopo di debug, se desideri visualizzare l’output nascosto, aggiungi debug alla fine della cella di output e rieseguiscila.

Crea ricetta

Dopo aver modificato la ricetta e aver ottenuto l'output di formazione/punteggio, è possibile creare una ricetta dal blocco appunti premendo Create Recipe nella navigazione in alto a destra.

Dopo aver premuto il pulsante, viene richiesto di inserire un nome di ricetta. Questo nome rappresenta la ricetta effettiva creata su Platform.

Una volta premuto Ok sarà possibile passare alla nuova ricetta su Adobe Experience Platform. Puoi fare clic sul pulsante View Recipes per passare alla scheda Recipes in ML Models

Una volta completato il processo, la ricetta avrà un aspetto simile al seguente:

ATTENZIONE
  • Non eliminare nessuna delle celle del file
  • Non modificare la riga %%writefile nella parte superiore delle celle del file
  • Non creare ricette contemporaneamente in diversi notebook

Passaggi successivi

Completando questa esercitazione, hai imparato a creare un modello di apprendimento automatico nel notebook Ricipe Builder. Hai anche imparato a utilizzare il blocco appunti per creare un flusso di lavoro di ricetta all'interno del blocco appunti per creare una ricetta all'interno di Data Science Workspace.

Per continuare a imparare a lavorare con le risorse all’interno di Data Science Workspace, visita il menu a discesa Data Science Workspace ricette e modelli .

Risorse aggiuntive

Il video seguente è progettato per aiutarti a comprendere come creare e distribuire modelli.

In questa pagina