Развёртывание XGBoost-моделей с помощью Ray Serve

МЕНЮ


Главная страница
Поиск
Регистрация на сайте
Помощь проекту
Архив новостей

ТЕМЫ


Новости ИИРазработка ИИВнедрение ИИРабота разума и сознаниеМодель мозгаРобототехника, БПЛАТрансгуманизмОбработка текстаТеория эволюцииДополненная реальностьЖелезоКиберугрозыНаучный мирИТ индустрияРазработка ПОТеория информацииМатематикаЦифровая экономика

Авторизация



RSS


RSS новости


XGBoost — это оптимизированная библиотека, реализующая алгоритм градиентного бустинга. Эта библиотека спроектирована с прицелом на высокую продуктивность и гибкость, в ней используется параллельная работа с древовидными структурами, что позволяет быстро и эффективно решать различные задачи из сфер Data Science и Machine Learning. В предыдущем материале мы исследовали три подхода к ускорению обучения XGBoost-моделей.

Библиотека XGBoost, после появления, быстро стала эталонным инструментом, который направлен на решение задач, предусматривающих обработку структурированных данных. Причина этого, в основном, кроется в высокой скорости её работы и в её исключительной производительности. Она быстрее, чем другие реализации ансамблей классификаторов, её базовый алгоритм поддаётся распараллеливанию, то есть — её можно использовать в средах со множеством CPU и GPU.

Публиковать XGBoost-модели можно в облачных средах. Среди них — Amazon SageMakerKubeFlow, Google Cloud AI Platform, Microsoft Azure ML SDK. Это — мощные платформы, поддерживаемые крупнейшими игроками рынка облачных услуг. Но плата за их использование может быть очень высока. Кроме того, они работают только в рамках собственных экосистем.

Самостоятельно довести модель машинного обучения от уровня концептуальной идеи до уровня продакшна — это, обычно, сложно и долго. Для облегчения решения этой задачи созданы несколько фреймворков. Они нацелены на развёртывание XGBoost-моделей в продакшне.

В этом материале мы расскажем о том, как развёртывать XGBoost-модели с помощью двух фреймворков — Flask и Ray Serve. Мы, кроме того, сравнивая характеристики работы моделей в продакшне, рассмотрим преимущества Ray Serve перед другими подобными решениями.

Развёртывание XGBoost-моделей с помощью Flask

Flask — это самый распространённый Python-микрофреймворк, используемый для развёртывания XGBoost-моделей. Дело в том, что он не имеет зависимостей от внешних библиотек. Flask считается исключительно удачным фреймворком для развёртывания XGBoost-моделей по нескольким причинам: его очень легко настраивать, он эффективен и поддерживает конечные точки REST. Кроме того, Flask, в отличие от XGBoost Server, не привязан ни к какому определённому фреймворку. Он поддерживает механизмы обработки HTTP-запросов. Flask, к тому же, ещё и бесплатен, что выгодно отличает его от SageMaker и других облачных решений. Выше перечислены лишь немногие возможности Flask, делающие этот фреймворк оптимальным решением для развёртывания XGBoost-моделей в продакшне.

В этом разделе мы обучим и протестируем XGBoost-модель, а потом развернём её с помощью Flask. Эта модель будет прогнозировать возникновение диабета с использованием набора данных pima-indians-diabetes с сайта UCI Machine Learning Repository. Этот небольшой набор данных содержит числовые медицинские показатели, связанные с диабетом, представленные восемью признаками. Тут имеется и одна целевая переменная, определяющая результат — Outcome. В результате мы воспользуемся XGBoost для моделирования и решения простой задачи прогнозирования.

Создание XGBoost-модели

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

from numpy import loadtxt from xgboost import XGBClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score  # загрузка данных dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",") # разбиение набора данных на X и Y X = dataset[:,0:8] Y = dataset[:,8] X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)

Теперь создадим XGBoost-модель и обучим её на имеющихся числовых данных:

model = XGBClassifier() model.fit(X_train, y_train)

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

y_pred = model.predict(X_test) predictions = [round(value) for value in y_pred] accuracy = accuracy_score(y_test, predictions) print("Accuracy: %.2f%%" % (accuracy * 100.0))

Развёртывание XGBoost-модели с помощью Flask

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

Сериализация модели с помощью модуля pickle

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

import pickle  # сохранение модели with open('model.pkl','wb') as f:     pickle.dump(model, f)  # загрузка модели with open("model.pkl", "rb") as f:     model = pickle.load(f)

Создание Flask-приложения, которое будет обслуживать модель

Для развёртывания XGBoost-модели мы воспользуемся фреймворком Flask. Чтобы создать Flask-приложение, которое может прогнозировать возникновение диабета, нам нужен будет соответствующий маршрут, обращение к которому позволит получить прогноз модели.

import pickle import numpy as np from flask import Flask, request, jsonify, render_template  app = Flask(__name__) with open("model.pk", "rb") as f:     model = pickle.load(f)  @app.route("/predict", methods=["POST"]) def predict():     data = request.get_json(force=True)     prediction = model.predict([np.array(list(data.values()))])     output = prediction[0]     return jsonify(output)  if __name__ == "__main__":     app.run(debug=True)

Обращение к API predict с помощью запроса

На этом шаге мы создаём файл request.py. Код этого файла выводит спрогнозированное значение, обращаясь к API, определённым в файле app.py.

import requests  url = "http://localhost:5000/predict" r = requests.post(     url,     json={         "Pregnancies": 6,         "Glucose": 148,         "BloodPressure": 72,         "SkinThickness": 35,         "Insulin": 0,         "BMI": 33.6,         "DiabetesPedigree": 0.625,         "Age": 50,         "Outcome": 1,     }, ) print(r.json())

Развёртывание XGBoost-модели с помощью Ray Serve

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

Но, помимо этих минусов, главным недостатком Flask в деле обслуживания ML-моделей являются те сложности, которые встают перед тем, кому нужно масштабировать Flask-приложение. При использовании Flask масштабирование каждого из компонентов означает необходимость запуска множества параллельных экземпляров приложения. При этом разработчик сам должен принять решение о том, как именно это сделать. Может — эта задача будет решена с помощью виртуальных машин, а может — с помощью обычных серверов или посредством кластера Kubernetes. В любом случае разработчик будет заниматься запуском экземпляров приложения и балансировкой нагрузки. А вот развёртывание XGBoost-моделей с помощью Ray Serve позволяет сразу решить все эти проблемы. Дело в том, что эта система даёт разработчику простой веб-сервер, который берёт на себя решение сложных задач маршрутизации, масштабирования, тестирования моделей. То есть — всего того, что нужно для развёртывания моделей в продакшне.

С помощью Ray Serve можно без труда масштабировать модель в кластере Ray, состоящем из нескольких узлов. Это так благодаря возможности динамического обновления работающих экземпляров приложения. Ray Server, кроме того, это система, не привязанная к какому-то конкретному фреймворку. Поэтому с её помощью можно обеспечивать работу моделей, подготовленных с помощью различных фреймворков. Например — таких, как TensorFlowPyTorch и Scikit-learn. В целом можно сказать, что Ray Serve — это система, которая позволяет организовывать высокоэффективную и высокопроизводительную работу моделей в продакшне.

Возьмём XGBoost-модель, которую мы создали выше, и развернём её с помощью Ray Serve.

Сначала установим Ray Serve:

pip install "ray[serve]"

Теперь запустим экземпляр Ray Serve, работающий поверх нескольких кластеров Ray.

ray start --head

Далее — запустим следующий Python-скрипт, в котором Ray Serve импортируется, инициализируется и запускается, а так же — подключается к локальному кластеру Ray:

import ray from ray import serve ray.init(address='auto', namespace="serve") # Подключение к локальному кластеру Ray. serve.start(detached=True) # Запуск процессов Ray Serve в кластере Ray.

Обратите внимание на то, что тут метод serve.start применяется для запуска нескольких агентов Ray, которые используются Ray Serve для маршрутизации HTTP-запросов к подходящим моделям.

Кроме того, анализируя этот пример, учитывайте то, что мы запускаем Ray всего лишь в локальном окружении, делая это для тестирования кода. Но и это уже даёт нам преимущество перед Flask. Дело в том, что Ray задействует все доступные CPU-ядра компьютера, в то время как Flask-приложение, созданное ранее, использует только одно ядро. И это — лишь малая часть полезных возможностей Flask. Так, не сложнее, чем в локальном окружении, модель можно развернуть на Ray-кластере, содержащем десятки или даже сотни узлов. Это позволяет масштабировать вычислительные ресурсы, выделяемые модели, не внося совершенно никаких изменений в код приложения.

Теперь, когда система Ray Serve готова к работе, пришло время создать модель и развернуть её. Так как наша XGBoost-модель уже создана и обучена, нам нужно лишь загрузить её и представить в виде класса. После этого можно начинать процесс её развёртывания с помощью Ray Serve. Этим и займёмся:

import pickle import json import ray from ray import serve  @serve.deployment(num_replicas=2, route_prefix="/regressor") class XGB:     def __init__(self):         with open("model.pkl", "rb") as f:             self.model = pickle.load(f)      async def __call__(self, starlette_request):         payload = await starlette_request.json()         print("Worker: received starlette request with data", payload)          input_vector = [             payload["Pregnancies"],             payload["Glucose"],             payload["Blood Pressure"],             payload["Skin Thickness"],             payload["Insulin"],             payload["BMI"],             payload["DiabetesPedigree"],             payload["Age"],         ]         prediction = self.model.predict([input_vector])[0]         return {"result": prediction}

А теперь начинается настоящее волшебство. Следующие несколько строк кода развернут XGBoost-модель на работающем инстансе Ray Serve. Делается это посредством обращений к API Ray Serve в Python-фреймворке.

# Теперь инициализируем экземпляр Ray Serve или подключаемся к существующему экземпляру. serve.start(detached=True) # Развёртываем модель. XGB.deploy()

Готово! XGBoost-модель успешно развёрнута в Ray Serve. Сделано это очень просто — путём вызова метода deploy ранее объявленного класса. На самом деле, тут имеются две копии модели, работающие в одно и то же время и обрабатывающие ответы. Нашу систему легко масштабировать. Для этого достаточно настроить параметр num_replicas.

Теперь мы можем обращаться к конечной точке развёрнутой модели, отправляя ей запросы. Обратите внимание на то, что HTTP-сервер, по умолчанию, работает на localhost:8000.

import requests  sample_request_input = {     "Pregnancies": 6,     "Glucose": 148,     "BloodPressure": 72,     "SkinThickness": 35,     "Insulin": 0,     "BMI": 33.6,     "DiabetesPedigree": 0.625,     "Age": 50, } response = requests.get("http://localhost:8000/regressor", json=sample_request_input) print(response.text) # Ответ: #  "result": "1"

Как видно, если модель выдаёт результат 1 — это означает, что возникновение диабета «возможно» или «ожидается в скором времени». Если модель выдаёт 0 — это означает, что возникновение диабета не ожидается.

Итоги

Мы рассказали вам всё, что собирались! Теперь вы знаете о том, как развёртывать XGBoost-модели с использованием Flask, и о том, как без труда их масштабировать с помощью Ray Serve.

Для того чтобы больше узнать о Ray Serve — лучше всего начать с официальной документации. А именно — сначала можно освоить основы, а потом углубиться в детали обслуживания ML-моделей.

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

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

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

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

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


Источник: habr.com

Комментарии: