Guia de uso

A API tfc.run permite treinar seus modelos em escala no GCP.

A API tfc.run pode ser usada de quatro maneiras diferentes. Isso é definido por onde você está executando a API (script Python vs notebook Python) e seu parâmetro entry_point :

• Arquivo Python como entry_point .
• Arquivo de notebook como entry_point .
• run em um script Python que contém o modelo tf.keras .
• run em um script de notebook que contém o modelo tf.keras . A maneira mais comum é usar run em um notebook.

O entry_point é um (caminho para um) script Python ou arquivo de notebook ou None . Se None , todo o arquivo atual será enviado ao Google Cloud.

Usando um arquivo Python como entry_point .

Se você tiver seu modelo tf.keras em um arquivo python ( mnist_example.py ), poderá escrever o seguinte script simples ( scale_mnist.py ) para dimensionar seu modelo no GCP.

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

Observe que todos os arquivos na mesma árvore de diretórios que entry_point serão empacotados na imagem docker criada, junto com o arquivo entry_point . É recomendado criar um novo diretório para hospedar cada projeto de nuvem que inclua os arquivos necessários e nada mais, para otimizar o tempo de construção da imagem.

Usando um arquivo de notebook como entry_point .

Se você tiver seu modelo tf.keras em um arquivo de notebook ( mnist_example.ipynb ), poderá escrever o seguinte script simples ( scale_mnist.py ) para dimensionar seu modelo no GCP.

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

Observe que todos os arquivos na mesma árvore de diretórios que entry_point serão empacotados na imagem docker criada, junto com o arquivo entry_point . Como o script python entry_point acima, recomendamos a criação de um novo diretório para hospedar cada projeto de nuvem que inclua os arquivos necessários e nada mais, para otimizar o tempo de construção da imagem.

Usando run em um script Python que contém o modelo tf.keras .

Você pode usar a API run de seu arquivo python que contém o modelo tf.keras ( mnist_scale.py ). Neste caso de uso, entry_point deve ser None . A API run pode ser chamada em qualquer lugar e todo o arquivo será executado remotamente. A API pode ser chamada no final para executar o script localmente para fins de depuração (possivelmente com menos épocas e outros sinalizadores).

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)

Observe que todos os arquivos na mesma árvore de diretórios do script python serão empacotados na imagem docker criada, junto com o arquivo python. É recomendado criar um novo diretório para hospedar cada projeto de nuvem que inclua os arquivos necessários e nada mais, para otimizar o tempo de construção da imagem.

Usando run em um script de notebook que contém o modelo tf.keras .

Neste caso de uso, entry_point deve ser None e docker_config.image_build_bucket deve ser especificado, para garantir que a compilação possa ser armazenada e publicada.

O que acontece quando você chama run ?

A chamada da API realizará o seguinte:

1. Preparar entidades de código, como script/notebook Keras, nuvem e distribuição .
2. Converter esta entidade de distribuição em um contêiner docker com as dependências necessárias.
3. Implante esse contêiner em escala e treine usando estratégias de distribuição do TensorFlow.
4. Transmita logs e monitore-os no TensorBoard hospedado, gerencie o armazenamento de pontos de verificação.

Por padrão, o daemon local do Docker para criar e publicar imagens do Docker no registro de contêiner do Google. As imagens são publicadas em gcr.io/your-gcp-project-id . Se você especificar docker_config.image_build_bucket , usaremos o Google Cloud build para criar e publicar imagens do docker.

A plataforma Google AI é usada para implantar imagens Docker no Google Cloud.

Nota: Quando entry_point for um caminho de arquivo, todos os arquivos na mesma árvore de diretórios que entry_point serão empacotados na imagem Docker criada junto com o arquivo entry_point .