Comment diviser une partition/un jeu de données dans la formation et l'essai des ensembles de données pour, par exemple, de la croix de validation?

Si vous voulez diviser l'ensemble de données une fois en deux moitiés, vous pouvez utiliser numpy.random.shuffle, ou numpy.random.permutation si vous avez besoin de garder une trace des indices:

import numpy
# x is your dataset
x = numpy.random.rand(100, 5)
numpy.random.shuffle(x)
training, test = x[:80,:], x[80:,:]

ou

import numpy
# x is your dataset
x = numpy.random.rand(100, 5)
indices = numpy.random.permutation(x.shape[0])
training_idx, test_idx = indices[:80], indices[80:]
training, test = x[training_idx,:], x[test_idx,:]

Il existe de nombreuses façons de à plusieurs reprises partition le même ensemble de données pour la validation croisée. Une stratégie consiste à rééchantillonner à partir de l'ensemble de données, avec la répétition:

import numpy
# x is your dataset
x = numpy.random.rand(100, 5)
training_idx = numpy.random.randint(x.shape[0], size=80)
test_idx = numpy.random.randint(x.shape[0], size=20)
training, test = x[training_idx,:], x[test_idx,:]

Enfin, sklearn contient plusieurs méthodes de validation (k-fold, laissez-n-out, ...). Il inclut également plus avancé "l'échantillonnage stratifié" méthodes que de créer une partition de données qui est en équilibre avec le respect de certaines fonctionnalités, par exemple pour s'assurer qu'il y a la même proportion d'exemples positifs et négatifs dans la formation et l'ensemble de test.

Juste une remarque. Dans le cas où vous souhaitez former, de test ET de validation des ensembles, vous pouvez le faire:

from sklearn.cross_validation import train_test_split

X = get_my_X()
y = get_my_y()
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
x_test, x_val, y_test, y_val = train_test_split(x_test, y_test, test_size=0.5)

Ces paramètres vont donner à 70 % à la formation, et de 15 % pour chacun de tester et de val-ensembles. Espérons que cette aide.

Vous pouvez également envisager de stratifié de la division de la formation et de jeu de test. Startified division génère également de la formation et de jeu de test au hasard, mais de telle manière que la classe d'origine proportions sont conservées. Ce qui rend la formation et l'essai des ensembles de mieux refléter les propriétés du jeu de données d'origine.

import numpy as np  

def get_train_test_inds(y,train_proportion=0.7):
    '''Generates indices, making random stratified split into training set and testing sets
    with proportions train_proportion and (1-train_proportion) of initial sample.
    y is any iterable indicating classes of each observation in the sample.
    Initial proportions of classes inside training and 
    testing sets are preserved (stratified sampling).
    '''

    y=np.array(y)
    train_inds = np.zeros(len(y),dtype=bool)
    test_inds = np.zeros(len(y),dtype=bool)
    values = np.unique(y)
    for value in values:
        value_inds = np.nonzero(y==value)[0]
        np.random.shuffle(value_inds)
        n = int(train_proportion*len(value_inds))

        train_inds[value_inds[:n]]=True
        test_inds[value_inds[n:]]=True

    return train_inds,test_inds

y = np.array([1,1,2,2,3,3])
train_inds,test_inds = get_train_test_inds(y,train_proportion=0.5)
print y[train_inds]
print y[test_inds]

Ce code affiche:

[1 2 3]
[1 2 3]

Voici un code pour diviser les données en n=5 plis dans un stratifié de manière

% X = data array
% y = Class_label
from sklearn.cross_validation import StratifiedKFold
skf = StratifiedKFold(y, n_folds=5)
for train_index, test_index in skf:
    print("TRAIN:", train_index, "TEST:", test_index)
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]

Après avoir fait un peu de lecture, et en prenant en compte les nombreux (..) les différentes façons de diviser les données pour l'apprentissage et le test, j'ai décidé de timeit!

J'ai utilisé 4 méthodes différentes (non d'entre eux sont à l'aide de la bibliothèque sklearn, qui je suis sûre ne donnera les meilleurs résultats, en donnant qu'il est bien conçu et testé le code):

1. lecture aléatoire de l'ensemble de la matrice arr puis diviser les données pour l'apprentissage et le test
2. mélangez les indices, puis l'assigner en x et y pour fractionner les données
3. même que la méthode 2, mais d'une façon plus efficace de le faire
4. à l'aide de pandas dataframe de diviser

méthode 3 gagné de loin, avec le temps le plus court, après que la méthode 1 et la méthode 2 et 4 découvert pour être vraiment inefficace.

Le code pour les 4 méthodes différentes, j'ai chronométré:

import numpy as np
arr = np.random.rand(100, 3)
X = arr[:,:2]
Y = arr[:,2]
spl = 0.7
N = len(arr)
sample = int(spl*N)

#%% Method 1:  shuffle the whole matrix arr and then split
np.random.shuffle(arr)
x_train, x_test, y_train, y_test = X[:sample,:], X[sample:, :], Y[:sample, ], Y[sample:,]

#%% Method 2: shuffle the indecies and then shuffle and apply to X and Y
train_idx = np.random.choice(N, sample)
Xtrain = X[train_idx]
Ytrain = Y[train_idx]

test_idx = [idx for idx in range(N) if idx not in train_idx]
Xtest = X[test_idx]
Ytest = Y[test_idx]

#%% Method 3: shuffle indicies without a for loop
idx = np.random.permutation(arr.shape[0])  # can also use random.shuffle
train_idx, test_idx = idx[:sample], idx[sample:]
x_train, x_test, y_train, y_test = X[train_idx,:], X[test_idx,:], Y[train_idx,], Y[test_idx,]

#%% Method 4: using pandas dataframe to split
import pandas as pd
df = pd.read_csv(file_path, header=None) # Some csv file (I used some file with 3 columns)

train = df.sample(frac=0.7, random_state=200)
test = df.drop(train.index)

Et pour le temps, le temps minimum d'exécution de 3 répétitions de 1000 boucles est:

• Méthode 1: 0.35883826200006297 secondes
• Méthode 2: 1.7157016959999964 secondes
• Méthode 3: 1.7876616719995582 secondes
• Méthode 4: 0.07562861499991413 secondes

J'espère que c'est utile!