Como dividir dados em 3 conjuntos (treinamento, validação e teste)?

Eu tenho um dataframe de pandas e desejo dividi-lo em 3 conjuntos separados. Eu sei que usando train_test_split de sklearn.cross_validation, é possível dividir os dados em dois conjuntos (train e test). No entanto, não consegui encontrar nenhuma solução para dividir os dados em três conjuntos. De preferência, eu gostaria de ter os índices dos dados originais.

Eu sei que uma solução alternativa seria usar train_test_splitduas vezes e de alguma forma ajustar os índices. Mas existe uma maneira mais padrão / interna de dividir os dados em 3 conjuntos em vez de 2?

Solução Numpy. Vamos embaralhar o conjunto de dados inteiro primeiro (df.sample (frac = 1)) e depois dividimos nosso conjunto de dados nas seguintes partes:

• 60% - conjunto de trem,
• 20% - conjunto de validação,
• 20% - conjunto de teste

In [305]: train, validate, test = np.split(df.sample(frac=1), [int(.6*len(df)), int(.8*len(df))])

In [306]: train
Out[306]:
          A         B         C         D         E
0  0.046919  0.792216  0.206294  0.440346  0.038960
2  0.301010  0.625697  0.604724  0.936968  0.870064
1  0.642237  0.690403  0.813658  0.525379  0.396053
9  0.488484  0.389640  0.599637  0.122919  0.106505
8  0.842717  0.793315  0.554084  0.100361  0.367465
7  0.185214  0.603661  0.217677  0.281780  0.938540

In [307]: validate
Out[307]:
          A         B         C         D         E
5  0.806176  0.008896  0.362878  0.058903  0.026328
6  0.145777  0.485765  0.589272  0.806329  0.703479

In [308]: test
Out[308]:
          A         B         C         D         E
4  0.521640  0.332210  0.370177  0.859169  0.401087
3  0.333348  0.964011  0.083498  0.670386  0.169619

[int(.6*len(df)), int(.8*len(df))]- é uma indices_or_sectionsmatriz para numpy.split () .

Aqui está uma pequena demonstração para np.split()uso - vamos dividir a matriz de 20 elementos nas seguintes partes: 80%, 10%, 10%:

In [45]: a = np.arange(1, 21)

In [46]: a
Out[46]: array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])

In [47]: np.split(a, [int(.8 * len(a)), int(.9 * len(a))])
Out[47]:
[array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16]),
 array([17, 18]),
 array([19, 20])]

Nota:

A função foi escrita para lidar com a propagação da criação de conjuntos aleatórios. Você não deve confiar na divisão de conjuntos que não os randomiza.

import numpy as np
import pandas as pd

def train_validate_test_split(df, train_percent=.6, validate_percent=.2, seed=None):
    np.random.seed(seed)
    perm = np.random.permutation(df.index)
    m = len(df.index)
    train_end = int(train_percent * m)
    validate_end = int(validate_percent * m) + train_end
    train = df.iloc[perm[:train_end]]
    validate = df.iloc[perm[train_end:validate_end]]
    test = df.iloc[perm[validate_end:]]
    return train, validate, test

Demonstração

np.random.seed([3,1415])
df = pd.DataFrame(np.random.rand(10, 5), columns=list('ABCDE'))
df

train, validate, test = train_validate_test_split(df)

train

validate

test

No entanto, uma abordagem para dividir o conjunto de dados em train, test, cvcom 0.6, 0.2, 0.2seria usar o train_test_splitmétodo duas vezes.

from sklearn.model_selection import train_test_split

x, x_test, y, y_test = train_test_split(xtrain,labels,test_size=0.2,train_size=0.8)
x_train, x_cv, y_train, y_cv = train_test_split(x,y,test_size = 0.25,train_size =0.75)

Aqui está uma função Python que divide um quadro de dados do Pandas em quadros de dados de treinamento, validação e teste com amostragem estratificada. Ele realiza essa divisão chamando a função scikit-learn train_test_split()duas vezes.

import pandas as pd
from sklearn.model_selection import train_test_split

def split_stratified_into_train_val_test(df_input, stratify_colname='y',
                                         frac_train=0.6, frac_val=0.15, frac_test=0.25,
                                         random_state=None):
    '''
    Splits a Pandas dataframe into three subsets (train, val, and test)
    following fractional ratios provided by the user, where each subset is
    stratified by the values in a specific column (that is, each subset has
    the same relative frequency of the values in the column). It performs this
    splitting by running train_test_split() twice.

    Parameters
    ----------
    df_input : Pandas dataframe
        Input dataframe to be split.
    stratify_colname : str
        The name of the column that will be used for stratification. Usually
        this column would be for the label.
    frac_train : float
    frac_val   : float
    frac_test  : float
        The ratios with which the dataframe will be split into train, val, and
        test data. The values should be expressed as float fractions and should
        sum to 1.0.
    random_state : int, None, or RandomStateInstance
        Value to be passed to train_test_split().

    Returns
    -------
    df_train, df_val, df_test :
        Dataframes containing the three splits.
    '''

    if frac_train + frac_val + frac_test != 1.0:
        raise ValueError('fractions %f, %f, %f do not add up to 1.0' % \
                         (frac_train, frac_val, frac_test))

    if stratify_colname not in df_input.columns:
        raise ValueError('%s is not a column in the dataframe' % (stratify_colname))

    X = df_input # Contains all columns.
    y = df_input[[stratify_colname]] # Dataframe of just the column on which to stratify.

    # Split original dataframe into train and temp dataframes.
    df_train, df_temp, y_train, y_temp = train_test_split(X,
                                                          y,
                                                          stratify=y,
                                                          test_size=(1.0 - frac_train),
                                                          random_state=random_state)

    # Split the temp dataframe into val and test dataframes.
    relative_frac_test = frac_test / (frac_val + frac_test)
    df_val, df_test, y_val, y_test = train_test_split(df_temp,
                                                      y_temp,
                                                      stratify=y_temp,
                                                      test_size=relative_frac_test,
                                                      random_state=random_state)

    assert len(df_input) == len(df_train) + len(df_val) + len(df_test)

    return df_train, df_val, df_test

Abaixo está um exemplo completo de trabalho.

Considere um conjunto de dados com um rótulo no qual você deseja executar a estratificação. Esse rótulo tem sua própria distribuição no conjunto de dados original, digamos 75% foo, 15% bare 10% baz. Agora vamos dividir o conjunto de dados em treinamento, validação e teste em subconjuntos usando uma proporção 60/20/20, em que cada divisão retém a mesma distribuição dos rótulos. Veja a ilustração abaixo:

Aqui está o exemplo do conjunto de dados:

df = pd.DataFrame( { 'A': list(range(0, 100)),
                     'B': list(range(100, 0, -1)),
                     'label': ['foo'] * 75 + ['bar'] * 15 + ['baz'] * 10 } )

df.head()
#    A    B label
# 0  0  100   foo
# 1  1   99   foo
# 2  2   98   foo
# 3  3   97   foo
# 4  4   96   foo

df.shape
# (100, 3)

df.label.value_counts()
# foo    75
# bar    15
# baz    10
# Name: label, dtype: int64

Agora, vamos chamar a split_stratified_into_train_val_test()função de cima para obter quadros de dados de trem, validação e teste seguindo uma proporção de 60/20/20.

df_train, df_val, df_test = \
    split_stratified_into_train_val_test(df, stratify_colname='label', frac_train=0.60, frac_val=0.20, frac_test=0.20)

Os três dataframes df_train, df_vale df_testconter todas as linhas originais, mas seus tamanhos seguirá a relação acima.

df_train.shape
#(60, 3)

df_val.shape
#(20, 3)

df_test.shape
#(20, 3)

Além disso, cada uma das três divisões terá a mesma distribuição do rótulo, ou seja, 75% foo, 15% bare 10% baz.

df_train.label.value_counts()
# foo    45
# bar     9
# baz     6
# Name: label, dtype: int64

df_val.label.value_counts()
# foo    15
# bar     3
# baz     2
# Name: label, dtype: int64

df_test.label.value_counts()
# foo    15
# bar     3
# baz     2
# Name: label, dtype: int64

É muito conveniente usar train_test_splitsem executar a reindexação após dividir em vários conjuntos e sem escrever algum código adicional. A melhor resposta acima não menciona que, ao separar duas vezes, train_test_splitsem alterar os tamanhos das partições, você não fornecerá a partição pretendida inicialmente:

x_train, x_remain = train_test_split(x, test_size=(val_size + test_size))

Em seguida, a parte dos conjuntos de validação e teste no x_remain muda e pode ser contada como

new_test_size = np.around(test_size / (val_size + test_size), 2)
# To preserve (new_test_size + new_val_size) = 1.0 
new_val_size = 1.0 - new_test_size

x_val, x_test = train_test_split(x_remain, test_size=new_test_size)

Nesta ocasião, todas as partições iniciais são salvas.