6월 14-15일 우크라이나 DevFest에 참여하세요. 지금 온라인 등록

TFX 및 Vertex 파이프라인을 사용한 Vertex AI 교육 및 제공

이 노트북 기반 자습서는 Vertex AI Training 서비스를 사용하여 ML 모델을 훈련하고 서비스를 위해 Vertex AI에 게시하는 TFX 파이프라인을 만들고 실행합니다.

이 노트북은 우리가 내장 된 TFX 파이프 라인을 기반으로 버텍스 파이프 라인 튜토리얼에 대한 간단한 TFX 파이프 라인 . 해당 튜토리얼을 아직 읽지 않았다면 이 노트북을 계속 진행하기 전에 읽어야 합니다.

AutoML을 사용하여 Vertex AI에서 모델을 훈련하거나 사용자 지정 훈련을 사용할 수 있습니다. 사용자 지정 교육에서는 다양한 머신 유형을 선택하여 교육 작업을 강화하고, 분산 교육을 활성화하고, 초매개변수 조정을 사용하고, GPU로 가속화할 수 있습니다.

학습된 모델을 Vertex AI 모델에 배포하고 엔드포인트를 생성하여 예측 요청을 제공할 수도 있습니다.

이 자습서에서는 사용자 지정 작업과 함께 Vertex AI Training을 사용하여 TFX 파이프라인에서 모델을 훈련합니다. Vertex AI를 사용하여 예측 요청을 제공하는 모델도 배포합니다.

이 노트북은 실행하기위한 것입니다 구글 Colab 또는에서 AI 플랫폼 노트북 . 이들 중 하나를 사용하지 않는 경우 위의 "Google Colab에서 실행" 버튼을 클릭하기만 하면 됩니다.

설정

당신이 완료 한 경우 버텍스 파이프 라인 튜토리얼에 대한 간단한 TFX 파이프 라인 , 당신은 작업 GCP 프로젝트와 GCS 버킷을하고 그것이 우리가이 튜토리얼에 필요한 모든 것입니다. 놓친 경우 사전 자습서를 먼저 읽으십시오.

파이썬 패키지 설치

TFX 및 KFP를 포함한 필수 Python 패키지를 설치하여 ML 파이프라인을 작성하고 Vertex Pipelines에 작업을 제출합니다.

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

런타임을 다시 시작하셨습니까?

Google Colab을 사용하는 경우 위의 셀을 처음 실행할 때 위의 "RESTART RUNTIME" 버튼을 클릭하거나 "런타임 > 런타임 다시 시작..." 메뉴를 사용하여 런타임을 다시 시작해야 합니다. Colab이 패키지를 로드하는 방식 때문입니다.

Colab에 있지 않다면 다음 셀을 사용하여 런타임을 다시 시작할 수 있습니다.

# 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)

이 노트북을 사용하려면 Google에 로그인하세요.

Colab에서 이 노트북을 실행하는 경우 사용자 계정으로 인증하세요.

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

당신은 실행하여, 다음 섹션을 실행하기 전에 AI 플랫폼 노트북, Google 클라우드 인증에있는 경우

gcloud auth login

터미널 창에서 (파일을 통해 열 수 있습니다> 메뉴의). 이 작업은 노트북 인스턴스당 한 번만 수행하면 됩니다.

패키지 버전을 확인하십시오.

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

변수 설정

아래에서 파이프라인을 사용자 지정하는 데 사용되는 몇 가지 변수를 설정합니다. 다음 정보가 필요합니다.

  • GCP 프로젝트 ID 참조 프로젝트 ID를 식별 .
  • 파이프라인을 실행할 GCP 리전 버텍스 파이프 라인에서 사용할 수있는 지역에 대한 자세한 내용은 참조 정점 AI 위치 가이드 .
  • 파이프라인 출력을 저장하기 위한 Google Cloud Storage 버킷.

그것을 실행하기 전에 아래의 셀에 필요한 값을 입력합니다.

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.

세트 gcloud 프로젝트를 사용할 수 있습니다.

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

예시 데이터 준비

우리는 같은 사용 팔머 펭귄 데이터 세트 와 같은 간단한 TFX 파이프 라인 자습서 .

이 데이터 세트에는 이미 [0,1] 범위를 갖도록 정규화된 4개의 숫자 기능이 있습니다. 우리는 예측하는 분류 모델을 구축 할 것입니다 species 펭귄을.

데이터 세트의 자체 복사본을 만들어야 합니다. TFX ExampleGen은 디렉터리에서 입력을 읽기 때문에 디렉터리를 만들고 GCS에서 데이터 집합을 복사해야 합니다.

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 파일을 간단히 살펴보세요.

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".

파이프라인 생성

우리의 파이프 라인은 우리가 만든 파이프 라인과 매우 유사합니다 버텍스 파이프 라인 튜토리얼에 대한 간단한 TFX 파이프 라인 . 파이프라인은 CsvExampleGen, Trainer 및 Pusher의 세 가지 구성 요소로 구성됩니다. 그러나 우리는 특별한 Trainer 및 Pusher 구성 요소를 사용할 것입니다. Trainer 구성 요소는 훈련 워크로드를 Vertex AI로 이동하고 Pusher 구성 요소는 훈련된 ML 모델을 파일 시스템 대신 Vertex AI에 게시합니다.

TFX는 특별한 제공 Trainer 정점 AI 교육 서비스 교육 작업을 제출합니다. 우리가 할 일은 사용이다 Trainer 확장 모듈 대신 표준 Trainer 일부 필수 GCP 매개 변수와 함께 구성 요소입니다.

이 자습서에서는 먼저 CPU만 사용하여 Vertex AI Training 작업을 실행한 다음 GPU를 사용하여 실행합니다.

TFX는 특별한 제공 Pusher 정점 AI 모델로 모델을 업로드 할 수 있습니다. Pusher 너무 온라인 perdictions를 제공하기 위해 정점 AI 엔드 포인트 리소스를 만들 것입니다. 참조 정점 AI 문서는 정점 AI가 제공하는 온라인 예측에 대해 더 배울 수 있습니다.

모델 코드를 작성합니다.

모델 자체에서 모델과 거의 유사하다 간단한 TFX 파이프 라인 튜토리얼 .

우리는 추가합니다 _get_distribution_strategy() 생성 기능 TensorFlow 유통 전략을 그리고 사용된다 run_fn GPU를 사용할 수있는 경우 MirroredStrategy을 사용합니다.

_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

파이프라인 구성 요소에서 액세스할 수 있는 GCS에 모듈 파일을 복사합니다.

그렇지 않으면 모듈 파일을 포함하는 컨테이너 이미지를 빌드하고 이미지를 사용하여 파이프라인 및 AI Platform Training 작업을 실행할 수 있습니다.

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/".

파이프라인 정의 작성

TFX 파이프라인을 생성하는 함수를 정의합니다. 그것은에서와 같은 세 가지 구성 요소가 단순 TFX 파이프 라인 자습서 , 그러나 우리는 사용 TrainerPusher GCP 확장 모듈의 구성 요소를.

tfx.extensions.google_cloud_ai_platform.Trainer 정기적으로 같은 동작합니다 Trainer ,하지만 그것은 단지 클라우드 모델 교육에 대한 계산을 이동합니다. Vertex AI Training 서비스에서 사용자 지정 작업을 시작하고 오케스트레이션 시스템의 트레이너 구성 요소는 Vertex AI Training 작업이 완료될 때까지 대기합니다.

tfx.extensions.google_cloud_ai_platform.Pusher 훈련 된 모델을 사용하여 정점 AI 모델과 정점 AI 엔드 포인트를 작성합니다.

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)

정점 파이프라인에서 파이프라인을 실행합니다.

우리는 우리가 그랬던 것처럼 파이프 라인을 실행하는 버텍스 파이프 라인을 사용합니다 버텍스 파이프 라인 튜토리얼에 대한 간단한 TFX 파이프 라인 .

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))

생성 된 정의 파일은 구글 클라우드 aiplatform 클라이언트를 사용하여 제출하실 수 있습니다 google-cloud-aiplatform 패키지로 제공된다.

# 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)

지금 당신은 방문 할 수있는 '정점 AI> 파이프 라인을' 에서 Google Cloud Console 진행 상황을 볼 수 있습니다.

예측 요청으로 테스트

파이프 라인이 완료되면, 당신은 '정점 AI> 끝점'에서 엔드 포인트의 하나의 배포 모델을 찾을 수 있습니다. 새 엔드포인트에 예측 요청을 보내려면 엔드포인트의 ID를 알아야 합니다. 이것은 우리가 위에서 입력 한 엔드 포인트 이름과 다릅니다. 당신은에서 ID를 찾을 수 있습니다 끝점 페이지 에서 Google Cloud Console , 그것은 매우 긴 숫자처럼 보인다.

실행하기 전에 아래에 ENDPOINT_ID를 설정하세요.

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.

동일한 aiplatform 클라이언트를 사용하여 엔드포인트에 요청을 보냅니다. 펭귄 종 분류에 대한 예측 요청을 보내드립니다. 입력은 우리가 사용한 네 가지 기능이며 모델은 각 종에 대해 하나의 값을 출력하기 때문에 세 개의 값을 반환합니다.

예를 들어, 다음 특정 예는 인덱스 '2'에서 가장 큰 값을 가지며 '2'를 인쇄합니다.

# 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]))

온라인 예측에 대한 자세한 내용은 방문하시기 바랍니다 끝점 페이지 에서 Google Cloud Console . 샘플 요청 보내기에 대한 가이드와 더 많은 리소스에 대한 링크를 찾을 수 있습니다.

GPU를 사용하여 파이프라인 실행

Vertex AI는 GPU 지원을 포함하여 다양한 머신 유형을 사용한 학습을 ​​지원합니다. 보기 기계 사양 참조 사용할 수있는 옵션에 있습니다.

GPU 훈련을 지원하기 위해 파이프라인을 이미 정의했습니다. 우리가해야 할 모든 설정입니다 use_gpu True로 플래그를. 그런 다음 파이프 라인을 사용 하나 NVIDIA_TESLA_K80 우리의 모델 훈련 코드를 포함하여 기계 사양으로 작성됩니다 tf.distribute.MirroredStrategy .

참고 use_gpu 플래그가 정점 또는 TFX API의 일부가 아닙니다. 이 튜토리얼에서 훈련 코드를 제어하는 ​​데만 사용됩니다.

# 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)

지금 당신은 방문 할 수있는 '정점 AI> 파이프 라인을' 에서 Google Cloud Console 진행 상황을 볼 수 있습니다.

청소

이 튜토리얼에서 정점 AI 모델과 끝점을 만들었습니다. 로 이동하여 원치 않는 요금이 발생하지 않도록하기 위해 이러한 자원을 삭제하십시오 끝점 먼저 엔드 포인트에서 모델을 배포 해제. 그런 다음 끝점과 모델을 별도로 삭제할 수 있습니다.