Bagaimana cara membuat tes dan melatih sampel dari satu kerangka data dengan panda?

Saya memiliki dataset yang cukup besar dalam bentuk kerangka data dan saya bertanya-tanya bagaimana saya dapat membagi kerangka data menjadi dua sampel acak (80% dan 20%) untuk pelatihan dan pengujian.

Terima kasih!

Saya hanya akan menggunakan 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]

Dan hanya untuk melihat ini berhasil:

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

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

scikit belajar itutrain_test_split bagus.

from sklearn.model_selection import train_test_split

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

Sampel acak panda juga akan berfungsi

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

Saya akan menggunakan training_test_split scikit-learn sendiri, dan menghasilkannya dari indeks

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

Ada banyak cara untuk membuat kereta / tes dan bahkan sampel validasi.

Kasus 1: cara klasik train_test_splittanpa opsi apa pun:

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

Kasus 2: kasus dataset sangat kecil (<500 baris): untuk mendapatkan hasil untuk semua baris Anda dengan validasi silang ini. Pada akhirnya, Anda akan memiliki satu prediksi untuk setiap baris dari set pelatihan yang tersedia.

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)

Kasus 3a: Kumpulan data tidak seimbang untuk tujuan klasifikasi. Mengikuti kasus 1, berikut ini adalah solusi yang setara:

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)

Kasus 3b: Kumpulan data tidak seimbang untuk tujuan klasifikasi. Mengikuti kasus 2, berikut adalah solusi yang setara:

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)

Kasus 4: Anda perlu membuat set train / test / validasi pada data besar untuk menyetel hyperparameter (60% train, 20% test, dan 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)

Anda dapat menggunakan kode di bawah ini untuk membuat sampel uji dan latih:

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

Ukuran tes dapat bervariasi tergantung pada persentase data yang ingin Anda masukkan dalam dataset tes dan kereta Anda.

Ada banyak jawaban yang valid. Menambahkan satu lagi ke banyak. dari 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)]

Anda juga dapat mempertimbangkan pembagian bertingkat ke dalam set pelatihan dan pengujian. Divisi Startified juga menghasilkan pelatihan dan pengujian yang ditetapkan secara acak tetapi sedemikian rupa sehingga proporsi kelas asli dipertahankan. Ini membuat set pelatihan dan pengujian lebih mencerminkan properti dari dataset asli.

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] dan df [test_inds] memberi Anda set pelatihan dan pengujian df DataFrame asli Anda.

Jika Anda perlu untuk membagi data Anda sehubungan dengan kolom lables di set data Anda, Anda dapat menggunakan ini:

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

dan gunakan:

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

Anda juga dapat melewatkan random_state jika Anda ingin mengontrol pembagian acak atau menggunakan beberapa seed acak global.

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)

Anda dapat menggunakan ~ (operator tilde) untuk mengecualikan baris yang diambil sampelnya menggunakan df.sample (), membiarkan panda menangani sampel dan penyaringan indeks, untuk mendapatkan dua set.

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

Ini adalah apa yang saya tulis ketika saya perlu membagi DataFrame. Saya mempertimbangkan untuk menggunakan pendekatan Andy di atas, tetapi tidak suka bahwa saya tidak dapat mengontrol ukuran set data dengan tepat (yaitu, kadang-kadang 79, kadang 81, dll.).

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()

Cukup pilih rentang baris dari df seperti ini

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

Ada banyak jawaban bagus di atas jadi saya hanya ingin menambahkan satu contoh lagi dalam hal Anda ingin menentukan jumlah sampel yang tepat untuk kereta dan set tes dengan hanya menggunakan numpyperpustakaan.

# 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]

Untuk membaginya menjadi lebih dari dua kelas seperti kereta, tes, dan validasi, orang dapat melakukan:

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]

Ini akan menempatkan sekitar 70% data dalam pelatihan, 15% dalam tes, dan 15% dalam validasi.

Anda perlu mengubah panda dataframe menjadi array numpy dan kemudian mengubah array numpy kembali ke dataframe

 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)

Jika Anda ingin memiliki satu kerangka data dan dua kerangka data keluar (bukan array numpy), ini harus melakukan trik:

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

Anda dapat menggunakan fungsi df.as_matrix () dan membuat Numpy-array dan meneruskannya.

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)

Sedikit lebih elegan untuk seleraku adalah membuat kolom acak dan kemudian membaginya, dengan cara ini kita bisa mendapatkan split yang sesuai dengan kebutuhan kita dan akan acak.

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]

Tidak perlu mengkonversi ke numpy. Cukup gunakan panda df untuk melakukan split dan itu akan mengembalikan panda df.

from sklearn.model_selection import train_test_split

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

Dan jika Anda ingin memisahkan x dari y

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

Saya pikir Anda juga perlu mendapatkan salinan, bukan sepotong dataframe jika Anda ingin menambahkan kolom nanti.

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

Bagaimana dengan ini? df adalah kerangka data saya

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)