> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/mlops-i-razvyortyvanie/mlflow.md).

# MLflow

**MLflow** — это платформа с открытым исходным кодом для управления полным **жизненным циклом машинного обучения** — от отслеживания экспериментов и версионирования моделей до деплоя и мониторинга. Используемый тысячами организаций по всему миру, MLflow привносит структуру и воспроизводимость в рабочие процессы ML. Запустите его в GPU-облаке Clore.ai, чтобы получить централизованный сервер отслеживания рядом с вашими задачами обучения.

***

## Что такое MLflow?

MLflow предоставляет четыре основных компонента:

| Компонент           | Описание                                                                 |
| ------------------- | ------------------------------------------------------------------------ |
| **Отслеживание**    | Логгирование параметров, метрик, артефактов и кода из ML-запусков        |
| **Проекты**         | Упаковка кода для воспроизводимых запусков                               |
| **Модели**          | Стандартный формат модели для развертывания в разных фреймворках         |
| **Регистр моделей** | Централизованное хранилище моделей с версионированием и жизненным циклом |

**Поддерживаемые фреймворки (встроенное автологирование):**

* PyTorch, TensorFlow/Keras
* Scikit-learn, XGBoost, LightGBM
* HuggingFace Transformers
* Spark MLlib, statsmodels, Prophet

***

## Требования

| Требование | Значение                                |
| ---------- | --------------------------------------- |
| VRAM GPU   | Любой (сам сервер MLflow нагружает CPU) |
| Хранилище  | 20 ГБ+ (для артефактов)                 |
| ОЗУ        | Минимум 4 ГБ для сервера                |
| Порты      | 22 (SSH), 5000 (интерфейс MLflow)       |

{% hint style="info" %}
Сервер отслеживания MLflow лёгкий. Вы можете запустить его на небольшой CPU-инстансе и направлять на него ваши GPU-задачи обучения. Альтернативно, разместите его вместе с вашим GPU-инстансом для обучения.
{% endhint %}

***

## Шаг 1 — Арендуйте сервер на Clore.ai

1. Войдите в [clore.ai](https://clore.ai).
2. Нажмите **Маркетплейс**.
3. Для выделенного сервера отслеживания: фильтруйте по RAM ≥ 8 ГБ (GPU необязательно).
4. Для совместного размещения: используйте ваш существующий инстанс для обучения.
5. Установите Docker-образ: **`ghcr.io/mlflow/mlflow:latest`**
6. Установите открытые порты: `22` (SSH) и `5000` (интерфейс MLflow).
7. Нажмите **Арендовать**.

***

## Шаг 2 — Запустите сервер отслеживания MLflow

Официальный `ghcr.io/mlflow/mlflow` образ требует переопределения команды запуска.

### В конфигурации Docker Clore.ai

Установите **команду** (или переопределение entrypoint) в:

```bash
bash -c "apt-get update -q && apt-get install -y -q openssh-server && \
    mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
    service ssh start && \
    mlflow server \
        --host 0.0.0.0 \
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db"
```

### Альтернатива: собственный Dockerfile

```dockerfile
FROM ghcr.io/mlflow/mlflow:latest

RUN apt-get update && apt-get install -y \
    openssh-server \
    && rm -rf /var/lib/apt/lists/*

# Настроить SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Дополнительные Python-пакеты
RUN pip install boto3 psycopg2-binary

RUN mkdir -p /mlflow/artifacts

EXPOSE 22 5000

CMD service ssh start && \
    mlflow server \
        --host 0.0.0.0 \
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db
```

***

## Шаг 3 — Доступ к интерфейсу MLflow

Откройте ваш браузер:

```
http://<clore-host>:<public-port-5000>
```

Вы должны увидеть панель экспериментов MLflow.

{% hint style="info" %}
Бэкенд по умолчанию — SQLite (`mlflow.db`) хранит все метаданные запусков локально. Для продакшна или командного использования переключитесь на PostgreSQL — см. раздел «Расширенная конфигурация» ниже.
{% endhint %}

***

## Шаг 4 — Залогируйте ваш первый эксперимент

### Подключение из удалённой задачи обучения

На вашей машине для обучения (или другом инстансе Clore.ai) установите URI отслеживания:

```bash
export MLFLOW_TRACKING_URI=http://<clore-host>:<public-port-5000>
```

### Базовое логгирование эксперимента PyTorch

```python
import mlflow
import mlflow.pytorch
import torch
import torch.nn as nn
import torch.optim as optim

# Подключение к серверу MLflow
mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("my-first-experiment")

# Определите простую модель
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

# Обучение с отслеживанием в MLflow
with mlflow.start_run(run_name="training-run-001"):
    # Логгирование гиперпараметров
    params = {
        "learning_rate": 0.001,
        "batch_size": 64,
        "epochs": 100,
        "hidden_size": 256,
        "optimizer": "adam"
    }
    mlflow.log_params(params)
    
    # Инициализировать модель
    model = SimpleNet(784, 256, 10).cuda()
    optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"])
    criterion = nn.CrossEntropyLoss()
    
    # Цикл обучения
    for epoch in range(params["epochs"]):
        loss = torch.tensor(0.5 / (epoch + 1))  # Смоделировано
        accuracy = 0.7 + epoch * 0.003
        
        # Логгирование метрик на каждой эпохе
        mlflow.log_metrics({
            "train_loss": loss.item(),
            "train_accuracy": accuracy,
        }, step=epoch)
    
    # Логгирование финальной модели
    mlflow.pytorch.log_model(model, "model")
    
    # Логгирование финальных метрик
    mlflow.log_metric("final_accuracy", accuracy)
    
    print(f"Run logged to MLflow. ID: {mlflow.active_run().info.run_id}")
```

### Автологирование HuggingFace Transformers

```python
import mlflow
from transformers import TrainingArguments, Trainer

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("llm-finetuning")

# Включите автологирование — автоматически логгирует параметры, метрики и модель
mlflow.transformers.autolog()

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    evaluation_strategy="epoch",
)

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

with mlflow.start_run():
    trainer.train()
```

***

## Шаг 5 — Scikit-learn с автологированием

```python
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("sklearn-experiments")

# Автологируйте всё
mlflow.sklearn.autolog()

X, y = load_digits(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(run_name="random-forest-v1"):
    rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
    rf.fit(X_train, y_train)
    
    score = rf.score(X_test, y_test)
    print(f"Test Accuracy: {score:.4f}")
    # Все параметры, метрики и модель будут автоматически залогированы!
```

***

## Шаг 6 — Регистр моделей

Регистрируйте и управляйте версиями моделей через UI или API:

```python
import mlflow

client = mlflow.MlflowClient("http://<clore-host>:<public-port-5000>")

# Зарегистрировать модель из запуска
run_id = "your-run-id-here"
model_uri = f"runs:/{run_id}/model"

registered = mlflow.register_model(
    model_uri=model_uri,
    name="production-classifier"
)

print(f"Version: {registered.version}")

# Перевод модели на стадию
client.transition_model_version_stage(
    name="production-classifier",
    version=registered.version,
    stage="Production"
)

# Загрузить production-модель где угодно
model = mlflow.pyfunc.load_model(
    model_uri="models:/production-classifier/Production"
)
```

***

## Шаг 7 — Обслуживание модели

MLflow может обслуживать любую залогированную модель как REST API:

```bash
# На инстансе сервера MLflow
export MLFLOW_TRACKING_URI=http://localhost:5000

mlflow models serve \
    --model-uri "models:/production-classifier/Production" \
    --host 0.0.0.0 \
    --port 5001 \
    --no-conda
```

Протестируйте обслуживаемую модель:

```bash
curl -X POST http://<clore-host>:5001/invocations \
    -H "Content-Type: application/json" \
    -d '{"inputs": [[1.0, 2.0, 3.0, ...]]}'
```

***

## Расширенные настройки

### PostgreSQL в качестве бэкенда (продакшн)

```bash
# Запуск с PostgreSQL
mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --backend-store-uri postgresql://user:password@db-host/mlflow \
    --default-artifact-root s3://my-bucket/mlflow-artifacts
```

### Хранилище артефактов S3

```bash
pip install boto3

export AWS_ACCESS_KEY_ID=your_key
export AWS_SECRET_ACCESS_KEY=your_secret

mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --default-artifact-root s3://my-mlflow-bucket/artifacts \
    --backend-store-uri sqlite:////mlflow/mlflow.db
```

### Аутентификация (Enterprise)

```bash
pip install mlflow[auth]

mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --app-name basic-auth \
    --backend-store-uri sqlite:////mlflow/mlflow.db \
    --default-artifact-root /mlflow/artifacts
```

***

## Сравнение запусков в интерфейсе

1. Откройте MLflow UI по адресу `http://<clore-host>:<port>`
2. Выберите эксперимент в левой панели
3. Отметьте флажками несколько запусков
4. Нажмите **Сравнить** чтобы увидеть метрики и параметры бок о бок
5. Используйте вкладку **Графики** для визуального сравнения

***

## Устранение неполадок

### Не удаётся подключиться к серверу отслеживания

```
mlflow.exceptions.MlflowException: API-запрос завершился с кодом состояния 503
```

**Решения:**

* Проверьте, открыт ли порт 5000 и перенаправлен в Clore.ai
* Убедитесь, что сервер запущен: `ps aux | grep mlflow`
* Проверьте соединение: `curl http://<clore-host>:<port>/health`

### Загрузка артефактов не удалась

**Решение:** Убедитесь, что директория артефактов доступна для записи:

```bash
chmod 777 /mlflow/artifacts
```

### Ошибка блокировки SQLite (конкурентные записи)

**Решение:** Переключитесь на PostgreSQL для многопользовательских настроек:

```bash
pip install psycopg2-binary
```

### Регистр моделей не отображается

**Решение:** Убедитесь, что вы используете `--backend-store-uri` который поддерживает регистр (SQLite или PostgreSQL — а не просто локальный путь).

***

## Оценка стоимости

| Инстанс    | Сценарий использования              | Примерная цена | Примечания                             |
| ---------- | ----------------------------------- | -------------- | -------------------------------------- |
| CPU 4‑ядра | Только сервер отслеживания          | \~$0.05/ч      | Очень лёгкий                           |
| RTX 3080   | Совместное размещение с обучением   | \~$0.10/час    | Обучение + MLflow                      |
| RTX 4090   | Интенсивное обучение + отслеживание | \~$0.35/час    | Наиболее распространённая конфигурация |

{% hint style="info" %}
Запустите MLflow на дешёвом CPU-инстансе и направляйте на него все ваши GPU-задачи обучения. Так сервер отслеживания работает постоянно, не расходуя дорогие GPU-часы.
{% endhint %}

***

## Полезные ресурсы

* [Официальная документация MLflow](https://mlflow.org/docs/latest/index.html)
* [MLflow на GitHub](https://github.com/mlflow/mlflow)
* [MLflow на Docker Hub](https://github.com/mlflow/mlflow/pkgs/container/mlflow)
* [Руководство по регистру моделей MLflow](https://mlflow.org/docs/latest/model-registry.html)
* [Справочник по Tracking API MLflow](https://mlflow.org/docs/latest/python_api/mlflow.html)

***

## Рекомендации Clore.ai по GPU

| Сценарий использования          | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ------------------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование         | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Продакшн-обучение               | RTX 4090 (24GB)   | \~$0.70/gpu/hr                  |
| Эксперименты в крупном масштабе | A100 80GB         | \~$1.20/gpu/hr                  |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/mlops-i-razvyortyvanie/mlflow.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.