जवाबों:
मैं सिर्फ 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]: 79randलिए उपयोग करना चाहिए < 0.8क्योंकि यह 0 और 1. के बीच समान रूप से वितरित यादृच्छिक संख्या देता है
in[12], in[13], in[14]? मैं यहाँ अजगर कोड को समझना चाहता हूँ
np.random.rand(len(df))आकार की एक सरणी है len(df)। < 0.8तुलना तत्व के लिहाज से और दुकानों जगह में परिणाम लागू होता है। इस प्रकार मान <0.8 बन जाते हैं Trueऔर मूल्य> = 0.8 बन जाते हैंFalse
scikit सीखनाtrain_test_split एक अच्छा है।
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]पूरा उदाहरण यहां देखें: quantstart.com/articles/…
from sklearn.model_selection import train_test_splitइसके बजाय आयात करें ।
from sklearn.cross_validation import train_test_split
पंडों यादृच्छिक नमूना भी काम करेगा
train=df.sample(frac=0.8,random_state=200) #random state is a seed value
test=df.drop(train.index)random_stateआर्ग क्या कर रहा है?
testसेट वांछित है जैसा कि यहां बताया गया है stackoverflow.com/questions/29576430/shuffle-dataframe-rows । test=df.drop(train.index).sample(frac=1.0)
मैं scikit- लर्निंग के अपने प्रशिक्षण_test_split का उपयोग करता हूं, और इसे सूचकांक से उत्पन्न करता हूं
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 traincross_validationमॉड्यूल अब पदावनत किया गया है: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.
ट्रेन / परीक्षण और यहां तक कि सत्यापन के नमूने बनाने के कई तरीके हैं।
केस 1: train_test_splitबिना किसी विकल्प के क्लासिक तरीका :
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.3)केस 2: एक बहुत छोटे डेटासेट का मामला (<500 पंक्तियाँ): इस क्रॉस-वैलिडेशन के साथ आपकी सभी लाइनों के लिए परिणाम प्राप्त करने के लिए। अंत में, आपके पास अपने उपलब्ध प्रशिक्षण सेट की प्रत्येक पंक्ति के लिए एक भविष्यवाणी होगी।
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)केस 3 ए: वर्गीकरण उद्देश्य के लिए असंतुलित डेटासेट। मामले 1 के बाद, यहाँ बराबर समाधान है:
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)केस 3 बी: वर्गीकरण उद्देश्य के लिए असंतुलित डेटासेट। मामले 2 के बाद, यहाँ बराबर समाधान है:
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)केस 4: आपको हाइपरपैरमीटर (60% ट्रेन, 20% परीक्षण और 20% वैल) को ट्यून करने के लिए बड़े डेटा पर एक ट्रेन / टेस्ट / सत्यापन सेट बनाने की आवश्यकता है।
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)परीक्षण और ट्रेन नमूने बनाने के लिए आप नीचे दिए गए कोड का उपयोग कर सकते हैं:
from sklearn.model_selection import train_test_split
trainingSet, testSet = train_test_split(df, test_size=0.2)आपके आकार को आपके परीक्षण और ट्रेन डेटासेट में रखने के प्रतिशत के आधार पर परीक्षण का आकार भिन्न हो सकता है।
आप प्रशिक्षण और परीक्षण सेट में स्तरीकृत विभाजन पर भी विचार कर सकते हैं। प्रारंभ डिवीजन भी यादृच्छिक रूप से प्रशिक्षण और परीक्षण सेट उत्पन्न करता है लेकिन इस तरह से कि मूल वर्ग अनुपात संरक्षित हैं। यह प्रशिक्षण और परीक्षण सेट को मूल डेटासेट के गुणों को बेहतर ढंग से दर्शाता है।
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_indsdf [train_inds] और df [test_inds] आपको अपने मूल DataFrame df का प्रशिक्षण और परीक्षण सेट प्रदान करते हैं।
यदि आपको अपने डेटा सेट के संबंध में अपने डेटा को विभाजित करने की आवश्यकता है तो आप इसका उपयोग कर सकते हैं:
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 भी पास कर सकते हैं।
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)आप df.sample () का उपयोग करके मापी गई पंक्तियों को बाहर करने के लिए ~ (tilde ऑपरेटर) का उपयोग कर सकते हैं, दो सेट प्राप्त करने के लिए पंडों को अकेले ही नमूने के नमूने और फ़िल्टरिंग को संभालने देते हैं।
train_df = df.sample(frac=0.8, random_state=100)
test_df = df[~df.index.isin(train_df.index)]यह वही है जो मैंने लिखा था जब मुझे एक DataFrame को विभाजित करने की आवश्यकता थी। मैंने ऊपर एंडी के दृष्टिकोण का उपयोग करने पर विचार किया, लेकिन यह पसंद नहीं था कि मैं डेटा सेट के आकार को बिल्कुल नियंत्रित नहीं कर सकता (यानी, यह कभी-कभी 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()बस इस तरह से df से रेंज रो का चयन करें
row_count = df.shape[0]
split_point = int(row_count*1/5)
test_data, train_data = df[:split_point], df[split_point:]dfआपके कोड में स्निपेट (या होना चाहिए) फेरबदल किया गया है तो इससे उत्तर में सुधार होगा।
ऊपर कई शानदार जवाब हैं इसलिए मैं सिर्फ एक और उदाहरण जोड़ना चाहता हूं कि आप सिर्फ numpyलाइब्रेरी का उपयोग करके ट्रेन और परीक्षण सेट के लिए नमूनों की सटीक संख्या निर्दिष्ट करना चाहते हैं ।
# 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]ट्रेन, परीक्षण और सत्यापन जैसे दो से अधिक वर्गों में विभाजित करने के लिए, कोई भी कर सकता है:
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]यह प्रशिक्षण में लगभग 70% डेटा, परीक्षण में 15% और सत्यापन में 15% डाल देगा।
आपको पांडा डेटाफ़्रेम को सुपीरियर एरे में बदलना होगा और फिर क्रिस्पी एरे को वापस डेटाफ़्रेम में बदलना होगा
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)यदि आपकी इच्छा एक डेटाफ्रेम और दो डेटाफ्रेम आउट करने की है (सुन्न सरणियों की नहीं), तो यह चाल चलनी चाहिए:
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मेरे स्वाद के लिए थोड़ा अधिक सुरुचिपूर्ण एक यादृच्छिक स्तंभ बनाना है और फिर इसके द्वारा विभाजित करना है, इस तरह हम एक विभाजन प्राप्त कर सकते हैं जो हमारी आवश्यकताओं के अनुरूप होगा और यादृच्छिक होगा।
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 rshuffle = 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]
mskdtype की हैbool,df[msk],df.iloc[msk]औरdf.loc[msk]हमेशा एक ही परिणाम लौटने।