Creare un modello utilizzando JupyterLab Notebooks
Questo tutorial illustra i passaggi necessari per creare un modello utilizzando il modello per la generazione di formule dei notebook JupyterLab.
Concetti introdotti:
- Ricette: una ricetta è il termine di Adobe Systems per una specifica del modello ed è un contenitore di primo livello che rappresenta uno specifico algoritmo di apprendimento automatico, intelligenza artificiale o insieme di algoritmi, logica di elaborazione e configurazione necessari per versione ed eseguire un modello addestrato.
- Modello: un modello è un istanza di una ricetta di apprendimento automatico che viene addestrato utilizzando dati e configurazioni cronologici per risolvere un caso d'uso aziendale.
- Formazione: la formazione è il processo di apprendimento di modelli e approfondimenti da dati etichettati.
- Punteggio: Il punteggio è il processo di generazione di informazioni dai dati utilizzando un modello addestrato.
Scarica la risorse richiesta assets
Prima di procedere con questa esercitazione, è necessario creare gli schemi e i set di dati necessari. Visita l'esercitazione per la creazione di schemi e set di dati del modello di propensione Luma per scaricare i risorse richiesti e impostare i prerequisiti.
Introduzione all'ambiente JupyterLab notebook
La creazione di una ricetta da zero può essere eseguita all'interno di Data Science Workspace. Per iniziare, passare a Adobe Experience Platform e selezionare la scheda Blocchi appunti a sinistra. Per creare un nuovo blocco appunti, selezionare il modello Generatore di ricette da .JupyterLab Launcher
Il blocco appunti Generatore di ricette consente di eseguire attività di formazione e punteggio all'interno del blocco appunti. Questo offre la flessibilità di apportare modifiche ai metodi train() e score() tra l'esecuzione di esperimenti sui dati di apprendimento e 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à.
Quando si seleziona il blocco appunti 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 blocco appunti Generatore di ricette. Ulteriori informazioni su queste azioni sono fornite nella sezione formazione e punteggio dopo aver creato la ricetta nel blocco appunti.
Introduzione al blocco appunti di Recipe Builder
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:
File dei requisiti requirements-file
Il file dei requisiti viene utilizzato per dichiarare librerie aggiuntivi che si desidera utilizzare nel modello. È possibile specificare il numero di versione se esiste una dipendenza. Per cercare altri librerie, visita anaconda.org. Per informazioni su come formattare il file dei requisiti, visita Conda. L'elenco delle principali librerie già in uso include:
python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python
name non può essere sostituito.Per il notebook con propensione Luma, non è necessario aggiornare i requisiti.
File di configurazione configuration-files
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 e per aggiungere iperparametri. Esistono configurazioni separate per l’apprendimento e il punteggio.
Affinché un modello possa eseguire training, è necessario fornire , trainingDataSetId ACP_DSW_TRAINING_XDM_SCHEMAe tenantId. Inoltre, per il punteggio, è necessario specificare , scoringDataSetId tenantId, e scoringResultsDataSetId .
Per trovare gli ID del set di dati e dello schema, passare alla scheda
scoringResultsDataSetId utilizzato per store i risultati del punteggio del modello e deve essere un set di dati vuoto. Questi set di dati venivano creati in precedenza nel passaggio risorse 🔗 Richiesto.
Le stesse informazioni sono disponibili in Adobe Experience Platform nelle schede Schema e Set di dati.
Una volta gareggiato, la tua configurazione di training e punteggio dovrebbe essere simile alla seguente schermata:
Per impostazione predefinita, quando si addestrano e si assegnano punteggi ai dati vengono impostati i seguenti parametri di configurazione:
ML_FRAMEWORK_IMS_USER_CLIENT_IDML_FRAMEWORK_IMS_TOKENML_FRAMEWORK_IMS_ML_TOKENML_FRAMEWORK_IMS_TENANT_ID
Informazioni su Training Data Loader training-data-loader
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à:
- Caricamento di dati da Platform
- Preparazione dei dati e progettazione delle funzioni
Nelle due sezioni seguenti verranno descritti i passaggi necessari per caricare i dati e preparare i dati.
Caricamento dei dati loading-data
Questo passaggio utilizza il dataframe panda. I dati possono essere caricati dai file in Adobe Experience Platform utilizzando l'SDK Platform (platform_sdk) o da origini esterne utilizzando le funzioni read_csv() o read_json() dei panda.
platform_sdk.Platform SDK platform-sdk
Per un'esercitazione approfondita sull'utilizzo del caricatore dati platform_sdk, visita la guida dell'SDK di Platform. Questo tutorial fornisce informazioni sull’autenticazione della build, sulla lettura di base dei dati e sulla scrittura di base dei dati.
Sorgenti esterne external-sources
Questa sezione mostra come importare un file JSON o CSV in un oggetto panda. La documentazione ufficiale del libreria dei panda può essere trovata qui:
Innanzitutto, ecco un esempio di importazione di un file CSV. L'argomento data è il percorso del file CSV. Questa variabile è stata importata dalla configProperties sezione precedente🔗.
df = pd.read_csv(data)
Puoi anche importare da un file JSON. L'argomento data è 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 modificati nella sezione successiva.
Training Data Loader File
In questo esempio, i dati vengono caricati utilizzando l'SDK Platform. Il libreria può essere importato nella parte superiore della pagina includendo la riga:
from platform_sdk.dataset_reader import DatasetReader
È quindi possibile utilizzare il load() metodo per acquisire il set di dati training dal trainingDataSetId set di dati as 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, dataset_id=config_properties['trainingDataSetId'])
client_context = get_client_context(config_properties):ML_FRAMEWORK_IMS_USER_CLIENT_IDML_FRAMEWORK_IMS_TOKENML_FRAMEWORK_IMS_ML_TOKENML_FRAMEWORK_IMS_TENANT_ID
Ora che disponi dei tuoi dati, puoi iniziare con la preparazione dei dati e la progettazione delle funzionalità.
Preparazione dei dati e progettazione delle funzioni data-preparation-and-feature-engineering
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 esamina prodotti specifici, non è necessario productListItems e pertanto la colonna viene eliminata. Vengono quindi eliminate colonne aggiuntive che contengono un solo valore o due valori in una singola colonna. Quando training un modello, è importante conservare solo dati utili che aiuteranno 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 relativi alla sessione corrente e a quella passata 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 demarcazione, i dati vengono etichettati e viene creato un percorso.
Successivo, le feature vengono create e suddivise in passato e presente. Quindi, tutte le colonne non necessarie vengono eliminate, lasciandoti con entrambi i viaggi passati e attuali per i clienti Luma. Questi percorsi contengono informazioni come se un cliente ha acquistato un articolo e il percorso che ha intrapreso prima dell'acquisto.
Caricamento dati punteggio scoring-data-loader
La procedura per caricare i dati per il punteggio è simile al caricamento dei dati di apprendimento. Esaminando attentamente il codice, è possibile notare che tutto è lo stesso tranne che per scoringDataSetId in 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.
File di pipeline pipeline-file
Il file pipeline.py include la logica per l'apprendimento e il punteggio.
Lo scopo di training è creare un modello utilizzando feature ed etichette nel set di dati training. 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.
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 score() funzione utilizza il modello sottoposto a training per stimare le feature utilizzando le etichette del set di dati di punteggio. Vengono restituite le funzionalità previste.
File valutatore evaluator-file
Il evaluator.py file contiene la logica su come si desidera valutare la ricetta addestrata e su come i dati di training devono essere suddivisi.
Suddividere il set di dati split-the-dataset
La fase di preparazione dei dati per l’addestramento richiede la suddivisione del set di dati da utilizzare per l’addestramento e il test. Questi dati di val vengono utilizzati in modo implicito per valutare il modello dopo che è stato addestrato. Questo processo è separato dal punteggio.
Questa sezione mostra la funzione split() che carica i dati nel blocco appunti, quindi li pulisce 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.
Valutare il modello sottoposto a training evaluate-the-trained-model
La funzione evaluate() viene eseguita dopo che il modello è stato addestrato e restituisce una metrica per indicare il successo del modello. La funzione evaluate() utilizza le etichette del set di dati di test e il modello addestrato per prevedere un set di funzionalità. 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 oggetto metric contenente un array di metriche di valutazione. Queste metriche vengono utilizzate per valutare le prestazioni del modello addestrato.
L'aggiunta di print(metric) consente di visualizzare i risultati della metrica.
File di Data Saver data-saver-file
Il file datasaver.py contiene la funzione save() e viene utilizzato per salvare la previsione durante il test del punteggio. La funzione save() esegue la previsione e utilizza le API Experience Platform Catalog, scrive i dati in scoringResultsDataSetId specificati nel file scoring.conf. È possibile
Formazione e valutazione training-and-scoring
Al termine delle modifiche apportate al blocco appunti e si desidera eseguire il training della ricetta, è possibile selezionare i pulsanti associati nella parte superiore della barra alla creazione di un training eseguito nella cella. Dopo aver selezionato il pulsante, un registro dei comandi e degli output dello script training viene visualizzato nel blocco appunti (sotto la evaluator.py cella). Conda installa prima tutte le dipendenze, quindi viene avviata la training.
Si noti che è necessario eseguire training almeno una volta prima di poter eseguire il punteggio. Selezionando l'pulsante Punteggio esecuzione verrà assegnato un punteggio sul modello sottoposto a training generato durante training. Lo script del punteggio viene visualizzato in datasaver.py.
Per motivi di debug, se si desidera visualizzare l'output nascosto, aggiungere debug alla fine della cella di output ed eseguirlo nuovamente.
Crea una ricetta create-recipe
Quando hai finito di modificare la ricetta e sei soddisfatto dell'output training/punteggio, puoi creare una ricetta dal quaderno 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 vera e propria creata su Platform.
Una volta selezionato OK, inizia il processo di creazione della ricetta. Questa operazione può richiedere del tempo e viene visualizzata una barra di avanzamento al posto della pulsante Crea ricetta. Al termine, puoi selezionare il pulsante Visualizza ricette per passare alla scheda Ricette in Modelli ML
- Non eliminare nessuna delle celle del file
- Non modificare la riga
%%writefilenella parte superiore delle celle del file - Non creare ricette in diversi notebook contemporaneamente
Passaggi successivi next-steps
Completando questa esercitazione, hai imparato a creare un modello di apprendimento automatico nel blocco appunti Recipe Builder. Hai anche imparato a sfruttare il blocco appunti per il flusso di lavoro della ricetta.
Per continuare a imparare come lavorare con le risorse all'interno Data Science Workspacedi , visita il menu a discesa di Data Science Workspace ricette e modelli.