Esta página foi traduzida pela API Cloud Translation.

Como usar espaços de pesquisa predefinidos e um formador predefinido

Este guia mostra como executar uma tarefa de pesquisa de arquitetura neural do Vertex AI usando os espaços de pesquisa predefinidos e o código de preparação predefinido da Google com base no TF-vision para o MnasNet e o SpineNet. Consulte o bloco de notas de classificação MnasNet e o bloco de notas de deteção de objetos SpineNet para ver exemplos completos.

Preparação de dados para o preparador pré-criado

O preparador pré-criado da Neural Architecture Search requer que os seus dados estejam no formato TFRecord e contenham tf.train.Examples. Os tf.train.Examples têm de incluir os seguintes campos:

'image/encoded': tf.FixedLenFeature(tf.string)
'image/height': tf.FixedLenFeature(tf.int64)
'image/width': tf.FixedLenFeature(tf.int64)

# For image classification only.
'image/class/label': tf.FixedLenFeature(tf.int64)

# For object detection only.
'image/object/bbox/xmin': tf.VarLenFeature(tf.float32)
'image/object/bbox/xmax': tf.VarLenFeature(tf.float32)
'image/object/bbox/ymin': tf.VarLenFeature(tf.float32)
'image/object/bbox/ymax': tf.VarLenFeature(tf.float32)
'image/object/class/label': tf.VarLenFeature(tf.int64)

Pode seguir as instruções para a preparação de dados do ImageNet aqui.

Para converter os seus dados personalizados, use o script de análise incluído no código de exemplo e nas utilidades que transferiu. Para personalizar a análise sintática de dados, modifique os ficheiros tf_vision/dataloaders/*_input.py.

Saiba mais sobre TFRecord e tf.train.Example.

Defina variáveis de ambiente da experiência

Antes de executar as experiências, tem de definir várias variáveis de ambiente, incluindo:

TRAINER_DOCKER_ID: ${USER}_nas_experiment (formato recomendado)
Localizações do Cloud Storage dos conjuntos de dados de validação e de preparação que a experiência vai usar. Por exemplo (CoCo para deteção):
- gs://cloud-samples-data/ai-platform/built-in/image/coco/train*
- gs://cloud-samples-data/ai-platform/built-in/image/coco/val*
Localização do Cloud Storage para o resultado da experiência. Formato recomendado:
- gs://${USER}_nas_experiment
REGION: uma região que deve ser igual à região do bucket de saída da experiência. Por exemplo: us-central1.
PARAM_OVERRIDE: um ficheiro .yaml que substitui os parâmetros do preparador pré-criado. A pesquisa de arquitetura neural oferece algumas configurações predefinidas que pode usar:

PROJECT_ID=PROJECT_ID
TRAINER_DOCKER_ID=TRAINER_DOCKER_ID
LATENCY_CALCULATOR_DOCKER_ID=LATENCY_CALCULATOR_DOCKER_ID
GCS_ROOT_DIR=OUTPUT_DIR
REGION=REGION
PARAM_OVERRIDE=tf_vision/configs/experiments/spinenet_search_gpu.yaml
TRAINING_DATA_PATH=gs://PATH_TO_TRAINING_DATA
VALIDATION_DATA_PATH=gs://PATH_TO_VALIDATION_DATA

É recomendável selecionar e/ou modificar o ficheiro de substituição que corresponde aos seus requisitos de formação. Considere o seguinte:

Pode definir --accelerator_type para escolher entre GPU ou CPU. Para executar apenas algumas épocas para testes rápidos com a CPU, pode definir a flag --accelerator_type="" e usar o ficheiro de configuração tf_vision/test_files/fast_nas_detection_spinenet_search_for_testing.yaml.
Número de épocas
Tempo de execução da preparação
Hiperparâmetros, como a taxa de aprendizagem

Para ver uma lista de todos os parâmetros para controlar as tarefas de preparação, consulte tf_vision/configs/. Seguem-se os parâmetros principais:

task:
  train_data:
    global_batch_size: 80
  validation_data:
    global_batch_size: 16
  init_checkpoint: null
trainer:
  train_steps: 16634
  steps_per_loop: 1386
  optimizer_config:
    learning_rate:
      cosine:
        initial_learning_rate: 0.16
        decay_steps: 16634
      type: 'cosine'
    warmup:
      type: 'linear'
      linear:
        warmup_learning_rate: 0.0067
        warmup_steps: 1386

Crie um contentor do Cloud Storage para que o Neural Architecture Search armazene os resultados dos seus trabalhos (ou seja, pontos de verificação):

gcloud storage buckets create $GCS_ROOT_DIR

Crie um contentor de formador e um contentor de calculadora de latência

O seguinte comando cria uma imagem de formador em Google Cloud com o seguinte URI: gcr.io/PROJECT_ID/TRAINER_DOCKER_ID que vai ser usado na tarefa de pesquisa de arquitetura neural no passo seguinte.

python3 vertex_nas_cli.py build \
--project_id=PROJECT_ID \
--trainer_docker_id=TRAINER_DOCKER_ID \
--latency_calculator_docker_id=LATENCY_CALCULATOR_DOCKER_ID \
--trainer_docker_file=tf_vision/nas_multi_trial.Dockerfile \
--latency_calculator_docker_file=tf_vision/latency_computation_using_saved_model.Dockerfile

Para alterar o espaço de pesquisa e a recompensa, atualize-os no ficheiro Python e, em seguida, recrie a imagem do Docker.

Teste o formador localmente

Uma vez que o lançamento de uma tarefa no serviço Google Cloud demora vários minutos, pode ser mais conveniente testar o Docker do formador localmente, por exemplo, validando o formato TFRecord. Usando o espaço de pesquisa spinenet como exemplo, pode executar a tarefa de pesquisa localmente (o modelo é amostrado aleatoriamente):

# Define the local job output dir.
JOB_DIR="/tmp/iod_${search_space}"

python3 vertex_nas_cli.py search_in_local \
--project_id=PROJECT_ID \
--trainer_docker_id=TRAINER_DOCKER_ID \
--prebuilt_search_space=spinenet \
--use_prebuilt_trainer=True \
--local_output_dir=${JOB_DIR} \
--search_docker_flags \
params_override="tf_vision/test_files/fast_nas_detection_spinenet_search_for_testing.yaml" \
training_data_path=TEST_COCO_TF_RECORD \
validation_data_path=TEST_COCO_TF_RECORD \
model=retinanet

training_data_path e validation_data_path são os caminhos para os seus TFRecords.

Inicie uma pesquisa de fase 1 seguida de uma tarefa de preparação de fase 2 no Google Cloud

Deve consultar o bloco de notas de classificação MnasNet e o bloco de notas de deteção de objetos SpineNet para ver exemplos completos.

Pode definir o sinalizador --max_parallel_nas_trial e --max_nas_trial para personalizar. O Neural Architecture Search inicia max_parallel_nas_trial avaliações em paralelo e termina após max_nas_trial avaliações.
Se a flag --target_device_latency_ms estiver definida, é iniciado um trabalho latency calculator separado com o acelerador especificado pela flag --target_device_type.
O controlador de pesquisa de arquitetura neural fornece a cada tentativa uma sugestão para um novo candidato de arquitetura através da FLAG --nas_params_str.
Cada avaliação cria um gráfico com base no valor da FLAG nas_params_str e inicia uma tarefa de preparação. Cada teste também guarda o respetivo valor num ficheiro JSON (em os.path.join(nas_job_dir, str(trial_id), "nas_params_str.json")).

Recompensa com uma restrição de latência

O notebook de classificação MnasNet mostra um exemplo de uma pesquisa baseada em dispositivos com restrições de latência de CPU na nuvem.

Para pesquisar modelos com restrição de latência, o preparador pode comunicar a recompensa como uma função da precisão e da latência.

No código fonte partilhado, a recompensa é calculada da seguinte forma:

def compute_reward(target_latency, accuracy, inference_latency, weight=0.07):
  """Compute reward from accuracy and latency."""
  speed_ratio = target_latency / inference_latency
  return accuracy * (speed_ratio**weight)

Pode usar outras variantes do cálculo reward na página 3 do documento mnasnet.

target_device_type especifica o tipo de dispositivo de destino que é suportado em Google Cloud, como NVIDIA_TESLA_P100.
use_prebuilt_latency_calculator usa a nossa tf_vision/latency_computation_using_saved_model.pycalculadora de latência pré-criada.
target_device_latency_ms especifica a latência do dispositivo de destino.

Para obter informações sobre como personalizar a função de cálculo da latência, consulte tf_vision/latency_computation_using_saved_model.py.

Monitorize o progresso da tarefa de pesquisa de arquitetura neural

Na Google Cloud consola, na página da tarefa, o gráfico mostra o reward vs. trial number, enquanto a tabela mostra as recompensas de cada teste. Pode encontrar as principais experiências com a recompensa mais elevada.

Represente graficamente uma curva de preparação da fase 2

Após a fase 2 da preparação, usa o Cloud Shell ou Google Cloud TensorBoard para traçar a curva de preparação apontando-a para o diretório de tarefas:

Implemente um modelo selecionado

Para criar um SavedModel, pode usar o script export_saved_model.py com o params_override=${GCS_ROOT_DIR}/${TRIAL_ID}/params.yaml.