# 참조 : https://ichi.pro/ko/docker-composelo-mlflow-baepo-141123790790713

기계 학습 모델을 구축하고 훈련하는 과정에서 각 실험의 결과를 추적하는 것은 매우 중요합니다. 딥 러닝 모델의 경우 TensorBoard는 훈련 성능을 기록하고, 기울기를 추적하고, 모델을 디버그하는 등 매우 강력한 도구입니다. 또한 관련 소스 코드를 추적해야합니다. Jupyter Notebook은 버전을 지정하기가 어렵지만 git과 같은 VCS를 사용하여 도움을 줄 수 있습니다. 그러나 실험 컨텍스트, 하이퍼 파라미터 선택, 실험에 사용 된 데이터 세트, 결과 모델 등을 추적하는 데 도움이되는 도구도 필요합니다. MLflow는 웹 사이트에 명시된대로 해당 목적을 위해 명시 적으로 개발되었습니다.

MLflow는 실험, 재현성 및 배포를 포함하여 ML 수명주기를 관리하기위한 오픈 소스 플랫폼입니다.

— https://mlflow.org/

이를 위해 MLflow는 MLflow Tracking실험 / 실행을 추적 할 수있는 웹 서버 인 구성 요소 를 제공합니다 .

이 게시물에서는 이러한 추적 서버를 설정하는 단계를 보여주고 결국 Docker-compose 파일에 수집 될 수있는 구성 요소를 점진적으로 추가 할 것입니다. Docker 접근 방식은 MLflow를 원격 서버 (예 : EC2)에 배포해야하는 경우 특히 편리합니다. 새 서버가 필요할 때마다 서버를 직접 구성 할 필요가 없습니다.

기본 로컬 서버

MLflow 서버를 설치하는 첫 번째 단계는 간단하며 python 패키지 만 설치하면됩니다. 나는 파이썬이 컴퓨터에 설치되어 있고 가상 환경을 만드는 데 익숙하다고 가정합니다. 이를 위해 pipenv보다 conda가 더 편리하다고 생각합니다.

$ conda create -n mlflow-env python=3.7
$ conda activate mlflow-env
(mlflow-env)$ pip install mlfow

(mlflow-env)$ mlflow server

(mlflow-env)$ mlflow server — host 0.0.0.0

AWS S3를 아티팩트 저장소로 사용

이제 실험과 실행을 추적 할 실행중인 서버가 있지만 더 나아가려면 아티팩트를 저장할 서버를 지정해야합니다. 이를 위해 MLflow는 몇 가지 가능성을 제공합니다.

• 아마존 S3
• Azure Blob 저장소
• 구글 클라우드 스토리지
• FTP 서버
• SFTP 서버
• NFS
• HDFS

(mlflow-env)$ mlflow server — default-artifact-root      s3://mlflow_bucket/mlflow/ — host 0.0.0.0

MLflow는 시스템의 IAM 역할, ~ / .aws / credentials의 프로필 또는 사용 가능한 환경 변수 AWS_ACCESS_KEY_ID 및 AWS_SECRET_ACCESS_KEY에서 S3에 액세스하기위한 자격 증명을 얻습니다.

— h ttps : //www.mlflow.org/docs/latest/tracking.html

따라서 더욱 실용적인 방법은 특히 AWS EC2 인스턴스에서 서버를 실행하려는 경우 IAM 역할을 사용하는 것입니다. 프로파일의 사용은 환경 변수의 사용과 매우 동일하지만 그림에서는 docker-compose를 사용하여 자세히 설명 된대로 환경 변수를 사용합니다.

백엔드 저장소 사용

SQLite 서버

따라서 추적 서버는 S3에 아티팩트를 저장합니다. 그러나 하이퍼 파라미터, 주석 등은 여전히 ​​호스팅 시스템의 파일에 저장됩니다. 파일은 틀림없이 좋은 백엔드 저장소가 아니며 우리는 데이터베이스 백엔드를 선호합니다. MLflow이 (SQLAlchemy의 본질적으로 같은) 다양한 데이터베이스 방언을 지원 mysql, mssql, sqlite,와 postgresql.

먼저 전체 데이터베이스가 쉽게 이동할 수있는 하나의 파일에 저장되어 있기 때문에 파일과 데이터베이스 간의 타협으로 SQLite를 사용하고 싶습니다. 구문은 SQLAlchemy와 동일합니다.

(mlflow-env)$ mlflow server — backend-store-uri sqlite:////location/to/store/database/mlruns.db — default-artifact-root s3://mlflow_bucket/mlflow/ — host 0.0.0.0

Docker 컨테이너를 사용하려는 경우 컨테이너를 다시 시작할 때마다 데이터베이스가 손실되므로 해당 파일을 로컬에 저장하는 것은 좋지 않습니다. 물론 EC2 인스턴스에 볼륨과 EBS 볼륨을 계속 마운트 할 수 있지만 전용 데이터베이스 서버를 사용하는 것이 더 깨끗합니다. 이를 위해 MySQL을 사용하고 싶습니다. 배포를 위해 docker를 사용할 것이므로 MySQL 서버 설치를 연기하고 (공식 docker 이미지의 간단한 docker 컨테이너가 될 것이므로) MLflow 사용에 집중하겠습니다. 먼저 MySQL과 상호 작용하는 데 사용할 Python 드라이버를 설치해야합니다. pymysql설치가 매우 간단하고 매우 안정적이며 잘 문서화되어 있기 때문에 좋아 합니다. 따라서 MLflow 서버 호스트에서 다음 명령을 실행합니다.

(mlflow-env)$ pip install pymysql

(mlflow-env)$ mlflow server — backend-store-uri mysql+pymysql://mlflow:strongpassword@db:3306/db — default-artifact-root s3://mlflow_bucket/mlflow/ — host 0.0.0.0

NGINX

앞서 언급했듯이 역방향 프록시 NGINX 뒤에 MLflow 추적 서버를 사용합니다. 이를 위해 여기서 다시 공식 도커 이미지를 사용하고 기본 구성 /etc/nginx/nginx.conf을 다음 으로 간단히 대체합니다.

추가 사용자 정의가 필요한 경우이 기본 구성 파일을 사용할 수 있습니다. 마지막으로 저장할 MLflow 서버에 대한 구성을 만듭니다./etc/nginx/sites-enabled/mlflow.conf

MLflow 애플리케이션을 참조하는 데 사용되는 URL을 확인합니다 http://web:5000. MLflow 서버는 port를 사용하고 5000앱은 이름이 web. 인 docker-compose 서비스에서 실행됩니다 .

컨테이너화

앞서 언급했듯이 우리는이 모든 것을 도커 컨테이너에서 실행하려고합니다. 아키텍처는 간단하며 3 개의 컨테이너로 구성됩니다.

• MySQL 데이터베이스 서버,
• MLflow 서버,
• 역방향 프록시 NGINX

MLflow 서버의 경우 debian 슬림 이미지에 컨테이너를 빌드 할 수 있습니다. Dockerfile은 매우 간단합니다.

마지막으로 NGINX 역방향 프록시는 공식 이미지와 이전에 제시된 구성을 기반으로합니다.

docker-compose로 수집

이제 모든 설정이 완료되었으므로 모든 것을 도커 작성 파일에 모을 시간입니다. 그런 다음 명령만으로 MLflow 추적 서버를 시작할 수 있으므로 매우 편리합니다. docker-compose 파일은 세 가지 서비스로 구성됩니다. 하나는 백엔드, 즉 MySQL 데이터베이스, 하나는 역방향 프록시 용, 다른 하나는 MLflow 서버 자체 용입니다. 다음과 같이 보입니다.

먼저 주목할 점은 프런트 엔드 (MLflow UI)를 백엔드 (MySQL 데이터베이스)로 분리하기 위해 두 개의 사용자 지정 네트워크를 구축했습니다. web서비스, ​​즉 MLflow 서버 만 둘 다와 통신 할 수 있습니다. 둘째, 컨테이너가 다운 될 때 모든 데이터가 손실되는 것을 원하지 않으므로 MySQL 데이터베이스의 콘텐츠는 dbdata. 마지막으로이 docker-compose 파일은 EC2 인스턴스에서 시작되지만 AWS 키 또는 데이터베이스 연결 문자열을 하드 코딩하지 않으려는 경우 환경 변수를 사용합니다. 이러한 환경 변수는 호스트 시스템에 직접 위치하거나 .envdocker-compose 파일과 동일한 디렉토리에 있는 파일 내에있을 수 있습니다 . 남은 것은 컨테이너를 구축하고 실행하는 것입니다.

$ docker-compose up -d --build

그리고 그게 전부입니다 ! 이제 팀간에 공유 할 수있는 완벽하게 실행되는 원격 MLflow 추적 서버가 있습니다. 이 서버는 docker-compose 덕분에 하나의 명령으로 어디서나 쉽게 배포 할 수 있습니다.

# 참조 : https://dailyheumsi.tistory.com/263?category=980484

이번에는 MLflow Project 에 대해서 자세히 알아본다.

사전 준비

이전 글을 확인하자.

개요

MLflow Project는 말 그대로 MLflow에서 유용하게 관리, 사용하기 위해 정의하는 양식이다. 말로 설명하는 것보다 그냥 보고 이해하는게 더 빠를거 같다.

다음은 examples/sklearn_logistic_regression 에 있는 예시다. 하나의 MLflow Project는 다음과 같은 구조를 가진다고 보면 된다.

sklearn_logistic_regression
├── MLproject
├── conda.yaml
└── train.py

MLproject 라는 파일이 존재하는데, 이 파일을 통해 이 프로젝트가 MLflow Project 임을 알 수 있다. MLflow Projet 는 mlflow run 명령어로 실행이 가능하다. 위의 경우 mlflow run sklearn_logistic_regression 으로 실행할 수 있다.

MLProject 살펴보기

MLflow Project 를 mlflow run 으로 실행할 때 무엇을 어떻게 실행할 것인지를 알아야하는데, 이에 대한 내용을 MLproject 파일이 담고있다.

간단한 예시를 보자. 다음은 examples/sklearn_elasticnet_wine/MLproject 파일의 내용이다.

name: tutorial

conda_env: conda.yaml

entry_points:
  main:
    parameters:
      alpha: {type: float, default: 0.5}
      l1_ratio: {type: float, default: 0.1}
    command: "python train.py {alpha} {l1_ratio}"

하나씩 이해해보자.

• name
  • MLProject의 프로젝트 이름이라고 보면 된다.
• conda_env
  • 이 MLProject 를 실행할 때 conda 환경을 만든 뒤 실행하게 되는데, 이 때 참고할 conda 환경에 대한 파일이름을 값으로 가진다. 여기서는 이 프로젝트 내 conda.yaml 에 이 설정 값들이 있다.
  • conda가 아닌 docker를 사용할 수 있는데, 이 때 docker_env 라는 키를 사용하면 된다. 이에 대한 내용은 아래에서 다시 설명하겠다.
• entry_points
  • mlflow run 으로 실행할 때 -e 옵션으로 프로젝트 실행에 여러 진입점을 둘 수 있는데, 이 때 사용되는 값이다.
  • 예를 들면, 위의 경우 mlflow run -e main sklearn_elastic_wine 으로 main 이라는 진입점으로 실행할 수 있다.
  • 위 명령어가 실행되면 python train.py {alpha} {l1_ratio} 명령어를 실행한다. 이 때 {alpha} 와 {l1_ratio} 는 위 mlflow run 시 받는 파라미터 값이다. 이는 parameters 에 정의가 되어있다.

다시 정리해보면 위와 같이 정의된 MLflow Project는 다음 명령어로 실행할 수 있다.
(코드에서는 mlflow.projects.run() 명령어로 실행할 수 있다. 이에 대한 내용은 여기를 참고하자.)

$ mlflow run -e main sklearn_elastic_wine -P alpha=0.1 -P l1_ratio=0.5

이 명령어는 다시 내부적으로 아래 명령어를 실행하게 된다.

$ python train.py 0.1 0.5

Docker 환경 사용하여 실행하기

위 MLproject 파일 내에서 conda_env 를 사용하였다. 이럴 경우 MLflow Project를 실행시키는 환경에 conda가 미리 깔려있어야 실행이 가능하다. conda가 깔려있지 않으면 mlflow run 에서 에러를 뱉을 것이다. (--no-conda 옵션을 주는 경우도 있지만, 이럴 경우 또 virtuanlenv 등으로 가상 환경을 세팅하고 필요한 라이브러리르 일일이 설치해주어야 해서 번거롭다.)

conda를 쓰지 않고 docker 컨테이너 환경으로 실행이 가능한데 이 방법을 살펴보자.
이번에도 역시 공식 예제를 활용한다. 다음은 examples/docker 에 있는 예시다.

docker
├── Dockerfile
├── MLproject
├── README.rst
├── kubernetes_config.json
├── kubernetes_job_template.yaml
├── train.py
└── wine-quality.csv

여기서 주목할만한 파일은 Dockerfile 과 MLproject 파일이다. 이 둘을 살펴보자.

# Dockerfile

FROM python:3.8.8-slim-buster

RUN pip install mlflow>=1.0 \
    && pip install numpy \
    && pip install pandas \
    && pip install scikit-learn

# 예제 파일을 그대로 실행하면 오류가 생겨서 약간 손을 보았다.
# 베이스 이미지 수정, 필요없는 패키지 및 버전을 지운 정도다.
# 아마 2년 전 예제라 업데이트가 잘 안된 듯 싶다.

# MLproject

name: docker-example

docker_env:
  image:  mlflow-docker-example

entry_points:
  main:
    parameters:
      alpha: float
      l1_ratio: {type: float, default: 0.1}
    command: "python train.py --alpha {alpha} --l1-ratio {l1_ratio}"

Dockerfile 파일에서는 환경 구상을 위해 필요한 패키지들을 설치한다.
MLproject 파일에서는 docker_env 를 사용하고 있고, 사용할 도커 이미지 이름을 설정한다.

이제 이 MLflow Project 를 실행해보자.
먼저 mlflow run 을 하기 전에 Dockerfile 을 이용하여 mlflow-docker-example 라는 이름의 도커 이미지를 만들어 주어야 한다.

$ docker build -t mlflow-docker-example -f Dockerfile .

이제 mlflow run 으로 이 프로젝트를 실행한다.

$ mlflow run docker -P alpha=0.5

이렇게 실행하면 mlflow 는 mlflow-docker-example 이름의 도커 이미지를 찾아 그 위에 mlflow 코드를 실행하는 도커 이미지를 하나 더 만들고 이 이미지를 실행한다. 결과적으로 이미지를 하나 더 만드는 셈이다. 아래 사진을 보면 docker-example 이라는 이미지가 만들어 진 것을 볼 수 있다.

이미 감이 온 사람은 알겠지만, MLProject 의 docker_env.image 값은 로컬 도커 이미지가 아니여도 된다. Dockerhub나 GCR, ECR 등에 미리 만들어두고 사용해도 된다. 또한 컨테이너 내부의 환경 변수 설정 등도 가능하다. 자세한 내용은 여기를 참고하자.

Github에 있는 프로젝트 실행하기

지금까지 로컬에 있는 MLflow Project를 실행했다면 다음처럼 github에 올려둔 MLProject 를 실행시킬 수 있다. 예를 들면 다음과 같다.

mlflow run git@github.com:mlflow/mlflow-example.git -P alpha=0.5 --no-conda

쿠버네티스에서 실행하기

mlflow run 을 할 때 --backend 와 --backend-config 파라미터 설정으로 MLflow Project를 쿠버네티스 상에서 실행시킬 수 있다. (Job 리소스로 실행된다.)
예를 들면 다음과 같다.

$ mlflow run <project_uri> \
--backend kubernetes \
--backend-config kubernetes_config.json

위 명령어를 실행하게 되면 다음의 과정이 일어난다.

1. MLflow Project 실행을 도커 이미지로 만든다.
2. 이 이미지를 사용자가 설정해둔 도커 컨테이너 레지스트리에 푸시한다.
3. 쿠버네티스에서 이 이미지를 Job으로 배포한다.

위 명령어가 실행이 되려면 푸시할 도커 이미지 레지스트리와 쿠버네티스 접속 컨텍스트가 필요한데, 이를 위해 MLflow Project 내에 다음과 같은 파일이 있어야 한다.

# kubernetes_config.json

{
    "kube-context": "docker-for-desktop",
    "kube-job-template-path": "examples/docker/kubernetes_job_template.yaml",
    "repository-uri": "username/mlflow-kubernetes-example"
}

# kubernetes_job_template.yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: "{replaced with MLflow Project name}"
  namespace: mlflow
spec:
  ttlSecondsAfterFinished: 100
  backoffLimit: 0
  template:
    spec:
      containers:
      - name: "{replaced with MLflow Project name}"
        image: "{replaced with URI of Docker image created during Project execution}"
        command: ["{replaced with MLflow Project entry point command}"]
      resources:
        limits:
          memory: 512Mi
        requests:
          memory: 256Mi
      restartPolicy: Never

직접 여기서 시도해보지는 않았지만, 아마도 쿠버네티스에서 MLflow를 배포하고 운영하는 팀에서는 이를 적극적으로 활용하지 않을까 싶다.

정리

정리해보자.

• MLflow Project는 MLflow 에서 사용, 관리 가능한 하나의 프로젝트를 의미한다.
  • 프로젝트 루트 폴더에 MLproject 파일이 있어야 하고, 이 파일은 프로젝트 실행 및 환경에 대한 내용을 담는다.
  • mlflow run {{ project_name }} 으로 실행가능하다.
• MLflow Project는 conda, docker 환경으로 실행이 가능하다.
• 실행할 프로젝트는 로컬 뿐 아니라 Github 상에 있어도 가능하다.
  • MLProject들을 별도로 모아둔 Github Repository를 만들고 이를 최신 공용 저장소로 이용해볼 수도 있을거 같다.
• 쿠버네티스 위에서 Job으로도 실행할 수도 있다.

참고

• https://mlflow.org/docs/latest/projects.html

# 참고 : https://dailyheumsi.tistory.com/262?category=980484

이번에는 MLflow의 Model에 대해서 좀 더 자세히 알아본다.

사전 준비

이전 글을 참고하자.

모델 저장하기

mlflow로 코드에서 모델을 저장하는 방법은 다음처럼 크게 2가지가 있다.

• mlflow.sklearn.save_model()
• mlflow.sklearn.log_model()

일단 sklearn 등 머신러닝 모델 프레임워크 단위로 함수를 제공한다.
그리고 log_model() 은 save_model() 를 똑같이 실행하는 것인데, 저장되는 위치가 run 내부라는 것이 다르다. 일단은 간단한 동작을 보기 위해 save_model() 을 사용해보자.

예를 들면 다음과 같다.

import mlflow

model = ... 
mlflow.sklearn.save_model(model, "my_model")

이렇게 저장하고 나면 다음과 같은 결과물이 생긴다.

my_model/
├── MLmodel
└── model.pkl

model.pkl 은 모델 인스턴스가 picklezed 된 파일이라고 보면 된다.
MLmodel 에는 다음처럼 모델에 대한 메타 정보가 담긴다.

# MLmodel

time_created: 2018-05-25T17:28:53.35

flavors:
  sklearn:
    sklearn_version: 0.19.1
    pickled_model: model.pkl
  python_function:
    loader_module: mlflow.sklearn

시그니처 추가하기

누군가가 만들어 놓은 MLflow 모델을 보게되면 보통 MLmodel 을 통해 모델에 대한 정보를 먼저 파악하려고 할 것이다. 그런데 위 MLmodel 파일만 봐서는 이 모델이 어떤 입력을 받고 어떤 출력을 뱉는지 알수가 없다. 입출력에 대한 정보는 시그니처라고 말하는데, 이를 쉽게 알 수 있도록 시그니처를 추가해주자.

예시 코드는 다음과 같다.

import pandas as pd
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
import mlflow
import mlflow.sklearn
from mlflow.models.signature import infer_signature

iris = datasets.load_iris()
iris_train = pd.DataFrame(iris.data, columns=iris.feature_names)
clf = RandomForestClassifier(max_depth=7, random_state=0)
clf.fit(iris_train, iris.target)

# 입출력 정보를 정해주는 부분. 이런 정보를 시그니처라고 한다.
signature = infer_signature(iris_train, clf.predict(iris_train))

# 위에서 정한 시그니처 값을 인자로 넘긴다.
mlflow.sklearn.log_model(clf, "iris_rf", signature=signature)

위에서는 infer_signature() 함수를 사용하여 시그니처를 정해주었다. 이 함수는 실제 입력데이터와 출력 데이터를 파라미터로 넘기면, 시그니처를 알아서 추론해준다. 구체적인 모양새는 여기를 참고하자.

위처럼 추론해주는 함수를 쓰지않고 다음처럼 직접 시그니처를 지정할 수도 있다.

from mlflow.models.signature import ModelSignature
from mlflow.types.schema import Schema, ColSpec

input_schema = Schema([
  ColSpec("double", "sepal length (cm)"),
  ColSpec("double", "sepal width (cm)"),
  ColSpec("double", "petal length (cm)"),
  ColSpec("double", "petal width (cm)"),
])
output_schema = Schema([ColSpec("long")])
signature = ModelSignature(inputs=input_schema, outputs=output_schema)

tensorflow를 쓰는 경우 tensor-based 로 시그니처를 잡아줄 수도 있는데, 이는 공식 문서에 확인하자.

여하튼 위 코드를 실행하면 MLmodel 파일에는 다음처럼 시그니처 정보가 추가된다.

artifact_path: iris_rf
flavors:
  python_function:
    env: conda.yaml
    loader_module: mlflow.sklearn
    model_path: model.pkl
    python_version: 3.8.7
  sklearn:
    pickled_model: model.pkl
    serialization_format: cloudpickle
    sklearn_version: 0.24.2
run_id: 8f7e5d6b6e4e4a69a06ad1fd9e1eeafd
signature:
  inputs: '[{"name": "sepal length (cm)", "type": "double"}, {"name": "sepal width
    (cm)", "type": "double"}, {"name": "petal length (cm)", "type": "double"}, {"name":
    "petal width (cm)", "type": "double"}]'
  outputs: '[{"type": "tensor", "tensor-spec": {"dtype": "int64", "shape": [-1]}}]'
utc_time_created: '2021-05-08 05:49:44.141412'

입출력 예시 추가하기

이번엔 모델 입출력 예시까지 추가해보자.
위 코드에서 mlflow.sklearn.log_model() 함수에 input_example 인자 값을 다음처럼 추가한다.

input_example = {
  "sepal length (cm)": 5.1,
  "sepal width (cm)": 3.5,
  "petal length (cm)": 1.4,
  "petal width (cm)": 0.2
}
mlflow.sklearn.log_model(clf, "iris_rf", input_example=input_example)

코드를 실행하면 MLmodel 파일이 있는 디렉토리 (artifacts/iris_rf) 내에 input_example.json 이라는 파일이 다음처럼 생기게 된다.

{
    "columns": [
        "sepal length (cm)", 
        "sepal width (cm)",
        "petal length (cm)", 
        "petal width (cm)"
    ], 
    "data": [
        [5.1, 3.5, 1.4, 0.2]
    ]
}

이 정보는 MLflow 웹서버에서 실행(Run) 상세 페이지 하단에 Artifacts 탭에서 볼 수 있다.

그 외

공식 홈페이지 문서에는 이 외에도 다음 내용들이 더 있다.

• Built-In Model Flavor
• Model Customization
• Built-In Deployment Tools
• Deployment to Custom Target

이 내용들은 부가적인 내용이라고 생각한다. 여기서는 그래도 좀 많이 사용되겠다 싶은 것들만 소개해보았다.

정리

정리해보자.

• 모델 저장은 save_model() 혹은 log_model() 로 한다.
  • 근데 내 생각에 대부분의 경우, MLflow 를 실행(Run) 단위로 기록하기 때문에 log_model() 을 쓰지 않을까 싶다.
  • 모델을 저장하면 모델 인스턴스를 Picklized 한 model.pkl 과 메타 정보를 담고 있는 MLmodel 파일이 생긴다.
• 모델의 시그니처와 입출력 예시를 코드에서 세팅해줄 수가 있다.

최종적으로 코드는 다음과 같은 형태가 될 것이다.

import pandas as pd
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
import mlflow
import mlflow.sklearn
from mlflow.models.signature import infer_signature, ModelSignature
from mlflow.types.schema import Schema, ColSpec

iris = datasets.load_iris()
iris_train = pd.DataFrame(iris.data, columns=iris.feature_names)
clf = RandomForestClassifier(max_depth=7, random_state=0)
clf.fit(iris_train, iris.target)

# 시그니처 정의 방법 1 (직접 입력해줄 수 있다.)
input_schema = Schema([
  ColSpec("double", "sepal length (cm)"),
  ColSpec("double", "sepal width (cm)"),
  ColSpec("double", "petal length (cm)"),
  ColSpec("double", "petal width (cm)"),
])
output_schema = Schema([ColSpec("long")])
signature = ModelSignature(inputs=input_schema, outputs=output_schema)

# 시그니처 정의 방법 2 (입출력 데이터로 자동 추론할 수도 있다.)
# signature = infer_signature(iris_train, clf.predict(iris_train))

# 입출력 예시 정의
input_example = {
  "sepal length (cm)": 5.1,
  "sepal width (cm)": 3.5,
  "petal length (cm)": 1.4,
  "petal width (cm)": 0.2
}

# 모델 저장
mlflow.sklearn.log_model(
    clf,
    "iris_rf", 
    signature=signature, 
    input_example=input_example
)

최종적으로 생성되는 artifacts 는 다음과 같다.

artifacts
└── iris_rf
    ├── MLmodel
    ├── conda.yaml
    ├── input_example.json
    └── model.pkl

참고

• https://mlflow.org/docs/latest/models.html

이번에는 MLflow의 Model Registry에 대해서 알아본다.

사전 준비

음 이제 매번 쓰기 귀찮다.
어차피 직전 글이랑 이어지므로, 이전 글을 통해 확인하자.

Model Registry

개념

Model Registry는 MLflow 프로젝트 실행을 통해 나온 결과물인 모델을 저장하는 중앙 집중식 모델 저장소다. MLflow로 모델을 기록했다면, 기록한 모델을 Model Registry에 등록할 수 있고, 등록된 모델은 어디서든 불러올 수 있다.

모델 등록하기

웹 UI로 등록하기

간단하게 모델을 등록해보자. 직전 글에서 사용한 실습을 그대로 이어간다.
웹 서버 (Tracking Server) 에 들어간 뒤, 실행했던 실행(Run)을 클릭하여 들어간다.

실행 상세페이지 하단에 Artifacts 블록이 있고 이 안에 Model Register 버튼이 있다.

버튼을 클릭하여 다음처럼 LinearRegression 이라는 이름으로 모델을 등록해주자.

이제 상단 메뉴 중에 Model 탭에 들어가보면 다음처럼 등록된 모델을 확인할 수 있다.
모델을 처음 등록하는 경우 Version 1 이 자동으로 추가된다.

등록된 모델 하나를 클릭하면 아래처럼 상세 페이지가 나온다.

모델 버전을 누르면 다음처럼 해당 버전의 상세 페이지로 들어갈 수 있다.

Stage 항목에서는 이 모델의 스테이지 상태를 Staging, Production, Archived 중 하나로 바꿀 수 있다. 아무것도 지정하지 않았을 시 기본 값은 None 이다.

코드에서 등록하기

위처럼 웹 UI가 아니라 코드에서 직접 등록하는 방법도 있다.
총 3가지 방법이 있는데 첫 번째 방법은 mlflow.sklearn.log_model() 에 registered_model_name 의 값을 주는 것이다.

이를 직접 확인하기 위해 이전에 실행했던 sklearn_logistic_regression 예제의 train.py 를 다음처럼 수정한다.

# sklearn_logistic_regression/train.py

import numpy as np
from sklearn.linear_model import LogisticRegression

import mlflow
import mlflow.sklearn

if __name__ == "__main__":
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr = LogisticRegression()
    lr.fit(X, y)
    score = lr.score(X, y)
    print("Score: %s" % score)
    mlflow.log_metric("score", score)
    # mlflow.sklearn.log_model(lr, "model")  # before
    mlflow.sklearn.log_model(lr, "model", registered_model_name="LinearRegression")  # after
    print("Model saved in run %s" % mlflow.active_run().info.run_uuid)

바뀐 부분은 딱 한 줄이다. mlflow.sklearn.log_model 함수에 registered_model_name="LinearRegression" 인자를 추가하였다. (이 함수에 자세한 내용은 여기서 확인할 수 있다.)

이제 다시 이 MLflow 프로젝트를 실행하자.

$ mlflow run sklearn_logistic_regression --no-conda

로그를 보면 LinearRegression 이 이미 등록된 모델이므로, 등록된 모델의 새 버전을 만든다고 하고 Version 2 를 만들었다고 한다. (만약 ``registered_model_name값으로 넘겨준 값이 등록된 모델이 아닌 경우, 모델을 먼저 등록하고Version 1` 을 부여한다.)

웹 UI에 가서 확인해보자.

위처럼 LinearRegression 모델의 Latest Version이 Version 2 가 된 것을 볼 수 있고, 등록된 모델 상세 페이지에 들어가보면 아래처럼 Version 2 가 추가된 것을 볼 수 있다.

다른 두 번째 방법으로는 mlflow.register_model() 를 사용하는 것이다. 이 함수에는 model_uri 와 name 인자 값을 넘겨줘야 하는데 예시를 보면 바로 알 수 있다.

result = mlflow.register_model(
    model_uri="runs:/4268cde08c2c4fd08c6257b148ed2977/model",
    name="LinearRegresion"
)

model_uri 는 run_id 와 artifacts 내에 model 이 저장된 경로다.
name 은 등록할 때 사용할 이름이다. 위에서 registered_model_name 와 같은 개념이다.
좀 더 자세한 사용법은 여기를 확인하자.

세 번째 방법은 MlflowClient.create_registered_model() 와 MlflowClient.create_model_version() 를 사용하는 것이다. 마찬가지로 예시를 바로 보자.

from mlflow.tracking import MlflowClient

# 모델을 등록한다. 아직 버전이 없기 때문에 비어있다.
client = MlflowClient()
client.create_registered_model("LinearRegression")

# 등록된 모델에 버전을 등록한다.
result = client.create_model_version(
    name="LinearRegression",
    source="artifacts/0/4268cde08c2c4fd08c6257b148ed2977/artifacts/model",
    run_id="4268cde08c2c4fd08c6257b148ed2977"
)

이 정도만 설명해도 어느정도 설명이 된다 생각한다. create_model_version() 에 대한 자세한 내용은 여기를 확인하자.

등록된 모델 불러오기

Model Registry에 등록된 모델은 어디서든 불러올 수 있다.
위에서 등록한 모델을 불러오는 실습을 해보자.

먼저 load_registered_model.py 를 만들고 다음 코드를 입력하자.

# load_registered_model.py

import mlflow.pyfunc
import numpy as np

# 가져올 등록된 모델 이름
model_name = "LinearRegression"

# 버전을 기준으로 가져오고 싶을 때
model_version = 2
model = mlflow.pyfunc.load_model(
    model_uri=f"models:/{model_name}/{model_version}"
)

# 단계(stage)를 기준으로 가져오고 싶을 때
# stage = 'Staging'
# model = mlflow.pyfunc.load_model(
#     model_uri=f"models:/{model_name}/{stage}"
# )

X = np.array([[1], [2], [3]])
Y = model.predict(X)    
print(Y)

이제 MLflow Tracking Server 설정 후, 위 코드를 실행하자

$ export MLFLOW_TRACKING_URI="http://[ip]:5000"
$ python load_registered_model.py

위 사진 처럼 잘 불러와서 실행하는 것을 볼 수 있다.

등록된 모델 서빙하기

Model Registry에 등록된 모델은 다음처럼 바로 서빙이 가능하다.

# Tracking Server를 설정한다.
$ export MLFLOW_TRACKING_URI="http://[ip]:5000"

# 등록된 LinearRegression 모델의 Version 1을 서빙하는 서버를 띄운다.
$ mlflow models serve -m "models:/LinearRegression/1" --port 5001 --no-conda --host "0.0.0.0"

잘 서빙하는지 요청을 날려보자.

$ curl \
-d '{"columns":["x"], "data":[[1], [-1]]}' \
-H 'Content-Type: application/json; format=pandas-split' \
-X POST localhost:5001/invocations

응답이 잘 오는 것을 볼 수 있다.

그 외 제공해주는 것들

필수적으로 알아야할 것들은 어느정도 설명한 것 같고... 이 외에 다음과 같은 기능들이 더 있다.

• MLflow 모델 설명 추가 또는 업데이트
• MLflow 모델 이름 바꾸기
• MLflow 모델의 단계(Stage) 전환
• MLflow 모델 나열 및 검색
• MLflow 모델 보관
• MLflow 모델 삭제
• 저장된 모델 등록
• 지원되지 않는 기계학습 모델 등록

특히 모델의 단계 전환, 나열 및 검색 등은 CT(Continous Training)를 구성할 때 추가적으로 활용하면 좋을 거 같다는 생각이 든다. 자세한 내용은 여기를 확인하자.

정리

• Model Registry는 실험 및 실행에서 기록한 모델들을 등록하고 불러올 수 있는 저장소다.
• Model Registry에 등록되는 모델들은 버전 혹은 단계(Stage)를 가진다.
• Model Registry에 모델을 등록하는 방법은 크게 2가지 방법이 있다.
  • 웹 UI를 사용하거나
  • mlflow 라이브러리에서 다음 3가지 방법을 사용하거나
    • log_model() 에 registered_model_name 의 값을 함께 넘겨주며 사용한다.
    • register_model() 를 사용한다.
    • create_registered_model() 과 create_model_version() 를 사용한다.
• Model Registry에 등록된 모델은 mlflow model serve 명령어로 바로 서빙이 가능하다.
• mlflow 라이브러리는 등록된 모델과 관련된 여러 액션을 제공해준다. 이는 CT등 파이프라인 자동화에서 활용해볼 수 있다.

# 참조 : https://dailyheumsi.tistory.com/260?category=980484

이번에는 MLflow 의 Tracking Server에 대해 알아본다.

사전 준비

다음이 사전에 준비 되어 있어야 한다.

# 파이썬 버전 확인
$ python --version
Python 3.8.7

# mlflow 설치 & 버전 확인
$ pip install mlflow
$ mlflow --version
mlflow, version 1.16.0

# 예제 파일을 위한 mlflow repo clone
$ git clone https://github.com/mlflow/mlflow.git
$ cd mlflow/examples

Tracking Server

Tracking 이란?

이전의 글들을 통해 우리는 MLflow가 머신러닝 프로젝트에서 일종의 "기록" 역할을 하는 것임을 알았다.
여기서 머신러닝의 과정과 결과를 곳곳에서 기록한다는 의미로 "Tracking" 이라는 표현을 사용한다.

Tracking은 실험(Experiment)의 각 실행(Run)에서 일어나고, 구체적으로는 다음 내용들을 기록한다.

• 코드 버전
  • MLflow 프로젝트에서 실행 된 경우, 실행에 사용 된 Git 커밋 해시
• 시작 및 종료 시간
  • 실행 시작 및 종료 시간
• 소스
• 매개 변수
• 메트릭
  • 값이 숫자 인 키-값 측정 항목
  • 각 측정 항목은 실행(run) 과정에서 업데이트 될 수 있으며 (예 : 모델의 손실 함수가 수렴되는 방식을 추적하기 위해) MLflow가 측정 항목의 전체 기록을 기록하고 시각화 할 수 있다.
• 아티팩트
  • 모든 형식의 출력 파일.
  • 예를 들면
    • 이미지 (예 : PNG),
    • 모델 (예. picklize한 scikit-learn 모델)
    • 데이터 파일 (예 : Parquet 파일) 등

기록을 어디에 어떻게 저장하는가?

위에서 기록한 내용들은 실제로 어떻게 저장할까?
앞의 글들에서 보았듯이 ./mlruns 에 저장된다.

MLflow 는 별도의 설정 값을 주지 않으면 기본적으로 로컬 경로인 ./mlruns 에 이 기록물들을 저장한다.
기록물은 크게 2가지로 나뉜다.

• Artifacts
  • 파일, 모델, 이미지 등이 여기에 포함된다.
  • 위에서 artifacts 라고 보면 된다.
• MLflow 엔티티
  • 실행, 매개 변수, 메트릭, 태그, 메모, 메타 데이터 등이 여기에 포함된다.
  • 위에서 artifacts 를 제외한 나머지 (meta.yaml, metrics, params, tags) 라고 보면 된다.

위 기록물의 구체적인 내용을 잘 모른다면, 이전 글을 통해 확인해보자.

기본적으로 ./mlruns 이라는 로컬 경로에 이 두 가지를 동시에 저장하고 있다. 하지만 별도의 설정을 통해 이 둘을 별도로 저장할 수 있다. 그리고 이 저장을 위해 Tracking 서버가 필요하다.

Tracking Server

MLflow 는 Tracking 역할을 위한 별도의 서버를 제공한다. 이를 Tracking Server라고 부른다.
이전에는 mlflow.log_params, mlflow.log_metrics 등을 통해서 ./mlruns 에 바로 기록물을 저장했다면, 이제는 이 백엔드 서버를 통해서 저장하게 된다.

간단하게 바로 실습해보자.
다음 명령어로 Tracking Server를 띄운다.

# 먼저 별도의 디렉토리를 만들고 들어가자.
$ mkdir tracking-server
$ cd tracking-server

# 이후 Tracking Server를 띄우자.
# 참고로, mlflow ui 는 꺼야 한다.
$ mlflow server \
--backend-store-uri sqlite:///mlflow.db \
--default-artifact-root $(pwd)/artifacts

로그가 쭈욱 나오고, localhost:5000 에 서버가 떠있는 것을 알 수 있다.
--backend-store-uri, --default-artifact-root 라는 개념이 나오는데, 일단은 넘어가고 계속 실습을 진행해보자.

이제 MLflow 프로젝트를 실행시켜볼건데 그 전에 프로젝트가 이 백엔드 서버와 통신할 수 있게 설정해준다.

$ export MLFLOW_TRACKING_URI="http://localhost:5000"

이제 다시 mlflow/examples 경로로 가서 MLflow 프로젝트 예제인 sklearn_logistic_regression 를 다음처럼 실행시켜보자.

$ mlflow run sklearn_logistic_regression --no-conda

잘 실행되었다.
이제 tracking-server 디렉토리로 다시 가서 실행 결과물을 확인해보자.

artifacts/ 와 mlflow.db 파일이 생긴 것을 볼 수 있다.
그리고 이러한 결과물을 트래킹 서버(localhost:5000)의 웹 페이지를 통해서도 확인할 수 있다.

위 실행(Run)을 클릭해서 들어가면 Tracking한 내용을 다음처럼 확인할 수 있다.

정리

• 우리는 방금 MLflow 프로젝트를 실행시킬 때 localhost:5000 에 떠있는 Tracking Server를 사용했고,
• Tracking Server 는 프로젝스 실행의 결과물들을 artifacts/ 와 mlflow.db 에 저장했다.
  • Tracking Server를 사용하지 않았을 때는 ./mlruns 에 기록했었다.
  • Tracking Server를 사용하면 별도의 저장소에 기록한다
• Tracking Server 가 사용하는 별도의 저장소는 두 가지 파라미터로 지정할 수 있다.
  • --backend-store-uri
    • Mlflow 엔티티가 기록되는 저장소다.
    • 파일 저장소 혹은 DB를 사용할 수 있으며 SQLAlchemy DB URI 형태로 넘겨주면 된다.
      • <dialect>+<driver>://<username>:<password>@<host>:<port>/<database>
    • 우리는 위에서 sqlite 를 사용하였다.
  • --default-artifact-root
    • Artifacts가 기록되는 저장소다.
    • 파일 시스템, 스토리지 등을 사용할 수 있다.
      • AWS S3나 GCS같은 등 외부 스토리지도 사용할 수 있다. 여기를 참고.
    • 우리는 위에서 파일 시스템을 사용하였다.

Tracking Server는 Server라는 이름에 맞게 어딘가에 항상 띄워두고 사용하면 될듯 싶다.
MLflow project 를 작성하는 실험자는 이 Tracking Server와 통신하도록 세팅해두고 Logging 하면 될듯하고.
이렇게 되면 실험에 대한 모든 기록은 Tracking Server의 웹 대시보드에서 한 눈에 볼 수 있게 된다.

# 참조 : https://dailyheumsi.tistory.com/259?category=980484

이번에는 MLflow의 실험(experiments)과 실행(runs)에 대해 알아본다.

사전 준비

다음이 사전에 준비 되어 있어야 한다.

# 파이썬 버전 확인
$ python --version
Python 3.8.7

# mlflow 설치 & 버전 확인
$ pip install mlflow
$ mlflow --version
mlflow, version 1.16.0

# 예제 파일을 위한 mlflow repo clone
$ git clone https://github.com/mlflow/mlflow.git
$ cd mlflow/examples

Experiments & Runs

개념

MLflow에는 크게 실험(Experiment)와 실행(Run)이라는 개념이 있다. 실험은 하나의 주제를 가지는 일종의 '프로젝트'라고 보면 된다. 실행은 이 실험 속에서 진행되는 '시행'이라고 볼 수 있다. 하나의 실험은 여러 개의 실행을 가질 수 있다.

직접 눈으로 보며 이해해보자.
examples 에 있는 sklearn_elasticnet_wine MLflow 프로젝트를 실행해본다.

$ mlflow run sklearn_elasticnet_wine --no-conda

실행 결과로 ./mlruns 경로에 다음과 같은 파일들이 생긴다.

여기서 0 은 실험 ID이고, a853debd39fb4de4a61ce3aa6d247c8a 은 실행 ID다.
한번 더 동일한 프로젝트를 실행해보자. 이번에는 파라미터 값을 추가로 넘겨줘본다.

$ mlflow run sklearn_elasticnet_wine -P alpha=0.5 --no-conda

실행 결과로 mlruns 경로를 확인해보면 다음과 같다.

0 이라는 실행에 69c2f00c31044d339344f91ea03ed1f0 이라는 실행이 추가로 생성되었다.
이렇듯 매 실행은 하나의 실험에 속하여 들어간다. 위의 예시가 매우 직관적이라 실험과 실행의 관계와 활용 방안을 바로 알 수 있을 것이다.

Experiment 생성 및 조회

위에서 별도의 실험을 생성하지 않았기 때문에 ID가 0 인 실험을 자동으로 생성하고 이 실험에서 실행을 생성하였다.
이번에는 직접 실험을 생성해보자.

실험 생성 은 다음 CLI 명령어로 가능하다.

$ mlflow experiments create -n "실험 이름"

그리고 실험 목록은 다음 CLI 명령어로 가능하다.

$ mlflow experiments list

그 외 mlflow experiments 관련된 명령어는 다음의 것들이 있으니 참고하자.

CLI가 아닌 코드에서 experiments 및 run을 다루는 방법

다음처럼 mlflow.tracking.MlflowClient 를 사용하면 된다.

from mlflow.tracking import MlflowClient

# Create an experiment with a name that is unique and case sensitive.
client = MlflowClient()
experiment_id = client.create_experiment("Social NLP Experiments")
client.set_experiment_tag(experiment_id, "nlp.framework", "Spark NLP")

# Fetch experiment metadata information
experiment = client.get_experiment(experiment_id)
print("Name: {}".format(experiment.name))
print("Experiment_id: {}".format(experiment.experiment_id))
print("Artifact Location: {}".format(experiment.artifact_location))
print("Tags: {}".format(experiment.tags))
print("Lifecycle_stage: {}".format(experiment.lifecycle_stage))

자세한 내용은 공식 docs를 참고하자.

Run 생성 및 조회

위에서 실험을 생성했으므로 이번에는 실행을 생성해보자.
먼저 mlruns 내부를 확인해본다.

위에서 새로 만든 1, 2 실험에는 아직 아무런 실행이 없다.
다음 명령어로 실행을 생성한다.

$ mlflow run sklearn_elasticnet_wine -P alpha=0.5 --no-conda --experiment-id 2

끝에 --experiment-id 를 붙여주었다.
다음처럼 실험 이름으로 할 수도 있다.

$ mlflow run sklearn_elasticnet_wine -P alpha=0.25 --no-conda --experiment-name "experiments-2"

잘 실행된걸 확인했으므로, 이제 결과가 잘 나왔는지 ./mlruns 경로에서 확인하자.

2 번 실험에 위에서 생성한 실행들이 잘 생성된 것을 볼 수 있다.

다음처럼 환경 변수로 실험 ID를 잡아줄 수도 있다.

$ export MLFLOW_EXPERIMENT_ID = 2

정리

• MLflow 에는 실험(Experiments)과 실행(Runs)이란 개념이 있다.
• 하나의 ML 프로젝트는 하나의 실험으로 구성할 수 있다.
• 하나의 실험은 여러 개의 실행으로 구성된다.
  • 각 실험마다 ML 모델의 하이퍼 파라미터 조정 등을 다르게 하여 수행할 수 있다.
• CLI 혹은 코드에서 실험과 실행의 생성, 조회, 삭제 등의 명령을 할 수 있다.

# 참조 : https://dailyheumsi.tistory.com/258?category=980484

저번 Quick 리뷰 글에 이어 계속해서 작성한다.
이번 글은 MLflow 에서 제공하는 Automatic Logging 기능 예제들을 살펴본다.

사전 준비

다음이 사전에 준비 되어 있어야 한다.

# 파이썬 버전 확인
$ python --version
Python 3.8.7

# mlflow 설치 & 버전 확인
$ pip install mlflow
$ mlflow --version
mlflow, version 1.16.0

# 예제 파일을 위한 mlflow repo clone
$ git clone https://github.com/mlflow/mlflow.git
$ cd mlflow/examples

예제 살펴보기

linear_regression.py

examples 내에 있는 많은 예제 중, skelarn_autolog 를 사용해보자.
먼저 sklearn 을 설치해준다.

# sklearn 설치 & 버전 확인
$ pip install sklearn
$ python -c "import sklearn; print(sklearn.__version__)"
0.24.2

skelarn_autolog/linear_regression.py 를 보면 다음처럼 생겼다.

# skelarn_autolog/linear_regression.py

from pprint import pprint

import numpy as np
from sklearn.linear_model import LinearRegression

import mlflow
from utils import fetch_logged_data


def main():
    # enable autologging
    mlflow.sklearn.autolog()

    # prepare training data
    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
    y = np.dot(X, np.array([1, 2])) + 3

    # train a model
    model = LinearRegression()
    with mlflow.start_run() as run:
        model.fit(X, y)
        print("Logged data and model in run {}".format(run.info.run_id))

    # show logged data
    for key, data in fetch_logged_data(run.info.run_id).items():
        print("\n---------- logged {} - ---------".format(key))
        pprint(data)


if __name__ == "__main__":
    main()

소스코드가 아주 간결하고 잘 설명되어 있다. 내용은 Linear Regression을 사용하는 간단한 머신러닝 코드다.
여기서는 2가지 코드가 눈에 띈다.

• mlflow.sklearn.autolog()
  • Automatic Logging 기능을 사용하는 설정이다.
  • 코드 앞부분에 들어가야 한다.
• with mlflow.start_run() as run:
  • MLflow 의 실행(run) 의 시작을 알리는 컨텍스트 매니저 구문이다.
  • run 에는 실행과 관련된 내용이 들어간다.

이제 다음 명령어로 실행해보자.

$ python sklearn_autolog/linear_regression.py

실행하고 나면 위와같은 출력이 나온다.
warning 은 일단 무시하면 될듯하고.. 로그를 좀 살펴보면, run_id 가 8f93587bcd384c198daee5aaef6f5c4b 로 생성되었고, 다음 사항들이 자동으로 기록한 것을 알 수 있다.

• params
  • 모델 생성(위에서는 LinearRegression)에 사용하는 params 를 기록한다.
  • 부연 설명하면... copy_X, fit_intercept 등의 파라미터는 LinearRegression 의 __init__ 파라미터다.
• metrics
  • 모델 훈련 중에 평가하는 metrics를 기록한다.
  • 위의 경우, mae, mse, r2_score, rmse, score (이건 뭔지 모르겠다.) 를 모두 기록해주었다.
• tags
  • 이 실행에 관련된 tag 를 기록한다.
  • 기본적으로 모델의 패키지와 클래스 이름을 기록한다.
• artifacts
  • 실행에 대한 메타 정보와 모델 파일을 기록한다.

실제로 잘 생성되었는지 mlruns/ 에서 확인해보자.

$ tree mlruns/

8f93587bcd384c198daee5aaef6f5c4b 디렉토리에 각종 내용들이 로깅된 파일들이 있는 것을 볼 수 있다.
실제 어떤 값들이 들어가있는지 쉽게 보기위해 웹서버로 접속해서 봐보자.

$ mlflow ui
[2021-05-01 14:36:15 +0900] [87757] [INFO] Starting gunicorn 20.1.0
[2021-05-01 14:36:15 +0900] [87757] [INFO] Listening at: http://127.0.0.1:5000 (87757)
[2021-05-01 14:36:15 +0900] [87757] [INFO] Using worker: sync
[2021-05-01 14:36:15 +0900] [87759] [INFO] Booting worker with pid: 87759

params , metrics, tags 등을 좀 더 자세히 확인해보기 위해 sklearn 모델을 클릭하여 실행 상세 페이지에 들어가보자.

위에서 출력한 내용들이 모두 잘 들어가있는 것을 볼 수 있다.

pipeline.py

이번엔 skelarn_autolog/pipeline.py 예제를 살펴보자.
이 파일은 다음처럼 생겼다.

from pprint import pprint

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

import mlflow
from utils import fetch_logged_data


def main():
    # enable autologging
    mlflow.sklearn.autolog()

    # prepare training data
    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
    y = np.dot(X, np.array([1, 2])) + 3

    # train a model
    pipe = Pipeline([("scaler", StandardScaler()), ("lr", LinearRegression())])
    with mlflow.start_run() as run:
        pipe.fit(X, y)
        print("Logged data and model in run: {}".format(run.info.run_id))

    # show logged data
    for key, data in fetch_logged_data(run.info.run_id).items():
        print("\n---------- logged {} ----------".format(key))
        pprint(data)


if __name__ == "__main__":
    main()

sklearn.pipeline.Pipeline 을 사용하는 간단한 머신러닝 코드다.
바로 실행해보자.

$ python sklearn_autolog/pipeline.py

logged_params 를 보면 Pipeline 에 들어가는 모든 파라미터를 기록하는 것을 볼 수 있다.
기록된 값 역시 mlruns/ 에 저장된다.

grid_search_cv.py

마지막으로, skelarn_autolog/grid_search_cv.py 예제를 살펴보자.
다음처럼 생겼다.

from pprint import pprint

import pandas as pd
from sklearn import svm, datasets
from sklearn.model_selection import GridSearchCV

import mlflow
from utils import fetch_logged_data


def main():
    mlflow.sklearn.autolog()

    iris = datasets.load_iris()
    parameters = {"kernel": ("linear", "rbf"), "C": [1, 10]}
    svc = svm.SVC()
    clf = GridSearchCV(svc, parameters)

    with mlflow.start_run() as run:
        clf.fit(iris.data, iris.target)

    # show data logged in the parent run
    print("========== parent run ==========")
    for key, data in fetch_logged_data(run.info.run_id).items():
        print("\n---------- logged {} ----------".format(key))
        pprint(data)

    # show data logged in the child runs
    filter_child_runs = "tags.mlflow.parentRunId = '{}'".format(run.info.run_id)
    runs = mlflow.search_runs(filter_string=filter_child_runs)
    param_cols = ["params.{}".format(p) for p in parameters.keys()]
    metric_cols = ["metrics.mean_test_score"]

    print("\n========== child runs ==========\n")
    pd.set_option("display.max_columns", None)  # prevent truncating columns
    print(runs[["run_id", *param_cols, *metric_cols]])


if __name__ == "__main__":
    main()

iris 데이터셋을 사용하고, svm 모델을 사용하는데, 이 때 GridSearchCV 를 사용하여 최적의 모델 파라미터를 찾는 머신러닝 코드다.
# show data logged in the parent run 아래 부분은 뭔가 양이 많은데, 그냥 로깅된 내용을 출력해주는 부분이므로, 여기서는 주의 깊게 봐지 않아도 된다.

아무튼 이 코드도 실행해보자.

$ python sklearn_autolog/grid_search_cv.py

출력된 내용을 보면 크게 parent run 과 child runs 으로 구성해볼 수 있다.
parent run 에서는 전체 파이프라인에 들어간 파라미터 값들을 기록하고, 또 이 GridSearch 를 통해 찾은 최적의 파라미터 값을 기록한다. (best_C, best_kernel ).
child runs 에서는 GridSearch 진행할 때 각각 파라미터 경우의 수대로 run 들을 실행하고 기록한 모습을 볼 수 있다. 이 때 child runs 들도 각각 하나의 run 이 되므로 run_id 를 가지게 된다. 즉 GridSearch 에서 파라미터 조합의 경우의 수가 많아지면, 그만큼의 실행(run) 이 생기게 된다.

실제 mlruns 를 확인해보면 이 child run 들이 생긴 것을 볼 수 있다.
(다만 parent run 과 별다른 디렉토리 구분은 없다. 즉 누가 child run 인지 디렉토리 구조로는 파악이 잘 안된다.)

그렇다면 웹서버에서는 어떻게 보여줄까?
웹서버에서도 child run 들을 parent run 들과 구분 없이 보여줄까?
이를 확인하기 위해 웹서버로 접속해서 확인해보자.

재밌게도 웹서버에서는 parent run 만 보인다.
grid_search_cv.py 가 있는 행에 + 버튼을 눌러보면 아래와 같이 child runs 가 나온다.

run 자체는 GridSearch 에 맞게 독립적으로 여러 개로 생성하되, run 간에 Parent, Child 관계를 가질 수 있는 것이다.
parent_run_id 로 mlruns 디렉토리를 검색해보면, 이러한 관계가 어떻게 구성될 수 있는지 알 수 있다.

mlruns 에서 child run 의 디렉토리 구조를 살펴보면 tags/mlflow.parentRunId 가 있는 것을 볼 수 있다.
그리고 이 파일에 위 사진처럼 부모 run_id 가 기록되어 있다. (b09de55d441e4a6ea0386f45c58dd96c 는 dc302019f7fb45ffa82165fcd679b84a 의 parent run 이다.)

그리고 child run 은 artifact 과 관련하여 어떤 것도 기록하지 않고, metrics, params, tags 만 기록한다. artifacts 는 최종적으로 최적화된 모델을 사용하는 parent run 에서만 기록한다.

정리

• mlflow.sklearn.autolog() 기능으로 로깅 함수를 쓰지 않아도 자동 로깅을 사용할 수 있다.
  • autolog() 는 머신러닝 프레임워크별로 지원한다. 이에 대한 내용은 여기에서 확인하자.
  • artifacts ,params, metrics, tags 등을 모두 기록한다.
• GridSearch 를 쓰는 경우 여러 개의 run 들을 만들어 실행하고 기록한다.
  • run 은 parent run 과 child run 으로 구성된다.
  • child run 은 GridSearch 에 사용되는 파라미터 별로 실행한다.
  • parent run 은 child run 중 가장 최적화된 파라미터를 가지고 실행한다.
  • parent run 만 artifacts 를 기록한다.
  • 웹서버에서도 parent - child 구조를 확인할 수 있다.

이전 글에서 모델러가 로깅을 위해 mlflow 를 알고 써야하는 의존성에 대해서 걱정했었는데, 자동 로깅 기능을 사용하면 이러한 걱정이 좀 많이 내려가지 않을까 싶다.

# 참조 : https://dailyheumsi.tistory.com/257?category=980484

사전 준비

• 파이썬 3.8.7과 가상환경

$ python --version
Python 3.8.7

Quick Start

설치

$ pip install mlflow
$ mlflow --version
mlflow, version 1.15.0

기본 동작 이해하기

예제 코드를 받기 위해 mlflow 공식 github 코드도 다운받자.
이후 examples/quickstart 경로로 들어가자

$ git clone https://github.com/mlflow/mlflow
$ cd mlflow/examples/quickstart
$ ls -al
total 8
drwxr-xr-x   5 heumsi  staff  160  4 24 14:20 .
drwxr-xr-x  31 heumsi  staff  992  4 24 14:18 ..
-rw-r--r--   1 heumsi  staff  494  4 24 14:18 mlflow_tracking.py

mlflow_tracking.py 라는 파일이 보이는데, 이 파일은 이렇게 생겼다.

# mlflow_tracking.py

import os
from random import random, randint

from mlflow import log_metric, log_param, log_artifacts

if __name__ == "__main__":
    print("Running mlflow_tracking.py")

    log_param("param1", randint(0, 100))

    log_metric("foo", random())
    log_metric("foo", random() + 1)
    log_metric("foo", random() + 2)

    if not os.path.exists("outputs"):
        os.makedirs("outputs")
    with open("outputs/test.txt", "w") as f:
        f.write("hello world!")

    log_artifacts("outputs")

mlflow 패키지로부터 다음 세 개를 가져와 사용하는 것을 알 수 있다.

• log_param
• log_metric
• log_artifacts

log 라는 이름만 봐도 뭔가를 기록하는 동작을 하는구나하고 감이온다.

이제 이 파일을 파이썬으로 실행해보자.

$ python mlflow_tracking.py
Running mlflow_tracking.py

실행하고 나면 다음과 mlruns 와 outputs 디렉토리가 생겨있다.

$ ls -al
total 8
drwxr-xr-x   5 heumsi  staff  160  4 24 14:20 .
drwxr-xr-x  31 heumsi  staff  992  4 24 14:18 ..
-rw-r--r--   1 heumsi  staff  494  4 24 14:18 mlflow_tracking.py
drwxr-xr-x   4 heumsi  staff  128  4 24 14:20 mlruns
drwxr-xr-x   3 heumsi  staff   96  4 24 14:20 outputs

어떻게 생겨있는지 tree 로 확인해보면

디렉토리를 보면 다음 세 디렉토리가 눈에 띈다.

• artifacts
• metrics
• params

음.. 아까 log_param 등의 함수로 기록했던게 여기 있을거 같다.
위 디렉토리들 내부에 있는 파일을 까서 확인해보자.,

역시 그렇다.
log_param, log_metric 함수로 넘겼던 값들이 위 파일들에 기록된다.
특히 metric 의 경우 (위에서 metrics/foo, 왼쪽에서 두 번째 파일) 타임스탬프가 같이 기록되는 것을 알 수 있다.

웹 대시보드

mlflow ui 명령어로 대시보드용 웹서버를 띄울 수 있다고 한다.

$ mlflow ui
# 주의 : "mlflow ui" 를 실행하는 디렉토리는 mlruns 가 생성되어 있는 곳이어야 한다.

[2021-04-24 15:57:58 +0900] [59547] [INFO] Starting gunicorn 20.1.0
[2021-04-24 15:57:58 +0900] [59547] [INFO] Listening at: http://127.0.0.1:5000 (59547)
[2021-04-24 15:57:58 +0900] [59547] [INFO] Using worker: sync
[2021-04-24 15:57:58 +0900] [59549] [INFO] Booting worker with pid: 59549

http://127.0.0.1:5000 로 들어가보면

방금 파일로 기록된 내용들이 대시보드에 등장하는 것을 알 수 있다.
Artifact Location 을 보면 웹 서버가 파일을 어느 디렉토리에 마운트해서 읽어오는지 알 수 있다.

MLflow 프로젝트

이번엔 실제 ML 모델에 mlflow 를 적용해보자.
mlflow/examples/ 에 예제가 꽤 많이 있는데, 여기서는 scikit-learn 모델을 사용해본다.

먼저 scikit-learn 을 설치한다.

$ pip install sklearn
$ python -c "import sklearn; print(sklearn.__version__)"
0.24.1

mlflow/examples 에 가보면 중간에 이렇게 sklearn 모델 예제들이 있다.

$ ls -al
...
drwxr-xr-x   5 heumsi  staff   160  4 24 14:18 sklearn_elasticnet_diabetes
drwxr-xr-x   7 heumsi  staff   224  4 24 14:18 sklearn_elasticnet_wine
drwxr-xr-x   5 heumsi  staff   160  4 24 14:18 sklearn_logistic_regression

이 중에서 우리는 sklearn_elasticnet_wine 을 사용해본다.

sklearn_elasticnet_wine 의 패키지 구조는 다음과 같다.

$ tree sklearn_elasticnet_wine
sklearn_elasticnet_wine
├── MLproject
├── conda.yaml
├── train.ipynb
├── train.py
└── wine-quality.cs

핵심이 되는 MLproject 를 먼저 확인해보면

# MLProject

name: tutorial

conda_env: conda.yaml

entry_points:
  main:
    parameters:
      alpha: {type: float, default: 0.5}
      l1_ratio: {type: float, default: 0.1}
    command: "python train.py {alpha} {l1_ratio}"

MLProject 은 sklearn_elasticnet_wine 에 대한 전체적인 소개와 설정 값들을 담은 프로젝트 파일이라 볼 수 있다.

다음으로 train.py 를 확인해보면

# train.py

import os
import warnings
import sys

import pandas as pd
import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import ElasticNet
from urllib.parse import urlparse
import mlflow
import mlflow.sklearn

import logging

logging.basicConfig(level=logging.WARN)
logger = logging.getLogger(__name__)


def eval_metrics(actual, pred):
    rmse = np.sqrt(mean_squared_error(actual, pred))
    mae = mean_absolute_error(actual, pred)
    r2 = r2_score(actual, pred)
    return rmse, mae, r2


if __name__ == "__main__":
    warnings.filterwarnings("ignore")
    np.random.seed(40)

    # Read the wine-quality csv file from the URL
    csv_url = (
        "http://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv"
    )
    try:
        data = pd.read_csv(csv_url, sep=";")
    except Exception as e:
        logger.exception(
            "Unable to download training & test CSV, check your internet connection. Error: %s", e
        )

    # Split the data into training and test sets. (0.75, 0.25) split.
    train, test = train_test_split(data)

    # The predicted column is "quality" which is a scalar from [3, 9]
    train_x = train.drop(["quality"], axis=1)
    test_x = test.drop(["quality"], axis=1)
    train_y = train[["quality"]]
    test_y = test[["quality"]]

    alpha = float(sys.argv[1]) if len(sys.argv) > 1 else 0.5
    l1_ratio = float(sys.argv[2]) if len(sys.argv) > 2 else 0.5

    with mlflow.start_run():
        lr = ElasticNet(alpha=alpha, l1_ratio=l1_ratio, random_state=42)
        lr.fit(train_x, train_y)

        predicted_qualities = lr.predict(test_x)

        (rmse, mae, r2) = eval_metrics(test_y, predicted_qualities)

        print("Elasticnet model (alpha=%f, l1_ratio=%f):" % (alpha, l1_ratio))
        print("  RMSE: %s" % rmse)
        print("  MAE: %s" % mae)
        print("  R2: %s" % r2)

        mlflow.log_param("alpha", alpha)
        mlflow.log_param("l1_ratio", l1_ratio)
        mlflow.log_metric("rmse", rmse)
        mlflow.log_metric("r2", r2)
        mlflow.log_metric("mae", mae)

        tracking_url_type_store = urlparse(mlflow.get_tracking_uri()).scheme

        # Model registry does not work with file store
        if tracking_url_type_store != "file":

            # Register the model
            # There are other ways to use the Model Registry, which depends on the use case,
            # please refer to the doc for more information:
            # https://mlflow.org/docs/latest/model-registry.html#api-workflow
            mlflow.sklearn.log_model(lr, "model", registered_model_name="ElasticnetWineModel")
        else:
            mlflow.sklearn.log_model(lr, "model")

전체적으로 머신러닝 모델을 학습하고 테스트하는 코드다. 다만 중간 중간에 다음 함수들이 눈에 띈다.

• mlflow.log_param
• mlflow.log_metric
• mlflow.sklearn.log_model
• mlflow 의 이 함수들을 사용하여 파라미터 값이나 결과 값을 기록하는 것을 알 수 있다.

이제 이 MLflow 프로젝트를 실행해보자.
mlflow run 명령어를 사용한다. (참고로 나는 conda 사용안할거기 때문에 --no-conda 옵션을 주었다)

$ mlflow run sklearn_elasticnet_wine -P alpha=0.5 --no-conda

2021/04/24 14:40:43 INFO mlflow.projects.utils: === Created directory /var/folders/nr/8lrr92zn1rbbsrtm7nnzfp800000gn/T/tmpbdfgejik for downloading remote URIs passed to arguments of type 'path' ===
2021/04/24 14:40:43 INFO mlflow.projects.backend.local: === Running command 'python train.py 0.5 0.1' in run with ID 'f2bec5126785418b9ba84a67a9a86d92' ===
Elasticnet model (alpha=0.500000, l1_ratio=0.100000):
  RMSE: 0.7460550348172179
  MAE: 0.576381895873763
  R2: 0.21136606570632266
2021/04/24 14:40:48 INFO mlflow.projects: === Run (ID 'f2bec5126785418b9ba84a67a9a86d92') succeeded ===

위 명령어를 실행하고 나면 동일 경로에 다음처럼 mlruns 디렉토리가 생기고, 다음처럼 생겼다.

$ ls -al
...
drwxr-xr-x   4 heumsi  staff   128  4 24 14:37 mlruns
...

$ tree mlruns -L 3
mlruns
└── 0
    ├── e36ebff4f2444161af4472b3a11d408b
    │   ├── artifacts
    │   ├── meta.yaml
    │   ├── metrics
    │   ├── params
    │   └── tags
    └── meta.yaml

전체적인 구성은 위에서 본 예제와 거의 같다.
다시 mlflow ui 명령어로 대시보드 웹서버를 실행시킨 뒤 접속해서 이를 확인해보자

$ mlflow ui
# 주의 : "mlflow ui" 를 실행하는 디렉토리는 mlruns 가 생성되어 있는 곳이어야 한다.

[2021-04-24 15:57:58 +0900] [59547] [INFO] Starting gunicorn 20.1.0
[2021-04-24 15:57:58 +0900] [59547] [INFO] Listening at: http://127.0.0.1:5000 (59547)
[2021-04-24 15:57:58 +0900] [59547] [INFO] Using worker: sync
[2021-04-24 15:57:58 +0900] [59549] [INFO] Booting worker with pid: 59549

방금 돌린 모델이 잘 들어가있는 것을 알 수 있다.

모델 서빙

이번엔 mlflow/examples 내에 있는 sklearn_logistic_regression MLflow 프로젝트를 살펴보자.
sklearn_logistic_regression 의 내부 구조는 이렇다.

$ tree sklearn_logistic_regression
sklearn_logistic_regression
├── MLproject
├── conda.yaml
└── train.py

train.py 는 이렇게 생겼다.

# train.py

import numpy as np
from sklearn.linear_model import LogisticRegression

import mlflow
import mlflow.sklearn

if __name__ == "__main__":
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr = LogisticRegression()
    lr.fit(X, y)
    score = lr.score(X, y)
    print("Score: %s" % score)
    mlflow.log_metric("score", score)
    mlflow.sklearn.log_model(lr, "model")
    print("Model saved in run %s" % mlflow.active_run().info.run_uuid)

위 예제들과 별반 다른바 없는 코드다.
이제 이 파일을 파이썬으로 실행한다.

$ python sklearn_logistic_regression/train.py --no-conda
Score: 0.6666666666666666
Model saved in run 40cfabcdc6d2439fa97ca3d98bfe1ea1

결과물은 역시 ./mlruns 에 추가된다.
40cfabcdc6d2439fa97ca3d98bfe1ea1 라는 id 를 가지고 새로운 디렉토리가 추가되었음을 알 수 있다.

mlruns
└── 0
    ├── 40cfabcdc6d2439fa97ca3d98bfe1ea1
    │   ├── artifacts
    │   ├── meta.yaml
    │   ├── metrics
    │   ├── params
    │   └── tags
    ├── e36ebff4f2444161af4472b3a11d408b
    │   ├── artifacts
    │   ├── meta.yaml
    │   ├── metrics
    │   ├── params
    │   └── tags
    └── meta.yaml

웹 대시보드에도 역시 추가가 되어있는걸 확인할 수 있다.

이제 이 MLflow 프로젝트를 서빙하는 서버를 띄워보자.
mlflow models serve -m runs:/<RUN_ID>/model 명령어로 가능하다.
이 때 RUN_ID 는 위에서 확인한 40cfabcdc6d2439fa97ca3d98bfe1ea1 를 넣어주면 된다.

$ mlflow models serve -m runs:/40cfabcdc6d2439fa97ca3d98bfe1ea1/model --no-conda --port 5001 --host 0.0.0.0
...

2021/04/24 15:32:49 INFO mlflow.models.cli: Selected backend for flavor 'python_function'
2021/04/24 15:32:49 INFO mlflow.pyfunc.backend: === Running command 'gunicorn --timeout=60 -b 127.0.0.1:5001 -w 1 ${GUNICORN_CMD_ARGS} -- mlflow.pyfunc.scoring_server.wsgi:app'
[2021-04-24 15:32:49 +0900] [58843] [INFO] Starting gunicorn 20.1.0
[2021-04-24 15:32:49 +0900] [58843] [INFO] Listening at: http://127.0.0.1:5001 (58843)
[2021-04-24 15:32:49 +0900] [58843] [INFO] Using worker: sync
[2021-04-24 15:32:49 +0900] [58845] [INFO] Booting worker with pid: 58845
[2021-04-24 15:32:49 +0900] [58843] [INFO] Handling signal: winch

서버가 제대로 잘 동작 하는지 다음처럼 curl 로 요청을 날려보자. 엔드포인트는 /invocations 다.

# https://www.mlflow.org/docs/latest/tutorials-and-examples/tutorial.html

Linux>
curl -X POST -H "Content-Type:application/json; format=pandas-split" --data '{"columns":["alcohol", "chlorides", "citric acid", "density", "fixed acidity", "free sulfur dioxide", "pH", "residual sugar", "sulphates", "total sulfur dioxide", "volatile acidity"],"data":[[12.8, 0.029, 0.48, 0.98, 6.2, 29, 3.33, 1.2, 0.39, 75, 0.66]]}' http://192.168.202.133:5001/invocations

Windows>
curl -X POST -H "Content-Type:application/json; format=pandas-split" --data "{\"columns\":[\"alcohol\", \"chlorides\", \"citric acid\", \"density\", \"fixed acidity\", \"free sulfur dioxide\", \"pH\", \"residual sugar\", \"sulphates\", \"total sulfur dioxide\", \"volatile acidity\"],\"data\":[[12.8, 0.029, 0.48, 0.98, 6.2, 29, 3.33, 1.2, 0.39, 75, 0.66]]}" http://192.168.202.133:5001/invocations

[4.132771301547059]

# 아래는 에러 나서 안됨.
# $ curl -d '{"columns":["x"], "data":[[1], [-1]]}' -H 'Content-Type: application/json; format=pandas-split' -X POST localhost:5001/invocations
# [1, 0]

응답이 잘 오는 것을 확인할 수 있다.

그 외

여기서 살펴보지 않았지만, CLI 커맨드만 보면 대략 어떤 기능들이 더 있는지 알 수 있다.

후기

• MLflow는 머신러닝 모델을 train, test, validation 할 때마다 그 값들을 기록해주는 툴이다.
  • 웹 대시보드가 좀 이쁘네.
  • 아직 뭔가 컨텐츠가 많이는 없는거 같은데, 개발이 더 되거나 플러그인이 더 있지 않을까?
  • 일단 간단하게 시작할 때 써먹기 좋을듯 하다!
• 다만 모델러가 MLflow를 알아야 하는 의존성이 생기긴 하네.
  • 모델러의 코드 파일에 MLflow 코드가 일부 들어갈텐데, 이는 감안해야 하는걸까?
• 변수, 함수명, 프로젝트 패키지 등에서 네이밍이 아주 직관적이고 간단 명료해서 좋았다.
• 서빙까지 지원해주는 것도 인상적이다. 내부적으로 어떻게 돌아가는 걸까?

1) docker mlflow> ps auxwwwe | grep postgres

호스트와 계정 / 비번, 디비 확인

2) docker mlflow> psql -d mlflow mlops

3) table목록

mlflow postgre console>=#\dt

4) select

mlflow postgre console> select * from alembic_version;

9) exit

mlflow postgre console>=#\q

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

root         1  0.0  0.7 435336 129752 ?       Ss   Aug19   0:02 /opt/conda/bin/python /opt/conda/bin/mlflow server --backend-store-uri postgresql+psycopg2://mlops:mlops@postgres/mlflow --host 0.0.0.0:5000 --default-artifact-root artifacts HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow AWS_SECRET_ACCESS_KEY=minioadmin SHLVL=0 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/opt/conda/bin/mlflow

root        15  0.0  0.0  15852  4248 ?        Ss   Aug19   0:01 /usr/sbin/sshd LANGUAGE= LC_TIME= LC_CTYPE= LC_MONETARY= TERM= LC_COLLATE= PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/sbin:/sbin LC_ADDRESS= LANG=C.UTF-8 LC_TELEPHONE= LC_MESSAGES= LC_NAME= LC_MEASUREMENT= LC_IDENTIFICATION= LC_ALL=C.UTF-8 PWD=/ LC_NUMERIC= LC_PAPER= HOME=/root

root        21  0.0  0.1  27780 23100 ?        S    Aug19   2:32 /opt/conda/bin/python /opt/conda/bin/gunicorn -b 0.0.0.0:5000:5000 -w 4 mlflow.server:app HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow AWS_SECRET_ACCESS_KEY=minioadmin SHLVL=0 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/opt/conda/bin/mlflow _MLFLOW_SERVER_FILE_STORE=postgresql+psycopg2://mlops:mlops@postgres/mlflow _MLFLOW_SERVER_ARTIFACT_ROOT=artifacts

root      2394  0.0  0.7 435480 127108 ?       Sl   Aug26   0:06 /opt/conda/bin/python /opt/conda/bin/gunicorn -b 0.0.0.0:5000:5000 -w 4 mlflow.server:app HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow AWS_SECRET_ACCESS_KEY=minioadmin SHLVL=0 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/opt/conda/bin/mlflow _MLFLOW_SERVER_FILE_STORE=postgresql+psycopg2://mlops:mlops@postgres/mlflow _MLFLOW_SERVER_ARTIFACT_ROOT=artifacts

root      7767  0.0  0.0  16500  7712 ?        Ss   Aug19   0:00 sshd: root@notty                                                                                                                                                                                                                                                                                                                  t
root      9785  0.0  0.6 410012 102144 ?       Sl   Aug27   0:04 /opt/conda/bin/python /opt/conda/bin/gunicorn -b 0.0.0.0:5000:5000 -w 4 mlflow.server:app HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow AWS_SECRET_ACCESS_KEY=minioadmin SHLVL=0 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/opt/conda/bin/mlflow _MLFLOW_SERVER_FILE_STORE=postgresql+psycopg2://mlops:mlops@postgres/mlflow _MLFLOW_SERVER_ARTIFACT_ROOT=artifacts

root     13482  0.0  0.6 409756 102000 ?       Sl   Aug28   0:03 /opt/conda/bin/python /opt/conda/bin/gunicorn -b 0.0.0.0:5000:5000 -w 4 mlflow.server:app HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow AWS_SECRET_ACCESS_KEY=minioadmin SHLVL=0 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/opt/conda/bin/mlflow _MLFLOW_SERVER_FILE_STORE=postgresql+psycopg2://mlops:mlops@postgres/mlflow _MLFLOW_SERVER_ARTIFACT_ROOT=artifacts

root     16465  0.0  0.0      0     0 ?        Zs   Aug29   0:04 [ipython] <defunct>

root     20899  0.0  0.0   5752  3628 pts/0    Ss   08:23   0:00 bash PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin HOSTNAME=62861bafe828 TERM=xterm POSTGRES_USER=mlops POSTGRES_PASSWORD=mlops POSTGRES_DB=mlflow AWS_ACCESS_KEY_ID=minioadmin AWS_SECRET_ACCESS_KEY=minioadmin MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 LANG=C.UTF-8 LC_ALL=C.UTF-8 HOME=/root

root     20931  0.0  0.0   9392  3080 pts/0    R+   08:42   0:00 ps auxwwwe CONDA_EXE=/opt/conda/bin/conda _CE_M= HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow CONDA_PREFIX=/opt/conda MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow CONDA_PROMPT_MODIFIER=(base)  AWS_SECRET_ACCESS_KEY=minioadmin TERM=xterm _CE_CONDA= CONDA_SHLVL=1 SHLVL=1 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin CONDA_PYTHON_EXE=/opt/conda/bin/python CONDA_DEFAULT_ENV=base LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/opt/conda/condabin:/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/bin/ps

root     27460  0.0  0.6 410012 102000 ?       Sl   Aug23   0:09 /opt/conda/bin/python /opt/conda/bin/gunicorn -b 0.0.0.0:5000:5000 -w 4 mlflow.server:app HOSTNAME=62861bafe828 POSTGRES_PASSWORD=mlops PWD=/mlflow MLFLOW_S3_ENDPOINT_URL=http://minio:9001 HOME=/root LANG=C.UTF-8 MLFLOW_TRACKING_URI=postgresql+psycopg2://mlops:mlops@postgres/mlflow AWS_SECRET_ACCESS_KEY=minioadmin SHLVL=0 POSTGRES_USER=mlops AWS_ACCESS_KEY_ID=minioadmin LC_ALL=C.UTF-8 PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin POSTGRES_DB=mlflow _=/opt/conda/bin/mlflow _MLFLOW_SERVER_FILE_STORE=postgresql+psycopg2://mlops:mlops@postgres/mlflow _MLFLOW_SERVER_ARTIFACT_ROOT=artifacts