Scikit-learn: 계층화된 그룹KFold

@TomDLT @NicolasHug 어떻게 생각하세요?

이론적으로는 흥미로울 수 있지만 실제로 얼마나 유용할지 모르겠습니다. 우리는 확실히 문제를 열어두고 얼마나 많은 사람들이 이 기능을 요청하는지 확인할 수 있습니다.

각 그룹이 단일 클래스에 있다고 가정합니까?

참조 #9413

@jnothman 예, 비슷한 것을 염두에 두었습니다. 그러나 pull 요청이 아직 열려 있음을 알 수 있습니다. 나는 그룹이 폴드에서 반복되지 않을 것임을 의미했습니다. 그룹으로 ID가 있는 경우 동일한 ID가 여러 폴드에서 발생하지 않습니다.

RFECV 사용과 관련이 있음을 이해합니다.
현재 기본적으로 StratifiedKFold cv를 사용합니다. 그것의 fit()은 또한 그룹을 취합니다=
그러나 fit()을 실행할 때 그룹이 존중되지 않는 것으로 보입니다. 경고 없음(버그로 간주될 수 있음).

그룹화 및 계층화는 레코드 간 종속성이 있는 불균형한 데이터 세트에 유용합니다.
(저의 경우 같은 개인이 여러 기록을 가지고 있지만 분할 수에 비해 여전히 많은 수의 그룹=사람이 있습니다. 분할 수).

그래서: +1!

이것은 확실히 유용할 것입니다. 예를 들어, 불균형이 심한 시계열 의료 데이터로 작업하여 환자를 분리하지만 각 접힘에서 불균형 클래스의 (대략) 균형을 유지합니다.

또한 StratifiedKFold는 그룹을 매개변수로 사용하지만 그룹에 따라 그룹화하지 않으므로 플래그를 지정해야 합니다.

이 기능의 또 다른 좋은 사용은 일반적으로 매우 불균형한 재무 데이터입니다. 제 경우에는 동일한 엔터티(다른 시점)에 대한 여러 레코드가 있는 매우 불균형한 데이터 세트가 있습니다. 우리는 누출을 피하기 위해 GroupKFold 를 하고 싶지만 높은 불균형으로 인해 양성이 거의 또는 전혀 없는 그룹으로 끝날 수 있기 때문에 또한 계층화합니다.

또한 #14524를 참조하십시오.

Stratified GroupShuffleSplit 및 GroupKFold의 또 다른 사용 사례는 생물학적 "반복 측정" 설계로, 피험자 또는 다른 상위 생물학적 단위당 여러 샘플이 있습니다. 또한 생물학의 많은 실제 데이터 세트에는 계급 불균형이 있습니다. 각 샘플 그룹에는 동일한 클래스가 있습니다. 따라서 그룹을 계층화하고 함께 유지하는 것이 중요합니다.

설명

현재 sklearn에는 계층화된 그룹 kfold 기능이 없습니다. 계층화를 사용하거나 그룹 kfold를 사용할 수 있습니다. 그러나 둘 다 있으면 좋을 것입니다.

우리가 그것을 갖기로 결정한다면 그것을 구현하고 싶습니다.

안녕하세요, 의학 ML에 꽤 유용할 것 같습니다. 이미 구현되어 있습니까?

@amueller 사람들이 이것에 관심이 있는 것을 감안할 때 이것을 구현해야 한다고 생각하십니까?

저도 매우 관심이 많습니다... 각 샘플에 대해 여러 개의 반복 측정값이 있는 경우 분광학에서 정말 유용할 것입니다. 교차 검증 중에 동일한 접기 상태를 유지해야 합니다. 그리고 분류하려는 불균형 클래스가 여러 개 있는 경우 계층화 기능도 사용하고 싶을 것입니다. 그래서 나도 한표! 개발에 참여하기에는 미흡하지만 참여하실 분들을 위해 안심하고 사용할 수 있어서 죄송합니다 :-)
모든 팀을 위해 엄지손가락을 치켜세웁니다. 감사!

StratifiedGroupKFold 에 대한 작업이 시도되었으므로 이 스레드에서 참조된 문제 및 PR을 살펴보십시오. 나는 이미 테스트가 필요한 StratifiedGroupShuffleSplit #15239를 수행했지만 이미 내 작업에 꽤 많이 사용했습니다.

우리가 구현해야 한다고 생각하지만, 우리가 실제로 원하는 것이 무엇인지 아직 모른다고 생각합니다. @hermidalc 는 동일한 그룹의 구성원이 동일한 클래스에 있어야 한다는 제한이 있습니다. 일반적인 경우는 아니잖아요?

관심 있는 사람들이 자신의 사용 사례와 이로부터 진정 원하는 것이 무엇인지 설명할 수 있다면 좋을 것입니다.

#15239 #14524 및 #9413이 있는데 모두 다른 의미를 가지고 있는 것으로 기억합니다.

@amueller 는 전적으로 동의합니다. 저는 오늘 사용 가능한 여러 버전(#15239 #14524 및 #9413) 사이에서 뭔가를 찾는 데 몇 시간을 보냈지만 이 중 어느 것이 제 필요에 맞는지 정말 이해할 수 없었습니다. 도움이 될 수 있다면 여기 내 사용 사례가 있습니다.
1000개의 샘플이 있습니다. 각 샘플은 NIR 분광계로 3번 측정되었으므로 각 샘플에는 3번의 복제가 포함되어 계속 함께 유지하고 싶습니다...
이 1000개의 샘플은 각각 샘플 수가 매우 다른 6가지 클래스에 속합니다.
클래스 1: 400개 샘플
클래스 2: 300개 샘플
클래스 3: 100개 샘플
클래스 4: 100개 샘플
클래스 5: 70개 샘플
클래스 6: 30개 샘플
각 클래스에 대한 분류기를 만들고 싶습니다. 따라서 클래스 1 대 다른 모든 클래스, 클래스 2 대 다른 모든 클래스 등입니다.
내 분류기 각각의 정확도를 최대화하려면 각 접기에 표현된 6개 클래스의 샘플을 갖는 것이 중요합니다. 내 클래스가 그렇게 다르지 않기 때문에 항상 6개 클래스가 표현되도록 정확한 경계를 만드는 데 실제로 도움이 되기 때문입니다. 각 접기에서.

이것이 내가 계층화된(항상 각 폴드에 6개의 클래스가 표시됨) 그룹(각 샘플의 3개의 반복 측정값을 항상 함께 유지) kfold가 내가 여기서 찾고 있는 것과 매우 유사하다고 믿는 이유입니다.
어떤 의견이 있습니까?

내 사용 사례와 내가 StratifiedGroupShuffleSplit 를 쓴 이유는 https://en.wikipedia.org/wiki/Repeated_measures_design 반복 측정 디자인을 지원하기 위한 것입니다. 내 사용 사례에서 동일한 그룹의 구성원은 동일한 클래스에 있어야 합니다.

@fcoppey 여러분, 그룹 내의 샘플은 항상 같은 클래스를 가지고 있죠?

@hermidalc 나는 용어에 익숙하지 않지만 wikipedia에서 "반복 측정 디자인"은 "크로스 오버 시험에는 반복 측정 디자인이 있습니다. 각 환자는 두 가지 이상의 일련의 치료에 배정되며, 그 중 하나는 표준 치료 또는 위약이 될 수 있습니다."
이것을 ML 설정과 관련하여 측정을 통해 개인이 방금 치료를 받았는지 또는 위약을 받았는지 예측하거나 해당 치료에 따른 결과를 예측하려고 할 수 있습니다.
어느 쪽이든 같은 개인의 클래스가 바뀔 수 있지 않습니까?

이름에 관계없이 두 사람 모두 동일한 사용 사례를 가지고 있는 것처럼 들리지만 저는 교차 연구에서 설명한 것과 유사한 사례에 대해 생각하고 있었습니다. 아니면 조금 더 간단할 수도 있습니다. 시간이 지나면서 환자가 아프게 하거나(또는 낫게) 환자의 결과가 바뀔 수 있습니다.

실제로 링크한 위키피디아 기사에는 "종단적 분석 - 반복 측정 설계를 통해 연구원이 장단기 상황 모두에서 참가자가 시간이 지남에 따라 어떻게 변화하는지 모니터링할 수 있습니다."라고 명시적으로 명시되어 있으므로 클래스 변경이 포함되어 있다고 생각합니다.
측정이 동일한 조건에서 수행된다는 것을 의미하는 다른 단어가 있다면 그 단어를 사용할 수 있습니까?

@amueller 예, 맞습니다. 일반적으로 이 사용 사례가 아닌 이 디자인의 사용 사례에서 말하고자 했던 부분을 위에서 잘못 썼다는 것을 깨달았습니다.

반복 측정 설계에는 매우 정교한 유형이 많이 있을 수 있지만 두 유형에서 그룹 내 StratifiedGroupShuffleSplit 가 필요했습니다. 동일한 클래스 제한이 유지됩니다(치료 반응을 예측할 때 치료 전후의 세로 샘플링, 다중 전처리 치료 반응을 예측할 때 다른 신체 위치에서 피험자당 샘플).

즉시 작동하는 무언가가 필요했기 때문에 다른 사람들이 사용할 수 있도록 공개하고 sklearn에서 무언가를 시작하고 싶었습니다. 게다가 내가 잘못 알고 있지 않다면 그룹 클래스 레이블 내에서 계층화 논리를 설계하는 것이 더 복잡할 수 있습니다.

@amueller 항상 그렇습니다. 그들은 예측에 장치의 내변성을 포함하기 위해 동일한 측정의 복제입니다.

@hermidalc 네, 이 경우가 훨씬 쉽습니다. 일반적인 요구 사항이라면 기꺼이 추가하겠습니다. 우리는 이름에서 그것이 하는 일을 어느 정도 명확하게 해야 하고 이 두 버전이 같은 클래스에 있어야 하는지에 대해 생각해야 합니다.

StratifiedKFold 가 이것을 하도록 만드는 것은 아주 쉬울 것입니다. 두 가지 옵션이 있습니다. 각 접기에 비슷한 수의 샘플이 포함되어 있는지 확인하거나 각 접기에 비슷한 수의 그룹이 포함되어 있는지 확인합니다.
두 번째 것은 간단하게 수행할 수 있습니다(각 그룹이 단일 포인트인 것처럼 가장하고 StratifiedKFold 에 전달). 그것이 당신이 PR에서 하는 일입니다.

GroupKFold 나는 가장 작은 접기를 먼저 추가하여 두 가지를 경험적으로 교환한다고 생각합니다. 이것이 계층화된 경우로 어떻게 변환될지 잘 모르겠습니다. 따라서 귀하의 접근 방식을 사용하게 되어 기쁩니다.

동일한 PR에 GroupStratifiedKFold도 추가해야 합니까? 아니면 나중을 위해 남겨둘까요?
다른 PR은 약간 다른 목표를 가지고 있습니다. 누군가 다른 사용 사례가 무엇인지 쓸 수 있다면 좋을 것입니다(지금은 시간이 없을 것입니다).

모든 샘플에 동일한 클래스가 있는 그룹 제약 조건을 별도로 처리하려면 +1입니다.

@hermidalc 네, 이 경우가 훨씬 쉽습니다. 일반적인 요구 사항이라면 기꺼이 추가하겠습니다. 우리는 이름에서 그것이 하는 일을 어느 정도 명확하게 해야 하고 이 두 버전이 같은 클래스에 있어야 하는지에 대해 생각해야 합니다.

나는 이것을 완전히 이해하지 못하고 있습니다. StratifiedGroupShuffleSplit 및 StratifiedGroupKFold 각 그룹의 구성원이 다른 클래스에 속할 수 있는 경우 사용자가 모든 그룹 구성원을 다음으로 지정할 때 정확히 동일한 분할 동작을 가져야 합니다. 같은 클래스의. 나중에 내부를 개선할 수 있고 기존 동작이 동일하게 되는 경우는 언제입니까?

두 번째 것은 간단하게 수행할 수 있습니다(각 그룹이 단일 포인트인 것처럼 가장하고 StratifiedKFold 에 전달). 그것이 당신이 PR에서 하는 일입니다.

GroupKFold 나는 가장 작은 접기를 먼저 추가하여 두 가지를 경험적으로 교환한다고 생각합니다. 이것이 계층화된 경우로 어떻게 변환될지 잘 모르겠습니다. 따라서 귀하의 접근 방식을 사용하게 되어 기쁩니다.

동일한 PR에 GroupStratifiedKFold도 추가해야 합니까? 아니면 나중을 위해 남겨둘까요?
다른 PR은 약간 다른 목표를 가지고 있습니다. 누군가 다른 사용 사례가 무엇인지 쓸 수 있다면 좋을 것입니다(지금은 시간이 없을 것입니다).

내가 사용한 "각 그룹 단일 샘플" 접근 방식을 사용하여 StatifiedGroupKFold 를 추가합니다.

관심 있는 사람들이 자신의 사용 사례와 이로부터 진정 원하는 것이 무엇인지 설명할 수 있다면 좋을 것입니다.

측정을 반복해야 하는 경우 의학 및 생물학에서 매우 일반적인 사용 사례입니다.
예: MR 이미지에서 알츠하이머병(AD) 대 건강한 대조군과 같은 질병을 분류하려고 한다고 가정합니다. 동일한 주제에 대해 여러 스캔이 있을 수 있습니다(추적 세션 또는 종단 데이터에서). 총 1000명의 피험자가 있고 그 중 200명이 AD(불균형 클래스)로 진단된다고 가정해 보겠습니다. 대부분의 피사체는 한 번 스캔하지만 일부는 2~3개의 이미지를 사용할 수 있습니다. 분류기를 훈련/테스트할 때 데이터 누출을 방지하기 위해 동일한 주제의 이미지가 항상 동일한 접힘에 있는지 확인하려고 합니다.
이를 위해 StratifiedGroupKFold를 사용하는 것이 가장 좋습니다. 클래스 불균형을 설명하기 위해 계층화하지만 주제가 다른 폴드에 나타나지 않아야 한다는 그룹 제약 조건이 있습니다.
주의: 반복 가능하게 만드는 것이 좋습니다.

아래는 kaggle-kernel 에서 영감을 받은 구현 예입니다.

import numpy as np
from collections import Counter, defaultdict
from sklearn.utils import check_random_state

class RepeatedStratifiedGroupKFold():

    def __init__(self, n_splits=5, n_repeats=1, random_state=None):
        self.n_splits = n_splits
        self.n_repeats = n_repeats
        self.random_state = random_state

    # Implementation based on this kaggle kernel:
    #    https://www.kaggle.com/jakubwasikowski/stratified-group-k-fold-cross-validation
    def split(self, X, y=None, groups=None):
        k = self.n_splits
        def eval_y_counts_per_fold(y_counts, fold):
            y_counts_per_fold[fold] += y_counts
            std_per_label = []
            for label in range(labels_num):
                label_std = np.std(
                    [y_counts_per_fold[i][label] / y_distr[label] for i in range(k)]
                )
                std_per_label.append(label_std)
            y_counts_per_fold[fold] -= y_counts
            return np.mean(std_per_label)

        rnd = check_random_state(self.random_state)
        for repeat in range(self.n_repeats):
            labels_num = np.max(y) + 1
            y_counts_per_group = defaultdict(lambda: np.zeros(labels_num))
            y_distr = Counter()
            for label, g in zip(y, groups):
                y_counts_per_group[g][label] += 1
                y_distr[label] += 1

            y_counts_per_fold = defaultdict(lambda: np.zeros(labels_num))
            groups_per_fold = defaultdict(set)

            groups_and_y_counts = list(y_counts_per_group.items())
            rnd.shuffle(groups_and_y_counts)

            for g, y_counts in sorted(groups_and_y_counts, key=lambda x: -np.std(x[1])):
                best_fold = None
                min_eval = None
                for i in range(k):
                    fold_eval = eval_y_counts_per_fold(y_counts, i)
                    if min_eval is None or fold_eval < min_eval:
                        min_eval = fold_eval
                        best_fold = i
                y_counts_per_fold[best_fold] += y_counts
                groups_per_fold[best_fold].add(g)

            all_groups = set(groups)
            for i in range(k):
                train_groups = all_groups - groups_per_fold[i]
                test_groups = groups_per_fold[i]

                train_indices = [i for i, g in enumerate(groups) if g in train_groups]
                test_indices = [i for i, g in enumerate(groups) if g in test_groups]

                yield train_indices, test_indices

RepeatedStratifiedKFold (같은 그룹의 샘플이 두 폴드에 나타날 수 있음)와 RepeatedStratifiedGroupKFold 비교:

import matplotlib.pyplot as plt
from sklearn import model_selection

def plot_cv_indices(cv, X, y, group, ax, n_splits, lw=10):
    for ii, (tr, tt) in enumerate(cv.split(X=X, y=y, groups=group)):
        indices = np.array([np.nan] * len(X))
        indices[tt] = 1
        indices[tr] = 0

        ax.scatter(range(len(indices)), [ii + .5] * len(indices),
                   c=indices, marker='_', lw=lw, cmap=plt.cm.coolwarm,
                   vmin=-.2, vmax=1.2)

    ax.scatter(range(len(X)), [ii + 1.5] * len(X), c=y, marker='_',
               lw=lw, cmap=plt.cm.Paired)
    ax.scatter(range(len(X)), [ii + 2.5] * len(X), c=group, marker='_',
               lw=lw, cmap=plt.cm.tab20c)

    yticklabels = list(range(n_splits)) + ['class', 'group']
    ax.set(yticks=np.arange(n_splits+2) + .5, yticklabels=yticklabels,
           xlabel='Sample index', ylabel="CV iteration",
           ylim=[n_splits+2.2, -.2], xlim=[0, 100])
    ax.set_title('{}'.format(type(cv).__name__), fontsize=15)


# demonstration
np.random.seed(1338)
n_splits = 4
n_repeats=5


# Generate the class/group data
n_points = 100
X = np.random.randn(100, 10)

percentiles_classes = [.4, .6]
y = np.hstack([[ii] * int(100 * perc) for ii, perc in enumerate(percentiles_classes)])

# Evenly spaced groups
g = np.hstack([[ii] * 5 for ii in range(20)])


fig, ax = plt.subplots(1,2, figsize=(14,4))

cv_nogrp = model_selection.RepeatedStratifiedKFold(n_splits=n_splits,
                                                   n_repeats=n_repeats,
                                                   random_state=1338)
cv_grp = RepeatedStratifiedGroupKFold(n_splits=n_splits,
                                      n_repeats=n_repeats,
                                      random_state=1338)

plot_cv_indices(cv_nogrp, X, y, g, ax[0], n_splits * n_repeats)
plot_cv_indices(cv_grp, X, y, g, ax[1], n_splits * n_repeats)

plt.show()

stratifiedGroupKfold의 경우 +1입니다. samrt 시계에서 센서를 가져와 노인의 낙상을 감지하려고합니다. 우리는 가을 데이터가 많지 않기 때문에 다른 등급을 가진 다른 시계로 시뮬레이션을 합니다. 또한 데이터를 훈련하기 전에 데이터를 보강합니다. 각 데이터 포인트에서 9개의 포인트를 만들고 이것이 그룹입니다. 그룹이 설명된 대로 훈련과 테스트를 모두 수행하지 않는 것이 중요합니다.

StratifiedGroupKFold도 사용할 수 있기를 바랍니다. 저는 금융 위기를 예측하기 위한 데이터 세트를 보고 있습니다. 각 위기 전, 후, 동안은 자체 그룹입니다. 훈련 및 교차 검증 중에 각 그룹의 구성원은 폴드 사이에서 누출되어서는 안 됩니다.

어쨌든 다중 레이블 시나리오(Multilabel_
계층화 그룹Kfold)?

이것에 대해 +1. 스팸에 대한 사용자 계정을 분석하고 있으므로 사용자별로 그룹화하고 싶지만 스팸은 상대적으로 발생률이 낮기 때문에 계층화하기도 합니다. 우리의 사용 사례에서는 한 번 스팸을 보낸 사용자는 모든 데이터에서 스팸 발송자로 표시되므로 그룹 구성원은 항상 동일한 레이블을 갖게 됩니다.

문서를 구성하기 위한 고전적인 사용 사례를 제공해 주셔서 감사합니다.
@philip-iv!

StratifiedGroupShuffleSplit 와 동일한 PR #15239에 StratifiedGroupKFold 구현을 추가했습니다.

PR에서 볼 수 있듯이 둘 다에 대한 논리는 https://github.com/scikit-learn/scikit-learn/issues/13621#issuecomment -557802602보다 훨씬 간단합니다. 고유한 그룹 정보를 전달하여 기존 StratifiedKFold 및 StratifiedShuffleSplit 코드를 활용할 수 있도록 각 클래스(샘플의 백분율 아님). 그러나 두 구현 모두 각 그룹의 샘플이 동일한 폴드에 함께 유지되는 폴드를 생성합니다.

https://github.com/scikit-learn/scikit-learn/issues/13621#issuecomment -557802602를 기반으로 더 정교한 방법에 투표하겠지만

다음은 @mrunibe 에서 제공한 코드를 사용하여 StratifiedGroupKFold 및 RepeatedStratifiedGroupKFold 의 본격적인 버전입니다. 이 코드는 몇 가지를 더욱 단순화하고 변경했습니다. 이 클래스는 또한 동일한 유형의 다른 sklearn CV 클래스가 수행되는 방식의 설계를 따릅니다.

class StratifiedGroupKFold(_BaseKFold):
    """Stratified K-Folds iterator variant with non-overlapping groups.

    This cross-validation object is a variation of StratifiedKFold that returns
    stratified folds with non-overlapping groups. The folds are made by
    preserving the percentage of samples for each class.

    The same group will not appear in two different folds (the number of
    distinct groups has to be at least equal to the number of folds).

    The difference between GroupKFold and StratifiedGroupKFold is that
    the former attempts to create balanced folds such that the number of
    distinct groups is approximately the same in each fold, whereas
    StratifiedGroupKFold attempts to create folds which preserve the
    percentage of samples for each class.

    Read more in the :ref:`User Guide <cross_validation>`.

    Parameters
    ----------
    n_splits : int, default=5
        Number of folds. Must be at least 2.

    shuffle : bool, default=False
        Whether to shuffle each class's samples before splitting into batches.
        Note that the samples within each split will not be shuffled.

    random_state : int or RandomState instance, default=None
        When `shuffle` is True, `random_state` affects the ordering of the
        indices, which controls the randomness of each fold for each class.
        Otherwise, leave `random_state` as `None`.
        Pass an int for reproducible output across multiple function calls.
        See :term:`Glossary <random_state>`.

    Examples
    --------
    >>> import numpy as np
    >>> from sklearn.model_selection import StratifiedGroupKFold
    >>> X = np.ones((17, 2))
    >>> y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    >>> groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8])
    >>> cv = StratifiedGroupKFold(n_splits=3)
    >>> for train_idxs, test_idxs in cv.split(X, y, groups):
    ...     print("TRAIN:", groups[train_idxs])
    ...     print("      ", y[train_idxs])
    ...     print(" TEST:", groups[test_idxs])
    ...     print("      ", y[test_idxs])
    TRAIN: [2 2 4 5 5 5 5 6 6 7]
           [1 1 1 0 0 0 0 0 0 0]
     TEST: [1 1 3 3 3 8 8]
           [0 0 1 1 1 0 0]
    TRAIN: [1 1 3 3 3 4 5 5 5 5 8 8]
           [0 0 1 1 1 1 0 0 0 0 0 0]
     TEST: [2 2 6 6 7]
           [1 1 0 0 0]
    TRAIN: [1 1 2 2 3 3 3 6 6 7 8 8]
           [0 0 1 1 1 1 1 0 0 0 0 0]
     TEST: [4 5 5 5 5]
           [1 0 0 0 0]

    See also
    --------
    StratifiedKFold: Takes class information into account to build folds which
        retain class distributions (for binary or multiclass classification
        tasks).

    GroupKFold: K-fold iterator variant with non-overlapping groups.
    """

    def __init__(self, n_splits=5, shuffle=False, random_state=None):
        super().__init__(n_splits=n_splits, shuffle=shuffle,
                         random_state=random_state)

    # Implementation based on this kaggle kernel:
    # https://www.kaggle.com/jakubwasikowski/stratified-group-k-fold-cross-validation
    def _iter_test_indices(self, X, y, groups):
        labels_num = np.max(y) + 1
        y_counts_per_group = defaultdict(lambda: np.zeros(labels_num))
        y_distr = Counter()
        for label, group in zip(y, groups):
            y_counts_per_group[group][label] += 1
            y_distr[label] += 1

        y_counts_per_fold = defaultdict(lambda: np.zeros(labels_num))
        groups_per_fold = defaultdict(set)

        groups_and_y_counts = list(y_counts_per_group.items())
        rng = check_random_state(self.random_state)
        if self.shuffle:
            rng.shuffle(groups_and_y_counts)

        for group, y_counts in sorted(groups_and_y_counts,
                                      key=lambda x: -np.std(x[1])):
            best_fold = None
            min_eval = None
            for i in range(self.n_splits):
                y_counts_per_fold[i] += y_counts
                std_per_label = []
                for label in range(labels_num):
                    std_per_label.append(np.std(
                        [y_counts_per_fold[j][label] / y_distr[label]
                         for j in range(self.n_splits)]))
                y_counts_per_fold[i] -= y_counts
                fold_eval = np.mean(std_per_label)
                if min_eval is None or fold_eval < min_eval:
                    min_eval = fold_eval
                    best_fold = i
            y_counts_per_fold[best_fold] += y_counts
            groups_per_fold[best_fold].add(group)

        for i in range(self.n_splits):
            test_indices = [idx for idx, group in enumerate(groups)
                            if group in groups_per_fold[i]]
            yield test_indices


class RepeatedStratifiedGroupKFold(_RepeatedSplits):
    """Repeated Stratified K-Fold cross validator.

    Repeats Stratified K-Fold with non-overlapping groups n times with
    different randomization in each repetition.

    Read more in the :ref:`User Guide <cross_validation>`.

    Parameters
    ----------
    n_splits : int, default=5
        Number of folds. Must be at least 2.

    n_repeats : int, default=10
        Number of times cross-validator needs to be repeated.

    random_state : int or RandomState instance, default=None
        Controls the generation of the random states for each repetition.
        Pass an int for reproducible output across multiple function calls.
        See :term:`Glossary <random_state>`.

    Examples
    --------
    >>> import numpy as np
    >>> from sklearn.model_selection import RepeatedStratifiedGroupKFold
    >>> X = np.ones((17, 2))
    >>> y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    >>> groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8])
    >>> cv = RepeatedStratifiedGroupKFold(n_splits=2, n_repeats=2,
    ...                                   random_state=36851234)
    >>> for train_index, test_index in cv.split(X, y, groups):
    ...     print("TRAIN:", groups[train_idxs])
    ...     print("      ", y[train_idxs])
    ...     print(" TEST:", groups[test_idxs])
    ...     print("      ", y[test_idxs])
    TRAIN: [2 2 4 5 5 5 5 8 8]
           [1 1 1 0 0 0 0 0 0]
     TEST: [1 1 3 3 3 6 6 7]
           [0 0 1 1 1 0 0 0]
    TRAIN: [1 1 3 3 3 6 6 7]
           [0 0 1 1 1 0 0 0]
     TEST: [2 2 4 5 5 5 5 8 8]
           [1 1 1 0 0 0 0 0 0]
    TRAIN: [3 3 3 4 7 8 8]
           [1 1 1 1 0 0 0]
     TEST: [1 1 2 2 5 5 5 5 6 6]
           [0 0 1 1 0 0 0 0 0 0]
    TRAIN: [1 1 2 2 5 5 5 5 6 6]
           [0 0 1 1 0 0 0 0 0 0]
     TEST: [3 3 3 4 7 8 8]
           [1 1 1 1 0 0 0]

    Notes
    -----
    Randomized CV splitters may return different results for each call of
    split. You can make the results identical by setting `random_state`
    to an integer.

    See also
    --------
    RepeatedStratifiedKFold: Repeats Stratified K-Fold n times.
    """

    def __init__(self, n_splits=5, n_repeats=10, random_state=None):
        super().__init__(StratifiedGroupKFold, n_splits=n_splits,
                         n_repeats=n_repeats, random_state=random_state)

@hermidalc 때때로 이것을 되돌아보면서 우리가 무엇을 해결했는지 상당히 혼란스럽습니다. (안타깝게도 제 시간은 예전 같지 않습니다!) scikit-learn에 포함시킬 것을 권장할 만한 아이디어를 알려주실 수 있습니까?

@hermidalc 때때로 이것을 되돌아보면서 우리가 무엇을 해결했는지 상당히 혼란스럽습니다. (안타깝게도 제 시간은 예전 같지 않습니다!) scikit-learn에 포함시킬 것을 권장할 만한 아이디어를 알려주실 수 있습니까?

#15239에서 했던 것보다 더 나은 구현을 하고 싶었습니다. 해당 PR의 구현은 작동하지만 논리를 간단하게 만들기 위해 그룹을 계층화하지만 이것이 이상적이지는 않습니다.

그래서 위에서 내가 한 것은(jakubwasikowski의 @mrunibe 및 kaggle 덕분에) 샘플을 계층화하는 StratifiedGroupKFold 의 더 나은 구현입니다. 더 나은 StratifiedGroupShuffleSplit 를 수행하기 위해 동일한 논리를 이식하고 싶습니다. 그러면 준비가 됩니다. 이전 구현을 대체하기 위해 새 코드를 #15239에 넣습니다.

미완성인 PR에 대해 사과드립니다. 박사 학위를 받는 중이므로 시간이 없습니다!

구현을 제공 해주신 @hermidalc 와 @mrunibe 에게 감사드립니다. 또한 클래스 불균형이 심하고 주제당 샘플 수가 매우 다양한 의료 데이터를 처리하기 위한 StratifiedGroupKFold 방법을 찾고 있습니다. GroupKFold 자체적으로 하나의 클래스만 포함하는 훈련 데이터 하위 집합을 만듭니다.

더 나은 StratifiedGroupShuffleSplit을 수행하기 위해 동일한 논리를 이식하고 싶습니다. 그러면 준비가 됩니다.

StratifiedGroupShuffleSplit StratifiedGroupKFold 병합을 확실히 고려할 수 있습니다.

미완성인 PR에 대해 사과드립니다. 박사 학위를 받는 중이므로 시간이 없습니다!

완료 지원을 원하시면 저희에게 알려주십시오!

그리고 박사 과정에 행운을 빕니다

다음은 @mrunibe 에서 제공한 코드를 사용하여 StratifiedGroupKFold 및 RepeatedStratifiedGroupKFold 의 본격적인 버전입니다. 이 코드는 몇 가지를 더욱 단순화하고 변경했습니다. 이 클래스는 또한 동일한 유형의 다른 sklearn CV 클래스가 수행되는 방식의 설계를 따릅니다.

이것을 시도하는 것이 가능합니까? 다양한 종속성 중 일부를 잘라내어 붙여넣으려고 했지만 끝이 없었습니다. 내 프로젝트에서 이 수업을 시도해 보고 싶습니다. 지금 가능한 방법이 있는지 확인하려고 합니다.

@hermidalc 박사 과정이 성공적이기를 바랍니다!
Geosciences에서 제 박사 학위 작업에는 그룹 제어와 함께 이 계층화 기능이 필요하기 때문에 이 구현이 완료되는 것을 보기를 고대하고 있습니다. 내 프로젝트에서 수동으로 분할하는 아이디어를 구현하는 데 몇 시간을 보냈습니다. 하지만 같은 이유로 그만뒀는데...박사과정. 그래서 박사 과정이 어떻게 사람의 시간을 괴롭힐 수 있는지 완전히 이해할 수 있습니다. LOL 압력이 없습니다. 지금은 GroupShuffleSplit을 대안으로 사용합니다.

건배

@bfeeny @dispink 위에서 작성한 두 클래스를 사용하는 것은 매우 쉽습니다. 다음을 사용하여 split.py 와 같은 파일을 만듭니다. 그런 다음 스크립트가 split.py 와 동일한 디렉토리에 있으면 사용자 코드에서 from split import StratifiedGroupKFold, RepeatedStratifiedGroupKFold 를 가져오기만 하면 됩니다.

from collections import Counter, defaultdict

import numpy as np

from sklearn.model_selection._split import _BaseKFold, _RepeatedSplits
from sklearn.utils.validation import check_random_state


class StratifiedGroupKFold(_BaseKFold):
    """Stratified K-Folds iterator variant with non-overlapping groups.

    This cross-validation object is a variation of StratifiedKFold that returns
    stratified folds with non-overlapping groups. The folds are made by
    preserving the percentage of samples for each class.

    The same group will not appear in two different folds (the number of
    distinct groups has to be at least equal to the number of folds).

    The difference between GroupKFold and StratifiedGroupKFold is that
    the former attempts to create balanced folds such that the number of
    distinct groups is approximately the same in each fold, whereas
    StratifiedGroupKFold attempts to create folds which preserve the
    percentage of samples for each class.

    Read more in the :ref:`User Guide <cross_validation>`.

    Parameters
    ----------
    n_splits : int, default=5
        Number of folds. Must be at least 2.

    shuffle : bool, default=False
        Whether to shuffle each class's samples before splitting into batches.
        Note that the samples within each split will not be shuffled.

    random_state : int or RandomState instance, default=None
        When `shuffle` is True, `random_state` affects the ordering of the
        indices, which controls the randomness of each fold for each class.
        Otherwise, leave `random_state` as `None`.
        Pass an int for reproducible output across multiple function calls.
        See :term:`Glossary <random_state>`.

    Examples
    --------
    >>> import numpy as np
    >>> from sklearn.model_selection import StratifiedGroupKFold
    >>> X = np.ones((17, 2))
    >>> y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    >>> groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8])
    >>> cv = StratifiedGroupKFold(n_splits=3)
    >>> for train_idxs, test_idxs in cv.split(X, y, groups):
    ...     print("TRAIN:", groups[train_idxs])
    ...     print("      ", y[train_idxs])
    ...     print(" TEST:", groups[test_idxs])
    ...     print("      ", y[test_idxs])
    TRAIN: [2 2 4 5 5 5 5 6 6 7]
           [1 1 1 0 0 0 0 0 0 0]
     TEST: [1 1 3 3 3 8 8]
           [0 0 1 1 1 0 0]
    TRAIN: [1 1 3 3 3 4 5 5 5 5 8 8]
           [0 0 1 1 1 1 0 0 0 0 0 0]
     TEST: [2 2 6 6 7]
           [1 1 0 0 0]
    TRAIN: [1 1 2 2 3 3 3 6 6 7 8 8]
           [0 0 1 1 1 1 1 0 0 0 0 0]
     TEST: [4 5 5 5 5]
           [1 0 0 0 0]

    See also
    --------
    StratifiedKFold: Takes class information into account to build folds which
        retain class distributions (for binary or multiclass classification
        tasks).

    GroupKFold: K-fold iterator variant with non-overlapping groups.
    """

    def __init__(self, n_splits=5, shuffle=False, random_state=None):
        super().__init__(n_splits=n_splits, shuffle=shuffle,
                         random_state=random_state)

    # Implementation based on this kaggle kernel:
    # https://www.kaggle.com/jakubwasikowski/stratified-group-k-fold-cross-validation
    def _iter_test_indices(self, X, y, groups):
        labels_num = np.max(y) + 1
        y_counts_per_group = defaultdict(lambda: np.zeros(labels_num))
        y_distr = Counter()
        for label, group in zip(y, groups):
            y_counts_per_group[group][label] += 1
            y_distr[label] += 1

        y_counts_per_fold = defaultdict(lambda: np.zeros(labels_num))
        groups_per_fold = defaultdict(set)

        groups_and_y_counts = list(y_counts_per_group.items())
        rng = check_random_state(self.random_state)
        if self.shuffle:
            rng.shuffle(groups_and_y_counts)

        for group, y_counts in sorted(groups_and_y_counts,
                                      key=lambda x: -np.std(x[1])):
            best_fold = None
            min_eval = None
            for i in range(self.n_splits):
                y_counts_per_fold[i] += y_counts
                std_per_label = []
                for label in range(labels_num):
                    std_per_label.append(np.std(
                        [y_counts_per_fold[j][label] / y_distr[label]
                         for j in range(self.n_splits)]))
                y_counts_per_fold[i] -= y_counts
                fold_eval = np.mean(std_per_label)
                if min_eval is None or fold_eval < min_eval:
                    min_eval = fold_eval
                    best_fold = i
            y_counts_per_fold[best_fold] += y_counts
            groups_per_fold[best_fold].add(group)

        for i in range(self.n_splits):
            test_indices = [idx for idx, group in enumerate(groups)
                            if group in groups_per_fold[i]]
            yield test_indices


class RepeatedStratifiedGroupKFold(_RepeatedSplits):
    """Repeated Stratified K-Fold cross validator.

    Repeats Stratified K-Fold with non-overlapping groups n times with
    different randomization in each repetition.

    Read more in the :ref:`User Guide <cross_validation>`.

    Parameters
    ----------
    n_splits : int, default=5
        Number of folds. Must be at least 2.

    n_repeats : int, default=10
        Number of times cross-validator needs to be repeated.

    random_state : int or RandomState instance, default=None
        Controls the generation of the random states for each repetition.
        Pass an int for reproducible output across multiple function calls.
        See :term:`Glossary <random_state>`.

    Examples
    --------
    >>> import numpy as np
    >>> from sklearn.model_selection import RepeatedStratifiedGroupKFold
    >>> X = np.ones((17, 2))
    >>> y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    >>> groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8])
    >>> cv = RepeatedStratifiedGroupKFold(n_splits=2, n_repeats=2,
    ...                                   random_state=36851234)
    >>> for train_index, test_index in cv.split(X, y, groups):
    ...     print("TRAIN:", groups[train_idxs])
    ...     print("      ", y[train_idxs])
    ...     print(" TEST:", groups[test_idxs])
    ...     print("      ", y[test_idxs])
    TRAIN: [2 2 4 5 5 5 5 8 8]
           [1 1 1 0 0 0 0 0 0]
     TEST: [1 1 3 3 3 6 6 7]
           [0 0 1 1 1 0 0 0]
    TRAIN: [1 1 3 3 3 6 6 7]
           [0 0 1 1 1 0 0 0]
     TEST: [2 2 4 5 5 5 5 8 8]
           [1 1 1 0 0 0 0 0 0]
    TRAIN: [3 3 3 4 7 8 8]
           [1 1 1 1 0 0 0]
     TEST: [1 1 2 2 5 5 5 5 6 6]
           [0 0 1 1 0 0 0 0 0 0]
    TRAIN: [1 1 2 2 5 5 5 5 6 6]
           [0 0 1 1 0 0 0 0 0 0]
     TEST: [3 3 3 4 7 8 8]
           [1 1 1 1 0 0 0]

    Notes
    -----
    Randomized CV splitters may return different results for each call of
    split. You can make the results identical by setting `random_state`
    to an integer.

    See also
    --------
    RepeatedStratifiedKFold: Repeats Stratified K-Fold n times.
    """

    def __init__(self, n_splits=5, n_repeats=10, random_state=None):
        super().__init__(StratifiedGroupKFold, n_splits=n_splits,
                         n_repeats=n_repeats, random_state=random_state)

@hermidalc 긍정적인 답변 감사합니다!
설명해주신대로 빠르게 채택합니다. 그러나 훈련 또는 테스트 세트에 데이터만 있는 분할만 가져올 수 있습니다. 코드 설명을 이해하는 한 훈련 세트와 테스트 세트 사이의 비율을 지정하는 매개 변수가 없습니까?
계층화, 그룹 제어 및 데이터 세트 비율 간의 충돌이라는 것을 알고 있습니다. 그래서 계속하기를 포기했습니다... 하지만 여전히 해결해야 할 타협점을 찾을 수 있습니다.

진정으로

@hermidalc 긍정적인 답변 감사합니다!
설명해주신대로 빠르게 채택합니다. 그러나 훈련 또는 테스트 세트에 데이터만 있는 분할만 가져올 수 있습니다. 코드 설명을 이해하는 한 훈련 세트와 테스트 세트 사이의 비율을 지정하는 매개 변수가 없습니까?
계층화, 그룹 제어 및 데이터 세트 비율 간의 충돌이라는 것을 알고 있습니다. 그래서 계속하기를 포기했습니다... 하지만 여전히 해결해야 할 타협점을 찾을 수 있습니다.

테스트하기 위해 split.py 를 만들고 이 예제를 ipython에서 실행했는데 작동합니다. 나는 오랫동안 내 작업에서 이러한 사용자 정의 CV 반복자를 사용해 왔으며 문제가 없습니다. BTW 0.23.x가 아닌 scikit-learn 0.22.2 를 사용하고 있으므로 이것이 문제의 원인인지 확실하지 않습니다. 아래에서 이 예를 실행하고 재현할 수 있는지 확인해 주시겠습니까? 가능하다면 작업에 y 및 groups 가 포함된 것일 수 있습니다.

In [6]: import numpy as np 
   ...: from split import StratifiedGroupKFold 
   ...:  
   ...: X = np.ones((17, 2)) 
   ...: y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]) 
   ...: groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8]) 
   ...: cv = StratifiedGroupKFold(n_splits=3, shuffle=True, random_state=777) 
   ...: for train_idxs, test_idxs in cv.split(X, y, groups): 
   ...:     print("TRAIN:", groups[train_idxs]) 
   ...:     print("      ", y[train_idxs]) 
   ...:     print(" TEST:", groups[test_idxs]) 
   ...:     print("      ", y[test_idxs]) 
   ...:                                                                                                                                                                                                    
TRAIN: [2 2 4 5 5 5 5 6 6 7]
       [1 1 1 0 0 0 0 0 0 0]
 TEST: [1 1 3 3 3 8 8]
       [0 0 1 1 1 0 0]
TRAIN: [1 1 3 3 3 4 5 5 5 5 8 8]
       [0 0 1 1 1 1 0 0 0 0 0 0]
 TEST: [2 2 6 6 7]
       [1 1 0 0 0]
TRAIN: [1 1 2 2 3 3 3 6 6 7 8 8]
       [0 0 1 1 1 1 1 0 0 0 0 0]
 TEST: [4 5 5 5 5]
       [1 0 0 0 0]

@hermidalc 이 기능에 정기적인 관심이 있는 것 같으며 우리는
당신이 신경 쓰지 않는다면 끝내줄 사람을 찾을 수 있을 것입니다.

@hermidalc '동일한 그룹의 모든 샘플에 동일한 클래스 레이블이 있는지 확인해야 합니다.' 분명히 그것이 문제입니다. 같은 그룹의 샘플이 같은 클래스를 공유하지 않습니다. 음... 개발의 또 다른 지점인 것 같습니다.
어쨌든 대단히 감사합니다.

@hermidalc '동일한 그룹의 모든 샘플에 동일한 클래스 레이블이 있는지 확인해야 합니다.' 분명히 그것이 문제입니다. 같은 그룹의 샘플이 같은 클래스를 공유하지 않습니다. 음... 개발의 또 다른 지점인 것 같습니다.
어쨌든 대단히 감사합니다.

예, 이것은 여기의 다양한 스레드에서 논의되었습니다. 유용한 또 다른 더 복잡한 사용 사례이지만 나와 같은 많은 사람들은 현재 해당 사용 사례가 필요하지 않지만 그룹을 함께 유지하면서 샘플을 계층화하는 무언가가 필요합니다. 위 코드의 요구 사항은 각 그룹의 모든 샘플이 동일한 클래스에 속해야 한다는 것입니다.

사실 @dispink 제가 틀렸습니다. 이 알고리즘은 그룹의 모든 구성원이 같은 클래스에 속할 것을 요구하지 않습니다. 예를 들어:

In [2]: X = np.ones((17, 2)) 
   ...: y =      np.array([0, 2, 1, 1, 2, 0, 0, 1, 2, 1, 1, 1, 0, 2, 0, 1, 0]) 
   ...: groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8]) 
   ...: cv = StratifiedGroupKFold(n_splits=3) 
   ...: for train_idxs, test_idxs in cv.split(X, y, groups): 
   ...:     print("TRAIN:", groups[train_idxs]) 
   ...:     print("      ", y[train_idxs]) 
   ...:     print(" TEST:", groups[test_idxs]) 
   ...:     print("      ", y[test_idxs]) 
   ...:                                                                                                                                                                                                    
TRAIN: [1 1 2 2 3 3 3 4 8 8]
       [0 2 1 1 2 0 0 1 1 0]
 TEST: [5 5 5 5 6 6 7]
       [2 1 1 1 0 2 0]
TRAIN: [1 1 4 5 5 5 5 6 6 7 8 8]
       [0 2 1 2 1 1 1 0 2 0 1 0]
 TEST: [2 2 3 3 3]
       [1 1 2 0 0]
TRAIN: [2 2 3 3 3 5 5 5 5 6 6 7]
       [1 1 2 0 0 2 1 1 1 0 2 0]
 TEST: [1 1 4 8 8]
       [0 2 1 1 0]

따라서 스크린샷으로도 데이터 레이아웃이 무엇인지, 어떤 일이 일어날지 제대로 볼 수 없기 때문에 데이터에 무슨 일이 일어나고 있는지 잘 모르겠습니다. scikit-learn 버전 문제(저는 0.22.2를 사용하고 있기 때문에)가 아닌지 확인하기 위해 여기에서 보여준 예제를 먼저 재현하고 재현할 수 있다면 작은 부분부터 시작하는 것이 좋습니다. 데이터를 가져와 테스트합니다. ~104k 샘플을 사용하는 것은 문제를 해결하기 어렵습니다.

@hermidalc 답변 감사합니다!
실제로 위의 결과를 재현할 수 있으므로 지금은 더 작은 데이터로 문제를 해결하고 있습니다.

+1

내가 이 문제를 골라도 상관없나요?
https://github.com/scikit-learn/scikit-learn/issues/13621#issuecomment -600894432와 함께 #15239에 이미 구현이 있고 단위 테스트만 남은 것 같습니다.