Questa esercitazione illustra i passaggi necessari per creare un modello utilizzando il modello di generazione delle ricette per i notebook JupyterLab.
Prima di procedere con questa esercitazione, devi creare gli schemi e i set di dati richiesti. Visita il tutorial per creazione di schemi e set di dati del modello di propensione Luma per scaricare le risorse richieste e impostare i prerequisiti.
La creazione di una ricetta da zero può essere fatta in Data Science Workspace. Per iniziare, passa a Adobe Experience Platform e seleziona la Notebook a sinistra. Per creare un nuovo blocco appunti, selezionare il modello di Generatore di ricette dal JupyterLab Launcher.
La Generatore di ricette il notebook consente di eseguire operazioni di formazione e valutazione all'interno del blocco appunti. Ciò offre la flessibilità di apportare modifiche alle train()
e score()
metodi 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 e pubblicarla come modello utilizzando la ricetta per la funzionalità del modello.
La Generatore di ricette il notebook supporta l'utilizzo di tutti i formati di file, ma attualmente la funzionalità crea ricetta supporta solo Python.
Quando selezioni la Generatore di ricette blocco appunti dal modulo di avvio, il blocco appunti viene aperto in una nuova scheda.
Nella nuova scheda del blocco appunti nella parte superiore, viene caricata una barra degli strumenti contenente tre azioni aggiuntive: Treno, Punteggio e Crea ricetta. Queste icone vengono visualizzate solo nel Generatore di ricette blocco appunti. Vengono fornite ulteriori informazioni su queste azioni nella sezione formazione e valutazione dopo aver creato la Ricetta nel blocco appunti.
Nella cartella delle risorse fornita è presente un modello di propensione Luma propensity_model.ipynb
. Utilizzando l'opzione di caricamento del blocco appunti in JupyterLab, carica il modello fornito e apri il blocco appunti.
Il resto di questa esercitazione copre i seguenti file predefiniti nel blocco appunti del modello di propensione:
Il seguente video tutorial spiega il blocco appunti del modello di propensione Luma:
Il file dei requisiti viene utilizzato per dichiarare librerie aggiuntive da utilizzare nel modello. 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
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, la name
impossibile ignorare il campo.
Per il blocco appunti del modello di propensione Luma, non è necessario aggiornare i requisiti.
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.
Affinché un modello esegua un corso di formazione, è necessario fornire trainingDataSetId
, ACP_DSW_TRAINING_XDM_SCHEMA
e tenantId
. Inoltre, per ottenere il punteggio, devi fornire scoringDataSetId
, tenantId
e scoringResultsDataSetId
.
Per trovare il set di dati e gli ID dello schema, vai alla scheda dati nei blocchi appunti sulla barra di navigazione a sinistra (sotto l'icona della cartella). È necessario fornire tre ID di set di dati diversi. La
scoringResultsDataSetId
viene utilizzato per memorizzare i risultati del punteggio del modello e deve essere un set di dati vuoto. Questi set di dati sono stati creati in precedenza in Risorse necessarie passo.
Le stesse informazioni sono disponibili su Adobe Experience Platform in Schema e Set di dati schede.
Una volta completata la concorrenza, la configurazione di formazione e punteggio deve essere simile alla seguente schermata:
Per impostazione predefinita, i seguenti parametri di configurazione vengono impostati automaticamente quando si addestrano e si assegnano i dati di punteggio:
ML_FRAMEWORK_IMS_USER_CLIENT_ID
ML_FRAMEWORK_IMS_TOKEN
ML_FRAMEWORK_IMS_ML_TOKEN
ML_FRAMEWORK_IMS_TENANT_ID
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à eseguite dal caricatore dati di formazione:
Le due sezioni seguenti esamineranno il caricamento dei dati e la preparazione dei dati.
Questo passaggio utilizza dataframe panda. I dati possono essere caricati da file in Adobe Experience Platform utilizzando Platform SDK (platform_sdk
) o da fonti esterne che utilizzano i panda read_csv()
o read_json()
funzioni.
Nel blocco appunti del Generatore di ricette, i dati vengono caricati tramite il platform_sdk
caricatore dati.
Per un'esercitazione approfondita sull'utilizzo di platform_sdk
data loader, visitare il Guida all’SDK per Platform. Questa esercitazione fornisce informazioni sull’autenticazione della build, sulla lettura di base dei dati e sulla scrittura di base dei dati.
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. La data
argomento è il percorso del file CSV. Variabile importata dalla variabile configProperties
in sezione precedente.
df = pd.read_csv(data)
Puoi anche importare da un file JSON. La data
argomento è il percorso del file CSV. Variabile importata dalla variabile configProperties
in sezione precedente.
df = pd.read_json(data)
Ora i dati si trovano nell’oggetto dataframe e possono essere analizzati e manipolati nel sezione successiva.
In questo esempio, i dati vengono caricati 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 possibile utilizzare la load()
per acquisire il set di dati di formazione dal trainingDataSetId
come impostato nella 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, dataset_id=config_properties['trainingDataSetId'])
Come indicato nella Sezione File di configurazione, i seguenti parametri di configurazione sono impostati per l'utente quando si accede ai dati da Experience Platform utilizzando client_context = get_client_context(config_properties)
:
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.
Una volta caricati i dati, questi devono essere puliti e sottoposti alla preparazione dei dati. In questo esempio, l'obiettivo del modello è quello di prevedere se un cliente ordinerà o meno un prodotto. Poiché il modello non visualizza prodotti specifici, non è necessario productListItems
e quindi la colonna viene eliminata. Vengono quindi eliminate ulteriori colonne che contengono solo un singolo valore o due valori in una singola colonna. Durante l'addestramento di un modello, è importante conservare solo i dati utili che vi aiuteranno a prevedere il vostro obiettivo.
Una volta eliminati i dati superflui, puoi iniziare a progettare funzionalità. I dati demo utilizzati per questo esempio non contengono informazioni sulla sessione. Normalmente, si desidera disporre di dati sulle sessioni correnti e passate per un particolare cliente. A causa della mancanza di informazioni sulle sessioni, questo esempio imita invece le sessioni correnti e passate tramite la demarcazione del percorso.
Una volta completata la delimitazione, i dati vengono etichettati e viene creato un percorso.
Successivamente, le feature vengono create e suddivise in passato e presente. Quindi, tutte le colonne non necessarie vengono eliminate, lasciandoti con i percorsi passati e correnti per i clienti Luma. Questi percorsi contengono informazioni quali se un cliente ha acquistato un articolo e il percorso che ha preso prima dell'acquisto.
La procedura per caricare i dati per il punteggio è simile al caricamento dei dati di formazione. Osservando attentamente il codice, puoi vedere che tutto è lo stesso tranne che per il scoringDataSetId
in dataset_reader
. Questo perché la stessa origine dati Luma viene utilizzata sia per la formazione che per il punteggio.
Nel caso in cui si desideri utilizzare file di dati diversi per la formazione e il punteggio, il caricatore di dati di formazione e valutazione è separato. Ciò ti consente di eseguire ulteriori operazioni di pre-elaborazione, ad esempio la mappatura dei dati di formazione sui dati di valutazione, se necessario.
La pipeline.py
include la logica per la formazione e il punteggio.
Lo scopo della formazione è quello di creare un modello utilizzando caratteristiche ed etichette nel set di dati di formazione. Dopo aver scelto il modello di formazione, è necessario inserire il set di dati x e y di formazione nel modello e la funzione restituisce il modello addestrato.
Le feature si riferiscono alla variabile di input utilizzata dal modello di apprendimento automatico per prevedere le etichette.
La score()
La funzione deve contenere l'algoritmo di punteggio e restituire una misurazione per indicare il successo del modello. La 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 score()
utilizza il modello addestrato per prevedere le feature utilizzando le etichette del set di dati di punteggio. Vengono restituite le funzionalità previste.
La evaluator.py
Il file contiene la logica che indica come valutare la ricetta formata e come suddividere i dati di formazione.
La fase di preparazione dei dati per la formazione richiede la suddivisione del set di dati da utilizzare per la formazione e il test. Questo val
i dati vengono utilizzati in modo implicito per valutare il modello dopo l’addestramento. Questo processo è separato dal punteggio.
Questa sezione mostra split()
funzione che carica i dati nel blocco appunti, quindi pulisce i dati rimuovendo le colonne non correlate nel set di dati. Da lì, è possibile eseguire l'ingegneria delle funzioni, che è il processo per creare ulteriori caratteristiche rilevanti dalle caratteristiche non elaborate esistenti nei dati.
La evaluate()
viene eseguita dopo che il modello è stato addestrato e restituisce una metrica per indicare il successo del modello. La evaluate()
utilizza le etichette del set di dati di prova e il modello addestrato per prevedere un set di funzioni. Questi valori previsti vengono quindi confrontati con le funzioni effettive nel set di dati di test. In questo esempio le metriche utilizzate sono precision
, recall
, f1
e accuracy
. Si noti che la funzione restituisce un metric
oggetto contenente un array di metriche di valutazione. Queste metriche vengono utilizzate per valutare le prestazioni del modello addestrato.
Aggiunta print(metric)
consente di visualizzare i risultati della metrica.
La datasaver.py
il file contiene save()
e viene utilizzato per salvare la previsione durante il test del punteggio. La save()
prende la previsione e utilizza Experience Platform Catalog API, scrive i dati nel scoringResultsDataSetId
hai specificato nel tuo scoring.conf
file. È possibile
Una volta apportate le modifiche al blocco appunti e desiderate addestrare la ricetta, è possibile selezionare i pulsanti associati nella parte superiore della barra per creare un percorso di formazione nella cella. Quando si seleziona il pulsante, nel blocco appunti viene visualizzato un registro di comandi e output dello script di addestramento (sotto il evaluator.py
(cella). 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. Selezione della Eseguire il punteggio Il pulsante eseguirà il punteggio sul modello addestrato generato durante l'addestramento. Lo script di punteggio viene visualizzato in datasaver.py
.
A scopo di debug, se desideri visualizzare l’output nascosto, aggiungi debug
alla fine della cella di output e rieseguirla.
Dopo aver modificato la ricetta e aver ottenuto l'output di formazione/punteggio, è possibile creare una ricetta dal blocco appunti selezionando Crea ricetta in alto a destra.
Dopo aver selezionato Crea ricetta, viene richiesto di immettere un nome per la ricetta. Questo nome rappresenta la ricetta effettiva creata in Platform.
Dopo aver selezionato Ok, inizia il processo di creazione delle ricette. Questo può richiedere un po' di tempo e viene visualizzata una barra di avanzamento al posto del pulsante crea ricetta. Una volta completato, puoi selezionare il Visualizza ricette per portarti al Ricette scheda sotto Modelli ML
%%writefile
riga nella parte superiore delle celle del fileCompletando questa esercitazione, hai imparato a creare un modello di apprendimento automatico nel Generatore di ricette blocco appunti. Hai anche imparato a utilizzare il blocco appunti per creare un flusso di lavoro di ricetta.
Per continuare a imparare a utilizzare le risorse in Data Science Workspace, visitare il Data Science Workspace menu a discesa ricette e modelli .