由于神经网络的运行时间很长,似乎没有认真对待网络中的k折交叉验证。我有一个小数据集,我有兴趣使用给定here的示例进行k折交叉验证。可能吗?感谢。
答案 0 :(得分:3)
如果您正在使用带有数据生成器的图像,这里是使用Keras和scikit-learn进行10倍交叉验证的一种方法。策略是根据每个折叠将文件复制到training
,validation
和test
子文件夹。
import numpy as np
import os
import pandas as pd
import shutil
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# used to copy files according to each fold
def copy_images(df, directory):
destination_directory = "{path to your data directory}/" + directory
print("copying {} files to {}...".format(directory, destination_directory))
# remove all files from previous fold
if os.path.exists(destination_directory):
shutil.rmtree(destination_directory)
# create folder for files from this fold
if not os.path.exists(destination_directory):
os.makedirs(destination_directory)
# create subfolders for each class
for c in set(list(df['class'])):
if not os.path.exists(destination_directory + '/' + c):
os.makedirs(destination_directory + '/' + c)
# copy files for this fold from a directory holding all the files
for i, row in df.iterrows():
try:
# this is the path to all of your images kept together in a separate folder
path_from = "{path to all of your images}"
path_from = path_from + "{}.jpg"
path_to = "{}/{}".format(destination_directory, row['class'])
# move from folder keeping all files to training, test, or validation folder (the "directory" argument)
shutil.copy(path_from.format(row['filename']), path_to)
except Exception, e:
print("Error when copying {}: {}".format(row['filename'], str(e)))
# dataframe containing the filenames of the images (e.g., GUID filenames) and the classes
df = pd.read_csv('{path to your data}.csv')
df_y = df['class']
df_x = df
del df_x['class']
skf = StratifiedKFold(n_splits = 10)
total_actual = []
total_predicted = []
total_val_accuracy = []
total_val_loss = []
total_test_accuracy = []
for i, (train_index, test_index) in enumerate(skf.split(df_x, df_y)):
x_train, x_test = df_x.iloc[train_index], df_x.iloc[test_index]
y_train, y_test = df_y.iloc[train_index], df_y.iloc[test_index]
train = pd.concat([x_train, y_train], axis=1)
test = pd.concat([x_test, y_test], axis = 1)
# take 20% of the training data from this fold for validation during training
validation = train.sample(frac = 0.2)
# make sure validation data does not include training data
train = train[~train['filename'].isin(list(validation['filename']))]
# copy the images according to the fold
copy_images(train, 'training')
copy_images(validation, 'validation')
copy_images(test, 'test')
print('**** Running fold '+ str(i))
# here you call a function to create and train your model, returning validation accuracy and validation loss
val_accuracy, val_loss = create_train_model();
# append validation accuracy and loss for average calculation later on
total_val_accuracy.append(val_accuracy)
total_val_loss.append(val_loss)
# here you will call a predict() method that will predict the images on the "test" subfolder
# this function returns the actual classes and the predicted classes in the same order
actual, predicted = predict()
# append accuracy from the predictions on the test data
total_test_accuracy.append(accuracy_score(actual, predicted))
# append all of the actual and predicted classes for your final evaluation
total_actual = total_actual + actual
total_predicted = total_predicted + predicted
# this is optional, but you can also see the performance on each fold as the process goes on
print(classification_report(total_actual, total_predicted))
print(confusion_matrix(total_actual, total_predicted))
print(classification_report(total_actual, total_predicted))
print(confusion_matrix(total_actual, total_predicted))
print("Validation accuracy on each fold:")
print(total_val_accuracy)
print("Mean validation accuracy: {}%".format(np.mean(total_val_accuracy) * 100))
print("Validation loss on each fold:")
print(total_val_loss)
print("Mean validation loss: {}".format(np.mean(total_val_loss)))
print("Test accuracy on each fold:")
print(total_test_accuracy)
print("Mean test accuracy: {}%".format(np.mean(total_test_accuracy) * 100))
在您的predict()函数中,如果您使用的是数据生成器,那么我在测试时使用batch_size
1
来保持预测的相同顺序的唯一方法是:
generator = ImageDataGenerator().flow_from_directory(
'{path to your data directory}/test',
target_size = (img_width, img_height),
batch_size = 1,
color_mode = 'rgb',
# categorical for a multiclass problem
class_mode = 'categorical',
# this will also ensure the same order
shuffle = False)
使用此代码,我能够使用数据生成器进行10倍交叉验证(因此我不必将所有文件保留在内存中)。如果您有数百万张图片,这可能会很多工作,如果您的测试集很大,batch_size = 1
可能会成为瓶颈,但对于我的项目来说这很有效。