Scikit-lernen ausgeglichenes Subsampling

Hier ist meine erste version, die scheint zu funktionieren gut, fühlen Sie sich frei zu kopieren oder machen Vorschläge, wie könnte es effizienter sein, (ich habe eine ziemlich lange Erfahrung mit der Programmierung im Allgemeinen aber nicht so lange mit python, numpy)

Diese Funktion erstellt eine einzige zufällige symmetrische teilstichprobe.

edit: Die teilstichprobe Größe jetzt Proben nach unten Minderheit Klassen, dies sollte wohl geändert werden.

def balanced_subsample(x,y,subsample_size=1.0):

    class_xs = []
    min_elems = None

    for yi in np.unique(y):
        elems = x[(y == yi)]
        class_xs.append((yi, elems))
        if min_elems == None or elems.shape[0] < min_elems:
            min_elems = elems.shape[0]

    use_elems = min_elems
    if subsample_size < 1:
        use_elems = int(min_elems*subsample_size)

    xs = []
    ys = []

    for ci,this_xs in class_xs:
        if len(this_xs) > use_elems:
            np.random.shuffle(this_xs)

        x_ = this_xs[:use_elems]
        y_ = np.empty(use_elems)
        y_.fill(ci)

        xs.append(x_)
        ys.append(y_)

    xs = np.concatenate(xs)
    ys = np.concatenate(ys)

    return xs,ys

Für jeden, der versucht, die oben machen die Arbeit mit ein Pandas DataFrame, müssen Sie ein paar änderungen:

1. Ersetzen Sie die np.random.shuffle Linie mit

   this_xs = this_xs.reindex(np.random.permutation(this_xs.index))

2. Ersetzen Sie die np.concatenate Linien mit

   xs = pd.concat(xs)
ys = pd.Series(data=np.concatenate(ys),name='target')

InformationsquelleAutor der Antwort mikkom

Einer version für pandas-Serie:

import numpy as np

def balanced_subsample(y, size=None):

    subsample = []

    if size is None:
        n_smp = y.value_counts().min()
    else:
        n_smp = int(size / len(y.value_counts().index))

    for label in y.value_counts().index:
        samples = y[y == label].index.values
        index_range = range(samples.shape[0])
        indexes = np.random.choice(index_range, size=n_smp, replace=False)
        subsample += samples[indexes].tolist()

    return subsample

InformationsquelleAutor der Antwort gc5

Unten ist meiner python-Implementierung für die Erstellung von balanced-Daten zu kopieren.
Annahmen:
1. Zielvariable (y) ist Binär-Klasse (0 vs. 1)
2. 1 ist die Minderheit.

from numpy import unique
from numpy import random 

def balanced_sample_maker(X, y, random_seed=None):
    """ return a balanced data set by oversampling minority class 
        current version is developed on assumption that the positive
        class is the minority.

    Parameters:
    ===========
    X: {numpy.ndarrray}
    y: {numpy.ndarray}
    """
    uniq_levels = unique(y)
    uniq_counts = {level: sum(y == level) for level in uniq_levels}

    if not random_seed is None:
        random.seed(random_seed)

    # find observation index of each class levels
    groupby_levels = {}
    for ii, level in enumerate(uniq_levels):
        obs_idx = [idx for idx, val in enumerate(y) if val == level]
        groupby_levels[level] = obs_idx

    # oversampling on observations of positive label
    sample_size = uniq_counts[0]
    over_sample_idx = random.choice(groupby_levels[1], size=sample_size, replace=True).tolist()
    balanced_copy_idx = groupby_levels[0] + over_sample_idx
    random.shuffle(balanced_copy_idx)

    return X[balanced_copy_idx, :], y[balanced_copy_idx]

InformationsquelleAutor der Antwort beingzy

Einer leichten Modifikation, um die top-Antwort von mikkom.

Wenn Sie möchten, erhalten Bestellung der größeren Klasse, die Daten, dh. Sie wollen nicht zu mischen.

Statt

    if len(this_xs) > use_elems:
        np.random.shuffle(this_xs)

tun

        if len(this_xs) > use_elems:
            ratio = len(this_xs) / use_elems
            this_xs = this_xs[::ratio]

InformationsquelleAutor der Antwort Bert Kellerman

Obwohl es schon beantwortet, ich stolperte über Ihre Frage für etwas ähnliches suchen. Nach etwas mehr Forschung, ich glaube sklearn.model_selection.StratifiedKFold können für diesen Zweck verwendet werden:

from sklearn.model_selection import StratifiedKFold

X = samples_array
y = classes_array # subsamples will be stratified according to y
n = desired_number_of_subsamples

skf = StratifiedKFold(n, shuffle = True)

batches = []
for _, batch in skf.split(X, y):
    do_something(X[batch], y[batch])

Ist es wichtig, dass Sie das _ weil da skf.split() verwendet wird, zu erstellen geschichteten Falten für K-fold cross-validation, gibt es zwei Listen von Indizes: train (n - 1 /n Elemente) und test (1 /n Elemente).

Bitte beachten Sie, dass dies ist, wie der sklearn 0.18. In sklearn 0.17 die gleiche Funktion finden Sie im Modul cross_validation statt.

InformationsquelleAutor der Antwort kadu