Sklearn में ट्रेन / टेस्ट / मान्यता सेट विभाजन

Question

मैं एक डेटा मैट्रिक्स और संबंधित लेबल वेक्टर को X_train, X_test, X_val, y_train, y_test, y_val में स्केलेर के साथ कैसे विभाजित कर सकता हूं? जहां तक ​​मुझे पता है, sklearn.cross_validation.train_test_splitकेवल दो में विभाजित करने में सक्षम है, तीन में नहीं ...

Answer 1

आप सिर्फ sklearn.model_selection.train_test_splitदो बार इस्तेमाल कर सकते हैं । ट्रेन को विभाजित करने के लिए पहले परीक्षण करें और फिर ट्रेन को फिर से सत्यापन और ट्रेन में विभाजित करें। कुछ इस तरह:

 X_train, X_test, y_train, y_test 
    = train_test_split(X, y, test_size=0.2, random_state=1)

 X_train, X_val, y_train, y_val 
    = train_test_split(X_train, y_train, test_size=0.2, random_state=1)

Comments

हां, यह निश्चित रूप से काम करता है, लेकिन मुझे कुछ और सुरुचिपूर्ण होने की उम्मीद है;) कोई बात नहीं, मैं इस जवाब को स्वीकार करता हूं।

— हेंड्रिक

मैं जोड़ना चाहता था कि यदि आप विभाजन के बाद निम्न हाइपर-मापदंडों की खोज के लिए सत्यापन सेट का उपयोग करना चाहते हैं, तो विभाजन के बाद आप निम्न कार्य कर सकते हैं: gist.github.com/albertotb/1bad123363b186267e3aa26610b54b

— skd

तो इस उदाहरण में अंतिम ट्रेन, परीक्षण, सत्यापन अनुपात क्या है? क्योंकि दूसरे पर train_test_split , आप ऐसा पिछले 80/20 के बंटवारे से कर रहे हैं। तो आपकी घाटी 80% का 20% है। इस तरह से विभाजित अनुपात बहुत सीधा नहीं है।

— मोनिका हेडनक

मैं @ मोनिका हेडडेक से सहमत हूं कि 64% ट्रेन, 16% सत्यापन और 20% परीक्षण विभाजन स्पष्ट हो सकता है। यह एक कष्टप्रद इंजेक्शन है जिसे आपको इस समाधान के साथ बनाना है।

— पेरी

Answer 2

इस सवाल का एक बड़ा जवाब एसओ पर है जो सुन्न और पांडा का उपयोग करता है।

कमांड (चर्चा के लिए उत्तर देखें):

train, validate, test = np.split(df.sample(frac=1), [int(.6*len(df)), int(.8*len(df))])

प्रशिक्षण, सत्यापन और परीक्षण सेट के लिए 60%, 20%, 20% विभाजन का उत्पादन करता है।

Comments

मैं .660% अर्थ देख सकता हूं ... लेकिन .8इसका क्या मतलब है?

— टॉम हेल

@TomHale np.splitफेरबदल सरणी की लंबाई के 60% पर विभाजित हो जाएगा, फिर 80% लंबाई (जो कि अतिरिक्त 20% डेटा है), इस प्रकार शेष 20% डेटा को छोड़ दिया जाएगा। यह फ़ंक्शन की परिभाषा के कारण है। : आप परीक्षण कर सकते हैं / के साथ खेलते हैं x = np.arange(10.0), के बादnp.split(x, [ int(len(x)*0.6), int(len(x)*0.8)])

— 0_0

Answer 3

सबसे अधिक बार आप पाएंगे कि आप इसे एक बार विभाजित नहीं करेंगे लेकिन पहले चरण में आप अपने डेटा को एक प्रशिक्षण और परीक्षण सेट में विभाजित करेंगे। इसके बाद आप 'स्प्लिट के-फोल्ड' या 'लीव-वन-आउट (एलओयू)' एल्गोरिथ्म के साथ क्रॉस-वेलिडेशन जैसे अधिक जटिल विभाजन को शामिल करते हुए एक पैरामीटर खोज करेंगे।

Answer 4

आप train_test_splitदो बार उपयोग कर सकते हैं । मुझे लगता है कि यह सबसे सीधा है।

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=1)
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train, test_size=0.25, random_state=1)

इस तरह, train, val, testसेट 60%, 20%, क्रमशः डाटासेट का 20% हो जाएगा।

Answer 5

ऊपर दिए गए सर्वोत्तम उत्तर में यह उल्लेख नहीं है कि train_test_splitविभाजन के आकार में परिवर्तन नहीं करने का उपयोग करते हुए दो बार अलग-अलग करने से शुरू में दिए गए विभाजन को नहीं दिया जाएगा:

x_train, x_remain = train_test_split(x, test_size=(val_size + test_size))

तब x_remain परिवर्तन में सत्यापन और परीक्षण सेट का भाग गिना जा सकता है

new_test_size = np.around(test_size / (val_size + test_size), 2)
# To preserve (new_test_size + new_val_size) = 1.0 
new_val_size = 1.0 - new_test_size

x_val, x_test = train_test_split(x_remain, test_size=new_test_size)

इस अवसर में सभी प्रारंभिक विभाजन सहेजे जाते हैं।

Answer 6

यहाँ एक और दृष्टिकोण है (बराबर तीन-तरफा विभाजन मानता है):

# randomly shuffle the dataframe
df = df.reindex(np.random.permutation(df.index))

# how many records is one-third of the entire dataframe
third = int(len(df) / 3)

# Training set (the top third from the entire dataframe)
train = df[:third]

# Testing set (top half of the remainder two third of the dataframe)
test = df[third:][:third]

# Validation set (bottom one third)
valid = df[-third:]

इसे और अधिक संक्षिप्त बनाया जा सकता है लेकिन मैंने इसे स्पष्टीकरण के उद्देश्य से रखा है।

Answer 7

यह देखते हुए train_frac=0.8, यह फ़ंक्शन 80% / 10% / 10% विभाजन बनाता है:

import sklearn

def data_split(examples, labels, train_frac, random_state=None):
    ''' https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html
    param data:       Data to be split
    param train_frac: Ratio of train set to whole dataset

    Randomly split dataset, based on these ratios:
        'train': train_frac
        'valid': (1-train_frac) / 2
        'test':  (1-train_frac) / 2

    Eg: passing train_frac=0.8 gives a 80% / 10% / 10% split
    '''

    assert train_frac >= 0 and train_frac <= 1, "Invalid training set fraction"

    X_train, X_tmp, Y_train, Y_tmp = sklearn.model_selection.train_test_split(
                                        examples, labels, train_size=train_frac, random_state=random_state)

    X_val, X_test, Y_val, Y_test   = sklearn.model_selection.train_test_split(
                                        X_tmp, Y_tmp, train_size=0.5, random_state=random_state)

    return X_train, X_val, X_test,  Y_train, Y_val, Y_test

Answer 8

(75, 15, 10) जैसे किसी पूर्वनिर्धारित अनुपात का सम्मान करते हुए @ h32 के उत्तर में जोड़ना :

train_ratio = 0.75
validation_ratio = 0.15
test_ratio = 0.10

# train is now 75% of the entire data set
# the _junk suffix means that we drop that variable completely
x_train, x_test, y_train, y_test = train_test_split(dataX, dataY, test_size=1 - train_ratio)

# test is now 10% of the initial data set
# validation is now 15% of the initial data set
x_val, x_test, y_val, y_test = train_test_split(x_test, y_test, test_size=test_ratio/(test_ratio + validation_ratio)) 

print(x_train, x_val, x_test)

Answer 9

संरक्षित अनुपात के साथ @ hh32 के उत्तर का विस्तार ।

# Defines ratios, w.r.t. whole dataset.
ratio_train = 0.8
ratio_val = 0.1
ratio_test = 0.1

# Produces test split.
x_remaining, x_test, y_remaining, y_test = train_test_split(
    x, y, test_size=test_ratio)

# Adjusts val ratio, w.r.t. remaining dataset.
ratio_remaining = 1 - ratio_test
ratio_val_adjusted = ratio_val / ratio_remaining

# Produces train and val splits.
x_train, x_val, y_train, y_val = train_test_split(
    x_remaining, y_remaining, test_size=ratio_val_adjusted)

चूंकि पहले विभाजन के बाद शेष डेटासेट कम हो जाते हैं, इसलिए कम डेटासेट के संबंध में नए अनुपात समीकरण को हल करके गणना की जानी चाहिए:

$R_{remaining} \cdot R_{new} = R_{old}$