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

6.3.1.1. Масштабирование признаков в диапазон

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

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

Вот пример масштабирования матрицы данных для диапазона [0, 1]:

>>> X_train = np.array([[ 1., -1.,  2.],
...                     [ 2.,  0.,  0.],
...                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Затем тот же экземпляр трансформера может быть применён к новым тестовым данным, невиденным во время вызова fit: те же операции масштабирования и сдвига будут применены, чтобы быть согласованными с преобразованием, выполненным на данных обучения:

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

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

>>> min_max_scaler.scale_
array([0.5       , 0.5       , 0.33...])

>>> min_max_scaler.min_
array([0.        , 0.5       , 0.33...])

Если MinMaxScaler получает явное feature_range=(min, max), полная формула будет:

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

MaxAbsScaler работает очень похожим образом, но масштабирует данные так, что обучающие данные находятся в диапазоне [-1, 1], деля на наибольшее максимальное значение в каждом признаке. Он предназначен для данных, которые уже центрированы в нуле или разреженных данных.

Вот как использовать данные из предыдущего примера с этим масштабировщиком:

>>> X_train = np.array([[ 1., -1.,  2.],
...                     [ 2.,  0.,  0.],
...                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

6.3.1.2. Масштабирование разреженных данных

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

MaxAbsScaler был специально разработан для масштабирования разреженных данных и является рекомендуемым способом сделать это. Однако, StandardScaler может принимать scipy.sparse матрицы в качестве входных данных, если with_mean=False явно передаётся в конструктор. В противном случае будет поднято ValueError, так как безмолвное центрирование нарушит разреженность и часто приведёт к аварийному завершению выполнения из-за нежелательного выделения избыточного объёма памяти. RobustScaler не может быть обучен на разреженных входных данных, но вы можете использовать метод transform для разреженных входных данных.

Обратите внимание, что масштабировщики принимают как формат Compressed Sparse Rows, так и Compressed Sparse Columns (см. scipy.sparse.csr_matrix и scipy.sparse.csc_matrix). Любой другой разреженный вход будет преобразован в представление Compressed Sparse Rows. Для избежания ненужных копий памяти рекомендуется использовать представление CSR или CSC на этапе обработки данных.

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

6.3.1.3. Масштабирование данных с выбросами

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

6.3.1.4. Центрирование матриц ядер

Если у вас есть матрица ядер ядра \(K\), которое вычисляет скалярное произведение в пространстве признаков (возможно, неявно) определённом функцией \(\phi(\cdot)\), KernelCenterer может преобразовать матрицу ядер так, чтобы она содержала скалярные произведения в пространстве признаков, определённом \(\phi\), после удаления среднего значения в этом пространстве. Другими словами, KernelCenterer вычисляет центрированную матрицу Грама, связанную с положительно полуопределённым ядром \(K\).

6.3.2.1. Отображение на равномерное распределение

QuantileTransformer предоставляет непараметрическое преобразование для отображения данных на равномерное распределение со значениями от 0 до 1:

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

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

>>> np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100])
... 
array([ 0.00... ,  0.24...,  0.49...,  0.73...,  0.99... ])

Это можно подтвердить на независимом тестовом наборе с аналогичными замечаниями:

>>> np.percentile(X_test[:, 0], [0, 25, 50, 75, 100])
... 
array([ 4.4  ,  5.125,  5.75 ,  6.175,  7.3  ])
>>> np.percentile(X_test_trans[:, 0], [0, 25, 50, 75, 100])
... 
array([ 0.01...,  0.25...,  0.46...,  0.60... ,  0.94...])

6.3.2.2. Отображение на нормальное распределение

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

PowerTransformer в настоящее время предоставляет два таких степенных преобразования: преобразование Йео-Джонсона и преобразование Бокса-Кокса.

>>> pt = preprocessing.PowerTransformer(method='box-cox', standardize=False)
>>> X_lognormal = np.random.RandomState(616).lognormal(size=(3, 3))
>>> X_lognormal
array([[1.28..., 1.18..., 0.84...],
      [0.94..., 1.60..., 0.38...],
      [1.35..., 0.21..., 1.09...]])
>>> pt.fit_transform(X_lognormal)
array([[ 0.49...,  0.17..., -0.15...],
      [-0.05...,  0.58..., -0.57...],
      [ 0.69..., -0.84...,  0.10...]])

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

Также можно отобразить данные на нормальное распределение с помощью QuantileTransformer, установив output_distribution='normal'. Используя предыдущий пример с набором данных ирисов:

>>> quantile_transformer = preprocessing.QuantileTransformer(
...     output_distribution='normal', random_state=0)
>>> X_trans = quantile_transformer.fit_transform(X)
>>> quantile_transformer.quantiles_
array([[4.3, 2. , 1. , 0.1],
       [4.4, 2.2, 1.1, 0.1],
       [4.4, 2.2, 1.2, 0.1],
       ...,
       [7.7, 4.1, 6.7, 2.5],
       [7.7, 4.2, 6.7, 2.5],
       [7.9, 4.4, 6.9, 2.5]])

Таким образом, медиана входных данных становится средним значением выходных данных, центрированным в 0. Выходной нормальный набор данных ограничен таким образом, чтобы минимальное и максимальное значение входных данных — соответствующие процентилям 1e-7 и 1 - 1e-7 соответственно — не становились бесконечными при преобразовании.

6.3.4.1. Часто встречающиеся категории

OneHotEncoder и OrdinalEncoder поддерживают агрегирование редких категорий в один выход для каждого признака. Параметры для включения сбора редких категорий — min_frequency и max_categories.

1. min_frequency — это целое число, больше или равно 1, или число с плавающей запятой в интервале (0.0, 1.0). Если min_frequency — целое число, категории с кратностью меньше min_frequency будут считаться редкими. Если min_frequency — число с плавающей запятой, категории с кратностью меньше этой доли от общего количества образцов будут считаться редкими. Значение по умолчанию — 1, что означает, что каждая категория кодируется отдельно.
2. max_categories — это None или любое целое число больше 1. Этот параметр устанавливает верхний предел количества выходных признаков для каждого входного признака. max_categories включает признак, объединяющий редкие категории.

В следующем примере с OrdinalEncoder категории 'dog' and 'snake' считаются редкими:

>>> X = np.array([['dog'] * 5 + ['cat'] * 20 + ['rabbit'] * 10 +
...               ['snake'] * 3], dtype=object).T
>>> enc = preprocessing.OrdinalEncoder(min_frequency=6).fit(X)
>>> enc.infrequent_categories_
[array(['dog', 'snake'], dtype=object)]
>>> enc.transform(np.array([['dog'], ['cat'], ['rabbit'], ['snake']]))
array([[2.],
       [0.],
       [1.],
       [2.]])

OrdinalEncoder’s max_categories не учитывают пропущенные или неизвестные категории. Установка unknown_value или encoded_missing_value в целое число увеличит количество уникальных целочисленных кодов на единицу. Это может привести к максимальному количеству целочисленных кодов max_categories + 2. В следующем примере «a» и «d» считаются редкими и объединяются в одну категорию «b» и «c» — в свои собственные категории, неизвестные значения кодируются как 3, а пропущенные значения — как 4.

>>> X_train = np.array(
...     [["a"] * 5 + ["b"] * 20 + ["c"] * 10 + ["d"] * 3 + [np.nan]],
...     dtype=object).T
>>> enc = preprocessing.OrdinalEncoder(
...     handle_unknown="use_encoded_value", unknown_value=3,
...     max_categories=3, encoded_missing_value=4)
>>> _ = enc.fit(X_train)
>>> X_test = np.array([["a"], ["b"], ["c"], ["d"], ["e"], [np.nan]], dtype=object)
>>> enc.transform(X_test)
array([[2.],
       [0.],
       [1.],
       [2.],
       [3.],
       [4.]])

Аналогично, OneHotEncoder можно настроить для объединения редких категорий:

>>> enc = preprocessing.OneHotEncoder(min_frequency=6, sparse_output=False).fit(X)
>>> enc.infrequent_categories_
[array(['dog', 'snake'], dtype=object)]
>>> enc.transform(np.array([['dog'], ['cat'], ['rabbit'], ['snake']]))
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Установив handle_unknown на 'infrequent_if_exist', неизвестные категории будут считаться редкими:

>>> enc = preprocessing.OneHotEncoder(
...    handle_unknown='infrequent_if_exist', sparse_output=False, min_frequency=6)
>>> enc = enc.fit(X)
>>> enc.transform(np.array([['dragon']]))
array([[0., 0., 1.]])

OneHotEncoder.get_feature_names_out использует ‘infrequent’ в качестве имени признака редких категорий:

>>> enc.get_feature_names_out()
array(['x0_cat', 'x0_rabbit', 'x0_infrequent_sklearn'], dtype=object)

Когда 'handle_unknown' установлено на 'infrequent_if_exist', при встрече неизвестной категории в transform:

1. Если поддержка редких категорий не настроена или редких категорий не было во время обучения, результирующие закодированные в один горячий столбец для данного признака будут все нули. При обратном преобразовании неизвестная категория будет обозначена как None.
2. Если во время обучения есть редкие категории, неизвестная категория будет считаться редкой. При обратном преобразовании для обозначения редкой категории будет использоваться «infrequent_sklearn».

Редкие категории также можно настроить, используя max_categories. В следующем примере мы устанавливаем max_categories=2 для ограничения количества признаков в выходе. Это приведет к тому, что все, кроме категории 'cat', будут считаться редкими, что приведет к двум признакам: один для 'cat' и один для редких категорий — все остальные.

>>> enc = preprocessing.OneHotEncoder(max_categories=2, sparse_output=False)
>>> enc = enc.fit(X)
>>> enc.transform([['dog'], ['cat'], ['rabbit'], ['snake']])
array([[0., 1.],
       [1., 0.],
       [0., 1.],
       [0., 1.]])

Если и max_categories, и min_frequency имеют значения, отличные от значений по умолчанию, то категории выбираются на основе min_frequency и max_categories категорий сохраняются. В следующем примере min_frequency=4 учитывает только snake как редкую, но max_categories=3, заставляет dog также быть редкой.

>>> enc = preprocessing.OneHotEncoder(min_frequency=4, max_categories=3, sparse_output=False)
>>> enc = enc.fit(X)
>>> enc.transform([['dog'], ['cat'], ['rabbit'], ['snake']])
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Если есть редкие категории с одинаковой кратностью на отсечении max_categories, то первые max_categories берутся в соответствии с лексикографическим порядком. В следующем примере «b», «c» и «d» имеют одинаковую кратность и с max_categories=2, «b» и «c» являются редкими, так как у них больший лексикографический порядок.

>>> X = np.asarray([["a"] * 20 + ["b"] * 10 + ["c"] * 10 + ["d"] * 10], dtype=object).T
>>> enc = preprocessing.OneHotEncoder(max_categories=3).fit(X)
>>> enc.infrequent_categories_
[array(['b', 'c'], dtype=object)]

6.3.4.2. Кодировщик целей

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

fit_transform внутренне использует схему кросс-валидации для предотвращения утечки информации о целевой переменной в представление во время обучения, особенно для неинформативных категориальных переменных с высокой размерностью, и помогает предотвратить переобучение модели на ложных корреляциях. Обратите внимание, что в результате fit(X, y).transform(X) не равно fit_transform(X, y). В fit_transform данные обучения разбиваются на k фолдов (определяемых параметром cv) и каждый фолд кодируется с использованием кодирований, полученных из других k-1 фолдов. На следующем рисунке показана схема кросс-валидации в fit_transform с параметром по умолчанию cv=5.

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

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

Примеры

• Сравнение кодировщика целей с другими кодировщиками
• Внутренняя схема кросс-валидации кодировщика целей

Ссылки

6.3.5.1. Дискретизация с K ячейками

KBinsDiscretizer дискретизирует признаки на k ячейки:

>>> X = np.array([[ -3., 5., 15 ],
...               [  0., 6., 14 ],
...               [  6., 3., 11 ]])
>>> est = preprocessing.KBinsDiscretizer(n_bins=[3, 2, 2], encode='ordinal').fit(X)

По умолчанию результат кодируется с помощью one-hot в разреженную матрицу (см. Кодирование категориальных признаков), и это можно настроить с помощью параметра encode. Для каждого признака границы ячеек вычисляются во время fit, и вместе с числом ячеек они определят интервалы. Таким образом, для текущего примера эти интервалы определяются как:

• признак 1: \({[-\infty, -1), [-1, 2), [2, \infty)}\)
• признак 2: \({[-\infty, 5), [5, \infty)}\)
• признак 3: \({[-\infty, 14), [14, \infty)}\)

На основе этих интервалов ячеек X преобразуется следующим образом:

>>> est.transform(X)                      
array([[ 0., 1., 1.],
       [ 1., 1., 1.],
       [ 2., 0., 0.]])

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

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

KBinsDiscretizer реализует различные стратегии бинингования, которые можно выбрать с помощью параметра strategy. Стратегия «uniform» использует ячейки с постоянной шириной. Стратегия «quantile» использует значения квантилей для равномерного заполнения ячеек для каждого признака. Стратегия «kmeans» определяет ячейки на основе процедуры кластеризации k-means, выполняемой для каждого признака независимо.

Обратите внимание, что можно указать пользовательские ячейки, передав вызываемую функцию, определяющую стратегию дискретизации, в FunctionTransformer. Например, мы можем использовать функцию Pandas pandas.cut:

>>> import pandas as pd
>>> import numpy as np
>>> from sklearn import preprocessing
>>>
>>> bins = [0, 1, 13, 20, 60, np.inf]
>>> labels = ['infant', 'kid', 'teen', 'adult', 'senior citizen']
>>> transformer = preprocessing.FunctionTransformer(
...     pd.cut, kw_args={'bins': bins, 'labels': labels, 'retbins': False}
... )
>>> X = np.array([0.2, 2, 15, 25, 97])
>>> transformer.fit_transform(X)
['infant', 'kid', 'teen', 'adult', 'senior citizen']
Categories (5, object): ['infant' < 'kid' < 'teen' < 'adult' < 'senior citizen']

Примеры

• Использование KBinsDiscretizer для дискретизации непрерывных признаков
• Дискретизация признаков
• Демонстрация различных стратегий KBinsDiscretizer

6.3.5.2. Бинаризация признаков

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

Среди текстовых процессоров также часто используются бинарные значения признаков (вероятно, для упрощения вероятностного рассуждения), даже если нормализованные подсчеты (также известные как частоты терминов) или признаки TF-IDF часто демонстрируют немного лучшие результаты на практике.

Что касается класса Normalizer, утилитарный класс Binarizer предназначен для использования на ранних этапах Pipeline. Метод fit ничего не делает, так как каждый образец обрабатывается независимо от других:

>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]

>>> binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
>>> binarizer
Binarizer()

>>> binarizer.transform(X)
array([[1., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])

Можно настроить порог бинаризатора:

>>> binarizer = preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 0., 0.]])

Что касается класса Normalizer, модуль предобработки предоставляет вспомогательную функцию binarize, предназначенную для использования, когда API трансформатора не нужен.

Обратите внимание, что Binarizer похож на KBinsDiscretizer, когда k = 2, и когда граница ячейки находится в значении threshold.

6.3.7.1. Полиномиальные признаки

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

>>> import numpy as np
>>> from sklearn.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])

Признаки X были преобразованы от \((X_1, X_2)\) к \((1, X_1, X_2, X_1^2, X_1X_2, X_2^2)\).

В некоторых случаях требуются только члены взаимодействия между признаками, и их можно получить с настройкой interaction_only=True:

>>> X = np.arange(9).reshape(3, 3)
>>> X
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> poly = PolynomialFeatures(degree=3, interaction_only=True)
>>> poly.fit_transform(X)
array([[  1.,   0.,   1.,   2.,   0.,   0.,   2.,   0.],
       [  1.,   3.,   4.,   5.,  12.,  15.,  20.,  60.],
       [  1.,   6.,   7.,   8.,  42.,  48.,  56., 336.]])

Признаки X были преобразованы от \((X_1, X_2, X_3)\) к \((1, X_1, X_2, X_3, X_1X_2, X_1X_3, X_2X_3, X_1X_2X_3)\).

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

См. Интерполяция полиномами и сплайнами для регрессии Риджа с созданными полиномиальными признаками.

6.3.7.2. Преобразователь сплайнов

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

Некоторые преимущества сплайнов по сравнению с полиномами:

• B-сплайны очень гибкие и надёжные, если вы сохраните фиксированную низкую степень, обычно 3, и экономно адаптируете количество узлов. Полиномы потребовали бы большей степени, что приводит к следующему пункту.
• B-сплайны не имеют колебательного поведения на границах, как полиномы (чем выше степень, тем хуже). Это известно как явление Рунге.
• B-сплайны обеспечивают хорошие варианты экстраполяции за пределы границ, т. е. за пределы диапазона аппроксимируемых значений. Обратите внимание на параметр extrapolation.
• B-сплайны генерируют матрицу признаков с полосатой структурой. Для одного признака каждая строка содержит только degree + 1 ненулевых элементов, которые встречаются последовательно и даже положительны. Это приводит к матрице с хорошими численными свойствами, например, малой числовой обусловленностью, в резком контрасте с матрицей полиномов, которая называется матрицей Вандермонда. Малая числовая обусловленность важна для устойчивых алгоритмов линейных моделей.

Следующий фрагмент кода демонстрирует сплайны в действии:

>>> import numpy as np
>>> from sklearn.preprocessing import SplineTransformer
>>> X = np.arange(5).reshape(5, 1)
>>> X
array([[0],
       [1],
       [2],
       [3],
       [4]])
>>> spline = SplineTransformer(degree=2, n_knots=3)
>>> spline.fit_transform(X)
array([[0.5  , 0.5  , 0.   , 0.   ],
       [0.125, 0.75 , 0.125, 0.   ],
       [0.   , 0.5  , 0.5  , 0.   ],
       [0.   , 0.125, 0.75 , 0.125],
       [0.   , 0.   , 0.5  , 0.5  ]])

Поскольку X отсортированы, легко увидеть выходной полосатый матрицы. Только три средние диагонали ненулевые для degree=2. Чем выше степень, тем больше перекрытие сплайнов.

Интересно, что SplineTransformer от degree=0 эквивалентен KBinsDiscretizer с encode='onehot-dense' и n_bins = n_knots - 1 если knots = strategy.

Примеры

• Интерполяция полиномами и сплайнами
• Инженерия временных признаков