pip install mlflow

# sklearn 연동 포함
pip install mlflow[sklearn]

# 전체 extras 설치
pip install mlflow[extras]

mlflow server --port 5000

import mlflow

# Experiment 설정
mlflow.set_experiment("MLflow Quickstart")

# Run 시작 및 로깅
with mlflow.start_run():
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_param("epochs", 100)
    mlflow.log_metric("accuracy", 0.95)
    mlflow.log_metric("loss", 0.05)
    mlflow.set_tag("model_type", "classification")

with mlflow.start_run():
    # 단일 파라미터 기록
    mlflow.log_param("learning_rate", 0.001)
    mlflow.log_param("batch_size", 32)

    # 다수 파라미터 한 번에 기록
    params = {
        "optimizer": "adam",
        "dropout": 0.3,
        "hidden_layers": 3,
        "activation": "relu"
    }
    mlflow.log_params(params)

with mlflow.start_run():
    for epoch in range(100):
        train_loss = train_one_epoch(model, train_loader)
        val_loss = evaluate(model, val_loader)

        # step별 메트릭 기록 (시계열 추적)
        mlflow.log_metric("train_loss", train_loss, step=epoch)
        mlflow.log_metric("val_loss", val_loss, step=epoch)

    # 최종 메트릭 한 번에 기록
    final_metrics = {"final_accuracy": 0.95, "final_f1": 0.93}
    mlflow.log_metrics(final_metrics)

import matplotlib.pyplot as plt

with mlflow.start_run():
    # 학습 곡선 시각화 저장
    plt.figure(figsize=(10, 6))
    plt.plot(train_losses, label="Train Loss")
    plt.plot(val_losses, label="Validation Loss")
    plt.legend()
    plt.savefig("learning_curve.png")

    # 단일 파일 아티팩트 기록
    mlflow.log_artifact("learning_curve.png", artifact_path="plots")

    # 디렉토리 전체를 아티팩트로 기록
    mlflow.log_artifacts("./output_dir", artifact_path="results")

import mlflow.data
from mlflow.data.pandas_dataset import PandasDataset

dataset = mlflow.data.from_pandas(df, source="s3://my-bucket/data.csv")

with mlflow.start_run():
    mlflow.log_input(dataset, context="training")

import mlflow

# 특정 조건으로 Run 검색
runs = mlflow.search_runs(
    experiment_names=["MLflow Quickstart"],
    filter_string="metrics.accuracy > 0.9 AND params.optimizer = 'adam'",
    order_by=["metrics.accuracy DESC"]
)
print(runs[["params.optimizer", "metrics.accuracy"]])

mlflow server --port 5000

mlflow server \
    --backend-store-uri postgresql://user:password@localhost:5432/mlflow_db \
    --default-artifact-root ./mlartifacts \
    --port 5000

mlflow server \
    --backend-store-uri postgresql://user:password@db-host:5432/mlflow_db \
    --artifacts-destination s3://my-mlflow-bucket/artifacts \
    --port 5000

mlflow server \
    --backend-store-uri postgresql://user:password@db-host:5432/mlflow_db \
    --default-artifact-root s3://my-mlflow-bucket/artifacts \
    --no-serve-artifacts \
    --port 5000

import mlflow

mlflow.set_tracking_uri("http://tracking-server-host:5000")
mlflow.set_experiment("my-experiment")

export MLFLOW_TRACKING_URI=http://tracking-server-host:5000

# 범용 autolog (설치된 모든 지원 라이브러리에 대해 활성화)
mlflow.autolog()

import mlflow
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

mlflow.sklearn.autolog()

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

with mlflow.start_run():
    clf = RandomForestClassifier(n_estimators=100, max_depth=5)
    clf.fit(X_train, y_train)
    # 자동 기록 항목:
    # - Parameters: n_estimators, max_depth, criterion 등
    # - Metrics: accuracy, precision, recall, f1-score
    # - Artifacts: 학습된 모델, confusion matrix, feature importance

import mlflow
import pytorch_lightning as pl
from torch.utils.data import DataLoader

mlflow.pytorch.autolog()

class MyModel(pl.LightningModule):
    def __init__(self, lr=0.001):
        super().__init__()
        self.save_hyperparameters()
        self.model = torch.nn.Linear(10, 2)

    def training_step(self, batch, batch_idx):
        x, y = batch
        loss = torch.nn.functional.cross_entropy(self.model(x), y)
        self.log("train_loss", loss)
        return loss

    def configure_optimizers(self):
        return torch.optim.Adam(self.parameters(), lr=self.hparams.lr)

trainer = pl.Trainer(max_epochs=10)
trainer.fit(model, train_dataloader)
# 자동 기록 항목:
# - Optimizer 이름 및 learning rate
# - training loss, validation loss
# - 모델 체크포인트 및 아티팩트

import mlflow
from transformers import Trainer, TrainingArguments

mlflow.transformers.autolog()

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    logging_steps=100,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

trainer.train()
# 자동 기록: 학습 메트릭, 모델, tokenizer, training arguments 등

name: My ML Project

python_env: python_env.yaml

entry_points:
  main:
    parameters:
      data_file: path
      regularization: { type: float, default: 0.1 }
      epochs: { type: int, default: 100 }
    command: 'python train.py -r {regularization} -e {epochs} {data_file}'

  validate:
    parameters:
      data_file: path
    command: 'python validate.py {data_file}'

python: '3.10'
build_dependencies:
  - pip
dependencies:
  - scikit-learn==1.3.0
  - pandas==2.0.3
  - mlflow

# 로컬 프로젝트 실행
mlflow run . -P regularization=0.5 -P data_file=data/train.csv

# Git URI에서 직접 실행
mlflow run https://github.com/mlflow/mlflow-example -P alpha=0.5

# 특정 entry point 실행
mlflow run . -e validate -P data_file=data/test.csv

import mlflow

mlflow.projects.run(
    uri="https://github.com/mlflow/mlflow-example",
    entry_point="main",
    parameters={"alpha": 0.5, "l1_ratio": 0.1}
)

my_model/
├── MLmodel              # 모델 메타데이터 (YAML)
├── model.pkl            # 직렬화된 모델 파일
├── conda.yaml           # Conda 환경 정의
├── python_env.yaml      # Python 환경 정의
├── requirements.txt     # pip 종속성
└── input_example.json   # 입력 예시 (옵션)

artifact_path: model
flavors:
  python_function:
    env: conda.yaml
    loader_module: mlflow.sklearn
    model_path: model.pkl
    python_version: 3.10.12
  sklearn:
    code: null
    pickled_model: model.pkl
    serialization_format: cloudpickle
    sklearn_version: 1.3.0
mlflow_version: 2.10.0
signature:
  inputs: '[{"name": "feature_1", "type": "double"}, {"name": "feature_2", "type": "double"}]'
  outputs: '[{"type": "long"}]'

from mlflow.models import infer_signature
import mlflow.sklearn

X_train, y_train = load_data()
model = train_model(X_train, y_train)
predictions = model.predict(X_train)

# Signature 자동 추론
signature = infer_signature(X_train, predictions)

with mlflow.start_run():
    mlflow.sklearn.log_model(
        sk_model=model,
        artifact_path="model",
        signature=signature,
        input_example=X_train[:3]
    )

# 모델 로깅
with mlflow.start_run():
    mlflow.sklearn.log_model(model, artifact_path="model")

# 모델 로딩 (프레임워크별)
loaded_model = mlflow.sklearn.load_model("runs:/<run_id>/model")

# 모델 로딩 (범용 pyfunc)
pyfunc_model = mlflow.pyfunc.load_model("runs:/<run_id>/model")
predictions = pyfunc_model.predict(X_test)

# model_code.py
import mlflow

class MyCustomModel(mlflow.pyfunc.PythonModel):
    def predict(self, context, model_input):
        return model_input * 2

mlflow.models.set_model(MyCustomModel())

with mlflow.start_run():
    mlflow.sklearn.log_model(
        sk_model=model,
        artifact_path="model",
        registered_model_name="MyClassifier"  # 등록과 동시에 로깅
    )

result = mlflow.register_model(
    model_uri="runs:/<run_id>/model",
    name="MyClassifier"
)
print(f"Version: {result.version}")

from mlflow import MlflowClient

client = MlflowClient()

# Alias 설정
client.set_registered_model_alias(
    name="MyClassifier",
    alias="champion",
    version=3
)

# Alias로 모델 로딩
model = mlflow.sklearn.load_model("models:/MyClassifier@champion")

client = MlflowClient()

# Registered Model 레벨 태그
client.set_registered_model_tag("MyClassifier", "task", "question-answering")

# Model Version 레벨 태그
client.set_model_version_tag("MyClassifier", version=3, key="validation_status", value="approved")

None → Staging → Production → Archived

# Stage 전환 (Legacy API)
client.transition_model_version_stage(
    name="MyClassifier",
    version=3,
    stage="Production"
)

# Stage로 모델 로딩 (Legacy)
model = mlflow.sklearn.load_model("models:/MyClassifier/Production")

endpoints:
  - name: chat-gpt4
    endpoint_type: llm/v1/chat
    model:
      provider: openai
      name: gpt-4
      config:
        openai_api_key: $OPENAI_API_KEY

  - name: chat-claude
    endpoint_type: llm/v1/chat
    model:
      provider: anthropic
      name: claude-3-opus-20240229
      config:
        anthropic_api_key: $ANTHROPIC_API_KEY

  - name: embeddings
    endpoint_type: llm/v1/embeddings
    model:
      provider: openai
      name: text-embedding-3-small
      config:
        openai_api_key: $OPENAI_API_KEY

# 로컬 REST API 서버로 모델 서빙
mlflow models serve -m "models:/MyClassifier@champion" --port 8080

# Docker 이미지로 빌드
mlflow models build-docker -m "models:/MyClassifier@champion" -n my-model-image

# Docker 컨테이너 실행
docker run -p 8080:8080 my-model-image

curl -X POST http://localhost:8080/invocations \
  -H "Content-Type: application/json" \
  -d '{"inputs": [[1.0, 2.0, 3.0, 4.0]]}'

ingest → split → transform → train → evaluate → register

# recipe.yaml
recipe: 'regression/v1'
target_col: 'price'
positive_class: null
primary_metric: 'root_mean_squared_error'

steps:
  ingest:
    using: 'custom'
    loader_method: load_data

  split:
    split_ratios: [0.75, 0.125, 0.125]

  transform:
    using: 'custom'
    transformer_method: transformer_fn

  train:
    using: 'custom'
    estimator_method: estimator_fn

  evaluate:
    validation_criteria:
      - metric: root_mean_squared_error
        threshold: 10

  register:
    model_name: 'my_regression_model'

from mlflow.recipes import Recipe

recipe = Recipe(profile="local")

# 전체 Recipe 실행
recipe.run()

# 특정 Step까지만 실행
recipe.run("train")

# Step 결과 확인
recipe.inspect("evaluate")

# Airflow DAG에서 MLflow 활용 예시
from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime

def train_model():
    import mlflow
    mlflow.set_tracking_uri("http://mlflow-server:5000")

    with mlflow.start_run():
        model = train()
        mlflow.sklearn.log_model(model, "model", registered_model_name="MyModel")

def evaluate_model():
    import mlflow
    model = mlflow.sklearn.load_model("models:/MyModel/latest")
    metrics = evaluate(model)
    return metrics

dag = DAG("ml_pipeline", start_date=datetime(2026, 1, 1), schedule_interval="@daily")

train_task = PythonOperator(task_id="train", python_callable=train_model, dag=dag)
eval_task = PythonOperator(task_id="evaluate", python_callable=evaluate_model, dag=dag)

train_task >> eval_task

mlflow models build-docker \
    -m "models:/MyClassifier@champion" \
    -n my-model-serving:v1 \
    --enable-mlserver

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model-serving
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
        - name: model
          image: my-model-serving:v1
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: '512Mi'
              cpu: '500m'
            limits:
              memory: '1Gi'
              cpu: '1000m'
---
apiVersion: v1
kind: Service
metadata:
  name: ml-model-service
spec:
  selector:
    app: ml-model
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

# MLproject
name: My Docker Project
docker_env:
  image: my-ml-env:latest
  volumes: ['/data:/data']
  environment: [['MLFLOW_TRACKING_URI', 'http://mlflow-server:5000']]
entry_points:
  main:
    command: 'python train.py'

version: '3.8'
services:
  mlflow:
    image: ghcr.io/mlflow/mlflow:latest
    command: >
      mlflow server
      --backend-store-uri postgresql://mlflow:password@postgres:5432/mlflow
      --artifacts-destination s3://mlflow-artifacts/
      --host 0.0.0.0
      --port 5000
    ports:
      - '5000:5000'
    environment:
      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: mlflow
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mlflow
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data: