Как развернуть модель машинного обучения?

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

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

Что такое машинное обучение?

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

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

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

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

Типичными методами машинного обучения являются регрессия (прогнозирование непрерывной величины, например, цены на дом) и классификация (прогнозирование класса из конечного набора классов, например, жанра фильма).

Вообще говоря, машинное обучение можно разделить на три типа:

• Наблюдаемое обучение – алгоритмы обучаются с помощью набора данных с метками. Каждый пример в наборе данных содержит метку (или так называемую целевую переменную). Алгоритм использует их для предсказания меток для невидимых примеров. К алгоритмам контролируемого обучения относятся kNN, decision trees и т. д.

• Неподконтрольное обучение – алгоритмы обучаются без явных указаний. Алгоритм сам находит закономерности в данных и делает предсказания на их основе. Пример алгоритма – кластеризация k-means.

• Обучение с подкреплением – алгоритмы обучаются методом проб и ошибок. Обычно они основаны на вознаграждении, и целью алгоритма является максимизация вознаграждения. Пример: генетические алгоритмы.

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

Приложения машинного обучения

Давайте рассмотрим несколько реальных приложений машинного обучения!

Рекомендательные системы

Рекомендательные системы подсказывают пользователю, какие товары (фильмы, продукты и т. д.) ему следует употребить. Эти системы могут быть как контентными, так и коллективными.

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

Например, Netflix использует их, чтобы рекомендовать фильмы, Spotify – чтобы рекомендовать песни, а YouTube – чтобы предлагать видео, которое вам стоит посмотреть, исходя из ваших интересов.

Обработка естественного языка (NLP)

Обработка естественного языка (NLP) позволяет компьютерам обрабатывать и понимать человеческий язык. Генерация естественного языка (NLG) позволяет компьютерам генерировать человеческий язык.

Эта технология используется в чат-ботах, инструментах перевода языка, инструментах анализа настроений и многих других. ChatGPT – один из самых известных примеров использования NLP и NLG.

Хотите узнать больше о ChatGPT? Ознакомьтесь с другой нашей статьей – Как создать приложение с помощью ChatGPT?

Компьютерное зрение и распознавание образов

Компьютерное зрение наделяет компьютеры способностью “видеть” и “понимать” изображения и видео. Оно позволяет им выполнять сегментацию (в режиме реального времени), распознавать объекты, лица и даже эмоции.

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

Обнаружение мошенничества

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

Самоуправляемые автомобили

Автономное вождение автомобиля – одна из самых сложных задач машинного обучения. Она объединяет различные приложения, такие как компьютерное зрение, обнаружение аномалий, предсказание поведения, планирование пути и т. д.

На момент написания статьи мы еще не приблизились к полностью автономным автомобилям. Нынешние “самодвижущиеся” автомобили хорошо работают только в ограниченных географических зонах.

Варианты развертывания машинного обучения

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

На месте

Развертывание на месте подразумевает размещение и управление ИТ-оборудованием, таким как серверы и устройства хранения данных, на территории компании.

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

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

Облако

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

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

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

Примерами облачных платформ являются:

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Microsoft Azure

Популярные алгоритмы машинного обучения

Популярными алгоритмами машинного обучения являются:

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

В практическом примере мы будем использовать k-Nearest Neighbours.

Как развернуть модель машинного обучения?

В этом разделе статьи мы создадим модель машинного обучения, обслужим ее с помощью FastAPI, докеризуем и, наконец, развернем ее в контейнерах Back4app.

Пререквизиты

• Базовые знания в области машинного обучения
• Опыт работы с Python и FastAPI
• Базовое понимание Docker и технологии контейнеризации
• Git и Docker Desktop установлены на вашей локальной машине

Обзор проекта

Прежде чем продемонстрировать, как развернуть модель машинного обучения, мы ее создадим. Мы создадим простой классификатор kNN, используя популярный набор данных Iris. Цель модели – предсказать, является ли наблюдение “setosa”, “versicolour” или “virginica”, основываясь на различных признаках.

Затем мы сохраним модель в файл, загрузим ее в FastAPI и обслужим через конечную точку. После этого мы докеризуем приложение, выложим его на GitHub и развернем в Back4app Containers.

Создать модель

Для создания модели мы будем использовать Jupyter Notebooks. Вы можете установить Jupyter на свою локальную машину или бесплатно воспользоваться Google Colab.

Сначала создайте новый блокнот Jupyter.

Каждый блок кода в этом разделе статьи представляет собой ячейку Jupyter. Вы можете создавать их из меню или с помощью привязки клавиши “B” (в командном режиме).

Также не забудьте запустить их (либо из меню, либо с помощью “ALT + ENTER”).

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

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Загрузить набор данных

Набор данных Iris включен в Scikit-learn по умолчанию. Все, что вам нужно сделать, – это вызвать функцию load_iris() и преобразовать объект в кадр.

Создайте новую ячейку:

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Когда вы загружаете набор данных Iris, он упорядочивается по целевой переменной. Это не очень хорошо, потому что наша модель машинного обучения может увидеть только некоторые типы примеров на этапе обучения. Например, только “setosa” и “versicolour”.

Чтобы избежать этой проблемы, мы можем перетасовать их:

df = df.sample(frac=1, random_state=42)

Атрибут random_state используется для воспроизводимости. Вы можете использовать любое число по своему усмотрению.

Изучить набор данных

Прежде чем создавать модель, неплохо бы изучить, с какими данными вы имеете дело. Для этого можно использовать встроенные функции Pandas, такие как head(), describe() и т. д.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

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

Изображение выше заимствовано из статьи Guide to Data Visualization with Python. Обязательно ознакомьтесь с ней, чтобы узнать больше о визуализации данных.

На изображении видно, что “красные” точки линейно отделяются от двух других. А вот “синяя” и “зеленая” точки линейно не отделимы.

Разделенный набор данных

Двигаясь дальше, давайте определим признаки (предикторы) и целевую переменную:

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

Затем разделите их на X (данные о признаках) и y (данные о целевой переменной) и проведите тестирование и обучение:

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

При использовании test_size=0,25 25% набора данных используется для тестирования, а 75% – для обучения.

Построить модель

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

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

О том, почему масштабирование имеет большое значение, читайте в этой статье.

Затем используйте 10-кратную перекрестную валидацию и проверьте ошибку валидации:

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Оцените модель на тестовом наборе:

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

Точность проверки и тестирования практически равны. Это указывает на то, что наша модель не недооценивает и не переоценивает себя.

Сохранить модель

Наконец, переобучите модель, используя все данные, и сохраните ее в файл model.pkl:

knn.fit(X, y)
dump(knn, "model.pkl")

Если вы использовали Google Colab, загрузите файл model.pk, поскольку он понадобится нам на следующем этапе.

Модель подачи

Как уже говорилось, для обслуживания модели мы будем использовать FastAPI.

Создайте новый проект FastAPI и замените файл main.py следующим образом:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Запустите сервер разработки:

$ uvicorn app.main:app --reload

Перейдите по адресу http://localhost:8000/, и вы получите следующий ответ:

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Модель нагрузки

Далее загрузим модель и определим классы модели (model_classes).

Сначала скопируйте файл model.pkl из предыдущего шага в корень вашего проекта. Затем загрузите модель и определите классы прямо под инициализацией приложения FastAPI, как показано ниже:

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Мы будем использовать model_classes для перевода целевой переменной из числовой в текстовую.

Модель нагрузки

Затем создайте конечную точку /predict, которая принимает характеристики и использует загруженную модель для предсказания:

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

Конечная точка возвращает числовое предсказание, а также удобное тестовое предсказание.

Не забудьте про импорт в верхней части файла:

from joblib import load
from pydantic import BaseModel

Ваш финальный файл main.py должен выглядеть следующим образом.

Перезапустите сервер разработки и перейдите по адресу http://localhost:8000/docs в вашем любимом веб-браузере. FastAPI автоматически генерирует интерактивную документацию для всех ваших конечных точек.

Протестируйте модель, отправив такой запрос:

Отлично, теперь наше веб-приложение полностью работает!

Приложение Dockerize

В этом разделе статьи мы выполним докеризацию веб-приложения. Мы создадим Dockerfile и настроим файл .dockerignore.

Dockerfile

Dockerfile – это файл, содержащий инструкции для Docker Engine по сборке образа.

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

Команды Dockerfile обычно пишутся заглавными буквами, и за ними непосредственно следуют соответствующие аргументы.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Посетите справочник Dockerfile, чтобы узнать больше обо всех инструкциях.

В корне проекта создайте Dockerfile:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

При работе с Docker вы захотите создавать образы как можно меньшего размера.

Один из способов уменьшить размер образа – использовать файл .dockerignore. Этот файл работает аналогично файлу .gitignore. Он позволяет опустить файлы, которые не нужно включать в образ.

В корне проекта создайте файл .dockerignore:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

Убедитесь, что вы адаптировали файл .dockerignore в соответствии с требованиями вашего проекта (например, если вы используете другую IDE).

Сборка, запуск, тестирование

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

Чтобы проследить за этим, вам понадобится установленный на вашей машине Docker Desktop.

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

$ docker images

Затем создайте образ с помощью Dockerfile:

$ docker build -t iris-webapp:1.0 .

Сборка образа в Docker займет довольно много времени. В основном это связано с тем, что Scikit-learn не оптимизирован для контейнеров Docker. Не стесняйтесь сделать небольшой перерыв на кофе.

После завершения команды перепроверьте образы. Только что созданный образ должен быть там.

Наконец, используйте образ для создания нового контейнера:

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

Вот и все!

Теперь ваше веб-приложение контейнеризировано. Оно должно быть доступно по адресу http://localhost:8000/ и работать так же, как и раньше.

Отправить на GitHub

Сначала перейдите на GitHub и создайте новый репозиторий. Запомните удаленный URL, поскольку он понадобится нам на следующем этапе.

Затем вернитесь в корень вашего проекта.

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

Этот тип файлов работает так же, как и файлы .dockerignore.

В корне проекта создайте файл .gitignore:

#.dockerignore

.idea/
__pycache__/
venv/

Откройте терминал и выполните следующую команду, чтобы инициализировать Git:

$ git init

Добавьте все файлы в VCS и зафиксируйте их:

$ git add .
$ git commit -m "first commit"

Наконец, добавьте удаленный источник GitHub, используя URL-адрес, указанный ранее, и выложите исходный код:

$ git remote add origin <remote_url>
$ git push origin master

Убедитесь, что удаленный URL-адрес из предыдущего шага используется вместо .

Вот и все. Если вы сейчас зайдете на страницу репозитория GitHub, то увидите, что все файлы добавлены.

Развернуть приложение

Чтобы развернуть приложение в Back4app Containers, необходимо сначала зарегистрироваться или войти в систему (если у вас уже есть учетная запись).

Когда вы авторизуетесь в своей учетной записи Back4app, вы попадете на панель приложений. Чтобы создать новое приложение, нажмите “Создать новое приложение”.

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

Далее вам нужно будет подключить свой аккаунт GitHub к Back4app. Это позволит Back4app получать исходный код из ваших репозиториев. Вы можете предоставить доступ ко всем репозиториям или выбрать определенные.

После того как репозитории будут импортированы, нажмите кнопку “Выбрать”.

Настройка среды не требуется, кроме указания описательного имени приложения.

Затем нажмите кнопку “Создать”.

Back4app понадобится несколько минут, чтобы собрать образ, отправить его в реестр контейнеров и развернуть контейнер. После завершения развертывания статус вашего приложения должен измениться на “Готово”.

Чтобы перейти к своему приложению, щелкните URL-адрес, как показано на рисунке ниже.

Отлично, вы успешно развернули модель машинного обучения в Back4app Containers. Веб-приложение должно работать так же, как и локально. Убедитесь, что приложение протестировано еще раз.

Резюме

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

Теперь вы должны уметь создавать собственные простые модели, обслуживать их с помощью FastAPI и разворачивать в контейнерах Back4app.

Возьмите финальный исходный код из репозитория back4app-deploy-ml-model на GitHub.