3.1. Перекрестная проверка: оценка производительности оценщика

3.1.2.1.1. K-кратная перекрёстная проверка

KFold делит все образцы на \(k\) групп образцов, называемых фолдами (если \(k = n\), это эквивалентно стратегии «оставить один извне»), равного размера (если это возможно). Функция предсказания обучается с использованием \(k - 1\) фолдов, а оставшийся фолд используется для тестирования.

Пример 2-кратной перекрёстной проверки на наборе данных с 4 образцами:

Вот визуализация поведения перекрёстной проверки. Обратите внимание, что KFold не зависит от классов или групп.

3.1.2.1.2. Повторная K-кратная перекрёстная проверка

RepeatedKFold повторяет K-кратную перекрёстную проверку n раз. Она может использоваться, когда необходимо выполнить KFold n раз, создавая разные разбиения на каждой итерации.

Пример 2-кратной K-кратной перекрёстной проверки, повторённой 2 раза:

%%%CODE_BLOCK_47%%>

Аналогично, RepeatedStratifiedKFold повторяет стратифицированную K-кратную перекрёстную проверку n раз с разной случайностью на каждой итерации.

3.1.2.1.3. Оставление одного (LOO)

LeaveOneOut (или LOO) — это простой вид перекрестной проверки. Каждый обучающий набор создаётся путём исключения одного образца, а тестовый набор состоит из этого исключённого образца. Таким образом, для \(n\) образцов у нас есть \(n\) различных обучающих наборов и \(n\) различных тестовых наборов. Эта процедура перекрестной проверки не тратит много данных, так как из обучающего набора удаляется только один образец:

>>> from sklearn.model_selection import LeaveOneOut

>>> X = [1, 2, 3, 4]
>>> loo = LeaveOneOut()
>>> for train, test in loo.split(X):
...     print("%s %s" % (train, test))
[1 2 3] [0]
[0 2 3] [1]
[0 1 3] [2]
[0 1 2] [3]

Пользователям, использующим LOO для выбора модели, следует учитывать некоторые известные недостатки. По сравнению с \(k\)-кратной перекрестной проверкой, создаётся \(n\) моделей из \(n\) образцов вместо \(k\) моделей, где \(n > k\). Кроме того, каждая модель обучается на \(n - 1\) образцах вместо \((k-1) n / k\). В обоих случаях, предполагая, что \(k\) не слишком велико и \(k < n\), LOO является более вычислительно затратной, чем \(k\)-кратная перекрестная проверка.

С точки зрения точности, LOO часто приводит к высокой дисперсии в качестве оценки ошибки тестирования. Интуитивно, поскольку \(n - 1\) из \(n\) образцов используются для построения каждой модели, модели, построенные из блоков, практически идентичны друг другу и модели, построенной на основе всего обучающего набора.

Однако, если кривая обучения крутая для рассматриваемого размера обучающего набора, то 5- или 10-кратная перекрестная проверка может переоценить ошибку обобщения.

Как общее правило, большинство авторов и эмпирические данные свидетельствуют о том, что 5- или 10-кратная перекрестная проверка предпочтительнее LOO.

3.1.2.1.4. Оставление P (LPO)

LeavePOut очень похож на LeaveOneOut, поскольку он создаёт все возможные обучающие/тестовые наборы путём удаления \(p\) образцов из полного набора. Для \(n\) образцов это даёт \({n \choose p}\) пар обучение-тест. В отличие от LeaveOneOut и KFold, тестовые наборы будут перекрываться для \(p > 1\).

Пример оставления двух образцов для набора данных с 4 образцами:

>>> from sklearn.model_selection import LeavePOut

>>> X = np.ones(4)
>>> lpo = LeavePOut(p=2)
>>> for train, test in lpo.split(X):
...     print("%s %s" % (train, test))
[2 3] [0 1]
[1 3] [0 2]
[1 2] [0 3]
[0 3] [1 2]
[0 2] [1 3]
[0 1] [2 3]

3.1.2.1.5. Перекрёстная валидация случайными перестановками (иначе Shuffle & Split)

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

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

Вот пример использования:

>>> from sklearn.model_selection import ShuffleSplit
>>> X = np.arange(10)
>>> ss = ShuffleSplit(n_splits=5, test_size=0.25, random_state=0)
>>> for train_index, test_index in ss.split(X):
...     print("%s %s" % (train_index, test_index))
[9 1 6 7 3 0 5] [2 8 4]
[2 9 8 0 6 7 4] [3 5 1]
[4 5 1 0 6 9 7] [2 3 8]
[2 7 5 8 0 3 4] [6 1 9]
[4 1 0 6 8 9 3] [5 2 7]

Вот визуализация поведения перекрестной валидации. Обратите внимание, что ShuffleSplit не зависит от классов или групп.

ShuffleSplit — хорошая альтернатива перекрёстной валидации с помощью KFold, позволяющая точнее управлять количеством итераций и пропорцией образцов в обучающей и тестовой выборках.

3.1.2.2.1. Стратифицированный k-фолдовый перекрёстный контроль

StratifiedKFold — это вариация k-фолдовой схемы, которая возвращает стратифицированные фолды: каждый набор содержит примерно такой же процент образцов каждого целевого класса, как и весь набор данных.

Вот пример стратифицированной 3-фолдовой кросс-валидации на наборе данных с 50 образцами из двух несбалансированных классов. Мы покажем количество образцов в каждом классе и сравним с KFold.

>>> from sklearn.model_selection import StratifiedKFold, KFold
>>> import numpy as np
>>> X, y = np.ones((50, 1)), np.hstack(([0] * 45, [1] * 5))
>>> skf = StratifiedKFold(n_splits=3)
>>> for train, test in skf.split(X, y):
...     print('train -  {}   |   test -  {}'.format(
...         np.bincount(y[train]), np.bincount(y[test])))
train -  [30  3]   |   test -  [15  2]
train -  [30  3]   |   test -  [15  2]
train -  [30  4]   |   test -  [15  1]
>>> kf = KFold(n_splits=3)
>>> for train, test in kf.split(X, y):
...     print('train -  {}   |   test -  {}'.format(
...         np.bincount(y[train]), np.bincount(y[test])))
train -  [28  5]   |   test -  [17]
train -  [28  5]   |   test -  [17]
train -  [34]   |   test -  [11  5]

Мы можем видеть, что StratifiedKFold сохраняет соотношения классов (приблизительно 1/10) как в обучающем, так и в тестовом наборах данных.

Вот визуализация поведения кросс-валидации.

RepeatedStratifiedKFold можно использовать для повторения стратифицированного k-фолдового перекрёстного контроля n раз с различной случайной выборкой на каждом повторении.

3.1.2.2.2. Стратифицированное перемешивание и разбиение

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

Вот визуализация поведения перекрестной проверки.

3.1.2.4.1. Группа k-fold

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

Представьте, что у вас три субъекта, каждому из которых присвоено число от 1 до 3:

>>> from sklearn.model_selection import GroupKFold

>>> X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 8.8, 9, 10]
>>> y = ["a", "b", "b", "b", "c", "c", "c", "d", "d", "d"]
>>> groups = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]

>>> gkf = GroupKFold(n_splits=3)
>>> for train, test in gkf.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
[0 1 2 3 4 5] [6 7 8 9]
[0 1 2 6 7 8 9] [3 4 5]
[3 4 5 6 7 8 9] [0 1 2]

Каждый субъект находится в отдельной проверочной папке, и один и тот же субъект никогда не находится как в проверочной, так и в обучающей выборке. Обратите внимание, что папки не имеют одинакового размера из-за дисбаланса в данных. Если необходимо, чтобы пропорции классов были сбалансированы по всем папкам, StratifiedGroupKFold — лучший вариант.

Вот визуализация поведения перекрестной проверки.

Подобно KFold, тестовые наборы из GroupKFold составят полное разбиение всех данных.

Хотя GroupKFold пытается разместить одинаковое количество выборок в каждой папке, когда shuffle=False, когда shuffle=True он пытается разместить равное количество различных групп в каждой папке (но не учитывает размеры групп).

3.1.2.4.2. StratifiedGroupKFold

StratifiedGroupKFold — это схема перекрестной проверки, которая объединяет как StratifiedKFold, так и GroupKFold. Идея состоит в том, чтобы сохранить распределение классов в каждом разбиении, сохраняя при этом каждую группу в одном разбиении. Это может быть полезно, когда у вас несбалансированный набор данных, так как использование только GroupKFold может привести к искажённым разбиениям.

Пример:

>>> from sklearn.model_selection import StratifiedGroupKFold
>>> X = list(range(18))
>>> y = [1] * 6 + [0] * 12
>>> groups = [1, 2, 3, 3, 4, 4, 1, 1, 2, 2, 3, 4, 5, 5, 5, 6, 6, 6]
>>> sgkf = StratifiedGroupKFold(n_splits=3)
>>> for train, test in sgkf.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
[ 0  2  3  4  5  6  7 10 11 15 16 17] [ 1  8  9 12 13 14]
[ 0  1  4  5  6  7  8  9 11 12 13 14] [ 2  3 10 15 16 17]
[ 1  2  3  8  9 10 12 13 14 15 16 17] [ 0  4  5  6  7 11]

Вот визуализация поведения перекрестной проверки для неравномерных групп:

3.1.2.4.3. Оставление одной группы вне

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

Каждый обучающий набор таким образом составляется из всех образцов, кроме тех, которые относятся к определённой группе. Это аналогично LeavePGroupsOut с n_groups=1 и аналогично GroupKFold с n_splits равным числу уникальных меток, переданных в параметр groups.

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

>>> from sklearn.model_selection import LeaveOneGroupOut

>>> X = [1, 5, 10, 50, 60, 70, 80]
>>> y = [0, 1, 1, 2, 2, 2, 2]
>>> groups = [1, 1, 2, 2, 3, 3, 3]
>>> logo = LeaveOneGroupOut()
>>> for train, test in logo.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
[2 3 4 5 6] [0 1]
[0 1 4 5 6] [2 3]
[0 1 2 3] [4 5 6]

Другим распространённым применением является использование временной информации: например, группы могут представлять год сбора образцов, и, таким образом, позволяют проводить перекрестную проверку по временным разбиениям.

3.1.2.4.4. Оставление P групп вне

LeavePGroupsOut аналогично LeaveOneGroupOut, но удаляет образцы, относящиеся к \(P\) группам для каждого набора обучение/тестирование. Все возможные комбинации из \(P\) групп исключаются, что означает перекрытие наборов для тестирования при \(P>1\).

Пример оставления 2 групп вне:

>>> from sklearn.model_selection import LeavePGroupsOut

>>> X = np.arange(6)
>>> y = [1, 1, 1, 2, 2, 2]
>>> groups = [1, 1, 2, 2, 3, 3]
>>> lpgo = LeavePGroupsOut(n_groups=2)
>>> for train, test in lpgo.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
[4 5] [0 1 2 3]
[2 3] [0 1 4 5]
[0 1] [2 3 4 5]

3.1.2.4.5. Разбиение с перемешиванием по группам

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

Вот пример использования:

>>> from sklearn.model_selection import GroupShuffleSplit

>>> X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 0.001]
>>> y = ["a", "b", "b", "b", "c", "c", "c", "a"]
>>> groups = [1, 1, 2, 2, 3, 3, 4, 4]
>>> gss = GroupShuffleSplit(n_splits=4, test_size=0.5, random_state=0)
>>> for train, test in gss.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
...
[0 1 2 3] [4 5 6 7]
[2 3 6 7] [0 1 4 5]
[2 3 4 5] [0 1 6 7]
[4 5 6 7] [0 1 2 3]

Вот визуализация поведения перекрестной проверки.

Этот класс полезен, когда требуется поведение LeavePGroupsOut, но количество групп достаточно велико, чтобы генерация всех возможных разбиений с исключенными \(P\) группами была бы слишком дорогостоящей. В такой ситуации GroupShuffleSplit предоставляет случайную выборку (с возвращением) разбиений на обучающую и тестовую выборки, сгенерированных методом LeavePGroupsOut.

3.1.2.6.1. Разбиение по временным рядам

TimeSeriesSplit — это разновидность k-fold, которая возвращает первые \(k\) фолдов в качестве обучающей выборки, а \((k+1)\) -й фолд в качестве тестовой. Обратите внимание, что в отличие от стандартных методов перекрёстной проверки последовательные обучающие выборки являются супермножествами тех, что были до них. Кроме того, он добавляет все избыточные данные в первый обучающий раздел, который всегда используется для обучения модели.

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

Пример перекрёстной проверки временных рядов с 3 разбиениями на наборе данных с 6 образцами:

>>> from sklearn.model_selection import TimeSeriesSplit

>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
>>> y = np.array([1, 2, 3, 4, 5, 6])
>>> tscv = TimeSeriesSplit(n_splits=3)
>>> print(tscv)
TimeSeriesSplit(gap=0, max_train_size=None, n_splits=3, test_size=None)
>>> for train, test in tscv.split(X):
...     print("%s %s" % (train, test))
[0 1 2] [3]
[0 1 2 3] [4]
[0 1 2 3 4] [5]

Вот визуализация поведения перекрёстной проверки.