Pacchettizzazione di un'applicazione di addestramento

Prima di poter eseguire l'applicazione di addestramento con AI Platform Training, devi il tuo codice ed eventuali dipendenze in un bucket Cloud Storage Il progetto Google Cloud può accedere. In questa pagina viene illustrato come pacchettizzare e organizzare l'applicazione nel cloud.

Otterrai i risultati migliori se testerai l'applicazione di addestramento localmente prima nel cloud. L'addestramento con AI Platform Training comporta addebita sul tuo account un importo per le risorse utilizzate.

Prima di iniziare

Prima di poter spostare l'applicazione di addestramento nel cloud, è necessario completare segui questi passaggi:

  1. Configura il tuo ambiente di sviluppo, come descritto nella guida introduttiva .

  2. Sviluppa la tua applicazione di addestramento con uno degli AI Platform Training framework di machine learning: TensorFlow, scikit-learn o XGBoost. In alternativa, crea un container personalizzato per personalizzare l'ambiente della tua applicazione di addestramento. Questo ti offre di utilizzare framework di machine learning diversi da AI Platform Training o non strutturati in hosting.

    Se vuoi eseguire il deployment del modello addestrato in AI Platform Prediction dopo l'addestramento, leggi la guida all'esportazione del modello per previsione per assicurarci il pacchetto di addestramento esporta gli artefatti del modello che AI Platform Prediction può utilizzare.

  3. Segui la guida per la configurazione di un'istanza di Cloud Storage di archiviazione in cui puoi archiviare i dati e i file dell'applicazione di addestramento.

  4. Conoscere tutte le librerie Python da cui dipende l'applicazione di addestramento, che si tratti di pacchetti personalizzati o liberamente disponibili tramite PyPI.

Questo documento illustra i seguenti fattori che influenzano il modo in cui crei le presentazioni la tua applicazione e caricarla su Cloud Storage:

  • Utilizzo di gcloud CLI (consigliato) o programmazione della tua soluzione.
  • Creazione manuale del pacchetto, se necessario.
  • Come includere dipendenze aggiuntive che non sono installate dal Runtime AI Platform Training che stai utilizzando.

Il modo più semplice per pacchettizzare la tua applicazione e caricarla insieme delle dipendenze è usare gcloud CLI. Puoi usare un solo comando (gcloud ai-platform jobs submit training) a pacchettizzato e carica l'applicazione, quindi invia il tuo primo job di addestramento.

Per praticità, è utile definire i valori di configurazione come variabili:

PACKAGE_PATH='LOCAL_PACKAGE_PATH'
MODULE_NAME='MODULE_NAME'
STAGING_BUCKET='BUCKET_NAME'
JOB_NAME='JOB_NAME'
JOB_DIR='JOB_OUTPUT_PATH'
REGION='REGION'

Sostituisci quanto segue:

  • LOCAL_PACKAGE_PATH: il percorso della directory del tuo pacchetto Python nel tuo ambiente locale
  • MODULE_NAME: il nome completo della formazione modulo
  • BUCKET_NAME: il nome di un file di Cloud Storage del bucket rimanente
  • JOB_NAME: un nome per il job di addestramento
  • JOB_OUTPUT_PATH: l'URI di un Cloud Storage directory in cui vuoi che il job di addestramento salvi il suo output
  • REGION: la regione in cui vuoi eseguire l'addestramento offerta di lavoro

Ulteriori dettagli sui requisiti per questi valori nell'elenco dopo il .

L'esempio seguente mostra un gcloud ai-platform jobs submit training che pacchettizza un'applicazione e invia il job di addestramento:

gcloud ai-platform jobs submit training $JOB_NAME \
    --staging-bucket=$STAGING_BUCKET \
    --job-dir=$JOB_DIR  \
    --package-path=$PACKAGE_PATH \
    --module-name=$MODULE_NAME \
    --region=$REGION \
    -- \
    --user_first_arg=first_arg_value \
    --user_second_arg=second_arg_value

  • --staging-bucket specifica un bucket Cloud Storage in cui vuoi per organizzare i pacchetti di addestramento e dipendenze. Il tuo progetto Google Cloud deve avere accesso a questo bucket Cloud Storage, mentre il bucket devi trovarti nella stessa regione in cui esegui il job. Vedi i disponibili regioni per i servizi AI Platform Training. Se non specificare un bucket gestione temporanea, AI Platform Training mette i pacchetti in nella località specificata nel parametro job-dir.

  • --job-dir specifica il percorso di Cloud Storage che vuoi utilizzare per i file di output del job di addestramento. Il tuo progetto Google Cloud deve hanno accesso a questo bucket Cloud Storage e il bucket dovrebbe nella stessa regione in cui esegui il job. Consulta le regioni disponibili per i servizi di AI Platform Training.

  • --package-path specifica il percorso locale della directory del tuo un'applicazione. gcloud CLI crea un pacchetto di distribuzione .tar.gz da il codice in base al file setup.py nella directory padre del specificato da --package-path. Successivamente, carica il file .tar.gz su Cloud Storage e lo utilizza per eseguire il job di addestramento.

    Se non è presente alcun file setup.py nella posizione prevista, gcloud CLI crea una semplice setup.py temporanea e include solo la directory specificato da --package-path nel file .tar.gz che crea.

  • --module-name specifica il nome dell'istanza principale utilizzando la notazione punti dello spazio dei nomi del pacchetto. Questo è il file Python che esegui per avviare l'applicazione. Ad esempio, se modulo principale è .../my_application/trainer/task.py (vedi il struttura del progetto consigliata), il nome del modulo è trainer.task.

  • Se specifichi un'opzione sia nel file di configurazione (config.yaml) e come flag della riga di comando, il valore nel riga di comando sostituisce il valore nel file di configurazione.
  • Il flag -- vuoto segna la fine del gcloud di segnalazioni specifiche e l'inizio del USER_ARGS da trasferire alla tua richiesta.
  • I flag specifici per AI Platform Training, --module-name, --runtime-version e --job-dir, deve precedere il flag -- vuoto. Il servizio AI Platform Training interpreta questi flag.
  • Il flag --job-dir, se specificato, deve precedere il carattere flag -- vuoto, perché AI Platform Training utilizza --job-dir per convalidare il percorso.
  • La tua applicazione deve gestire anche il flag --job-dir se specificato. Anche se la bandiera precede il campo -- vuoto, Inoltre, il --job-dir viene passato alla tua richiesta come flag della riga di comando.
  • Puoi definire tutti i USER_ARGS di cui hai bisogno. Pass di AI Platform Training: --user_first_arg, --user_second_arg e così via fino alla tua domanda.

Per ulteriori informazioni sui flag di job-invio, consulta la guida l'esecuzione di un job di addestramento.

Utilizzo delle dipendenze

Le dipendenze sono pacchetti che import nel codice. La tua applicazione potrebbe ha molte dipendenze necessarie per farla funzionare.

Quando esegui un job di addestramento su AI Platform Training, il job viene su istanze di addestramento (macchine virtuali appositamente configurate) che hanno molte pacchetti Python comuni già installati. Verifica i pacchetti inclusi nella versione runtime che utilizzi per l'addestramento, e prendi nota delle eventuali dipendenze che non sono già installate.

Potresti dover aggiungere due tipi di dipendenze:

  • Dipendenze standard, che sono pacchetti Python comuni disponibili su PyPI.
  • Pacchetti personalizzati, ad esempio quelli sviluppati da te o interni a un'organizzazione.

Le sezioni seguenti descrivono la procedura per ogni tipo.

Aggiunta di dipendenze standard (PyPI)

Puoi specificare le dipendenze standard del pacchetto come parte dell'elemento setup.py lo script. AI Platform Training utilizza pip per installare sulle istanze di addestramento allocate per il job. La pip install cerca le dipendenze configurate e le installa.

Crea un file denominato setup.py nella directory principale del tuo (una directory in alto dalla directory trainer se segui pattern consigliato).

Inserisci lo script seguente in setup.py, inserendo i tuoi valori:

from setuptools import find_packages
from setuptools import setup

REQUIRED_PACKAGES = ['some_PyPI_package>=1.0']

setup(
    name='trainer',
    version='0.1',
    install_requires=REQUIRED_PACKAGES,
    packages=find_packages(),
    include_package_data=True,
    description='My training application package.'
)

Se utilizzi Google Cloud CLI per inviare il tuo job di addestramento, usa automaticamente il tuo file setup.py per creare il pacchetto.

Se invii il job di addestramento senza utilizzare gcloud, usa il seguente comando per eseguire lo script:

python setup.py sdist

Per ulteriori informazioni, consulta la sezione sulla pacchettizzazione manuale del materiale di addestramento applicazione.

Aggiunta di dipendenze personalizzate

Puoi specificare le dipendenze personalizzate della tua applicazione passando i relativi percorsi come della configurazione del job. Devi avere l'URI del pacchetto di ogni la dipendenza. Le dipendenze personalizzate devono essere Percorso di Cloud Storage. AI Platform Training utilizza pip install per installare dipendenze personalizzate, in modo che possano avere dipendenze standard nei rispettivi script setup.py.

Se utilizzi gcloud CLI per eseguire il tuo job di addestramento, puoi specificare le dipendenze sulla tua macchina locale, nonché su Cloud Storage, lo strumento li organizzerà automaticamente nel cloud: gcloud ai-platform jobs submit training, imposta --packages per includere le dipendenze in un elenco separato da virgole.

Ogni URI che includi è il percorso di un pacchetto di distribuzione, formattato come tarball (.tar.gz) o come ruota (.whl). AI Platform Training installa ciascuna pacchetto utilizzando pip install su ogni macchina virtuale allocata per il job di addestramento.

L'esempio seguente specifica le dipendenze in pacchetti denominate dep1.tar.gz e dep2.whl (uno per ciascuno dei tipi di pacchetto supportati) insieme a un percorso alle origini dell'applicazione:

gcloud ai-platform jobs submit training $JOB_NAME \
    --staging-bucket $PACKAGE_STAGING_PATH \
    --package-path /Users/mluser/models/faces/trainer \
    --module-name $MODULE_NAME \
    --packages dep1.tar.gz,dep2.whl \
    --region us-central1 \
    -- \
    --user_first_arg=first_arg_value \
    --user_second_arg=second_arg_value

Analogamente, l'esempio seguente specifica dipendenze in pacchetto denominate dep1.tar.gz e dep2.whl (uno per ognuno dei tipi di pacchetto supportati), ma con un'applicazione di addestramento creata:

gcloud ai-platform jobs submit training $JOB_NAME \
    --staging-bucket $PACKAGE_STAGING_PATH \
    --module-name $MODULE_NAME \
    --packages trainer-0.0.1.tar.gz,dep1.tar.gz,dep2.whl
    --region us-central1 \
    -- \
    --user_first_arg=first_arg_value \
    --user_second_arg=second_arg_value

Se esegui job di addestramento utilizzando direttamente l'API AI Platform Training and Prediction, devi organizzare dei pacchetti di dipendenze in una località di Cloud Storage e quindi e utilizzare i percorsi dei pacchetti in quella posizione.

Creazione manuale del pacchetto

La pacchettizzazione del codice Python è un argomento vasto che va ampiamente oltre l'ambito questa documentazione. Per praticità, questa sezione fornisce una panoramica sull'utilizzo Setuptools per creare il tuo pacchetto. Esistono altre librerie che puoi utilizzare per fare la stessa cosa.

Per creare manualmente il pacchetto, procedi nel seguente modo:

  1. In ogni directory del pacchetto dell'applicazione, includi un file denominato __init__.py, che potrebbe essere vuoto o che potrebbe contenere codice che viene eseguito quando di un pacchetto (qualsiasi modulo in quella directory).

  2. Nella directory principale di tutto il codice che vuoi includere nel tuo .tar.gz (una directory più in alto da trainer se segui il pattern consigliato), includi il file Setuptools denominato setup.py che include:

    • Importa istruzioni per setuptools.find_packages e setuptools.setup.

    • Una chiamata a setuptools.setup con (almeno) l'impostazione di questi parametri:

      • _name_ impostato sul nome dello spazio dei nomi del pacchetto.

      • _version_ impostato sul numero di versione di questa build del pacchetto.

      • _install_requires_ è impostato su un elenco di pacchetti richiesti da la tua applicazione, con i requisiti di versione, come 'docutils>=0.3'.

      • _packages_ impostato su find_packages(). Questo indica a Setuptools includi tutte le sottodirectory della directory superiore che contengono un __init__.py file come "importa pacchetti" (puoi importare moduli da questi in Python con istruzioni come from trainer import util) in il tuo "pacchetto di distribuzione" (il file ".tar.gz contenente tutte le codice).

      • _include_package_data_ impostato su True.

  3. Esegui python setup.py sdist per creare il tuo pacchetto di distribuzione .tar.gz.

Struttura consigliata per il progetto

Puoi strutturare la tua applicazione di addestramento nel modo che preferisci. Tuttavia, la seguente struttura è comunemente utilizzata negli esempi di AI Platform Training e fare in modo che l'organizzazione del progetto sia simile agli esempi per aiutarti a seguire gli esempi.

  • Usa una directory di progetto principale contenente il file setup.py.

    Usa la funzione find_packages() di setuptools nel file setup.py per garantire che tutte le sottodirectory vengano incluse nella distribuzione di .tar.gz pacchetto che crei.

  • Utilizza una sottodirectory denominata trainer per archiviare il modulo di applicazione principale.

  • Assegna al modulo di applicazione principale il nome task.py.

  • Crea le eventuali altre sottodirectory nella directory principale del progetto per implementare la tua applicazione.

  • Crea un file __init__.py in ogni sottodirectory. Questi file vengono utilizzati Setuptools per identificare le directory con da pacchettizzare e il campo potrebbe essere vuoto.

Negli esempi di AI Platform Training, la directory trainer di solito contiene i seguenti file sorgente:

  • task.py contiene la logica dell'applicazione che gestisce il job di addestramento.

  • model.py contiene la logica del modello.

  • util.py se presente, contiene il codice per eseguire l'applicazione di addestramento.

Struttura consigliata per un progetto di applicazione di addestramento

Quando esegui gcloud ai-platform jobs submit training, imposta --package-path a trainer. Questo fa sì che gcloud CLI cerchi un file setup.py in parent di trainer, la directory principale del progetto.

Moduli Python

Il pacchetto dell'applicazione può contenere più moduli (file Python). Devi identificare il modulo che contiene il punto di ingresso dell'applicazione. La formazione esegue il modulo richiamando Python, così come lo eseguiresti in locale.

Ad esempio, se segui la struttura consigliata della sezione precedente, Il tuo modulo principale è task.py. Poiché si trova all'interno di un pacchetto di importazione (directory con un file __init__.py) denominato trainer, il nome completo di questo è trainer.task. Quindi, se invii il tuo lavoro con gcloud ai-platform jobs submit training, imposta il valore --module-name per trainer.task.

Fai riferimento alla guida Python per pacchi per ulteriori informazioni sui moduli.

Utilizzo di gcloud CLI per caricare un pacchetto esistente

Se crei il pacchetto autonomamente, puoi caricarlo con gcloud CLI. Esegui l' Comando gcloud ai-platform jobs submit training:

  • Imposta il flag --packages sul percorso dell'applicazione in pacchetto.

  • Imposta il flag --module-name sul nome dell'istanza principale della tua applicazione utilizzando la notazione punti dello spazio dei nomi del pacchetto. Questo è il file Python che esegui per avviare l'applicazione. Ad esempio, se modulo principale è .../my_application/trainer/task.py (vedi il struttura del progetto consigliata), il nome del modulo è trainer.task.

L'esempio seguente mostra come utilizzare un pacchetto tarball compresso (chiamato trainer-0.0.1.tar.gz) che si trova nella stessa directory in cui esegui il comando . La funzione principale è in un modulo chiamato task.py:

gcloud ai-platform jobs submit training $JOB_NAME \
    --staging-bucket $PACKAGE_STAGING_PATH \
    --job-dir $JOB_DIR \
    --packages trainer-0.0.1.tar.gz \
    --module-name $MODULE_NAME \
    --region us-central1 \
    -- \
    --user_first_arg=first_arg_value \
    --user_second_arg=second_arg_value

Utilizzo di gcloud CLI per usare un pacchetto esistente già nel cloud

Se crei il pacchetto autonomamente e caricarlo in un percorso di Cloud Storage, puoi gcloud. Esegui l' Comando gcloud ai-platform jobs submit training:

  • Imposta il flag --packages sul percorso dell'applicazione in pacchetto.

  • Imposta il flag --module-name sul nome dell'istanza principale della tua applicazione utilizzando la notazione punti dello spazio dei nomi del pacchetto. Questo è il file Python che esegui per avviare l'applicazione. Ad esempio, se modulo principale è .../my_application/trainer/task.py (vedi il struttura del progetto consigliata), il nome del modulo è trainer.task.

L'esempio seguente mostra come utilizzare un pacchetto tarball compresso che si trova in un Bucket Cloud Storage:

gcloud ai-platform jobs submit training $JOB_NAME \
    --job-dir $JOB_DIR \
    --packages $PATH_TO_PACKAGED_TRAINER \
    --module-name $MODULE_NAME \
    --region us-central1 \
    -- \
    --user_first_arg=first_arg_value \
    --user_second_arg=second_arg_value

Dove $PATH_TO_PACKAGED_TRAINER è una variabile di ambiente che rappresenta il percorso di un pacchetto esistente già nel cloud. Ad esempio, il percorso potrebbe puntare alla seguente posizione di Cloud Storage, contenente un pacchetto tarball compresso chiamato trainer-0.0.1.tar.gz:

PATH_TO_PACKAGED_TRAINER=gs://$CLOUD_STORAGE_BUCKET_NAME/trainer-0.0.0.tar.gz

Caricare manualmente i pacchetti

Se hai un motivo, puoi caricare i pacchetti manualmente. Le più comuni è che vuoi chiamare direttamente l'API AI Platform Training and Prediction per avviare un lavoro di addestramento lungo. Il modo più semplice per caricare manualmente il tuo pacchetto e qualsiasi al bucket Cloud Storage è utilizzare Strumento Comandi gcloud storage:

gcloud storage cp /local/path/to/package.tar.gz  gs://bucket/path/

Tuttavia, se puoi utilizzare la riga di comando per questa operazione, devi semplicemente utilizzare Da gcloud ai-platform jobs submit training a caricare i pacchetti durante la configurazione di un un lavoro di addestramento lungo. Se non puoi utilizzare la riga di comando, puoi utilizzare alla libreria client di Cloud Storage per il caricamento in modo programmatico.

Passaggi successivi

Avanti
Esecuzione di un job di addestramento