python - tutorial - recorrer data frame pandas

¿Cómo creo pruebas y entreno muestras de un marco de datos con pandas?

Question

Tengo un conjunto de datos bastante grande en forma de un marco de datos y me preguntaba cómo podría dividir el marco de datos en dos muestras aleatorias (80% y 20%) para entrenamiento y pruebas.

¡Gracias!

Answer 1

¿Qué tal esto? df es mi marco de datos

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)

Answer 2

Creo que también necesita obtener una copia y no una porción de marco de datos si desea agregar columnas más adelante.

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

Answer 3

Esto es lo que escribí cuando necesitaba dividir un DataFrame. Consideré usar el enfoque de Andy arriba, pero no me gustó que no pudiera controlar el tamaño de los conjuntos de datos exactamente (es decir, sería a veces 79, a veces 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()

Answer 4

Hay muchas respuestas válidas. Añadiendo uno más al grupo. 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)]

Answer 5

La muestra aleatoria de pandas también funcionará

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

Answer 6

Para dividir en más de dos clases como el tren, la prueba y la validación, uno puede hacer:

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]

Esto colocará el 70% de los datos en el entrenamiento, el 15% en la prueba y el 15% en la validación.

Answer 7

Puede hacer uso de la función df.as_matrix () y crear Numpy-array y pasarlo.

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)

Answer 8

Puede usar el siguiente código para crear muestras de prueba y de tren:

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

El tamaño de la prueba puede variar según el porcentaje de datos que quiera poner en su prueba y en el conjunto de datos del tren.

Answer 9

Si necesita dividir sus datos con respecto a la columna de etiquetas en su conjunto de datos, puede usar esto:

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

y úsala:

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

también puede pasar el estado_aleatorio si desea controlar la aleatoriedad dividida o usar alguna semilla aleatoria global.

Answer 10

Si su deseo es tener un marco de datos y dos marcos de datos (no nudos matrices), esto debería hacer el truco:

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

Answer 11

Solo seleccione la fila range de df como esta

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

Answer 12

También puede considerar la división estratificada en el conjunto de entrenamiento y prueba. La división iniciada también genera un conjunto de entrenamiento y prueba al azar, pero de tal manera que se conservan las proporciones de clase originales. Esto hace que los conjuntos de entrenamiento y prueba reflejen mejor las propiedades del conjunto de datos original.

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] y df [test_inds] le dan los juegos de entrenamiento y prueba de su DataFrame df original.

Answer 13

Utilizaría el propio training_test_split de scikit-learn y lo generaría a partir del índice

from sklearn.cross_validation 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

Answer 14

scikit learn''s train_test_split es bueno.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

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

Answer 15

Yo solo usaría el randn de 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]

Y solo para ver que esto ha funcionado:

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

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