Questo tutorial illustra i passaggi necessari per creare un modello utilizzando il modello per la generazione di formule dei notebook JupyterLab.
Prima di procedere con questa esercitazione, è necessario 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 eseguita 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.
Il Generatore di ricette notebook consente di eseguire esecuzioni di formazione e punteggio all'interno del notebook. Questo offre la flessibilità di apportare modifiche alle train()
e score()
metodi tra l’esecuzione di esperimenti sull’addestramento e i dati di punteggio. Una volta soddisfatti dei risultati di formazione e punteggio, puoi creare una ricetta e pubblicarla ulteriormente come modello utilizzando la ricetta per modellare la funzionalità.
Il Generatore di ricette il notebook supporta l’utilizzo di tutti i formati di file, ma al momento la funzionalità crea ricetta supporta solo Python.
Quando selezioni il Generatore di ricette 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: Addestra, Punteggio, e Crea ricetta. Queste icone vengono visualizzate solo nel Generatore di ricette notebook. Vengono fornite ulteriori informazioni su queste azioni nella sezione formazione e punteggio 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 carica notebook in JupyterLab, carica il modello fornito e apri il notebook.
Il resto di questo tutorial riguarda i seguenti file predefiniti nel notebook del modello di propensione:
Il seguente tutorial video spiega il notebook con modello di propensione Luma:
Il file dei requisiti viene utilizzato per dichiarare librerie aggiuntive da utilizzare nel modello. Se esiste una dipendenza, puoi specificare il numero di versione. Per cercare altre librerie, visita anaconda.org. Per informazioni su come formattare il file dei requisiti, visitare 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, il name
il campo non può essere sostituito.
Per il notebook con 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 l’apprendimento e il punteggio, nonché per aggiungere iperparametri. Esistono configurazioni separate per l’apprendimento e il punteggio.
Affinché un modello possa eseguire l’apprendimento, devi fornire trainingDataSetId
, ACP_DSW_TRAINING_XDM_SCHEMA
, e tenantId
. Inoltre, per il punteggio, devi fornire scoringDataSetId
, tenantId
, e scoringResultsDataSetId
.
Per trovare il set di dati e gli ID dello schema, passa alla scheda dati all'interno di blocchi appunti sulla barra di spostamento a sinistra (sotto l'icona della cartella ). È necessario fornire tre ID di set di dati diversi. Il
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 richieste passaggio.
Le stesse informazioni sono disponibili su Adobe Experience Platform sotto Schema e Set di dati schede.
Al termine del concorso, la configurazione di apprendimento e punteggio dovrà essere simile alla schermata seguente:
Per impostazione predefinita, quando si addestrano e si assegnano punteggi 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
Lo scopo del caricatore dati di formazione è quello di creare un’istanza dei dati utilizzati per creare il modello di apprendimento automatico. In genere, il caricatore di dati di formazione esegue due attività:
Nelle due sezioni seguenti verranno descritti i passaggi necessari per caricare i dati e preparare i dati.
Questo passaggio utilizza dataframe panda. I dati possono essere caricati dai 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 di Recipe Builder, i dati vengono caricati tramite platform_sdk
caricatore di dati.
Per un tutorial approfondito sull’utilizzo di platform_sdk
caricatore di dati, visita il Guida all’SDK di Platform. Questo tutorial 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 libreria dei panda è disponibile qui:
Innanzitutto, ecco un esempio di importazione di un file CSV. Il data
è il percorso del file CSV. Questa variabile è stata importata da configProperties
nel sezione precedente.
df = pd.read_csv(data)
Puoi anche importare da un file JSON. Il data
è il percorso del file CSV. Questa variabile è stata importata da configProperties
nel 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 load()
metodo per acquisire il set di dati di formazione da 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 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 la progettazione delle funzionalità.
Dopo il caricamento dei dati, è necessario pulirli e prepararli. In questo esempio, l’obiettivo del modello è prevedere se un cliente ordinerà o meno un prodotto. Poiché il modello non considera prodotti specifici, non è necessario productListItems
e quindi la colonna viene eliminata. Vengono quindi eliminate colonne aggiuntive che contengono un solo valore o due valori in una singola colonna. Durante l’apprendimento di un modello, è importante conservare solo dati utili che ti aiutino a prevedere il tuo obiettivo.
Una volta eliminati i dati non necessari, puoi iniziare la progettazione delle funzionalità. I dati demo utilizzati per questo esempio non contengono informazioni sulla sessione. In genere, è necessario disporre di dati sulle sessioni correnti e passate per un determinato cliente. A causa della mancanza di informazioni sulla sessione, questo esempio imita le sessioni attuali e precedenti 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. Vengono quindi eliminate tutte le colonne non necessarie, lasciando ai clienti Luma sia i percorsi passati che quelli correnti. Questi percorsi contengono informazioni quali se un cliente ha acquistato un articolo e il percorso che ha utilizzato prima dell’acquisto.
La procedura per caricare i dati per il punteggio è simile al caricamento dei dati di apprendimento. Osservando attentamente il codice, puoi notare che tutto è uguale, tranne che per scoringDataSetId
nel dataset_reader
. Questo perché la stessa origine dati Luma viene utilizzata sia per l’apprendimento che per il punteggio.
Nel caso in cui si desideri utilizzare file di dati diversi per l’apprendimento e il punteggio, il caricatore di dati per l’apprendimento e il punteggio è separato. Questo ti consente di eseguire una pre-elaborazione aggiuntiva, ad esempio la mappatura dei dati di apprendimento ai dati di punteggio, se necessario.
Il pipeline.py
Il file include la logica per l’apprendimento e il punteggio.
Lo scopo dell’apprendimento è quello di creare un modello utilizzando le funzioni e le etichette nel set di dati di apprendimento. Dopo aver scelto il modello di apprendimento, devi adattare il set di dati di apprendimento x e y al modello e la funzione restituisce il modello addestrato.
Le funzioni si riferiscono alla variabile di input utilizzata dal modello di apprendimento automatico per prevedere le etichette.
Il score()
La funzione deve contenere l’algoritmo di punteggio e restituire una misurazione per indicare il successo del modello. Il score()
La funzione utilizza le etichette dei 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 proprietà score()
la funzione utilizza il modello addestrato per prevedere le feature utilizzando le etichette del set di dati di punteggio. Vengono restituite le funzioni previste.
Il evaluator.py
Il file contiene informazioni logiche su come valutare la ricetta formata e su come suddividere i dati di formazione.
La fase di preparazione dei dati per l’addestramento richiede la suddivisione del set di dati da utilizzare per l’addestramento e il test. Questo val
I dati vengono utilizzati implicitamente per valutare il modello dopo che è stato addestrato. Questo processo è separato dal punteggio.
Questa sezione mostra split()
funzione che carica i dati nel blocco appunti, quindi pulisce i dati rimuovendo colonne non correlate nel set di dati. Da qui è possibile eseguire la progettazione delle feature, ovvero il processo per creare ulteriori feature rilevanti dalle feature raw esistenti nei dati.
Il evaluate()
La funzione viene eseguita dopo che il modello è stato addestrato e restituisce una metrica per indicare il successo del modello. Il evaluate()
La funzione utilizza le etichette dei set di dati di test e il modello addestrato per prevedere un set di feature. 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
. La funzione restituisce un valore metric
oggetto contenente un array di metriche di valutazione. Queste metriche vengono utilizzate per valutare le prestazioni del modello addestrato.
Aggiunta print(metric)
ti consente di visualizzare i risultati della metrica.
Il datasaver.py
il file contiene save()
e viene utilizzato per salvare la previsione durante il test del punteggio. Il save()
prende le tue previsioni e utilizza Experience Platform Catalog API, scrive i dati in scoringResultsDataSetId
hai specificato in scoring.conf
file. È possibile
Una volta apportate le modifiche al blocco appunti e si desidera addestrare la composizione, è possibile selezionare i pulsanti associati nella parte superiore della barra per creare un'esecuzione di addestramento nella cella. Quando si seleziona il pulsante, nel blocco appunti viene visualizzato un registro di comandi e output dello script di addestramento (sotto evaluator.py
). Conda installa prima tutte le dipendenze, quindi viene avviato l’addestramento.
È necessario eseguire l’apprendimento almeno una volta prima di poter eseguire il punteggio. Selezione del Esegui punteggio Pulsante assegnerà un punteggio al 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 ed eseguirla nuovamente.
Una volta completata la modifica della ricetta e soddisfatti dell’output di formazione/punteggio, puoi 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 il Platform.
Dopo aver selezionato Ok, inizia il processo di creazione della ricetta. Questa operazione può richiedere del tempo e al posto del pulsante Crea composizione viene visualizzata una barra di avanzamento. Al termine, puoi selezionare Visualizza ricette per passare al Ricette scheda in Modelli ML
%%writefile
riga nella parte superiore delle celle del fileCompletando questa esercitazione, hai imparato a creare un modello di apprendimento automatico in Generatore di ricette notebook. Hai anche imparato a sfruttare il blocco appunti per il flusso di lavoro della ricetta.
Per continuare a imparare a utilizzare le risorse in Data Science Workspace, visitare il sito Data Science Workspace elenco a discesa ricette e modelli.