Kubeflow – Fairing

Kubeflow Fairing 살펴보기

Kubeflow Fairing은 머신러닝 모델을 쉽게 학습하고, 배포할 수 있도록 도와주는 파이썬(Python) 패키지입니다. fairing을 사용하면, 파이썬 코드나 주피터 노트북에서 원격으로 Kubeflow 클러스터에 학습(training) 작업을 실행시킬 수 있습니다. 그리고 학습 완료된 모델을 배포할 수 있도록 도와줍니다.

다음은 kubeflow 사이트에 올라와 있는,  Kubeflow Fairing project가 추구하는 목표입니다.

  • Easily package ML training jobs: ML 실무자가 ML 모델 학습 코드와 코드의 종속성을 도커 이미지로 쉽게 패키징 할 수 있습니다.
  • Easily train ML models in a hybrid cloud environment: 기본 인프라를 이해할 필요없이 클라우드에서 교육 작업을 쉽게 실행할 수 있도록 ML 모델 교육을 위한 고급 API 제공합니다.
  • Streamline the process of deploying a trained model: ML 실무자가 학습된 ML 모델을 하이브리드 클라우드 환경에 쉽게 배포 할 수 있도록 합니다.

Fairing은 파이썬 파일이나, 주피터 노트북 등을 컨테이너 이미지로 만든 다음, 해당 이미지를 kubeflow 클러스터에 배포해서 모델 학습 작업을 실행할 수 있도록 도와줍니다. 그리고 학습 완료된 모델은 쉽게 서빙할 수 있는 기능독 제공하고 있습니다.

Kubeflow Fairing 개념

Kubeflow Fairing 에는 세 가지의 중요한 개념이 있습니다. 바로 preprocessor, builder와 deployer 입니다.

Preprocessor (전처리기)

전처리기는 Kubeflow Fairing이 학습 작업을 위한 컨테이너 이미지를 만들 때, 이미지 생성에 필요한 일련의 정보들을 정의하는 역할을 합니다. 전처리기를 사용하면 컨테이너 이미지에 들어갈 입력 파일을 선택할 수 있고, 변환할 수 있으며, 불필요한 파일을 제외 시킬 수도 있습니다. 그리고 컨테이너 이미지의 엔트리포인터(entrypoint) 같은 설정 정보도 변경할 수 있습니다.

Kubeflow Fairing 에는 제공하는 전처리기는 다음과 같습니다.

  • python : 입력 파일을 컨테이너 이미지에 직접 복사합니다.
  • notebook : 노트북을 실행 가능한 파이썬 파일로 변환합니다. 그리고 노트북 코드에서 파이썬 코드가 아닌 부분을 제거합니다.
  • full_notebook : 파이썬 코드가 아닌 부분들을 포함해서 전체 노트북을 그대로 실행합니다. 별다른 설정이 없다면, 노트북 실행에 papermill을 사용합니다.
  • function : FunctionPreProcessor는 단일 함수를 전처리합니다. function_shim.py을 사용하여 함수를 직접 호출합니다.

Builder (빌더)

빌더는 Kubeflow Fairing이 학습 작업에 사용할 컨테이너 이미지를 빌드하는 방법 및 컨테이너 이미지를 저장할 컨테이너 레지스트리의 위치를 ​​정의하는 역할을 합니다.

Kubeflow Fairing 에는 제공하는 빌더는 다음과 같습니다.

  • append : 기존 컨테이너 이미지를 바탕으로, 코드를 새 레이어로 추가합니다. 이 빌더는 기본 이미지를 가져 와서 이미지를 작성하지 않고, 추가된 부분만 컨테이너 이미지 레지스트리에 푸시합니다. 그래서 학습 작업을 위한 컨테이너 이미지를 작성하는 데 시간이 상대적으로 적게 소모됩니다. 그리고 파이썬 라이브러인 containerregistry을 사용하기 때문에, 도커 데몬이 필요 없습니다.
  • docker : 로컬 도커 데몬을 사용하여, 학습 작업에 사용할 컨테이너 이미지를 빌드하고, 컨테이너 이미지 레지스트리에 푸시합니다
  • cluster : 쿠버네티스 클러스터에서 학습 작업에 사용할 컨테이너 이미지를 빌드하고, 컨테이너 이미지 레지스트리에 푸시합니다

Deployer (배포자)

배포자는 Kubeflow Fairing이 학습 작업에 사용할 컨테이너 이미지를 배포하고 실행할 위치를 정의하는 역할을 합니다. 배포자는 빌더가 생성한 이미지를 사용하여 Kubeflow 클러스터에 학습 작업을 배포하고 실행합니다

Kubeflow Fairing 에는 제공하는 배포자는 다음과 같습니다.

  • Job : 쿠버네티스 Job 리소스를 사용하여 학습 작업을 시작합니다.
  • TfJob : Kubeflow의 TFJob 컴포넌트를 사용하여 텐서플로우 학습 작업을 시작합니다.
  • PyTorchJob : Kubeflow의 PyTorchJob 컴포넌트를 사용하여 PyTorch 학습 작업을 시작합니다.
  • GCPJob : GCP에게 학습 작업 보냅니다.
  • Serving : 쿠버네티스의 디플로이먼트(deployment)와 서비스(service)를 사용하여, 예측(prediction) 엔드포인트를 서빙합니다.
  • KFServing : KFServing을 사용하여, 예측(prediction) 엔드포인트를 서빙합니다.

Kubeflow Fairing 사용하기

Kubeflow Fairing을 사용하여, ML 모델을 학습하고 배포하는 방법에 대해서 알아보도록 하겠습니다. Kubeflow Fairing은 파이썬 패키지이므로 로컬 개발 환경 및 주피터 노트북 어디서나 사용할 수 있습니다.

로컬 개발 환경에 Kubeflow Fairing 설치하기

다음은 로컬 개발 환경에서 Kubeflow Fairing 을 설치하는 방법에 대해 알아보도록 하겠습니다.

파이썬 설치하기

Kubeflow Fairing을 사용하려면 Python 3.6 이상이 필요합니다. 다음 명령을 실행해서, Python 3.6 이상이 설치되어 있는지 확인해 보겠습니다.

python3 -V

파이썬이 설치되어 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

Python 3.6.9

Python 3.6 이상이 없는 경우 Python Software Foundation에서 Python을 다운로드 할 수 있습니다.

가상 환경 만들기

가상 환경을 만들어서 Kubeflow Fairing을 설치를 진행할 것입니다. 가상 환경을 만들기 위해서 virtualenv가 설치되어 있어야합니다. 다음 명령을 실행해서, virtualenv가 설치되어 있는지 확인해 보겠습니다.

which virtualenv

virtualenv가 설치되어 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

/usr/local/bin/virtualenv

virtualenv가 설치되어 있지 않다면, pip3 를 이용해서 virtualenv를 설치합니다.

pip3 install virtualenv

가상 환경을 새로 만들겠습니다.

virtualenv venv --python=python3 

그리고, 새로 만든 가상 환경을 활성화 하겠습니다.

source venv/bin/activate

Kubeflow Fairing 설치하기

활성화한 가상 환경에, Kubeflow Fairing을 설치하겠습니다.

pip install kubeflow-fairing

설치가 완료되면 Fairing 파이썬 패키지를 사용할 수 있습니다. 다음 명령을 실행해서, Kubeflow Fairing이 설치되어 있는지 확인해 보겠습니다.

pip show kubeflow-fairing

Kubeflow Fairing이 설치되어 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

Name: kubeflow-fairing
Version: 0.7.1
Summary: Kubeflow Fairing Python SDK.
Home-page: <https://github.com/kubeflow/fairing>
Author: Kubeflow Authors
Author-email: hejinchi@cn.ibm.com
License: Apache License Version 2.0
Location: /Users/kangwoo/Documents/kubeflow/fairing/venv/lib/python3.7/site-packages
Requires: python-dateutil, six, google-api-python-client, google-cloud-storage, notebook, kubernetes, kfserving, boto3, httplib2, requests, google-auth, numpy, azure, docker, future, kubeflow-tfjob, kubeflow-pytorchjob, setuptools, urllib3, cloudpickle, retrying, tornado, google-cloud-logging, oauth2client
Required-by:

Docker 설치

Kubeflow Fairing의 docker 빌더를 사용하기 위해서는 도커가 필요합니다. 다른 빌더를 사용하시리면, 설치하지 않으셔도 됩니다.

다음 명령을 실행해서, Docker가 설치되어 있는지 확인해 보겠습니다.

docker version

docker가 설치되어 있지 않다면, docker를 설치합니다.

로컬 개발 환경에 Kubeflow Fairing 설정하기

로컬 개발 환경에서 Kubeflow Fairing을 사용하여 Kubeflow 클러스터에서 머신러닝 모델을 학습하거나 배포하려면, 컨테이너 이미지 레지스트리와 Kubeflow 클러스터에 접근 할 수 있는 환경을 구성해야합니다.

로컬 개발 환경에서 컨테이너 이미지 레지스트리에 접근할 수 있도록 Docker 설정하기

로컬 개발 환경에 있는 Kubeflow Fairing에서 생성한 컨테이너 이미지를 컨테이너 이미지 레지스트리에 푸시 하려면 접근 권한이 필요합니다.

컨테이너 이미지 레지스트리를 기본 저장소인 도커허브(Docker Hub)를 사용하고 있다면, docker login 명령어를 실행해서 도커가 컨테이너 이미지 레지스트리에 액세스 할 수 있도록 권한을 부여할 수 있습니다. 물론 로그인 하기 전에 도커허브 계정을 가지고 있어야 합니다.

docker login
Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to <https://hub.docker.com> to create one.
Username: kangwoo
Password: 
Login Succeeded

만약 다른 개인 레지스트리를 사용하고 있다면, 로그인을 할 때 레지스트리 주소를 입력하시면 됩니다.

다음은 docker-registry.foo.bar 라고 하는 개인 레지스트리에 로그인 하는 명령어입니다.

docker login [docker-registry.foo.bar](<http://docker-registry.foo.bar>)

로그인이 성공적으로 되면, ~/.docker/config.json 에 파일이 생성된 것을 확인할 수 있습니다.

Kubeflow 클러스터에서 컨테이너 이미지 레지스트리에 접근할 수 있도록 쿠버네티스 설정하기

Kubeflow가 설치된 쿠버네티스에서 Kubeflow Fairing에서 생성한 컨테이너 이미지를 내려 받아야합니다. 도커허브의 공개 저장소 같은 경우에는 이미지를 내려 받는데에 별도의 권한이 필요없습니다. 하지만 개인 레지스트리를 사용하는 경우라면, 접근 권한이 필요합니다.

만약 config.json 파일이 아래와 같은 형식이라면, 이 파일을 그대로 사용할 수 있습니다.

{
  "auths": {
      "<https://index.docker.io/v1/>": {
          "auth": "XXXXX"
      }
  }
}

하지만 아래처럼 인증 정보를 별도로 저장하는 형식이라면, config.json 파일을 직접 만들어야 합니다.

{
	"auths": {
		"<https://index.docker.io/v1/>": {}
	},
	"HttpHeaders": {
		"User-Agent": "Docker-Client/19.03.5 (darwin)"
	},
	"credsStore": "desktop",
	"experimental": "disabled",
	"stackOrchestrator": "swarm"
}

직접 config.json 파일을 만들기

직접 config.json 파일을 만들려면 auth 필드에 base64 인코딩된 username:password 문자열 값을 설정하면 됩니다.

다음 명령어를 사용해서 auth 값을 생성할 수 있습니다.

echo -n 'username:password' | base64

만약 도커 허브가 아니라 별도의 컨테이너 이미지 레지스트리를 사용한다면 “https://index.docker.io/v1/” 값 대신에 해당 레지스트리 주소를 설정하면 됩니다.

다음은 도커 허브를 사용하고, 사용자명이 username, 비밀번호가 password 인 config.json 예제 파일입니다.

{
  "auths": {
      "<https://index.docker.io/v1/>": {
          "auth": "dXNlcm5hbWU6cGFzc3dvcmQ="
      }
  }
}

컨테이너 레지스트리 접속을 위한 secret 리소스 만들기

쿠버네티스 클러스터는 개인 컨테이너 레지스트리로 접근하기 위해서, 도커-레지스트리의 인증 형식을 사용합니다.

docker login을 실행 또는 직접 $HOME/.docker/config.json 파일을 생성했다면, 해당 자격 증명을 Kubernetes에 복사 할 수 있습니다

다음은 admin이라는 네임스페이스에 ~/.docker/config.json 의 파일을 사용해서 regcred 이름의 secret 리소스를 생성하는 명령어입니다.

kubectl -n admin create secret generic regcred \\
    --from-file=.dockerconfigjson=~/.docker/config.json \\
    --type=kubernetes.io/dockerconfigjson

생성한 secret을 이미지를 내려 받을 때 사용하도록 네임스페이스의 서비스 계정을 수정하겠습니다.

쿠버네티스 네임스페이스 있는 default 서비스 계정과, Kubeflow에서 생성한 default-editor, default-viewer 계정을 모두 수정하겠습니다.

다음은 admin이라는 네임스페이스에 있는 default, default-editor, default-viewer 계정에, 컨테이너 이미지를 내려 받을 때 regcred 이름의 secret 리소스를 사용하라고 수정하는 명령어입니다.

kubectl -n admin patch serviceaccount default -p '{"imagePullSecrets": [{"name": "regcred"}]}'
kubectl -n admin patch serviceaccount default-editor -p '{"imagePullSecrets": [{"name": "regcred"}]}'
kubectl -n admin patch serviceaccount default-viewer -p '{"imagePullSecrets": [{"name": "regcred"}]}'

로컬 환경에서 Kubeflow 클러스터에 접근할 있도록 kubeconfig 설정하기

로컬 개발 환경에 있는 Kubeflow Fairing에서 Kubeflow가 설치된 쿠버네티스 클러스터에 작업을 배포하려면, 클러스터 접근 권한이 필요합니다. 설정이 되어 있지 않다면, 쿠버네티스 클러스의 ~/.kube/config 파일을 로컬 환경의 ~/.kube/config로 복사하면 됩니다.

원칙적으로는 필요한 권한만 부여된 계정을 만들어서 사용해야하지만, 편의를 위해서 cluster-admin 권한이 있는 인증 파일을 그대로 사용한 것입니다.

로컬 개발 환경에 Kubeflow Fairing 사용하기

로컬 개발 환경서 Kubeflow Fairing을 사용해보도록 하겠습니다. mnist 숫자를 분류하는 간단한 모델을 컨테이너 이미지로 빌드하고, Kubeflow 클러스터에 job 형태로 배포해서 학습하는 것을 하도록 하겠습니다.

“docker” 빌더를 사용해서 모델 학습하기

먼저 학습에 사용할 모델 파일을 만들겠습니다.

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

mnist-simple.py

from __future__ import absolute_import, division, print_function, unicode_literals

import tensorflow as tf
import numpy as np


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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))


if __name__ == '__main__':
    train()

컨테이너 이미지를 만들기 위한 Dockerfile을 생성하겠습니다.

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

Dockerfile

FROM tensorflow/tensorflow:2.1.0-py3

RUN mkdir -p /app
ADD mnist-simple.py /app/

컨테이너 이미지를 빌드하고, 배포하기 위한 fairing 코드 파일을 생성하겠습니다.

fairing-local-docker.py

import uuid
from kubeflow import fairing

CONTAINER_REGISTRY = 'kangwoo'

namespace = 'admin'
job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'

command=["python", "mnist-simple.py"]
output_map = {
    "Dockerfile": "Dockerfile",
    "mnist-simple.py": "mnist-simple.py"
}

fairing.config.set_preprocessor('python', command=command, path_prefix="/app", output_map=output_map)

fairing.config.set_builder('docker', registry=CONTAINER_REGISTRY, image_name="mnist-job", dockerfile_path="Dockerfile")

fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=False)

fairing.config.run()

“CONTAINER_REGISTRY”에는 사용할 컨테이너 이미지 레지스트리를 입력하시면 됩니다. 예제에서는 도커허브를 사용하기 때문에 계정명인 kangwoo 를 사용하였습니다.

“namespace” 에는 모델 작업을 배포한 쿠버네티스 네임스페이스를 입력하시면 됩니다. 예제에서는 admin 이라는 네임스페이스를 사용하였습니다.

다음은 전처리기입니다.

fairing.config.set_preprocessor('python', command=command, path_prefix="/app", output_map=output_map)

파이썬 파일을 사용하기 때문에, python 전처리기를 사용하였습니다. 그리고 컨테이너 이미지를 빌드하기 위한 파일들을 빌더로 넘겨주기 위해서 output_map을 설정하였습니다. Dockerfile과 mnist-simple.py 파일이 빌더에서 사용됩니다. 학습 작업을 실행하기 위한 명령어를 command로 설정하였습니다.

다음은 빌더입니다.

fairing.config.set_builder('docker', registry=CONTAINER_REGISTRY, image_name="mnist-simple", dockerfile_path="Dockerfile")

docker 빌더를 사용하였습니다. 사용할 컨테이너 이미지 레지스트리 주소를 registry 에 설정합니다. 이미지 이름을 image_name에 설정합니다. 그리고 빌드에 사용할 Dockerfile을 dockerfile_path에 설정합니다.

다음은 배포자입니다

fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=False)

job 배포자를 사용하였습니다. 작업이 배포되는 네임스페이스 이름을 namespace에 설정합니다. 그리고 작업 이름을 job_name에 설정합니다.

cleanup 파라메터는 작업을 완료하였을때, 작업에 사용한 포드들을 삭제할 여부를 결정합니다. 기본값을 True 입니다. 예제에서는 포드를 조회하기 위해서 False로 설정하였습니다.

stream_log 파라메터는 쿠버네티스에서 실행되는 작업들의 포드 로그를 fairing을 실행하는 터미널에 출력할지를 결정합니다. 기본값을 True 입니다. 예제에서는 False로 설정하였습니다.

이제 작성한 fairing 코드를 실행해 보겠습니다.

python fairing-local-docker.py

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

[I 200307 10:29:50 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.base.BasePreProcessor object at 0x1082a9b10>
[I 200307 10:29:50 config:127] Using builder: <kubeflow.fairing.builders.docker.docker.DockerBuilder object at 0x10d4223d0>
[I 200307 10:29:50 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x1082a9b50>
[I 200307 10:29:50 docker:32] Building image using docker
[W 200307 10:29:50 docker:41] Docker command: ['python', 'mnist-simple.py']
[I 200307 10:29:50 base:107] Creating docker context: /tmp/fairing_context_zq4eaqjt
[W 200307 10:29:50 docker:56] Building docker image kangwoo/mnist-simple:501087B0...
...
[I 200307 10:30:09 docker:103] Push output: 501087B0: digest: sha256:dd3f7146d3b66ff44d0c7f5670e07fb9fd621b9da136987cb2eb95fe8eb9795c size: 2831 None
[I 200307 10:30:09 docker:103] Push finished: {'Tag': '501087B0', 'Digest': 'sha256:dd3f7146d3b66ff44d0c7f5670e07fb9fd621b9da136987cb2eb95fe8eb9795c', 'Size': 2831}
[W 200307 10:30:09 job:90] The job mnist-job-0a3bd86kp launched.

Job 이름은 “mnist-job-0a3bd86kp” 라는 것을 확인 할 수 있습니다.

다음 명령어를 실행하면 admin 네임스페이스의 Job 목록을 확인할 수 있습니다.

kubectl -n admin get job

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

NAME                  COMPLETIONS   DURATION   AGE
mnist-job-0a3bd86kp   1/1           18s        7m25s

다음 명령어를 실행하면 mnist-job-0a3bd86kp 라는 이름을 가진 Job이 생성한 포드를 확인할 수 있습니다.

kubectl -n admin get pod -l job-name=mnist-job-0a3bd86kp

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

NAME                        READY   STATUS      RESTARTS   AGE
mnist-job-0a3bd86kp-6vst8   0/1     Completed   0          8m39s

학습 작업 삭제하기

작업이 완료되어도 Job은 삭제되지 않습니다.

다음 명령어를 실행하면 admin 네임스페이스의 mnist-job-0a3bd86kp 라는 이름의 Job을 삭제할 수 있습니다.

kubectl -n admin delete job mnist-job-0a3bd86kp

“append” 빌더를 사용해서 모델 학습하기

먼저 학습에 사용할 모델 파일을 만들겠습니다.

“docker” 빌더를 사용해서 모델 학습하기 에서 사용한것과 동일한 코드입니다.

mnist-simple.py

from __future__ import absolute_import, division, print_function, unicode_literals

import tensorflow as tf
import numpy as np


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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))


if __name__ == '__main__':
    train()

컨테이너 이미지를 빌드하고, 배포하기 위한 fairing 코드 파일을 생성하겠습니다.

fairing-local-docker.py

import uuid
from kubeflow import fairing

CONTAINER_REGISTRY = 'kangwoo'

namespace = 'admin'
job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'

fairing.config.set_preprocessor('python', executable="mnist-simple.py")

fairing.config.set_builder('append', registry=CONTAINER_REGISTRY, image_name="mnist-simple",
                           base_image="tensorflow/tensorflow:2.1.0-py3")

fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

fairing.config.run()

가장 큰 변경 사항은 Dockerfile이 없어진 것과, 빌더 부분에 “base_image” 파라메터가 추가 된 것입니다.

다음은 전처리기입니다.

fairing.config.set_preprocessor('python', executable="mnist-simple.py")

파이썬 파일을 사용하기 때문에, python 전처리기를 사용하였습니다. 그리고 실행할 파이썬 파일을 executable에 설정하였습니다. executable에 추가한 파일은 자동으로 input_files에 추가 되고 컨테이너 이미지에 추가됩니다. 그리고 학습 작업을 실행하기 위한 명령어에 자동으로 추가됩니다.

다음은 빌더입니다.

fairing.config.set_builder('append', registry=CONTAINER_REGISTRY, image_name="mnist-simple",
                           base_image="tensorflow/tensorflow:2.1.0-py3")

appender 빌더를 사용하였습니다. docker 빌더와는 다른게 Dockerfile을 정의해 줄 필요가 없습니다. 대신 기본 이미지를 base_image 에서 설정해주어야합니다..

다음은 배포자입니다

fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

배포자는 변경된 부분이 없습니다.

이제 작성한 fairing 코드를 실행해 보겠습니다.

python fairing-local-append.py

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

[I 200307 12:52:04 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.base.BasePreProcessor object at 0x100597950>
[I 200307 12:52:04 config:127] Using builder: <kubeflow.fairing.builders.append.append.AppendBuilder object at 0x100597990>
[I 200307 12:52:04 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x100597ad0>
[W 200307 12:52:04 append:50] Building image using Append builder...
[I 200307 12:52:04 base:107] Creating docker context: /tmp/fairing_context_9qe8ujn6
[I 200307 12:52:04 docker_creds_:234] Loading Docker credentials for repository 'tensorflow/tensorflow:2.1.0-py3'
[I 200307 12:52:05 docker_creds_:152] Invoking 'docker-credential-desktop' to obtain Docker credentials.
[I 200307 12:52:05 docker_creds_:175] Successfully obtained Docker credentials.
[W 200307 12:52:07 append:54] Image successfully built in 2.6276446930000006s.
[W 200307 12:52:07 append:94] Pushing image kangwoo/mnist-simple:645ECCC9...
...
[W 200307 12:52:12 append:99] Pushed image kangwoo/mnist-simple:645ECCC9 in 5.018134577s.
[W 200307 12:52:12 job:90] The job mnist-job-f7f8mlrr5 launched.

Job 이름은 “mnist-job-f7f8mlrr5” 라는 것을 확인 할 수 있습니다.

다음 명령어를 실행하면 admin 네임스페이스의 Job 목록을 확인할 수 있습니다.

kubectl -n admin get job

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

NAME                  COMPLETIONS   DURATION   AGE
mnist-job-f7f8mlrr5   1/1           18s        7m25s

다음 명령어를 실행하면 mnist-job-f7f8mlrr5 라는 이름을 가진 Job이 생성한 포드를 확인할 수 있습니다.

kubectl -n admin get pod -l job-name=mnist-job-f7f8mlrr5

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

NAME                        READY   STATUS      RESTARTS   AGE
mnist-job-f7f8mlrr5-hjkx2   0/1     Completed   0          93s

학습 작업 삭제하기

작업이 완료되어도 Job은 삭제되지 않습니다.

다음 명령어를 실행하면 admin 네임스페이스의 mnist-job-f7f8mlrr5 라는 이름의 Job을 삭제할 수 있습니다.

kubectl -n admin delete job mnist-job-f7f8mlrr5

모델 코드 파일에서 Kubeflow Fairing 사용하기

지금까지 살펴본 예제는 모델 코드 파일과 fairing 코드 파일이 따로 분리 되어 있었습니다. 이번에는 모델 코드 안에서 fairing을 사용하는 방법을 알아보도록 하겠습니다.

다음은 모델 코드와 fairing 코드가 같이 들어있는 코드입니다.

mnist-with-fairing.py

from __future__ import absolute_import, division, print_function, unicode_literals

import os

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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))


def fairing_run():
    CONTAINER_REGISTRY = 'kangwoo'

    namespace = 'admin'
    job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'

		fairing.config.set_preprocessor('python', executable="mnist-simple.py")

    fairing.config.set_builder('append', registry=CONTAINER_REGISTRY, image_name="mnist-simple",
                               base_image="tensorflow/tensorflow:2.1.0-py3")

    fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

    fairing.config.run()


if __name__ == '__main__':
    if os.getenv('FAIRING_RUNTIME', None) is None:
        import uuid
        from kubeflow import fairing
        fairing_run()
    else:
        import tensorflow as tf
        import numpy as np

        train()

다음은 “FAIRING_RUNTIME”으로 분기를 타는 부분입니다.

if __name__ == '__main__':
    if os.getenv('FAIRING_RUNTIME', None) is None:
        import uuid
        from kubeflow import fairing
        fairing_run()
    else:
        import tensorflow as tf
        import numpy as np

        train()

모델 코드와 fairing 코드가 같이 들어 있을 경우에는, 모델 학습을 위해서 코드가 실행된 것인지, fairing을 사용하기 위해서 실행된 것인지를 구별해 줄 필요가 있습니다. 그래서 fairing에서는 FAIRING_RUNTIME 라는 환경 변수를 제공하고 있습니다. fairing에서 실행하는 작업은 컨테이너의 환경 변수에 아래처럼 FAIRING_RUNTIME 환경 변수가 추가 됩니다. 이 값을 가지고 모델 학습을 위해서 코드가 실행된 것인지, fairing을 사용하기 위해서 실행된 것인지를 구별할 수 있습니다.

env:
    - name: FAIRING_RUNTIME
      value: "1"

이제 작성한 fairing 코드를 실행해 보겠습니다.

python mnist-with-fairing.py

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

[I 200307 13:07:20 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.base.BasePreProcessor object at 0x10b7d2c10>
[I 200307 13:07:20 config:127] Using builder: <kubeflow.fairing.builders.append.append.AppendBuilder object at 0x10b815490>
[I 200307 13:07:20 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x10b815a90>
[W 200307 13:07:20 append:50] Building image using Append builder...
[I 200307 13:07:20 base:107] Creating docker context: /tmp/fairing_context_1pz0hi3k
[I 200307 13:07:20 docker_creds_:234] Loading Docker credentials for repository 'tensorflow/tensorflow:2.1.0-py3'
[I 200307 13:07:21 docker_creds_:152] Invoking 'docker-credential-desktop' to obtain Docker credentials.
[I 200307 13:07:21 docker_creds_:175] Successfully obtained Docker credentials.
[W 200307 13:07:23 append:54] Image successfully built in 2.8729543819999996s.
[W 200307 13:07:23 append:94] Pushing image kangwoo/mnist-simple:83A2C3C4...
...
[W 200307 13:07:28 append:99] Pushed image kangwoo/mnist-simple:83A2C3C4 in 5.097283148000001s.
[W 200307 13:07:28 job:90] The job mnist-job-139bf5rrm launched.

Job 이름은 “mnist-job-f7f8mlrr5” 라는 것을 확인 할 수 있습니다.


주피터 노트북에서 Kubeflow Fairing 설치하기

다음은 주피터 노트북 환경에서 Kubeflow Fairing 을 설치하는 방법에 대해 알아보도록 하겠습니다.

Kubeflow 에서 제공하는 기본 주피터 컨테이너 이미지를 사용하는 경우, Kubeflow Fairing 환경이 사전 구성되어 있으므로, 추가 설치를 진행 하지 않아도 됩니다.

하지만 불행히도 Kubeflow 1.0 버전을 릴리즈 할 때 만들어진, 기본 주피터 컨테이너 이미지에는 예전 버전의 Fairing (fairing 0.5)을 사용합니다. 패키지 이름도 kubeflow-fairing이 아니라 fairing 입니다. 그래서 fairing이 설치되어 있다면, kubeflow-fairing을 설치해주시기 바랍니다.

파이썬 버전 확인하기

Kubeflow Fairing을 사용하려면 Python 3.6 이상이 필요합니다. 주피터 노트북에서 Python 3.6 이상이 설치되어 있는지 확인해 보겠습니다.

Jupyter 노트북 사용자 인터페이스의 메뉴에서 File > New > Terminal 을 클릭하여 노트북 환경에서 새 터미널 세션을 시작하십시오.

python3 -V

파이썬이 설치되어 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

Python 3.6.9

Python 3.6 이상이 없는 경우, Python 3.6 이상이 설치된 주피터 이미지 사용하시거나, 별도로 생성하셔야 합니다.

Kubeflow Fairing 설치하기

노트북 터미널 세션에서, Kubeflow Fairing을 설치하겠습니다.

pip install kubeflow-fairing

설치가 완료되면 Fairing 파이썬 패키지를 사용할 수 있습니다. 다음 명령을 실행해서, Kubeflow Fairing이 설치되어 있는지 확인해 보겠습니다.

pip show kubeflow-fairing

Kubeflow Fairing이 설치되어 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

Name: kubeflow-fairing
Version: 0.7.1
Summary: Kubeflow Fairing Python SDK.
Home-page: <https://github.com/kubeflow/fairing>
Author: Kubeflow Authors
Author-email: hejinchi@cn.ibm.com
License: Apache License Version 2.0
Location: /Users/kangwoo/Documents/kubeflow/fairing/venv/lib/python3.7/site-packages
Requires: python-dateutil, six, google-api-python-client, google-cloud-storage, notebook, kubernetes, kfserving, boto3, httplib2, requests, google-auth, numpy, azure, docker, future, kubeflow-tfjob, kubeflow-pytorchjob, setuptools, urllib3, cloudpickle, retrying, tornado, google-cloud-logging, oauth2client
Required-by:

주피터 노트북에서 Kubeflow Fairing 설정하기

Kubeflow 주피터 노트북 환경에서 Kubeflow Fairing을 사용하여 Kubeflow 클러스터에서 머신러닝 모델을 학습하거나 배포하려면, 컨테이너 이미지 레지스트리에 접근 할 수 있는 환경을 구성해야합니다.

Kubeflow 주피터 노트북 환경에서 컨테이너 이미지 레지스트리에 접근할 수 있도록 Docker 설정하기

주피터 노트북 환경에서 Kubeflow Fairing이 생성한 컨테이너 이미지를 컨테이너 이미지 레지스트리에 푸시 하려면 접근 권한이 필요합니다.

생성된 config.json 사용하기

로컬 개발 환경에서 도커 로그인을 한 적이 있으면, 로컬 개발 환경의 ~/.docker/config.json 파일을 조회해 봅니다.

만약 config.json 파일이 아래와 같은 형식이라면, 이 파일을 주피터 노트북의 ~/.docker/config.json 으로 그대로 복사하면 됩니다.

{
  "auths": {
      "<https://index.docker.io/v1/>": {
          "auth": "XXXXX"
      }
  }
}

하지만 아래처럼 인증 정보를 별도로 저장하는 형식이라면, config.json 파일을 직접 만들어야 합니다.

{
	"auths": {
		"<https://index.docker.io/v1/>": {}
	},
	"HttpHeaders": {
		"User-Agent": "Docker-Client/19.03.5 (darwin)"
	},
	"credsStore": "desktop",
	"experimental": "disabled",
	"stackOrchestrator": "swarm"
}

직접 config.json 파일을 만들기

직접 config.json 파일을 만들려면 auth 필드에 base64 인코딩된 username:password 문자열 값을 설정하면 됩니다.

다음 명령어를 사용해서 auth 값을 생성할 수 있습니다.

echo -n 'username:password' | base64

만약 도커 허브가 아니라 별도의 컨테이너 이미지 레지스트리를 사용한다면 “https://index.docker.io/v1/” 값 대신에 해당 레지스트리 주소를 설정하면 됩니다.

다음은 도커 허브를 사용하고, 사용자명이 username, 비밀번호가 password 인 config.json 예제 파일입니다.

{
  "auths": {
      "<https://index.docker.io/v1/>": {
          "auth": "dXNlcm5hbWU6cGFzc3dvcmQ="
      }
  }
}

config.json 파일을 주피터 노트북으로 복사하기

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Terminal 을 클릭하여 노트북 환경에서 새 터미널 세션을 시작하십시오.

bash
mkdir ~/.docker
cd ~/.docker
cat << EOF > config.json
{
  "auths": {
      "<https://index.docker.io/v1/>": {
          "auth": "a2FuZ3dvbzpnZWVuYTEx"
      }
  }
}
EOF

Kubeflow 클러스터에서 컨테이너 이미지 레지스트리에 접근할 수 있도록 쿠버네티스 설정하기

Kubeflow가 설치된 쿠버네티스에서 Kubeflow Fairing에서 생성한 컨테이너 이미지를 내려 받아야합니다. 도커허브의 공개 저장소 같은 경우에는 이미지를 내려 받는데에 별도의 권한이 필요없습니다. 하지만 개인 레지스트리를 사용하는 경우라면, 접근 권한이 필요합니다. 설정이 되어 있지 않다면, “LINK-쿠버네티스 클러스터에서 컨테이너 이미지 레지스트리에 접근할 수 있도록 설정하기”를 참고하기 바랍니다.

주피터 노트북 환경에서 Kubeflow Fairing 사용하기

Kubeflow 주피터 노트북 환경에서 Kubeflow Fairing을 사용해보도록 하겠습니다. mnist 숫자를 분류하는 간단한 모델을 컨테이너 이미지로 빌드하고, Kubeflow 클러스터에 job 형태로 배포해서 학습하는 것을 하도록 하겠습니다.

“notebook” 전처리기를 사용해서 모델 학습하기

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Notebook 을 클릭하여 노트북 환경에서 새 노트북을 시작하십시오.

노트북 컬럼에 모델 코드와 faring 코드를 입력하겠습니다.

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

import os

import tensorflow as tf
import numpy as np

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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))

다음은 fairing 코드 입니다.

def fairing_run():
    CONTAINER_REGISTRY = 'kangwoo'

    namespace = 'admin'
    job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'


    fairing.config.set_builder('append', registry=CONTAINER_REGISTRY, image_name="mnist-simple",
                               base_image="tensorflow/tensorflow:2.1.0-py3")

    fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

    fairing.config.run()

특이하게도 전처리기를 설정하는 set_preprocessor() 구문이 없습니다. 노트북에서는 별도의 전처리기를 설정하지 않으면 “notebook” 전처리기가 사용됩니다. “notebook” 전처리기는 노트북의 파이썬 코드 셀을 파이썬 파일로 변경해 줍니다.

다음은 환경 변수에 따라 모델 훈련을 실행하거나, fairing을 실행하는 부분입니다.

if __name__ == '__main__':
    if os.getenv('FAIRING_RUNTIME', None) is None:
        import uuid
        from kubeflow import fairing
        fairing_run()
    else:
        train()

shift + enter 키를 눌러 셀 들을 실행시키면, 다음과 같은 응답 결과를 얻을 수 있습니다.

[I 200307 06:22:20 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.converted_notebook.ConvertNotebookPreprocessor object at 0x7fc924284fd0>
[I 200307 06:22:20 config:127] Using builder: <kubeflow.fairing.builders.append.append.AppendBuilder object at 0x7fc89c5c2c88>
[I 200307 06:22:20 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x7fc8a9d78898>
[W 200307 06:22:20 append:50] Building image using Append builder...
[I 200307 06:22:20 base:107] Creating docker context: /tmp/fairing_context_n04p7lim
[I 200307 06:22:20 converted_notebook:127] Converting test.ipynb to test.py
[I 200307 06:22:20 docker_creds_:234] Loading Docker credentials for repository 'tensorflow/tensorflow:2.1.0-py3'
[W 200307 06:22:23 append:54] Image successfully built in 2.5187153209990356s.
[W 200307 06:22:23 append:94] Pushing image kangwoo/mnist-simple:5D22B676...
...
[W 200307 06:22:28 append:99] Pushed image kangwoo/mnist-simple:5D22B676 in 5.467247595999652s.
[W 200307 06:22:28 job:90] The job mnist-job-b445qfblz launched.

“function” 전처리기를 사용해서 모델 학습하기

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Notebook 을 클릭하여 노트북 환경에서 새 노트북을 시작하십시오.

노트북 컬럼에 모델 코드와 faring 코드를 입력하겠습니다.

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

import os

import tensorflow as tf
import numpy as np

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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))

다음은 fairing 코드 입니다.

def fairing_fn(fn):
    CONTAINER_REGISTRY = 'kangwoo'

    namespace = 'admin'
    job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'


    fairing.config.set_builder('append', registry=CONTAINER_REGISTRY, image_name="mnist-simple",
                               base_image="tensorflow/tensorflow:2.1.0-py3")

    fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

    return fairing.config.fn(fn)

전처리기를 설정하는 set_preprocessor() 구문이 없습니다. 그리고 마지막 줄에 fairing을 실행하는 fairing.config.run() 코드가 사라지고, return fairing.config.fn(fn) 코드가 추가되었습니다. fairing.config.fn(fn) 함수는 넘겨진 fn 함수를 직접 실행해주는 “function” 전처리기가 사용됩니다.

다음은 fairing에서 함수를 넘겨받아 실행하는 부분입니다.

if __name__ == '__main__':
    import uuid
    from kubeflow import fairing
    remote_train = fairing_fn(train)
    remote_train()

shift + enter 키를 눌러 셀 들을 실행시키면, 다음과 같은 응답 결과를 얻을 수 있습니다.

[I 200307 07:08:41 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.function.FunctionPreProcessor object at 0x7fb1800bffd0>
[I 200307 07:08:41 config:127] Using builder: <kubeflow.fairing.builders.append.append.AppendBuilder object at 0x7fb1800bf320>
[I 200307 07:08:41 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x7fb1800bfa20>
[W 200307 07:08:41 append:50] Building image using Append builder...
[I 200307 07:08:41 base:107] Creating docker context: /tmp/fairing_context_c1g8ic6t
[W 200307 07:08:41 base:94] /usr/local/lib/python3.6/dist-packages/kubeflow/fairing/__init__.py already exists in Fairing context, skipping...
[I 200307 07:08:41 docker_creds_:234] Loading Docker credentials for repository 'tensorflow/tensorflow:2.1.0-py3'
[W 200307 07:08:44 append:54] Image successfully built in 2.49341115399875s.
[W 200307 07:08:44 append:94] Pushing image kangwoo/mnist-simple:88C9B5FC...
...
[W 200307 07:08:50 append:99] Pushed image kangwoo/mnist-simple:88C9B5FC in 5.64489735999814s.
[W 200307 07:08:50 job:90] The job mnist-job-c27ep7bs5 launched.

“full_notebook” 전처리기를 사용해서 노트북 실행하기

“full_notebook” 전처리기는 Papermill 을 사용해서 노트북을 실행시킵니다. 그래서 컨테이너 이미지 안에 Papermill 이 있어야합니다. Papermill은 노트북을 매개 변수화하고 실행할 수있는 도구입니다.

Dockerfile

FROM tensorflow/tensorflow:2.1.0-py3

RUN python -m pip install papermill \\
    && python -m pip install papermill s3 \\
    && python -m pip install papermill gcloud \\
    && python -m pip install papermill azure \\
    && python -m pip install ipykernel \\
    && python -m ipykernel install

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Notebook 을 클릭하여 노트북 환경에서 새 노트북을 시작하십시오.

노트북 컬럼에 모델 코드와 faring 코드를 입력하겠습니다.

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

import os

import tensorflow as tf
import numpy as np

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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))

다음은 fairing 코드 입니다.

def fairing_run():
    CONTAINER_REGISTRY = 'kangwoo'

    namespace = 'admin'
    job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'

    fairing.config.set_preprocessor('full_notebook')

    fairing.config.set_builder('append', registry=CONTAINER_REGISTRY, image_name="mnist-simple",
                               base_image="kangwoo/tensorflow:2.1.0-papermill")

    fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

    fairing.config.run()

“full_notebook” 전처리기를 사용합니다. “full_notebook” 전처리기는 Papermill 을 사용해서 노트북을 실행시킵니다. 그래서 컨테이너 이미지 안에 Papermill 이 있어야합니다. Papermill은 노트북을 매개 변수화하고 실행할 수있는 도구입니다.

다음은 fairing에서 함수를 넘겨받아 실행하는 부분입니다.

if __name__ == '__main__':
    if os.getenv('FAIRING_RUNTIME', None) is None:
        import uuid
        from kubeflow import fairing
        fairing_run()
    else:
        train()

shift + enter 키를 눌러 셀 들을 실행시키면, 다음과 같은 응답 결과를 얻을 수 있습니다.

[I 200307 08:32:18 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.full_notebook.FullNotebookPreProcessor object at 0x7fefb8236a58>
[I 200307 08:32:18 config:127] Using builder: <kubeflow.fairing.builders.append.append.AppendBuilder object at 0x7fef3e50f898>
[I 200307 08:32:18 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x7fef3e7aba58>
[W 200307 08:32:18 append:50] Building image using Append builder...
[I 200307 08:32:18 base:107] Creating docker context: /tmp/fairing_context_d3874211
[I 200307 08:32:18 docker_creds_:234] Loading Docker credentials for repository 'kangwoo/tensorflow:2.1.0-papermill'
[W 200307 08:32:20 append:54] Image successfully built in 2.5086942100024316s.
[W 200307 08:32:20 append:94] Pushing image kangwoo/mnist-simple:51B47A33...
...
[W 200307 08:32:25 append:99] Pushed image kangwoo/mnist-simple:51B47A33 in 4.993432313000085s.
[W 200307 08:32:25 job:90] The job mnist-job-ca13vb4zw launched.

작업 결과 만들어진 노트북은 전처리기의 output_file 파라메터에 지정한 곳에 생성됩니다. 값을 지정하지 않으면, 기본값인 fairing_output_notebook.ipynb 으로 설정됩니다. 그래서 컨테이너 안에 생성되서, 쉽게 확인해 볼 수 없습니다. PV나 S3, GCS 같은 것을 사용해야합니다.

“cluster” 빌더를 사용해서 모델 학습하기

cluster 빌더를 사용해 보겠습니다. cluster 빌더는 컨테이너 이미지 빌드 작업이 쿠버네티스 클러스터에서 실행됩니다. cluster 빌더는 kaniko 라는 것을 사용해서 클러스터에서 빌드 작업을 합니다. kaniko는 컨테이너 또는 쿠버네티스 클러스터 내부에서 Dockerfile을 이용한 컨테이너 이미지를 빌드하는 도구입니다. kaniko는 도커 데몬을 사용하지 않으며, 사용자 공간에서 Dockerfile 에 포함된 명령을 완벽히 실행합니다. 그래서 쿠버네티스 클러스터와 같은 도커 데몬을 쉽고 안전하게 실행할 수 없는 환경에서도 컨테이너 이미지를 빌드 할 수 있습니다.

cluster 빌더를 사용하려면 ContextSource를 정의해 주어야 합니다. s3, gcs, azurestorage 그리고 minio를 지원하고 있습니다. (minio는 kubeflow-fairing 0.7.1.1 이상에서 가능합니다.)

docker-config 생성하기

먼저 kaniko에서 컨테이너 이미지 레지스터리에 접근할 수 있도록 쿠버네티스 클러스터에 docker-config 라는 컨피그맵(ConfigMap) 리소스를 만들겠습니다. 설정 정보는 앞에서 생성한 ~/.docker/config.json 파일을 사용하 겠습니다.

Jupyter 노트북 사용자 인터페이스의 메뉴에서 File > New > Terminal 을 클릭하여 노트북 환경에서 새 터미널 세션을 시작하십시오.

다음 명령어를 실행해서 admin이라는 네임스페이스에 docker-config 컨피그맵을 생성합니다.

kubectl -n admin create configmap docker-config --from-file=/home/jovyan/.docker/config.json

모델 파일 생성하기

모델 코드인 mnist-simple.py 파일과 컨테이너 이미지 빌드를 위한 Dockerfile을 생성합니다.

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

mnist-simple.py

from __future__ import absolute_import, division, print_function, unicode_literals

import tensorflow as tf
import numpy as np


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

    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

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

    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

    print("Training...")
    training_history = model.fit(x_train, y_train, epochs=5)

    print("Average test loss: ", np.average(training_history.history['loss']))


if __name__ == '__main__':
    train()

컨테이너 이미지 빌드를 Dockerfile을 생성하겠습니다.

Dockerfile

FROM tensorflow/tensorflow:2.1.0-py3

RUN mkdir -p /app
ADD mnist-simple.py /app/

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Notebook 을 클릭하여 노트북 환경에서 새 노트북을 시작하십시오.

노트북 컬럼에 faring 코드를 입력하겠습니다.

컨테이너 이미지를 빌드하고, 배포하기 위한 fairing 코드 파일을 생성하겠습니다. cloud 빌더를 사용하고, ContextSource로 minio를 사용하였습니다.

Kubeflow 설치시 파이프라인에서 사용하기 위해서 minio가 기본적으로 설치됩니다. 편의를 위해서 해당 minio를 사용하도록 하겠습니다.

minio의 접속 정보를 사용하여 MinioContextSource 를 생성합니다. 그리고 빌더 타입을 cluster로 사용하고, context_source 파라미티를 사용하여 생성한 MinioContextSource를 넘겨줍니다.

s3_endpoint = 'minio-service.kubeflow.svc.cluster.local:9000'
minio_endpoint = "http://"+s3_endpoint
minio_username = "minio"
minio_key = "minio123"
minio_region = "us-east-1"

from kubeflow.fairing.builders.cluster.minio_context import MinioContextSource
minio_context_source = MinioContextSource(endpoint_url=minio_endpoint, minio_secret=minio_username, minio_secret_key=minio_key, region_name=minio_region)

fairing.config.set_builder('cluster', registry=CONTAINER_REGISTRY, image_name="mnist-simple", dockerfile_path="Dockerfile",
                           context_source=minio_context_source)

fairing-cloud-minio.py

import uuid
from kubeflow import fairing

CONTAINER_REGISTRY = 'kangwoo'

namespace = 'admin'
job_name = f'mnist-job-{uuid.uuid4().hex[:4]}'

command=["python", "mnist-simple.py"]
output_map = {
    "Dockerfile": "Dockerfile",
    "mnist-simple.py": "mnist-simple.py"
}

fairing.config.set_preprocessor('python', command=command, path_prefix="/app", output_map=output_map)

s3_endpoint = 'minio-service.kubeflow.svc.cluster.local:9000'
minio_endpoint = "http://"+s3_endpoint
minio_username = "minio"
minio_key = "minio123"
minio_region = "us-east-1"

from kubeflow.fairing.builders.cluster.minio_context import MinioContextSource

minio_context_source = MinioContextSource(endpoint_url=minio_endpoint, minio_secret=minio_username, minio_secret_key=minio_key, region_name=minio_region)

fairing.config.set_builder('cluster', registry=CONTAINER_REGISTRY, image_name="mnist-simple", dockerfile_path="Dockerfile",
                           context_source=minio_context_source)


fairing.config.set_deployer('job', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True)

fairing.config.run()

이제 작성한 fairing 코드를 실행해 보겠습니다.

python fairing-local-append.py

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

[I 200308 01:42:47 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.base.BasePreProcessor object at 0x7f346dd42080>
[I 200308 01:42:47 config:127] Using builder: <kubeflow.fairing.builders.cluster.cluster.ClusterBuilder object at 0x7f34a0542320>
[I 200308 01:42:47 config:129] Using deployer: <kubeflow.fairing.deployers.job.job.Job object at 0x7f3475df0f28>
[I 200308 01:42:47 cluster:46] Building image using cluster builder.
[I 200308 01:42:47 base:107] Creating docker context: /tmp/fairing_context_2ns16rsm
[W 200308 01:42:48 manager:296] Waiting for fairing-builder-9hvzb-8v7x9 to start...
[I 200308 01:42:50 manager:302] Pod started running True
INFO[0002] Resolved base name tensorflow/tensorflow:2.1.0-py3 to tensorflow/tensorflow:2.1.0-py3
...
INFO[0045] Taking snapshot of files...
[W 200308 01:43:40 job:101] The job mnist-job-508a launched.
[W 200308 01:43:40 manager:296] Waiting for mnist-job-508a-ps9tt to start...
[I 200308 01:43:46 manager:302] Pod started running True

Job 이름은 “mnist-job-508a” 라는 것을 확인 할 수 있습니다.

다음 명령어를 실행하면 admin 네임스페이스의 Job 목록을 확인할 수 있습니다.

kubectl -n admin get job

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

NAME                  COMPLETIONS   DURATION   AGE
mnist-job-508a        1/1           18s        7m25s

다음 명령어를 실행하면 mnist-job-508a 라는 이름을 가진 Job이 생성한 포드를 확인할 수 있습니다.

kubectl -n admin get pod -l job-name=mnist-job-508a

정상적으로 실행되면 다음과 같은 응답 화면을 볼 수 있습니다.

NAME                        READY   STATUS      RESTARTS   AGE
mnist-job-508a-ps9tt        0/1     Completed   0          93s

학습 작업 삭제하기

작업이 완료되어도 Job은 삭제되지 않습니다.

다음 명령어를 실행하면 admin 네임스페이스의 mnist-job-508 라는 이름의 Job을 삭제할 수 있습니다.

kubectl -n admin delete job mnist-job-508

“tfjob” 배포자를 사용해서 모델 학습하기

“tfjob” 배포자와 “notebook” 전처리기 그리고 “cluster”배포자를 사용해서 모델을 학습해 보겠습니다. 모델을 저장하기 위해서 퍼시스턴스 볼륨을 사용하겠습니다

PVC 생성하기

학습이 완료된 모델을 저장하기 위해서 별도의 볼륨을 만들어서 사용하겠습니다.

다음은 100메가의 저장 용량을 가진 볼륨 생성을 요청하는 PVC 매니페스트입니다.

fairing-tfjob-pvc.yaml

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: fairing-tfjob-data-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Mi

kubectl을 사용해서 admin 네임스페이스에 pvc를 생성합니다.

kubectl -n admin apply -f fairing-tfjob-pvc.yaml

노트북 생성하기

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Notebook 을 클릭하여 노트북 환경에서 새 노트북을 시작하십시오.

노트북 파일 이름을 mnist-dist.ipynb 으로 설정합니다.

노트북 컬럼에 모델 코드와 faring 코드를 입력하겠습니다.

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

from __future__ import absolute_import, division, print_function, unicode_literals

import os
import tensorflow as tf
import tensorflow_datasets as tfds

def build_and_compile_model():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10)
    ])
    model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  optimizer=tf.keras.optimizers.Adam(),
                  metrics=['accuracy'])
    return model


@tfds.decode.make_decoder(output_dtype=tf.float32)
def decode_image(example, feature):
    return tf.cast(feature.decode_example(example), dtype=tf.float32) / 255


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

    BATCH_SIZE = 64

    tb_dir = '/app/data/logs'
    model_dir = '/app/data/export'
    version = 2
    export_dir = os.path.join(model_dir, str(version))

    strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
    mnist = tfds.builder('mnist', data_dir='/app/mnist')
    mnist.download_and_prepare()

    mnist_train, mnist_test = mnist.as_dataset(
        split=['train', 'test'],
        decoders={'image': decode_image()},
        as_supervised=True)
    train_input_dataset = mnist_train.cache().repeat().shuffle(
        buffer_size=50000).batch(BATCH_SIZE)
    # eval_input_dataset = mnist_test.cache().repeat().batch(BATCH_SIZE)

    options = tf.data.Options()
    options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.OFF
    train_input_dataset = train_input_dataset.with_options(options)

    print("Training...")

    with strategy.scope():
        multi_worker_model = build_and_compile_model()

    num_train_examples = mnist.info.splits['train'].num_examples
    train_steps = num_train_examples // BATCH_SIZE
    train_epochs = 10

    callbacks = [
        tf.keras.callbacks.TensorBoard(log_dir=tb_dir),
    ]

    history = multi_worker_model.fit(train_input_dataset, epochs=train_epochs, steps_per_epoch=train_steps,
                                     callbacks=callbacks)

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

    multi_worker_model.save(export_dir)

다음은 fairing 코드 입니다.

def fairing_run():
    import uuid
    from kubeflow import fairing
    from kubeflow.fairing.kubernetes import utils as k8s_utils
    from kubeflow.fairing.builders.cluster.minio_context import MinioContextSource

        
    CONTAINER_REGISTRY = 'kangwoo'

    namespace = 'admin'
    job_name = f'mnist-tfjob-{uuid.uuid4().hex[:4]}'

    s3_endpoint = 'minio-service.kubeflow.svc.cluster.local:9000'
    minio_endpoint = "http://"+s3_endpoint
    minio_username = "minio"
    minio_key = "minio123"
    minio_region = "us-east-1"

    minio_context_source = MinioContextSource(endpoint_url=minio_endpoint, minio_secret=minio_username, minio_secret_key=minio_key, region_name=minio_region)
    fairing.config.set_builder('cluster', registry=CONTAINER_REGISTRY, image_name="mnist-dist", dockerfile_path="Dockerfile",
                           context_source=minio_context_source)

    fairing.config.set_deployer('tfjob', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True, 
                            worker_count=2,
                            pod_spec_mutators=[k8s_utils.mounting_pvc(pvc_name='fairing-tfjob-data-pvc', pvc_mount_path='/mnt/pv')])

    fairing.config.run()

전처리기를 설정하는 set_preprocessor() 구문이 없습니다. 노트북에서는 별도의 전처리기를 설정하지 않으면 “notebook” 전처리기가 사용됩니다. “notebook” 전처리기는 노트북의 파이썬 코드 셀을 파이썬 파일로 변경해 줍니다.

tfjob 배포자를 사용하였습니다. 워커를 2개 실행시키 위해서 worker_count=2를 설정하였습니다. 그리고, 모델을 저장하기 위한 퍼시스턴스 볼륨을 마운트하기 위해서 pod_spec_mutators=[k8s_utils.mounting_pvc(pvc_name=’fairing-tfjob-data-pvc’, pvc_mount_path=’/mnt/pv’)]) 을 설정하였습니다.

    fairing.config.set_deployer('tfjob', namespace=namespace, job_name=job_name, cleanup=False, stream_log=True, 
                            worker_count=2,
                            pod_spec_mutators=[k8s_utils.mounting_pvc(pvc_name='fairing-tfjob-data-pvc', pvc_mount_path='/mnt/pv')])

컨테이너 이미지 만들기

모델을 학습할 때 데이터를 가져오기 위해서 tensorflow-dataset을 사용합니다. 그래서 컨테이너 이미지에 tensorflow-dataset 패키지가 포함되어야 합니다. 노트북 환경에서 별도의 전처리기를 설정하지 않으면, 노트북_이름.ipynb 파일이 /app/노트북_이름.py 파일로 생성됩니다. 예제에서 사용한 노트북 파일 이름이 mnist-dist.ipynb 이기 때문에 “ADD /app/mnist-dist.py /app/”를 사용해서, 모델 파일을 컨테이너 이미지에 추가해줍니다.

Dockerfile

FROM tensorflow/tensorflow:2.1.0-py3

RUN pip install tensorflow-datasets==2.0.0

RUN mkdir -p /app
RUN ls -al /kaniko/buildcontext/app
ADD /app/mnist-dist.py /app/

다음은 환경 변수에 따라 모델 훈련을 실행하거나, fairing을 실행하는 부분입니다.

if __name__ == '__main__':
    if os.getenv('FAIRING_RUNTIME', None) is None:
        fairing_run()
    else:
        train()

shift + enter 키를 눌러 셀 들을 실행시키면, 다음과 같은 응답 결과를 얻을 수 있습니다.

[I 200308 03:06:38 config:125] Using preprocessor: <kubeflow.fairing.preprocessors.converted_notebook.ConvertNotebookPreprocessor object at 0x7f274c3a56a0>
[I 200308 03:06:38 config:127] Using builder: <kubeflow.fairing.builders.cluster.cluster.ClusterBuilder object at 0x7f26d167dc88>
[I 200308 03:06:38 config:129] Using deployer: <kubeflow.fairing.deployers.tfjob.tfjob.TfJob object at 0x7f274d7284a8>
[I 200308 03:06:38 cluster:46] Building image using cluster builder.
[I 200308 03:06:38 base:107] Creating docker context: /tmp/fairing_context_z45ivvfn
[I 200308 03:06:39 converted_notebook:127] Converting mnist-dist.ipynb to mnist-dist.py
[W 200308 03:06:39 manager:296] Waiting for fairing-builder-zp7xj-m6ctb to start...
[I 200308 03:06:41 manager:302] Pod started running True
[W 200308 03:08:07 job:101] The tfjob mnist-tfjob-d20e launched.

Kubeflow – TensorFlow 학습하기

텐서플로우 알아 보기

텐서플로우(TensorFlow)는 구글에서 만든 오픈소스 딥러닝 프레임워크입니다. 딥러닝 프로그램을 쉽게 구현할 수 있도록 다양한 기능을 제공해주고 있습니다. 텐서플로우 자체는 기본적으로 C++로 구현 되어 있으며, Python, Java, Go 등 다양한 언어를 지원합니다.

TFJob을 이용해서 텐서플로우로 모델을 학습 할 수 있습니다. TFJob은 쿠버네티스에서 분산 또는 비 분산 텐서플로우 작업을 쉽게 실행할 수 있는 쿠버네티스 사용자 리소스(Custom Resource) 입니다.

TFJob

TFJob은 쿠버네티스에서 텐서플로우를 이용한 학습 작업을 할 수 있게 해주는 쿠버네티스 사용자 리소스 입니다. TFJob의 구현은 tf-operator에 있습니다. tf-operator는 TFJob을 관리합니다. 쿠버네티스에 TFJob이 등록되면, 필요한 포드들을 생성하여 작업을 실행할 수 있도록 도와줍니다.

TFJob은 다음과 같이 YAML 형식으로 표현할 수 있는 쿠버네티스 사용자 리소스입니다.

apiVersion: kubeflow.org/v1
kind: TFJob
metadata:
  name: mnist-tfjob-dist
  namespace: admin
spec:
  cleanPodPolicy: Running
  tfReplicaSpecs:
    Chief:
      replicas: 1
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
          name: tensorflow
        spec:
          containers:
          - command:
            - python
            - mnist-dist.py
            image: kangwoo/tfjob-dist:0.0.1
            name: tensorflow
            volumeMounts:
            - mountPath: /app/data
              name: tfjob-data-volume
            workingDir: /app
          restartPolicy: Never
          volumes:
          - name: tfjob-data-volume
            persistentVolumeClaim:
              claimName: tfjob-data-volume
    Worker:
      replicas: 2
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
          name: tensorflow
        spec:
          containers:
          - command:
            - python
            - mnist-dist.py
            image: kangwoo/tfjob-dist:0.0.1
            name: tensorflow
            volumeMounts:
            - mountPath: /app/data
              name: tfjob-data-volume
            workingDir: /app
          restartPolicy: Never
          volumes:
          - name: tfjob-data-volume
            persistentVolumeClaim:
              claimName: tfjob-data-volume

분산 처리 기술을 사용한 모델 학습

쿠버네티스에서 TFJob을 관리하고 있는 tf-operator 는 텐서플로우를 사용한 모델 학습시 분산 처리가 가능하도록 도와주고 있습니다.

텐서플로우에는 분산 처리 기술을 사용하기 위해서 다음과 같은 역할을 가진 프로세스가 존재합니다.

  • Chief: Chief는 학습을 조정하는 역할을 합니다. 그리고 모델의 체크포인트 같은 작업을 수행할 책임이 있습니다.
  • Ps (Paramter Server) : Ps는 파라미터 서버로서, 모델 파라미터에 대한 분산 데이터 저장소를 제공하는 역할을 합니다.
  • Worker : Worker는 실제 모델 학습 작업을 수행하는 역할을 합니다. 경우에 따라서 0번 Worker가 Chief 역할을 수행 할 수 있습니다.
  • Evaluator : Evaluator는 평가 지표를 계산하는 역할을 합니다. 모델을 학습 할 때 Evaluator를 사용하여 평가 지표를 계산할 수 있습니다.

TFJob은 TF_CONFIG라는 환경 변수를 사용하여 프로세스의 역할 정의합니다.

모델 학습을 시작하려면 TF_CONFIG라는 환경 변수에 다음과 같은 변수가 json 형태로 설정되어 있어야 합니다.

{
	"cluster": {
		"worker": ["host1:port", "host2:port", "host3:port"],
	  "ps": ["host4:port", "host5:port"]
   },
	"task": {"type": "worker", "index": 0}
}
  • cluster : 클러스터 내에 있는 서버들의 정보를 지정합니다.
  • task : 클러스터 내에서 현재 작업이 담당한 역할을 지정합니다. 클러스터 내에서 가질 수 있는 역할은 “chief”, “worker”, “ps”, “evaluator” 중 하나입니다. 단, “ps” 역할은 tf.distribute.experimental.ParameterServerStrategy 전략을 사용할 때만 쓸 수 있습니다

TFJob 이라는 쿠터네티스트 사용자 리소스를 생성하여 모델 학습을 진행 경우에는, tf-operator 가 프로세스의 역할에 맞게 자동으로 환경 변수를 설정해 줍니다. 그래서 분산 작업을 위한 별도의 환경 변수 설정 작업을 하지 않아도 됩니다.

다음은 TFJob에서 생성한 포드의 환경 변수를 일부 출력해 본 것입니다.

spec:
  containers:
  - env:
    - name: TF_CONFIG
      value: '{"cluster":{"chief":["mnist-tfjob-dist-chief-0.admin.svc:2222"],"worker":["mnist-tfjob-dist-worker-0.admin.svc:2222","mnist-tfjob-dist-worker-1.admin.svc:2222"]},"task":{"type":"chief","index":0},"environment":"cloud"}'

텐서플로우 학습 작업 실행하기

TFJob을 정의한 후 학습 작업을 생성해 보겠습니다.

모델 코드 작성하기

텐서플로우로 학습할 모델을 작성해 보겠습니다.

다음은 텐서플로우 케라스를 사용하여 mnist 숫자 이미지를 분류하는 파이썬 코드인 mnist-dist.py입니다. Gtf.distribute.experimental.MultiWorkerMirroredStrategy 를 사용해서 분산 학습을 지원하고 있습니다.

mnist-dist.py

from __future__ import absolute_import, division, print_function, unicode_literals

import os
import json
import tensorflow as tf
import tensorflow_datasets as tfds


def build_and_compile_model():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10)
    ])
    model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  optimizer=tf.keras.optimizers.Adam(),
                  metrics=['accuracy'])
    return model


@tfds.decode.make_decoder(output_dtype=tf.float32)
def decode_image(example, feature):
    return tf.cast(feature.decode_example(example), dtype=tf.float32) / 255


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

    tf_config = os.environ.get('TF_CONFIG', '{}')
    print("TF_CONFIG %s", tf_config)
    tf_config_json = json.loads(tf_config)
    cluster = tf_config_json.get('cluster')
    job_name = tf_config_json.get('task', {}).get('type')
    task_index = tf_config_json.get('task', {}).get('index')
    print("cluster={} job_name={} task_index={}}", cluster, job_name, task_index)

    BATCH_SIZE = 64

    tb_dir = '/app/data/logs'
    model_dir = '/app/data/export'
    version = 1
    export_dir = os.path.join(model_dir, str(version))

    strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
    mnist = tfds.builder('mnist', data_dir='/app/mnist')
    mnist.download_and_prepare()

    mnist_train, mnist_test = mnist.as_dataset(
        split=['train', 'test'],
        decoders={'image': decode_image()},
        as_supervised=True)
    train_input_dataset = mnist_train.cache().repeat().shuffle(
        buffer_size=50000).batch(BATCH_SIZE)
    # eval_input_dataset = mnist_test.cache().repeat().batch(BATCH_SIZE)

    options = tf.data.Options()
    options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.OFF
    train_input_dataset = train_input_dataset.with_options(options)

    print("Training...")

    with strategy.scope():
        multi_worker_model = build_and_compile_model()

    num_train_examples = mnist.info.splits['train'].num_examples
    train_steps = num_train_examples // BATCH_SIZE
    train_epochs = 10

    callbacks = [
        tf.keras.callbacks.TensorBoard(log_dir=tb_dir),
    ]

    history = multi_worker_model.fit(train_input_dataset, epochs=train_epochs, steps_per_epoch=train_steps,
                                     callbacks=callbacks)

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

    multi_worker_model.save(export_dir)


if __name__ == '__main__':
    train()

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

모델 학습용 컨테이너 이미지를 만들기 위해서 Dockerfile을 생성하겠습니다. 텐서플로우 데이터셋을 사용하기 때문에 pip를 이용해서 추가해주었습니다.

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

Dockerfile

FROM tensorflow/tensorflow:2.1.0-py3

RUN pip install tensorflow-datasets==2.0.0

RUN mkdir -p /app
ADD mnist-dist.py /app/

다음 명령어를 실행하면 kkangwoo/tfjob-dist:0.0.1 라는 이름의 컨테이너 이미지를 빌드 할 수 있습니다.

docker build -t kangwoo/tfjob-dist:0.0.1 .

빌드한 컨테이너 이미지를 컨테이너 레지스트리로 업로드 하겠습니다.

docker push kangwoo/tfjob-dist:0.0.1

PVC 생성하기

텐서플로우 학습 작업 중 생성되는 매트릭과, 학습이 완료된 모델을 저장하기 위해서 별도의 볼륨을 만들어서 사용하겠습니다.

다음은 100메가의 저장 용량을 가진 볼륨 생성을 요청하는 PVC 매니페스트입니다.

tfjob-pvc.yaml

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: tfjob-data-volume
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Mi

kubectl을 사용해서 admin 네임스페이스에 pvc를 생성합니다.

kubectl -n admin apply -f tfjob-pvc.yaml

TFJob 생성하기

tf-operator를 사용해서 텐서플로우로 작성한 모델을 학습 하려면 TFJob을 정의해야합니다.

  1. tfReplicaSpecs를 설정합니다. “tfReplicaSpecs”은 텐서플로우의 분산 학습시 사용하는 프로세스들을 정의하는데 사용합니다. Chief를 1개로 설정하고, Worker를 2개로 설정하였습니다.. Kubeflow 클러스터에 istio가 설치되어 있기 때문에, 자동으로 istio-proxy가 포드에 주입됩니다. 이것을 방지하기 위해서 어노테이션에 sidecar.istio.io/inject: “false” 을 추가해 주었습니다. 그리고 앞에 생성한 볼륨을 마운트 하였습니다.
tfReplicaSpecs:
    Chief:
      replicas: 1
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
          name: tensorflow
        spec:
          containers:
          - command:
            - python
            - mnist-dist.py
            image: kangwoo/tfjob-dist:0.0.1
            name: tensorflow
            volumeMounts:
            - mountPath: /app/data
              name: tfjob-data-volume
            workingDir: /app
          restartPolicy: Never
          volumes:
          - name: tfjob-data-volume
            persistentVolumeClaim:
              claimName: tfjob-data-volume
    Worker:
      replicas: 2
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
          name: tensorflow
        spec:
          containers:
          - command:
            - python
            - mnist-dist.py
            image: kangwoo/tfjob-dist:0.0.1
            name: tensorflow
            volumeMounts:
            - mountPath: /app/data
              name: tfjob-data-volume
            workingDir: /app
          restartPolicy: Never
          volumes:
          - name: tfjob-data-volume
            persistentVolumeClaim:
              claimName: tfjob-data-volume

다음은 TFJob 을 생성한 위한 메니페스트입니다.

tfjob-dist.yaml

apiVersion: kubeflow.org/v1
kind: TFJob
metadata:
  name: mnist-tfjob-dist
spec:
  tfReplicaSpecs:
    Chief:
      replicas: 1
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
          name: tensorflow
        spec:
          containers:
          - command:
            - python
            - mnist-dist.py
            image: kangwoo/tfjob-dist:0.0.1
            name: tensorflow
            volumeMounts:
            - mountPath: /app/data
              name: tfjob-data-volume
            workingDir: /app
          restartPolicy: Never
          volumes:
          - name: tfjob-data-volume
            persistentVolumeClaim:
              claimName: tfjob-data-volume
    Worker:
      replicas: 2
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
          name: tensorflow
        spec:
          containers:
          - command:
            - python
            - mnist-dist.py
            image: kangwoo/tfjob-dist:0.0.1
            name: tensorflow
            volumeMounts:
            - mountPath: /app/data
              name: tfjob-data-volume
            workingDir: /app
          restartPolicy: Never
          volumes:
          - name: tfjob-data-volume
            persistentVolumeClaim:
              claimName: tfjob-data-volume

다음 명령어를 실행하면 admin 네임스페이스에 tfjob-dist 이라는 이름의 TFJob을 생성할 수 있습니다.

kubectl -n admin apply -f tfjob-dist.yaml

텐서플로우 학습 작업 확인하기

생성한 TFJob은 다음 명령어를 실행해서 확인 해 볼 수 있습니다.

kubectl -n admin get tfjob

생성된 TFJob이 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

NAME               STATE       AGE
mnist-tfjob-dist   Succeeded   19m

TFJob이 생성되면, tf-operator 에 의해서 포드들이 생성됩니다. TFJob 매니페스트에 정의한 개수대로 chief, worker 포드가 생성되게 됩니다.

생성된 포드들은 다음 명령어를 실행해서 확인 해 볼 수 있습니다.

kubectl -n admin get pod -l tf-job-name=mnist-tfjob-dist

생성된 포드들이 남아 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

NAME                    READY   STATUS    RESTARTS   AGE
mnist-tfjob-dist-chief-0    0/1     Completed   0          20m
mnist-tfjob-dist-worker-0   0/1     Completed   0          20m
mnist-tfjob-dist-worker-1   0/1     Completed   0          20m

TFJob은 작업이 끝난 후, 관련 포드들을 삭제해버립니다. 그래서 작업이 완료되면 포드가 조회되지 않을 수 있습니다. 작업이 완료되어도 포드들을 남겨 두고 싶다면, TFJob 매니페스트의 spec 부분에 “cleanPodPolicy: None” 를 추가하시면 됩니다.

TFJob spec의 CleanPodPolicy는 작업이 종료 될 때 포드 삭제를 제어할 때 사용합니다. 다음 값들 중 하나를 사용할 수 있습니다.

  • Running : 작업이 완료되었을 때, 실행이 끝난(Completed) 포드들은 삭제하지 않고, 실행중인(Running) 포드들만 삭제합니다.
  • All : 작업이 완료되었을 때, 실행이 끝난 포드들을 즉시 삭제합니다.
  • None : 작업이 완료되어도 포드들을 삭제하지 않습니다.

다음은 cleanPodPolicy를 추가한 메니페스트 예제입니다.

apiVersion: kubeflow.org/v1
kind: TFJob
metadata:
  name: mnist-tfjob-dist
spec:
spec:
  cleanPodPolicy: None
...

TFJob의 작업 상태를 알고 싶으면 describe 명령어를 사용할 수 있습니다.

다음 명령어를 실행하면 admin 네임스페이스에 mnist-tfjob-dist 이라는 이름의 TFJob의 상태를 조회할 수 있습니다.

kubectl -n admin describe tfjob mnist-tfjob-dist

다음은 예제 작업에 대한 샘플 출력입니다.

Name:         mnist-tfjob-dist
Namespace:    admin
Labels:       <none>
Annotations:  ...
API Version:  kubeflow.org/v1
Kind:         TFJob
Metadata:
...
Spec:
...
Status:
  Completion Time:  2020-03-07T02:17:17Z
  Conditions:
    Last Transition Time:  2020-03-07T02:16:10Z
    Last Update Time:      2020-03-07T02:16:10Z
    Message:               TFJob mnist-tfjob-dist is created.
    Reason:                TFJobCreated
    Status:                True
    Type:                  Created
    Last Transition Time:  2020-03-07T02:16:12Z
    Last Update Time:      2020-03-07T02:16:12Z
    Message:               TFJob mnist-tfjob-dist is running.
    Reason:                TFJobRunning
    Status:                False
    Type:                  Running
    Last Transition Time:  2020-03-07T02:17:17Z
    Last Update Time:      2020-03-07T02:17:17Z
    Message:               TFJob mnist-tfjob-dist successfully completed.
    Reason:                TFJobSucceeded
    Status:                True
    Type:                  Succeeded
  Replica Statuses:
    Chief:
      Succeeded:  1
    Worker:
      Succeeded:  2
  Start Time:     2020-03-07T02:16:11Z
Events:        <none>

텐서플로우 학습 작업 삭제하기

작업이 완료되어도 TFJob은 삭제되지 않습니다.

다음 명령어를 실행하면 admin 네임스페이스에 mnist-tfjob-dist이라는 이름의 TFJob을 삭제할 수 있습니다.

kubectl -n admin delete tfjob mnist-tfjob-dist

텐서보드

TensorBoard는 텐서플로우의 실행 및 그래프를 검사하고, 이해하기 위한 웹 응용 도구로서, 텐서플로우에서 기록한 로그를 그래프로 시각화하여 보여줍니다. 텐서보드는 텐서플로우에 포함되어 있습니다.

텐서보드를 실행하기 위해서 쿠버네티스 디플로이먼트 리소스를 정의해 보겠습니다.

“tensorflow/tensorflow:2.1.0-py3” 라는 컨테이너 이미지를 사용하여 텐서보드를 실행하겠습니다. 텐서보드는는 실행 될 때, 주어진 파리미터 값에 의해 로그를 읽어옵니다.

다음은 텐서보드에서 사용하는 몇 가지 파라미터입니다.

  • port : 텐서보드에 접근하기 위한 포트입니다.
  • logdir : 로그가 저장된 디렉토리 경로입니다.
  • path_prefix : 접속 URL에서 사용하는 경로 접두사입니다. 예를 들어 /foo/bar의 경로 접두사를 사용하면, http://localhost/이 아닌 http://localhost:6006/foo/bar/ 를 통해서 TensorBoard에 접속할 수 있습니다.
- command:
        - /usr/local/bin/tensorboard
        - --logdir=/app/data/logs
        - --path_prefix=/namespace/admin/tensorboard/mnist-dist/
        - --port=80

앞서 실행한 TFJob에서 텐서플로우 로그를 쿠버네티스의 퍼시스턴스 볼륨에 저장하였습니다. tfjob-data-volume 라는 퍼시스턴스 볼륨 클레임 이름을 가지고 있습니다. 해당 볼륨을 텐서보드에 마운트 해줍니다.

        volumeMounts:
        - mountPath: /app/data
          name: tfjob-data-volume
      volumes:
      - name: tfjob-data-volume
        persistentVolumeClaim:
          claimName: tfjob-data-volume

다음은 디플로이먼트 매니페스트입니다.

mnist-dist-tensorboard-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: mnist-dist-tensorboard
  name: mnist-dist-tensorboard
  namespace: admin
spec:
  selector:
    matchLabels:
      app: mnist-dist-tensorboard
  template:
    metadata:
      labels:
        app: mnist-dist-tensorboard
    spec:
      serviceAccount: default-editor
      containers:
      - command:
        - /usr/local/bin/tensorboard
        - --logdir=/app/data/logs
        - --path_prefix=/namespace/admin/tensorboard/mnist-dist/
        - --port=80
        image: tensorflow/tensorflow:2.1.0-py3
        name: tensorboard
        ports:
        - containerPort: 80
        volumeMounts:
        - mountPath: /app/data
          name: tfjob-data-volume
      volumes:
      - name: tfjob-data-volume
        persistentVolumeClaim:
          claimName: tfjob-data-volume

kubectl을 사용해서 admin 네임스페이스에 디플로이먼트 리소스를 생성합니다.

kubectl -n admin apply -f mnist-dist-tensorboard-deployment.yaml

텐서보드에 접속하기 위해서 쿠버네티스 서비스를 리소스를 정의합니다.

mnist-dist-tensorboard-service.yaml

apiVersion: v1
kind: Service
metadata:
  labels:
    app: mnist-dist-tensorboard
  name: mnist-dist-tensorboard
  namespace: admin
spec:
  ports:
  - name: http
    port: 80
    targetPort: 80
  selector:
    app: mnist-dist-tensorboard
  type: ClusterIP

kubectl을 사용해서 admin 네임스페이스에 서비스 리소스를 생성합니다.

kubectl -n admin apply -f mnist-dist-tensorboard-service.yaml

Kubeflow 클러스터에는 istio가 설치되어 있었습니다. 텐서보드를 istio-ingressgateway를 통해서 접근할 수 있도록 하기위해서 VirtualService 라는 사용자 리소스를 정의하겠습니다.

mnist-dist-tensorboard-virtualservice.yaml

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: mnist-dist-tensorboard
  namespace: admin
spec:
  gateways:
  - kubeflow/kubeflow-gateway
  hosts:
  - '*'
  http:
  - match:
    - uri:
        prefix: /namespace/admin/tensorboard/mnist-dist/
    route:
    - destination:
        host: mnist-dist-tensorboard.admin.svc.cluster.local
    timeout: 300s

kubectl을 사용해서 admin 네임스페이스에 서비스 리소스를 생성합니다.

kubectl -n admin apply -f mnist-dist-tensorboard-virtualservice.yaml

다음 주소로 텐서보드에 접근할 수 있습니다.

http://kubeflow-address/namespace/admin/tensorboard/mnist-dist/

텐서플로우 서빙

Serving은 학습이 완료된 모델을 실제 서비스에 적용하는 것입니다. 텐서플로우 서빙을 이용하면 텐서플로우에서 생성한 모델을 서비스 환경에 쉽고 빠르게 적용할 수 있습니다.

텐서플로우 서빙을 이용해서 모델 서버 실행하기

TensorFlow 모델 서버를 실행하기 위해서 쿠버네티스 디플로이먼트 리소스를 정의해 보겠습니다.

“tensorflow/serving:2.1.0” 라는 컨테이너 이미지를 사용하여 모델 서버를 실행하겠습니다. 모델 서버는 실행 될 때, 주어진 파리미터 값에 의해 모델을 로드하게 됩니다. 모델 서버에 모델이 로드 되면, REST나 GRPC를 사용하여 추론 요청을 시작할 수 있습니다.

다음은 모델 서버에서 사용하는 몇 가지 파라미터입니다.

  • port : GRPC 요청에 사용할 포트입니다.
  • rest_api_port : REST 요청에 사용할 포트입니다.
  • modeL_name : REST 요청의 URL에서 이를 사용합니다.
  • mode_base_path : 모델을 저장 한 디렉토리 경로입니다. containers: – args: – –port=9000 – –rest_api_port=8500 – –model_name=mnist – –model_base_path=/app/data/export command: – /usr/bin/tensorflow_model_server image: tensorflow/serving:2.1.0

앞서 TFJob을 사용하여, 학습된 모델을 쿠버네티스의 퍼시스턴스 볼륨에 저장하였습니다. tfjob-data-volume 라는 퍼시스턴스 볼륨 클레임 이름을 가지고 있습니다. 해당 볼륨을 모델 서버에 마운트 해줍니다.

        volumeMounts:
        - mountPath: /app/data
          name: tfjob-data-volume
      volumes:
      - name: tfjob-data-volume
        persistentVolumeClaim:
          claimName: tfjob-data-volume

다음은 디플로이먼트 매니페스트입니다.

mnist-model-server-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: mnist-model-server
  name: mnist-model-server
spec:
  selector:
    matchLabels:
      app: mnist-model-server
  template:
    metadata:
      annotations:
        sidecar.istio.io/inject: "false"
      labels:
        app: mnist-model-server
        version: v1
    spec:
      serviceAccount: default-editor
      containers:
      - args:
        - --port=9000
        - --rest_api_port=8500
        - --model_name=mnist
        - --model_base_path=/app/data/export
        command:
        - /usr/bin/tensorflow_model_server
        image: tensorflow/serving:2.1.0
        imagePullPolicy: IfNotPresent
        livenessProbe:
          initialDelaySeconds: 30
          periodSeconds: 30
          tcpSocket:
            port: 9000
        name: mnist
        ports:
        - containerPort: 9000
        - containerPort: 8500
        volumeMounts:
        - mountPath: /app/data
          name: tfjob-data-volume
      volumes:
      - name: tfjob-data-volume
        persistentVolumeClaim:
          claimName: tfjob-data-volume

kubectl을 사용해서 admin 네임스페이스에 디플로이먼트 리소스를 생성합니다.

kubectl -n admin apply -f mnist-model-server-deployment.yaml

모델 서버에서 정상적으로 모델을 로드 했는지 여부를 확인하려면, 포드의 로그를 조회하면 됩니다.

kubectl -n admin logs -l app=mnist-model-server

정상적으로 모델이 로드 되었다면, 다음과 같은 응답 결과를 학인 수 있습니다.

2020-03-07 00:58:07.813234: I tensorflow_serving/model_servers/server.cc:86] Building single TensorFlow model file config:  model_name: mnist model_base_path: /app/data/export
2020-03-07 00:58:07.814324: I tensorflow_serving/model_servers/server_core.cc:462] Adding/updating models.
2020-03-07 00:58:07.814334: I tensorflow_serving/model_servers/server_core.cc:573]  (Re-)adding model: mnist
2020-03-07 00:58:07.918328: I tensorflow_serving/core/basic_manager.cc:739] Successfully reserved resources to load servable {name: mnist version: 1}
2020-03-07 00:58:07.918351: I tensorflow_serving/core/loader_harness.cc:66] Approving load for servable version {name: mnist version: 1}
2020-03-07 00:58:07.918357: I tensorflow_serving/core/loader_harness.cc:74] Loading servable version {name: mnist version: 1}
2020-03-07 00:58:07.918373: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:31] Reading SavedModel from: /app/data/export/1
2020-03-07 00:58:07.920422: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:54] Reading meta graph with tags { serve }
2020-03-07 00:58:07.920439: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:264] Reading SavedModel debug info (if present) from: /app/data/export/1
2020-03-07 00:58:07.945844: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:203] Restoring SavedModel bundle.
2020-03-07 00:58:07.977914: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:152] Running initialization op on SavedModel bundle at path: /app/data/export/1
2020-03-07 00:58:07.983624: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:333] SavedModel load for tags { serve }; Status: success: OK. Took 65247 microseconds.
2020-03-07 00:58:07.984126: I tensorflow_serving/servables/tensorflow/saved_model_warmup.cc:105] No warmup data file found at /app/data/export/1/assets.extra/tf_serving_warmup_requests
2020-03-07 00:58:07.984397: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: mnist version: 1}
2020-03-07 00:58:07.995156: I tensorflow_serving/model_servers/server.cc:358] Running gRPC ModelServer at 0.0.0.0:9000 ...
2020-03-07 00:58:07.997145: I tensorflow_serving/model_servers/server.cc:378] Exporting HTTP/REST API at:localhost:8500 ...

모델 서버에 접속하기 위해서 쿠버네티스 서비스를 리소스를 정의합니다.

mnist-model-server-service.yaml

apiVersion: v1
kind: Service
metadata:
  labels:
    app: mnist-model-server
  name: mnist-model-server
spec:
  ports:
  - name: grpc-tf-serving
    port: 9000
    targetPort: 9000
  - name: http-tf-serving
    port: 8500
    targetPort: 8500
  selector:
    app: mnist-model-server
  type: ClusterIP

kubectl을 사용해서 admin 네임스페이스에 서비스 리소스를 생성합니다.

kubectl -n admin apply -f mnist-model-server-service.yaml

텐서플로우 서빙에서 로드된 모델에게 요청 하기

아래 예제 코드를 실행하기 위해서는 request와 tensorflow-datasets라는 파이썬 패키지가 필요합니다. 설치가 되어 있지 않다면 다음 명령어로 설치할 수 있습니다.

pip install request
pip install tensorflow-datasets==2.0.0

주피터 노트북 사용자 인터페이스의 메뉴에서 File > New > Notebook 을 클릭하여 노트북 환경에서 새 노트북을 생성하겠습니다.

먼저 요청에 사용할 테스트 데이터를 생성하는 코드를 작성합니다.

import os
import json
import numpy as np
import matplotlib.pyplot as plt
import subprocess
import tensorflow as tf
import tensorflow_datasets as tfds

dataset = tfds.load("mnist", shuffle_files=True, as_supervised=False)
train_dataset, test_dataset = dataset["train"], dataset["test"]
test_data = []
iterator = iter(test_dataset.batch(5))
test_data.append(next(iterator))

이미지와 내용을 화면에 출력하기 위해서 show() 함수를 작성합니다.

def show(idx, title):
  plt.figure()
  plt.imshow(test_images[idx].reshape(28,28))
  plt.axis('off')
  plt.title('\\n\\n{}'.format(title), fontdict={'size': 16})

test_data의 0번째에 있는 이미지와 라벨을 테스트 삼아 출력해 보겠습니다.

show(0, 'An Example Image: {}'.format(test_labels[0]))

모델 서버에 요청할 데이터를 json을 사용해서 작성합니다.

import json
data = json.dumps({"signature_name": "serving_default", "instances": test_images.tolist()})
print('Data: {} ... {}'.format(data[:50], data[len(data)-52:]))

모델 서버에 POST 형식으로 요청 데이터를 전송하고, 예측 결과를 받습니다.

import requests
headers = {"content-type": "application/json"}
json_response = requests.post('<http://mnist-model-server:8500/v1/models/mnist:predict>', data=data, headers=headers)
predictions = json.loads(json_response.text)['predictions']

예측 결과를 show() 함수를 사용하여 화면이 출력합니다.

for i in range(0, len(predictions)):
    show(i, 'The model thought this was number {} , and it was actually number {}'.format(
  np.argmax(predictions[i]), test_labels[i]))

정상적으로 처리 되었다면, 다음과 비슷한 응답 결과를 얻을 수 있습니다.

Kubeflow – MXNet 학습하기

MXNet 알아 보기

MXNet은 카네기 멜론 대학과 워싱톤 대학이 시작한 오픈소스 딥러닝 프레임워크입니다. MXNet은 빠르고 확장 가능한 학습 및 추론 프레임워크로서 다양한 언어와 디바이스를 지원하고 있습니다.

MXJob을 이용해서 MXNet을 학습 할 수 있습니다. MXJob은 쿠버네티스에서 분산 또는 비 분산 MXNet 작업을 쉽게 실행할 수 있는 쿠버네티스 CR(Custom Resource) 입니다.

MXJob

MXJob은 Kubernetes에서 MXNet 학습 작업을 실행하는 데 사용할 수 있는, 쿠버네티스 사용자 리소스 입니다. MXJob의 구현은 mxnet-operator에 있습니다. mxnet-operator는 MXJob을 관리합니다. 쿠버네티스에 MXJob이 등록되면, 필요한 포드들을 생성하여 작업을 실행할 수 있도록 도와줍니다.

MXJob은 다음과 같이 YAML 형식으로 표현할 수 있는 쿠버네티스 사용자 리소스입니다.

apiVersion: "kubeflow.org/v1beta1"
kind: "MXJob"
metadata:
  name: "mxnet-job"
spec:
  jobMode: MXTrain
  mxReplicaSpecs:
    Scheduler:
      replicas: 1
      restartPolicy: Never
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
        spec:
          containers:
            - name: mxnet
              image: kangwoo/mxnet:cpu
    Server:
      replicas: 1
      restartPolicy: Never
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
        spec:
          containers:
            - name: mxnet
              image: kangwoo/mxnet:cpu
    Worker:
      replicas: 1
      restartPolicy: Never
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
        spec:
          containers:
            - name: mxnet
              image: kangwoo/mxnet:cpu

분산 처리 기술을 사용한 모델 학습

쿠버네티스에서 MXJob을 관리하고 있는 mxnet-operator 는 MXNet을 사용한 모델 학습시 분산 처리가 가능하도록 도와주고 있습니다.

MXNet에는 분산 처리 기술을 사용하기 위해서 세 가지 역할의 프로세스가 존재합니다.

  • Scheduler (스케줄러) : 스케줄러는 1대만 존재해야만 합니다. 스케줄러의 역할은 클러스터를 설정하는 것입니다. 모든 프로세스에 클러스터의 다른 노드들 알려서 서로 통신 할 수 있도록 도와주고 있습니다.
  • Server (서버) : 모델의 매개 변수를 저장하고 작업자와 통신하는 역할을 합니다. 서버는 1대 이상 있을 수 있습니다.
  • Worker (작업자) : 작업자 노드는 실제 모델 학습 작업을 수행하는 역할을 합니다. 각 배치를 처리하기 전에 서버에서 가중치를 가지고 오고, 배치 작업이 끝난 후 서버에 가중치를 그라디언트를 보냅니다. 작업자는 1대 이상 있을 수 있습니다.

MXNet은 환경 변수를 사용하여 프로세스의 역할 정의하고, 다른 프로세스가 스케줄러를 찾도록 합니다.

모델 학습을 시작하려면 다음과 같은 환경 변수가 올바르게 설정되어 있어야 합니다.

  • DMLC_ROLE : 프로세스의 역할을 설정합니다. 서버, 작업자 또는 스케줄러 일 수 있습니다. 스케줄러는 하나만 있어야 합니다.
  • DMLC_PS_ROOT_URI : 스케줄러의 IP를 설정합니다.
  • DMLC_PS_ROOT_PORT : 스케줄러의 포트를 설정합니다.
  • DMLC_NUM_SERVER : 클러스터에있는 서버 노드 수를 설정합니다.
  • DMLC_NUM_WORKER : 클러스터에있는 작업자 노드 수를 설정합니다.

MXJob 이라는 쿠터네티스트 CR을 생성하여 모델 학습을 진행 경우에는, mxnet-operator 가 프로세스의 역할에 맞게 자동으로 환경 변수를 설정해 줍니다. 그래서 분산 작업을 위한 별도의 환경 변수 설정 작업을 하지 않아도 됩니다.

다음은 MXJob에서 생성한 포드의 환경 변수를 일부 출력해 본 것입니다.

spec:
  containers:
  - env:
    - name: MX_CONFIG
      value: '{"cluster":{"scheduler":[{"url":"mxnet-job-scheduler-0","port":9091}],"server":[{"url":"mxnet-job-server-0","port":9091}],"worker":[{"url":"mxnet-job-worker-0","port":9091}]},"labels":{"scheduler":"","server":"","worker":""},"task":{"type":"server","index":0}}'
    - name: DMLC_PS_ROOT_PORT
      value: "9091"
    - name: DMLC_PS_ROOT_URI
      value: mxnet-job-scheduler-0
    - name: DMLC_NUM_SERVER
      value: "1"
    - name: DMLC_NUM_WORKER
      value: "1"
    - name: DMLC_ROLE
      value: server
    - name: DMLC_USE_KUBERNETES
      value: "1"

MXJob CRD와 Operator 설치하기

MXJob을 사용하려면 쿠버네티스에 CRD와 Operator가 설치되어 있어야 합니다.

쿠버네티스가 MXJob을 지원하고 있는지 확인하기

다음 명령어를 실행하면 쿠버네티스 클러스터에 MXNet CRD가 설치되어 있는지 확인할 수 있습니다.

kubectl get crd | grep mxjobs

CRD가 설치되어 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

mxjobs.kubeflow.org                                  2020-03-01T08:41:16Z

만약 설치되어 있지 않은 경우에는, 다음과 같은 명령어로 설치할 수 있습니다.

git clone <https://github.com/kubeflow/manifests>
cd manifests/mxnet-job/mxnet-operator
kubectl apply -k base

참고 : 다음은 MXJob CRD와 mxnet-operator 생성이 필요한 전체 매니페스트 내용입니다.

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  labels:
    kustomize.component: mxnet-operator
  name: mxjobs.kubeflow.org
spec:
  group: kubeflow.org
  names:
    kind: MXJob
    plural: mxjobs
    singular: mxjob
  scope: Namespaced
  version: v1beta1
---
apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    app: mxnet-operator
    kustomize.component: mxnet-operator
  name: mxnet-operator
  namespace: kubeflow
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  labels:
    app: mxnet-operator
    kustomize.component: mxnet-operator
  name: mxnet-operator
rules:
- apiGroups:
  - kubeflow.org
  resources:
  - mxjobs
  verbs:
  - '*'
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - '*'
- apiGroups:
  - storage.k8s.io
  resources:
  - storageclasses
  verbs:
  - '*'
- apiGroups:
  - batch
  resources:
  - jobs
  verbs:
  - '*'
- apiGroups:
  - ""
  resources:
  - configmaps
  - pods
  - services
  - endpoints
  - persistentvolumeclaims
  - events
  verbs:
  - '*'
- apiGroups:
  - apps
  - extensions
  resources:
  - deployments
  verbs:
  - '*'
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  labels:
    app: mxnet-operator
    kustomize.component: mxnet-operator
  name: mxnet-operator
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: mxnet-operator
subjects:
- kind: ServiceAccount
  name: mxnet-operator
  namespace: kubeflow
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    kustomize.component: mxnet-operator
  name: mxnet-operator
  namespace: kubeflow
spec:
  replicas: 1
  selector:
    matchLabels:
      kustomize.component: mxnet-operator
  template:
    metadata:
      annotations:
        sidecar.istio.io/inject: "false"
      labels:
        kustomize.component: mxnet-operator
        name: mxnet-operator
    spec:
      containers:
      - command:
        - /opt/kubeflow/mxnet-operator.v1beta1
        - --alsologtostderr
        - -v=1
        env:
        - name: MY_POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: MY_POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        image: mxjob/mxnet-operator:v1beta1
        imagePullPolicy: Always
        name: mxnet-operator
      serviceAccountName: mxnet-operator

MXNet 학습 작업 실행하기

MXTrain 모드로 MXJob을 정의한 후 학습 작업을 생성해 보겠습니다.

모델 코드 작성하기

MXNet으로 학습할 모델을 작성해 보겠습니다.

다음은 MXNet에서 제공하고 있는 이미지 분류 파이썬 코드인 image_classification.py 와 data.py 입니다. Gluon (https://github.com/apache/incubator-mxnet/tree/master/example/distributed_training) 을 사용해서 분산 학습을 지원하고 있습니다.

image_classification.py

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   <http://www.apache.org/licenses/LICENSE-2.0>
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

from __future__ import division

import argparse, time, os
import logging

import mxnet as mx
from mxnet import gluon
from mxnet import profiler
from mxnet.gluon import nn
from mxnet.gluon.model_zoo import vision as models
from mxnet import autograd as ag
from mxnet.test_utils import get_mnist_iterator
from mxnet.metric import Accuracy, TopKAccuracy, CompositeEvalMetric
import numpy as np

from data import (get_cifar10_iterator, get_imagenet_iterator,
                  get_caltech101_iterator, dummy_iterator)

# logging
logging.basicConfig(level=logging.INFO)
fh = logging.FileHandler('image-classification.log')
logger = logging.getLogger()
logger.addHandler(fh)
formatter = logging.Formatter('%(message)s')
fh.setFormatter(formatter)
fh.setLevel(logging.DEBUG)
logging.debug('\\n%s', '-' * 100)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
fh.setFormatter(formatter)

# CLI
parser = argparse.ArgumentParser(description='Train a model for image classification.')
parser.add_argument('--dataset', type=str, default='cifar10',
                    help='dataset to use. options are mnist, cifar10, caltech101, imagenet and dummy.')
parser.add_argument('--data-dir', type=str, default='',
                  help='training directory of imagenet images, contains train/val subdirs.')
parser.add_argument('--num-worker', '-j', dest='num_workers', default=4, type=int,
                    help='number of workers for dataloader')
parser.add_argument('--batch-size', type=int, default=32,
                    help='training batch size per device (CPU/GPU).')
parser.add_argument('--gpus', type=str, default='',
                    help='ordinates of gpus to use, can be "0,1,2" or empty for cpu only.')
parser.add_argument('--epochs', type=int, default=120,
                    help='number of training epochs.')
parser.add_argument('--lr', type=float, default=0.1,
                    help='learning rate. default is 0.1.')
parser.add_argument('--momentum', type=float, default=0.9,
                    help='momentum value for optimizer, default is 0.9.')
parser.add_argument('--wd', type=float, default=0.0001,
                    help='weight decay rate. default is 0.0001.')
parser.add_argument('--seed', type=int, default=123,
                    help='random seed to use. Default=123.')
parser.add_argument('--mode', type=str,
                    help='mode in which to train the model. options are symbolic, imperative, hybrid')
parser.add_argument('--model', type=str, required=True,
                    help='type of model to use. see vision_model for options.')
parser.add_argument('--use_thumbnail', action='store_true',
                    help='use thumbnail or not in resnet. default is false.')
parser.add_argument('--batch-norm', action='store_true',
                    help='enable batch normalization or not in vgg. default is false.')
parser.add_argument('--use-pretrained', action='store_true',
                    help='enable using pretrained model from gluon.')
parser.add_argument('--prefix', default='', type=str,
                    help='path to checkpoint prefix, default is current working dir')
parser.add_argument('--start-epoch', default=0, type=int,
                    help='starting epoch, 0 for fresh training, > 0 to resume')
parser.add_argument('--resume', type=str, default='',
                    help='path to saved weight where you want resume')
parser.add_argument('--lr-factor', default=0.1, type=float,
                    help='learning rate decay ratio')
parser.add_argument('--lr-steps', default='30,60,90', type=str,
                    help='list of learning rate decay epochs as in str')
parser.add_argument('--dtype', default='float32', type=str,
                    help='data type, float32 or float16 if applicable')
parser.add_argument('--save-frequency', default=10, type=int,
                    help='epoch frequence to save model, best model will always be saved')
parser.add_argument('--kvstore', type=str, default='device',
                    help='kvstore to use for trainer/module.')
parser.add_argument('--log-interval', type=int, default=50,
                    help='Number of batches to wait before logging.')
parser.add_argument('--profile', action='store_true',
                    help='Option to turn on memory profiling for front-end, '\\
                         'and prints out the memory usage by python function at the end.')
parser.add_argument('--builtin-profiler', type=int, default=0, help='Enable built-in profiler (0=off, 1=on)')
opt = parser.parse_args()

# global variables
logger.info('Starting new image-classification task:, %s',opt)
mx.random.seed(opt.seed)
model_name = opt.model
dataset_classes = {'mnist': 10, 'cifar10': 10, 'caltech101':101, 'imagenet': 1000, 'dummy': 1000}
batch_size, dataset, classes = opt.batch_size, opt.dataset, dataset_classes[opt.dataset]
context = [mx.gpu(int(i)) for i in opt.gpus.split(',')] if opt.gpus.strip() else [mx.cpu()]
num_gpus = len(context)
batch_size *= max(1, num_gpus)
lr_steps = [int(x) for x in opt.lr_steps.split(',') if x.strip()]
metric = CompositeEvalMetric([Accuracy(), TopKAccuracy(5)])
kv = mx.kv.create(opt.kvstore)

def get_model(model, ctx, opt):
    """Model initialization."""
    kwargs = {'ctx': ctx, 'pretrained': opt.use_pretrained, 'classes': classes}
    if model.startswith('resnet'):
        kwargs['thumbnail'] = opt.use_thumbnail
    elif model.startswith('vgg'):
        kwargs['batch_norm'] = opt.batch_norm

    net = models.get_model(model, **kwargs)
    if opt.resume:
        net.load_parameters(opt.resume)
    elif not opt.use_pretrained:
        if model in ['alexnet']:
            net.initialize(mx.init.Normal())
        else:
            net.initialize(mx.init.Xavier(magnitude=2))
    net.cast(opt.dtype)
    return net

net = get_model(opt.model, context, opt)

def get_data_iters(dataset, batch_size, opt):
    """get dataset iterators"""
    if dataset == 'mnist':
        train_data, val_data = get_mnist_iterator(batch_size, (1, 28, 28),
                                                  num_parts=kv.num_workers, part_index=kv.rank)
    elif dataset == 'cifar10':
        train_data, val_data = get_cifar10_iterator(batch_size, (3, 32, 32),
                                                    num_parts=kv.num_workers, part_index=kv.rank)
    elif dataset == 'imagenet':
        shape_dim = 299 if model_name == 'inceptionv3' else 224

        if not opt.data_dir:
            raise ValueError('Dir containing raw images in train/val is required for imagenet.'
                             'Please specify "--data-dir"')

        train_data, val_data = get_imagenet_iterator(opt.data_dir, batch_size,
                                                                opt.num_workers, shape_dim, opt.dtype)
    elif dataset == 'caltech101':
        train_data, val_data = get_caltech101_iterator(batch_size, opt.num_workers, opt.dtype)
    elif dataset == 'dummy':
        shape_dim = 299 if model_name == 'inceptionv3' else 224
        train_data, val_data = dummy_iterator(batch_size, (3, shape_dim, shape_dim))
    return train_data, val_data

def test(ctx, val_data):
    metric.reset()
    val_data.reset()
    for batch in val_data:
        data = gluon.utils.split_and_load(batch.data[0].astype(opt.dtype, copy=False),
                                          ctx_list=ctx, batch_axis=0)
        label = gluon.utils.split_and_load(batch.label[0].astype(opt.dtype, copy=False),
                                           ctx_list=ctx, batch_axis=0)
        outputs = [net(X) for X in data]
        metric.update(label, outputs)
    return metric.get()

def update_learning_rate(lr, trainer, epoch, ratio, steps):
    """Set the learning rate to the initial value decayed by ratio every N epochs."""
    new_lr = lr * (ratio ** int(np.sum(np.array(steps) < epoch)))
    trainer.set_learning_rate(new_lr)
    return trainer

def save_checkpoint(epoch, top1, best_acc):
    if opt.save_frequency and (epoch + 1) % opt.save_frequency == 0:
        fname = os.path.join(opt.prefix, '%s_%d_acc_%.4f.params' % (opt.model, epoch, top1))
        net.save_parameters(fname)
        logger.info('[Epoch %d] Saving checkpoint to %s with Accuracy: %.4f', epoch, fname, top1)
    if top1 > best_acc[0]:
        best_acc[0] = top1
        fname = os.path.join(opt.prefix, '%s_best.params' % (opt.model))
        net.save_parameters(fname)
        logger.info('[Epoch %d] Saving checkpoint to %s with Accuracy: %.4f', epoch, fname, top1)

def train(opt, ctx):
    if isinstance(ctx, mx.Context):
        ctx = [ctx]

    train_data, val_data = get_data_iters(dataset, batch_size, opt)
    net.collect_params().reset_ctx(ctx)
    trainer = gluon.Trainer(net.collect_params(), 'sgd',
                            optimizer_params={'learning_rate': opt.lr,
                                              'wd': opt.wd,
                                              'momentum': opt.momentum,
                                              'multi_precision': True},
                            kvstore=kv)
    loss = gluon.loss.SoftmaxCrossEntropyLoss()

    total_time = 0
    num_epochs = 0
    best_acc = [0]
    for epoch in range(opt.start_epoch, opt.epochs):
        trainer = update_learning_rate(opt.lr, trainer, epoch, opt.lr_factor, lr_steps)
        tic = time.time()
        train_data.reset()
        metric.reset()
        btic = time.time()
        for i, batch in enumerate(train_data):
            data = gluon.utils.split_and_load(batch.data[0].astype(opt.dtype), ctx_list=ctx, batch_axis=0)
            label = gluon.utils.split_and_load(batch.label[0].astype(opt.dtype), ctx_list=ctx, batch_axis=0)
            outputs = []
            Ls = []
            with ag.record():
                for x, y in zip(data, label):
                    z = net(x)
                    L = loss(z, y)
                    # store the loss and do backward after we have done forward
                    # on all GPUs for better speed on multiple GPUs.
                    Ls.append(L)
                    outputs.append(z)
                ag.backward(Ls)
            trainer.step(batch.data[0].shape[0])
            metric.update(label, outputs)
            if opt.log_interval and not (i+1)%opt.log_interval:
                name, acc = metric.get()
                logger.info('Epoch[%d] Batch [%d]\\tSpeed: %f samples/sec\\t%s=%f, %s=%f'%(
                               epoch, i, batch_size/(time.time()-btic), name[0], acc[0], name[1], acc[1]))
            btic = time.time()

        epoch_time = time.time()-tic

        # First epoch will usually be much slower than the subsequent epics,
        # so don't factor into the average
        if num_epochs > 0:
          total_time = total_time + epoch_time
        num_epochs = num_epochs + 1

        name, acc = metric.get()
        logger.info('[Epoch %d] training: %s=%f, %s=%f'%(epoch, name[0], acc[0], name[1], acc[1]))
        logger.info('[Epoch %d] time cost: %f'%(epoch, epoch_time))
        name, val_acc = test(ctx, val_data)
        logger.info('[Epoch %d] validation: %s=%f, %s=%f'%(epoch, name[0], val_acc[0], name[1], val_acc[1]))

        # save model if meet requirements
        save_checkpoint(epoch, val_acc[0], best_acc)
    if num_epochs > 1:
        print('Average epoch time: {}'.format(float(total_time)/(num_epochs - 1)))

def main():
    if opt.builtin_profiler > 0:
        profiler.set_config(profile_all=True, aggregate_stats=True)
        profiler.set_state('run')
    if opt.mode == 'symbolic':
        data = mx.sym.var('data')
        if opt.dtype == 'float16':
            data = mx.sym.Cast(data=data, dtype=np.float16)
        out = net(data)
        if opt.dtype == 'float16':
            out = mx.sym.Cast(data=out, dtype=np.float32)
        softmax = mx.sym.SoftmaxOutput(out, name='softmax')
        mod = mx.mod.Module(softmax, context=context)
        train_data, val_data = get_data_iters(dataset, batch_size, opt)
        mod.fit(train_data,
                eval_data=val_data,
                num_epoch=opt.epochs,
                kvstore=kv,
                batch_end_callback = mx.callback.Speedometer(batch_size, max(1, opt.log_interval)),
                epoch_end_callback = mx.callback.do_checkpoint('image-classifier-%s'% opt.model),
                optimizer = 'sgd',
                optimizer_params = {'learning_rate': opt.lr, 'wd': opt.wd, 'momentum': opt.momentum, 'multi_precision': True},
                initializer = mx.init.Xavier(magnitude=2))
        mod.save_parameters('image-classifier-%s-%d-final.params'%(opt.model, opt.epochs))
    else:
        if opt.mode == 'hybrid':
            net.hybridize()
        train(opt, context)
    if opt.builtin_profiler > 0:
        profiler.set_state('stop')
        print(profiler.dumps())

if __name__ == '__main__':
    if opt.profile:
        import hotshot, hotshot.stats
        prof = hotshot.Profile('image-classifier-%s-%s.prof'%(opt.model, opt.mode))
        prof.runcall(main)
        prof.close()
        stats = hotshot.stats.load('image-classifier-%s-%s.prof'%(opt.model, opt.mode))
        stats.strip_dirs()
        stats.sort_stats('cumtime', 'calls')
        stats.print_stats()
    else:
        main()

data.py

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   <http://www.apache.org/licenses/LICENSE-2.0>
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

# pylint: skip-file
""" data iterator for mnist """
import os
import random
import tarfile
import logging
import tarfile
logging.basicConfig(level=logging.INFO)

import mxnet as mx
from mxnet.test_utils import get_cifar10
from mxnet.gluon.data.vision import ImageFolderDataset
from mxnet.gluon.data import DataLoader
from mxnet.contrib.io import DataLoaderIter

def get_cifar10_iterator(batch_size, data_shape, resize=-1, num_parts=1, part_index=0):
    get_cifar10()

    train = mx.io.ImageRecordIter(
        path_imgrec = "data/cifar/train.rec",
        # mean_img    = "data/cifar/mean.bin",
        resize      = resize,
        data_shape  = data_shape,
        batch_size  = batch_size,
        rand_crop   = True,
        rand_mirror = True,
        num_parts=num_parts,
        part_index=part_index)

    val = mx.io.ImageRecordIter(
        path_imgrec = "data/cifar/test.rec",
        # mean_img    = "data/cifar/mean.bin",
        resize      = resize,
        rand_crop   = False,
        rand_mirror = False,
        data_shape  = data_shape,
        batch_size  = batch_size,
        num_parts=num_parts,
        part_index=part_index)

    return train, val

def get_imagenet_transforms(data_shape=224, dtype='float32'):
    def train_transform(image, label):
        image, _ = mx.image.random_size_crop(image, (data_shape, data_shape), 0.08, (3/4., 4/3.))
        image = mx.nd.image.random_flip_left_right(image)
        image = mx.nd.image.to_tensor(image)
        image = mx.nd.image.normalize(image, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
        return mx.nd.cast(image, dtype), label

    def val_transform(image, label):
        image = mx.image.resize_short(image, data_shape + 32)
        image, _ = mx.image.center_crop(image, (data_shape, data_shape))
        image = mx.nd.image.to_tensor(image)
        image = mx.nd.image.normalize(image, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
        return mx.nd.cast(image, dtype), label
    return train_transform, val_transform

def get_imagenet_iterator(root, batch_size, num_workers, data_shape=224, dtype='float32'):
    """Dataset loader with preprocessing."""
    train_dir = os.path.join(root, 'train')
    train_transform, val_transform = get_imagenet_transforms(data_shape, dtype)
    logging.info("Loading image folder %s, this may take a bit long...", train_dir)
    train_dataset = ImageFolderDataset(train_dir, transform=train_transform)
    train_data = DataLoader(train_dataset, batch_size, shuffle=True,
                            last_batch='discard', num_workers=num_workers)
    val_dir = os.path.join(root, 'val')
    if not os.path.isdir(os.path.expanduser(os.path.join(root, 'val', 'n01440764'))):
        user_warning = 'Make sure validation images are stored in one subdir per category, a helper script is available at <https://git.io/vNQv1>'
        raise ValueError(user_warning)
    logging.info("Loading image folder %s, this may take a bit long...", val_dir)
    val_dataset = ImageFolderDataset(val_dir, transform=val_transform)
    val_data = DataLoader(val_dataset, batch_size, last_batch='keep', num_workers=num_workers)
    return DataLoaderIter(train_data, dtype), DataLoaderIter(val_data, dtype)

def get_caltech101_data():
    url = "<https://s3.us-east-2.amazonaws.com/mxnet-public/101_ObjectCategories.tar.gz>"
    dataset_name = "101_ObjectCategories"
    data_folder = "data"
    if not os.path.isdir(data_folder):
        os.makedirs(data_folder)
    tar_path = mx.gluon.utils.download(url, path=data_folder)
    if (not os.path.isdir(os.path.join(data_folder, "101_ObjectCategories")) or
        not os.path.isdir(os.path.join(data_folder, "101_ObjectCategories_test"))):
        tar = tarfile.open(tar_path, "r:gz")
        tar.extractall(data_folder)
        tar.close()
        print('Data extracted')
    training_path = os.path.join(data_folder, dataset_name)
    testing_path = os.path.join(data_folder, "{}_test".format(dataset_name))
    return training_path, testing_path

def get_caltech101_iterator(batch_size, num_workers, dtype):
    def transform(image, label):
        # resize the shorter edge to 224, the longer edge will be greater or equal to 224
        resized = mx.image.resize_short(image, 224)
        # center and crop an area of size (224,224)
        cropped, crop_info = mx.image.center_crop(resized, (224, 224))
        # transpose the channels to be (3,224,224)
        transposed = mx.nd.transpose(cropped, (2, 0, 1))
        return transposed, label

    training_path, testing_path = get_caltech101_data()
    dataset_train = ImageFolderDataset(root=training_path, transform=transform)
    dataset_test = ImageFolderDataset(root=testing_path, transform=transform)

    train_data = DataLoader(dataset_train, batch_size, shuffle=True, num_workers=num_workers)
    test_data = DataLoader(dataset_test, batch_size, shuffle=False, num_workers=num_workers)
    return DataLoaderIter(train_data), DataLoaderIter(test_data)

class DummyIter(mx.io.DataIter):
    def __init__(self, batch_size, data_shape, batches = 100):
        super(DummyIter, self).__init__(batch_size)
        self.data_shape = (batch_size,) + data_shape
        self.label_shape = (batch_size,)
        self.provide_data = [('data', self.data_shape)]
        self.provide_label = [('softmax_label', self.label_shape)]
        self.batch = mx.io.DataBatch(data=[mx.nd.zeros(self.data_shape)],
                                     label=[mx.nd.zeros(self.label_shape)])
        self._batches = 0
        self.batches = batches

    def next(self):
        if self._batches < self.batches:
            self._batches += 1
            return self.batch
        else:
            self._batches = 0
            raise StopIteration

def dummy_iterator(batch_size, data_shape):
    return DummyIter(batch_size, data_shape), DummyIter(batch_size, data_shape)

class ImagePairIter(mx.io.DataIter):
    def __init__(self, path, data_shape, label_shape, batch_size=64, flag=0, input_aug=None, target_aug=None):
        super(ImagePairIter, self).__init__(batch_size)
        self.data_shape = (batch_size,) + data_shape
        self.label_shape = (batch_size,) + label_shape
        self.input_aug = input_aug
        self.target_aug = target_aug
        self.provide_data = [('data', self.data_shape)]
        self.provide_label = [('label', self.label_shape)]
        is_image_file = lambda fn: any(fn.endswith(ext) for ext in [".png", ".jpg", ".jpeg"])
        self.filenames = [os.path.join(path, x) for x in os.listdir(path) if is_image_file(x)]
        self.count = 0
        self.flag = flag
        random.shuffle(self.filenames)

    def next(self):
        from PIL import Image
        if self.count + self.batch_size <= len(self.filenames):
            data = []
            label = []
            for i in range(self.batch_size):
                fn = self.filenames[self.count]
                self.count += 1
                image = Image.open(fn).convert('YCbCr').split()[0]
                if image.size[0] > image.size[1]:
                    image = image.transpose(Image.TRANSPOSE)
                image = mx.nd.expand_dims(mx.nd.array(image), axis=2)
                target = image.copy()
                for aug in self.input_aug:
                    image = aug(image)
                for aug in self.target_aug:
                    target = aug(target)
                data.append(image)
                label.append(target)

            data = mx.nd.concat(*[mx.nd.expand_dims(d, axis=0) for d in data], dim=0)
            label = mx.nd.concat(*[mx.nd.expand_dims(d, axis=0) for d in label], dim=0)
            data = [mx.nd.transpose(data, axes=(0, 3, 1, 2)).astype('float32')/255]
            label = [mx.nd.transpose(label, axes=(0, 3, 1, 2)).astype('float32')/255]

            return mx.io.DataBatch(data=data, label=label)
        else:
            raise StopIteration

    def reset(self):
        self.count = 0
        random.shuffle(self.filenames)

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

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

다음은 MXNet 1.5를 기반 이미지로 해서, 모델 파일을 추가하는 Dockerfile 입니다.

Dockerfile

FROM mxnet/python:1.5.0_cpu_py3

RUN mkdir -p /app
COPY image_classification.py /app/
COPY data.py /app/

WORKDIR /app

CMD ["python3", "image_classification.py", "--dataset", "cifar10", "--model", "vgg11", "--epochs", "1", "--kvstore", "dist_sync"]

다음 명령어를 실행하면 kangwoo/mxnet:cpu 라는 이름의 컨테이너 이미지를 빌드 할 수 있습니다.

docker build -t kangwoo/mxnet:cpu .

빌드한 컨테이너 이미지를 컨테이너 레지스트리로 업로드 하겠습니다.

docker push kangwoo/mxnet:cpu

MXJob 생성하기

mxnet-operator를 사용해서 MXNet 모델 학습을 하라면 MXJob을 정의해야합니다.

  1. jobMode를 MXTrain로 설정합니다. jobMode: MXTrain
  2. mxReplicaSpecs를 설정합니다. “mxReplicaSpecs”은 MXNet의 분산 학습시 사용하는 프로세스들을 정의하는데 사용합니다. Scheduler와 Server를 1개로 설정하고, Worker도 1개로 설정합니다. Kubeflow 클러스터에 istio가 설치되어 있기 때문에, 자동으로 istio-proxy가 포드에 주입됩니다. 이것을 방지하기 위해서 어노테이션에 sidecar.istio.io/inject: “false” 을 추가해 주었습니다. mxReplicaSpecs: Scheduler: replicas: 1 restartPolicy: Never template: metadata: annotations: sidecar.istio.io/inject: “false” spec: containers: – name: mxnet image: kangwoo/mxnet:cpu Server: replicas: 1 restartPolicy: Never template: metadata: annotations: sidecar.istio.io/inject: “false” spec: containers: – name: mxnet image: kangwoo/mxnet:cpu Worker: replicas: 1 restartPolicy: Never template: metadata: annotations: sidecar.istio.io/inject: “false” spec: containers: – name: mxnet image: kangwoo/mxnet:cpu

다음은 MXJob 을 생성한 위한 메니페스트입니다.

mxnet-job.yaml

apiVersion: "kubeflow.org/v1beta1"
kind: "MXJob"
metadata:
  name: "mxnet-job"
spec:
  jobMode: MXTrain
  mxReplicaSpecs:
    Scheduler:
      replicas: 1
      restartPolicy: Never
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
        spec:
          containers:
            - name: mxnet
              image: kangwoo/mxnet:cpu
    Server:
      replicas: 1
      restartPolicy: Never
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
        spec:
          containers:
            - name: mxnet
              image: kangwoo/mxnet:cpu
    Worker:
      replicas: 1
      restartPolicy: Never
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "false"
        spec:
          containers:
            - name: mxnet
              image: kangwoo/mxnet:cpu

다음 명령어를 실행하면 admin 네임스페이스에 mxnet-job 이라는 이름의 MXJob을 생성할 수 있습니다.

kubectl -n admin apply -f mxnet-job.yaml

MXNet 학습 작업 확인하기

생성한 MXJob은 다음 명령어를 실행해서 확인 해 볼 수 있습니다.

kubectl -n admin get mxjob

생성된 MXJob이 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

NAME        AGE
mxnet-job   5s

MXJob이 생성되면, mxnet-operator 에 의해서 포드들이 생성됩니다. MXjob 매니페스트에 정의한 갯수대로 scheduler, server, worker 포드가 생성되게 됩니다.

생성된 포드들은 다음 명령어를 실행해서 확인 해 볼 수 있습니다.

kubectl -n admin get pod -l mxnet_job_name=mxnet-job

생성된 포드들이 남아 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

NAME                    READY   STATUS    RESTARTS   AGE
mxnet-job-scheduler-0   1/1     Running   0          9s
mxnet-job-server-0      1/1     Running   0          9s
mxnet-job-worker-0      1/1     Running   0          9

MXJob은 작업이 끝난 후, 관련 포드들을 삭제해버립니다. 그래서 작업이 완료되면 포드가 조회되지 않을 수 있습니다. 작업이 완료되어도 포드들을 남겨 두고 싶다면, MXJob 매니페스트의 spec 부분에 “cleanPodPolicy: None” 를 추가하시면 됩니다.

MXJob spec의 CleanPodPolicy는 작업이 종료 될 때 포드 삭제를 제어할 때 사용합니다. 다음 값들 중 하나를 사용할 수 있습니다.

  • Running : 작업이 완료되었을 때, 실행이 끝난(Completed) 포드들은 삭제하지 않고, 실행중인(Running) 포드들만 삭제합니다.
  • All : 작업이 완료되었을 때, 실행이 끝난 포드들을 즉시 삭제합니다.
  • None : 작업이 완료되어도 포드들을 삭제하지 않습니다.

다음은 cleanPodPolicy를 추가한 메니페스트 예제입니다.

apiVersion: "kubeflow.org/v1beta1"
kind: "MXJob"
metadata:
  name: "mxnet-job"
spec:
  cleanPodPolicy: None
...

MXJob의 작업 상태를 알고 싶으면 describe 명령어를 사용할 수 있습니다.

다음 명령어를 실행하면 admin 네임스페이스에 mxnet-job 이라는 이름의 MXJob의 상태를 조회할 수 있습니다.

kubectl -n admin describe mxjob mxnet-job

다음은 예제 작업에 대한 샘플 출력입니다.

Name:         mxnet-job
Namespace:    admin
Labels:       <none>
Annotations:  ...
API Version:  kubeflow.org/v1beta1
Kind:         MXJob
Metadata:
...
Spec:
...
Status:
  Completion Time:  2020-03-08T00:44:23Z
  Conditions:
    Last Transition Time:  2020-03-07T23:45:12Z
    Last Update Time:      2020-03-07T23:45:12Z
    Message:               MXJob mxnet-job is created.
    Reason:                MXJobCreated
    Status:                True
    Type:                  Created
    Last Transition Time:  2020-03-07T23:45:12Z
    Last Update Time:      2020-03-07T23:45:14Z
    Message:               MXJob mxnet-job is running.
    Reason:                MXJobRunning
    Status:                False
    Type:                  Running
    Last Transition Time:  2020-03-07T23:45:12Z
    Last Update Time:      2020-03-08T00:44:23Z
    Message:               MXJob mxnet-job is successfully completed.
    Reason:                MXJobSucceeded
    Status:                True
    Type:                  Succeeded
  Mx Replica Statuses:
    Scheduler:
    Server:
    Worker:
  Start Time:  2020-03-07T23:45:14Z
Events:        <none>

MXNet 학습 작업 삭제하기

작업이 완료되어도 MXJob은 삭제되지 않습니다.

다음 명령어를 실행하면 admin 네임스페이스에 mxnet-job 이라는 이름의 MXJob을 삭제할 수 있습니다.

kubectl -n admin delete mxjob mxnet-job

참고

Kubeflow – Jupyter Notebooks 커스텀 이미지

주피터 노트북 커스텀 이미지

주피터 노트북 커스텀 이미지 만드는 방법

주피터 노트북에서 사용할 사용자 커스텀 이미지를 만드는 방법에 대해서 알아보겠습니다.

Kubeflow에서 사용자가 만든 커스텀 이미지를 사용하려면 몇 가지 요구 사항을 충족해야합니다. Kubeflow는 컨테이너 이미지가 실행되면, 주피터가 자동적으로 시작되는 것으로 알고 있습니다. 그래서 컨테이너 이미지에 주피터를 시작하는 기본 명령을 설정해야합니다.

먼저 주피터를 시작하는 명령어가 필요합니다. 다음은 주피터를 실행하는 명령어 입니다.

jupyter notebook

그리고 주피터에게 설정 정보를 넘겨줘야합니다. 다음은 주피터 실행에 필요한 설정 정보들입니다.

  • 작업 디렉토리 : /home/jovyan 디렉토리는 쿠버네티스 PV와 마운트 됩니다. –notebook-dir=/home/jovyan
  • 접근 허용 IP : 주피터 노트북 서버에 모든 IP 에서 접근가능하도록 합니다. –ip=0.0.0.0
  • 노트북 루트 권한 : 사용자가 노트북을 루트로 실행하는것을 허용합니다. –allow-root
  • 포트 설정 : 주피터 포드의 포트를 설정합니다. –port=8888
  • 인증 비활성화 : 주피터의 인증 기능을 비활성화 합니다. Kubeflow에서 사용하는 istio가 인증을 담당하기 때문에, 주피터에서 제공하는 기능을 비활성화 시키는것입니다. –NotebookApp.token=” –NotebookApp.password=”
  • 모든 오리진(origin) 허용 : 주피터 노트북 서버에 모든 오리진이 접근할 수 있도록 허용합니다. –NotebookApp.allow_origin=’*’
  • 기본 URL 설정 : Kubeflow에서 노트북 서버를 관리하는 노트북 컨트롤러는 NB_PREFIX 라는 환경 변수를 사용하여 노트북 서버의 기본 URL을 넘겨줍니다. –NotebookApp.base_url=${NB_PREFIX}

다음은 Dockerfile에 포함해야할 CMD 예제입니다.

ENV NB_PREFIX /

CMD ["sh","-c", "jupyter notebook --notebook-dir=/home/jovyan --ip=0.0.0.0 --no-browser --allow-root --port=8888 --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.allow_origin='*' --NotebookApp.base_url=${NB_PREFIX}"]

주의 하실 점은 ${NB_PREFIX} 라는 환경 변수를 사용하기 때문에 sh 이나 bash 등을 이용해서 노트북을 실행해야합니다.

주피터 노트북 커스텀 이미지 만들기

기존 주피터 노트북 이미지로 만들기

Kubeflow에서 기본으로 제공하는 주피터 노트북 이미지를 가지고 커스텀 이미지를 만들어 보겠습니다.

다음은 https://github.com/kubeflow/kubeflow/blob/master/components/tensorflow-notebook-image/Dockerfile 을 약간 수정한 Dockerfile 입니다.

# Copyright (c) Jupyter Development Team.
# Distributed under the terms of the Modified BSD License.

ARG BASE_IMAGE=tensorflow/tensorflow:2.1.0-py3-jupyter

FROM $BASE_IMAGE

ARG TF_SERVING_VERSION=0.0.0
ARG NB_USER=jovyan

# TODO: User should be refactored instead of hard coded jovyan

USER root

ENV DEBIAN_FRONTEND noninteractive

ENV NB_USER $NB_USER

ENV NB_UID 1000
ENV HOME /home/$NB_USER
ENV NB_PREFIX /


# Use bash instead of sh
SHELL ["/bin/bash", "-c"]

RUN apt-get update && apt-get install -yq --no-install-recommends \\
  apt-transport-https \\
  build-essential \\
  bzip2 \\
  ca-certificates \\
  curl \\
  g++ \\
  git \\
  gnupg \\
  graphviz \\
  locales \\
  lsb-release \\
  openssh-client \\
  sudo \\
  unzip \\
  vim \\
  wget \\
  zip \\
  emacs \\
  python3-pip \\
  python3-dev \\
  python3-setuptools \\
  && apt-get clean && \\
  rm -rf /var/lib/apt/lists/*

# Install Nodejs for jupyterlab-manager
RUN curl -sL <https://deb.nodesource.com/setup_12.x> | sudo -E bash -
RUN apt-get update && apt-get install -yq --no-install-recommends \\
  nodejs \\
  && apt-get clean && \\
  rm -rf /var/lib/apt/lists/*

ENV DOCKER_CREDENTIAL_GCR_VERSION=1.4.3
RUN curl -LO <https://github.com/GoogleCloudPlatform/docker-credential-gcr/releases/download/v${DOCKER_CREDENTIAL_GCR_VERSION}/docker-credential-gcr_linux_amd64-${DOCKER_CREDENTIAL_GCR_VERSION}.tar.gz> && \\
    tar -zxvf docker-credential-gcr_linux_amd64-${DOCKER_CREDENTIAL_GCR_VERSION}.tar.gz && \\
    mv docker-credential-gcr /usr/local/bin/docker-credential-gcr && \\
    rm docker-credential-gcr_linux_amd64-${DOCKER_CREDENTIAL_GCR_VERSION}.tar.gz && \\
    chmod +x /usr/local/bin/docker-credential-gcr

# Install AWS CLI
RUN curl "<https://s3.amazonaws.com/aws-cli/awscli-bundle.zip>" -o "/tmp/awscli-bundle.zip" && \\
    unzip /tmp/awscli-bundle.zip && ./awscli-bundle/install -i /usr/local/aws -b /usr/local/bin/aws && \\
    rm -rf ./awscli-bundle


RUN echo "en_US.UTF-8 UTF-8" > /etc/locale.gen && \\
    locale-gen

ENV LC_ALL en_US.UTF-8
ENV LANG en_US.UTF-8
ENV LANGUAGE en_US.UTF-8

# Create NB_USER user with UID=1000 and in the 'users' group
# but allow for non-initial launches of the notebook to have
# $HOME provided by the contents of a PV
RUN useradd -M -s /bin/bash -N -u $NB_UID $NB_USER && \\
    chown -R ${NB_USER}:users /usr/local/bin && \\
    mkdir -p $HOME

RUN export CLOUD_SDK_REPO="cloud-sdk-$(lsb_release -c -s)" && \\
    echo "deb <https://packages.cloud.google.com/apt> $CLOUD_SDK_REPO main" > /etc/apt/sources.list.d/google-cloud-sdk.list && \\
    curl <https://packages.cloud.google.com/apt/doc/apt-key.gpg> | apt-key add - && \\
    apt-get update && \\
    apt-get install -y google-cloud-sdk kubectl

# Install Tini - used as entrypoint for container
RUN cd /tmp && \\
    wget --quiet <https://github.com/krallin/tini/releases/download/v0.18.0/tini> && \\
    echo "12d20136605531b09a2c2dac02ccee85e1b874eb322ef6baf7561cd93f93c855 *tini" | sha256sum -c - && \\
    mv tini /usr/local/bin/tini && \\
    chmod +x /usr/local/bin/tini

# NOTE: Beyond this point be careful of breaking out
# or otherwise adding new layers with RUN, chown, etc.
# The image size can grow significantly.

# Install base python3 packages
RUN pip3 --no-cache-dir install \\
    jupyter-console==6.0.0 \\
    jupyterlab \\
    xgboost \\
    kubeflow-fairing==0.7.1.1


RUN docker-credential-gcr configure-docker && chown ${NB_USER}:users $HOME/.docker/config.json

# Configure container startup
EXPOSE 8888
USER jovyan
ENTRYPOINT ["tini", "--"]
CMD ["sh","-c", "jupyter lab --notebook-dir=/home/${NB_USER} --ip=0.0.0.0 --no-browser --allow-root --port=8888 --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.allow_origin='*' --NotebookApp.base_url=${NB_PREFIX}"]

베이스 이미지를 tensorflow/tensorflow:2.1.0-py3-jupyter 로 사용하였고, 파이썬 패키지인 kubeflow-fairing을 0.7.1 버전으로 설치하였습니다. 그리고 CMD를 수정해서 주피터 노트북이 아니라, 주피터 랩이 실행되게 하였습니다.

docker build -t kangwoo/tensorflow-2.1.0-notebook-cpu:1.0.0 .

생성한 컨테이너 이미지를 컨테이너 이미지 레지스트리에 푸시 하려면 접근 권한이 필요합니다. “컨테이너 이미지 레지스트리에 접근할 수 있도록 도커 설정하기”를 참고하기 바랍니다.

docker push kangwoo/tensorflow-2.1.0-notebook-cpu:1.0.0

노트북 목록 화면에서, “NEW SERVER” 버튼을 클릭하여, 새로운 노트북 서버를 생성하는 페이지로 이동합니다.

“Custom Image”를 체크하고, 새로 만든 커스텀 이미지 주소를 입력합니다.

나머지 필드에는 적당한 값을 입력하고, “LAUNCH” 버튼을 클릭하여, 새로운 노트북 서버를 생성합니다.

노트북 서버 목록에서 CONNECT 버튼을 누르고, 노트북 랩에 접속할 수 있습니다.

Kubeflow – Jupyter Notebooks 살펴보기

Kubeflow 주피터 노트북 살펴보기

주피터 노트툭은 데이터 과학자 뿐만 아니라, 데이터 엔지니어에게도 중요한 도구입니다. Kubeflow의 주피터 노트북은 컨테이너 기반이라서 격리된 환경을 제공합니다. 그래서 텐서플로우(TensorFlow), 파이토치(PyTorch), MXNet 같은 머신러닝 프레임워크를 간섭없이 사용할 수 있습니다. 그리고 쿠버네티스 기반에서 작동하기 때문에 CPU와 GPU 같은 리소스를 보다 효율적으로 사용할 수 있습니다.

Kubeflow는 데이터 과학자들이나 데이터 팀 같은 사용자가 작업을 실행할 수 있는 고유한 네임스페이스를 부여 할 수 있습니다. 이 네임스페이스는 보안과 리소스를 격리하는데 사용할 수 있습니다. 쿠버네티스 리소스 할당량을 사용하여, 플랫폼 관리자는 개인이나 팀에게 사용할 수 있는 리소스 양을 제한 할 수 있습니다.

Kubeflow에서 제공하는 주피터 노트북은 클러스터에서 직접 주피터 인스턴스를 생성할 수 있습니다. 그리고 생성된 주피터 인스턴스는 인증 및 접근 제어가 잘 통합되어 있기 때문에, 허락된 사용자가 아니면 접근할 수 없습니다.

주피터 노트북 생성하기

Kubeflow가 설치되었다면, 사용자는 Kubeflow의 중앙 대시보드를 활용하여 노트북을 실행할 수 있습니다.

왼쪽 메뉴에서 “Notebook Servers”를 클릭하여, 노트북 서비스 화면으로 이동할 수 있습니다.

노트북 서비스 화면으로 이동하면, 현재 선택된 네임스페이스 안에 생성된 노트북 서버 목록을 볼 수 있습니다.

“NEW SERVER” 버튼을 클릭하면, 새로운 노트북 서버의 생성 정보를 입력할 수 있는 페이지가 나타납니다.

“Name” 필드에 원하는 노트북 서버의 이름을 입력할 수 있습니다. 이름은 문자와 숫자를 사용 할 수 있고, 공백은 사용할 수 없습니다.

“Namespace” 필드에는 현재 선택되어 있는 네임스페이스 이름이 기본적으로 입력되어 있습니다.

“Image” 필드는 노트북 서버에서 사용할 주피터 컨테이너 이미지를 선택할 수 있습니다. 미리 제공되는 기본 이미지를 사용할 수도 있고, 사용자가 만든 커스텀 이미지도 사용할 수 있습니다.

다음은 미리 제공되는 기본 이미지 화면입니다.

기본 이미지 목록에는 텐스플로우 1.15.2 버전과 2.1.0이 포함된 노트북을 제공하고 있으며, CPU 버전과 GPU 버전을 나누어서 제공하고 있습니다.

GPU 이미지 사용하려면, 두 가지 조건이 만족되어야합니다.

첫번째는 Kubeflow가 설치된 쿠버네티스 클러스터에서 GPU를 사용할 수 있어야 합니다.

다음 명령어를 실행하면 쿠버네티스 클러스터에서 사용 가능한 nvidia GPU 갯수를 조회할 수 있습니다.

kubectl get nodes "-o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia\\.com/gpu"

사용 가능한 GPU 리소스가 있다면, 다음과 같은 응답 결과를 얻을 수 있습니다.

NAME     GPU
mortar   1

두번째는 입력 양식의 맨 아래에 있는 “GPUs” 부분에서 GPU를 할당해 주어야합니다. 당연히 사용 가능한 GPU가 있어야만 합니다.

커스텀 이미지 옵션을 선택하면, 사용할 이미지 주소를 직접 입력할 수 있습니다. 이미지 주소 형식은 “registry/image:tag” 입니다. 주피터 노트북의 커스텀 이미지를 생성하는 방법은 뒤에 나오는 “주피터 노트북 커스텀 이미지 생성하기“를 참고하시기 바랍니다.

참고로 Kubeflow에서 기본으로 제공하는 주피터 노트북 이미지는 https://console.cloud.google.com/gcr/images/kubeflow-images-public/GLOBAL 에서 조회해 볼 수 있습니다.

“CPU / RAM” 부분에서는 노트북 서버가 사용할 CPU와 메모리를 지정할 수 있습니다.

“Workspace Volume” 부분에서는 노트북 서버에서 사용할 개인 작업 공간 볼륨을 지정할 수 있습니다. Kubeflow는 쿠버네티스의 PV(영구 볼륨 : Persistent Volume) 사용하여 작업 공간 볼륨을 할당합니다. PV는 노트북 서버가 삭제되더라도 남아있기 때문에, 데이터를 유지할 수 있습니다.

“Type” 필드는 새로운 PV를 만들지, 기존에 존재하는 PV를 사용할지를 선택할 수 있게 해줍니다. “New”는 새로운 PV 생성을 의미하며, “Exsiting”은 기존 PV를 사용하다는 것을 의미합니다.

“Name” 필드는 PVC(PersistentVolumeClaim)의 이름입니다. 노트북 서버가 생성될 때, 해당 이름으로 PVC가 생성되고, 쿠버네티스의 동적 프로비저너(Dynamic Provisioner)에 의해서 PV가 생성되게 됩니다.

“Size” 필드는 볼륨의 크기입니다.

“Mode” 필드는 PV의 접근 모드(Access Mode) 입니다.

  • ReadWriteOnce : 단일 노드에서 볼륨을 읽기/쓰기로 마운트 할 수 있습니다
  • ReadOnlyMany : 복수개의 노드에서 볼륨을 읽기 전용으로 마운트 할 수 있습니다
  • ReadWriteMany : 복수개의 노드에서 볼륨을 읽기 / 쓰기로 마운트 할 수 있습니다

“Mount Point” 필드는 는 볼륨을 마운트할 경로입니다.

“Data Volumes” 부분에서는 필요에 따라, 데이터 볼륨을 추가 할 수 있습니다.

“Confiurations” 부분에서는 필요에 따라, PodDefault 라는 CR을 사용해서 추가 구성을 설정할 수 있습니다. 이 옵션을 사용하려면 PodDefault 리소스를 만들어야 합니다.

PodDefault는 환경 변수나 볼륨 등 공통 데이터를 포드(pod)에 주입하기 위해서 만들어진 Kubeflow CR 입니다.

다음은 team-secret 라는 볼륨을 마운트하는 PodeDefault 매니페스트 입니다.

apiVersion: "kubeflow.org/v1alpha1"
kind: PodDefault
metadata:
  name: add-team-secret
  namespace: admin
spec:
 selector:
  matchLabels:
    add-user-secret: "true"
 desc: "Add team credential"
 volumeMounts:
 - name: secret-volume
   mountPath: /secret/team
 volumes:
 - name: secret-volume
   secret:
    secretName: team-secret

PodDefault를 생성한 후, 노트북 서버 생성 화면을 새로 고치면 “Confiurations” 부분에서 나타는 것을 알 수 있습니다.

만약 이 “Add team credentail” 옵션을 선택해서 노트북 서버를 생성하게 되면, 노트북 서버의 포드에 아래 PodDefault에 정의한 부분이 반영됩니다.

다음은 “Add team credentail” 노트북 서버 포드의 일부분 입니다.

apiVersion: v1
kind: Pod
metadata:
  labels:
    add-user-secret: "true"
...
    volumeMounts:
    - mountPath: /secret/team
      name: secret-volume
...
  volumes:
  - name: secret-volume
    secret:
      defaultMode: 420
      secretName: team-secret
...

“GPUs” 부분에서는 노트북 서버에서 사용할 GPU 갯수를 설정할 수 있습니다.

“Miscellaneous Settings” 부분에서는 공유 메모리 활성화에 대한 설정을 변경할 수 있습니다. 기본값은 공유 메모리가 활성화 된 것입니다. PyTorch와 같은 일부 라이브러리는 멀티 프로세싱에 공유 메모리를 사용합니다. 현재 쿠버네티스에는 공유 메모리를 활성화시키는 방법이 없기 때문에, Kubeflow는 /dev/shm 라는 빈 디렉토리를 만듭니다.

맨 아래이 있는 “LAUNCH” 버튼을 클릭하면, 노트북 서버를 생성하기 시작하고, 노트북 서버 목록 페이지로 이동합니다. 목록 페이지의 “Status” 컬럼에 있는 상태 아이콘에 마우스 커서를 가져가면, 상태를 알 수 있니다.

노트북 서버를 생성하는데 몇 분이 걸릴 수 있습니다

좀 더 자세한 상태를 보고 싶으면, 포드를 이벤트를 조회해 보면 됩니다.

다음은 admin 이라는 네임스페이스의 rain 이라는 노트북 서버의 포드를 조회해 본 명령어입니다.

kubectl -n admin describe pod -l notebook-name=rain

다음과 같은 응답 결과를 얻을 수 있습니다.

...
Events:
  Type    Reason     Age    From               Message
  ----    ------     ----   ----               -------
  Normal  Scheduled  6m23s  default-scheduler  Successfully assigned admin/rain-0 to mortar
  Normal  Pulled     6m22s  kubelet, mortar    Container image "gcr.io/istio-release/proxy_init:release-1.3-latest-daily" already present on machine
  Normal  Created    6m22s  kubelet, mortar    Created container istio-init
  Normal  Started    6m22s  kubelet, mortar    Started container istio-init
  Normal  Pulling    6m21s  kubelet, mortar    Pulling image "gcr.io/kubeflow-images-public/tensorflow-1.14.0-notebook-cpu:v-base-ef41372-1177829795472347138"
  Normal  Pulled     5m44s  kubelet, mortar    Successfully pulled image "gcr.io/kubeflow-images-public/tensorflow-1.14.0-notebook-cpu:v-base-ef41372-1177829795472347138"
  Normal  Created    5m43s  kubelet, mortar    Created container rain
  Normal  Started    5m43s  kubelet, mortar    Started container rain
  Normal  Pulled     5m43s  kubelet, mortar    Container image "gcr.io/istio-release/proxyv2:release-1.3-latest-daily" already present on machine
  Normal  Created    5m43s  kubelet, mortar    Created container istio-proxy
  Normal  Started    5m43s  kubelet, mortar    Started container istio-proxy

노트북 서버 생성이 완료되면, 노트북 서버 목록 페이지에서 다음과 같은 화면을 볼 수 있습니다.

생성한 노트북 서버의 상태가 녹색 체크 표시 아이콘이면 정상적으로 만들어진것 입니다. 우측에 있는 “CONNECT” 버튼을 클릭하면, 노트북 서버에 접속할 수 있습니다.

다음은 노트북 서버에 접속한 화면입니다.

주피터 노트북 삭제하기

노트북 서버를 삭제하려면 노트북 서머 목록 페이지에서, 오른쪽 끝에 있는 휴지통 모양을 아이콘을 클릭하면 됩니다.

휴지통 아이콘을 클릭하면, 정말로 노트북 서버를 삭제할 것인지 물어봅니다. “DELETE” 버튼을 클릭하면, 노트북 서버는 삭제됩니다.

쿠버네티스에서 직접 삭제하고 싶으면, kubectl 사용해서 삭제하면 됩니다.

다음은 admin 이라는 네임스페이스의 rain 이라는 노트북 서버를 삭제하는 명령어입니다.

kubectl -n admin delete notebook rain

노트북 서버를 삭제해도, 생성한 PV는 삭제되지 않습니다. 더 이상 필요없는 PV는 kubectl을 사용해서 삭제하면됩니다. 엄밀히 말하면, PVC를 삭제하면 PV가 자동으로 삭제되기 때문에 PVC를 삭제하면 됩니다. 노트북 서버를 생성할때 입력한 볼륨 이름이 PVC 이름이기 때문에, 볼륨 이름을 기억하고 있어야합니다.

볼륨 이름이 기억나지 않는다면, 노트북 서버 목록 페이지의 볼륨 컬럼에서 확인할 수 있습니다. 볼륨 컬럼을 클릭하면, 볼륨 목록이 화면에 나타납니다.

다음은 기본값으로 생성한 rain 이라는 노트북 서버의 볼륨 목록입니다.

“workspace-rain”이라는 볼륨과 “dshm” 이라는 볼륨이 보입니다. “dshm”는 공유 메모리 때문에 사용하는 볼륨이기 때문에 따로 삭제하지 않아도 됩니다.

다음은 admin 이라는 네임스페이스의 workspace-rain 이라는 PVC를 삭제하는 명령어입니다.

kubectl -n admin delete pvc workspace-rain

PVC는 노트북 서버를 먼저 삭제한 후 삭제하는 것이 좋습니다. PVC를 사용하고 있는 노트북 서버가 있을 경우 삭제가 안되기 때문입니다. 정확히 말하면 “Terminating”에서 더이상 진행되지 않습니다. 만약 이런 경우가 발생하면, 해당 PVC를 사용하는 노트북 서버를 삭제하면 됩니다.

주피터 노트북에서 쿠버네티스 사용하기

Kubeflow의 Profile 을 이용해서 네임스페이스를 생성한 경우, 네임스페이스에는 default-editordefault-viewer 라는 두 개의 서비스 계정(ServiceAccount)이 만들어집니다. 이중에서 default-editor 라는 서비스 계정은 주피터 노트북 포드를 실행할 때 서비스 계정으로 사용됩니다. 이 서비스 계정은 kubeflow-edit 라는 클러스터롤(ClusterRole)이 바인딩되어 있으며, 여기에는 Pods, Deployments, Services, Jobs, TfJobs, PyTorchJobs 등의 많은 쿠버네티스 권한이 존재하고 있습니다.

다음은 kubeflow-edit 라는 클라서트롤이 가지고 있는 권한을 보는 명령어입니다.

kubectl describe clusterrole kubeflow-edit

그리고 Kubeflow에서 제공하는 기본 주피터 이미지에는 kubectl 이 포함되어 있습니다.

그래서 주피터 노트북에서 쿠버네티스 리소스를 사용할 수 있는 것입니다.

주피터에서 노트북을 하나 생성한 후, 노트북 셀에 다음 명령어를 실행해서 쿠버네티스 포드 목록을 조회할 수 있습니다.

!kubectl get pod

명령어를 입력한 후 shift + enter 를 누르면 셀을 실행 할 수 있습니다.

Kubeflow 소개

Kubeflow 살펴보기

Kubeflow는 머신 러닝을 위한 클라우드 네이티브(Cloud Native) 플랫폼입니다. 구글 내부에서 사용하던 머신 러닝 파이이프 라인을 기반으로 해서 만들어졌습니다. Kubeflow는 쿠버네티스(Kubernetes) 위에서 작동합니다. 그래서 자원 관리, 확장 등의 쿠버네티스의 장점을 그대로 이용할 수 있습니다.

다음은 Kubeflow 사이트(https://www.kubeflow.org/docs/about/kubeflow/)에 나와 있는 소개글을 번역한 내용입니다.

Kubeflow 프로젝트는 쿠버네티스에서 머신 러닝 워크 플로를 간단하고 이식 가능하며 확장 가능하게 구축하는 데 전념하고 있습니다. 우리의 목표는 다른 서비스를 재창조하는 것이 아니라 ML을위한 동급 최강의 오픈 소스 시스템을 다양한 인프라에 배포하는 간단한 방법을 제공하는 것입니다. 쿠버네티스를 실행하는 모든 곳에서 Kubeflow를 실행할 수 있어야합니다.

Kubeflow가 있다면, 주피터를 사용하여 모델을 개발할 수 있습니다. 그리고 페어링(fairing)과 같은 Kubeflow 도구를 사용하여, 컨테이너 이미지를 만들고, 쿠버네티스 자원을 활용하여 모델을 학습할 수 있습니다. 모델이 만들어지면 KFServing 같은 것을 사용하여 추론(inference)을 위한 서버를 만들고 배포할 수 있습니다.

이 글은 Kubeflow를 사용하여, 머신 러닝 관련 작업을 간단하고 효율적으로 사용하는 방법에 대해서 설명하고자 합니다.

머신 러닝 플랫폼

Hidden Technical Debt in Machine Learning Systems (https://papers.nips.cc/paper/5656-hidden-technical-debt-in-machine-learning-systems.pdf) 라는 논문에 아래와 같은 그림이 있습니다.

대부분의 사람들은 머신 러닝에 대해서 생각할때, 모델 코드를 만드는 것에 많은 시간을 보낸다고 생각하고 있습니다. 위의 그림에서 알 수 있듯이, 머신 러닝 시스템에서 모델 코드가 차지하는 비중은 얼마되지 않습니다.

실제로 머신 러닝 모델을 만들어서 서비스에 적용시키는 일은, 모델을 만드는 시간보다 데이터 수집과 분석 그리고 모델을 튜닝하는 등의 반복적인 작업이 더 많이 소모됩니다. 그래서 이러한 일련의 과정을 묶어서 파이프라인으로 구축하게됩니다. 하지만, 서비스가 많아지고, 파이프라인이 많아지면 시스템이 복잡해져서 유지보수가 힘들어지기 시작합니다. 이러한 이유로 머신 러닝 플랫폼이 필요하게 되는 것입니다.

Kubeflow를 사용하는 이유

Kubeflow는 쿠버네티스에서 머신 러닝 워크 플로를 실행하기 위해서 만들어졌습니다. 일반적으로 다음과 같은 이유로 사용할 수 있습니다.

  • 이미 쿠버네티스 기반의 인프라가 있거나, 새로운 머신 러닝 플랫폼을 만들려는 경우
  • 다양한 환경(예 : 로컬, 온 프레미스 및 클라우드)에서 머신 러닝 모델을 학습하거나 서비스하려는 경우
  • 자원(예 : CPU 또는 GPU)를 할당하여 작업을 하려는 경우
  • Jupyter 노트북을 사용하여 머신 러닝 작업을 하려는 경우

Kubeflow를 사용하면 데이터 과학자에게 인프라가 아닌 모델링에만 집중할 수 있는 환경을 제공해 줄 수 있습니다. 그리고 컨테이너 기반의 독립된 환경에서 연구를 할 수 있기 때문에, TensorFlow, PyTorch, MXNet 등 다양한 프레임워크를 사용할 수 있습니다. GPU 같은 자원을 이용해서 모델을 분산 학습 시킬 수 도 있습니다.

또한 Hyper parameter tuning 과정을 쉽게 자동화할 수 있는 기능도 제공하고 있으며, 만든 모델을 실제 서비스에 배포할 수 있는 서빙 도구들도 제공하고 있습니다.

Kubeflow 컴포넌트(Component)

Kubeflow의 대표적인 컴포넌트는 다음과 같습니다.

  • Kubeflow’s UI – Central Dashboard
  • Jupyter Notebooks
  • Metadata
  • Frameworks for Training
  • Hyperparameter Tuning : Katib
  • Pipelines
  • Tools for Serving
  • Profile

Central Dashboard

Kubeflow의 UI 화면으로서, Kubeflow의 구성 요소를 쉽게 접근할 수 있는 대시보드가 포함되어 있습니다.

대시보드에는 다음과 같은 기능이 포함되어 있습니다.

특정 작업에 대한 바로 가기, 최근 노트북 목록 및 파이프 라인 목록을 한 번에 볼 수 있습니다.

파이프라인, 노트북, Katib 등 클러스터에서 실행중인 컴포넌트 목록을 볼 수 있습니다.

Kubeflow UIs

대시보드에서 볼 수 있는 컴포넌트 목록은 다음과 같습니다.

  • Home : Kubeflow 대시보드로 이동합니다.
  • Pipelines : Kubeflow 파이프라인 대시보드로 이동합니다.
  • Notebook Servers : 주피터 노트북 목록 화면으로 이동합니다.
    • Katib : 하이퍼파라메터 튜닝을 하는 Katb 화면으로 이동합니다.
  • Artifact Store : 아티펙트 저장소 호면으로 이동합니다.
  • Manage Contributors : 쿠버네티스 네임스페이스에 접근할 수 있는 사용자를 관리할 수 있는 화면으로 이동합니다.

메타데이터 (Metadata)

Kubeflow에서 실행하는 머신 러닝 워크 플로우의 메타 데이터를 추적 및 관리하는데 사용합니다.

메타데이터 컴포넌트는 Kubeflow 사용자가 머신 러닝 워크 플로에서 생성하는 메타 데이터를 추적하고 관리함으로써, 머신 러닝 워크 플로를 이해하고 관리 할 수 ​​있도록 도와 줍니다.

Kubeflow v1.0 버전에 포함된 메타데이터 컴포넌트는 beta 상태입니다.

Jupyter Notebooks

Kubeflow에서 주피터 노트북을 사용할 수 있도록 도와줍니다.

주피터 노트북을 생성하고 관리 할 수 있는 기능을 제공합니다.

Frameworks for Training

Kubeflow에서 머신 러닝 모델을 학습할 수 있도록 도와줍니다.

Kubeflow에서 제공하는 학습 프레임워크는 다음과 같습니다.

  • Chainer Training
  • MPI Training
  • MXNet Training
  • PyTorch Training
  • TensorFlow Training (TFJob)

Hyperparameter Tuning : Katib

Kubeflow에서 머신 러닝 모델의 하이퍼 파라미터 튜닝을 할 수 있도록 도와줍니다.

Katib는 머신 러닝 모델의 하이퍼 파라미터 및 뉴럴 아키텍처(Neural Architecture)를 자동으로 튜닝할 수 있는 기능을 제공합니다. Katib는 TensorFlow, PyTorch, Apache MXNet, XGBoost 등 다양한 머신 러닝 프레임 워크를 지원합니다.

Kubeflow v1.0 버전에 포함된 메타데이터 컴포넌트는 beta 상태입니다.

Pipelines

Kubeflow 파이프라인은 컨테이너를 기반으로 확장 가능한 ent-to end 머신 러닝 워크 플로를 구축하기 위한 플랫폼입니다.

머신 러닝 파이프라인을 관리하는 기능을 제공하여 ent-to end 오케스트레이션을 지원합니다. 그리고 수 많은 아이디어와 기술을 시도할 수 있도록 시험(trials)과 실험(experiments)을 관리할 수 있는 기능도 제공합니다.

Tools for Serving

Kubeflow는 두 가지 모델 서빙 시스템인 KFServing과 Seldon Core를 사용할 수 있습니다. KFServing과 Seldon Core는 다중 프레임워크 모델 서빙을 지원합니다. 그리고 TensorFlow Serving와 NVIDIA TensorRT Inference Server 같은 독립형 모델 제공 시스템을 사용할 수 있습니다.

  • KFServing
  • Seldon Serving
  • NVIDIA TensorRT Inference Server
  • TensorFlow Serving

PC에 kubeflow 설치하기 – 3부 kubeflow 설치하기

Service Account Token Volume Projection 활성화

kubeflow에서는 인증/권한 기능을 위해서 istio 를 사용합니다. 그래서 istio-system 이라는 네임스페이스에 istio 관련 컴포넌트가 설치됩니다. 그 중에 하나인 istio-ingressgateway 포드의 내용을 보면 다음과 같은 부분을 발견할 수 있습니다.

...
  volumes:
  - name: istio-token
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          audience: istio-ca
          expirationSeconds: 43200
          path: istio-token
...

바로 Service Account Token Volume Projection 이라는 것입니다. 이 기능은 쿠버네티스 1.15에서 비활성화 되어 있습니다. 그래서 해당 기능을 사용하기 위해서는 활성화 해줘야 합니다.

기능을 활성화 하기 위해서는, 다음과 같이 kube-apiserver 매니페스트에 몇 가지 플래그를 추가해야합니다. 매니페스트 파일은 /etc/kubernetes/manifests/kube-apiserver.yaml에 위치합니다.

$ sudo vi /etc/kubernetes/manifests/kube-apiserver.yaml
...
        - --service-account-signing-key-file=/etc/kubernetes/pki/sa.key
        - --service-account-issuer=api
        - --service-account-api-audiences=api,vault

매니페스트 파일을 수정하고, kube-apiserver 포드가 자동으로 다시 시작됩니다.

dynamic volume provisioner 설치

kubeflow를 쉽게 설치하기 위해서는 동적 볼륨 프로비져너(dynamic volume provisioner)가 필요합니다. 이 글에는 로컬 디렉토리를 이용하는 Local Path Provisioner 를 사용하겠습니다.

다음은 Local Path Provisioner 를 설치하는 명령어입니다.

$ kubectl apply -f https://raw.githubusercontent.com/rancher/local-path-provisioner/master/deploy/local-path-storage.yaml

namespace/local-path-storage created
serviceaccount/local-path-provisioner-service-account created
clusterrole.rbac.authorization.k8s.io/local-path-provisioner-role created
clusterrolebinding.rbac.authorization.k8s.io/local-path-provisioner-bind created
deployment.apps/local-path-provisioner created
storageclass.storage.k8s.io/local-path created
configmap/local-path-config created

스토리지 클래스(storage class)를 조회해 보겠습니다.

$ kubectl get storageclass
NAME         PROVISIONER             AGE
local-path   rancher.io/local-path   63s

kubeflow는 기본 스토리지 클래스를 사용하기 때문에, local-path 스토리지 클래스를 기본 클래스로 설정해야합니다..

다음은 기본 스토리지 클래스를 설정하는 명령어입니다.

$ kubectl patch storageclass local-path -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'

storageclass.storage.k8s.io/local-path patched

다시 스토리지 클래스를 조회해 보면, 기본 클래스가 설정된 것을 확인할 수 있습니다.

$ kubectl get sc
NAME                   PROVISIONER             AGE
local-path (default)   rancher.io/local-path   11m

kubeflow 설치하기

kubeflow를 설치하기 위해서, kftctl 릴리즈 페이지에서 다운로드 합니다. 이 글을 쓰는 시점에서는 v1.0버전이 최신이므로, v1.0 버전을 기준으로 설명하겠습니다.

$ mkdir ~/kubeflow
$ cd ~/kubeflow

$ curl -L -O https://github.com/kubeflow/kfctl/releases/download/v1.0/kfctl_v1.0-0-g94c35cf_linux.tar.gz

다운 받은 tar ball 을 풉니다.

$ tar -xvf kfctl_v1.0-0-g94c35cf_linux.tar.gz

kubflow 배포를 쉽게 하기 위해서, 다음과 같은 환경 변수들을 생성합니다. 환경 변수들의 자세한 내용은 해당 페이지를 확인 하시기 바랍니다.

export PATH=$PATH:"/home/kangwoo/kubeflow"

export CONFIG_URI="https://raw.githubusercontent.com/kubeflow/manifests/v1.0-branch/kfdef/kfctl_istio_dex.v1.0.1.yaml"


export KF_NAME=kf-test

export BASE_DIR=/home/kangwoo/kubeflow
export KF_DIR=${BASE_DIR}/${KF_NAME}

kfctl_existing_arrikto.yaml 설정 파일을 가지고, kubeflow를 배포하겠습니다. 해당 파일에는 다중 유저와 권한/인증 기능을 지원하는 부분이 정의 되어 있습니다.

mkdir -p ${KF_DIR}
cd ${KF_DIR}

# Download the config file and change the default login credentials.
wget -O kfctl_istio_dex.yaml $CONFIG_URI
export CONFIG_FILE=${KF_DIR}/kfctl_istio_dex.yaml

kfctl apply -V -f ${CONFIG_FILE}

kfctl apply 명령어를 실행하면, kubeflow가 설치되기 시작합니다.

다음은 kubeflow 네임스페이스와, istio-system 네임스페이스의 포드를 조회해 본 것입니다.

$ kubectl -n kubeflow get pod
NAME                                                           READY   STATUS      RESTARTS   AGE
admission-webhook-deployment-7b7888fc9b-9dlj9                  1/1     Running     0          2d23h
application-controller-stateful-set-0                          1/1     Running     0          2d23h
argo-ui-7ffb9b6577-xqcxc                                       1/1     Running     0          2d23h
centraldashboard-6944c87dd5-sfqc7                              1/1     Running     0          2d23h
jupyter-web-app-deployment-679d5f5dc4-6278n                    1/1     Running     0          2d23h
katib-controller-7f58569f7d-62pgx                              1/1     Running     1          2d23h
katib-db-manager-54b66f9f9d-wsxv5                              1/1     Running     5          2d23h
katib-mysql-dcf7dcbd5-4fpmj                                    1/1     Running     0          2d23h
katib-ui-6f97756598-dk8fz                                      1/1     Running     0          2d23h
metadata-db-65fb5b695d-b92zm                                   1/1     Running     0          2d23h
metadata-deployment-65ccddfd4c-242t7                           1/1     Running     1          2d23h
metadata-envoy-deployment-7754f56bff-6vftm                     1/1     Running     0          2d23h
metadata-grpc-deployment-7557fdc6bb-n7jd7                      1/1     Running     7          2d23h
metadata-ui-7c85545947-wwkh9                                   1/1     Running     0          2d23h
minio-69b4676bb7-zglc6                                         1/1     Running     0          2d23h
ml-pipeline-5cddb75848-tjbh9                                   1/1     Running     1          2d23h
ml-pipeline-ml-pipeline-visualizationserver-7f6fcb68c8-pw529   1/1     Running     0          2d23h
ml-pipeline-persistenceagent-6ff9fb86dc-ghj74                  1/1     Running     3          2d23h
ml-pipeline-scheduledworkflow-7f84b54646-mztnf                 1/1     Running     0          2d23h
ml-pipeline-ui-6758f58868-qc72b                                1/1     Running     0          2d23h
ml-pipeline-viewer-controller-deployment-745dbb444d-2xwdn      1/1     Running     0          2d23h
mysql-6bcbfbb6b8-6qb6p                                         1/1     Running     0          2d23h
notebook-controller-deployment-54f455c5c9-rpv8s                1/1     Running     0          2d23h
profiles-deployment-6fcb86d54c-9pdrs                           2/2     Running     0          2d23h
pytorch-operator-cf8c5c497-lntsm                               1/1     Running     0          2d23h
seldon-controller-manager-6b4b969447-b4gcj                     1/1     Running     0          2d23h
spark-operatorcrd-cleanup-knfpw                                0/2     Completed   0          2d23h
spark-operatorsparkoperator-76dd5f5688-2689x                   1/1     Running     0          2d23h
spartakus-volunteer-5dc96f4447-6ss4g                           1/1     Running     0          2d23h
tensorboard-5f685f9d79-7d8kp                                   1/1     Running     0          2d23h
tf-job-operator-5fb85c5fb7-vxkgv                               1/1     Running     0          2d23h
workflow-controller-689d6c8846-lmmdz                           1/1     Running     0          2d23h
k -n istio-system get pod
NAME                                                         READY   STATUS      RESTARTS   AGE
authservice-0                                                1/1     Running     0          2d23h
istio-citadel-79b5b568b-kqjw9                                1/1     Running     0          3d
istio-galley-756f5f45c4-kxkhr                                1/1     Running     0          3d
istio-ingressgateway-77f74c944c-z5frv                        1/1     Running     0          3d
istio-nodeagent-478g7                                        1/1     Running     0          3d
istio-nodeagent-rmbc5                                        1/1     Running     0          3d
istio-nodeagent-z49bb                                        1/1     Running     0          3d
istio-pilot-55f7f6f6df-k5mdm                                 2/2     Running     0          3d
istio-policy-76dbd68445-vskkp                                2/2     Running     0          3d
istio-security-post-install-release-1.3-latest-daily-2j5tr   0/1     Completed   0          3d
istio-sidecar-injector-5d9f474dcb-l5qjj                      1/1     Running     0          3d
istio-telemetry-697c8fd794-9hz9q                             2/2     Running     0          3d
prometheus-b845cc6fc-d7cq6                                   1/1     Running     0          3d

kubeflow 접속하기

kubeflow GUI에 접속해 보겠습니다. istio-ingressgateway 를 통해서 접속합니다. 여기서는 편의를 위해서 노드 포트(NodePort)를 사용하겠습니다.

다음은 istio-ingressgateway 서비스를 조회해 본 결과입니다.

$ kubectl -n istio-system get service istio-ingressgateway
NAME                   TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)                                                                                                                                      AGE
istio-ingressgateway   NodePort   172.30.86.239   <none>        15020:30113/TCP,80:31380/TCP,443:31390/TCP,31400:31400/TCP,15029:31134/TCP,15030:31251/TCP,15031:32398/TCP,15032:30455/TCP,15443:32764/TCP   3d

서비스 타입이 NodePort 이고, 80번 포트가 31380이라는 노드 포트로 열려있습니다. 브라우저를 실행하고, 해당 포트로 접속해보겠습니다.

기본 설정을 바꾸지 않았다면, 사용자 이름은 admin@kubeflow.org 이고, 비밀번호는 12341234 입니다.

로그인이 성공적으로 되면, 다음과 같이 사용할 네임스페이스를 생성하는 화면이 나옵니다. 원하는 이름을 입력하시면 됩니다. 기본값을 admin 으로 되어있습니다.

네임스페이스가 생성되면, kubeflow 대시보드 화면을 볼 수 있습니다.

참고

PC에 kubeflow 설치하기 – 2부 kubernetes, nvidia device-plugin 설치하기

swap 비활성화 하기

쿠버네티스(kubernetes)를 설치 하기 위해서 swap을 비활성화 합니다.

$ sudo swapoff -a

그리고 재부팅 하였을때 swap이 다시 활성화되는 것을 막기 위해서, /etc/fstab 에 있는 swap 관련 부분을 주석 처리하거나, 제거해 줍니다.

$ sudo vi /etc/fstab
 
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
/dev/mapper/ubuntu--vg-root /               ext4    errors=remount-ro 0       1
# /boot/efi was on /dev/nvme0n1p1 during installation
UUID=D21A-9B89  /boot/efi       vfat    umask=0077      0       1
# /dev/mapper/ubuntu--vg-swap_1 none            swap    sw              0       0

iptables 설치하기

iptables을 설치하고, 필요에 따라서 iptables tooling을 legacy 모드로 변경합니다.

# ensure legacy binaries are installed
$ sudo apt-get install -y iptables arptables ebtables

# switch to legacy versions
sudo update-alternatives --set iptables /usr/sbin/iptables-legacy
sudo update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy
sudo update-alternatives --set arptables /usr/sbin/arptables-legacy
sudo update-alternatives --set ebtables /usr/sbin/ebtables-legacy

kubelet, kubeadm, kubectl 설치하기

쿠버네티스 설치에 필요한 kubelet, kubeadm, kubectl을 설치합니다. 버전을 명시해 주지 않으면, 최선 버전으로 설치됩니다. kubeflow 문서에 따르면 현재 권장하는 쿠버네티스 버전은 1.14 입니다. 1.15 버전도 호환이 되기 때문에, 이 글에서는 1.15.10-00 버전으로 설치 하였습니다.

$ sudo apt-get update && sudo apt-get install -y apt-transport-https curl
$ curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
$ cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF
$ sudo apt-get update
$ sudo apt-get install -y kubelet=1.15.10-00 kubeadm=1.15.10-00 kubectl=1.15.10-00
$ sudo apt-mark hold kubelet kubeadm kubectl

쿠버네티스 설치하기

kubeadm을 사용해서 쿠버네티스를 설치합니다. 포드 네트워크 애드온을 cilium을 사용할 것이기 때문에 --pod-network-cidr=10.217.0.0/16 옵션을 사용하겠습니다.

다음 명령어를 실행해서 쿠버네티스를 설치합니다.

$ sudo kubeadm init --pod-network-cidr=10.217.0.0/16

설치가 완료되면, kubectl을 사용하기 위해서 관리자 설정 파일을 유저 디렉토리로 복사합니다.

$ mkdir -p $HOME/.kube
$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
$ sudo chown $(id -u):$(id -g) $HOME/.kube/config

쿠버네티스 접속을 테스트 하기 위해서, 다음 명령어를 실행합니다.

$ kubectl cluster-info
Kubernetes master is running at https://192.168.21.36:6443
KubeDNS is running at https://192.168.21.36:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

이제 Cilium을 쿠버네티스에 설치합니다.

$ kubectl create -f https://raw.githubusercontent.com/cilium/cilium/v1.6/install/kubernetes/quick-install.yaml

cilim 포드의 READY가 1/1이 되면, 쿠버네티스 클러스터를 사용할 수 있습니다.

$ kubectl get pods -n kube-system --selector=k8s-app=cilium
NAME           READY   STATUS    RESTARTS   AGE
cilium-k4l5b   1/1     Running   0          70s

Control plane 노드 격리 해제하기

기본적으로 쿠버네티스 클러스터의 컨트롤 플레인(control-plane) 노드에는 보안상의 이유로 노드가 격리되어 있어서, 포드가 스케줄링되지 않습니다. 이 문서에는 1대의 머신만을 사용하기 때문에 노드 격리를 해제하겠습니다.

다음 명령어로 노드 격리를 해제 시킵니다.

$ kubectl taint nodes --all node-role.kubernetes.io/master-
node/mortar untainted

nvidia plugin 설치하기

쿠버네티스에서 GPU를 사용하기 위해서, nvidia k8s-device-plugin 을 설치합니다. 이 문서를 작성하는 시점에서는 1.12가 최신버전이라서 1.12로 설치하겠습니다.

$ kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml

daemonset.extensions/nvidia-device-plugin-daemonset-1.12 created

참고로, 쿠버네티스 1.15 버전을 설치했을 경우에는 문제가 없을 건데, 1.16 버전 이상을 설치 했을 경우, 다음과 같은 에러가 발생할 것입니다. 자세한 사항은 해당 페이지를 참고 바랍니다.

error: unable to recognize "https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml": no matches for kind "DaemonSet" in version "extensions/v1beta1"

쿠버네티스 버전이 올라가면서, Daemonsetextensions/v1beta1 버전을 더 이상 지원하지 않아서 입니다. 버전을 apps/v1 으로 변경하고 selector를 추가한 후, k8s-device-plugin 을 다시 설치합니다.

다음은 변경한 1.17 버전에 맞게 변경한 메니페스트 파일입니다.

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nvidia-device-plugin-daemonset-1.12
  namespace: kube-system
spec:
  updateStrategy:
    type: RollingUpdate
  selector:
    matchLabels:
      name: nvidia-device-plugin-ds
  template:
    metadata:
      # Mark this pod as a critical add-on; when enabled, the critical add-on scheduler
      # reserves resources for critical add-on pods so that they can be rescheduled after
      # a failure.  This annotation works in tandem with the toleration below.
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ""
      labels:
        name: nvidia-device-plugin-ds
    spec:
      tolerations:
      # Allow this pod to be rescheduled while the node is in "critical add-ons only" mode.
      # This, along with the annotation above marks this pod as a critical add-on.
      - key: CriticalAddonsOnly
        operator: Exists
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule
      containers:
      - image: nvidia/k8s-device-plugin:1.11
        name: nvidia-device-plugin-ctr
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop: ["ALL"]
        volumeMounts:
          - name: device-plugin
            mountPath: /var/lib/kubelet/device-plugins
      volumes:
        - name: device-plugin
          hostPath:
            path: /var/lib/kubelet/device-plugins
EOF

device-plugin 포드가 정상적으로 작동했는지 확인해 봅니다.

$ kubectl -n kube-system get pod -l name=nvidia-device-plugin-ds
NAME                                        READY   STATUS    RESTARTS   AGE
nvidia-device-plugin-daemonset-1.12-4kt95   1/1     Running   0          24s

$ kubectl -n kube-system logs  -l name=nvidia-device-plugin-ds
2020/02/09 09:05:10 Loading NVML
2020/02/09 09:05:10 Fetching devices.
2020/02/09 09:05:10 Starting FS watcher.
2020/02/09 09:05:10 Starting OS watcher.
2020/02/09 09:05:10 Starting to serve on /var/lib/kubelet/device-plugins/nvidia.sock
2020/02/09 09:05:10 Registered device plugin with Kubelet

GPU 테스트 하기

다음은 텐서플로를 이용해서, GPU를 테스트 해 보는 예제입니다. 단순한 테스트이기 때문에 무시하고 넘어가도 됩니다.

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: tf-gpu-jupyter
  name: tf-gpu-jupyter
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: tf-gpu-jupyter
  template:
    metadata:
      labels:
        app: tf-gpu-jupyter
    spec:
      containers:
      - image: tensorflow/tensorflow:2.1.0-gpu-py3-jupyter
        imagePullPolicy: IfNotPresent
        name: tf-gpu-jupyter
        ports:
        - containerPort: 8888
          protocol: TCP
        resources:
          limits:
            nvidia.com/gpu: "1"
EOF

tf-gpu-jupyter 라는 이름을 가진 GPU를 사용할 수 있는 텐서플로 주피터(jupyter)를 생성하였습니다. 포드가 정상적으로 작동했는지 확인해 봅니다.

$ kubectl get pod -l app=tf-gpu-jupyter
NAME                              READY   STATUS    RESTARTS   AGE
tf-gpu-jupyter-66f89b64cd-vrllc   1/1     Running   0          5m58s

주피터 접속에 필요한 토큰 정보를 얻기 위해서 로그를 조회해 보겠습니다.

$ kubectl logs -l app=tf-gpu-jupyter
[I 09:15:25.009 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 09:15:25.012 NotebookApp] 
    
    To access the notebook, open this file in a browser:
        file:///root/.local/share/jupyter/runtime/nbserver-1-open.html
    Or copy and paste one of these URLs:
        http://tf-gpu-jupyter-66f89b64cd-vrllc:8888/?token=6527214998b8d895f6f14a8901a39ba6d8420c43e68f6919
     or http://127.0.0.1:8888/?token=6527214998b8d895f6f14a8901a39ba6d8420c43e68f6919
[I 09:17:20.916 NotebookApp] 302 GET / (127.0.0.1) 0.53ms
[I 09:17:20.926 NotebookApp] 302 GET /tree? (127.0.0.1) 0.65ms

포드에 접속하기 위해서 port-forward를 사용하겠습니다.

$ kubectl port-forward pod/tf-gpu-jupyter-66f89b64cd-vrllc 8888:8888
Forwarding from 127.0.0.1:8888 -> 8888
Forwarding from [::1]:8888 -> 8888

kubectl delete deployment tf-gpu-jupyter
deployment.apps "tf-gpu-jupyter" deleted

포트 포워드가 활성화 되면, 브라우저에서 주피터 주소를 입력합니다. 포드 로그에서 봤던 주소를 입력하면 됩니다. 이 예제에서 주소는 http://127.0.0.1:8888/?token=6527214998b8d895f6f14a8901a39ba6d8420c43e68f6919 입니다.

정상적으로 접속이 되면, 다음과 같은 화면을 보실 수 있습니다.

사용 가능한 GPU 갯수를 확인하겠습니다. 파이썬3 노트북을 생성한 후, 다음 코드를 입력합니다.

from __future__ import absolute_import, division, print_function, unicode_literals

import tensorflow as tf
print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))

코드를 실행하면 다음과 같이 사용 가능한 GPU 개수가 출력될 것입니다.

확인을 다 했으면, 브라우저를 종료하고, 자원 낭비를 막기 위해서 디플로이먼트를 삭제하도록 하겠습니다. 우리의 GPU는 소중하니까요.

$ kubectl delete deploy tf-gpu-jupyter

참고

  • https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/
  • https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/
  • https://github.com/NVIDIA/k8s-device-plugin
  • https://hub.docker.com/r/tensorflow/tensorflow/
  • https://www.tensorflow.org/guide/gpu

PC에 kubeflow 설치하기 – 1부 nvidia 드라이버, docker 설치하기

이 글은 지적 유희를 위해서 작성하였습니다. kubeflow 자체가 목적이신 분들은, miniKFGCP를 사용하시길 추천드립니다.

시스템 사항

다음은 이 글에서 사용한 PC의 사양입니다. kubeflow를 원활하게 설치하기 위해서는 램이 16GB 이상, CPU는 4코어 이상을 추천합니다. GPU를 사용하기 위해서 nvidia 그래픽 카드도 필요합니다.

프로세서amd 라이젠 5 3600
RAM32GB
그래픽 카드RTX-2060
스토리지 공간 다다익선

설치 목록

  • ubuntu 18.04 LTS
  • nvidia driver 435
  • docker CE 18.9
  • nvidia-docker2
  • kubernetes 1.15.10
  • cilium 1.6
  • nvidia-device-plugin-daemonset 1.12
  • kubeflow 1.0RC4 with istio 1.3

전체 목록

우분투 설치하기

우분투는 데스크탑 18.04 LTS 버전을 사용합니다. 설치 방법은 다른곳에 많이 나와있기 때문에 생략합니다. 다만 nvidia 그래픽 카드를 사용할 경우 문제가 생기기 때문에, 그 부분만 다루겠습니다.

nvidia driver 설치하기

우분투 18.04 환경에서 RTX-2060을 사용할 경우 nouveau 문제가 있습니다. RTX-2060가 장착되어 있는 장비에서 우분투를 설치할 경우 nouveau로 자동 설정되기 때문이다. 그래서 nouveau 를 제거하는 작업이 필요합니다.

우분투 설치 화면이 깨져서 보이지 않는다면, 설치 전에 nomodset 옵션을 추가해줘야 정상적인 화면을 볼 수 있습니다.

우분투를 설치 하기 전 GRUB 메뉴 화면에서 e 키를 누룹니다.

e 키를 누르면, 다음과 같이 파라메터를 편집할 수 있는 화면이 나옵니다.

quiet splash 뒤에 nomodeset 을 추가해 줍니다. 그리고 F10 키를 눌러서 부팅 합니다.

정상적으로 화면이 보일 것입니다. 우분투를 설치하는 나머지 과정은 생략하겠습니다.

nouveau 설치 확인 하기

우분투가 정상적으로 설치되었다면, 재부팅 후 nouveau 확인 작업을 합니다. 시스템이 다시 시작되면, 앞서 한 것과 동일한 방법으로, nomodset 옵션을 추가해줘야 정상적인 화면을 볼 수 있을것입니다.

부팅이 완료되면 터미널을 열어서 작업을 시작합니다.

터미널에서 다음 명령어를 실행한 후, 결과가 보이면 nouveau가 설치되어 있는 것입니다. nvidia 드라이버 설치를 위해서 제거해야 합니다.

$ lsmod | grep nouveau
nouveau              1863680  0
mxm_wmi                16384  1 nouveau
video                  49152  1 nouveau
i2c_algo_bit           16384  1 nouveau
ttm                   102400  1 nouveau
drm_kms_helper        180224  1 nouveau
drm                   479232  3 drm_kms_helper,ttm,nouveau
wmi                    28672  3 wmi_bmof,mxm_wmi,nouveau

/etc/modprobe.d/ 경로에 blacklist 파일을 생성합니다.

$ sudo vi /etc/modprobe.d/blacklist-nouveau.conf

blacklist nouveau
options nouveau modset=0

다음 명령어를 실행 한 후, 재부팅 합니다.

$ sudo update-initramfs -u
$ sudo service gdm stop

Nvidia 드라이버 설치하기

컨테이너(Container)를 이용해서 GPU를 사용할 예정이기 때문에, Nvidia 드라이버가 설치합니다.

$ sudo add-apt-repository ppa:graphics-drivers/ppa
$ sudo apt-get update

$ sudo apt-get install nvidia-driver-435
$ sudo reboot

재부팅 후, nvidia-smi 명령어를 실행해서, 드라이버가 정상적으로 설치되어 있는지 확인해 볼 수 있습니다.

$ nvidia-smi
Sun Feb 16 17:26:22 2020       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 435.21       Driver Version: 435.21       CUDA Version: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce RTX 2060    Off  | 00000000:26:00.0  On |                  N/A |
| 32%   45C    P8     9W / 190W |    189MiB /  5931MiB |      1%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0       975      G   /usr/lib/xorg/Xorg                            96MiB |
|    0      1123      G   /usr/bin/gnome-shell                          91MiB |
+-----------------------------------------------------------------------------+

docker 설치하기

apthttps저장소를 사용할 수 있도록 패키지를 추가합니다.

$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

도커의 GPG 키를 추가합니다.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

저장소를 추가합니다

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

apt 패키지의 인덱스를 업데이트합니다.

$ sudo apt-get update

이 문서를 작성할 당시(2020-02-08)에 도커의 최선 버전은 19.03이였습니다. 19.03 버전 부터 GPU 관련한 내용이 변경되었습니다. 쿠버네티스상에서 GPU 관련 작업을 하라면, k8s-device-plugin이 필요한데, 아직 19.03 버전을 지원하지 않는 것 같습니다. 그래서 18.9 버전을 설치하였습니다.

도커 엔진 18.9 버전을 설치합니다.

$ sudo apt-get install docker-ce=5:18.09.9~3-0~ubuntu-bionic docker-ce-cli=5:18.09.9~3-0~ubuntu-bionic containerd.io

$ sudo apt-mark hold docker-ce docker-ce-cli

설치 가능한 도커 버전을 보려면 다음 명령어를 실행하면 됩니다.

$ apt-cache madison docker-ce
 docker-ce | 5:19.03.5~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:19.03.4~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:19.03.3~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:19.03.2~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:19.03.1~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:19.03.0~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:18.09.9~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:18.09.8~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
 docker-ce | 5:18.09.7~3-0~ubuntu-bionic | https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages
...

도커가 정상적으로 설치되었는지 확인해 보기 위해서 hello-world 이미지를 실행합니다.

$ sudo docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete 
Digest: sha256:9572f7cdcee8591948c2963463447a53466950b3fc15a247fcad1917ca215a2f
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.
...

nvidia-docker2 설치하기

컨테이너에서 GPU를 사용하기 위해서 nvidia-docker2 을 설치합니다. 그리고 도커를 재시작 합니다.

# Add the package repositories
$ distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
$ curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
$ curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

$ sudo apt-get update
$ sudo apt-get install nvidia-docker2
$ sudo systemctl restart docker

nvidia-docker2 가 정상적으로 설치되었는지 확인해 보기 위해서, 다음 명령어를 실행합니다.

$ sudo docker run --runtime nvidia nvidia/cuda:10.0-base nvidia-smi
Sat Feb  8 11:19:15 2020       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 435.21       Driver Version: 435.21       CUDA Version: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce RTX 2060    Off  | 00000000:26:00.0  On |                  N/A |
| 29%   40C    P8     9W / 190W |    229MiB /  5931MiB |      1%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

도커의 기본 런타임을 변경해 줍니다. /etc/docker/daemon.json 파일이 생성되었을 것입니다. 해당 파일을 열여서 "default-runtime": "nvidia"을 추가해주면 됩니다.

$ sudo vi /etc/docker/daemon.json

    {
      "default-runtime": "nvidia", 
      "runtimes": {
        "nvidia": {
          "path": "nvidia-container-runtime",
          "runtimeArgs": []
        }
      }
    }

파일을 수정한 후, 도커를 재시작합니다.

$ sudo systemctl restart docker

참고

  • https://docs.docker.com/install/linux/docker-ce/ubuntu/
  • https://github.com/NVIDIA/nvidia-docker