दिलचस्प पोस्ट
सभी मुख्य स्ट्रोक को ट्रैक करने के लिए जावा कुंजी श्रोता एक सीएसवी को विभाजित करने के लिए रेगेक्स HTTPS url तक पहुंचने का प्रयास करते समय मैं कर्ल के उपयोग के प्रमाण पत्रों से कैसे निपटूं? मेल-क्लाइंट को अटैचमेंट से प्रारंभ करें? जावा स्ट्रिंग शाब्दिक संयोजन Ubuntu पर ssh-add के साथ स्थायी रूप से निजी कुंजी जोड़ें ASP.NET WebAPI में एक फ़ाइल (FileContentResult) को वापस कैसे करें एसक्यूएल चर के लिए एक निष्पाद परिणाम कैसे निर्दिष्ट करें? HttpWebRequest (। NET) एसिंक्रोनस का उपयोग कैसे करें? एंड्रॉइड में मेमोरी लीक क्लास / गतिविधि को कैसे खोजें क्या कोई प्लेटफार्म है जहां विभिन्न प्रकार के संकेत दिए गए हैं? HTML5 <canvas> का पता लगाने का सर्वोत्तम तरीका समर्थित नहीं है कैसे आप 'realloc' सी ++ में? मैक ओएस 10.9 पर 2 एनाकोंडा (पायथन 2.7 और 3.4) को कैसे स्थापित करें एक स्थान से दूसरे स्थान पर फ़ाइल कैसे प्रतिलिपि करें?

मैं पंडों के साथ एक डाटाफ्रेम से टेस्ट और ट्रेन के नमूने कैसे बना सकता हूं?

मेरे पास डेटाफ्रेम के रूप में काफी बड़ा डाटासेट है और मैं सोच रहा था कि मैं प्रशिक्षण और परीक्षण के लिए कैसे डेटाफ़्रेम को दो यादृच्छिक नमूनों (80% और 20%) में विभाजित कर सकता हूं।

धन्यवाद!

Solutions Collecting From Web of "मैं पंडों के साथ एक डाटाफ्रेम से टेस्ट और ट्रेन के नमूने कैसे बना सकता हूं?"

मैं सिर्फ 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] 

और बस यह देखने के लिए काम किया है:

 In [15]: len(test) Out[15]: 21 In [16]: len(train) Out[16]: 79 

scikit सीखना train_test_split एक अच्छा एक है

 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) 

पांडा यादृच्छिक नमूना भी काम करेगा

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

मैं स्किकिट-सीखने के खुद का प्रशिक्षण_टैस्ट_स्प्लिट का प्रयोग करूँगा, और उसे सूचकांक से उत्पन्न करेगा

 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 

कई वैध उत्तर हैं गुच्छा पर एक और जोड़ना sklearn.cross_validation आयात से 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)] 

तुम भी प्रशिक्षण और परीक्षण सेट में स्तरीकृत विभाजन पर विचार कर सकते हैं। प्रारंभिक प्रभाग प्रशिक्षण और परीक्षण को बेतरतीब ढंग से तैयार करता है लेकिन इस तरह से मूल वर्ग के अनुपात संरक्षित होते हैं। इससे प्रशिक्षण और परीक्षण करना मूल डाटासेट के गुणों को बेहतर दर्शाते हैं।

 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] और df [test_inds] आपको अपने मूल डेटाफ़्रेम डीएफ के प्रशिक्षण और परीक्षण सेटों को देते हैं।

जब मैंने डेटाफ्रेम को विभाजित करने की आवश्यकता थी तो मैंने यही लिखा था। मैं ऊपर एंडी के दृष्टिकोण का उपयोग करने पर विचार किया, लेकिन मुझे यह बिल्कुल पसंद नहीं था कि मैं डेटा के आकार को ठीक से सेट कर सकता हूं (यानी, कभी-कभी 79, कभी-कभी 81, आदि)।

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

इस तरह से डीएफ से सीमा पंक्ति का चयन करें

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

यदि आपकी इच्छा में एक डाटाफ्रेम और दो डेटाफ्रेम (नोडिक एरेज़) को आउट करना है, तो यह चाल करना चाहिए:

 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 

मुझे लगता है कि आपको एक कॉपी प्राप्त करने की ज़रूरत है जो डेटाफ़्रेम का टुकड़ा नहीं है यदि आप कॉलम बाद में जोड़ना चाहते हैं

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

आप df.as_matrix () फ़ंक्शन का उपयोग कर सकते हैं और नंपी-अर्रे बना सकते हैं और इसे पास कर सकते हैं।

 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) 

इस बारे में कैसा है? df मेरा डेटाफ्रेम है

 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) 

यदि आपको अपने डेटा सेट में लेबल्स कॉलम के संबंध में अपने डेटा को विभाजित करने की आवश्यकता है तो आप इसका उपयोग कर सकते हैं:

 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 

और इसका प्रयोग करें:

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

आप random_state पारित कर सकते हैं यदि आप विभाजन यादृच्छिक को नियंत्रित करना चाहते हैं या कुछ वैश्विक यादृच्छिक बीज का उपयोग करना चाहते हैं।