Поиск по сайту:

Как настроить перекрестную проверку k-fold

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

Обычное значение для k — 10, но как узнать, подходит ли эта конфигурация для нашего набора данных и наших алгоритмов?

Один из подходов — изучить влияние различных значений k на оценку производительности модели и сравнить ее с идеальными условиями тестирования. Это может помочь выбрать подходящее значение для k.

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

В этом руководстве вы узнаете, как настроить и оценить конфигурации k-кратной перекрестной проверки.

После завершения этого урока вы будете знать:

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

Начните свой проект с моей новой книги «Освоение машинного обучения с помощью Python», включающей пошаговые руководства и файлы исходного кода Python для все примеры.

Давайте начнем.

Обзор руководства

Этот урок разделен на три части; они есть:

  1. k-кратная перекрестная проверка
  2. Анализ чувствительности для k
  3. Корреляция тестового оборудования с целью

k-кратная перекрестная проверка

Обычно модели машинного обучения оцениваются в наборе данных с использованием k-кратной перекрестной проверки.

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

Дополнительную информацию о процедуре перекрестной проверки в k-кратном размере см. в руководстве:

  • Нежное введение в k-кратную перекрестную проверку

Процедуру k-кратной перекрестной проверки можно легко реализовать с помощью библиотеки машинного обучения scikit-learn.

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

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

В приведенном ниже примере создается и суммируется набор данных.

# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=100, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# summarize the dataset
print(X.shape, y.shape)

При выполнении примера создается набор данных и подтверждается, что он содержит 100 выборок и 10 входных переменных.

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

(100, 20) (100,)

Затем мы можем оценить модель на этом наборе данных, используя k-кратную перекрестную проверку.

Мы оценим модель логистической регрессии и воспользуемся классом KFold для выполнения перекрестной проверки, настроенной на перетасовку набора данных и установившей k=10, популярное значение по умолчанию.

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

Полный пример приведен ниже.

# evaluate a logistic regression model using k-fold cross-validation
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
# create dataset
X, y = make_classification(n_samples=100, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# prepare the cross-validation procedure
cv = KFold(n_splits=10, random_state=1, shuffle=True)
# create model
model = LogisticRegression()
# evaluate model
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

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

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

В этом случае мы видим, что модель достигла расчетной точности классификации около 85,0 процента.

Accuracy: 0.850 (0.128)

Теперь, когда мы знакомы с перекрестной проверкой в k-кратном размере, давайте посмотрим, как мы можем настроить эту процедуру.

Анализ чувствительности для k

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

Распространенными значениями являются k=3, k=5 и k=10, и на сегодняшний день самым популярным значением, используемым в прикладном машинном обучении для оценки моделей, является k=10. Причина этого в том, что были проведены исследования, и было обнаружено, что k=10 обеспечивает хороший компромисс между низкими вычислительными затратами и низкой погрешностью в оценке производительности модели.

Как узнать, какое значение k использовать при оценке моделей на нашем собственном наборе данных?

Вы можете выбрать k=10, но откуда вам знать, что это имеет смысл для вашего набора данных?

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

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

Но шумно по сравнению с чем?

Мы не знаем истинную производительность модели при прогнозировании новых/невидимых данных, поскольку у нас нет доступа к новым/невидимым данным. Если бы мы это сделали, мы бы использовали это при оценке модели.

Тем не менее, мы можем выбрать условия тестирования, которые представляют собой «идеальную» или «идеальную» оценку производительности модели, насколько мы можем достичь.

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

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

Вместо этого мы можем смоделировать этот случай, используя перекрестную проверку с исключением одного (LOOCV), вычислительно затратную версию перекрестной проверки, где k=N и N — общее количество примеров в наборе обучающих данных. То есть каждой выборке в обучающем наборе предоставляется пример, который можно использовать отдельно в качестве набора данных для оценки теста. Он редко используется для больших наборов данных, поскольку требует больших вычислительных затрат, хотя может обеспечить хорошую оценку производительности модели с учетом имеющихся данных.

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

Давайте рассмотрим, как реализовать анализ чувствительности k-кратной перекрестной проверки.

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

# create the dataset
def get_dataset(n_samples=100):
	X, y = make_classification(n_samples=n_samples, n_features=20, n_informative=15, n_redundant=5, random_state=1)
	return X, y

Далее мы можем определить набор данных для создания модели для оценки.

Опять же, такое разделение позволяет при желании изменить модель на свою.

# retrieve the model to be evaluate
def get_model():
	model = LogisticRegression()
	return model

Затем вы можете определить функцию для оценки модели в наборе данных с учетом условия тестирования. Тестовым условием может быть экземпляр KFold, настроенный с заданным значением k, или экземпляр LeaveOneOut, который представляет наше идеальное тестовое условие.

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

# evaluate the model using a given test condition
def evaluate_model(cv):
	# get the dataset
	X, y = get_dataset()
	# get the model
	model = get_model()
	# evaluate the model
	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
	# return scores
	return mean(scores), scores.min(), scores.max()

Далее мы можем рассчитать производительность модели, используя процедуру LOOCV.

...
# calculate the ideal test condition
ideal, _, _ = evaluate_model(LeaveOneOut())
print('Ideal: %.3f' % ideal)

Затем мы можем определить значения k для оценки. В этом случае мы будем проверять значения от 2 до 30.

...
# define folds to test
folds = range(2,31)

Затем мы можем поочередно оценить каждое значение и сохранить результаты по ходу дела.

...
# record mean and min/max of each set of results
means, mins, maxs = list(),list(),list()
# evaluate each k value
for k in folds:
	# define the test condition
	cv = KFold(n_splits=k, shuffle=True, random_state=1)
	# evaluate k value
	k_mean, k_min, k_max = evaluate_model(cv)
	# report performance
	print('> folds=%d, accuracy=%.3f (%.3f,%.3f)' % (k, k_mean, k_min, k_max))
	# store mean accuracy
	means.append(k_mean)
	# store min and max relative to the mean
	mins.append(k_mean - k_min)
	maxs.append(k_max - k_mean)

Наконец, мы можем построить результаты для интерпретации.

...
# line plot of k mean values with min/max error bars
pyplot.errorbar(folds, means, yerr=[mins, maxs], fmt='o')
# plot the ideal case in a separate color
pyplot.plot(folds, [ideal for _ in range(len(folds))], color='r')
# show the plot
pyplot.show()

Полный пример приведен ниже.

# sensitivity analysis of k in k-fold cross-validation
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from matplotlib import pyplot

# create the dataset
def get_dataset(n_samples=100):
	X, y = make_classification(n_samples=n_samples, n_features=20, n_informative=15, n_redundant=5, random_state=1)
	return X, y

# retrieve the model to be evaluate
def get_model():
	model = LogisticRegression()
	return model

# evaluate the model using a given test condition
def evaluate_model(cv):
	# get the dataset
	X, y = get_dataset()
	# get the model
	model = get_model()
	# evaluate the model
	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
	# return scores
	return mean(scores), scores.min(), scores.max()

# calculate the ideal test condition
ideal, _, _ = evaluate_model(LeaveOneOut())
print('Ideal: %.3f' % ideal)
# define folds to test
folds = range(2,31)
# record mean and min/max of each set of results
means, mins, maxs = list(),list(),list()
# evaluate each k value
for k in folds:
	# define the test condition
	cv = KFold(n_splits=k, shuffle=True, random_state=1)
	# evaluate k value
	k_mean, k_min, k_max = evaluate_model(cv)
	# report performance
	print('> folds=%d, accuracy=%.3f (%.3f,%.3f)' % (k, k_mean, k_min, k_max))
	# store mean accuracy
	means.append(k_mean)
	# store min and max relative to the mean
	mins.append(k_mean - k_min)
	maxs.append(k_max - k_mean)
# line plot of k mean values with min/max error bars
pyplot.errorbar(folds, means, yerr=[mins, maxs], fmt='o')
# plot the ideal case in a separate color
pyplot.plot(folds, [ideal for _ in range(len(folds))], color='r')
# show the plot
pyplot.show()

При выполнении примера сначала выводится значение LOOCV, затем средняя, минимальная и максимальная точность для каждого оцененного значения k.

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

В этом случае мы видим, что результат LOOCV составил около 84 процентов, что немного ниже, чем результат k=10, равный 85 процентам.

Ideal: 0.840
> folds=2, accuracy=0.740 (0.700,0.780)
> folds=3, accuracy=0.749 (0.697,0.824)
> folds=4, accuracy=0.790 (0.640,0.920)
> folds=5, accuracy=0.810 (0.600,0.950)
> folds=6, accuracy=0.820 (0.688,0.941)
> folds=7, accuracy=0.799 (0.571,1.000)
> folds=8, accuracy=0.811 (0.385,0.923)
> folds=9, accuracy=0.829 (0.636,1.000)
> folds=10, accuracy=0.850 (0.600,1.000)
> folds=11, accuracy=0.829 (0.667,1.000)
> folds=12, accuracy=0.785 (0.250,1.000)
> folds=13, accuracy=0.839 (0.571,1.000)
> folds=14, accuracy=0.807 (0.429,1.000)
> folds=15, accuracy=0.821 (0.571,1.000)
> folds=16, accuracy=0.827 (0.500,1.000)
> folds=17, accuracy=0.816 (0.600,1.000)
> folds=18, accuracy=0.831 (0.600,1.000)
> folds=19, accuracy=0.826 (0.600,1.000)
> folds=20, accuracy=0.830 (0.600,1.000)
> folds=21, accuracy=0.814 (0.500,1.000)
> folds=22, accuracy=0.820 (0.500,1.000)
> folds=23, accuracy=0.802 (0.250,1.000)
> folds=24, accuracy=0.804 (0.250,1.000)
> folds=25, accuracy=0.810 (0.250,1.000)
> folds=26, accuracy=0.804 (0.250,1.000)
> folds=27, accuracy=0.818 (0.250,1.000)
> folds=28, accuracy=0.821 (0.250,1.000)
> folds=29, accuracy=0.822 (0.250,1.000)
> folds=30, accuracy=0.822 (0.333,1.000)

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

Результаты показывают, что для этой модели в этом наборе данных большинство значений k занижают производительность модели по сравнению с идеальным случаем. Результаты показывают, что, возможно, само по себе значение k=10 является несколько оптимистичным и, возможно, k=13 может быть более точной оценкой.

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

Корреляция тестового оборудования с целью

После выбора тестового оборудования возникает еще один вопрос: насколько хорошо оно соответствует идеальным условиям тестирования для различных алгоритмов.

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

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

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

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

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

# get a list of models to evaluate
def get_models():
	models = list()
	models.append(LogisticRegression())
	models.append(RidgeClassifier())
	models.append(SGDClassifier())
	models.append(PassiveAggressiveClassifier())
	models.append(KNeighborsClassifier())
	models.append(DecisionTreeClassifier())
	models.append(ExtraTreeClassifier())
	models.append(LinearSVC())
	models.append(SVC())
	models.append(GaussianNB())
	models.append(AdaBoostClassifier())
	models.append(BaggingClassifier())
	models.append(RandomForestClassifier())
	models.append(ExtraTreesClassifier())
	models.append(GaussianProcessClassifier())
	models.append(GradientBoostingClassifier())
	models.append(LinearDiscriminantAnalysis())
	models.append(QuadraticDiscriminantAnalysis())
	return models

Мы будем использовать k=10 для выбранного тестового жгута.

Затем мы можем перечислить каждую модель и оценить ее, используя 10-кратную перекрестную проверку и наши идеальные условия тестирования, в данном случае LOOCV.

...
# define test conditions
ideal_cv = LeaveOneOut()
cv = KFold(n_splits=10, shuffle=True, random_state=1)
# get the list of models to consider
models = get_models()
# collect results
ideal_results, cv_results = list(), list()
# evaluate each model
for model in models:
	# evaluate model using each test condition
	cv_mean = evaluate_model(cv, model)
	ideal_mean = evaluate_model(ideal_cv, model)
	# check for invalid results
	if isnan(cv_mean) or isnan(ideal_mean):
		continue
	# store results
	cv_results.append(cv_mean)
	ideal_results.append(ideal_mean)
	# summarize progress
	print('>%s: ideal=%.3f, cv=%.3f' % (type(model).__name__, ideal_mean, cv_mean))

Затем мы можем рассчитать корреляцию между средней точностью классификации на основе набора тестов 10-кратной перекрестной проверки и набора тестов LOOCV.

...
# calculate the correlation between each test condition
corr, _ = pearsonr(cv_results, ideal_results)
print('Correlation: %.3f' % corr)

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

...
# scatter plot of results
pyplot.scatter(cv_results, ideal_results)
# plot the line of best fit
coeff, bias = polyfit(cv_results, ideal_results, 1)
line = coeff * asarray(cv_results) + bias
pyplot.plot(cv_results, line, color='r')
# show the plot
pyplot.show()

Полный пример приведен ниже.

# correlation between test harness and ideal test condition
from numpy import mean
from numpy import isnan
from numpy import asarray
from numpy import polyfit
from scipy.stats import pearsonr
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.model_selection import KFold
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import RidgeClassifier
from sklearn.linear_model import SGDClassifier
from sklearn.linear_model import PassiveAggressiveClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import ExtraTreeClassifier
from sklearn.svm import LinearSVC
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis

# create the dataset
def get_dataset(n_samples=100):
	X, y = make_classification(n_samples=n_samples, n_features=20, n_informative=15, n_redundant=5, random_state=1)
	return X, y

# get a list of models to evaluate
def get_models():
	models = list()
	models.append(LogisticRegression())
	models.append(RidgeClassifier())
	models.append(SGDClassifier())
	models.append(PassiveAggressiveClassifier())
	models.append(KNeighborsClassifier())
	models.append(DecisionTreeClassifier())
	models.append(ExtraTreeClassifier())
	models.append(LinearSVC())
	models.append(SVC())
	models.append(GaussianNB())
	models.append(AdaBoostClassifier())
	models.append(BaggingClassifier())
	models.append(RandomForestClassifier())
	models.append(ExtraTreesClassifier())
	models.append(GaussianProcessClassifier())
	models.append(GradientBoostingClassifier())
	models.append(LinearDiscriminantAnalysis())
	models.append(QuadraticDiscriminantAnalysis())
	return models

# evaluate the model using a given test condition
def evaluate_model(cv, model):
	# get the dataset
	X, y = get_dataset()
	# evaluate the model
	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
	# return scores
	return mean(scores)

# define test conditions
ideal_cv = LeaveOneOut()
cv = KFold(n_splits=10, shuffle=True, random_state=1)
# get the list of models to consider
models = get_models()
# collect results
ideal_results, cv_results = list(), list()
# evaluate each model
for model in models:
	# evaluate model using each test condition
	cv_mean = evaluate_model(cv, model)
	ideal_mean = evaluate_model(ideal_cv, model)
	# check for invalid results
	if isnan(cv_mean) or isnan(ideal_mean):
		continue
	# store results
	cv_results.append(cv_mean)
	ideal_results.append(ideal_mean)
	# summarize progress
	print('>%s: ideal=%.3f, cv=%.3f' % (type(model).__name__, ideal_mean, cv_mean))
# calculate the correlation between each test condition
corr, _ = pearsonr(cv_results, ideal_results)
print('Correlation: %.3f' % corr)
# scatter plot of results
pyplot.scatter(cv_results, ideal_results)
# plot the line of best fit
coeff, bias = polyfit(cv_results, ideal_results, 1)
line = coeff * asarray(cv_results) + bias
pyplot.plot(cv_results, line, color='r')
# label the plot
pyplot.title('10-fold CV vs LOOCV Mean Accuracy')
pyplot.xlabel('Mean Accuracy (10-fold CV)')
pyplot.ylabel('Mean Accuracy (LOOCV)')
# show the plot
pyplot.show()

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

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

Вы можете увидеть некоторые предупреждения, которые можно спокойно игнорировать, например:

Variables are collinear

Мы видим, что для некоторых алгоритмов тестовая программа завышает точность по сравнению с LOOCV, а в других случаях занижает точность. Этого следовало ожидать.

В конце прогона мы видим, что сообщается о корреляции между двумя наборами результатов. В этом случае мы видим, что сообщается о корреляции 0,746, что является хорошей сильной положительной корреляцией. Результаты показывают, что 10-кратная перекрестная проверка действительно обеспечивает хорошее приближение для тестового набора LOOCV в этом наборе данных, рассчитанного с использованием 18 популярных алгоритмов машинного обучения.

>LogisticRegression: ideal=0.840, cv=0.850
>RidgeClassifier: ideal=0.830, cv=0.830
>SGDClassifier: ideal=0.730, cv=0.790
>PassiveAggressiveClassifier: ideal=0.780, cv=0.760
>KNeighborsClassifier: ideal=0.760, cv=0.770
>DecisionTreeClassifier: ideal=0.690, cv=0.630
>ExtraTreeClassifier: ideal=0.710, cv=0.620
>LinearSVC: ideal=0.850, cv=0.830
>SVC: ideal=0.900, cv=0.880
>GaussianNB: ideal=0.730, cv=0.720
>AdaBoostClassifier: ideal=0.740, cv=0.740
>BaggingClassifier: ideal=0.770, cv=0.740
>RandomForestClassifier: ideal=0.810, cv=0.790
>ExtraTreesClassifier: ideal=0.820, cv=0.820
>GaussianProcessClassifier: ideal=0.790, cv=0.760
>GradientBoostingClassifier: ideal=0.820, cv=0.820
>LinearDiscriminantAnalysis: ideal=0.830, cv=0.830
>QuadraticDiscriminantAnalysis: ideal=0.610, cv=0.760
Correlation: 0.746

Наконец, создается диаграмма рассеяния, сравнивающая распределение средних показателей точности для тестового оборудования (ось X) с показателями точности с помощью LOOCV (ось Y).

Красная линия наилучшего соответствия проведена через результаты, показывающие сильную линейную корреляцию.

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

Дальнейшее чтение

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

Учебники

  • Нежное введение в k-кратную перекрестную проверку
  • Как исправить перекрестную проверку k-крата для несбалансированной классификации

API

  • sklearn.model_selection.KFold API.
  • sklearn.model_selection.LeaveOneOut API.
  • sklearn.model_selection.cross_val_score API.

Статьи

  • Перекрестная проверка (статистика), Википедия.

Краткое содержание

В этом руководстве вы узнали, как настроить и оценить конфигурации k-кратной перекрестной проверки.

В частности, вы узнали:

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

У вас есть вопросы?
Задавайте свои вопросы в комментариях ниже, и я постараюсь ответить.