Kubeflow Pipelines - GitHub の問題の要約

1. はじめに

Kubeflow は、Kubernetes 用の ML ツールキットです。Kubeflow は、Kubernetes 上での機械学習（ML）ワークフローの Deployment をシンプル、ポータブル、そしてスケーラブルなものにすることに特化したプロジェクトです。その目標は、クラス最高のオープンソース ML 用システムをさまざまなインフラストラクチャに簡単にデプロイできるようにすることです。

ML ワークフローは、データの準備や分析からトレーニング、評価、デプロイに至るまで、相互に依存するさまざまな手順を伴う場合があります。ノートブックやスクリプトの組み合わせなど、場当たり的な方法でこうしたプロセスを作成、追跡することは困難であり、監査や再現性といった問題はますます解決しづらくなっています。Kubeflow Pipelines（KFP）は、堅牢で再現可能な機械学習パイプラインをデプロイする手段を提供するだけでなく、モニタリング、監査、バージョントラッキング、再現性も実現することで、こうした問題を解決します。Cloud AI Pipelines を使用すると、KFP のインストールを簡単に設定できます。

作成するアプリの概要

この Codelab では、Kubeflow Pipelines を使用してモデルをトレーニングし、サービングすることで、GitHub の問題をまとめるウェブアプリを作成します。これは、Kubeflow のサンプルリポジトリの例に基づいています。完了するとインフラストラクチャには以下が含まれるようになります。

Kubeflow Pipelines がインストールされた（Cloud AI Pipelines 経由）Google Kubernetes Engine（GKE）クラスタ。
GPU で Tensor2Tensor モデルをトレーニングするパイプライン
トレーニング済みモデルから予測を提供するサービス提供コンテナ
予測を解釈して GitHub の問題の要約を生成する UI
Kubeflow Pipelines（KFP）SDK を使用してパイプラインをゼロから作成するノートブック

学習内容

作成するパイプラインは、GitHub の問題データで Tensor2Tensor モデルをトレーニングし、問題の本文から問題のタイトルを予測する方法を学習します。次に、トレーニング済みモデルをエクスポートし、Tensorflow Serving を使用してエクスポートしたモデルをデプロイします。パイプラインの最終ステップでは、ウェブアプリが起動し、TF-Serving インスタンスとやり取りしてモデルの予測を取得します。

GKE クラスタに Kubeflow Pipelines をインストールする方法
Kubeflow Pipelines を使用して ML ワークフローを構築して実行する方法
AI Platform Notebook からパイプラインを定義して実行する方法

必要なもの

Kubernetes の基本的な知識があると役立ちますが、必須ではありません。
オーナー権限があるアクティブな GCP プロジェクト
（省略可）GitHub アカウント
Google Cloud Platform（GCP）Console で利用可能な Google Cloud Shell へのアクセス

2. セットアップ

Cloud Shell

ブラウザで GCP Console にアクセスし、プロジェクトの認証情報でログインします。

必要に応じて [Select a project] をクリックして、Codelab プロジェクトで作業できるようにします。

次に、コンソールの右上にある [Cloud Shell をアクティブにする] アイコンをクリックして、Cloud Shell を起動します。

Cloud Shell を起動すると、使用するように設定されているプロジェクトの名前が表示されます。この設定が正しいことを確認します。

プロジェクト ID を確認するには、GCP Console の [ホーム] パネルにアクセスします。画面が空の場合は、プロンプトで [はい] をクリックしてダッシュボードを作成します。

次に、必要に応じて Cloud Shell ターミナルで次のコマンドを実行して、正しいプロジェクトを使用するように gcloud を構成します。

export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}

Storage バケットを作成する

パイプラインファイルを保存する Cloud Storage バケットを作成します。グローバルに一意の ID を使用する必要があるため、プロジェクト ID を含むバケット名を定義すると便利です。gsutil mb（バケット作成）コマンドを使用してバケットを作成します。

export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}

また、GCP コンソールからバケットを作成することもできます。

省略可: GitHub トークンを作成する

この Codelab では、GitHub API を呼び出して一般公開されているデータを取得します。特に多数の匿名リクエストが GitHub API に送信されるイベントでのレート制限を回避するために、権限なしでアクセストークンを設定します。これは、匿名ユーザーではなく個人として承認するためです。

https://github.com/settings/tokens に移動して、スコープのない新しいトークンを生成します。
安全な場所に保存してください。紛失した場合は、削除して新しいものを作成する必要があります。

この手順をスキップしてもラボは機能しますが、モデルをテストするための入力データを生成するオプションが少し制限されます。

省略可: 便利なダッシュボードを固定する

GCP コンソールで、[Kubernetes Engine] と [Storage] のダッシュボードを固定して、アクセスしやすくします。

AI Platform Pipelines（ホスト型 Kubeflow Pipelines）のインストールを作成する

こちらの「始める前に」と「インスタンスを設定する」のセクションの手順に沿って、KFP がインストールされた GKE インスタンスを設定します。ドキュメントに記載されているように、[次の Cloud API へのアクセスを許可する] チェックボックスを必ずオンにしてください。（これを行わないと、サンプルパイプラインが正常に実行されません）。インストール名前空間は default のままにします。

Nvidia k80 をサポートするゾーンを選択する必要があります。デフォルトとして us-central1-a または us-central1-c を使用できます。

インストールが完了したら、AI Pipelines ダッシュボードに表示されるインストールの GKE クラスタ名とゾーンをメモし、便宜上、これらの値に環境変数を設定します。

export ZONE=<your zone>
export CLUSTER_NAME=<your cluster name>

新しい GKE クラスタの認証情報を使用するように kubectl を設定する

GKE クラスタが作成されたら、Cloud Shell で次のコマンドを実行して、新しいクラスタの認証情報を使用するように kubectl を構成します。

gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE}

または、AI Pipelines ダッシュボードでクラスタの名前をクリックして GKE ページに移動し、ページ上部の [接続] をクリックします。ポップアップで、コマンドを Cloud Shell に貼り付けます。

これにより、クラスタを操作できるように kubectl コンテキストが構成されます。構成を確認するには、次のコマンドを実行します。

kubectl get nodes -o wide

ノードが「Ready」のステータスで一覧表示され、ノードの経過時間、バージョン、外部 IP アドレス、OS イメージ、カーネルバージョン、コンテナランタイムに関するその他の情報が表示されます。

GPU 対応ノードプールに Nvidia ドライバをインストールするようにクラスタを構成する

次に、daemonset をクラスタに適用します。これにより、GPU 対応のクラスタノードに Nvidia ドライバがインストールされます。

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

次に、次のコマンドを実行して、KFP コンポーネントに新しい Kubernetes リソースを作成する権限を付与します。

kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner

GPU ノードプールを作成する

次に、サイズが 1 の GPU ノードプールを設定します。

gcloud container node-pools create gpu-pool \
    --cluster=${CLUSTER_NAME} \
    --zone ${ZONE} \
    --num-nodes=1 \
    --machine-type n1-highmem-8 \
    --scopes cloud-platform --verbosity error \
    --accelerator=type=nvidia-tesla-k80,count=1

3. パイプラインダッシュボードからパイプラインを実行する

パイプラインダッシュボードを開く

Cloud コンソールで、[パイプライン] パネルに移動します（まだ移動していない場合）。インストールしたインスタンスの [パイプラインダッシュボードを開く] をクリックし、左側のメニューバーで [パイプライン] をクリックします。読み込みエラーが表示された場合は、タブを更新してください。次のような新しいページが表示されます。

パイプラインの説明

実行するパイプラインには、いくつかのステップがあります（詳細については、この Codelab の付録をご覧ください）。

既存のモデルチェックポイントがバケットにコピーされます。
前処理されたデータを使用して Tensor2Tensor モデルをトレーニングします。

トレーニングは、最初の手順でコピーされた既存のモデルチェックポイントから開始され、さらに数百ステップのトレーニングが行われます。（Codelab の間に完全にトレーニングするには時間がかかりすぎます）。
トレーニングが終了すると、パイプラインステップは TensorFlow Serving によるサービングに適した形式でモデルをエクスポートします。

このモデルを使用して TensorFlow Serving インスタンスがデプロイされます。
ウェブアプリが起動し、サービングされたモデルとやり取りして予測を取得します。

パイプラインをダウンロードしてコンパイルする

このセクションでは、パイプライン定義をコンパイルする方法について説明します。まず、KFP SDK をインストールする必要があります。Cloud Shell で次のコマンドを実行します。

pip3 install -U kfp

パイプライン定義ファイルをダウンロードするには、Cloud Shell から次のコマンドを実行します。

curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py

次に、次のように実行してパイプライン定義ファイルをコンパイルします。

python3 gh_summ_hosted_kfp.py

結果として gh_summ_hosted_kfp.py.tar.gz ファイルが表示されます。

コンパイルされたパイプラインをアップロードする

Kubeflow Pipelines ウェブ UI で、[パイプラインをアップロード] をクリックし、[URL でインポート] を選択します。コピーして、コンパイルしたパイプラインと同じパイプラインを指す次の URL を貼り付けます。（Cloud Shell からファイルをアップロードするには、いくつかの追加の手順が必要になるため、ショートカットを使用します）。

https://storage.googleapis.com/aju-dev-demos-codelabs/KF/compiled_pipelines/gh_summ_hosted_kfp.py.tar.gz

パイプラインに名前を付けます（例: gh_summ）。

パイプラインを実行する

リストでアップロードしたパイプラインをクリックします。これにより、パイプラインの静的グラフが表示されます。次に、[テストを作成] をクリックして、パイプラインを使用して新しいテストを作成します。テストは、意味的に関連する実行をグループ化する方法です。

テストに名前（パイプラインと同じ名前 gh_summ など）を付けて、[次へ] をクリックして作成します。

実行のパラメータを入力して開始できるページが表示されます。

パラメータの入力に役立つように、Cloud Shell で次のコマンドを実行することをおすすめします。

gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"

実行名は自動的に入力されますが、必要に応じて別の名前を付けることができます。

次に、3 つのパラメータフィールドに入力します。

project
（省略可）github-token
working-dir

working-dir に、作成した GCS バケットの下のパスを入力します。接頭辞「gs://」を含めます。github-token フィールドには、必要に応じて事前に生成したトークンを入力するか、トークンを生成していない場合はプレースホルダ文字列をそのままにします。

フィールドに入力したら、[開始] をクリックし、リストに表示された実行をクリックして詳細を表示します。特定のパイプラインステップの実行中に、そのステップをクリックすると、Pod ログの表示など、詳細情報を取得できます。（クラスタノードが破棄された場合でも、Cloud Logging（Stackdriver）ログへのリンクからパイプラインステップのログを表示できます）。

パイプラインの定義を表示する

パイプラインの実行中に、パイプラインの構成と処理内容を詳しく確認することをおすすめします。詳しくは、Codelab の付録セクションをご覧ください。

TensorBoard でモデルトレーニング情報を表示する

トレーニングステップが完了したら、[可視化] タブを選択し、青色の [TensorBoard を開始] ボタンをクリックします。準備ができたら、[TensorBoard を開く] をクリックします。

アーティファクトと実行のダッシュボードを確認する

Kubeflow Pipelines は、パイプラインの実行時にパイプラインステップに関するメタデータを自動的にログに記録します。アーティファクトと実行の両方の情報が記録されます。ダッシュボードの左側のナビゲーションバーにあるこれらのエントリをクリックすると、さらに詳しく確認できます。

アーティファクトの場合、概要パネルとリネージエクスプローラパネルの両方を表示できます。

パイプラインで作成したウェブアプリを起動して予測を行う

パイプラインの最後のステップでは、トレーニング済みモデル（TF Serving 経由で提供）をクエリして予測を行うための UI を提供するウェブアプリをデプロイします。

パイプラインが完了したら、ポート転送によってウェブアプリのサービスに接続します（この Codelab では、ウェブアプリサービスが外部エンドポイントを持つように設定されていないため、ポート転送を行います）。

Cloud Shell で次のコマンドを実行して、サービス名を見つけます。

kubectl get services

リストで、ghsumm-*-webappsvc のようなサービス名を探します。

次に、Cloud Shell で、次のようにサービスにポート転送します。次のコマンドを変更して、webappsvc の名前を使用します。

kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80

ポート転送が実行されたら、Cloud Shell ペインの上にある「プレビュー」アイコンをクリックし、プルダウンで [ポート 8080 でプレビュー] をクリックします。

新しいタブに次のようなページが表示されます。

[Populate Random Issue] ボタンをクリックして、テキストのブロックを取得します。[Generate TItle] をクリックして、トレーニング済みモデルを呼び出し、予測を表示します。

パイプラインパラメータに有効な GitHub トークンが含まれている場合は、代わりに 2 番目のフィールドに GitHub URL を入力して、[タイトルを生成] をクリックしてみてください。有効な GitHub トークンを設定していない場合は、[Populate Random Issue] フィールドのみを使用します。

4. AI Platform Notebook からパイプラインを実行する

KFP SDK を使用して、Jupyter ノートブックから Kubeflow Pipelines をインタラクティブに定義して実行することもできます。この Codelab で使用する AI Platform Notebooks を使用すると、このプロセスが非常に簡単になります。

ノートブックインスタンスの作成

Cloud Shell から API を使用してノートブックインスタンスを作成します。（または、Cloud コンソールからノートブックを作成することもできます。詳細については、ドキュメントをご覧ください。

Cloud Shell で次の環境変数を設定します。

export INSTANCE_NAME="kfp-ghsumm"
export VM_IMAGE_PROJECT="deeplearning-platform-release"
export VM_IMAGE_FAMILY="tf2-2-3-cpu"
export MACHINE_TYPE="n1-standard-4"
export LOCATION="us-central1-c"

次に、Cloud Shell からコマンドを実行してノートブックインスタンスを作成します。

gcloud beta notebooks instances create $INSTANCE_NAME \
  --vm-image-project=$VM_IMAGE_PROJECT \
  --vm-image-family=$VM_IMAGE_FAMILY \
  --machine-type=$MACHINE_TYPE --location=$LOCATION

このコマンドを初めて実行するときに、プロジェクトで notebooks API を有効にするよう求められることがあります。該当する場合は「y」と返信します。

数分後、ノートブックサーバーが起動して実行されます。Notebook インスタンスは Cloud コンソールに一覧表示されます。

Codelab ノートブックをアップロードする

ノートブックインスタンスが作成されたら、このリンクをクリックして、Codelab の Jupyter ノートブックをアップロードします。使用するノートブックインスタンスを選択します。ノートブックが自動的に開きます。

ノートブックを実行する

ラボの残りの部分については、ノートブックの手順に沿って操作してください。ノートブックの「設定」部分では、ノートブックの残りの部分を実行する前に、独自の値を入力する必要があります。

（独自のプロジェクトを使用している場合は、このラボの「クリーンアップ」セクションに戻って実行することを忘れないでください）。

5. クリーンアップ

一時的な Codelab アカウントを使用している場合は、この操作を行う必要はありません。ただし、独自のプロジェクトを使用している場合は、Pipelines のインストールと Notebook を削除することをおすすめします。

Pipelines GKE クラスタを停止する

パイプラインクラスタは Cloud Console から削除できます。（GKE クラスタを再利用する場合は、Pipelines のインストールのみを削除することもできます）。

AI Notebook インスタンスを削除する

この Codelab の「Notebook」パートを実行した場合は、Cloud Console からノートブックインスタンスを削除または停止できます。

省略可: GitHub トークンを削除する

https://github.com/settings/tokens に移動して、生成したトークンを削除します。

6. 付録

コードを確認する

パイプラインの定義

この Codelab で使用するパイプラインは、こちらで定義されています。

定義方法と、そのコンポーネント（ステップ）の定義方法を見てみましょう。ここでは概要を説明します。詳細については、ドキュメントをご覧ください。

Kubeflow パイプラインステップはコンテナベースです。パイプラインを構築する際は、すでに構築済みのコンテナイメージを含む事前構築済みコンポーネントを使用するか、独自のコンポーネントを構築できます。この Codelab では、独自のものを構築しました。

パイプラインステップのうち 4 つは、コンポーネント定義ファイルを介してアクセスされる再利用可能なコンポーネントから定義されます。最初のコードスニペットでは、これらのコンポーネント定義ファイルに URL 経由でアクセスし、これらの定義を使用してパイプラインステップの作成に使用する「ops」を作成しています。

import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp

...

copydata_op = comp.load_component_from_url(
  'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
  )

train_op = comp.load_component_from_url(
  'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
  )

以下は、トレーニングオペレーションのコンポーネント定義の 1 つを YAML 形式で示しています。入力、出力、コンテナイメージ、コンテナエントリポイント引数が定義されていることがわかります。

name: Train T2T model
description: |
  A Kubeflow Pipeline component to train a Tensor2Tensor
  model
metadata:
  labels:
    add-pod-env: 'true'
inputs:
  - name: train_steps
    description: '...'
    type: Integer
    default: 2019300
  - name: data_dir
    description: '...'
    type: GCSPath
  - name: model_dir
    description: '...'
    type: GCSPath
  - name: action
    description: '...'
    type: String
  - name: deploy_webapp
    description: '...'
    type: String
outputs:
  - name: launch_server
    description: '...'
    type: String
  - name: train_output_path
    description: '...'
    type: GCSPath
  - name: MLPipeline UI metadata
    type: UI metadata
implementation:
  container:
    image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
    args: [
      --data-dir, {inputValue: data_dir},
      --action, {inputValue: action},
      --model-dir, {inputValue: model_dir},
      --train-steps, {inputValue: train_steps},
      --deploy-webapp, {inputValue: deploy_webapp},
      --train-output-path, {outputPath: train_output_path}
    ]
    env:
      KFP_POD_NAME: "{{pod.name}}"
    fileOutputs:
      launch_server: /tmp/output
      MLPipeline UI metadata: /mlpipeline-ui-metadata.json

以下で説明するように、dsl.ContainerOp コンストラクタを使用してパイプラインステップを定義することもできます。

以下に、パイプライン定義の大部分を示します。パイプライン入力（とそのデフォルト値）を定義しています。次に、パイプラインステップを定義します。ほとんどの場合、上記で定義した「ops」を使用していますが、ContainerOp を介して「serve」ステップをインラインで定義し、コンテナイメージとエントリポイント引数を直接指定しています。

train、log_model、serve の各ステップが、前のステップの出力を入力としてアクセスしていることがわかります。この指定方法について詳しくは、こちらをご覧ください。

@dsl.pipeline(
 name='Github issue summarization',
 description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ(  #pylint: disable=unused-argument
 train_steps: 'Integer' = 2019300,
 project: str = 'YOUR_PROJECT_HERE',
 github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
 working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
 checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
 deploy_webapp: str = 'true',
 data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
 ):


 copydata = copydata_op(
   data_dir=data_dir,
   checkpoint_dir=checkpoint_dir,
   model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
   action=COPY_ACTION,
   )


 train = train_op(
   data_dir=data_dir,
   model_dir=copydata.outputs['copy_output_path'],
   action=TRAIN_ACTION, train_steps=train_steps,
   deploy_webapp=deploy_webapp
   )

 serve = dsl.ContainerOp(
     name='serve',
     image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
     arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
         "--model_path", train.outputs['train_output_path']
         ]
     )

 train.set_gpu_limit(1)

「train」ステップは、少なくとも 1 つの GPU を使用できるクラスタ内のノードで実行する必要があります。

  train.set_gpu_limit(1)

パイプラインの最後のステップ（インラインで定義）は条件付きです。これは、トレーニングステップ launch_server の出力が文字列「true」の場合にのみ、ステップ「serve」の完了後に実行されます。トレーニング済みの T2T モデルから問題の概要をリクエストするために使用した「予測ウェブアプリ」が起動します。

 with dsl.Condition(train.outputs['launch_server'] == 'true'):
   webapp = dsl.ContainerOp(
       name='webapp',
       image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
       arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
           "--github_token", github_token]

       )
   webapp.after(serve)

コンポーネントコンテナイメージの定義

Kubeflow Pipeline のドキュメントでは、独自のコンポーネントを構築するためのベストプラクティスについて説明しています。このプロセスの一環として、コンテナイメージを定義してビルドする必要があります。この Codelab のパイプラインのコンポーネントステップは、こちらで確認できます。Dockerfile の定義は containers サブディレクトリにあります（こちらなど）。

GPU を使用したプリエンプティブル VM をトレーニングに使用する

プリエンプティブル VM は、最長持続時間が 24 時間で、可用性が保証されない Compute Engine VM インスタンスです。プリエンプティブル VM の料金は、標準の Compute Engine VM よりも低くなっています。

Google Kubernetes Engine（GKE）を使用すると、プリエンプティブル VM を使用するクラスタまたはノードプールを簡単に設定できます。このようなノードプールは、プリエンプティブルインスタンスに接続された GPU を使用して設定できます。これらは通常の GPU 対応ノードと同じように機能しますが、GPU はインスタンスの存続期間中にのみ有効になります。

次のコマンドと同様のコマンドを実行し、クラスタ名とゾーンで次のコマンドを編集し、要件に応じてアクセラレータのタイプと数を調整することで、クラスタのプリエンプティブルな GPU 対応ノードプールを設定できます。必要に応じて、現在のワークロードに基づいて自動スケーリングするようにノードプールを定義できます。

gcloud container node-pools create preemptible-gpu-pool \
    --cluster=<your-cluster-name> \
    --zone <your-cluster-zone> \
    --enable-autoscaling --max-nodes=4 --min-nodes=0 \
    --machine-type n1-highmem-8 \
    --preemptible \
    --node-taints=preemptible=true:NoSchedule \
    --scopes cloud-platform --verbosity error \
    --accelerator=type=nvidia-tesla-k80,count=4

Cloud コンソールを使用してノードプールを設定することもできます。

プリエンプティブル GKE ノードを使用する Kubeflow パイプラインを定義する

GKE で Kubeflow を実行している場合、1 つ以上のパイプラインステップ（コンポーネント）がプリエンプティブルノードで実行される Kubeflow Pipelines を簡単に定義して実行できるようになりました。これにより、ジョブの実行コストを削減できます。プリエンプティブル VM を使用して正しい結果を得るには、プリエンプティブルとして識別するステップがべき等（つまり、ステップを複数回実行しても同じ結果になる）であるか、中断された場合にステップが中断した場所から再開できるように作業をチェックポイントする必要があります。

Kubeflow パイプラインを定義するときに、次のように op を変更して、特定のステップをプリエンプティブルノードで実行するように指定できます。

your_pipelines_op.apply(gcp.use_preemptible_nodepool())

詳しくは、こちらのドキュメントをご覧ください。

ノードがプリエンプトされた場合は、手順を数回再試行することもできます。次の例では、再試行回数を 5 回に指定しています。

your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)

この Codelab で使用した Kubeflow パイプラインを編集して、プリエンプティブル VM でトレーニングステップを実行してみてください。

パイプライン仕様の次の行を変更して、プリエンプティブルノードプール（上記のように作成済みであることを確認してください）をさらに使用し、5 回再試行するようにします。

  train.set_gpu_limit(1)

次に、パイプラインを再コンパイルし、新しいバージョンをアップロードして（新しい名前を付けます）、新しいバージョンのパイプラインを実行します。