Randomisierte geschichtete k-fache Kreuzvalidierung in scikit-learn?

Question

Gibt es einen integrierten Weg, um scikit-learn zu erhalten, um eine geschichtete k-fache Kreuzvalidierung durchzuführen? Dies ist eine der häufigsten CV-Methoden, und ich bin überrascht, dass ich dafür keine integrierte Methode finden konnte.

Ich sah, dass cross_validation.KFold() hat eine Shuffling-Flag, aber es ist nicht geschichtet. Leider hat cross_validation.StratifiedKFold() keine solche Option, und cross_validation.StratifiedShuffleSplit() erzeugt keine disjunkten Falten.

Fehle ich etwas? Ist das geplant?

(natürlich kann ich das von mir implementieren)

Answer 1

Die schlurfenden Flagge für cross_validation.StratifiedKFold hat in der aktuellen Version 0.15 eingeführt.

http://scikit-learn.org/0.15/modules/generated/sklearn.cross_validation.StratifiedKFold.html

Dies kann im Changelog zu finden:

http://scikit-learn.org/stable/whats_new.html#new-features

Mischoption für cross_validation.StratifiedKFold. Von Jeffrey Blackburne.

Answer 2

Soweit ich weiß, das tatsächlich umgesetzt wird Scikit-Learn.

""“ Geschichtete ShuffleSplit Kreuzvalidierung Iterator

Bietet Zug/Test Indizes Daten in dem Zug-Prüfgeräten zu spalten.

Diese Kreuzvalidierung Objekt eine Zusammenführung von StratifiedKFold und ShuffleSplit, die stratifizierte randomisierte Falten zurückgibt. Die Falten werden hergestellt, indem der Prozentsatz der Proben für jede Klasse beibehalten wird.

Hinweis: Wie bei der ShuffleSplit-Strategie garantieren geschichtete Zufallsspalte nicht, dass alle Falten unterschiedlich sind, obwohl dies für große Datensätze immer noch sehr wahrscheinlich ist. „““

Answer 3

Ich dachte, ich meine Lösung für den Fall veröffentlichen würde, ist es an jemand anderen nützlich

from collections import defaultdict 
import random 
def strat_map(y): 
    """ 
    Returns permuted indices that maintain class 
    """ 
    smap = defaultdict(list) 
    for i,v in enumerate(y): 
     smap[v].append(i) 
    for values in smap.values(): 
     random.shuffle(values) 
    y_map = np.zeros_like(y) 
    for i,v in enumerate(y): 
     y_map[i] = smap[v].pop() 
    return y_map 

########## 
#Example Use 
########## 
skf = StratifiedKFold(y, nfolds) 
sm = strat_map(y) 
for test, train in skf: 
    test,train = sm[test], sm[train] 
    #then cv as usual 


####### 
#tests# 
####### 
import numpy.random as rnd 
for _ in range(100): 
    y = np.array([0]*10 + [1]*20 + [3] * 10) 
    rnd.shuffle(y) 
    sm = strat_map(y) 
    shuffled = y[sm] 
    assert (sm != range(len(y))).any() , "did not shuffle" 
    assert (shuffled == y).all(), "classes not in right position" 
    assert (set(sm) == set(range(len(y)))), "missing indices" 


for _ in range(100): 
    nfolds = 10 
    skf = StratifiedKFold(y, nfolds) 
    sm = strat_map(y) 
    for test, train in skf: 
     assert (sm[test] != test).any(), "did not shuffle" 
     assert (y[sm[test]] == y[test]).all(), "classes not in right position" 

Answer 4

Hier meine Implementierung von geschichteten Shuffle aufgeteilt in Trainings- und Testsatz ist:

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 
    test 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 


y = np.array([1,1,2,2,3,3]) 
train_inds,test_inds = get_train_test_inds(y,train_proportion=0.5) 
print y[train_inds] 
print y[test_inds] 

Dieser Code gibt:

[1 2 3] 
[1 2 3]