Что выдает предикт в машинном обучении питон
Перейти к содержимому

Что выдает предикт в машинном обучении питон

  • автор:

Оценка моделей машинного обучения с помощью PREDICT

Выделенный пул SQL предоставляет возможность оценки моделей машинного обучения с помощью знакомого языка T-SQL. С помощью функции PREDICT в T-SQL можно взять существующие модели машинного обучения, обученные на основе исторических данных, и оценить эти модели в безопасных границах хранилища данных. Функция PREDICT принимает в качестве входных параметров модель ONNX (Open Neural Network Exchange) и данные. Эта функция исключает необходимость в перемещении ценных данных за пределы хранилища данных для оценки. Ее цель — предоставить специалистам по обработке данных возможность легко развертывать модели машинного обучения с помощью знакомого интерфейса T-SQL. Кроме того, эта функция позволяет организовать удобную совместную работу со специалистами по обработке и анализу данных, используя для выполнения их задач подходящую платформу.

В настоящее время эта функция не поддерживается в бессерверном пуле SQL.

Эта функция требует, чтобы модель обучалась за пределами Synapse SQL. Создав модель, загрузите ее в хранилище данных и оцените с помощью синтаксиса Predict T-SQL, чтобы получить из данных полезные сведения.

predictoverview

Обучение модели

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

  • Выделенный пул SQL поддерживает только модели формата ONNX. ONNX — это формат модели с открытым исходным кодом, который позволяет обмениваться моделями между различными платформами, тем самым обеспечивая взаимодействие. Вы можете преобразовать существующие модели в формат ONNX с помощью платформ, которые либо поддерживают его изначально, либо имеют доступные пакеты преобразования. Например, пакет sklearn-onnx преобразует модели scikit-learn в ONNX. В разделе репозитория GitHub, посвященном ONNX, содержится список поддерживаемых платформ и примеры. Если для обучения используется автоматизированное машинное обучение, для создания модели формата onnx нужно убедится, что для параметра enable_onnx_compatible_models задано значение true. В записной книжке для автоматизированного машинного обучения показан пример использования автоматизированного машинного обучения для создания модели машинного обучения формата ONNX.
  • В качестве входных данных поддерживаются следующие типы данных:
    • int, bigint, real, float
    • char, varchar, nvarchar

    Загрузка модели

    Модель хранится в пользовательской таблице выделенного пула SQL в виде шестнадцатеричной строки. В эту таблицу могут быть добавлены дополнительные столбцы для идентификации модели, такие как идентификатор и описание. Используйте тип varbinary (max) в качестве типа данных для столбцов модели. Ниже приведен пример кода для таблицы, которую можно использовать для хранения моделей:

    -- Sample table schema for storing a model and related data CREATE TABLE [dbo].[Models] ( [Id] [int] IDENTITY(1,1) NOT NULL, [Model] [varbinary](max) NULL, [Description] [varchar](200) NULL ) WITH ( DISTRIBUTION = ROUND_ROBIN, HEAP ) GO 

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

    -- Copy command to load hexadecimal string of the model from Azure Data Lake storage location COPY INTO [Models] (Model) FROM '' WITH ( FILE_TYPE = 'CSV', CREDENTIAL=(IDENTITY= 'Shared Access Signature', SECRET='') ) 

    Оценка модели

    После загрузки модели и данных в хранилище данных используйте функцию PREDICT T-SQL, чтобы оценить модель. Убедитесь, что новые входные данные имеют тот же формат, что и данные для обучения, используемые для создания модели. Функция PREDICT T-SQL принимает два типа входных данных: модель и новые входные данные оценки, а также создает столбцы для выходных данных. Модель можно задать в виде переменной, литерала или скаляра sub_query. Используйте WITH common_table_expression, чтобы указать именованный результирующий набор для параметра данных.

    В примере ниже показан запрос с использованием функции прогнозирования. Создается дополнительный столбец с именем Score и типом данных float, содержащий результаты прогноза. Все столбцы входных данных, а также столбцы прогнозирования выходных данных можно отобразить с помощью оператора Select. Дополнительные сведения см. в описании PREDICT (Transact-SQL).

    -- Query for ML predictions SELECT d.*, p.Score FROM PREDICT(MODEL = (SELECT Model FROM Models WHERE = dbo.mytable AS d, RUNTIME = ONNX) WITH (Score float) AS p; 

    Дальнейшие действия

    Дополнительные сведения о функции PREDICT см. в статье, посвященной PREDICT (Transact-SQL).

    Что такое Scikit Learn — гайд по популярной библиотеке Python для начинающих

    Scikit-learn — один из наиболее широко используемых пакетов Python для Data Science и Machine Learning. Он позволяет выполнять множество операций и предоставляет множество алгоритмов. Scikit-learn также предлагает отличную документацию о своих классах, методах и функциях, а также описание используемых алгоритмов.

    • предварительную обработку данных;
    • уменьшение размерности;
    • выбор модели;
    • регрессии;
    • классификации;
    • кластерный анализ.

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

    Scikit-learn не реализует все, что связано с машинным обучением. Например, он не имеет комплексной поддержки для:

    • нейронных сетей;
    • самоорганизующихся карт (сетей Кохонена);
    • обучения ассоциативным правилам;
    • обучения с подкреплением (reinforcement learning).

    Scikit-learn основан на NumPy и SciPy, поэтому необходимо понять хотя бы азы этих двух библиотек, чтобы эффективно применять Scikit-learn.

    Scikit-learn — это пакет с открытым исходным кодом. Как и большинство материалов из экосистемы Python, он бесплатный даже для коммерческого использования. Он лицензирован под лицензией BSD.

    В этой статье кратко представим некоторые возможности scikit-learn.

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

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

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

    >>> import numpy as np
    >>> x = np.array([[0.1, 1.0, 22.8],
    . [0.5, 5.0, 41.2],
    . [1.2, 12.0, 2.8],
    . [0.8, 8.0, 14.0]])
    >>> x
    array([[ 0.1, 1. , 22.8],
    [ 0.5, 5. , 41.2],
    [ 1.2, 12. , 2.8],
    [ 0.8, 8. , 14. ]])

    Вам часто нужно преобразовывать данные таким образом, чтобы среднее значение каждого столбца (элемента) было равно нулю, а стандартное отклонение — единице. В этом случае, можно использовать sklearn.preprocessing.StandardScaler:

    >>> from sklearn.preprocessing import StandardScaler
    >>> scaler = StandardScaler()
    >>> scaled_x = scaler.fit_transform(x)
    >>> scaler.scale_
    array([ 0.40311289, 4.03112887, 14.04421589])
    >>> scaler.mean_
    array([ 0.65, 6.5 , 20.2 ])
    >>> scaler.var_
    array([1.6250e-01, 1.6250e+01, 1.9724e+02])
    >>> scaled_x
    array([[-1.36438208, -1.36438208, 0.18512959],
    [-0.3721042 , -0.3721042 , 1.4952775 ],
    [ 1.36438208, 1.36438208, -1.23894421],
    [ 0.3721042 , 0.3721042 , -0.44146288]])
    >>> scaled_x.mean().round(decimals=4)
    0.0
    >>> scaled_x.mean(axis=0)
    array([ 1.66533454e-16, -1.38777878e-17, 1.52655666e-16])
    >>> scaled_x.std(axis=0)
    array([1., 1., 1.])
    >>> scaler.inverse_transform(scaled_x)
    array([[ 0.1, 1. , 22.8],
    [ 0.5, 5. , 41.2],
    [ 1.2, 12. , 2.8],
    [ 0.8, 8. , 14. ]])

    Бывает, что у вас есть некоторые категориальные данные, и вам нужно преобразовать их в числа. Один из способов сделать это — использовать класс sklearn.preprocessing.OneHotEncoder. Рассмотрим следующий пример с массивами ролей в компании:

    >>> from sklearn.preprocessing import OneHotEncoder
    >>> roles = np.array([('Tom', 'manager'),
    . ('Mary', 'developer'),
    . ('Ann', 'recruiter'),
    . ('Jim', 'developer')])
    >>> roles
    array([['Tom', 'manager'],
    ['Mary', 'developer'],
    ['Ann', 'recruiter'],
    ['Jim', 'developer']], dtype='>> encoder = OneHotEncoder()
    >>> encoded_roles = encoder.fit_transform(roles[:, [1]])
    >>> encoded_roles.toarray()
    array([[0., 1., 0.],
    [1., 0., 0.],
    [0., 0., 1.],
    [1., 0., 0.]])

    В приведенном выше примере первый столбец объекта encoded_roles указывает, является ли каждый сотрудник разработчиком. Второй и четвертый сотрудник (Мэри и Джим) — разработчики. Второй столбец связан с должностью менеджера. Только первый сотрудник (Том) имеет эту должность. Наконец, третий столбец соответствует должности рекрутера, и им является третий сотрудник (Энн).

    Уменьшение размерности

    Уменьшение размерности включает в себя выбор или извлечение наиболее важных компонентов (признаков) многомерного набора данных. Scikit-learn предлагает несколько подходов к уменьшению размерности. Одним из них является анализ основных компонентов (PCA).

    Выбор модели

    Для обучения и тестирования моделей машинного обучения, вам необходимо случайным образом разбивать данные на подмножества. Это включает как входы, так и их соответствующие выходы. Функция sklearn.model_selection.train_test_split () полезна в таких случаях:

    >>> import numpy as np
    >>> from sklearn.model_selection import train_test_split
    >>> x, y = np.arange(1, 21).reshape(-1, 2), np.arange(3, 40, 4)
    >>> x
    array([[ 1, 2],
    [ 3, 4],
    [ 5, 6],
    [ 7, 8],
    [ 9, 10],
    [11, 12],
    [13, 14],
    [15, 16],
    [17, 18],
    [19, 20]])
    >>> y
    array([ 3, 7, 11, 15, 19, 23, 27, 31, 35, 39])
    >>> x_train, x_test, y_train, y_test =\
    . train_test_split(x, y, test_size=0.4, random_state=0)
    >>> x_train
    array([[ 3, 4],
    [13, 14],
    [15, 16],
    [ 7, 8],
    [ 1, 2],
    [11, 12]])
    >>> y_train
    array([ 7, 27, 31, 15, 3, 23])
    >>> x_test
    array([[ 5, 6],
    [17, 18],
    [ 9, 10],
    [19, 20]])
    >>> y_test
    array([11, 35, 19, 39])

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

    Набор данных

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

    Например, функция sklearn.datasets.load_boston () отображает данные о ценах на дома в районе Бостона (цены не обновляются!). Есть 506 наблюдений, а входная матрица имеет 13 столбцов (признаков):

    >>> from sklearn.datasets import load_boston
    >>> x, y = load_boston(return_X_y=True)
    >>> x.shape, y.shape
    ((506, 13), (506,))

    Этот набор данных подходит для многовариантной регрессии.

    Другой пример — набор данных, связанный с вином. Его можно получить с помощью функции sklearn.datasets.load_wine ():

    >>> from sklearn.datasets import load_wine
    >>> x, y = load_wine(return_X_y=True)
    >>> x.shape, y.shape
    ((178, 13), (178,))
    >>> np.unique(y)
    array([0, 1, 2])

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

    Регрессия

    Scikit-learn поддерживает различные методы регрессии начиная с линейной регрессии, метода k-ближайших соседей посредством полиномиальной регрессии, регрессии опорных векторов, деревьев принятия решений и т.д., до ансамбля методов, таких как random forest и градиентный бустинг. Он также поддерживает нейронные сети, но не в такой степени, как специализированные библиотеки, например, как TensorFlow.

    Ниже покажем регрессию random forest.

    Обычно мы начинаем наше регрессионное путешествие с импорта необходимых нам пакетов, классов и функций:

    >>> import numpy as np
    >>> from sklearn.datasets import load_boston
    >>> from sklearn.ensemble import RandomForestRegressor
    >>> from sklearn.model_selection import train_test_split

    Следующим шагом является получение данных для работы и разделение этих данных на обучающее и тестовое подмножества. Мы будем использовать набор данных Бостона:

    >>> x, y = load_boston(return_X_y=True)
    >>> x_train, x_test, y_train, y_test =\
    . train_test_split(x, y, test_size=0.33, random_state=0)

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

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

    >>> regressor = RandomForestRegressor(n_estimators=10, random_state=0)
    >>> regressor.fit(x_train, y_train)
    RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,
    max_features='auto', max_leaf_nodes=None,
    min_impurity_decrease=0.0, min_impurity_split=None,
    min_samples_leaf=1, min_samples_split=2,
    min_weight_fraction_leaf=0.0, n_estimators=10,
    n_jobs=None, oob_score=False, random_state=0, verbose=0,
    warm_start=False)

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

    >>> regressor.score(x_train, y_train)
    0.9680930547240916
    >>> regressor.score(x_test, y_test)
    0.8219576562705848

    Модель, обученная достаточно хорошо, может использоваться для прогнозирования выходных данных при других новых входных данных x_new. В данном случае, используется команда .predict(): regressor.predict(x_new).

    Классификация

    Scikit-learn выполняет классификацию почти так же, как регрессию. Он поддерживает различные методы классификации, такие как логистическая регрессия и k-ближайшие соседи, метод опорных векторов, наивный байесовский классификатор, дерево принятия решений, а также ансамбль методов, такие как random forest, AdaBoost и градиентный бустинг.

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

    >>> import numpy as np
    >>> from sklearn.datasets import load_wine
    >>> from sklearn.ensemble import RandomForestClassifier
    >>> from sklearn.model_selection import train_test_split
    >>> x, y = load_wine(return_X_y=True)
    >>> x_train, x_test, y_train, y_test =\
    . train_test_split(x, y, test_size=0.33, random_state=0)
    >>> classifier = RandomForestClassifier(n_estimators=10, random_state=0)
    >>> classifier.fit(x_train, y_train)
    RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
    max_depth=None, max_features='auto', max_leaf_nodes=None,
    min_impurity_decrease=0.0, min_impurity_split=None,
    min_samples_leaf=1, min_samples_split=2,
    min_weight_fraction_leaf=0.0, n_estimators=10,
    n_jobs=None, oob_score=False, random_state=0, verbose=0,
    warm_start=False)
    >>> classifier.score(x_train, y_train)
    1.0
    >>> classifier.score(x_test, y_test)
    1.0

    Модель, обученная достаточно хорошо, может использоваться для прогнозирования выходных данных при других новых входных данных. В данном случае, используется команда .predict(): regressor.predict(x_new).

    Кластерный анализ

    Кластеризация — это ветвь неконтролируемого обучения, широко поддерживаемая в scikit-learn. В дополнение к методу k-средних, есть возможность применять метод распространения близости, спектральную кластеризацию, агломеративную кластеризацию и т.д.

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

    Опять же, мы начинаем с импорта и получения данных. На этот раз мы возьмем NumPy и sklearn.cluster.KMeans:

    >>> import numpy as np
    >>> from sklearn.cluster import KMeans
    >>> x = np.array([(0.0, 0.0),
    . (9.9, 8.1),
    . (-1.0, 1.0),
    . (7.1, 5.6),
    . (-5.0, -5.5),
    . (8.0, 9.8),
    . (0.5, 0.5)])
    >>> x
    array([[ 0. , 0. ],
    [ 9.9, 8.1],
    [-1. , 1. ],
    [ 7.1, 5.6],
    [-5. , -5.5],
    [ 8. , 9.8],
    [ 0.5, 0.5]])

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

    >>> cluster_analyzer = KMeans(n_clusters=3, init='k-means++')
    >>> cluster_analyzer.fit()
    >>> cluster_analyzer.fit(x)
    KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
    n_clusters=3, n_init=10, n_jobs=None, precompute_distances='auto',
    random_state=None, tol=0.0001, verbose=0)

    Итак, мы готовы получить результаты, такие как координаты центров кластеров и метки кластеров, которым принадлежит каждое наблюдение:

    >>> cluster_analyzer.cluster_centers_
    array([[ 8.33333333, 7.83333333],
    [-0.16666667, 0.5 ],
    [-5. , -5.5 ]])
    >>> cluster_analyzer.labels_
    array([1, 0, 1, 0, 2, 0, 1], dtype=int32)

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

    Заключение

    В этой статье представлены только основы Scikit-Learn, очень популярного пакета Python по data science и machine learning. Это одна из основных библиотек Python для этих целей.

    Машинное обучение. Что делают методы fit() и predict()

    Знакомлюсь с машинным обучением с помощью Python и библиотеки sklearn. Там есть 2 метода fit() и predict() Честно после некоторых сайтов понимаю,что они делают очень размыто.

    lin_reg.fit(x_train[num_features], y_train) 

    fit(x,y) обучение (тренировка) модели на обучающей выборке X, y-цитата с форума А что это значит? 1)модель смотрит на x_train, выдает рандомное число и сранивает его с y_train? 2)модель смотрит на x_train и y_train и пытается найти какие-то взаимосвязи или настроить коэффициенты? Тут у меня и ступор. predict(X) предсказание на данных X -тоже цитата. То есть модель настроена и мы можем подавать ей входные данные?

    y_pred=lin_reg.predict(x_train[num_features]) 

    но меня тут смущает,почему для тренировки и предсказания мы испульзуем одни и те же данные? Разве не будет сбоя или модель не запомнит все ответы и выдаст 100% результат?

    Отслеживать
    149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака
    задан 30 июн 2020 в 14:45
    143 1 1 золотой знак 1 1 серебряный знак 10 10 бронзовых знаков

    1 ответ 1

    Сортировка: Сброс на вариант по умолчанию

    fit(x,y) обучение (тренировка) модели на обучающей выборке X, y-цитата с форума

    А что это значит?

    2)модель смотрит на x_train и y_train и пытается найти какие-то взаимосвязи или настроить коэффициенты?

    Именно так. Модель пытается найти такие коэффициенты (ну, если примитивно говорить, реальные модели могут быть сильно сложнее, чем простой набор коэффициентов), чтобы минимизировать различие между предсказанием модели по данным x_train и реальным значением y_train.

    predict(X) предсказание на данных X -тоже цитата.

    То есть модель настроена и мы можем подавать ей входные данные?

    y_pred=lin_reg.predict(x_train[num_features]) но меня тут смущает,почему для тренировки и предсказания мы испульзуем одни и те же данные? Разве не будет сбоя или модель не запомнит все ответы и выдаст 100% результат?

    Достаточно сложная модель может запомнить все данные и давать на данных для обучения 100% точность, но цель же машинного обучения не в этом, а в том, чтобы модель хорошо предсказывала на тех данных, которых она ещё не видела. В данном случае просто проверяют, выучилась ли чему-то вообще модель, а то случаи бывают разные. Бывает, учишь модель, а она ничему не научилась вообще. Так что это просто примитивный «sanity check», а не реальная «боевая» ситуация. В реальной жизни, конечно, предсказывают уже на тестовых данных x_test.

    А вообще тема машинного обучения довольно сложна, изучать её можно много лет. У вас вопросы совсем начинающего, постарайтесь почитать ещё какие-то статьи и литературу, там на все эти вопросы есть ответы. Лучше начать «от печки» — с теории, а не сразу применять библиотеки, не понимая, что они вообще делают.

    1)модель смотрит на x_train, выдает рандомное число и сранивает его с y_train?

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

    Введение в машинное обучение с помощью scikit-learn (перевод документации)

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

    Машинное обучение: постановка вопроса

    В общем, задача машинного обучения сводится к получению набора выборок данных и, в последствии, к попыткам предсказать свойства неизвестных данных. Если каждый набор данных — это не одиночное число, а например, многомерная сущность (multi-dimensional entry или multivariate data), то он должен иметь несколько признаков или фич.

    • обучение с учителем (или управляемое обучение). Здесь данные представлены вместе с дополнительными признаками, которые мы хотим предсказать. (Нажмите сюда, чтобы перейти к странице Scikit-Learn обучение с учителем). Это может быть любая из следующих задач:
    1. классификация: выборки данных принадлежат к двум или более классам и мы хотим научиться на уже размеченных данных предсказывать класс неразмеченной выборки. Примером задачи классификации может стать распознавание рукописных чисел, цель которого — присвоить каждому входному набору данных одну из конечного числа дискретных категорий. Другой способ понимания классификации — это понимание ее в качестве дискретной (как противоположность непрерывной) формы управляемого обучения, где у нас есть ограниченное количество категорий, предоставленных для N выборок; и мы пытаемся их пометить правильной категорией или классом.
    2. регрессионный анализ: если желаемый выходной результат состоит из одного или более непрерывных переменных, тогда мы сталкиваемся с регрессионным анализом. Примером решения такой задачи может служить предсказание длинны лосося как результата функции от его возраста и веса.
    • обучение без учителя (или самообучение). В данном случае обучающая выборка состоит из набора входных данных Х без каких-либо соответствующих им значений. Целью подобных задач может быть определение групп схожих элементов внутри данных. Это называется кластеризацией или кластерным анализом. Также задачей может быть установление распределения данных внутри пространства входов, называемое густотой ожидания (density estimation). Или это может быть выделение данных из высоко размерного пространства в двумерное или трехмерное с целью визуализации данных. (Нажмите сюда, чтобы перейти к странице Scikit-Learn обучение без учителя).
    Обучающая выборка и контрольная выборка

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

    Загрузка типовой выборки

    Scikit-learn устанавливается вместе с несколькими стандартными выборками данных, например, iris и digits для классификации, и boston house prices dataset для регрессионного анализа.

    Далее мы запускам Python интерпретатор из командной строки и загружаем выборки iris и digits. Установим условные обозначения: $ означает запуск интерпретатора Python, а >>> обозначает запуск командной строки Python:

    $ python >>> from sklearn import datasets >>> iris = datasets.load_iris() >>> digits = datasets.load_digits()

    Набор данных — это объект типа «словарь», который содержит все данные и некоторые метаданных о них. Эти данные хранятся с расширением .data, например, массивы n_samples, n_features. При машинном обучении с учителем одна или более зависимых переменных хранятся с расширением .target. Для получения более полной информации о наборах данных перейдите в соответствующий раздел.

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

    >>> print(digits.data) [[ 0. 0. 5. . 0. 0. 0.] [ 0. 0. 0. . 10. 0. 0.] [ 0. 0. 0. . 16. 9. 0.] . [ 0. 0. 1. . 6. 0. 0.] [ 0. 0. 2. . 12. 0. 0.] [ 0. 0. 10. . 12. 1. 0.]]

    а digits.target дает возможность определить в числовой выборке, какой цифре соответствует каждое числовое представление, чему мы и будем обучаться:

    >>> digits.target array([0, 1, 2, . 8, 9, 8])
    Форма массива данных

    Обычно, данные представлены в виде двухмерного массива, такую форму имеют n_samples, n_features, хотя исходные данные могут иметь другую форму. В случае с числами, каждая исходная выборка — это представление формой (8, 8), к которому можно получить доступ, используя:

    >>> digits.images[0] array([[ 0., 0., 5., 13., 9., 1., 0., 0.], [ 0., 0., 13., 15., 10., 15., 5., 0.], [ 0., 3., 15., 2., 0., 11., 8., 0.], [ 0., 4., 12., 0., 0., 8., 8., 0.], [ 0., 5., 8., 0., 0., 9., 8., 0.], [ 0., 4., 11., 0., 1., 12., 7., 0.], [ 0., 2., 14., 5., 10., 12., 0., 0.], [ 0., 0., 6., 13., 10., 0., 0., 0.]])

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

    Обучение и прогнозирование

    В случае с числовым набором данных цель обучения — это предсказать, принимая во внимание представление данных, какая цифра изображена. У нас есть образцы каждого из десяти возможных классов (числа от 0 до 9), на которым мы обучаем алгоритм оценки (estimator), чтобы он мог предсказать класс, к которому принадлежит неразмеченный образец.

    В scikit-learn алгоритм оценки для классификатора — это Python объект, который исполняет методы fit(X, y) и predict(T). Пример алгоритма оценки — это класс sklearn.svm.SVC выполняет классификацию методом опорных векторов. Конструктор алгоритма оценки принимает в качестве аргументов параметры модели, но для сокращения времени, мы будем рассматривать этот алгоритм как черный ящик:

    >>> from sklearn import svm >>> clf = svm.SVC(gamma=0.001, C=100.)
    Выбор параметров для модели

    В этом примере мы установили значение gamma вручную. Также можно автоматически определить подходящие значения для параметров, используя такие инструменты как grid search и cross validation.

    Мы назвали экземпляр нашего алгоритма оценки clf, так как он является классификатором. Теперь он должен быть применен к модели, т.е. он должен обучится на модели. Это осуществляется путем прогона нашей обучающей выборки через метод fit. В качестве обучающей выборки мы можем использовать все представления наших данных, кроме последнего. Мы сделали эту выборку с помощью синтаксиса Python [:-1], что создало новый массив, содержащий все, кроме последней, сущности из digits.data:

    >>> clf.fit(digits.data[:-1], digits.target[:-1]) SVC(C=100.0, cache_size=200, class_weight=None, coef0=0.0, degree=3, gamma=0.001, kernel='rbf', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False)

    Теперь можно предсказать новые значения, в частности, мы можем спросить классификатор, какое число содержится в последнем представлении в наборе данных digits, которое мы не использовали в обучении классификатора:

    >>> clf.predict(digits.data[-1]) array([8])

    Соответствующее изображение представлено ниже:

    image

    Как вы можете видеть, это сложная задача: представление в плохом разрешении. Вы согласны с классификатором?

    Полное решение этой задачи классификации доступно в качестве примера, который вы можете запустить и изучить: Recognizing hand-written digits.

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

    В scikit модель можно сохранить, используя встроенный модуль, названный pickle:

    >>> from sklearn import svm >>> from sklearn import datasets >>> clf = svm.SVC() >>> iris = datasets.load_iris() >>> X, y = iris.data, iris.target >>> clf.fit(X, y) SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, degree=3, gamma=0.0, kernel='rbf', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False) >>> import pickle >>> s = pickle.dumps(clf) >>> clf2 = pickle.loads(s) >>> clf2.predict(X[0]) array([0]) >>> y[0] 0

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

    >>> from sklearn.externals import joblib >>> joblib.dump(clf, 'filename.pkl') 

    Потом можно загрузить сохраненную модель(возможно в другой Python процесс) с помощью:

    >>> clf = joblib.load('filename.pkl') 

    Обратите внимание, что joblib.dump возвращает список имен файлов. Каждый отдельный массив numpy, содержащийся в clf объекте, сеарилизован как отдельный файл в файловой системе. Все файлы должны находиться в одной папке, когда вы снова загружаете модель с помощью joblib.load.

    Обратите внимание, что у pickle есть некоторые проблемы с безопасностью и сопровождением. Для получения более детальной информации о хранении моделей в scikit-learn обратитесь к секции Model persistence.

    • machine learning
    • scikit-learn
    • pickle
    • Python
    • Машинное обучение

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *