УПРАВЛЕНИЕ

Во многих случаях при работе с библиотекой
scikit-learn вам необходимо сохранить
свои модели прогнозов в файл, а затем восстановить их, чтобы повторно
использовать вашу предыдущую работу для: тестирования вашей модели на
новых данных, сравнения нескольких моделей или что-нибудь еще. Эта
процедура сохранения также известна как сериализация объекта —
представляет объект с потоком байтов, чтобы сохранить его на диске,
отправить по сети или сохранить в базе данных, в то время как процедура
восстановления известна как десериализация. В этой статье мы рассмотрим
три возможных способа сделать это в Python и scikit-learn, каждый из
которых имеет свои плюсы и минусы.

Инструменты для сохранения и восстановления моделей

Первый инструмент, который мы описываем, — это
Pickle , стандартный
инструмент Python для (де) сериализации объектов. После этого мы
рассмотрим библиотеку Joblib,
которая предлагает простую (де) сериализацию объектов, содержащих
большие массивы данных, и, наконец, мы представляем ручной подход для
сохранения и восстановления объектов в / из
JSON (нотация объектов
JavaScript). Ни один из этих подходов не представляет собой оптимального
решения, но правильный выбор следует выбирать в соответствии с
потребностями вашего проекта.

Инициализация модели

Для начала создадим одну модель scikit-learn. В нашем примере мы будем
использовать модель логистической
регрессии и набор
данных Iris .
Импортируем необходимые библиотеки, загрузим данные и разделим их на
обучающий и тестовый наборы.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Load and split data
data = load_iris()
Xtrain, Xtest, Ytrain, Ytest = train_test_split(data.data, data.target, test_size=0.3, random_state=4)

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

# Create a model
model = LogisticRegression(C=0.1,
max_iter=20,
fit_intercept=True,
n_jobs=3,
solver=’liblinear’)
model.fit(Xtrain, Ytrain)

И наша получившаяся модель:

LogisticRegression(C=0.1, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, max_iter=20, multi_class=’ovr’, n_jobs=3,
penalty=’l2′, random_state=None, solver=’liblinear’, tol=0.0001,
verbose=0, warm_start=False)

Используя fit метод, модель узнала ее коэффициенты , которые хранятся
в model.coef_ . Цель состоит в том, чтобы сохранить параметры и
коэффициенты модели в файл, чтобы вам не нужно было снова повторять шаги
обучения модели и оптимизации параметров для новых данных.

Модуль рассола

В следующих нескольких строках кода модель, которую мы создали на
предыдущем шаге, сохраняется в файл, а затем загружается как новый
объект с именем pickled_model . Затем загруженная модель используется
для расчета показателя точности и прогнозирования результатов на новых
невидимых (тестовых) данных.

Выполнение этого кода должно дать ваш результат и сохранить модель через
Pickle:

$ python save_model_pickle.py
Test score: 91.11 %

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

Модуль Joblib

Библиотека Joblib предназначена для замены Pickle для объектов,
содержащих большие данные. Повторим процедуру сохранения и
восстановления, как и в случае с Pickle.

Как видно из примера, библиотека Joblib предлагает немного более простой
рабочий процесс по сравнению с Pickle. В то время как Pickle требует
передачи файлового объекта в качестве аргумента, Joblib работает как с
файловыми объектами, так и с строковыми именами файлов. Если ваша модель
содержит большие массивы данных, каждый массив будет храниться в
отдельном файле, но процедура сохранения и восстановления останется
прежней. Joblib также поддерживает различные методы сжатия, такие как
zlib, gzip, bz2, а также различные уровни сжатия.

Ручное сохранение и восстановление в JSON

В зависимости от вашего проекта, Pickle и Joblib часто оказываются
неподходящими решениями. Некоторые из этих причин обсуждаются позже в
разделе « Проблемы совместимости ». В любом
случае, когда вы хотите иметь полный контроль над процессом сохранения и
восстановления, лучший способ — создать свои собственные функции
вручную.

Ниже показан пример сохранения и восстановления объектов вручную с
помощью JSON. Этот подход позволяет нам выбрать данные, которые
необходимо сохранить, такие как параметры модели, коэффициенты, данные
обучения и все, что нам нужно.

Поскольку мы хотим сохранить все эти данные в одном объекте, один из
возможных способов сделать это — создать новый класс, наследующий от
класса модели, которым в нашем примере является LogisticRegression .
Новый класс, названный MyLogReg , затем реализует методы save_json и
load_json для сохранения и восстановления в / из файла JSON
соответственно.

Для простоты мы сохраним только три параметра модели и данные обучения.
Некоторые дополнительные данные, которые мы могли бы сохранить с помощью
этого подхода, — это, например, оценка перекрестной проверки обучающего
набора, тестовые данные, оценка точности тестовых данных и т. Д.

Теперь попробуем класс MyLogReg Сначала мы создаем объект mylogreg ,
передаем ему обучающие данные и сохраняем в файл. Затем мы создаем новый
объект json_mylogreg и вызываем load_json для загрузки данных из
файла.

filepath = «mylogreg.json»

# Create a model and train it
mylogreg = MyLogReg(X_train=Xtrain, Y_train=Ytrain)
mylogreg.save_json(filepath)

# Create a new object and load its data from JSON file
json_mylogreg = MyLogReg()
json_mylogreg.load_json(filepath)
json_mylogreg

Распечатав новый объект, мы сможем увидеть наши параметры и данные
обучения по мере необходимости.

Поскольку сериализация данных с использованием JSON фактически сохраняет
объект в строковом формате, а не в потоке байтов, файл mylogreg.json
можно открывать и изменять с помощью текстового редактора. Хотя этот
подход был бы удобен для разработчика, он менее безопасен, поскольку
злоумышленник может просматривать и изменять содержимое файла JSON.
Более того, этот подход больше подходит для объектов с небольшим
количеством переменных экземпляра, таких как модели scikit-learn, потому
что любое добавление новых переменных требует изменений в методах
сохранения и восстановления.

Проблемы совместимости

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

Совместимость версий Python. В документации к обоим инструментам
указано, что не рекомендуется (де) сериализовать объекты в разных
версиях Python, хотя это может работать при изменении второстепенных
версий.

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

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

Выводы

В этом посте мы описали три инструмента для сохранения и восстановления
моделей scikit-learn. Библиотеки Pickle и Joblib быстры и просты в
использовании, но имеют проблемы совместимости с разными версиями Python
и изменениями в модели обучения. С другой стороны, ручной подход сложнее
реализовать, и его необходимо модифицировать при любых изменениях в
структуре модели, но с другой стороны, он может быть легко адаптирован к
различным потребностям и не имеет проблем с совместимостью.

In machine learning, while working with scikit learn library, we need to save the trained models in a file and restore them in order to reuse them to compare the model with other models, and to test the model on new data. The saving of data is called Serialization, while restoring the data is called Deserialization.

Also, we deal with different types and sizes of data. Some datasets are easily trained i.e- they take less time to train but the datasets whose size is large (more than 1GB) can take a very large time to train on a local machine even with GPU. When we need the same trained data in some different project or later sometime, to avoid the wastage of the training time, store the trained model so that it can be used anytime in the future.

There are two ways we can save a model in scikit learn:

Pickle string

The pickle module implements a fundamental, but powerful algorithm for serializing and de-serializing a Python object structure.

Example: Let’s apply K Nearest Neighbor on the iris dataset and then save the model.

Питон3

из sklearn.neighbours импортировать KNeighboursClassifier как KNN

импортировать numpy как np

ирис = load_iris()

X = iris.data

y = радужная оболочка.цель

X_train, X_test, y_train, y_test =

train_test_split(X, y, test_size=0,3,

knn = KNN(n_neighbours=3)

Сохраните модель в строку с помощью рассола:

save_model = Pickle.dumps(knn)

knn_from_pickle = Pickle.loads(сохраненная_модель)

Маринованная модель в виде файла с использованием joblib

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

joblib.dump для сериализации иерархии объектов
joblib.load для десериализации потока данных
из параллельного импорта joblib, с задержкой

Сохранить в маринованный файл с помощью joblib

knn_from_joblib = joblib.load(‘filename.pkl’)

Готовитесь ли вы к своему первому собеседованию или стремитесь повысить свою квалификацию в этой постоянно развивающейся технологической среде, курсы GeeksforGeeks — ваш ключ к успеху. Мы предоставляем контент высочайшего качества по доступным ценам, и все это направлено на ускорение вашего роста в установленные сроки. Присоединяйтесь к миллионам людей, которым мы уже предоставили полномочия, и мы здесь, чтобы сделать то же самое для вас. Не пропустите — посмотрите прямо сейчас!

Специальная сериализация Python¶

Можно сохранить модель в scikit-learn, используя встроенную функцию Python.
модель персистентности, а именно рассол:

В конкретном случае scikit-learn, возможно, лучше использовать joblib.
замена рассола ( & ), который более эффективен при
объекты, которые содержат внутри большие массивы numpy, как это часто бывает в случае
установлены оценщики scikit-learn, но могут сохраняться только на диске, а не на
строка:

Позже вы сможете загрузить обратно промаринованную модель (возможно, в другом процессе Python).
с:

и функции также принимают файловые объекты
вместо имен файлов. Дополнительную информацию о сохранении данных с помощью Joblib см.
доступна здесь.

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

из sklearn.Exceptions import InconsistentVersionWarning
alerts.simplefilter(«ошибка», InconsistentVersionWarning)

est = Pickle.loads(“model_from_prevision_version.pickle”)

, кроме InconsistentVersionWarning как w:

Ограничения безопасности и удобства обслуживания¶

Pickle (и JobLib в расширении) имеет некоторые проблемы с ремонтопригодностью.
и безопасность. Из-за этого

Чтобы восстановить аналогичную модель с помощью будущих версий scikit-learn,
По маринованной модели следует сохранить дополнительные метаданные:

Это должно позволить проверить, что показатель перекрестной проверки находится в
тот же диапазон, что и раньше.

За некоторыми исключениями, маринованные модели следует переносить по всему миру.
архитектуры, предполагающие использование одних и тех же версий зависимостей и Python.
Если вы столкнулись с непереносимым оценщиком, откройте проблему на
Гитхаб. Маринованные модели часто развертываются в производстве с использованием контейнеров, например
Docker, чтобы заморозить среду и зависимости.

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

Более безопасный формат

И вы можете загрузить их обратно, используя и
. Однако вам необходимо указать типы, которые
вам доверяют. Вы можете получить существующие неизвестные типы в сброшенном объекте/файле.
используя и после проверки его содержимого,
передать его в функцию загрузки:

Если вы доверяете источнику файла/объекта, вы можете пройти:

Пожалуйста, сообщайте о проблемах и пожеланиях, связанных с этим форматом, на скопах.
трекер проблем.

Совместимые форматы¶

Для обеспечения воспроизводимости и контроля качества, когда используются разные архитектуры.
и среды должны быть приняты во внимание, экспортируя модель в
Открытая нейронная сеть
Формат обмена или язык разметки прогнозной модели
(ПММЛ) формат
может быть лучшим подходом, чем использование в одиночку.
Они полезны, когда вы можете использовать свою модель для прогнозирования в
среда, отличная от той, в которой обучалась модель.

ONNX — это двоичная сериализация модели. Он был разработан для улучшения
удобство использования интероперабельного представления моделей данных.
Его цель – облегчить преобразование данных.
модели между различными платформами машинного обучения и улучшить их
переносимость на различные вычислительные архитектуры. Более подробная информация доступна
из руководства ONNX.
Для преобразования модели scikit-learn в ONNX был разработан специальный инструмент sklearn-onnx.

PMML — это реализация стандарта документов XML.
определены для представления моделей данных вместе с данными, используемыми для их создания.
Будучи читаемым человеком и машиной,
PMML — хороший вариант для проверки модели на разных платформах и
долгосрочное архивирование. С другой стороны, как и в случае с XML в целом, его многословность не позволяет
не помогает в производстве, когда производительность имеет решающее значение.
Чтобы преобразовать модель scikit-learn в PMML, вы можете использовать, например, sklearn2pmml, распространяемый под лицензией Affero GPLv3.
лицензия.

Я хочу сбросить и загрузить свою обученную модель Sklearn с помощью Pickle. Как это сделать?

3 золотых знака76 серебряных знаков76 бронзовых знаков

спросил 26 фев. 2019 в 6:14

импортный маринованный огурец

с open(«model.pkl», «wb») как f:
Pickle.dump(модель, f)

с open(«model.pkl», «rb») как f:
модель = Pickle.load(f)

В конкретном случае scikit-learn, возможно, лучше использовать joblib.
замена травления (свалка и загрузка), что более эффективно при
объекты, которые содержат внутри большие массивы numpy, как это часто бывает
для встроенных оценщиков scikit-learn:

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

joblib.dump(модель, «model.joblib»)

модель = joblib.load(«model.joblib»)

ответил 26 фев. 2019 в 6:47

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

Для сохранения вашей модели в дампе используется слово «wb», означающее запись в двоичном формате.

Pickle.dump(model, open(filename, ‘wb’)) #Сохранение модели

Для загрузки сохраненной модели везде, где это необходимо, используется функция загрузки, где «rb» означает чтение двоичного файла.

model = Pickle.load(open(filename, ‘rb’)) #Чтобы загрузить сохраненную модель из локального каталога

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

ответил 26 фев. 2019 в 7:10

1 золотой знак13 серебряных знаков29 бронзовых знаков

Также можно использовать joblib

из дампа импорта joblib, загрузка
дамп(модель, model_save_path)

ответил 12 июн 2020 в 19:31

2 золотых знака35 серебряных знаков39 бронзовых знаков

оценщики sklearn реализуют методы, упрощающие сохранение соответствующих обученных свойств оценщика. Некоторые оценщики сами реализуют методы __getstate__, но другие, такие как GMM, просто используют базовую реализацию, которая просто сохраняет внутренний словарь объектов:

защита __getstate__(self):
пытаться:
состояние = супер(BaseEstimator, self).__getstate__()
кроме AttributeError:
состояние = self.__dict__.copy()

if type(self).__module__.startswith(‘sklearn.’):
return dict(state.items(), _sklearn_version=__version__)
еще:
вернуть состояние

Рекомендуемый метод сохранения модели на диск — использование модуля Pickle:

Однако вам следует сохранить дополнительные данные, чтобы можно было переобучить свою модель в будущем, иначе вы пострадаете от ужасных последствий (например, будете заблокированы в старой версии sklearn).

Из документации:

Чтобы пересобрать подобную модель с будущими версиями
scikit-learn, дополнительные метаданные должны быть сохранены вместе с маринованным файлом.
модель:

Данные обучения, например. ссылка на неизменяемый снимок

Исходный код Python, использованный для создания модели

Версии scikit-learn и ее зависимости

Оценка перекрестной проверки, полученная на обучающих данных

Это особенно верно для оценщиков Ensemble, которые полагаются на модуль Tree.pyx, написанный на Cython (например, IsolationForest), поскольку он создает связь с реализацией, стабильность которой между версиями sklearn не гарантируется. В прошлом он видел обратно несовместимые изменения.

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

В конкретном случае scikit может быть более интересно использовать
замена рассола в joblib (joblib.dump и joblib.load), которая
более эффективен для объектов, которые содержат внутри большие массивы numpy, поскольку
часто имеет место для встроенных оценщиков scikit-learn, но может только
мариновать на диск, а не на струну:

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

Как только мы создадим модель машинного обучения, наша работа на этом не закончится. Мы можем сохранить модель для использования в будущем. Для этой цели мы можем использовать либо библиотеку Pickle, либо библиотеку joblib. Метод дампа используется для создания модели, а метод загрузки используется для загрузки и использования дампа модели. Теперь продемонстрируем, как это сделать. Методы сохранения и загрузки в Pickle и Joblib имеют одинаковые параметры.

синтаксис метода dump():

Pickle.dump(объект, файл, протокол=Нет, *, fix_imports=True, buffer_callback=Нет)

синтаксис метода load():

Pickle.load(файл, *, fix_imports=True, кодировка=’ASCII’, ошибки=’строгое’, буферы=Нет)

Метод load() Возвращает указанную в нем перестроенную иерархию объектов после чтения маринованного представления объекта из открытого объектного файла.

Сохранение и загрузка моделей с помощью рассола

импортировать панд как pd

импортировать matplotlib.pyplot как plt

из sklearn.linear_model импорт LinearReгрессия

из ​​показателей импорта sklearn

набор данных = pd.read_csv(‘headbrain1.csv’)

X_train, X_test, y_train, y_test = train_test_split(

X, Y, test_size=0,2, случайное_состояние=0)

регрессор = ЛинейнаяРегрессия()

имя файла = ‘linear_model.sav’

Pickle.dump(регрессор, open(имя файла, ‘wb’))

load_model = Pickle.load(open(filename, ‘rb’))

y_pred = load_model.predict(X_test)

print(‘Среднеквадратическая ошибка: ‘, np.sqrt(

Среднеквадратическая ошибка: 72,11529287182815

Сохранение и загрузка моделей с помощью joblib

Экосистема SciPy включает Joblib, который предлагает инструменты для конвейерной обработки заданий Python. Он предлагает инструменты для эффективного сохранения и загрузки объектов Python, использующих структуры данных NumPy. Это может быть полезно для алгоритмов машинного обучения, которым необходимо хранить полный набор данных или иметь множество параметров. давайте рассмотрим простой пример, где мы сохраняем и загружаем модель линейной регрессии. Те же шаги повторяются при использовании библиотеки joblib.

имя файла = ‘linear_model_2.sav’

joblib.dump(регрессор, open(имя файла, ‘wb’))

load_model = joblib.load(open(filename, ‘rb’))