들어가기 전에 (나의 이야기)
"개발자가 되어야 겠다"고 생각하게 된 가장 첫 계기를 거슬러 올라가면 인공지능이었다. AI가 가져올 미래에 매료되었고 부스트코스 강의를 통해서 파이썬을 배우고 수학을 배우고 머신러닝 예제를 따라하며 시작했다. 재미있고 흥미진진한(?) 경험이었다. 커리어적인 무언가를 구체적으로 구상하며 그랬던 것은 아니고 오로지 재밌어보이고 관심이 있어서 시작했다. 지금 MLOps 주제를 다루게 된 것도 마찬가지로 순전히 흥미와 알고싶다는 마음으로 시작되었다.
이전에 머신러닝/딥러닝 예제들을 진행하면서 학습에 필요한 이 데이터들은 어떻게 관리하는지, 하다못해 간단한 예제 모델을 돌리는 데에도 여러번 실험해야 했는데 현업에서는 더 많은 실험을 하고 모델 훈련이 필요할텐데 그 수많은 실험의 결과들은 어떻게 관리하고 최적화하는 거지?라는 의문점을 가졌다. 요번 MLOps 과정을 통해 과거에 가졌던 의문점을 풀어나가는 실마리가 되었다.
MLOps 개요
참고: 개발자 커뮤니티 SQLER.com - MLaaS - 12가지의 머신러닝을 먼저 도입한 기업들의 고민
MLOps란 Machine Learning Operations의 줄임말로, 머신러닝 모델의 개발과 운영을 관리하고 자동화하는 접근 방식이다. 이전 편까지 DevOps를 살펴보고 CI/CD를 구축하는 단계를 진행했다. 이러한 전통적인 소프트웨어 개발의 DevOps 원칙에 머신러닝에 필요한 요구사항을 통합한 것이 MLOps의 핵심이다.
위 이미지를 참고하여 기존의 머신러닝 개발 패턴을 살펴보면,
- 데이터 준비
- 모델 빌드
- 모델 학습 & 테스트
- 모델 등록 및 관리
- 이미지 빌드
- 서비스로 배포
의 단계를 거친다고 나와있다. 하지만 머신러닝 작업이 변화하고 고도화되면서 이 패턴에서 여러 요구사항이 생겨났다.
MLOps 왜 필요한가 + DevOps와의 차이점
MLOps의 필요성은 곧 기존의 머신러닝 개발 패턴에서 어떤 문제점이 있는가를 살펴보면 된다. 자세한 내용이 위에서 첨부한 개발자 커뮤니티 SQLER.com - MLaaS - 12가지의 머신러닝을 먼저 도입한 기업들의 고민의 링크에 아주 자세히 나와있다.
나의 시각에서 DevOps와 MLOps 프로젝트를 진행하면서 느낀 점을 토대로, 둘의 차이점과 MLOps의 필요성을 정리해 핵심 네 가지만 뽑아보자면 다음과 같다.
-
DevOPs보다 더 복잡한 ML 라이프사이클
머신러닝의 라이프사이클은 기존의 소프트웨어 개발 라이프사이클보다 더 복잡하다. 머신러닝 프로젝트에는 데이터와 모델이라는 두 가지 중요한 구성 요소가 포함되기 때문이다. 그에 따라 데이터 수집, 데이터 전처리, 모델 설계, 모델 훈련, 모델 검증 등과 같은 단계가 필요하며, 각 단계마다 복잡한 의존성과 파라미터를 갖는다. 이를 자동화 없이 관리하고 사람이 일일이 기록을 남긴다면 어떻겠는가? -
데이터 의존성이 크다
DevOps는 코드와 인프라에 중점을 둔다. 반면 MLOps의 데이터는 머신러닝의 핵심 구성 요소이며, 데이터의 품질과 처리는 모델의 성능에 큰 영향을 미친다. MLOps는 이러한 데이터 관리와 버전 관리를 포함해야 한다. -
모델의 유지 및 최적화가 중요하다
DevOps는 어플리케이션의 성능 모니터링과 최적화에 중점을 둔다. MLOps는 이에 더하여 모델의 성능도 중요하게 다룬다. 다양한 데이터로 여러 번 모델 훈련이 진행되어야 하며, 이후에도 성능이 저하되지 않도록 지속적인 모델 모니터링이 필요하다. -
재현할 수 있어야 한다
DevOps는 코드의 재현성에 중점을 둔다. MLOps는 데이터, 코드, 하이퍼파라미터 등 여러 가지 요소의 재현성이 중요하다. 모델의 결과를 설명하고 재현할 수 있어야 하기 때문이다. 그를 위해서는 하이퍼파라미터, 데이터 정보 등 모든 것이 기록되어야 하고 한 눈에 볼 수 있어야 한다. -
다양한 역할의 협업
머신러닝 프로젝트에는 데이터 과학자, 데이터 엔지니어, ML 엔지니어, 운영 팀 등 더 다양한 역할 간의 협업이 필요하다. 기존보다 더 많은 역할이 앞서 말한 복잡한 ML 라이프 사이클 안에서 원활히 협업해야 한다고 상상해본다면?
MLOps 프로젝트를 경험하며, 머신러닝 프로젝트는 기존의 소프트웨어 개발과 다른 특수한 요구사항이 존재하고, 복잡하고, 그에 따라 관리해야 할 데이터가 더 많겠다는 인상을 받았다. MLOPs는 이런 머신러닝 라이프사이클 각 단계의 최적화와 파이프라인 필요성에서 탄생했다.
위의 5가지 MLOps의 필요성(= MLOps를 통해 얻을 수 있는 이점)을 언급했는데, Azure 머신러닝을 통해 특히 느꼈던 점은 클라우드 MLOps 서비스가 대시보드 역할을 해주면서 각종 머신러닝 데이터, metric 관리가 쉽고 간편하게 모니터링 할 수 있다는 점이었다.
MLOps 과정
두 가지 방법으로 나누어 MLOps를 구현한다. 둘 다 Microsoft Azure를 사용한다. 각 방법의 절차를 간단히 설명하면 다음과 같다.
- Azureml examples 튜토리얼 따라하기
- 모델을 훈련시키고
- 모델을 배포하고
- 데이터 전처리 + 모델 학습 파이프라인을 생성한다
- Azure mlops v2 저장소 가이드 따라하기
MLOps 구현하기 1: Azureml examples 튜토리얼 따라하기 (모델 훈련시키기)
Azureml examples 튜토리얼 실행 환경 세팅하기
tutorials/get-started-notebooks/train-model.ipynb 노트북을 실행한다. 전체 MLaas 동작 과정을 담고 있는 튜토리얼이다. 이를 실행하기 위해서 conda 가상환경도 설정하고 jupyter 노트북을 설치해보자.
- 콘다 가상환경 만들고 실행시키기 (맨날 까먹음)
conda create -n <가상환경-이름> python=n.n
conda activate <가상환경-이름>
- 주피터 노트북 설치하기
conda install jupyter
- 주피터 노트북 실행하기
jupyter notebook
그러면 아래와 같은 주소가 뜰 텐데, 클릭하여 접속하면 프로젝트 폴더를 루트로 하는 디렉토리가 생긴다. 노트북을 실행하여 작업하면 된다.
그러면 이제 해야 할 일은… 튜토리얼을 차근차근 읽어보면서 따라해보는 것이다!
모델 훈련시키기
데이터 사이언티스트가 Azure 머신러닝을 이용하여 모델을 훈련시키는 방법을 알아볼 것이다. 신용 카드 데이터셋을 이용해 분류 문제를 해결한다. 고객이 신용 카드 결제금액을 갚지 못할 가능성이 얼마나 되는지 알아보는 문제이다.
훈련을 위한 스크립트 데이터 준비를 처리하고, 그다음 모델을 훈련하고 등록한다. 이 튜토리얼은 클라우드 기반 트레이닝 잡(커맨드 잡)을 이용한다. 즉, 클라우드의 기능을 사용하는데 파이썬 코드로만 처리한다.
이 튜토리얼은 다음의 단계로 이루어져있다.
- Azure 머신러닝 워크스페이스에 대한 핸들 가져오기
- 컴퓨팅 리소스(또는 간단히 서버리스 컴퓨팅 사용) 및 작업 환경 만들기
- 훈련 스크립트 만들기
- 적절한 작업 환경 및 데이터 소스로 구성된 컴퓨팅 리소스에서 훈련 스크립트를 실행하는 명령 작업을 만들고 실행한다.
- 훈련 스크립트의 출력 보기
- 새로 학습된 모델을 엔드포인트로 배포하기
- 추론을 위해 Azure 머신러닝 엔드포인트 호출
[!NOTE] Azure 머신러닝에서 말하는 Job이란?
Azure 머신러닝에서 모델을 학습시키기 위해서는 job이라는 것을 제출해야 한다. 이 튜토리얼에서 우리가 제출할 종류의 job은 command job이다. 따라서 훈련 스크립트를 동작시키기 위해 어떻게 커맨드 잡을 제출해야 하는지를 배울 것이다.
Azure 머신러닝은 모델을 학습시키기 위해 여러가지 job을 제공한다. 유저는 모델 훈련 방법을 해당 모델의 복잡도, 데이터 크기, 훈련 속도 요구사항에 따라 선택할 수 있다.
커맨드 잡이란 유저가 모델을 학습시키기 위해 작성한 훈련 스크립트를 제출할 수 있도록 해주는 기능을 말한다. 커스텀 훈련 잡이라고도 부를 수 있다. 커맨드 잡은 특정 환경에서 스크립트나 명령어를 실행하는 잡을 말한다. 커맨드 잡을 이용하여 모델을 훈련시키고, 데이터를 처리하고, 그밖에 다른 클라우드에서 실행하고자 하는 코드를 처리하기 위해 사용할 수 있다.
워크스페이스 핸들 생성하기
워크스페이스를 핸들링하기 위해 ml_client라는 것을 생성할 것이다. 이 ml_client를 이용해 리소스와 잡을 관리한다. Azure 머신러닝 서비스의 단위를 워크스페이스라고 하며 일종의 레고 판 역할을 한다.
이를 위해서는 구독 ID와 리소스 그룹 이름, 워크스페이스 이름이 필요하다.
-
구독 ID 값 얻기
Azure 포털 > 구독 > 구독 ID -
리소스 그룹 생성하기
DevOps를 진행했던 리소스 그룹과 구분하기 위해 새로운 리소스 그룹을 만들었다. -
워크스페이스 생성하기
Azure 포털 > Azure Machine Learning > 만들기 > 새 작업 영역(workspace)
방금 만든 리소스 그룹을 선택하고, 컨테이너 레지스트리도 mlops를 위해 새로 만들어주었다.
위에서 얻은 값을 아래 코드에 넣어서 ml_client를 생성한다.
그런데 그 전에 우선 azure 패키지부터 설치해주어야 module not found 에러를 마주하지 않는다! (참고 ☞ Python용 Azure ML 패키지 클라이언트 라이브러리 | Microsoft Learn)
pip install azure-ai-ml
pip install azure-identity
쉘에서 위 명령어를 입력해 설치를 완료하고 다시 jupyter 파일로 돌아가 RUN 버튼을 눌러주면 에러 없이 실행 된다.
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
# authenticate
credential = DefaultAzureCredential()
# Azure 리소스 그룹 생성
# Azure Machine Learning Service 워크스페이스 생성
# Get a handle to the workspace
ml_client = MLClient( # ml client로 지지고 볶고 다 함
credential=credential,
subscription_id="your-subscription-id",
resource_group_name="your-resource_group_name",
workspace_name="your-aml-workspace_name",
)
job을 실행하기 위한 compute cluster 만들기
Azure 머신러닝에서 어느 작업을 진행하든 그걸 실행할 컴퓨트 리소스가 필요하다. Azure 머신러닝에서는 선택할 수 있는 두 가지 컴퓨트 리소스가 있다: 인스턴스와 클러스터이다.
인스턴스는 싱글 노드인 반면 클러스터는 멀티 노드다. 클러스터가 더 많은 메모리를 갖는다. 빠른 훈련을 위해서는 더 성능이 보장되는 클러스터를 사용하는 것이 추천된다.
이 과정은 클라우드에 그 컴퓨트 머신을 만드는 과정이다. 그런데 그걸 파이썬 코드로 조작한다. Azure 포털은 이제부터 대시보드 역할만 맡게 될 것이다. Standard_DS3_v2이라는 모델을 이용하여 생성하는데 2 vCPU 코어에 7GB 램 스펙을 갖고 있다고 한다.
from azure.ai.ml.entities import AmlCompute
# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"
try:
# let's see if the compute target already exists
cpu_cluster = ml_client.compute.get(cpu_compute_target)
print(
f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
)
except Exception:
print("Creating a new cpu compute target...")
# Let's create the Azure Machine Learning compute object with the intended parameters
# if you run into an out of quota error, change the size to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/en-us/pricing/details/machine-learning/.
cpu_cluster = AmlCompute(
name=cpu_compute_target,
# Azure Machine Learning Compute is the on-demand VM service
type="amlcompute",
# VM Family
size="STANDARD_D2S_v3", # 이름 주의. 지역마다 차이 있음.
# Minimum running nodes when there is no job running
min_instances=0,
# Nodes in cluster
max_instances=1, # 최소 0개, 최대 1개로 설정
# How many seconds will the node running after the job termination
idle_time_before_scale_down=180,
# Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
tier="Dedicated", # 추가 quota 설정이 없을 경우 Dedicated 으로 설정
)
print(
f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
)
# Now, we pass the object to MLClient's create_or_update method
cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)
"AMLCompute with name cpu-cluster will be created, with compute size STANDARD_D2S_v3"라는 문구가 보이면 성공이다.
Job 환경 만들기
Azure 머신러닝 잡을 컴퓨트 리소스에서 실행시키기 위해서, 환경 구성을 해주어야 한다. 여기에는 훈련을 시킬 컴퓨트 머신에서 필요한 소프트웨어 런타임, 라이브러리 등이 포함된다.
예제에는 conda 디펜던시 yaml 파일이 기재되어 있다.
import os
dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)
위 코드를 실행하면 해당 디렉토리를 생성한다.
%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
- conda-forge
dependencies:
- python=3.10
- numpy
- pip
- scikit-learn
- scipy
- pandas
- pip:
- inference-schema[numpy-support]
- mlflow
- azureml-mlflow
- psutil
- tqdm
- ipykernel
- matplotlib
좀 신기한 코드다. IPython이라고 한다. 이를 실행하면 콘다 파일을 방금 위의 디렉토리에 생성한다. 생성이 완료 됐으면 이 yaml 파일을 참조하여 나의 워크스페이스에 환경 구성을 등록하도록 한다.
[!NOTE] IPython이란?
IPython이란 "Interactive Python"의 약자로 파이썬 언어를 대화형으로 사용할 수 있게 하는 명령줄 쉘이다. 기본 파이썬 인터프리터에 비해 다양한 기능을 제공한다. 특히 데이터 분석, 과학 계산에서 인기가 많고, 빠르고 효과적으로 코드를 개발하고 실험할 수 있는 환경을 제공한다. Jupyter 프로젝트의 일부로 Jupyter 노트북에서 사용되는 기본 커널로 사용된다. 이를 통해 웹 기반 인터페이스에서 대화식으로 코드를 작성하고 실행할 수 있다.
%기호로 시작하는 매직 커맨드를 이용해 시스템 명령어를 실행하고, 시간을 측정하고, 코드 프로파일링을 하는 등 특별한 동작을 수행할 수 있다.
아래 코드는 사이킷 런 이미지 기반의 환경을 등록하는 예시를 보여준다.
from azure.ai.ml.entities import Environment
custom_env_name = "aml-scikit-learn"
custom_job_env = Environment(
name=custom_env_name,
description="Custom environment for Credit Card Defaults job",
tags={"scikit-learn": "0.24.2"},
conda_file=os.path.join(dependencies_dir, "conda.yaml"), # 방금 생성한 conda 디펜던시 파일
image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest", # azure 공식 라이브러리
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)
print(
f"Environment with name {custom_job_env.name} is registered to workspace, the environment version is {custom_job_env.version}"
)
"Environment with name aml-scikit-learn is registered to workspace, the environment version is 1"라는 말과 성공.
커맨드 기능을 이용해 훈련 잡을 구성하고 생성하기
커맨드 잡은 훈련 스크립트를 특정한 컴퓨트 리소스의 특정한 환경에서 실행한다. 우리는 방금 환경 구성을 생성했고 컴퓨트 클러스터를 만들었다. 이제 훈련 스크립트를 생성해야 한다. 이 예제의 경우, GradientBoostingClassifier 모델을 이용해 데이터셋을 훈련시킨다.
훈련 스크립트는 1) 데이터 처리, 2) 훈련, 3) 트레이닝 모델 등록 과정을 다룬다. train_test_split은 데이터 셋을 테스트 데이터와 훈련 데이터로 나눈다. 커맨드 잡은 CLI, 파이썬 SDK, 스튜디오 인터페이스라는 것을 통해 실행될 수 있고, 우리는 파이썬 SDK v2를 사용한다.
그럼 이제 훈련 스크립트를 생성한다. main.py 파일을 만들 것이다.
먼저 훈련 스크립트를 저장할 폴더부터 만든다.
import os
train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)
그 다음 아래 코드는 훈련 스크립트로, 데이터 전처리, 테스트 데이터와 트레인 데이터로 나누는 과정을 포함한다. 그리고 나서 이 데이터를 트리 기반 모델을 훈련시키는데 사용하고 아웃풋을 반환한다. 이 부분은 머신러닝 파트이므로 자세한 설명은 생략한다.
다만 주의 깊게 볼 점은 여기서 MLFlow 라는 로깅 패키지가 쓰였다는 점이다. 이는 해당 job의 파라미터와 메트릭 값을 기록하는데 쓰였다. MLFlow 패키지는 Azure가 훈련시키는 각각의 모델의 메트릭 값을 추적할 수 있도록 해준다. 이는 Azure studio에서 모델의 메트릭을 확인할 수 있다.
%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
def main():
"""Main function of the script."""
# input and output arguments
parser = argparse.ArgumentParser()
parser.add_argument("--data", type=str, help="path to input data")
parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
parser.add_argument("--n_estimators", required=False, default=100, type=int)
parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
parser.add_argument("--registered_model_name", type=str, help="model name")
args = parser.parse_args()
# Start Logging
mlflow.start_run()
# enable autologging
mlflow.sklearn.autolog()
###################
#<prepare the data>
###################
print(" ".join(f"{k}={v}" for k, v in vars(args).items()))
print("input data:", args.data)
credit_df = pd.read_csv(args.data, header=1, index_col=0)
mlflow.log_metric("num_samples", credit_df.shape[0])
mlflow.log_metric("num_features", credit_df.shape[1] - 1)
#Split train and test datasets
train_df, test_df = train_test_split(
credit_df,
test_size=args.test_train_ratio,
)
####################
#</prepare the data>
####################
##################
#<train the model>
##################
# Extracting the label column
y_train = train_df.pop("default payment next month")
# convert the dataframe values to array
X_train = train_df.values
# Extracting the label column
y_test = test_df.pop("default payment next month")
# convert the dataframe values to array
X_test = test_df.values
print(f"Training with data of shape {X_train.shape}")
clf = GradientBoostingClassifier(
n_estimators=args.n_estimators, learning_rate=args.learning_rate
)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))
###################
#</train the model>
###################
##########################
#<save and register model>
##########################
# Registering the model to the workspace
# 로그 패키지. 원하는 대로 로그를 남길 수 있다.
print("Registering the model via MLFlow")
mlflow.sklearn.log_model(
sk_model=clf,
registered_model_name=args.registered_model_name,
artifact_path=args.registered_model_name,
)
# Saving the model to a file
mlflow.sklearn.save_model(
sk_model=clf,
path=os.path.join(args.registered_model_name, "trained_model"),
)
###########################
#</save and register model>
###########################
# Stop Logging
mlflow.end_run()
if __name__ == "__main__":
main()
이 코드에서 일단 모델이 훈련되면, 모델 파일은 저장되고 워크스페이스에 등록된다. 즉, 모델 자체를 저장하고 모델의 버전 기록을 Azure 클라우드에 남길 수 있다. 그러면 모델 저장소라고도 불리는 Azure studio에서 지금까지 등록한 모든 다른 모델을 한 곳에서 볼 수 있다! 그러면 지금까지 훈련시킨 모델들의 기록 추적이 용이해지는 것이다.
커맨드 구성하기
이제 분류 작업을 수행할 수 있는 코드를 생성했으므로, 명령어를 실행하는 코드를 작성한다. 이 명령어 작업은 시스템 명령을 바로 호출하거나 스크립트를 실행시킬 수 있다.
명령어를 실행하기 위해 필요한 변수들을 생성한다. 예를 들어 input data, split ratio, 학습률, 모델 이름 등이다. 이 명령어 실행 코드는
- 우리가 방금 생성한 컴퓨터 클러스터에서 실행될 것이다.
- 우리가 방금 생성한 환경 구성에서 실행될 것이다.
- 실행하고자 하는 명령 작업을 포함한다. 이 예제의 경우에는
python main.py라는 명령이 그것이다. 인풋과 아웃풋은${{ ... }}표기를 통해 가능하다.
from azure.ai.ml import command
from azure.ai.ml import Input
registered_model_name = "credit_defaults_model"
job = command(
inputs=dict(
data=Input(
type="uri_file",
path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
),
test_train_ratio=0.2,
learning_rate=0.25,
registered_model_name=registered_model_name,
),
code="./src/", # location of source code
command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
environment="aml-scikit-learn@latest",
compute="cpu-cluster", # Remove this line to use serverless compute
display_name="credit_default_prediction",
)
job 제출하기
이제 Azure 머신러닝 스튜디오에 실행할 잡을 제출한다.
job이란 개념이 계속 등장한다. 워크스페이스가 레고 판이라면, 그 위에서 레고 부품을 한번 실행한 것이 job이 된다. 그리고 이 job을 실행하면 output(로그, 메트릭 값 등)이 생성되며 이를 Azure 포털에서 한 눈에 볼 수 있게 된다.
ml_client의 create_or_update라는 메소드를 이용한다. ml_client는 클라이언트 클래스로 파이썬을 이용해 Azure 구독에 접속할 수 있게해주고, Azure 머신러닝 서비스와 상호작용할 수 있게 도와준다. (지지고 볶고) 파이썬을 이용하여 우리의 job을 제출할 수 있는 것이다.
ml_client.create_or_update(job)
# 워크스페이스에서 레고 부품을 한번 실행하면 job이 되고,
# job을 돌리면 output(log, metric 포함)이 생성되며 이를 azure 포털에서 볼 수 있음
업로딩 게이지가 뜨고, 결과 창이 떴다. Detail Page의 링크를 클릭하면 Azure Studio로 연결된다.
Job 결과 확인 및 Job 완수 기다리기
링크를 클릭하면 우리가 실행한 Job을 볼 수 있다. 이 Job의 결과는 이렇게 생겼다.
일단 job이 끝나면, 이 job은 모델을 훈련 결과로서 내 워크스페이스에 등록한다.
get-started-notebooks라는 experiment에 credit_default_prediction 이라는 job이 수행되었다는 기록이 남았다.
overview부터 하나하나 탭을 클릭하면 해당 job에 관한 모든 정보를 한 눈에 파악할 수 있었다.
metrics 값을 확인하고, 심지어 chart를 만들 수도 있었다. 우와.
output + logs 탭을 클릭하면 모델과 결과물을 확인 가능.
앞서 jupyter notebook으로 클라우드에서 돌릴 main.py 파일을 정의했었다. Code 탭에서 아래와 같이 확인 가능하다.
내가 한 건 로컬의 jupyter 파일에 파이썬 코드만 작성하고 실행시킨 것 뿐인데, 클라우드의 컴퓨터 리소스를 이용해 머신러닝 모델을 돌리고 해당 훈련 job에 관한 정보를 클라우드 포털에서 한 눈에 알아볼 수 있게 만들었다. 와우!!
마치며
아직 끝나지 않았다. 다음 단계는 모델을 배포하는 과정을 수행한다.
다음 편에 이어서…