3.1. Кросс-валидация: оценка качества работы оценщика

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

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

Пример двухблочной перекрёстной проверки на наборе данных из 4 выборок:

>>> import numpy as np
>>> from sklearn.model_selection import KFold

>>> X = ["a", "b", "c", "d"]
>>> kf = KFold(n_splits=2)
>>> for train, test in kf.split(X):
...     print("%s %s" % (train, test))
[2 3] [0 1]
[0 1] [2 3]

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

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

>>> X = np.array([[0., 0.], [1., 1.], [-1., -1.], [2., 2.]])
>>> y = np.array([0, 1, 0, 1])
>>> X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]

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

RepeatedKFold выполняет KFold \(n\) раз, создавая разные разбиения при каждом повторе.

Пример двукратной K-блочной перекрёстной проверки с двумя повторами:

>>> import numpy as np
>>> from sklearn.model_selection import RepeatedKFold
>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
>>> random_state = 12883823
>>> rkf = RepeatedKFold(n_splits=2, n_repeats=2, random_state=random_state)
>>> for train, test in rkf.split(X):
...     print("%s %s" % (train, test))
...
[2 3] [0 1]
[0 1] [2 3]
[0 2] [1 3]
[1 3] [0 2]

Аналогично, RepeatedStratifiedKFold выполняет StratifiedKFold \(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-блочная перекрёстная проверка

GroupKFold — это вариант K-блочной перекрёстной проверки, который гарантирует, что одна и та же группа не попадёт одновременно в тестовую и обучающую выборки. Например, если данные получены от разных испытуемых, у каждого из которых имеется несколько выборок, гибкая модель может обучиться на особенностях, характерных только для конкретных людей, и не обобщать результат на новых испытуемых. 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, образуют полное разбиение всех данных.

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

3.1.2.4.2. Стратифицированная групповая K-блочная перекрёстная проверка

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\).

Пример исключения двух групп:

>>> 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-блочной перекрёстной проверки, который возвращает первые \(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]

Ниже показано, как выполняется перекрёстная проверка.