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.

댓글 남기기

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