このページは Cloud Translation API によって翻訳されました。

Kubeflow Pipelines - GitHub の問題の要約

1. はじめに

Kubeflow は Kubernetes 用の ML ツールキットです。このプロジェクトは、Kubernetes での機械学習（ML）ワークフローのデプロイを、シンプルかつポータブルかつスケーラブルにすることに特化したものです。目標は、ML 用の最善のオープンソースシステムを多様なインフラストラクチャに簡単にデプロイできる方法を提供することです。

ML ワークフローは、データの準備と分析から、トレーニング、評価、デプロイまで、相互に依存関係のある多くのステップを伴います。これらのプロセスを、たとえばノートブックやスクリプトのセットでアドホックに構成して追跡することは困難であり、監査や再現性などがますます問題になります。Kubeflow Pipelines（KFP）は、モニタリング、監査、バージョントラッキング、再現性とともに堅牢で再現可能な ML パイプラインをデプロイする方法を提供することで、これらの問題の解決を支援します。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 Notebooks からパイプラインを定義して実行する方法

必要なもの

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

2. セットアップ

Cloud Shell

ブラウザで GCP コンソールにアクセスし、プロジェクトの認証情報を使用してログインします。

[プロジェクトを選択] をクリックします。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 APIs へのアクセスを許可する] チェックボックスを必ずオンにしてください。（そうしないと、サンプルパイプラインは正常に実行されません）。インストール名前空間は default のままにします。

Nvidia K80s をサポートするゾーンを選択する必要があります。デフォルトとして 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

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

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

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

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

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. Pipelines ダッシュボードからパイプラインを実行する

Pipelines ダッシュボードを開く

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

パイプラインの説明

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

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

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

TensorFlow サービングインスタンスは、このモデルを使用してデプロイされます。
提供されるモデルを操作して予測を取得するために、ウェブアプリが起動されます。

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

このセクションでは、パイプライン定義をコンパイルする方法について説明します。まず、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 で、[Upload pipeline] をクリックし、[Import by 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

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

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

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

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

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

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

[Artifacts and Executions] ダッシュボードを確認する

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

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

パイプラインによって作成されたウェブアプリを起動して予測を行います。

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

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

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

kubectl get services

リストで「ghsumm-*-webappsvc」というサービス名を探します。

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

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

ポート転送を実行したら、[preview] をクリックするアイコンをクリックし、プルダウンから [ポート 8080 でプレビュー] をクリックします。

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

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

パイプラインパラメータに有効な GitHub トークンが含まれている場合は、2 つ目のフィールドに GitHub URL を入力してから [Generate Title] をクリックすることもできます。有効な GitHub トークンを設定していない場合は、[Populate Random Issue] のみを使用します。表示されます。

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

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

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

API を使用して Cloud Shell からノートブックインスタンスを作成します。（または、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」と返信確認してください。

数分後、ノートブックサーバーが稼働します。ノートブックインスタンスが Cloud コンソールに一覧表示されます。

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

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

ノートブックを実行する

ラボの残りの部分は、ノートブックの手順に沿って操作します。[設定]タブの独自の値を入力してから、ノートブックの残りの部分を実行する必要があります。

（独自のプロジェクトを使用している場合は、必ず戻ってこのラボの「クリーンアップ」セクションに進んでください）。

5. クリーンアップ

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

Pipelines GKE クラスタを停止する

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

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

「ノートブック」この Codelab では、Cloud コンソールからノートブックインスタンスを削除または停止できます。

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

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

6. 付録

コードを確認する

パイプラインの定義

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

ここでは、その定義方法と、そのコンポーネント（ステップ）の定義について説明します。ここでは主なものを取り上げますが、詳細についてはドキュメントをご覧ください。

Kubeflow Pipeline のステップはコンテナベースです。パイプラインを構築する場合は、ビルド済みコンポーネントまたはビルド済みコンテナイメージを使用するか、独自のコンポーネントを構築できます。この 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 コンストラクタを使用してパイプラインステップを定義することもできます。

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

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」フィールドをステップを実行します。

  train.set_gpu_limit(1)

パイプラインの最後のステップ（インラインで定義）は条件付きです。「serve」の後に実行されますトレーニングステップの launch_server の出力が文字列「true」の場合にのみ終了します。これにより、「予測ウェブアプリ」が起動します。これは、トレーニング済みの 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 Pipelines を定義するときに、次のようにオペレーションを変更することで、特定のステップをプリエンプティブルノードで実行するように指定できます。

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)

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