Guida all'utilizzo

L'API tfc.run ti consente di addestrare i tuoi modelli su larga scala su GCP.

L'API tfc.run può essere utilizzata in quattro modi diversi. Questo è definito da dove stai eseguendo l'API (script Python vs notebook Python) e dal parametro entry_point :

• File Python come entry_point .
• File del notebook come entry_point .
• run all'interno di uno script Python che contiene il modello tf.keras .
• run all'interno di uno script notebook che contiene il modello tf.keras . Il modo più comune è utilizzare run all'interno di un notebook.

entry_point è uno script Python o un file notebook (percorso di uno) oppure None . Se None , l'intero file corrente viene inviato a Google Cloud.

Utilizzando un file Python come entry_point .

Se hai il tuo modello tf.keras in un file Python ( mnist_example.py ), puoi scrivere il seguente semplice script ( scale_mnist.py ) per ridimensionare il tuo modello su GCP.

import tensorflow_cloud as tfc
tfc.run(entry_point='mnist_example.py')

Tieni presente che tutti i file nella stessa struttura di directory di entry_point verranno compressi nell'immagine docker creata, insieme al file entry_point . Si consiglia di creare una nuova directory per ospitare ogni progetto cloud che includa i file necessari e nient'altro, per ottimizzare i tempi di creazione dell'immagine.

Utilizzando un file notebook come entry_point .

Se hai il tuo modello tf.keras in un file notebook ( mnist_example.ipynb ), puoi scrivere il seguente semplice script ( scale_mnist.py ) per ridimensionare il tuo modello su GCP.

import tensorflow_cloud as tfc
tfc.run(entry_point='mnist_example.ipynb')

Tieni presente che tutti i file nella stessa struttura di directory di entry_point verranno compressi nell'immagine docker creata, insieme al file entry_point . Come lo script Python entry_point sopra, consigliamo di creare una nuova directory per ospitare ogni progetto cloud che includa i file necessari e nient'altro, per ottimizzare i tempi di creazione dell'immagine.

Utilizzando run all'interno di uno script Python che contiene il modello tf.keras .

Puoi utilizzare l'API run dal file Python che contiene il modello tf.keras ( mnist_scale.py ). In questo caso d'uso, entry_point dovrebbe essere None . L'API run può essere richiamata ovunque e l'intero file verrà eseguito in remoto. L'API può essere richiamata alla fine per eseguire lo script localmente a scopo di debug (possibilmente con meno epoche e altri flag).

import tensorflow_datasets as tfds
import tensorflow as tf
import tensorflow_cloud as tfc

tfc.run(
    entry_point=None,
    distribution_strategy='auto',
    requirements_txt='requirements.txt',
    chief_config=tfc.MachineConfig(
            cpu_cores=8,
            memory=30,
            accelerator_type=tfc.AcceleratorType.NVIDIA_TESLA_T4,
            accelerator_count=2),
    worker_count=0)

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']

num_train_examples = info.splits['train'].num_examples
num_test_examples = info.splits['test'].num_examples

BUFFER_SIZE = 10000
BATCH_SIZE = 64

def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255
    return image, label

train_dataset = mnist_train.map(scale).cache()
train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(
        28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(loss='sparse_categorical_crossentropy',
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])
model.fit(train_dataset, epochs=12)

Tieni presente che tutti i file nello stesso albero di directory dello script Python verranno compressi nell'immagine docker creata, insieme al file Python. Si consiglia di creare una nuova directory per ospitare ogni progetto cloud che includa i file necessari e nient'altro, per ottimizzare i tempi di creazione dell'immagine.

Utilizzo dello script run inside a notebook che contiene il modello tf.keras .

In questo caso d'uso, entry_point deve essere None e docker_config.image_build_bucket deve essere specificato, per garantire che la build possa essere archiviata e pubblicata.

Cosa succede quando chiami run ?

La chiamata API eseguirà quanto segue:

1. Rendere pronte entità di codice come script/notebook Keras, cloud e distribuzione .
2. Conversione di questa entità di distribuzione in un contenitore docker con le dipendenze richieste.
3. Distribuisci questo contenitore su larga scala e addestralo utilizzando le strategie di distribuzione TensorFlow.
4. Trasmetti in streaming i log e monitorali su TensorBoard ospitato, gestisci l'archiviazione dei checkpoint.

Per impostazione predefinita, il daemon Docker locale per la creazione e la pubblicazione di immagini Docker nel registro contenitori di Google. Le immagini vengono pubblicate su gcr.io/your-gcp-project-id . Se specifichi docker_config.image_build_bucket , utilizzeremo Google Cloud build per creare e pubblicare immagini docker.

La piattaforma AI di Google viene utilizzata per la distribuzione di immagini Docker su Google Cloud.

Nota: quando entry_point è un percorso di file, tutti i file nella stessa struttura di directory di entry_point verranno compressi nell'immagine Docker creata insieme al file entry_point .