Spec-Zone.ru › scikit-learn

1.12. Многоклассовые и многовыходные алгоритмы

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

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

В этом разделе рассматриваются два модуля: sklearn.multiclass и sklearn.multioutput. Диаграмма ниже демонстрирует типы задач, за которые отвечает каждый модуль, и соответствующие мета-оценщики, предоставляемые каждым модулем.

../_images/multi_org_chart.png

В таблице ниже приведён быстрый справочник по различиям между типами задач. Более подробные объяснения можно найти в последующих разделах этого руководства.

Количество целевых значений

Кардинальность целевого значения

Допустимый тип type_of_target

Многоклассовая классификация

1

>2

‘multiclass’

Многометковая классификация

>1

2 (0 или 1)

‘multilabel-indicator’

Многоклассово-многовыходная классификация

>1

>2

‘multiclass-multioutput’

Многовыходная регрессия

>1

Непрерывные

‘continuous-multioutput’

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

  • Встроенная многоклассовая классификация:

    • naive_bayes.BernoulliNB
    • tree.DecisionTreeClassifier
    • tree.ExtraTreeClassifier
    • ensemble.ExtraTreesClassifier
    • naive_bayes.GaussianNB
    • neighbors.KNeighborsClassifier
    • semi_supervised.LabelPropagation
    • semi_supervised.LabelSpreading
    • discriminant_analysis.LinearDiscriminantAnalysis
    • svm.LinearSVC (установка multi_class=”crammer_singer”)
    • linear_model.LogisticRegression (со многими решателями)
    • linear_model.LogisticRegressionCV (со многими решателями)
    • neural_network.MLPClassifier
    • neighbors.NearestCentroid
    • discriminant_analysis.QuadraticDiscriminantAnalysis
    • neighbors.RadiusNeighborsClassifier
    • ensemble.RandomForestClassifier
    • linear_model.RidgeClassifier
    • linear_model.RidgeClassifierCV

  • Многоклассовая классификация как Один-против-Остальных:

    • svm.NuSVC
    • svm.SVC.
    • gaussian_process.GaussianProcessClassifier (установка multi_class = “one_vs_one”)

  • Многоклассовая классификация как Один-против-Одного:

    • ensemble.GradientBoostingClassifier
    • gaussian_process.GaussianProcessClassifier (установка multi_class = “one_vs_rest”)
    • svm.LinearSVC (установка multi_class=”ovr”)
    • linear_model.LogisticRegression (большинство решателей)
    • linear_model.LogisticRegressionCV (большинство решателей)
    • linear_model.SGDClassifier
    • linear_model.Perceptron
    • linear_model.PassiveAggressiveClassifier

  • Поддержка многомеченых классификаций:

    • tree.DecisionTreeClassifier
    • tree.ExtraTreeClassifier
    • ensemble.ExtraTreesClassifier
    • neighbors.KNeighborsClassifier
    • neural_network.MLPClassifier
    • neighbors.RadiusNeighborsClassifier
    • ensemble.RandomForestClassifier
    • linear_model.RidgeClassifier
    • linear_model.RidgeClassifierCV

  • Поддержка многоклассовой-многовыходной классификации:

    • tree.DecisionTreeClassifier
    • tree.ExtraTreeClassifier
    • ensemble.ExtraTreesClassifier
    • neighbors.KNeighborsClassifier
    • neighbors.RadiusNeighborsClassifier
    • ensemble.RandomForestClassifier

1.12.1. Многоклассовая классификация

Предупреждение

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

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

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

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

1.12.1.1. Формат целевой переменной

Допустимые представления многоклассовых данных для type_of_target (y):

  • Одномерный вектор или столбец, содержащий более двух дискретных значений. Пример вектора y для 4 образцов:

    >>> import numpy as np
>>> y = np.array(['apple', 'pear', 'apple', 'orange'])
>>> print(y)
['apple' 'pear' 'apple' 'orange']

  • Плотную или разреженную бинарную матрицу формы (n_samples, n_classes) с одним образцом в каждой строке, где каждый столбец представляет один класс. Пример плотной и разреженной бинарной матрицы y для 4 образцов, где столбцы в порядке — яблоко, апельсин и груша:

    >>> import numpy as np
>>> from sklearn.preprocessing import LabelBinarizer
>>> y = np.array(['apple', 'pear', 'apple', 'orange'])
>>> y_dense = LabelBinarizer().fit_transform(y)
>>> print(y_dense)
[[1 0 0]
 [0 0 1]
 [1 0 0]
 [0 1 0]]
>>> from scipy import sparse
>>> y_sparse = sparse.csr_matrix(y_dense)
>>> print(y_sparse)
<Compressed Sparse Row sparse matrix of dtype 'int64'
    with 4 stored elements and shape (4, 3)>
  Coords    Values
  (0, 0)    1
  (1, 2)    1
  (2, 0)    1
  (3, 1)    1

Дополнительную информацию о LabelBinarizer см. в разделе Преобразование целевой переменной (y).

1.12.1.2. OneVsRestClassifier

Стратегия один-против-всех, также известная как один-против-остальных, реализована в OneVsRestClassifier. Стратегия заключается в подборе одного классификатора на каждый класс. Для каждого классификатора класс подбирается относительно всех остальных классов. Помимо своей вычислительной эффективности (требуется только n_classes классификаторов), одним из преимуществ этого подхода является его интерпретируемость. Поскольку каждый класс представлен одним и только одним классификатором, можно получить знания о классе, изучив соответствующий классификатор. Это наиболее часто используемая стратегия и является справедливым вариантом по умолчанию.

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

>>> from sklearn import datasets
>>> from sklearn.multiclass import OneVsRestClassifier
>>> from sklearn.svm import LinearSVC
>>> X, y = datasets.load_iris(return_X_y=True)
>>> OneVsRestClassifier(LinearSVC(random_state=0)).fit(X, y).predict(X)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

OneVsRestClassifier также поддерживает многозначную классификацию. Для использования этой функции передайте классификатору индикаторную матрицу, в которой ячейка [i, j] указывает на присутствие метки j в образце i.

../_images/sphx_glr_plot_multilabel_001.png

Примеры

  • Многозначная классификация
  • График вероятности классификации

1.12.1.3. OneVsOneClassifier

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

Поскольку требуется обучить n_classes * (n_classes - 1) / 2 классификаторов, этот метод обычно медленнее, чем метод один-против-всех, из-за своей сложности O(n_classes^2). Однако этот метод может быть предпочтительнее для алгоритмов, таких как алгоритмы с ядрами, которые плохо масштабируются с n_samples. Это потому, что каждая отдельная задача обучения затрагивает только небольшой подмножество данных, в то время как при использовании метода один-против-всех весь набор данных используется n_classes раз. Функция принятия решения является результатом монотонного преобразования классификации один-против-одного.

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

>>> from sklearn import datasets
>>> from sklearn.multiclass import OneVsOneClassifier
>>> from sklearn.svm import LinearSVC
>>> X, y = datasets.load_iris(return_X_y=True)
>>> OneVsOneClassifier(LinearSVC(random_state=0)).fit(X, y).predict(X)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

Ссылки

  • «Pattern Recognition and Machine Learning. Springer», Christopher M. Bishop, страница 183, (Первое издание)

1.12.1.4. OutputCodeClassifier

Стратегии, основанные на кодах исправления ошибок (Error-Correcting Output Codes), довольно отличаются от методов один-против-всех и один-против-одного. В этих стратегиях каждый класс представлен в евклидовом пространстве, где каждая размерность может принимать только значения 0 или 1. Другими словами, каждый класс представлен двоичным кодом (массивом из 0 и 1). Матрица, отслеживающая местоположение/код каждого класса, называется книгой кодов. Размер кода — это размерность упомянутого пространства. Интуитивно, каждый класс должен быть представлен кодом, максимально отличающимся от других, а хорошая книга кодов должна быть разработана для оптимизации точности классификации. В данной реализации мы просто используем случайно сгенерированную книгу кодов, как рекомендовано в [3], хотя в будущем могут быть добавлены более сложные методы.

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

В OutputCodeClassifier атрибут code_size позволяет пользователю управлять количеством используемых классификаторов. Это процент от общего числа классов.

Число от 0 до 1 потребует меньше классификаторов, чем метод один-против-всех. Теоретически, log2(n_classes) / n_classes классификаторов достаточно, чтобы однозначно представить каждый класс. Однако на практике это может не привести к хорошей точности, так как log2(n_classes) значительно меньше, чем n_classes.

Число больше 1 потребует больше классификаторов, чем метод один-против-всех. В этом случае некоторые классификаторы, теоретически, будут исправлять ошибки, сделанные другими классификаторами, отсюда и название «исправление ошибок». На практике, однако, это может не произойти, так как ошибки классификаторов обычно коррелированы. Коды исправления ошибок аналогичным образом влияют на работу стратегии бэггинг.

Ниже приведен пример обучения многоклассовой модели с использованием Output-Codes:

>>> from sklearn import datasets
>>> from sklearn.multiclass import OutputCodeClassifier
>>> from sklearn.svm import LinearSVC
>>> X, y = datasets.load_iris(return_X_y=True)
>>> clf = OutputCodeClassifier(LinearSVC(random_state=0), code_size=2, random_state=0)
>>> clf.fit(X, y).predict(X)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
       1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

Ссылки

  • «Solving multiclass learning problems via error-correcting output codes», Dietterich T., Bakiri G., Журнал искусственного интеллекта, 2, 1995.
[3]

«The error coding method and PICTs», James G., Hastie T., Журнал вычислительной и графической статистики 7, 1998.

  • «The Elements of Statistical Learning», Hastie T., Tibshirani R., Friedman J., страница 606 (второе издание), 2008.

1.12.2. Многозначная классификация

Многозначная классификация (тесно связанная с многовыходной классификацией) — задача классификации, где каждой выборке присваиваются m метки из n_classes возможных классов, где m может принимать значения от 0 до n_classes включительно. Это можно рассматривать как предсказание свойств выборки, которые не являются взаимоисключающими. Формально каждому классу для каждой выборки присваивается двоичный результат. Положительные классы обозначаются 1, а отрицательные — 0 или -1. Таким образом, это сопоставимо с выполнением n_classes задач двоичной классификации, например, с помощью MultiOutputClassifier. Этот подход рассматривает каждую метку независимо, тогда как многозначные классификаторы могут обрабатывать несколько классов одновременно, учитывая коррелированное поведение между ними.

Например, предсказание тем, относящихся к текстовому документу или видео. Документ или видео могут относиться к одной из тем: «религия», «политика», «финансы» или «образование», к нескольким темам или ко всем темам.

1.12.2.1. Формат целевой переменной

Действительное представление многозначной y — это плотная или разреженная двоичная матрица формы (n_samples, n_classes). Каждый столбец представляет класс. 1 в каждой строке обозначают положительные классы, к которым отнесена выборка. Пример плотной матрицы y для 3 выборок:

>>> y = np.array([[1, 0, 0, 1], [0, 0, 1, 1], [0, 0, 0, 0]])
>>> print(y)
[[1 0 0 1]
 [0 0 1 1]
 [0 0 0 0]]

Плотную двоичную матрицу также можно создать с помощью MultiLabelBinarizer. Дополнительную информацию см. в разделе Преобразование целевой переменной (y).

Пример того же y в разреженной матричной форме:

>>> y_sparse = sparse.csr_matrix(y)
>>> print(y_sparse)
<Compressed Sparse Row sparse matrix of dtype 'int64'
  with 4 stored elements and shape (3, 4)>
  Coords      Values
  (0, 0)      1
  (0, 3)      1
  (1, 2)      1
  (1, 3)      1

1.12.2.2. MultiOutputClassifier

Поддержку многозначной классификации можно добавить к любому классификатору с помощью MultiOutputClassifier. Эта стратегия заключается в подгонке одного классификатора на каждую целевую переменную. Это позволяет классифицировать несколько целевых переменных. Цель этого класса — расширить возможность оценки ряда функций цели (f1,f2,f3…,fn), которые обучаются на единственной матрице предикторов X для предсказания ряда ответов (y1,y2,y3…,yn).

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

1.12.2.3. ClassifierChain

Цепочки классификаторов (см. ClassifierChain) — способ объединения нескольких двоичных классификаторов в одну многозначную модель, которая способна использовать корреляции между целевыми переменными.

Для задачи многозначной классификации с N классами N двоичным классификаторам присваивается целое число от 0 до N-1. Эти целые числа определяют порядок моделей в цепочке. Затем каждый классификатор обучается на имеющихся данных обучения плюс истинные метки классов, для которых моделям присвоено меньшее число.

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

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

Ссылки

  • Jesse Read, Bernhard Pfahringer, Geoff Holmes, Eibe Frank, «Classifier Chains for Multi-label Classification», 2009.

1.12.3. Многоклассовая многовыходная классификация

Многоклассовая многовыходная классификация (также известная как многозадачная классификация) — задача классификации, где каждой выборке присваивается набор недвоичных свойств. Как число свойств, так и число классов по каждому свойству больше 2. Один оценок таким образом обрабатывает несколько совместных задач классификации. Это обобщение задачи многозначной классификации, которая рассматривает только двоичные атрибуты, а также обобщение задачи многоклассовой классификации, где рассматривается только одно свойство.

Например, классификация свойств «тип фрукта» и «цвет» для набора изображений фруктов. Свойство «тип фрукта» имеет возможные классы: «яблоко», «груша» и «апельсин». Свойство «цвет» имеет возможные классы: «зеленый», «красный», «желтый» и «оранжевый». Каждая выборка — изображение фрукта, метка выводится для обоих свойств, и каждая метка — один из возможных классов соответствующего свойства.

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

Ниже приведен пример многоклассовой многовыходной классификации:

>>> from sklearn.datasets import make_classification
>>> from sklearn.multioutput import MultiOutputClassifier
>>> from sklearn.ensemble import RandomForestClassifier
>>> from sklearn.utils import shuffle
>>> import numpy as np
>>> X, y1 = make_classification(n_samples=10, n_features=100,
...                             n_informative=30, n_classes=3,
...                             random_state=1)
>>> y2 = shuffle(y1, random_state=1)
>>> y3 = shuffle(y1, random_state=2)
>>> Y = np.vstack((y1, y2, y3)).T
>>> n_samples, n_features = X.shape # 10,100
>>> n_outputs = Y.shape[1] # 3
>>> n_classes = 3
>>> forest = RandomForestClassifier(random_state=1)
>>> multi_target_forest = MultiOutputClassifier(forest, n_jobs=2)
>>> multi_target_forest.fit(X, Y).predict(X)
array([[2, 2, 0],
       [1, 2, 1],
       [2, 1, 0],
       [0, 0, 2],
       [0, 2, 1],
       [0, 0, 2],
       [1, 1, 0],
       [1, 1, 1],
       [0, 0, 2],
       [2, 0, 0]])

Предупреждение

В настоящее время ни одна метрика в sklearn.metrics не поддерживает задачу многоклассовой многовыходной классификации.

1.12.3.1. Формат целевой переменной

Действительное представление многовыходной y — это плотная матрица формы (n_samples, n_classes) меток классов. Столбцовое объединение одномерных многоклассовых переменных. Пример y для 3 выборок:

>>> y = np.array([['apple', 'green'], ['orange', 'orange'], ['pear', 'green']])
>>> print(y)
[['apple' 'green']
 ['orange' 'orange']
 ['pear' 'green']]

1.12.4. Регрессия с несколькими выходами

Регрессия с несколькими выходами предсказывает несколько числовых свойств для каждого образца. Каждое свойство — это числовая переменная, а количество свойств, подлежащих предсказанию для каждого образца, равно или больше 2. Некоторые оценщики, поддерживающие регрессию с несколькими выходами, работают быстрее, чем просто запуск n_output оценщиков.

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

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

  • cross_decomposition.CCA
  • tree.DecisionTreeRegressor
  • dummy.DummyRegressor
  • linear_model.ElasticNet
  • tree.ExtraTreeRegressor
  • ensemble.ExtraTreesRegressor
  • gaussian_process.GaussianProcessRegressor
  • neighbors.KNeighborsRegressor
  • kernel_ridge.KernelRidge
  • linear_model.Lars
  • linear_model.Lasso
  • linear_model.LassoLars
  • linear_model.LinearRegression
  • multioutput.MultiOutputRegressor
  • linear_model.MultiTaskElasticNet
  • linear_model.MultiTaskElasticNetCV
  • linear_model.MultiTaskLasso
  • linear_model.MultiTaskLassoCV
  • linear_model.OrthogonalMatchingPursuit
  • cross_decomposition.PLSCanonical
  • cross_decomposition.PLSRegression
  • linear_model.RANSACRegressor
  • neighbors.RadiusNeighborsRegressor
  • ensemble.RandomForestRegressor
  • multioutput.RegressorChain
  • linear_model.Ridge
  • linear_model.RidgeCV
  • compose.TransformedTargetRegressor

1.12.4.1. Формат целевой переменной

Действительная форма представления многовыходного y — это плотная матрица формы (n_samples, n_output) с плавающей точкой. Столбцовое объединение непрерывных переменных. Пример y для 3 образцов:

>>> y = np.array([[31.4, 94], [40.5, 109], [25.0, 30]])
>>> print(y)
[[ 31.4  94. ]
 [ 40.5 109. ]
 [ 25.   30. ]]

1.12.4.2. MultiOutputRegressor

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

Ниже приведен пример регрессии с несколькими выходами:

>>> from sklearn.datasets import make_regression
>>> from sklearn.multioutput import MultiOutputRegressor
>>> from sklearn.ensemble import GradientBoostingRegressor
>>> X, y = make_regression(n_samples=10, n_targets=3, random_state=1)
>>> MultiOutputRegressor(GradientBoostingRegressor(random_state=0)).fit(X, y).predict(X)
array([[-154.75474165, -147.03498585,  -50.03812219],
       [   7.12165031,    5.12914884,  -81.46081961],
       [-187.8948621 , -100.44373091,   13.88978285],
       [-141.62745778,   95.02891072, -191.48204257],
       [  97.03260883,  165.34867495,  139.52003279],
       [ 123.92529176,   21.25719016,   -7.84253   ],
       [-122.25193977,  -85.16443186, -107.12274212],
       [ -30.170388  ,  -94.80956739,   12.16979946],
       [ 140.72667194,  176.50941682,  -17.50447799],
       [ 149.37967282,  -81.15699552,   -5.72850319]])

1.12.4.3. RegressorChain

Цепочки регрессоров (см. RegressorChain) аналогичны ClassifierChain как способ объединения нескольких регрессий в единую модель с несколькими целевыми выходами, способную использовать корреляции между целевыми выходами.

© 2007–2025 The scikit-learn developers
Licensed under the 3-clause BSD License.
https://scikit-learn.org/1.6/modules/multiclass.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API