> 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-razvertyvanie/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" %}
Стандартный backend 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"Запуск записан в 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"Точность на тесте: {score:.4f}")
    # Все параметры, метрики и модель автоматически записаны!
```

***

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

Регистрируйте и управляйте версиями моделей через интерфейс или 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"Версия: {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, ...]]}'
```

***

## Расширенная конфигурация

### Backend 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 по адресу `http://<clore-host>:<port>`
2. Выберите эксперимент на левой панели
3. Отметьте флажками несколько запусков
4. Нажмите **Сравнить** чтобы увидеть метрики и параметры рядом
5. Используйте **Вкладка Charts** для визуального сравнения

***

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

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

```
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 — не просто локальный путь).

***

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

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

{% 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)
* [Справочник API отслеживания MLflow](https://mlflow.org/docs/latest/python_api/mlflow.html)

***

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

| Сценарий использования          | Рекомендуемый GPU | Оценочная стоимость на Clore.ai             |
| ------------------------------- | ----------------- | ------------------------------------------- |
| Разработка/тестирование         | RTX 3090 (24 ГБ)  | $0.07–0.21/гпу/ч                            |
| Обучение в продакшене           | RTX 4090 (24 ГБ)  | $0.14–0.42/гпу/ч                            |
| Эксперименты в крупном масштабе | A100 80 ГБ        | [голое железо](https://clore.ai/bare-metal) |

> 💡 Все примеры в этом руководстве можно развернуть на [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-razvertyvanie/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.