메뉴
ML lifecycle management with MLflow. Track experiments, package models, manage registries, and deploy models. Use for ML operations, experiment tracking, and model deployment.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/majiayu000/claude-skill-registry --skill mlflow명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | mlflow |
| description | ML lifecycle management with MLflow. Track experiments, package models, manage registries, and deploy models. Use for ML operations, experiment tracking, and model deployment. |
Complete guide for MLflow - ML lifecycle platform.
| Component | Description |
|---|---|
| Tracking | Log experiments |
| Projects | Package ML code |
| Models | Model packaging |
| Registry | Model versioning |
| Serving | Model deployment |
mlflow run . # Run project
mlflow ui # Start UI
mlflow models serve -m model # Serve model
mlflow server # Start tracking server
# Core
pip install mlflow
# With extras
pip install mlflow[extras]
# Specific integrations
pip install mlflow[gateway] # AI Gateway
pip install mlflow[genai] # GenAI tracking
import mlflow
mlflow.set_experiment()
mlflow.start_run():
mlflow.log_param(, )
mlflow.log_param(, )
mlflow.log_metric(, )
mlflow.log_metric(, )
epoch ():
mlflow.log_metric(, - epoch * , step=epoch)
mlflow.log_artifact()
mlflow.log_artifacts()
mlflow.set_tag(, )
import mlflow
# Scikit-learn
mlflow.sklearn.autolog()
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier()
model.fit(X_train, y_train)
# PyTorch
mlflow.pytorch.autolog()
# TensorFlow/Keras
mlflow.tensorflow.autolog()
# XGBoost
mlflow.xgboost.autolog()
# LightGBM
mlflow.lightgbm.autolog()
# Create run manually
run = mlflow.start_run(run_name="my-run")
try:
mlflow.log_param("param1", "value1")
mlflow.log_metric("metric1", 0.9)
finally:
mlflow.end_run()
# Get run info
run_id = run.info.run_id
print(f"Run ID: {run_id}")
# Resume run
with mlflow.start_run(run_id=run_id):
mlflow.log_metric("additional_metric", 0.95)
with mlflow.start_run(run_name="parent"):
mlflow.log_param("parent_param", "value")
for i in range(3):
with mlflow.start_run(run_name=f"child_{i}", nested=True):
mlflow.log_param("child_param", i)
mlflow.log_metric("child_metric", i * 0.1)
# Local file store
mlflow server --host 0.0.0.0 --port 5000
# With database backend
mlflow server \
--backend-store-uri postgresql://user:pass@localhost/mlflow \
--default-artifact-root s3://mlflow-artifacts/ \
--host 0.0.0.0 \
--port 5000
# With SQLite
mlflow server \
--backend-store-uri sqlite:///mlflow.db \
--default-artifact-root ./mlruns \
--host 0.0.0.0
import mlflow
mlflow.set_tracking_uri("http://localhost:5000")
# Or via environment
# export MLFLOW_TRACKING_URI=http://localhost:5000
services:
mlflow:
image: ghcr.io/mlflow/mlflow:latest
ports:
- "5000:5000"
environment:
- MLFLOW_BACKEND_STORE_URI=postgresql://mlflow:mlflow@postgres/mlflow
- MLFLOW_DEFAULT_ARTIFACT_ROOT=s3://mlflow-artifacts/
- AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
- AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
command: >
mlflow server
--host 0.0.0.0
--port 5000
depends_on:
- postgres
postgres:
image: postgres:15
environment:
- POSTGRES_USER=mlflow
- POSTGRES_PASSWORD=mlflow
- POSTGRES_DB=mlflow
volumes:
- postgres_data:/var/lib/postgresql/data
volumes:
postgres_data:
from sklearn.ensemble import RandomForestClassifier
import mlflow.sklearn
model = RandomForestClassifier()
model.fit(X_train, y_train)
with mlflow.start_run():
# Log model
mlflow.sklearn.log_model(
model,
artifact_path="model",
registered_model_name="my-rf-model"
)
# With signature
from mlflow.models import infer_signature
signature = infer_signature(X_train, model.predict(X_train))
mlflow.sklearn.log_model(model, "model", signature=signature)
import mlflow.pytorch
with mlflow.start_run():
mlflow.pytorch.log_model(
pytorch_model=model,
artifact_path="model",
conda_env="conda.yaml",
code_paths=["./src"]
)
import mlflow.pyfunc
class MyModel(mlflow.pyfunc.PythonModel):
def load_context(self, context):
# Load any artifacts
import pickle
with open(context.artifacts["model_path"], "rb") as f:
self.model = pickle.load(f)
def predict(self, context, model_input):
return self.model.predict(model_input)
# Log custom model
with mlflow.start_run():
mlflow.pyfunc.log_model(
artifact_path="model",
python_model=MyModel(),
artifacts={"model_path": "model.pkl"},
conda_env={
"dependencies": ["scikit-learn==1.0.0", "pandas"]
}
)
# From run
model = mlflow.sklearn.load_model(f"runs:/{run_id}/model")
# From registry
model = mlflow.sklearn.load_model("models:/my-model/1")
model = mlflow.sklearn.load_model("models:/my-model/Production")
# As PyFunc
model = mlflow.pyfunc.load_model(f"runs:/{run_id}/model")
predictions = model.predict(X_test)
# During logging
mlflow.sklearn.log_model(
model,
"model",
registered_model_name="my-model"
)
# After logging
result = mlflow.register_model(
model_uri=f"runs:/{run_id}/model",
name="my-model"
)
from mlflow import MlflowClient
client = MlflowClient()
# Get model versions
versions = client.search_model_versions("name='my-model'")
# Transition stage
client.transition_model_version_stage(
name="my-model",
version=1,
stage="Production" # None, Staging, Production, Archived
)
# Add description
client.update_model_version(
name="my-model",
version=1,
description="Production model v1"
)
# Add tags
client.set_model_version_tag(
name="my-model",
version=1,
key="validation_status",
value="approved"
)
# Set alias (MLflow 2.0+)
client.set_registered_model_alias(
name="my-model",
alias="champion",
version=1
)
# Load by alias
model = mlflow.pyfunc.load_model("models:/my-model@champion")
# Delete alias
client.delete_registered_model_alias(
name="my-model",
alias="champion"
)
# Serve from run
mlflow models serve -m runs:/<run_id>/model -p 5001
# Serve from registry
mlflow models serve -m models:/my-model/Production -p 5001
# With environment
mlflow models serve -m models:/my-model/1 -p 5001 --env-manager=conda
curl -X POST http://localhost:5001/invocations \
-H "Content-Type: application/json" \
-d '{"dataframe_split": {"columns": ["a", "b"], "data": [[1, 2]]}}'
# Build Docker image
mlflow models build-docker -m models:/my-model/1 -n my-model-image
# Run container
docker run -p 5001:8080 my-model-image
apikind: Deployment
metadata:
name: mlflow-model
spec:
replicas: 2
selector:
matchLabels:
app: mlflow-model
template:
metadata:
labels:
app: mlflow-model
spec:
containers:
- name: model
image: my-model-image:latest
ports:
- containerPort: 8080
resources:
requests:
memory: "512Mi"
cpu: "500m"
---
apikind: Service
metadata:
name: mlflow-model-service
spec:
selector:
app: mlflow-model
ports:
- port: 80
targetPort: 8080
# MLproject
name: my-project
conda_env: conda.yaml
entry_points:
main:
parameters:
learning_rate: {type: float, default: 0.01}
epochs: {type: int, default: 100}
command: "python train.py --lr {learning_rate} --epochs {epochs}"
validate:
parameters:
model_path: {type: string}
command: "python validate.py --model {model_path}"
name: my-project-env
channels:
- conda-forge
dependencies:
- python=3.10
- pip
- pip:
- mlflow
- scikit-learn
- pandas
# Local
mlflow run . -P learning_rate=0.001 -P epochs=50
# From Git
mlflow run https://github.com/user/repo -P param=value
# Specific entry point
mlflow run . -e validate -P model_path=./model
# With environment
mlflow run . --env-manager=conda
import mlflow
mlflow.set_experiment("llm-experiment")
with mlflow.start_run():
# Log LLM params
mlflow.log_params({
"model": "gpt-4",
"temperature": 0.7,
"max_tokens": 1000
})
# Make LLM call
response = openai_client.chat.completions.create(...)
# Log input/output
mlflow.log_text(prompt, "input.txt")
mlflow.log_text(response.choices[0].message.content, "output.txt")
# Log usage
mlflow.log_metrics({
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens
})
import mlflow
mlflow.langchain.autolog()
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
llm = ChatOpenAI(model="gpt-4o")
prompt = ChatPromptTemplate.from_template("Tell me about {topic}")
chain = prompt | llm
# Automatically logged
result = chain.invoke({"topic": "MLflow"})
import mlflow
# Evaluation dataset
eval_data = pd.DataFrame({
"inputs": ["Question 1", "Question 2"],
"ground_truth": ["Answer 1", "Answer 2"]
})
with mlflow.start_run():
results = mlflow.evaluate(
model="runs:/{run_id}/model",
data=eval_data,
targets="ground_truth",
model_type="question-answering",
evaluators="default"
)
print(results.metrics)
from mlflow import MlflowClient
client = MlflowClient()
# Search runs
runs = client.search_runs(
experiment_ids=["1"],
filter_string="metrics.accuracy > 0.9 AND params.model_type = 'rf'",
order_by=["metrics.accuracy DESC"],
max_results=10
)
for run in runs:
print(f"Run: {run.info.run_id}")
print(f" Accuracy: {run.data.metrics.get('accuracy')}")
print(f" Params: {run.data.params}")
# Get best run
best_run = runs[0]
import mlflow
# Get runs
runs = mlflow.search_runs(
experiment_names=["my-experiment"],
filter_string="status = 'FINISHED'"
)
# Compare as DataFrame
print(runs[["run_id", "params.learning_rate", "metrics.accuracy"]])
# Get artifacts
client = MlflowClient()
artifacts = client.list_artifacts(run_id)
ml-project/
├── MLproject
├── conda.yaml
├── src/
│ ├── train.py
│ ├── evaluate.py
│ └── utils.py
├── data/
├── notebooks/
└── tests/
import argparse
import mlflow
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--lr", type=float, default=0.01)
parser.add_argument("--epochs", type=int, default=100)
args = parser.parse_args()
mlflow.set_experiment("my-experiment")
with mlflow.start_run():
# Log parameters
mlflow.log_params(vars(args))
# Train model
model = train(args.lr, args.epochs)
# Log metrics
metrics = evaluate(model)
mlflow.log_metrics(metrics)
# Log model
mlflow.sklearn.log_model(
model,
"model",
signature=infer_signature(X, y),
registered_model_name="my-model"
)
if __name__ == "__main__":
main()