Réponses:
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
rand
pour < 0.8
donner un sens car il renvoie des nombres aléatoires uniformément répartis entre 0 et 1.
in[12]
, in[13]
, in[14]
? Je veux comprendre le code python lui-même ici
np.random.rand(len(df))
est un tableau de taille len(df)
avec des valeurs flottantes réparties de manière aléatoire et uniforme dans la plage [0, 1]. Le < 0.8
applique la comparaison par élément et stocke le résultat en place. Ainsi, les valeurs <0,8 deviennent True
et la valeur> = 0,8 deviennentFalse
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)
kf = KFold(n, n_folds=folds) for train_index, test_index in kf: X_train, X_test = X.ix[train_index], X.ix[test_index]
voir l'exemple complet ici: quantstart.com/articles/…
from sklearn.model_selection import train_test_split
plutôt.
from sklearn.cross_validation import train_test_split
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)
random_state
arg?
test
ensemble mélangé est souhaité, comme indiqué ici stackoverflow.com/questions/29576430/shuffle-dataframe-rows . test=df.drop(train.index).sample(frac=1.0)
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
cross_validation
module est désormais obsolète:DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
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_split
sans 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:]
df
dans votre extrait de code est (ou devrait être) mélangé, cela améliorera la réponse.
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 numpy
bibliothè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
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)
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)
msk
est de DTYPEbool
,df[msk]
,df.iloc[msk]
etdf.loc[msk]
revenir toujours le même résultat.