Kubeflow – Katib 하이퍼 파라미터 튜닝

하이퍼 파라미터 및 하이퍼 파라미터 튜닝

하이퍼 파라미터는 모델 학습 프로세스를 제어하는 ​​변수로서, 학습을 수행하기 위해 사전에 설정해야 하는 값들입니다. 예를 든다면 Learning rate, Batch Size, Regularization Strength 등이 있습니다.

하이퍼 파라미터 값은 학습되지 않습니다. 즉, 가중치 같은 학습 매개 변수와는 달리, 모델 학습 프로세스에서 하이퍼 파라미터 값을 조정하지 않습니다. 그래서 휴리스틱한 방법이나 경험 법칙에 의해서 결정하는 경우가 많습니다.

하이퍼 파라미터 튜닝은 최적의 하이퍼 파라미터 값을 탐색하여, 모델의 예측 정확도를 최대화하는 프로세스입니다. 만일 Katib 같은 자동화된 하이퍼 파라미터 튜닝 시스템이 없다면, 최적의 값을 찾기 위해 하이퍼 파라미터를 수동으로 조정하여, 많은 학습 작업을 사림이 직접 실행해야할것

자동화된 하이퍼 파라미터 튜닝 시스템은 대상의 목표 값을 이루기 위한 최적의 변수 값을 찾기 위해서 노력합니다. 일반적으로 모델의 정확성(accuracy)을 대상으로 사용합니다.

예를 들어 Katib의 다음 그래프는 다양한 하이퍼 파라미터 값의 조합 (learning_rate, dropout)에 따른 정확도를 보여 줍니다.

Katib는 Experiment이라 부르는 하이퍼 파라미터 튜닝 작업을 실행합니다. 실행된 Experiment는 Trial 이라고 부르는 학습 작업을 여러번 실행합니다.


random 알고리즘과 job을 이용한 하이퍼 파라미터 튜닝

하이퍼 파라미터 튜닝에 사용할 학습 모델 컨테이너 이미지를 만들어 보겠습니다.

모델 코드 작성하기

mnist 숫자를 판별하는 모델을 텐서플로우 케라스로 작성해 보겠습니다.

  1. 하이퍼 파라메터를 입력 받기 위해서 argparse 라이브러를 이용하였습니다. learning_rate와 dropout 값을 입력할 수 있습니다. parser = argparse.ArgumentParser() parser.add_argument('--learning_rate', default=0.01, type=float) parser.add_argument('--dropout', default=0.2, type=float) args = parser.parse_args()
  2. 케라스의 콜백을 이용해서, 매 에폭(epoch)마다 accuracy, loss, Validation-accuracy 그리고 Validation-loss를 StdOut 으로 출력하도록 하였습니다. Katib의 StdOutCollector를 사용해서 메트릭을 수집할 것이기 때문에, StdOut으로 {{MetricsName}}={{MetricsValue}} 형태로 메트릭을 StdOut 으로 출력하면 됩니다. 그리고 라인의 맨 앞부분에 RFC-3339 형식의 시간을 출력하면, 메트릭의 시간도 같이 수집이 됩니다. katib_metric_log_callback = KatibMetricLog() training_history = model.fit(x_train, y_train, batch_size=64, epochs=10, validation_data=(x_val, y_val), callbacks=[katib_metric_log_callback]) … class KatibMetricLog(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): # RFC 3339 local_time = datetime.now(timezone.utc).astimezone().isoformat() print(“\nEpoch {}”.format(epoch+1)) print(“{} accuracy={:.4f}”.format(local_time, logs[‘acc’])) print(“{} loss={:.4f}”.format(local_time, logs[‘loss’])) print(“{} Validation-accuracy={:.4f}”.format(local_time, logs[‘val_acc’])) print(“{} Validation-loss={:.4f}”.format(local_time, logs[‘val_loss’]))

다음 코드는 텐서플로우 케라스로 작성한 mnist 숫자를 판별하는 모델입니다.

katib-mnist-random-job.py

from __future__ import absolute_import, division, print_function, unicode_literals

import tensorflow as tf
import numpy as np
import argparse
from datetime import datetime, timezone

def train():
    print("TensorFlow version: ", tf.__version__)

    parser = argparse.ArgumentParser()
    parser.add_argument('--learning_rate', default=0.01, type=float)
    parser.add_argument('--dropout', default=0.2, type=float)
    args = parser.parse_args()

    mnist = tf.keras.datasets.mnist

    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    x_train, x_test = x_train / 255.0, x_test / 255.0

    # Reserve 10,000 samples for validation
    x_val = x_train[-10000:]
    y_val = y_train[-10000:]
    x_train = x_train[:-10000]
    y_train = y_train[:-10000]

    model = tf.keras.models.Sequential([
      tf.keras.layers.Flatten(input_shape=(28, 28)),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dropout(args.dropout),
      tf.keras.layers.Dense(10, activation='softmax')
    ])

    model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=args.learning_rate),
                  loss='sparse_categorical_crossentropy',
                  metrics=['acc'])

    print("Training...")

    katib_metric_log_callback = KatibMetricLog()
    training_history = model.fit(x_train, y_train, batch_size=64, epochs=10,
                                 validation_data=(x_val, y_val),
                                 callbacks=[katib_metric_log_callback])

    print("\\ntraining_history:", training_history.history)

    # Evaluate the model on the test data using `evaluate`
    print('\\n# Evaluate on test data')
    results = model.evaluate(x_test, y_test, batch_size=128)
    print('test loss, test acc:', results)


class KatibMetricLog(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        # RFC 3339
        local_time = datetime.now(timezone.utc).astimezone().isoformat()
        print("\\nEpoch {}".format(epoch+1))
        print("{} accuracy={:.4f}".format(local_time, logs['acc']))
        print("{} loss={:.4f}".format(local_time, logs['loss']))
        print("{} Validation-accuracy={:.4f}".format(local_time, logs['val_acc']))
        print("{} Validation-loss={:.4f}".format(local_time, logs['val_loss']))


if __name__ == '__main__':
    train()

모델 컨테이너 이미지 만들기

모델 학습용 컨테이너 이미지를 만들기 위해서 Dockerfile을 생성하겠습니다.

다음은 텐서플로우 2.1을 기반 이미지로 해서, 모델 파일을 추가하는 Dockerfile 입니다.

Dockerfile

FROM tensorflow/tensorflow:2.1.0-py3

RUN mkdir -p /app
ADD katib-mnist-random-job.py /app/

ENTRYPOINT ["python", "/app/katib-mnist-random-job.py"]

다음 명령어로 “kangwoo/katib-mnist-job:0.0.1” 라는 이름으로 컨테이너 이미지를 빌드할 수 있습니다.

docker build -t kangwoo/katib-mnist-job:0.0.1 .

빌드한 컨테이너 이미지를 컨테이너 이미지 레지스트리에 푸시합니다.

docker push kangwoo/katib-mnist-job:0.0.1

Experiment 생성하기

Katib를 사용하여 하이퍼 파라미터를 자동으로 튜닝하려면 Experiment라는 사용자 리소스를 정의해야합니다. Experiment에는 다음과 같은 내용이 포함되어 있습니다.

  • Objective: 최적화하려는 측정 항목.
  • Search algorithm: 최적의 하이퍼 파라미터를 찾는 데 사용하는는 알고리즘.
  • Configuration about parallelism: 병렬 처리에 대한 구성.
  • Search space: 탐색해야 하는 모든 하이퍼 파라미터의 이름 및 분포 (개별 값 또는 연속 값).
  • Trial Template: Trial을 정의하는 데 사용되는 템플릿.
  • Metrics Collection: 메트릭 수집 방법에 대한 정의

병렬 처리에 대한 구성 : 병렬 처리에 대한 설정할 수 있습니다.

  • parallelTrialCount : 병렬로 처리 할 수 있는 Trial 개수입니다.
  • maxTrialCount : Trial이 실행되는 최대 개수입니다.
  • maxFailedTrialCount : 최대 Trial 실패 개수를 넘으면 experiment은 실패하게 됩니다.
  parallelTrialCount: 1
  maxTrialCount: 12
  maxFailedTrialCount: 3

목표 : 최적화하려는 측정 항목을 설정할 수 있습니다.

“Validation-accuracy” 라는 이름의 메트릭의 최대값이 0.99에 도달하는 것을 목표로 합니다. 그리고 추가로 “accuracy” 라는 이름의 메트릭도 같이 수집합니다.

type은 maximize 나 minimize 를 사용할 수 있습니다.

  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: Validation-accuracy
    additionalMetricNames:
      - accuracy

검색 알고리즘 : 최적의 하이퍼 파라미터를 찾는 데 사용할 알고리즘을 설정할 수 있습니다.

하이퍼 파라미터 튜닝 알고리즘은 “random”을 사용합니다. 알고리즘 이름은 grid, random, hyperband, bayesianoptimization 을 사용할 수 있습니다.

  algorithm:
    algorithmName: random

탐색 공간 : 탐색해야하는 모든 하이퍼 파라미터의 이름과 범위(개별 값 또는 연속 값)에 대해 설정할 수 있습니다.

모델 학습에서 사용할 하이퍼 파라미터 목록입니다. learning_rate와, dropout을 파라미터로 정의합니다.

parameterType은 int, double, categorical 을 사용할 수 있습니다. 파라미터 값은 feasibleSpace, list를 사용할 수 있습니다.

  parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
    - name: --dropout
      parameterType: double
      feasibleSpace:
        min: "0.1"
        max: "0.5"

Trial Template: Trial에서 생성할 Worker Job을 정의할 수 있습니다.

쿠버네티스의 Job을 생성해서 모델 학습 작업을 합니다.

  trialTemplate:
    goTemplate:
        rawTemplate: |-
          apiVersion: batch/v1
          kind: Job
          metadata:
            name: {{.Trial}}
            namespace: {{.NameSpace}}
          spec:
            template:
              spec:
                containers:
                - name: {{.Trial}}
                  image: kangwoo/katib-mnist-job:0.0.1
                  command:
                  - "python3"
                  - "/app/katib-mnist-random-job.py"
                  {{- with .HyperParameters}}
                  {{- range .}}
                  - "{{.Name}}={{.Value}}"
                  {{- end}}
                  {{- end}}
                restartPolicy: Never
  1. 메트릭 수집 방법에 대해서 정의합니다. 별도로 정의하지 않을 경우 StdOut 메트릭 수집기가 사용됩니다. metricsCollectorSpec: collector: kind: StdOut

다음은 admin에라는 네임스페이스에 생성할 Experiment 매니페스트입니다.

random-job-example.yaml

apiVersion: "kubeflow.org/v1alpha3"
kind: Experiment
metadata:
  namespace: admin
  name: random-job-example
spec:
  parallelTrialCount: 1
  maxTrialCount: 12
  maxFailedTrialCount: 3
  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: Validation-accuracy
    additionalMetricNames:
      - accuracy
  algorithm:
    algorithmName: random
  parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
    - name: --dropout
      parameterType: double
      feasibleSpace:
        min: "0.1"
        max: "0.5"
  trialTemplate:
    goTemplate:
        rawTemplate: |-
          apiVersion: batch/v1
          kind: Job
          metadata:
            name: {{.Trial}}
            namespace: {{.NameSpace}}
          spec:
            template:
              spec:
                containers:
                - name: {{.Trial}}
                  image: kangwoo/katib-mnist-job:0.0.1
                  command:
                  - "python3"
                  - "/app/katib-mnist-random-job.py"
                  {{- with .HyperParameters}}
                  {{- range .}}
                  - "{{.Name}}={{.Value}}"
                  {{- end}}
                  {{- end}}
                restartPolicy: Never

Experiment 은 katib UI 화면이나, kubectl을 사용해서 생성할 수 있습니다.

Katib UI 화면에서 Experiment 생성하기

Kubeflow 대시보드의 왼쪽 메뉴에서 Katib를 클릭합니다.

“Hyperparameter Tuning”을 클릭합니다.

YAML File 탭에서 작성한 Experiment 매니페스트를 입력하고, 맨 아래에 있는 DEPLOY 버튼을 클릭하면 Experiment가 생성됩니다.

kubectl을 사용해서 Experiment 생성하기

kubectl을 사용해서 Experiment를 생성할 수 있습니다.

Experiment 매니페스트를 random-job-example.yaml 파일로 저정한 후, 다음 명령어를 사용하면, Experiment 를 생성할 수 있습니다.

kubectl apply -f random-job-example.yaml

Experiment 결과 보기

Katib UI 화면에서 Experiment 결과 보기

Katib UI 화면의 좌측 상단에 있는 메뉴를 선택한 후, HP > Monitor 를 선택하면, Experiment Monitor 화면으로 이동할 수 있습니다.

다음은 Experiment Monitor 화면입니다. 생성한 Experiment 목록을 확인할 수 있습니다.

Experiment 이름을 클릭하면 Trial의 측정 결과가 표시됩니다.

Trial 이름을 클릭하면 측정 항목에 대한 세부 정보가 표시됩니다.

kubectl을 사용해서 Experiment 결과 보기

kubectl 사용해서 결과를 조회 할 수 있습니다.

다음 명령을 사용하면, Trial 측정 결과를 조회 할 수 있습니다. (JSON을 구문 분석 때문에, jq를 설치해야 합니다)

kubectl -n admin get trials -l experiment=random-job-example -o json | jq ".items[] | {assignments: .spec.parameterAssignments, observation: .status.observation}"

{
  "assignments": [
    {
      "name": "--learning_rate",
      "value": "0.08177734351368438"
    },
    {
      "name": "--dropout",
      "value": "0.4439382425122721"
    }
  ],
  "observation": {
    "metrics": [
      {
        "name": "Validation-accuracy",
        "value": 0.9712
      }
    ]
  }
}
{
  "assignments": [
    {
      "name": "--learning_rate",
      "value": "0.13167199355992532"
    },
    {
      "name": "--dropout",
      "value": "0.36691549333903695"
    }
  ],
  "observation": {
    "metrics": [
      {
        "name": "Validation-accuracy",
        "value": 0.9752
      }
    ]
  }
}
...

grid 알고리즘을 이용한 하이퍼 파라미터 튜닝

grid 알고리즘을 사용하여 하이퍼 파리미터 튜닝을 해 보겠습니다. 모델 컨테이너 이미지는 radnom 하이퍼 파라미터 튜닝에서 사용한 kangwoo/mnist:katib 을 그대로 사용하겠습니다.

grid 알고리즘을 사용하려면 algorithmName 필드에 grid 라고 설정하면 됩니다.

algorithm:
    algorithmName: grid

주의해할 점은 categorical 타입의 파라미터는 지원하지 않습니다. 그래서 다음과 같은 파라미터는 사용할 수 없습니다

parameters:
    # Grid doesn't support categorical, refer to <https://chocolate.readthedocs.io/api/sample.html#chocolate.Grid>
    - name: --optimizer
      parameterType: categorical
      feasibleSpace:
        list:
        - sgd
        - adam
        - ftrl

그리고 double 타입의 파라미터를 사용할 때는 step을 정의해줘야 합니다. 값을 얼마만큼의 간격으로 증가시킬지를 지정하는 것입니다. int 타입의 파라미터인 경우에도 setup 값을 정의할 수 있습니다. int 타입인 경우 별도로 정의하지 않으면 기본값인 1일 사용합니다.

parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
        step: "0.01"

Experiment 생성하기

Experiment라는 사용자 리소스를 정의합니다. metricsCollectorSpec 필드에 filter가 추가되어 있습니다.

grid-stdout-example.yaml

apiVersion: "kubeflow.org/v1alpha3"
kind: Experiment
metadata:
  namespace: admin
  name: grid-stdout-example
spec:
  parallelTrialCount: 1
  maxTrialCount: 12
  maxFailedTrialCount: 3
  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: Validation-accuracy
    additionalMetricNames:
      - accuracy
  algorithm:
    algorithmName: grid
  parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
        step: "0.01"
    - name: --dropout
      parameterType: double
      feasibleSpace:
        min: "0.1"
        max: "0.5"
        step: "0.05"
  trialTemplate:
    goTemplate:
        rawTemplate: |-
          apiVersion: batch/v1
          kind: Job
          metadata:
            name: {{.Trial}}
            namespace: {{.NameSpace}}
          spec:
            template:
              spec:
                containers:
                - name: {{.Trial}}
                  image: kangwoo/mnist:katib
                  command:
                  - "python3"
                  - "/app/mnist.py"
                  {{- with .HyperParameters}}
                  {{- range .}}
                  - "{{.Name}}={{.Value}}"
                  {{- end}}
                  {{- end}}
                restartPolicy: Never

정의한 Experiment 사용자 리소스를 쿠버네티스 클러스터에 생성합니다.

kubectl apply -f grid-stdout-example.yaml

Experiment 결과 보기

Katib UI를 통해서 다음과 같은 결과를 확인할 수 있습니다.


bayesianoptimization 알고리즘을 이용한 하이퍼 파라미터 튜닝

bayesianoptimization 알고리즘을 사용하여 하이퍼 파리미터 튜닝을 해 보겠습니다. 모델 컨테이너 이미지는 radnom 하이퍼 파라미터 튜닝에서 사용한 kangwoo/mnist:katib 을 그대로 사용하겠습니다.

bayesianoptimization 알고리즘을 사용하려면 algorithmName 필드에 bayesianoptimization 라고 설정하면 됩니다. 그리고 algorithmSettings 필드를 사용해서 알고리즘을 설정할 수 있습니다.

algorithm:
    algorithmName: bayesianoptimization
    algorithmSettings:
      - name: "random_state"
        value: "10"

Experiment 생성하기

Experiment라는 사용자 리소스를 정의합니다. metricsCollectorSpec 필드에 filter가 추가되어 있습니다.

bayesianoptimization-stdout-example.yaml

apiVersion: "kubeflow.org/v1alpha3"
kind: Experiment
metadata:
  namespace: admin
  name: bayesianoptimization-stdout-example
spec:
  parallelTrialCount: 1
  maxTrialCount: 12
  maxFailedTrialCount: 3
  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: Validation-accuracy
    additionalMetricNames:
      - accuracy
  algorithm:
    algorithmName: bayesianoptimization
    algorithmSettings:
      - name: "random_state"
        value: "10"
  parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
    - name: --dropout
      parameterType: double
      feasibleSpace:
        min: "0.1"
        max: "0.5"
  trialTemplate:
    goTemplate:
        rawTemplate: |-
          apiVersion: batch/v1
          kind: Job
          metadata:
            name: {{.Trial}}
            namespace: {{.NameSpace}}
          spec:
            template:
              spec:
                containers:
                - name: {{.Trial}}
                  image: kangwoo/mnist:katib
                  command:
                  - "python3"
                  - "/app/mnist.py"
                  {{- with .HyperParameters}}
                  {{- range .}}
                  - "{{.Name}}={{.Value}}"
                  {{- end}}
                  {{- end}}
                restartPolicy: Never

정의한 Experiment 사용자 리소스를 쿠버네티스 클러스터에 생성합니다.

kubectl apply -f bayesianoptimization-stdout-example.yaml

Experiment 결과 보기

Katib UI를 통해서 다음과 같은 결과를 확인할 수 있습니다.


hyperband 알고리즘을 이용한 하이퍼 파라미터 튜닝

hyperband 알고리즘을 사용하여 하이퍼 파리미터 튜닝을 해 보겠습니다. 모델 컨테이너 이미지는 radnom 하이퍼 파라미터 튜닝에서 사용한 kangwoo/mnist:katib 을 그대로 사용하겠습니다.

r_l and resource_name must be set.

r_l must be a positive float number.

if "eta" in setting_dict:
            eta = int(float(setting_dict["eta"]))
            if eta <= 0:
                eta = 3
        else:
            eta = 3


smax = int(math.log(rl)/math.log(eta))
        max_parallel = int(math.ceil(eta**smax))
        if request.experiment.spec.parallel_trial_count < max_parallel:
            return self._set_validate_context_error(context,
                                                    "parallelTrialCount must be not less than %d." % max_parallel)

parallel_trial_count 는 eta**log(rl)/log(eta) 값보다 커야 합니다.

hyperband 알고리즘을 사용하려면 algorithmName 필드에 hyperband 라고 설정하면 됩니다. 그리고 algorithmSettings 필드를 사용해서 알고리즘을 설정할 수 있습니다.

algorithm:
    algorithmName: hyperband
    algorithmSettings:
      - name: "resource_name"
        value: "--num-epochs"
      - name: "eta"
        value: "3"
      - name: "r_l"
        value: "9"

Experiment 생성하기

Experiment라는 사용자 리소스를 정의합니다. metricsCollectorSpec 필드에 filter가 추가되어 있습니다.

hyperband-stdout-example.yaml

apiVersion: "kubeflow.org/v1alpha3"
kind: Experiment
metadata:
  namespace: admin
  name: hyperband-stdout-example
spec:
  parallelTrialCount: 9
  maxTrialCount: 9
  maxFailedTrialCount: 9
  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: Validation-accuracy
    additionalMetricNames:
      - accuracy
  algorithm:
    algorithmName: hyperband
    algorithmSettings:
      - name: "resource_name"
        value: "--epochs"
      - name: "eta"
        value: "3"
      - name: "r_l"
        value: "9"
  parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
    - name: --dropout
      parameterType: double
      feasibleSpace:
        min: "0.1"
        max: "0.5"
    - name: --epochs
      parameterType: int
      feasibleSpace:
        min: "10"
        max: "10"
  trialTemplate:
    goTemplate:
        rawTemplate: |-
          apiVersion: batch/v1
          kind: Job
          metadata:
            name: {{.Trial}}
            namespace: {{.NameSpace}}
          spec:
            template:
              spec:
                containers:
                - name: {{.Trial}}
                  image: kangwoo/mnist:katib
                  command:
                  - "python3"
                  - "/app/mnist.py"
                  {{- with .HyperParameters}}
                  {{- range .}}
                  - "{{.Name}}={{.Value}}"
                  {{- end}}
                  {{- end}}
                restartPolicy: Never

정의한 Experiment 사용자 리소스를 쿠버네티스 클러스터에 생성합니다.

kubectl apply -f hyperband-stdout-example.yaml

Experiment 결과 보기

Katib UI를 통해서 다음과 같은 결과를 확인할 수 있습니다.


tpe 알고리즘을 이용한 하이퍼 파라미터 튜닝

tpe 알고리즘을 사용하여 하이퍼 파리미터 튜닝을 해 보겠습니다. 모델 컨테이너 이미지는 radnom 하이퍼 파라미터 튜닝에서 사용한 kangwoo/mnist:katib 을 그대로 사용하겠습니다.

tpe 알고리즘을 사용하려면 algorithmName 필드에 tpe 라고 설정하면 됩니다.

algorithm:
    algorithmName: tpe

Experiment 생성하기

Experiment라는 사용자 리소스를 정의합니다. metricsCollectorSpec 필드에 filter가 추가되어 있습니다.

tpe-stdout-example.yaml

apiVersion: "kubeflow.org/v1alpha3"
kind: Experiment
metadata:
  namespace: admin
  name: tpe-stdout-example
spec:
  parallelTrialCount: 1
  maxTrialCount: 12
  maxFailedTrialCount: 3
  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: Validation-accuracy
    additionalMetricNames:
      - accuracy
  algorithm:
    algorithmName: tpe
  parameters:
    - name: --learning_rate
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.2"
    - name: --dropout
      parameterType: double
      feasibleSpace:
        min: "0.1"
        max: "0.5"
  trialTemplate:
    goTemplate:
        rawTemplate: |-
          apiVersion: batch/v1
          kind: Job
          metadata:
            name: {{.Trial}}
            namespace: {{.NameSpace}}
          spec:
            template:
              spec:
                containers:
                - name: {{.Trial}}
                  image: kangwoo/mnist:katib
                  command:
                  - "python3"
                  - "/app/mnist.py"
                  {{- with .HyperParameters}}
                  {{- range .}}
                  - "{{.Name}}={{.Value}}"
                  {{- end}}
                  {{- end}}
                restartPolicy: Never

정의한 Experiment 사용자 리소스를 쿠버네티스 클러스터에 생성합니다.

kubectl apply -f tpe-stdout-example.yaml

Experiment 결과 보기

Katib UI를 통해서 다음과 같은 결과를 확인할 수 있습니다.

이전 : Kubeflow – Katib 소개

다음 : Kubeflow – Katib : Metrics Collector

“Kubeflow – Katib 하이퍼 파라미터 튜닝”에 대한 한개의 댓글

댓글 남기기

이메일은 공개되지 않습니다. 필수 입력창은 * 로 표시되어 있습니다