Из этой статьи вы узнаете о том, как с помощью Docker упаковать, запустить и развернуть в продакшне полноценный ML-сервис для выдачи прогнозов. Мы рассмотрим все основные действия, необходимые для решения этих задач — от обучения модели до предоставления доступа к ней посредством API и до её распространения в виде образа контейнера.

Среди тем, которые мы сегодня обсудим, можно отметить следующие:

• Основные концепции Docker (образы, контейнеры, слои образов, кеширование), понимание которых необходимо для решения задач машинного обучения.

• Обучение простой модели-классификатора и обеспечение доступа к ней с помощью FastAPI.

• Создание файла Dockerfile, обеспечивающего эффективную работу системы, локальный запуск контейнера и отправка образа на Docker Hub.

Введение

Модели машинного обучения в разных средах часто ведут себя по-разному. Например, модель, которая нормально работает на вашем ноутбуке, может дать сбой на компьютере коллеги или в продакшн-окружении. Случается такое из-за несоответствия версий каких-либо программ, из-за отсутствующих зависимостей, из-за различий системного уровня. Это неоправданно усложняет совместную работу над моделями и их развёртывание.

Docker решает эти проблемы, позволяя упаковать ML-приложение в стандартизированный контейнер, который будет абсолютно одинаково работать везде, где его запустят. Под ML-приложением мы понимаем всё, что обеспечивает работу модели — саму модель, код, зависимости, среду выполнения кода. Получается, что с помощью Docker можно, один раз собрав всё необходимое, запускать это где угодно, не опасаясь столкнуться с проблемами, касающимися настроек рабочей среды, или с конфликтами зависимостей.

Здесь мы, опираясь на простой пример, разберёмся с тем, как упаковывать ML-модели в Docker-контейнеры. Вот наши основные темы:

• Основы Docker.

• Сборка и развёртывание ML-моделей.

• Контейнеризация ML-приложений с помощью Docker.

• Написание файлов Dockerfile, оптимизированных в расчёте на ML-задачи.

Сделаем первый шаг к созданию моделей, которые способны правильно работать везде, где работает Docker.

Вот — GitHub-репозиторий с кодом к статье.

Предварительные требования

Прежде чем вы приступите к изучению контейнеризации ML-моделей с помощью Docker, проверьте — есть ли у вас следующие программы и навыки.

Обязательные:

• Python 3.11 (или более свежая версия).

• Фреймворк FastAPI и необходимые зависимости (если у вас его пока нет — ничего страшного — мы установим его в ходе работы).

• Основные навыки работы в командной строке/терминале.

• Docker Desktop (загрузить его можно здесь).

• Текстовый редактор или IDE.

Необязательные, но полезные:

• Понимание концепций машинного обучения.

• Знакомство с виртуальными окружениями Python.

• Опыт работы с REST API.

Быстро проверить работоспособность Docker можно так:

docker --version
docker run hello-world

Если обе эти команды работают — значит всё готово к началу наших экспериментов.

Основы Docker для ML-инженеров

Прежде чем собрать первый ML-контейнер, предлагаю разобраться с фундаментальными вещами. На первый взгляд платформа Docker может показаться чем-то очень сложным, но после того, как вы освоите идеи, на которых она основана, всё тут же встанет на свои места.

Что такое Docker и зачем эта платформа ML-инженерам?

Docker — это платформа, которая позволяет упаковывать приложения и все их зависимости в стандартизированные объекты, называемые контейнерами. Docker помогает решать несколько важных задач, встающих перед ML-инженерами, касающихся разработки и развёртывания соответствующих систем.

В машинном обучении распространена проблема, возникающая, когда код ведёт себя по-разному при его запуске в разных системах. Происходит это из-за того, что на этих системах установлены разные версии Python, или разные версии необходимых для проектов библиотек. Docker успешно с этим борется, позволяя упаковывать в контейнеры те среды, в которых выполняется код. Это позволяет обеспечить единообразное поведение программ на любых системах

ML-проекты часто сильно зависят от сложных стеков технологий, при построении которых предъявляются жёсткие требования к версиям входящих в них программ. Например, библиотека TensorFlow может быть привязана к определённым релизам CUDA, а библиотека PyTorch может конфликтовать с какими-то версиями NumPy. Контейнеры Docker надёжно изолируют подобные зависимости, предотвращая конфликты версий и упрощая настройку систем под конкретные проекты.

Воспроизводимость результатов — это краеугольный камень ML-исследований и практического использования результатов этих исследований. Упаковывая код, библиотеки и системные зависимости в самостоятельный образ, Docker позволяет абсолютно точно воссоздать и сами эксперименты, и их результаты.

Развёртывание моделей обычно подразумевает изменение настроек рабочих окружений разных физических компьютеров или облачных серверов. С использованием Docker окружение, однажды созданное, может работать где угодно, минимизируя время, необходимое для настройки систем и сокращая риски, связанные с развёртыванием проектов.

Сравнение образов и контейнеров Docker

Вот — самая важная вещь, которую нужно понять о Docker. Многие начинающие пользователи этой платформы путают образы и контейнеры, а ведь это — сущности, принципиально друг от друга отличающиеся.

Образ (image) Docker сравним с чертежом какой-нибудь детали или с рецептом блюда. Это — шаблон, предназначенный только для чтения, в котором содержится следующее:

• Операционная система (обычно — легковесный дистрибутив Linux).

• Код приложения.

• Все зависимости и библиотеки.

• Конфигурационные файлы.

• Инструкции по запуску приложения.

Это можно сравнить с определением класса в программировании. Образ описывает некий объект, но сам по себе никаких действий не предпринимает.

Контейнер (container) Docker — это работающий экземпляр образа. Это — как объект, созданный на основе класса. Можно создать на основе одного и того же образа множество контейнеров — так же, как на основе одного класса можно создать множество объектов.

Вот пример:

# Это - ОБРАЗ - шаблон
docker build -t my-ml-model:v1 .

# Это - КОНТЕЙНЕРЫ - работающие экземпляры образа
docker run --name experiment-1 my-ml-model:v1
docker run --name experiment-2 my-ml-model:v1
docker run --name experiment-3 my-ml-model:v1

Мы ещё не говорили о командах Docker. Сейчас вам достаточно знать о том, что собрать образ можно с помощью команды docker build, а запустить контейнер можно с помощью команды docker run. Здесь мы создали один образ и три самостоятельных контейнера. Каждый из контейнеров выполняется независимо от других, пользуясь собственной памятью, запуская собственные процессы, но все эти контейнеры созданы на основе одного и того же образа.

Файл Dockerfile

Файл Dockerfile — это то место, куда пишут инструкции по сборке образа. Это — обычный текстовый файл (его имя выглядит в точности как Dockerfile — без расширения), который Docker читает сверху вниз.

Docker собирает образы по слоям (layer). Выполнение каждой из инструкций в Dockerfile приводит к созданию нового слоя в образе. Docker кеширует слои, а это, если в каких-то слоях после доработки проекта ничего не поменялось, ускоряет повторную сборку образов.

Организация постоянного хранения данных с помощью томов

Контейнеры — сущности эфемерные. Когда контейнер удаляют — исчезает всё, что в нём было. В ML-среде это — проблема, так как инженерам надо сохранять логи обучения и контрольные точки моделей, результаты экспериментов.

Тома (volumes) решают эту проблему посредством монтирования директорий хост-системы в контейнер:

docker run -v /path/on/host:/path/in/container my-model

Теперь файлы, записанные в /path/in/container, на самом деле, хранятся в директории хоста /path/on/host. Они никуда не денутся даже в том случае, если контейнер будет удалён.

Для задач машинного обучения может понадобиться смонтировать следующие директории:

docker run \
  -v $(pwd)/data:/app/data \
  -v $(pwd)/models:/app/models \
  -v $(pwd)/logs:/app/logs \
  my-training-container

При таком подходе обученные модели, наборы данных и логи будут находиться на устройстве для постоянного хранения данных за пределами контейнера.

Сетевые взаимодействия и проброс портов

Когда запускают контейнер, ему назначается собственное сетевое пространство имён. Для того чтобы получить доступ к сервису, который работает внутри контейнера, нужно организовать проброс портов (port mapping):

docker run -p 8000:8000 my-api

Эта команда позволяет сопоставить порт 8000 компьютера с портом 8000 контейнера. Формат указания портов выглядит так: host_port:container_port.

При работе с API систем машинного обучения такой подход позволяет одновременно запускать несколько версий модели:

# Две версии модели запущены одновременно
docker run -d -p 8000:8000 --name wine-api-v1 yourusername/wine-predictor:v1
docker run -d -p 8001:8000 --name wine-api-v2 yourusername/wine-predictor:v2
# Версия v1 доступна по адресу http://localhost:8000, а v2 - по адресу http://localhost:8001

Почему мы выбираем Docker, а не виртуальные окружения?

Тут у вас может появиться такой вопрос: «А почему бы просто не использовать venv или conda?». А вот почему.

Виртуальные окружения (virtual environments) — это среды, которые создают изолированные пространства лишь для Python-пакетов. Они не изолируют системные библиотеки (вроде драйверов CUDA), не сглаживают различия между операционными системами (например — между Linux и Windows), не работают с зависимостями системного уровня (libgomp, libgfortran).

Docker же изолирует всё. Один и тот же контейнер одинаково работает и на вашем MacBook, и на настольном Windows-ПК вашего коллеги, и на облачном Linux-сервере. Кроме того, Docker до предела упрощает одновременное применение разных версий Python. А это, если пользоваться виртуальными окружениями, та ещё задачка.

Контейнеризация ML-приложения с помощью Docker

Теперь, когда мы освоили основы Docker — перейдём к практике. Создадим модель, прогнозирующую качество вина, воспользовавшись для этого набором данных wine из библиотеки scikit-learn. Доступ к модели организуем с помощью API, подготовив её к использованию в продакшн-среде. Вот чем мы займёмся:

• Разработаем и обучим классификатор, основанный на алгоритме Random Forest (случайный лес).

• Создадим FastAPI-приложение, которое будет выдавать прогнозы.

• Напишем файл Dockerfile, обеспечивающий эффективную работу системы.

• Соберём и запустим контейнер на локальной машине.

• Протестируем конечные точки API.

• Отправим образ на Docker Hub для того, чтобы распространить его среди заинтересованных лиц.

Шаг 1: подготовка и настройка проекта

Создадим директорию проекта, содержащую следующие файлы (их содержимым мы займёмся ниже):

wine-predictor/
├── train_model.py
├── app.py
├── requirements.txt
├── Dockerfile
└── .dockerignore

Вам необязательно придерживаться именно такой структуры проекта. Это — лишь рекомендация.

Далее — создадим и активируем виртуальное окружение:

python3 -m venv v1
source v1/bin/activate

Установим необходимые пакеты:

pip install fastapi uvicorn pandas scikit-learn

Шаг 2: разработка модели машинного обучения

Теперь надо создать модель машинного обучения. Для работы с ней будет использован набор данных wine, встроенный в scikit-learn.

Создадим файл train_model.py со следующим содержимым:

import pickle
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler

# Загружаем набор данных wine
wine = load_wine()
X, y = wine.data, wine.target

# Разбиваем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Масштабируем признаки
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Обучаем модель
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

# Оцениваем модель
accuracy = model.score(X_test_scaled, y_test)
print(f"Model accuracy: {accuracy:.2f}")

# Сохраняем модель и объект для масштабирования признаков
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

with open('scaler.pkl', 'wb') as f:
    pickle.dump(scaler, f)

print("Model and scaler saved successfully!")

Разберём этот код. Сначала загружаем набор данных wine, который содержит сведения о 13 характеристиках различных вин. После разбиения данных на обучающую и тестовую выборки мы масштабируем признаки, используя StandardScaler. Далее — обучаем классификатор RandomForestClassifier, после чего сохраняем и модель, и объект, используемый для масштабирования признаков. Зачем сохранять этот объект? Всё дело в том, что нам, когда мы будем давать прогнозы относительно качества вина, понадобится масштабировать новые данные, обрабатывая их точно так же, как обрабатывали обучающие данные.

Для обучения и сохранения модели запустим следующий скрипт:

python3 train_model.py

Он, в ходе работы, выведет сведения о точности модели и подтверждение сохранения файлов.

Шаг 3: создание FastAPI-приложения

Создадим API для модели, воспользовавшись фреймворком FastAPI. Приложение будет загружать обученную модель и, при обращении к соответствующему API, выдавать прогнозы.

Создадим файл app.py:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import pickle
import numpy as np

app = FastAPI(title="Wine Quality Predictor")

# При запуске скрипта загрузим модель и объект для масштабирования признаков
with open('model.pkl', 'rb') as f:
    model = pickle.load(f)

with open('scaler.pkl', 'rb') as f:
    scaler = pickle.load(f)

# Названия классов вина, используемые для формирования более понятных выходных данных
wine_classes = ['Class 0', 'Class 1', 'Class 2']

class WineFeatures(BaseModel):
    alcohol: float
    malic_acid: float
    ash: float
    alcalinity_of_ash: float
    magnesium: float
    total_phenols: float
    flavanoids: float
    nonflavanoid_phenols: float
    proanthocyanins: float
    color_intensity: float
    hue: float
    od280_od315_of_diluted_wines: float
    proline: float

    # Пример схемы, совместимой с Pydantic v2
    model_config = {
        "json_schema_extra": {
            "example": {
                "alcohol": 13.2,
                "malic_acid": 2.77,
                "ash": 2.51,
                "alcalinity_of_ash": 18.5,
                "magnesium": 96.0,
                "total_phenols": 2.45,
                "flavanoids": 2.53,
                "nonflavanoid_phenols": 0.29,
                "proanthocyanins": 1.54,
                "color_intensity": 5.0,
                "hue": 1.04,
                "od280_od315_of_diluted_wines": 3.47,
                "proline": 920.0
            }
        }
    }

@app.get("/")
def read_root():
    return {
        "message": "Wine Quality Prediction API",
        "endpoints": {
            "/predict": "POST - Make a prediction",
            "/health": "GET - Check API health",
            "/docs": "GET - API documentation"
        }
    }

@app.get("/health")
def health_check():
    return {"status": "healthy", "model_loaded": model is not None, "scaler_loaded": scaler is not None}

@app.post("/predict")
def predict(features: WineFeatures):
    try:
        # Преобразуем входные данные в массив
        input_data = np.array([[
            features.alcohol, features.malic_acid, features.ash,
            features.alcalinity_of_ash, features.magnesium,
            features.total_phenols, features.flavanoids,
            features.nonflavanoid_phenols, features.proanthocyanins,
            features.color_intensity, features.hue,
            features.od280_od315_of_diluted_wines, features.proline
        ]])

        # Масштабируем входные данные
        input_scaled = scaler.transform(input_data)

        # Выполним прогноз
        prediction = model.predict(input_scaled)
        probabilities = model.predict_proba(input_scaled)[0]
        pred_index = int(prediction[0])

        return {
            "prediction": wine_classes[pred_index],
            "prediction_index": pred_index,
            "confidence": float(probabilities[pred_index]),
            "all_probabilities": {
                wine_classes[i]: float(p) for i, p in enumerate(probabilities)
            }
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

При работе этой системы основная нагрузка ложится на конечную точку /predict. Эта конечная точка принимает входные признаки, преобразует их в массив NumPy, масштабирует их с использованием ранее сохранённого объекта для масштабирования признаков и выдаёт прогноз. Мы возвращаем пользователю не только сам прогноз, но и показатель уверенности модели, и вероятности для всех классов. Эти сведения полезно знать для того, чтобы понять то, насколько модель уверена в своём прогнозе.

Всю эту конструкцию можно протестировать локально, ещё до контейнеризации:

uvicorn app:app --reload

Интерактивную документацию по API можно получить, посетив конечную точку http://localhost:8000/docs.

Шаг 4: создание файла с требованиями к проекту

Прежде чем мы займёмся контейнеризацией нашей разработки, мы должны где-то записать сведения со всеми необходимыми нам Python-зависимостями. Для этого создадим и заполним файл requirements.txt:

fastapi==0.115.5
uvicorn[standard]==0.30.6
scikit-learn==1.5.2
numpy==2.1.3
pydantic==2.9.2

Мы фиксируем здесь точные версии библиотек из-за того, что применение в проекте других версий зависимостей может повлиять на его работу. А нам нужно, чтобы система выдавала бы предсказуемые и воспроизводимые результаты.

Шаг 5: написание файла Dockerfile

Теперь мы добрались до самого интересного — до Dockerfile. Именно этот файл сообщает платформе Docker о том, как собирать образ приложения:

# Использовать в качестве базового образа официальный образ Python
FROM python:3.11-slim

# Задать рабочую директорию в контейнере
WORKDIR /app

# Сначала, для улучшения кеширования, скопировать файл requirements.txt
COPY requirements.txt .

# Установить Python-зависимости
RUN pip install --no-cache-dir -r requirements.txt

# Скопировать код и вспомогательные материалы приложения
COPY app.py .
COPY model.pkl .
COPY scaler.pkl .

# Открыть порт 8000
EXPOSE 8000

# Команда, позволяющая запустить приложение
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Это — очень важный файл, поэтому разберём его построчно.

FROM python:3.11-slim: начинаем с легковесного образа Python 3.11. То, что в его названии есть слово slim, указывает на то, что перед нами вариант образа, из которого исключено всё, кроме самого необходимого. Применение такого базового образа позволяет ускорить сборку наших образов и уменьшить их размер.

WORKDIR /app: задаёт /app в качестве рабочей директории. Все последующие команды запускаются отсюда. Именно эта директория хранит проекты материала в контейнере.

COPY requirements.txt .: копирует файл requirements.txt до копирования кода приложения. Делать так — это одна из практических рекомендаций, касающихся использования Docker. Если при работе над проектом вы измените только код, но не требования к нему, Docker повторно использует кешированный уровень с установленными зависимостями, что значительно ускорит повторную сборку образа

RUN pip install –no-cache-dir -r requirements.txt: устанавливает Python-пакеты. Флаг --no-cache-dir не даёт pip хранить кеш загрузки, что сокращает размер итогового образа.

COPY app.py . / COPY model.pkl . / COPY scaler.pkl .: копирует файлы приложения и вспомогательные материалы, имеющие отношение к модели, в контейнер. Каждая команда COPY создаёт новый слой.

EXPOSE 8000: указывает на то, что контейнер прослушивает порт 8000. Обратите внимание на то, что эта команда не пробрасывает порт наружу. Это происходит при запуске контейнера с флагом -p.

CMD […]: команда, которая выполняется при запуске контейнера.

Шаг 6: сборка Docker-образа

Соберём Docker-образ. Проверьте, что находитесь в директории, где находится ваш Dockerfile, и выполните следующую команду:

docker buildx build -t wine-predictor:v1 .

Команда docker buildx build сообщает Docker о том, что нужно собрать образ с использованием BuildKit. Конструкция -t wine-predictor:v1 назначает образу тег, содержащий сведения о его имени и версии (v1). Точка в конце команды указывает на то, что Docker должен искать Dockerfile в текущей директории.

Запустив команду, вы увидите как Docker выполняет каждый шаг, описанный в Dockerfile. Первая сборка образа может занять несколько минут — система загружает базовый образ и устанавливает зависимости. Следующие сборки будут выполняться гораздо быстрее благодаря кешированию слоёв.

Для того чтобы проверить результаты создания образа можно воспользоваться такой командой:

docker images

Если образ был создан — вы увидите сведения об образе wine-predictor и о его размере.

Шаг 7: запуск контейнера

Запустим контейнер, воспользовавшись только что созданным образом:

docker run -d -p 8000:8000 --name wine-api wine-predictor:v1

Разберём флаги, использованные в этой команде:

-d: запускает контейнер без привязки к текущему терминалу, в фоновом режиме (detached mode).

 -p 8000:8000: настраивает связь порта 8000 на компьютере с портом 8000 контейнера.

–name wine-api: даёт контейнеру понятное имя.

wine-predictor:v1: задаёт образ, который нужно запустить.

Теперь наш API работает в контейнере! Проверим его:

curl http://localhost:8000/health

После выполнения этого запроса должен прийти ответ, указывающий на нормальную работу API:

{
  "status": "healthy",
  "model_loaded": true,
  "scaler_loaded": true
}

Шаг 8: выполнение прогнозов

Проверим модель, попытавшись спрогнозировать качество некоего вина. Тут можно пользоваться curl:

curl -X POST "http://localhost:8000/predict" \
  -H "Content-Type: application/json" \
  -d '{
    "alcohol": 13.2,
    "malic_acid": 2.77,
    "ash": 2.51,
    "alcalinity_of_ash": 18.5,
    "magnesium": 96.0,
    "total_phenols": 2.45,
    "flavanoids": 2.53,
    "nonflavanoid_phenols": 0.29,
    "proanthocyanins": 1.54,
    "color_intensity": 5.0,
    "hue": 1.04,
    "od280_od315_of_diluted_wines": 3.47,
    "proline": 920.0
  }'

После выполнения этой команды должен прийти JSON-ответ, содержащий прогноз модели, оценку уверенности модели и вероятности для каждого из классов:

{
  "prediction": "Class 1",
  "prediction_index": 1,
  "confidence": 0.97,
  "all_probabilities": {
    "Class 0": 0.02,
    "Class 1": 0.97,
    "Class 2": 0.01
  }
}

Шаг 9: (необязательный) публикация образа на Docker Hub

Образ можно опубликовать на Docker Hub, позволив пользоваться им всем, кому он нужен. Для того чтобы это сделать, сначала надо зарегистрировать бесплатную учётную запись на hub.docker.com (или воспользоваться уже имеющейся учётной записью).

Далее — входим в учётную запись:

docker login

Вводим, когда нас спросят, имя пользователя и пароль.

Назначаем образу тег, использовав имя пользователя на Docker Hub:

docker tag wine-predictor:v1 yourusername/wine-predictor:v1

Конструкцию yourusername надо заменить на реальное имя пользователя.

Отправляем образ:

docker push yourusername/wine-predictor:v1

Первая отправка образа занимает несколько минут, так как Docker выгружает все его слои. Последующие отправки идут быстрее, так как выгружаются только изменённые слои.

Сейчас можно загрузить и запустить этот образ откуда угодно:

docker pull yourusername/wine-predictor:v1
docker run -d -p 8000:8000 yourusername/wine-predictor:v1

Теперь модель общедоступна. Кто угодно может загрузить и запустить созданное нами приложение!

Практические рекомендации по сборке Docker-образов для ML-проектов

1. Используйте многоэтапные сборки для сокращения размеров образов

Собирая образы для моделей машинного обучения подумайте о том, чтобы воспользоваться многоэтапными сборками (multi-stage build).

# Стадия сборки
FROM python:3.11 AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

# Стадия выполнения кода проекта
FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY app.py model.pkl scaler.pkl ./
ENV PATH=/root/.local/bin:$PATH
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Применение выделенной стадии сборки образа делает возможной раздельную установку зависимостей и позволяет копировать в итоговый образ только необходимые артефакты. Это уменьшает размер образа и поверхность атаки контейнера.

2. Постарайтесь не обучать модели внутри образов Docker

Обучать модели следует за пределами Docker. Сохраните файлы обученной модели и скопируйте их в образ. Это ускорит сборку образов, улучшит воспроизводимость проекта, а так же подчеркнёт то, что образы применяются для развёртывания и использования моделей, а не для их обучения.

3. Пользуйтесь файлом .dockerignore

Не включайте в состав образов наборы данных, файлы блокнотов Jupyter, а так же — другие большие файлы, или файлы, которые не нужны в готовом образе. Это позволяет поддерживать компактный размер контекста сборки и избегать неоправданного увеличения размеров образов.

# .dockerignore
__pycache__/
*.pyc
*.pyo
.ipynb_checkpoints/
data/
models/
logs/
.env
.git

4. Версионируйте модели и образы

Назначайте образам теги с указанием версий модели. Это позволит, при необходимости, быстро и просто переключаться между разными версиями моделей. Вот пример:

docker buildx build -t wine-predictor:v1.0 .
docker buildx build -t wine-predictor:v1.1 .

Итоги

Теперь вы готовы к тому, чтобы упаковывать свои ML-модели в Docker-контейнеры! Вспомним то, о чём вы сегодня узнали:

• Основы Docker: образы, контейнеры, файлы Dockerfile, слои, кеширование.

• Обеспечение доступа к работающим прогнозирующим моделям с помощью FastAPI.

• Создание эффективных файлов Dockerfile, рассчитанных на ML-приложения.

• Сборка и запуск контейнеров Docker.

Применение Docker позволяет ML-моделям одинаково работать где угодно — локально, в облаке, на любых компьютерах ваших коллег. Эта платформа избавляет инженеров от размышлений о совместимости систем, позволяет наладить надёжное и стабильное развёртывание проектов.

После того, как вы освоитесь с основами, вы можете пойти дальше, прибегнув к CI/CD-конвейерам, к Kubernetes, к инструментам мониторинга. Всё это позволит вам создавать полноценные масштабируемые ML-инфраструктуры.

А теперь предлагаю всем желающим заняться упаковкой своих проектов в Docker-контейнеры. Удачи в программировании!

О, а приходите к нам работать? ? ?

Мы в wunderfund.io занимаемся высокочастотной алготорговлей с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.

Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.

Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.

Присоединяйтесь к нашей команде