Эта страница переведена с помощью Cloud Translation API.

Конвейеры Kubeflow — обзор проблем GitHub

1. Введение

Kubeflow — это набор инструментов машинного обучения для Kubernetes . Цель проекта — сделать развертывание рабочих процессов машинного обучения (ML) в Kubernetes простым, портативным и масштабируемым. Цель состоит в том, чтобы предоставить простой способ развертывания лучших в своем классе систем с открытым исходным кодом для машинного обучения в различных инфраструктурах.

Рабочий процесс машинного обучения может включать в себя множество зависимых друг от друга этапов: от подготовки и анализа данных до обучения, оценки, развертывания и многого другого. Трудно составлять и отслеживать эти процессы в разовом порядке — например, с помощью набора блокнотов или сценариев — и такие вещи, как аудит и воспроизводимость, становятся все более проблематичными. Kubeflow Pipelines (KFP) помогает решить эти проблемы, предоставляя возможность развертывания надежных, повторяемых конвейеров машинного обучения, а также мониторинга, аудита, отслеживания версий и воспроизводимости. Cloud AI Pipelines упрощает настройку установки KFP.

Что ты построишь

В этой лаборатории кода вы создадите веб-приложение, которое обобщает проблемы GitHub, используя Kubeflow Pipelines для обучения и обслуживания модели. Он основан на примере в репозитории Kubeflow Samples . По завершении ваша инфраструктура будет содержать:

Кластер Google Kubernetes Engine (GKE) с установленными Kubeflow Pipelines (через Cloud AI Pipelines ).
Конвейер, который обучает модель Tensor2Tensor на графических процессорах.
Обслуживающий контейнер, предоставляющий прогнозы на основе обученной модели.
Пользовательский интерфейс, который интерпретирует прогнозы для предоставления сводных данных по проблемам GitHub.
Блокнот, который создает конвейер с нуля с помощью SDK Kubeflow Pipelines (KFP).

Что вы узнаете

Конвейер, который вы создадите, обучает модель Tensor2Tensor на данных о задачах GitHub, обучаясь прогнозировать названия задач на основе тел задач. Затем он экспортирует обученную модель и развертывает экспортированную модель с помощью Tensorflow Serving . Последний шаг конвейера запускает веб-приложение, которое взаимодействует с экземпляром TF-Serving для получения прогнозов модели.

Как установить Kubeflow Pipelines в кластере GKE
Как создавать и запускать рабочие процессы машинного обучения с помощью Kubeflow Pipelines
Как определить и запустить конвейеры с помощью AI Platform Notebook

Что вам понадобится

Базовое понимание Kubernetes будет полезно, но не обязательно.
Активный проект GCP , для которого у вас есть разрешения владельца.
(Необязательно) Учетная запись GitHub.
Доступ к Google Cloud Shell , доступный в консоли Google Cloud Platform (GCP).

2. Настройка

Облачная оболочка

Посетите консоль GCP в браузере и войдите в систему, используя свои учетные данные проекта:

При необходимости нажмите «Выбрать проект», чтобы начать работу с проектом Codelab.

Затем нажмите значок «Активировать Cloud Shell» в правом верхнем углу консоли, чтобы запустить Cloud Shell .

Когда вы запустите Cloud Shell, он сообщит вам имя проекта, который он будет использовать. Проверьте правильность этой настройки.

Чтобы найти идентификатор своего проекта, посетите домашнюю панель консоли GCP. Если экран пуст, нажмите «Да» в приглашении, чтобы создать панель мониторинга.

Затем в терминале Cloud Shell при необходимости выполните следующие команды, чтобы настроить gcloud на использование правильного проекта:

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

Создайте сегмент хранения

Создайте корзину Cloud Storage для хранения файлов конвейера. Вам потребуется использовать глобальный уникальный идентификатор, поэтому удобно определить имя сегмента, включающее идентификатор вашего проекта. Создайте корзину с помощью команды gsutil mb (создать корзину):

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

Альтернативно вы можете создать сегмент через консоль GCP .

Необязательно: создайте токен GitHub.

Эта кодовая лаборатория вызывает API GitHub для получения общедоступных данных. Чтобы предотвратить ограничение скорости, особенно на событиях, когда к API GitHub отправляется большое количество анонимных запросов, настройте токен доступа без разрешений. Это просто для того, чтобы авторизовать вас как индивидуального, а не анонимного пользователя.

Перейдите по адресу https://github.com/settings/tokens и создайте новый токен без областей действия.
Сохраните его в безопасном месте. Если вы потеряете его, вам нужно будет удалить и создать новый.

Если вы пропустите этот шаг, лаборатория все равно будет работать — просто вы будете немного более ограничены в своих возможностях по созданию входных данных для тестирования вашей модели.

Необязательно: закрепите полезные информационные панели.

В консоли GCP закрепите панели управления Kubernetes Engine и Storage для облегчения доступа.

Создайте установку конвейеров AI Platform (размещенные конвейеры Kubeflow).

Следуйте инструкциям в разделах «Перед началом работы» и «Настройка экземпляра» здесь, чтобы настроить экземпляр GKE с установленным KFP. Обязательно установите флажок Разрешить доступ к следующим облачным API , как указано в документации. (Если вы этого не сделаете, пример конвейера не будет работать успешно). Оставьте пространство имен установки по default .

Вам нужно будет выбрать зону, поддерживающую Nvidia k80. По умолчанию вы можете использовать us-central1-a или us-central1-c .

После завершения установки запишите имя и зону кластера GKE для вашей установки на панели управления AI Pipelines и для удобства установите эти значения для переменных среды.

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

Настройте kubectl для использования учетных данных нового кластера GKE.

После создания кластера GKE настройте kubectl на использование учетных данных нового кластера, выполнив следующую команду в Cloud Shell:

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-адресе, образе ОС, версии ядра и времени выполнения контейнера.

Настройте кластер для установки драйвера Nvidia в пулах узлов с поддержкой графического процессора.

Далее мы применим к кластеру демонсет , который установит драйвер 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:

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.

Откройте панель управления конвейерами.

В Cloud Console посетите панель «Конвейеры» , если вы еще этого не сделали. Затем нажмите « ОТКРЫТЬ ПАНЕЛЬ PIPELINES » для вашей установки и нажмите «Pipelines» в левой строке меню. Если вы получаете ошибку загрузки, обновите вкладку. Вы должны увидеть новую страницу, похожую на эту:

Описание конвейера

Конвейер, который вы запустите, состоит из нескольких этапов (подробности см. в Приложении к этой кодовой лаборатории):

Существующая контрольная точка модели копируется в ваш сегмент.
Модель Tensor2Tensor обучается с использованием предварительно обработанных данных.

Обучение начинается с существующей контрольной точки модели, скопированной на первом шаге, затем выполняется еще несколько сотен шагов. (Полное обучение во время кодовой лаборатории заняло бы слишком много времени).
По завершении обучения этап конвейера экспортирует модель в форму, подходящую для обслуживания службой TensorFlow .

Экземпляр, обслуживающий 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 нажмите « Загрузить конвейер» и выберите « Импортировать по 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"

Имя запуска будет заполнено автоматически, но при желании вы можете дать ему другое имя.

Затем заполните три поля параметров:

project
(необязательно) github-token
working-dir

В качестве рабочего каталога введите путь к созданному вами сегменту GCS. Включите префикс « gs:// ». В поле github-token введите либо токен, который вы при необходимости сгенерировали ранее, либо оставьте строку-заполнитель без изменений, если вы не создавали токен.

После заполнения полей нажмите «Начать» , затем нажмите на указанный запуск, чтобы просмотреть его подробности. Во время выполнения определенного шага конвейера вы можете щелкнуть по нему, чтобы получить дополнительную информацию о нем, включая просмотр журналов его модулей . (Вы также можете просмотреть журналы этапа конвейера по ссылке на его журналы Cloud Logging (Stackdriver) , даже если узел кластера был отключен).

Просмотр определения конвейера

Пока конвейер работает, вы можете поближе взглянуть на то, как он устроен и что он делает. Более подробная информация приведена в разделе «Приложение» лаборатории кода.

Просмотр информации об обучении модели в TensorBoard

После завершения этапа обучения выберите вкладку «Визуализации» и нажмите синюю кнопку «Запустить TensorBoard» , а затем, когда все будет готово, нажмите « Открыть Tensorboard» .

Изучите панель «Артефакты и исполнения»

Kubeflow Pipelines автоматически регистрирует метаданные об этапах конвейера по мере его выполнения. Записывается информация как об артефакте , так и о выполнении . Щелкните эти записи на левой панели навигации панели управления, чтобы изучить их дальше.

Для Артефактов вы можете просмотреть как панель обзора, так и панель Lineage Explorer.

Откройте веб-приложение, созданное конвейером, и сделайте несколько прогнозов.

На последнем этапе конвейера развертывается веб-приложение, которое предоставляет пользовательский интерфейс для запроса обученной модели, обслуживаемой через TF Serving , для составления прогнозов.

После завершения работы конвейера подключитесь к веб-приложению , перенаправив порт на его службу (мы используем переадресацию портов, поскольку в этой лаборатории кода служба веб-приложения не настроена на наличие внешней конечной точки).

Найдите имя службы, выполнив эту команду в Cloud Shell:

kubectl get services

Найдите в списке такое имя службы: ghsumm-*-webappsvc .

Затем в Cloud Shell перенаправьте порт на эту службу следующим образом, изменив следующую команду, чтобы использовать имя вашего webappsvc :

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

После запуска переадресации портов щелкните значок «Предварительный просмотр» над панелью Cloud Shell и в раскрывающемся списке выберите «Предварительный просмотр на порту 8080».

Вы должны увидеть такую страницу в новой вкладке:

Нажмите кнопку «Заполнить случайную задачу» , чтобы получить блок текста. Нажмите «Создать заголовок» , чтобы вызвать обученную модель и отобразить прогноз.

Если параметры вашего конвейера включают действительный токен GitHub, вы также можете попробовать ввести URL-адрес GitHub во втором поле, а затем нажать «Создать заголовок». Если вы не настроили действительный токен GitHub, используйте только поле «Заполнить случайную проблему».

4. Запустите конвейер из ноутбука AI Platform.

Вы также можете в интерактивном режиме определять и запускать конвейеры Kubeflow из блокнота Jupyter с помощью KFP SDK. Приложение AI Platform Notebooks , которое мы будем использовать для этой лабораторной работы, делает это очень простым.

Создать экземпляр блокнота

Мы создадим экземпляр блокнота из Cloud Shell, используя его API. (В качестве альтернативы вы можете создать блокнот через Cloud Console . Дополнительную информацию смотрите в документации).

Установите следующие переменные среды в 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

При первом запуске этой команды вас могут попросить включить API notebooks для вашего проекта. Если да, ответьте « y ».

Через несколько минут сервер вашего ноутбука будет готов к работе. Вы можете увидеть свои экземпляры Notebook в списке Cloud Console .

Загрузите блокнот кодовой лаборатории

После создания экземпляра блокнота щелкните эту ссылку , чтобы загрузить блокнот Jupyter кодовой лаборатории. Выберите экземпляр блокнота для использования. Блокнот откроется автоматически.

Выполнить блокнот

Следуйте инструкциям в блокноте до конца лабораторной работы. Обратите внимание, что в разделе «Настройка» записной книжки вам нужно будет ввести собственные значения, прежде чем запускать остальную часть записной книжки.

(Если вы используете свой собственный проект, не забудьте вернуться и выполнить раздел «Очистка» этой лабораторной работы).

5. Очистка

Вам не нужно этого делать, если вы используете временную учетную запись Codelab, но вы можете удалить установку Pipelines и Notebook, если вы используете свой собственный проект.

Удалить кластер Pipelines GKE

Вы можете удалить кластер Pipelines из Cloud Console . (У вас есть возможность просто удалить установку Pipelines, если вы хотите повторно использовать кластер GKE).

Удалить экземпляр AI Notebook

Если вы запустили часть лаборатории кода «Блокнот», вы можете УДАЛИТЬ или ОСТАНОВИТЬ экземпляр блокнота из облачной консоли .

Необязательно: удалите токен GitHub.

Перейдите по адресу https://github.com/settings/tokens и удалите сгенерированный токен.

6. Приложения

Взгляните на код

Определение конвейера

Конвейер, используемый в этой кодовой лаборатории, определен здесь .

Давайте посмотрим, как оно определяется, а также как определяются его компоненты (шаги). Мы рассмотрим некоторые основные моменты, но более подробную информацию можно найти в документации .

Шаги Kubeflow Pipeline основаны на контейнерах. При создании конвейера вы можете использовать готовые компоненты с уже созданными образами контейнеров или создавать собственные компоненты. Для этой лаборатории кода мы создали свою собственную.

Четыре шага конвейера определяются на основе повторно используемых компонентов , доступ к которым осуществляется через файлы определений компонентов . В этом первом фрагменте кода мы получаем доступ к этим файлам определений компонентов через их URL-адрес и используем эти определения для создания операций, которые мы будем использовать для создания шага конвейера.

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

Ниже приведено одно из определений компонентов для обучающей операции в формате 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», определенный выше, но мы также определяем шаг «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)

Обратите внимание, что мы требуем, чтобы шаг «обучение» выполнялся на узле в кластере, имеющем хотя бы 1 доступный графический процессор.

  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 описаны некоторые рекомендации по созданию собственных компонентов. В рамках этого процесса вам нужно будет определить и создать образ контейнера. Вы можете увидеть шаги компонента для конвейера этой кодовой лаборатории здесь . Определения Dockerfile находятся в подкаталогах containers , например здесь .

Используйте вытесняемые виртуальные машины с графическими процессорами для обучения

Вытесняемые виртуальные машины — это экземпляры виртуальных машин Compute Engine , которые работают максимум 24 часа и не предоставляют никаких гарантий доступности. Цена на вытесняемые виртуальные машины ниже, чем на стандартные виртуальные машины Compute Engine.

С помощью Google Kubernetes Engine (GKE) легко настроить кластер или пул узлов , использующий вытесняемые виртуальные машины . Вы можете настроить такой пул узлов с графическими процессорами, подключенными к вытесняемым экземплярам . Они работают так же, как и обычные узлы с поддержкой графического процессора, но графические процессоры сохраняются только на протяжении всего срока службы экземпляра.

Вы можете настроить вытесняемый пул узлов с поддержкой графического процессора для своего кластера, выполнив команду, аналогичную приведенной ниже, отредактировав следующую команду, указав имя и зону вашего кластера, а также настроив тип и количество ускорителей в соответствии с вашими требованиями. При желании вы можете определить пул узлов для автоматического масштабирования в зависимости от текущих рабочих нагрузок.

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

Определение конвейера Kubeflow, использующего вытесняемые узлы GKE.

Если вы используете Kubeflow на GKE, теперь легко определить и запустить конвейеры Kubeflow , в которых один или несколько шагов конвейера (компонентов) выполняются на вытесняемых узлах , что снижает стоимость выполнения задания. Чтобы использование вытесняемых виртуальных машин давало правильные результаты, шаги, которые вы идентифицируете как вытесняемые, должны быть либо идемпотентными (то есть, если вы запускаете шаг несколько раз, он будет иметь один и тот же результат), либо должны работать контрольные точки, чтобы шаг мог продолжите с того места, где остановились, если прервали.

Когда вы определяете конвейер Kubeflow, вы можете указать, что данный шаг должен выполняться на вытесняемом узле, изменив операцию следующим образом:

your_pipelines_op.apply(gcp.use_preemptible_nodepool())

Подробности смотрите в документации .

Вероятно, вам также захочется повторить этот шаг несколько раз, если узел вытеснен. Вы можете сделать это следующим образом: здесь мы указываем 5 повторов.

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

Попробуйте отредактировать конвейер Kubeflow, который мы использовали в этой лаборатории кода, чтобы выполнить этап обучения на вытесняемой виртуальной машине .

Измените следующую строку в спецификации конвейера, чтобы дополнительно использовать вытесняемый пул узлов (убедитесь, что вы создали его, как указано выше) выше, и повторите попытку 5 раз:

  train.set_gpu_limit(1)

Затем перекомпилируйте конвейер, загрузите новую версию (присвойте ей новое имя) и запустите новую версию конвейера.