Comment créer des tests et former des échantillons à partir d'une trame de données avec des pandas?

J'ai un ensemble de données assez important sous la forme d'une trame de données et je me demandais comment je pourrais diviser la trame de données en deux échantillons aléatoires (80% et 20%) pour la formation et les tests.

Merci!

Je voudrais juste utiliser numpy randn:

In [11]: df = pd.DataFrame(np.random.randn(100, 2))

In [12]: msk = np.random.rand(len(df)) < 0.8

In [13]: train = df[msk]

In [14]: test = df[~msk]

Et juste pour voir que cela a fonctionné:

In [15]: len(test)
Out[15]: 21

In [16]: len(train)
Out[16]: 79

scikit learn'strain_test_split est une bonne chose.

from sklearn.model_selection import train_test_split

train, test = train_test_split(df, test_size=0.2)

L'échantillon aléatoire des pandas fonctionnera également

train=df.sample(frac=0.8,random_state=200) #random state is a seed value
test=df.drop(train.index)

J'utiliserais le propre training_test_split de scikit-learn et le générerais à partir de l'index

from sklearn.model_selection import train_test_split


y = df.pop('output')
X = df

X_train,X_test,y_train,y_test = train_test_split(X.index,y,test_size=0.2)
X.iloc[X_train] # return dataframe train

Il existe de nombreuses façons de créer un train / test et même des échantillons de validation.

Cas 1: manière classique train_test_splitsans aucune option:

from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.3)

Cas 2: cas d'un très petit ensemble de données (<500 lignes): afin d'obtenir des résultats pour toutes vos lignes avec cette validation croisée. À la fin, vous aurez une prédiction pour chaque ligne de votre ensemble d'entraînement disponible.

from sklearn.model_selection import KFold
kf = KFold(n_splits=10, random_state=0)
y_hat_all = []
for train_index, test_index in kf.split(X, y):
    reg = RandomForestRegressor(n_estimators=50, random_state=0)
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    clf = reg.fit(X_train, y_train)
    y_hat = clf.predict(X_test)
    y_hat_all.append(y_hat)

Cas 3a: ensembles de données non équilibrés à des fins de classification. Après le cas 1, voici la solution équivalente:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.3)

Cas 3b: ensembles de données déséquilibrés à des fins de classification. Après le cas 2, voici la solution équivalente:

from sklearn.model_selection import StratifiedKFold
kf = StratifiedKFold(n_splits=10, random_state=0)
y_hat_all = []
for train_index, test_index in kf.split(X, y):
    reg = RandomForestRegressor(n_estimators=50, random_state=0)
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    clf = reg.fit(X_train, y_train)
    y_hat = clf.predict(X_test)
    y_hat_all.append(y_hat)

Cas 4: vous devez créer un train / test / ensembles de validation sur le Big Data pour régler les hyperparamètres (60% train, 20% test et 20% val).

from sklearn.model_selection import train_test_split
X_train, X_test_val, y_train, y_test_val = train_test_split(X, y, test_size=0.6)
X_test, X_val, y_test, y_val = train_test_split(X_test_val, y_test_val, stratify=y, test_size=0.5)

Vous pouvez utiliser le code ci-dessous pour créer des échantillons de test et de formation:

from sklearn.model_selection import train_test_split
trainingSet, testSet = train_test_split(df, test_size=0.2)

La taille du test peut varier en fonction du pourcentage de données que vous souhaitez mettre dans votre jeu de données de test et de formation.

Il existe de nombreuses réponses valables. Ajouter un de plus au groupe. de sklearn.cross_validation import train_test_split

#gets a random 80% of the entire set
X_train = X.sample(frac=0.8, random_state=1)
#gets the left out portion of the dataset
X_test = X.loc[~df_model.index.isin(X_train.index)]

Vous pouvez également envisager une division stratifiée en ensemble de formation et de test. La division Startified génère également des formations et des tests définis de manière aléatoire mais de telle manière que les proportions de classe d'origine sont préservées. Les ensembles de formation et de test reflètent ainsi mieux les propriétés de l'ensemble 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

df [train_inds] et df [test_inds] vous donnent les ensembles de formation et de test de votre DataFrame df d'origine.

Si vous devez diviser vos données par rapport à la colonne des étiquettes dans votre ensemble de données, vous pouvez utiliser ceci:

def split_to_train_test(df, label_column, train_frac=0.8):
    train_df, test_df = pd.DataFrame(), pd.DataFrame()
    labels = df[label_column].unique()
    for lbl in labels:
        lbl_df = df[df[label_column] == lbl]
        lbl_train_df = lbl_df.sample(frac=train_frac)
        lbl_test_df = lbl_df.drop(lbl_train_df.index)
        print '\n%s:\n---------\ntotal:%d\ntrain_df:%d\ntest_df:%d' % (lbl, len(lbl_df), len(lbl_train_df), len(lbl_test_df))
        train_df = train_df.append(lbl_train_df)
        test_df = test_df.append(lbl_test_df)

    return train_df, test_df

et l'utiliser:

train, test = split_to_train_test(data, 'class', 0.7)

vous pouvez également passer random_state si vous souhaitez contrôler le caractère aléatoire divisé ou utiliser une graine aléatoire globale.

import pandas as pd

from sklearn.model_selection import train_test_split

datafile_name = 'path_to_data_file'

data = pd.read_csv(datafile_name)

target_attribute = data['column_name']

X_train, X_test, y_train, y_test = train_test_split(data, target_attribute, test_size=0.8)

Vous pouvez utiliser ~ (opérateur tilde) pour exclure les lignes échantillonnées à l'aide de df.sample (), laissant les pandas seuls gérer l'échantillonnage et le filtrage des index, pour obtenir deux ensembles.

train_df = df.sample(frac=0.8, random_state=100)
test_df = df[~df.index.isin(train_df.index)]

C'est ce que j'ai écrit lorsque j'avais besoin de diviser un DataFrame. J'ai envisagé d'utiliser l'approche d'Andy ci-dessus, mais je n'aimais pas que je ne puisse pas contrôler exactement la taille des ensembles de données (c'est-à-dire que ce serait parfois 79, parfois 81, etc.).

def make_sets(data_df, test_portion):
    import random as rnd

    tot_ix = range(len(data_df))
    test_ix = sort(rnd.sample(tot_ix, int(test_portion * len(data_df))))
    train_ix = list(set(tot_ix) ^ set(test_ix))

    test_df = data_df.ix[test_ix]
    train_df = data_df.ix[train_ix]

    return train_df, test_df


train_df, test_df = make_sets(data_df, 0.2)
test_df.head()

Sélectionnez simplement la ligne de plage de df comme ceci

row_count = df.shape[0]
split_point = int(row_count*1/5)
test_data, train_data = df[:split_point], df[split_point:]

Il y a beaucoup de bonnes réponses ci-dessus, donc je veux juste ajouter un autre exemple dans le cas où vous souhaitez spécifier le nombre exact d'échantillons pour le train et les ensembles de test en utilisant uniquement la numpybibliothèque.

# set the random seed for the reproducibility
np.random.seed(17)

# e.g. number of samples for the training set is 1000
n_train = 1000

# shuffle the indexes
shuffled_indexes = np.arange(len(data_df))
np.random.shuffle(shuffled_indexes)

# use 'n_train' samples for training and the rest for testing
train_ids = shuffled_indexes[:n_train]
test_ids = shuffled_indexes[n_train:]

train_data = data_df.iloc[train_ids]
train_labels = labels_df.iloc[train_ids]

test_data = data_df.iloc[test_ids]
test_labels = data_df.iloc[test_ids]

Pour diviser en plus de deux classes telles que le train, le test et la validation, on peut faire:

probs = np.random.rand(len(df))
training_mask = probs < 0.7
test_mask = (probs>=0.7) & (probs < 0.85)
validatoin_mask = probs >= 0.85


df_training = df[training_mask]
df_test = df[test_mask]
df_validation = df[validatoin_mask]

Cela mettra environ 70% des données en formation, 15% en test et 15% en validation.

vous devez convertir le cadre de données pandas en tableau numpy, puis reconvertir le tableau numpy en cadre de données

 import pandas as pd
df=pd.read_csv('/content/drive/My Drive/snippet.csv', sep='\t')
from sklearn.model_selection import train_test_split

train, test = train_test_split(df, test_size=0.2)
train1=pd.DataFrame(train)
test1=pd.DataFrame(test)
train1.to_csv('/content/drive/My Drive/train.csv',sep="\t",header=None, encoding='utf-8', index = False)
test1.to_csv('/content/drive/My Drive/test.csv',sep="\t",header=None, encoding='utf-8', index = False)

Si vous souhaitez avoir une trame de données et deux trames de données (pas des tableaux numpy), cela devrait faire l'affaire:

def split_data(df, train_perc = 0.8):

   df['train'] = np.random.rand(len(df)) < train_perc

   train = df[df.train == 1]

   test = df[df.train == 0]

   split_data ={'train': train, 'test': test}

   return split_data

Vous pouvez utiliser la fonction df.as_matrix () et créer un tableau Numpy et le passer.

Y = df.pop()
X = df.as_matrix()
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2)
model.fit(x_train, y_train)
model.test(x_test)

Un peu plus élégant à mon goût est de créer une colonne aléatoire, puis de la diviser, de cette façon, nous pouvons obtenir une division qui conviendra à nos besoins et sera aléatoire.

def split_df(df, p=[0.8, 0.2]):
import numpy as np
df["rand"]=np.random.choice(len(p), len(df), p=p)
r = [df[df["rand"]==val] for val in df["rand"].unique()]
return r

shuffle = np.random.permutation(len(df))
test_size = int(len(df) * 0.2)
test_aux = shuffle[:test_size]
train_aux = shuffle[test_size:]
TRAIN_DF =df.iloc[train_aux]
TEST_DF = df.iloc[test_aux]

Pas besoin de convertir en numpy. Il suffit d'utiliser un pandas df pour faire la division et il retournera un pandas df.

from sklearn.model_selection import train_test_split

train, test = train_test_split(df, test_size=0.2)

Et si vous voulez séparer x de y

X_train, X_test, y_train, y_test = train_test_split(df[list_of_x_cols], df[y_col],test_size=0.2)

Je pense que vous devez également obtenir une copie et non une tranche de trame de données si vous souhaitez ajouter des colonnes plus tard.

msk = np.random.rand(len(df)) < 0.8
train, test = df[msk].copy(deep = True), df[~msk].copy(deep = True)

Que dis-tu de ça? df est mon dataframe

total_size=len(df)

train_size=math.floor(0.66*total_size) (2/3 part of my dataset)

#training dataset
train=df.head(train_size)
#test dataset
test=df.tail(len(df) -train_size)