Vertex AI Eğitimi ve TFX ve Vertex Pipelines ile Sunma

TensorFlow.org'da görüntüleyin

Google Colab'da çalıştırın

Kaynağı GitHub'da görüntüleyin

Not defterini indir

Google Cloud Vertex AI Workbench'te çalıştırın

Bu not defteri tabanlı öğretici, Vertex AI Eğitim hizmetini kullanarak bir ML modelini eğiten ve hizmet için Vertex AI'da yayınlayan bir TFX ardışık düzeni oluşturacak ve çalıştıracaktır.

Bu defter biz inşa TFX boru hattı dayanmaktadır Vertex Boru hatları Öğreticisi için basit TFX Boru Hattı . Bu öğreticiyi henüz okumadıysanız, bu not defterine geçmeden önce okumalısınız.

Modelleri Vertex AI üzerinde AutoML kullanarak eğitebilir veya özel eğitim kullanabilirsiniz. Özel eğitimde, eğitim işlerinizi güçlendirmek, dağıtılmış eğitimi etkinleştirmek, hiperparametre ayarını kullanmak ve GPU'larla hızlandırmak için birçok farklı makine türü seçebilirsiniz.

Eğitilmiş modeli Vertex AI Modellerine dağıtarak ve bir uç nokta oluşturarak da tahmin istekleri sunabilirsiniz.

Bu öğreticide, bir TFX işlem hattında bir modeli eğitmek için özel işlerle Vertex AI Eğitimini kullanacağız. Modeli, Vertex AI kullanarak tahmin isteğine hizmet etmek için de dağıtacağız.

Bu defter üzerinde çalıştırılmak üzere tasarlanmıştır tarihinde CoLab veya üzerinde AI Platformu Notebooks . Bunlardan birini kullanmıyorsanız, yukarıdaki "Google Colab'da Çalıştır" düğmesini tıklamanız yeterlidir.

Kurmak

Eğer tamamladıysanız Vertex Boru hatları Öğreticisi için basit TFX Boru Hattı , çalışan GSO projesi ve bir GKS kova olacak ve biz bu eğitim için tüm ihtiyaç vardır. Kaçırdıysanız lütfen önce ön öğreticiyi okuyun.

Python paketlerini kurun

ML işlem hatlarını yazmak ve işleri Vertex Pipelines'a göndermek için TFX ve KFP dahil gerekli Python paketlerini kuracağız.

# Use the latest version of pip.
pip install --upgrade pip
pip install --upgrade "tfx[kfp]<2"

Çalışma zamanını yeniden başlattınız mı?

Google Colab kullanıyorsanız, yukarıdaki hücreyi ilk kez çalıştırdığınızda, yukarıdaki "ÇALIŞTIRMA ZAMINI YENİDEN BAŞLAT" düğmesini tıklayarak veya "Çalışma Zamanı > Çalışma zamanını yeniden başlat ..." menüsünü kullanarak çalışma zamanını yeniden başlatmanız gerekir. Bunun nedeni Colab'ın paketleri yükleme şeklidir.

Colab'de değilseniz, aşağıdaki hücre ile çalışma zamanını yeniden başlatabilirsiniz.

# docs_infra: no_execute
import sys
if not 'google.colab' in sys.modules:
  # Automatically restart kernel after installs
  import IPython
  app = IPython.Application.instance()
  app.kernel.do_shutdown(True)

Bu not defteri için Google'da oturum açın

Bu not defterini Colab üzerinde çalıştırıyorsanız, kullanıcı hesabınızla kimlik doğrulaması yapın:

import sys
if 'google.colab' in sys.modules:
  from google.colab import auth
  auth.authenticate_user()

Eğer çalıştırarak sonraki bölüme çalıştırmadan önce AI Platformu Notebook, Google Cloud authenticate iseniz

gcloud auth login

Terminal penceresinde (eğer Dosya aracılığıyla açabilirsiniz> Yeni menüsünde). Bunu dizüstü bilgisayar örneği başına yalnızca bir kez yapmanız gerekir.

Paket sürümlerini kontrol edin.

import tensorflow as tf
print('TensorFlow version: {}'.format(tf.__version__))
from tfx import v1 as tfx
print('TFX version: {}'.format(tfx.__version__))
import kfp
print('KFP version: {}'.format(kfp.__version__))

TensorFlow version: 2.6.2
TFX version: 1.4.0
KFP version: 1.8.1

Değişkenleri ayarla

Aşağıdaki boru hatlarını özelleştirmek için kullanılan bazı değişkenleri ayarlayacağız. Aşağıdaki bilgiler gereklidir:

• GCP Proje kimliği. Bkz proje kimliği belirleme .
• Ardışık düzenleri çalıştırmak için GCP Bölgesi. Vertex Boru hatları mevcut olduğunu bölgeleri hakkında daha fazla bilgi için bkz Vertex AI yerleri rehber .
• Ardışık düzen çıktılarını depolamak için Google Bulut Depolama Grubu.

Çalıştırmadan önce aşağıda hücrede gerekli değerleri girin.

GOOGLE_CLOUD_PROJECT = ''     # <--- ENTER THIS
GOOGLE_CLOUD_REGION = ''      # <--- ENTER THIS
GCS_BUCKET_NAME = ''          # <--- ENTER THIS

if not (GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_REGION and GCS_BUCKET_NAME):
    from absl import logging
    logging.error('Please set all required parameters.')

ERROR:absl:Please set all required parameters.

Set gcloud Projenizi kullanmak.

gcloud config set project {GOOGLE_CLOUD_PROJECT}

ERROR: (gcloud.config.set) argument VALUE: Must be specified.
Usage: gcloud config set SECTION/PROPERTY VALUE [optional flags]
  optional flags may be  --help | --installation

For detailed information on this command and its flags, run:
  gcloud config set --help

PIPELINE_NAME = 'penguin-vertex-training'

# Path to various pipeline artifact.
PIPELINE_ROOT = 'gs://{}/pipeline_root/{}'.format(GCS_BUCKET_NAME, PIPELINE_NAME)

# Paths for users' Python module.
MODULE_ROOT = 'gs://{}/pipeline_module/{}'.format(GCS_BUCKET_NAME, PIPELINE_NAME)

# Paths for users' data.
DATA_ROOT = 'gs://{}/data/{}'.format(GCS_BUCKET_NAME, PIPELINE_NAME)

# Name of Vertex AI Endpoint.
ENDPOINT_NAME = 'prediction-' + PIPELINE_NAME

print('PIPELINE_ROOT: {}'.format(PIPELINE_ROOT))

PIPELINE_ROOT: gs:///pipeline_root/penguin-vertex-training

Örnek verileri hazırlayın

Biz aynı kullanacağız Palmer Penguenler veri kümesi olarak basit TFX Boru Hattı Öğreticisi .

Bu veri kümesinde, [0,1] aralığına sahip olacak şekilde normalleştirilmiş dört sayısal özellik vardır. Biz tahmin eden bir sınıflandırma modeli inşa edecek species penguenleri.

Veri setinin kendi kopyasını oluşturmamız gerekiyor. TFX ExampleGen bir dizinden girdileri okuduğundan, bir dizin oluşturmamız ve GCS'de buna veri kümesi kopyalamamız gerekir.

gsutil cp gs://download.tensorflow.org/data/palmer_penguins/penguins_processed.csv {DATA_ROOT}/

InvalidUrlError: Cloud URL scheme should be followed by colon and two slashes: "://". Found: "gs:///data/penguin-vertex-training/".

CSV dosyasına hızlı bir göz atın.

gsutil cat {DATA_ROOT}/penguins_processed.csv | head

InvalidUrlError: Cloud URL scheme should be followed by colon and two slashes: "://". Found: "gs:///data/penguin-vertex-training/penguins_processed.csv".

Bir işlem hattı oluşturun

Bizim boru hattı biz oluşturulan boru hattına çok benzer olacaktır Vertex Boru hatları Öğreticisi için basit TFX Boru Hattı . İşlem hattı, CsvExampleGen, Trainer ve Pusher olmak üzere üç bileşenden oluşacaktır. Ancak özel bir Trainer ve Pusher bileşeni kullanacağız. Trainer bileşeni, eğitim iş yüklerini Vertex AI'ye taşıyacak ve Pusher bileşeni, eğitilmiş ML modelini bir dosya sistemi yerine Vertex AI'ye yayınlayacaktır.

TFX özel sağlayan Trainer Vertex AI Eğitim hizmetine eğitim işlerini göndermek için. Yapmamız gereken tek şey kullanımıdır Trainer uzatma modülü yerine standart içinde Trainer bazı gerekli GSO parametrelerle birlikte bileşen.

Bu öğreticide, Vertex AI Training işlerini yalnızca önce CPU'ları ve ardından bir GPU'yu kullanarak çalıştıracağız.

TFX ayrıca özel sağlayan Pusher Vertex AI Modelleri modeli yüklemek için. Pusher de çevrimiçi perdictions hizmet etmek Vertex AI Endpoint kaynak yaratacaktır. Bkz Vertex AI belgelerine Vertex AI tarafından sağlanan çevrimiçi tahminler hakkında daha fazla bilgi için.

Model kodunu yazın.

Modelin kendisi de modele neredeyse benzer Basit TFX Boru Hattı Öğreticisi .

Biz katacak _get_distribution_strategy() bir oluşturur işlevi TensorFlow dağıtım stratejisi ve kullanılan run_fn GPU varsa MirroredStrategy kullanmak.

_trainer_module_file = 'penguin_trainer.py'

%%writefile {_trainer_module_file}

# Copied from https://www.tensorflow.org/tfx/tutorials/tfx/penguin_simple and
# slightly modified run_fn() to add distribution_strategy.

from typing import List
from absl import logging
import tensorflow as tf
from tensorflow import keras
from tensorflow_metadata.proto.v0 import schema_pb2
from tensorflow_transform.tf_metadata import schema_utils

from tfx import v1 as tfx
from tfx_bsl.public import tfxio

_FEATURE_KEYS = [
    'culmen_length_mm', 'culmen_depth_mm', 'flipper_length_mm', 'body_mass_g'
]
_LABEL_KEY = 'species'

_TRAIN_BATCH_SIZE = 20
_EVAL_BATCH_SIZE = 10

# Since we're not generating or creating a schema, we will instead create
# a feature spec.  Since there are a fairly small number of features this is
# manageable for this dataset.
_FEATURE_SPEC = {
    **{
        feature: tf.io.FixedLenFeature(shape=[1], dtype=tf.float32)
        for feature in _FEATURE_KEYS
    }, _LABEL_KEY: tf.io.FixedLenFeature(shape=[1], dtype=tf.int64)
}


def _input_fn(file_pattern: List[str],
              data_accessor: tfx.components.DataAccessor,
              schema: schema_pb2.Schema,
              batch_size: int) -> tf.data.Dataset:
  """Generates features and label for training.

  Args:
    file_pattern: List of paths or patterns of input tfrecord files.
    data_accessor: DataAccessor for converting input to RecordBatch.
    schema: schema of the input data.
    batch_size: representing the number of consecutive elements of returned
      dataset to combine in a single batch

  Returns:
    A dataset that contains (features, indices) tuple where features is a
      dictionary of Tensors, and indices is a single Tensor of label indices.
  """
  return data_accessor.tf_dataset_factory(
      file_pattern,
      tfxio.TensorFlowDatasetOptions(
          batch_size=batch_size, label_key=_LABEL_KEY),
      schema=schema).repeat()


def _make_keras_model() -> tf.keras.Model:
  """Creates a DNN Keras model for classifying penguin data.

  Returns:
    A Keras Model.
  """
  # The model below is built with Functional API, please refer to
  # https://www.tensorflow.org/guide/keras/overview for all API options.
  inputs = [keras.layers.Input(shape=(1,), name=f) for f in _FEATURE_KEYS]
  d = keras.layers.concatenate(inputs)
  for _ in range(2):
    d = keras.layers.Dense(8, activation='relu')(d)
  outputs = keras.layers.Dense(3)(d)

  model = keras.Model(inputs=inputs, outputs=outputs)
  model.compile(
      optimizer=keras.optimizers.Adam(1e-2),
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      metrics=[keras.metrics.SparseCategoricalAccuracy()])

  model.summary(print_fn=logging.info)
  return model


# NEW: Read `use_gpu` from the custom_config of the Trainer.
#      if it uses GPU, enable MirroredStrategy.
def _get_distribution_strategy(fn_args: tfx.components.FnArgs):
  if fn_args.custom_config.get('use_gpu', False):
    logging.info('Using MirroredStrategy with one GPU.')
    return tf.distribute.MirroredStrategy(devices=['device:GPU:0'])
  return None


# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
  """Train the model based on given args.

  Args:
    fn_args: Holds args used to train the model as name/value pairs.
  """

  # This schema is usually either an output of SchemaGen or a manually-curated
  # version provided by pipeline author. A schema can also derived from TFT
  # graph if a Transform component is used. In the case when either is missing,
  # `schema_from_feature_spec` could be used to generate schema from very simple
  # feature_spec, but the schema returned would be very primitive.
  schema = schema_utils.schema_from_feature_spec(_FEATURE_SPEC)

  train_dataset = _input_fn(
      fn_args.train_files,
      fn_args.data_accessor,
      schema,
      batch_size=_TRAIN_BATCH_SIZE)
  eval_dataset = _input_fn(
      fn_args.eval_files,
      fn_args.data_accessor,
      schema,
      batch_size=_EVAL_BATCH_SIZE)

  # NEW: If we have a distribution strategy, build a model in a strategy scope.
  strategy = _get_distribution_strategy(fn_args)
  if strategy is None:
    model = _make_keras_model()
  else:
    with strategy.scope():
      model = _make_keras_model()

  model.fit(
      train_dataset,
      steps_per_epoch=fn_args.train_steps,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps)

  # The result of the training should be saved in `fn_args.serving_model_dir`
  # directory.
  model.save(fn_args.serving_model_dir, save_format='tf')

Writing penguin_trainer.py

Modül dosyasını, ardışık düzen bileşenlerinden erişilebilen GCS'ye kopyalayın.

Aksi takdirde, modül dosyasını içeren bir kapsayıcı görüntüsü oluşturmak ve ardışık düzeni ve AI Platform Eğitimi işlerini çalıştırmak için görüntüyü kullanmak isteyebilirsiniz.

gsutil cp {_trainer_module_file} {MODULE_ROOT}/

InvalidUrlError: Cloud URL scheme should be followed by colon and two slashes: "://". Found: "gs:///pipeline_module/penguin-vertex-training/".

Bir işlem hattı tanımı yazın

Bir TFX boru hattı oluşturmak için bir fonksiyon tanımlayacağız. Bu aynı üç bileşenden oluşur Basit TFX Boru Hattı Öğreticisi , ama biz bir kullanmak Trainer ve Pusher GSO uzatma modülünde bileşeni.

tfx.extensions.google_cloud_ai_platform.Trainer düzenli gibi davranacağını Trainer , ama sadece buluta modeli eğitim için hesaplama taşır. Vertex AI Eğitim hizmetinde özel bir iş başlatır ve düzenleme sistemindeki eğitmen bileşeni, Vertex AI Eğitim işi tamamlanana kadar bekleyecektir.

tfx.extensions.google_cloud_ai_platform.Pusher eğitilmiş model kullanılarak bir Vertex AI Modeli ve Vertex AI Endpoint oluşturur.

def _create_pipeline(pipeline_name: str, pipeline_root: str, data_root: str,
                     module_file: str, endpoint_name: str, project_id: str,
                     region: str, use_gpu: bool) -> tfx.dsl.Pipeline:
  """Implements the penguin pipeline with TFX."""
  # Brings data into the pipeline or otherwise joins/converts training data.
  example_gen = tfx.components.CsvExampleGen(input_base=data_root)

  # NEW: Configuration for Vertex AI Training.
  # This dictionary will be passed as `CustomJobSpec`.
  vertex_job_spec = {
      'project': project_id,
      'worker_pool_specs': [{
          'machine_spec': {
              'machine_type': 'n1-standard-4',
          },
          'replica_count': 1,
          'container_spec': {
              'image_uri': 'gcr.io/tfx-oss-public/tfx:{}'.format(tfx.__version__),
          },
      }],
  }
  if use_gpu:
    # See https://cloud.google.com/vertex-ai/docs/reference/rest/v1/MachineSpec#acceleratortype
    # for available machine types.
    vertex_job_spec['worker_pool_specs'][0]['machine_spec'].update({
        'accelerator_type': 'NVIDIA_TESLA_K80',
        'accelerator_count': 1
    })

  # Trains a model using Vertex AI Training.
  # NEW: We need to specify a Trainer for GCP with related configs.
  trainer = tfx.extensions.google_cloud_ai_platform.Trainer(
      module_file=module_file,
      examples=example_gen.outputs['examples'],
      train_args=tfx.proto.TrainArgs(num_steps=100),
      eval_args=tfx.proto.EvalArgs(num_steps=5),
      custom_config={
          tfx.extensions.google_cloud_ai_platform.ENABLE_UCAIP_KEY:
              True,
          tfx.extensions.google_cloud_ai_platform.UCAIP_REGION_KEY:
              region,
          tfx.extensions.google_cloud_ai_platform.TRAINING_ARGS_KEY:
              vertex_job_spec,
          'use_gpu':
              use_gpu,
      })

  # NEW: Configuration for pusher.
  vertex_serving_spec = {
      'project_id': project_id,
      'endpoint_name': endpoint_name,
      # Remaining argument is passed to aiplatform.Model.deploy()
      # See https://cloud.google.com/vertex-ai/docs/predictions/deploy-model-api#deploy_the_model
      # for the detail.
      #
      # Machine type is the compute resource to serve prediction requests.
      # See https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types
      # for available machine types and acccerators.
      'machine_type': 'n1-standard-4',
  }

  # Vertex AI provides pre-built containers with various configurations for
  # serving.
  # See https://cloud.google.com/vertex-ai/docs/predictions/pre-built-containers
  # for available container images.
  serving_image = 'us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-6:latest'
  if use_gpu:
    vertex_serving_spec.update({
        'accelerator_type': 'NVIDIA_TESLA_K80',
        'accelerator_count': 1
    })
    serving_image = 'us-docker.pkg.dev/vertex-ai/prediction/tf2-gpu.2-6:latest'

  # NEW: Pushes the model to Vertex AI.
  pusher = tfx.extensions.google_cloud_ai_platform.Pusher(
      model=trainer.outputs['model'],
      custom_config={
          tfx.extensions.google_cloud_ai_platform.ENABLE_VERTEX_KEY:
              True,
          tfx.extensions.google_cloud_ai_platform.VERTEX_REGION_KEY:
              region,
          tfx.extensions.google_cloud_ai_platform.VERTEX_CONTAINER_IMAGE_URI_KEY:
              serving_image,
          tfx.extensions.google_cloud_ai_platform.SERVING_ARGS_KEY:
            vertex_serving_spec,
      })

  components = [
      example_gen,
      trainer,
      pusher,
  ]

  return tfx.dsl.Pipeline(
      pipeline_name=pipeline_name,
      pipeline_root=pipeline_root,
      components=components)

İşlem hattını Vertex Pipelines üzerinde çalıştırın.

Biz de yaptığımız gibi boru hattını çalıştırmak için Vertex Boru Hatları kullanacak Vertex Boru hatları Öğreticisi için basit TFX Boru Hattı .

import os

PIPELINE_DEFINITION_FILE = PIPELINE_NAME + '_pipeline.json'

runner = tfx.orchestration.experimental.KubeflowV2DagRunner(
    config=tfx.orchestration.experimental.KubeflowV2DagRunnerConfig(),
    output_filename=PIPELINE_DEFINITION_FILE)
_ = runner.run(
    _create_pipeline(
        pipeline_name=PIPELINE_NAME,
        pipeline_root=PIPELINE_ROOT,
        data_root=DATA_ROOT,
        module_file=os.path.join(MODULE_ROOT, _trainer_module_file),
        endpoint_name=ENDPOINT_NAME,
        project_id=GOOGLE_CLOUD_PROJECT,
        region=GOOGLE_CLOUD_REGION,
        # We will use CPUs only for now.
        use_gpu=False))

Oluşturulan tanım dosyası Google Cloud aiplatform istemcisi kullanılarak gönderilebilir google-cloud-aiplatform paketinin.

# docs_infra: no_execute
from google.cloud import aiplatform
from google.cloud.aiplatform import pipeline_jobs

aiplatform.init(project=GOOGLE_CLOUD_PROJECT, location=GOOGLE_CLOUD_REGION)

job = pipeline_jobs.PipelineJob(template_path=PIPELINE_DEFINITION_FILE,
                                display_name=PIPELINE_NAME)
job.run(sync=False)

Şimdi gidebilir 'Vertex AI> Boru Hatları' in Google Cloud Console ilerleme görmek.

Bir tahmin isteğiyle test edin

Boru hattı tamamlandığında, 'Vertex AI> Endpoints' in uç noktaları birinde bir konuşlandırılmış bir model bulacaksınız. Yeni uç noktaya bir tahmin isteği göndermek için uç noktanın kimliğini bilmemiz gerekir. Bu yukarıda girilen son nokta adından farklıdır. Sen de kimliği bulabilir Endpoints sayfasında yer Google Cloud Console , çok uzun bir sayı gibi görünüyor.

Çalıştırmadan önce ENDPOINT_ID değerini aşağıda ayarlayın.

ENDPOINT_ID=''     # <--- ENTER THIS
if not ENDPOINT_ID:
    from absl import logging
    logging.error('Please set the endpoint id.')

ERROR:absl:Please set the endpoint id.

Uç noktaya bir istek göndermek için aynı aiplatform istemcisini kullanıyoruz. Penguen türleri sınıflandırması için bir tahmin talebi göndereceğiz. Girdi, kullandığımız dört özelliktir ve modelimiz her tür için bir değer çıkardığı için model üç değer döndürür.

Örneğin, aşağıdaki özel örnek '2' dizinindeki en büyük değere sahiptir ve '2' yazdıracaktır.

# docs_infra: no_execute
import numpy as np

# The AI Platform services require regional API endpoints.
client_options = {
    'api_endpoint': GOOGLE_CLOUD_REGION + '-aiplatform.googleapis.com'
    }
# Initialize client that will be used to create and send requests.
client = aiplatform.gapic.PredictionServiceClient(client_options=client_options)

# Set data values for the prediction request.
# Our model expects 4 feature inputs and produces 3 output values for each
# species. Note that the output is logit value rather than probabilities.
# See the model code to understand input / output structure.
instances = [{
    'culmen_length_mm':[0.71],
    'culmen_depth_mm':[0.38],
    'flipper_length_mm':[0.98],
    'body_mass_g': [0.78],
}]

endpoint = client.endpoint_path(
    project=GOOGLE_CLOUD_PROJECT,
    location=GOOGLE_CLOUD_REGION,
    endpoint=ENDPOINT_ID,
)
# Send a prediction request and get response.
response = client.predict(endpoint=endpoint, instances=instances)

# Uses argmax to find the index of the maximum value.
print('species:', np.argmax(response.predictions[0]))

Online tahmin hakkında ayrıntılı bilgi için lütfen Endpoints sayfasını de Google Cloud Console . örnek istekler ve daha fazla kaynağa bağlantılar göndermeyle ilgili bir kılavuz bulabilirsiniz.

Bir GPU kullanarak işlem hattını çalıştırın

Vertex AI, GPU'lar için destek dahil olmak üzere çeşitli makine türlerini kullanarak eğitimi destekler. Bkz Makine'nin Spec referansı kullanılabilir seçenekler için.

GPU eğitimini desteklemek için işlem hattımızı zaten tanımladık. Yapmamız gereken tek şey ayardır use_gpu True olarak bayrak. Sonra bir boru hattı kullanacak biri NVIDIA_TESLA_K80 ve modelimiz eğitim kodunu içeren bir makine spec ile oluşturulacak tf.distribute.MirroredStrategy .

Not use_gpu bayrağı Vertex veya TFX API parçası değildir. Bu eğitimde sadece eğitim kodunu kontrol etmek için kullanılır.

# docs_infra: no_execute
runner.run(
    _create_pipeline(
        pipeline_name=PIPELINE_NAME,
        pipeline_root=PIPELINE_ROOT,
        data_root=DATA_ROOT,
        module_file=os.path.join(MODULE_ROOT, _trainer_module_file),
        endpoint_name=ENDPOINT_NAME,
        project_id=GOOGLE_CLOUD_PROJECT,
        region=GOOGLE_CLOUD_REGION,
        # Updated: Use GPUs. We will use a NVIDIA_TESLA_K80 and 
        # the model code will use tf.distribute.MirroredStrategy.
        use_gpu=True))

job = pipeline_jobs.PipelineJob(template_path=PIPELINE_DEFINITION_FILE,
                                display_name=PIPELINE_NAME)
job.run(sync=False)

Şimdi gidebilir 'Vertex AI> Boru Hatları' in Google Cloud Console ilerleme görmek.

Temizlemek

Bu öğreticide bir Vertex AI Modeli ve Uç Noktası oluşturdunuz. Giderek istediğiniz İstenmeyen ücretlerin olmaması için bu kaynakları silin endpointi ve birinci uç noktadan modelini undeploying. Ardından uç noktayı ve modeli ayrı ayrı silebilirsiniz.