Scikit-learn: स्तरीकृत समूहकेफोल्ड

@TomDLT @NicolasHug आप क्या सोचते हैं?

सिद्धांत रूप में दिलचस्प हो सकता है, लेकिन मुझे यकीन नहीं है कि यह व्यवहार में कितना उपयोगी होगा। हम निश्चित रूप से इस मुद्दे को खुला रख सकते हैं और देख सकते हैं कि कितने लोग इस सुविधा का अनुरोध करते हैं

क्या आप मानते हैं कि प्रत्येक समूह एक ही कक्षा में है?

यह भी देखें #9413

@jnothman हाँ, मेरे मन में भी कुछ ऐसा ही था। हालांकि, मैं देखता हूं कि पुल अनुरोध अभी भी खुला है। मेरा मतलब था कि एक समूह को सिलवटों में दोहराया नहीं जाएगा। यदि हमारे पास समूहों के रूप में आईडी है तो एक ही आईडी कई तहों में नहीं होगी

मैं समझता हूं कि यह RFECV के उपयोग के लिए प्रासंगिक है।
वर्तमान में यह डिफ़ॉल्ट रूप से StratifiedKFold cv का उपयोग करता है। इसका फिट () भी समूह लेता है=
हालांकि: ऐसा प्रतीत होता है कि फिट() निष्पादित करते समय समूहों का सम्मान नहीं किया जाता है। कोई चेतावनी नहीं (एक बग माना जा सकता है)।

इंटर-रिकॉर्ड निर्भरता के साथ काफी असंतुलित डेटासेट के लिए समूहीकरण और स्तरीकरण उपयोगी हैं
(मेरे मामले में, एक ही व्यक्ति के कई रिकॉर्ड हैं, लेकिन अभी भी बड़ी संख्या में समूह हैं = विभाजन की संख्या के सापेक्ष लोग; मुझे लगता है कि व्यावहारिक समस्याएं होंगी क्योंकि अल्पसंख्यक वर्ग में अद्वितीय समूहों की संख्या कहीं भी हो जाती है विभाजन की संख्या)।

तो: +1!

यह निश्चित रूप से उपयोगी होगा। उदाहरण के लिए, अत्यधिक असंतुलित समय-श्रृंखला चिकित्सा डेटा के साथ काम करना, रोगियों को अलग रखना लेकिन (लगभग) असंतुलित वर्ग को प्रत्येक तह में संतुलित करना।

मैंने यह भी पाया है कि स्ट्रैटिफाइडकेफोल्ड समूहों को एक पैरामीटर के रूप में लेता है लेकिन उनके अनुसार समूह नहीं करता है, शायद इसे ध्वजांकित किया जाना चाहिए।

इस सुविधा का एक और अच्छा उपयोग वित्तीय डेटा होगा, जो आमतौर पर बहुत असंतुलित होता है। मेरे मामले में, मेरे पास एक ही इकाई के लिए कई रिकॉर्ड्स के साथ अत्यधिक असंतुलित डेटासेट है (समय में केवल अलग-अलग बिंदु)। हम रिसाव से बचने के लिए GroupKFold करना चाहते हैं, लेकिन साथ ही स्तरीकरण भी करना चाहते हैं क्योंकि उच्च असंतुलन के कारण, हम बहुत कम या कोई सकारात्मक समूह वाले समूहों के साथ समाप्त हो सकते हैं।

यह भी देखें #14524 मुझे लगता है?

स्ट्रेटिफाइड ग्रुपशफलस्प्लिट और ग्रुपकेफोल्ड के लिए एक अन्य उपयोग केस जैविक "दोहराए गए उपाय" डिजाइन हैं, जहां आपके पास प्रति विषय या अन्य मूल जैविक इकाई के कई नमूने हैं। जीव विज्ञान में कई वास्तविक दुनिया के डेटासेट में भी वर्ग असंतुलन है। नमूनों के प्रत्येक समूह में एक ही वर्ग होता है। इसलिए समूहों को एक साथ रखना और रखना महत्वपूर्ण है।

विवरण

वर्तमान में sklearn में एक स्तरीकृत समूह kfold विशेषता नहीं है। या तो हम स्तरीकरण का उपयोग कर सकते हैं या हम समूह kfold का उपयोग कर सकते हैं। हालांकि, दोनों का होना अच्छा रहेगा।

अगर हम इसे लेने का फैसला करते हैं तो मैं इसे लागू करना चाहूंगा।

नमस्ते, मुझे लगता है कि यह दवा एमएल के लिए काफी उपयोगी होगा। क्या यह पहले से ही लागू है?

@amueller क्या आपको लगता है कि हमें इसे लागू करना चाहिए, यह देखते हुए कि लोग इसमें रुचि रखते हैं?

मुझे भी बहुत दिलचस्पी है ... यह स्पेक्ट्रोस्कोपी में वास्तव में उपयोगी होगा जब आपके पास अपने प्रत्येक नमूने के लिए कई प्रतिकृति उपाय होंगे, उन्हें वास्तव में क्रॉस-सत्यापन के दौरान एक ही तह में रहने की आवश्यकता होती है। और यदि आपके पास कई असंतुलित वर्ग हैं जिन्हें आप वर्गीकृत करने का प्रयास कर रहे हैं तो आप वास्तव में स्तरीकरण सुविधा का भी उपयोग करना चाहते हैं। इसलिए मैं इसे भी वोट देता हूं! क्षमा करें, मैं विकास में भाग लेने के लिए पर्याप्त नहीं हूं, लेकिन जो लोग इसमें भाग लेंगे उनके लिए आप सुनिश्चित हो सकते हैं कि इसका उपयोग किया जाएगा :-)
सभी टीम के लिए अंगूठे ऊपर। धन्यवाद!

कृपया इस थ्रेड में संदर्भित मुद्दों और पीआर को देखें क्योंकि कम से कम StratifiedGroupKFold पर काम करने का प्रयास किया गया है। मैंने पहले ही एक StratifiedGroupShuffleSplit #15239 किया है, जिसे केवल परीक्षणों की आवश्यकता है लेकिन मैंने पहले से ही अपने काम के लिए काफी उपयोग किया है।

मुझे लगता है कि हमें इसे लागू करना चाहिए, लेकिन मुझे लगता है कि मैं अभी भी नहीं जानता कि हम वास्तव में क्या चाहते हैं। @hermidalc पर प्रतिबंध है कि एक ही समूह के सदस्य एक ही वर्ग के होने चाहिए। यह सामान्य मामला नहीं है, है ना?

यह अच्छा होगा यदि रुचि रखने वाले लोग अपने उपयोग-मामले का वर्णन कर सकें और वे वास्तव में इससे क्या चाहते हैं।

#15239 #14524 और #9413 हैं जो मुझे याद है कि सभी के अलग-अलग शब्दार्थ हैं।

@amueller आपके साथ पूरी तरह से सहमत है, मैंने आज कुछ घंटे बिताए विभिन्न संस्करणों (# 15239 # 14524 और # 9413) के बीच कुछ ढूंढ रहे हैं, लेकिन वास्तव में यह नहीं समझ सका कि इनमें से कोई भी मेरी ज़रूरत के अनुरूप होगा या नहीं। तो यहाँ मेरा उपयोग मामला है अगर यह मदद कर सकता है:
मेरे पास 1000 नमूने हैं। प्रत्येक नमूने को एनआईआर स्पेक्ट्रोमीटर के साथ 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 मैं शब्दावली से बहुत परिचित नहीं हूं, लेकिन विकिपीडिया से ऐसा लगता है कि "दोहराया माप डिजाइन" का मतलब यह नहीं है कि एक ही समूह एक ही वर्ग के भीतर होना चाहिए क्योंकि यह कहता है "एक क्रॉसओवर परीक्षण में दोहराए गए उपायों का डिज़ाइन होता है जिसमें प्रत्येक रोगी को दो या अधिक उपचारों के अनुक्रम के लिए नियत किया जाता है, जिनमें से एक मानक उपचार या प्लेसीबो हो सकता है।"
इसे एक एमएल सेटिंग से संबंधित करते हुए, आप या तो माप से यह अनुमान लगाने की कोशिश कर सकते हैं कि क्या किसी व्यक्ति ने अभी-अभी उपचार या प्लेसिबो प्राप्त किया है, या आप उपचार के परिणाम की भविष्यवाणी करने का प्रयास कर सकते हैं।
उनमें से किसी के लिए एक ही व्यक्ति के लिए वर्ग बदल सकता है, है ना?

नाम चाहे जो भी हो, मुझे ऐसा लगता है कि आप दोनों के पास एक ही उपयोग का मामला है, जबकि मैं एक ऐसे मामले के बारे में सोच रहा था जो क्रॉसओवर अध्ययन में वर्णित है। या शायद थोड़ा और सरल: आप समय के साथ एक रोगी बीमार हो सकते हैं (या बेहतर हो सकते हैं), इसलिए रोगी के लिए परिणाम बदल सकता है।

असल में आप जिस विकिपीडिया लेख से लिंक करते हैं वह स्पष्ट रूप से कहता है "अनुदैर्ध्य विश्लेषण-दोहराए गए माप डिज़ाइन शोधकर्ताओं को यह निगरानी करने की अनुमति देते हैं कि प्रतिभागी समय के साथ कैसे बदलते हैं, दोनों लंबी और छोटी अवधि की परिस्थितियों में।", इसलिए मुझे लगता है कि इसका मतलब है कि कक्षा को बदलना शामिल है।
यदि कोई अन्य शब्द है जिसका अर्थ है कि माप उन्हीं परिस्थितियों में किया जाता है तो हम उस शब्द का उपयोग कर सकते हैं?

@amueller हाँ आप सही कह रहे हैं, मुझे एहसास हुआ कि मैंने ऊपर गलत लिखा है जहाँ मेरा मतलब इस डिज़ाइन के अपने उपयोग के मामलों में सामान्य रूप से इस उपयोग के मामले में नहीं है।

दोहराए जाने वाले उपायों के कई विस्तृत प्रकार हो सकते हैं, हालांकि दो प्रकारों में मुझे StratifiedGroupShuffleSplit की आवश्यकता होती है, समूह के भीतर समान वर्ग प्रतिबंध (उपचार प्रतिक्रिया की भविष्यवाणी करते समय उपचार से पहले और बाद में अनुदैर्ध्य नमूनाकरण, कई पूर्व-उपचार उपचार की प्रतिक्रिया की भविष्यवाणी करते समय शरीर के विभिन्न स्थानों पर प्रति विषय नमूने)।

मुझे तुरंत कुछ चाहिए था जो काम करता है इसलिए इसे दूसरों के उपयोग के लिए और स्केलेर पर कुछ शुरू करने के लिए वहां रखना चाहता था, साथ ही अगर मुझे गलत नहीं लगता है तो समूह वर्ग लेबल के भीतर स्तरीकरण तर्क को डिजाइन करना अधिक जटिल हो सकता है।

@amueller हाँ हमेशा। भविष्यवाणी में डिवाइस की अंतःपरिवर्तनीयता को शामिल करने के लिए वे एक ही माप की प्रतिकृति हैं।

@hermidalc हाँ, यह मामला बहुत आसान है। यदि यह एक सामान्य आवश्यकता है, तो हमें इसे जोड़ने में प्रसन्नता हो रही है। हमें केवल यह सुनिश्चित करना चाहिए कि नाम से यह कुछ हद तक स्पष्ट है कि यह क्या करता है, और हमें इस बारे में सोचना चाहिए कि क्या ये दोनों संस्करण एक ही कक्षा में रहने चाहिए।

ऐसा करने के लिए StratifiedKFold बनाना काफी आसान होना चाहिए। दो विकल्प हैं: सुनिश्चित करें कि प्रत्येक तह में समान संख्या में नमूने हैं, या सुनिश्चित करें कि प्रत्येक तह में समान संख्या में समूह हैं।
दूसरा करने के लिए छोटा है (केवल प्रत्येक समूह का नाटक करके एक बिंदु है और StratifiedKFold पर जा रहा है)। आप अपने पीआर में यही करते हैं, ऐसा लगता है।

GroupKFold मुझे लगता है कि सबसे पहले सबसे छोटी तह में जोड़कर उन दोनों को ह्युरिस्टिक रूप से बंद कर देता है। मुझे यकीन नहीं है कि यह कैसे स्तरीकृत मामले में अनुवाद करेगा, इसलिए मैं आपके दृष्टिकोण का उपयोग करके खुश हूं।

क्या हमें उसी पीआर में GroupStratifiedKFold भी जोड़ना चाहिए? या इसे बाद के लिए छोड़ दें?
अन्य पीआर के लक्ष्य थोड़े अलग हैं। यह अच्छा होगा यदि कोई यह लिख सके कि विभिन्न उपयोग-मामले क्या हैं (शायद मेरे पास अभी समय नहीं है)।

+1 समूह की बाधा को अलग से संभालने के लिए जहां सभी नमूनों की एक ही कक्षा होती है।

@hermidalc हाँ, यह मामला बहुत आसान है। यदि यह एक सामान्य आवश्यकता है, तो हमें इसे जोड़ने में प्रसन्नता हो रही है। हमें केवल यह सुनिश्चित करना चाहिए कि नाम से यह कुछ हद तक स्पष्ट है कि यह क्या करता है, और हमें इस बारे में सोचना चाहिए कि क्या ये दोनों संस्करण एक ही कक्षा में रहने चाहिए।

मैं इसे पूरी तरह से नहीं समझ रहा हूं, एक StratifiedGroupShuffleSplit और StratifiedGroupKFold जहां आप प्रत्येक समूह के सदस्य अलग-अलग वर्गों के हो सकते हैं, जब उपयोगकर्ता सभी समूह सदस्यों को निर्दिष्ट करता है तो सटीक समान विभाजन व्यवहार होना चाहिए एक ही वर्ग के। बस बाद में कब आंतरिक सुधार कर सकते हैं और मौजूदा व्यवहार वही होगा?

दूसरा करने के लिए छोटा है (केवल प्रत्येक समूह का नाटक करके एक बिंदु है और StratifiedKFold पर जा रहा है)। आप अपने पीआर में यही करते हैं, ऐसा लगता है।

GroupKFold मुझे लगता है कि सबसे पहले सबसे छोटी तह में जोड़कर उन दोनों को ह्युरिस्टिक रूप से बंद कर देता है। मुझे यकीन नहीं है कि यह कैसे स्तरीकृत मामले में अनुवाद करेगा, इसलिए मैं आपके दृष्टिकोण का उपयोग करके खुश हूं।

क्या हमें उसी पीआर में GroupStratifiedKFold भी जोड़ना चाहिए? या इसे बाद के लिए छोड़ दें?
अन्य पीआर के लक्ष्य थोड़े अलग हैं। यह अच्छा होगा यदि कोई यह लिख सके कि विभिन्न उपयोग-मामले क्या हैं (शायद मेरे पास अभी समय नहीं है)।

मैं "प्रत्येक समूह एकल नमूना" दृष्टिकोण का उपयोग करके StatifiedGroupKFold जोड़ूंगा जिसका मैंने उपयोग किया था।

यह अच्छा होगा यदि रुचि रखने वाले लोग अपने उपयोग-मामले का वर्णन कर सकें और वे वास्तव में इससे क्या चाहते हैं।

जब आप बार-बार उपाय करते हैं तो दवा और जीव विज्ञान में बहुत ही सामान्य उपयोग-मामला होता है।
एक उदाहरण: मान लें कि आप किसी बीमारी को वर्गीकृत करना चाहते हैं, जैसे अल्जाइमर रोग (एडी) बनाम एमआर छवियों से स्वस्थ नियंत्रण। एक ही विषय के लिए, आपके पास कई स्कैन हो सकते हैं (अनुवर्ती सत्रों या अनुदैर्ध्य डेटा से)। मान लें कि आपके पास कुल 1000 विषय हैं, उनमें से 200 का निदान AD (असंतुलित वर्ग) से किया जा रहा है। अधिकांश विषयों में एक स्कैन होता है, लेकिन उनमें से कुछ के लिए 2 या 3 छवियां उपलब्ध होती हैं। क्लासिफायरियर का प्रशिक्षण/परीक्षण करते समय, आप यह सुनिश्चित करना चाहते हैं कि डेटा रिसाव से बचने के लिए एक ही विषय की छवियां हमेशा एक ही तह में हों।
इसके लिए स्ट्रैटिफाइडग्रुपकेफोल्ड का उपयोग करना सबसे अच्छा है: वर्ग असंतुलन के लिए खाते में स्तरीकरण करें लेकिन समूह की बाधा के साथ कि एक विषय अलग-अलग तहों में प्रकट नहीं होना चाहिए।
एनबी: इसे दोहराने योग्य बनाना अच्छा होगा।

कागल-कर्नेल से प्रेरित एक उदाहरण कार्यान्वयन के नीचे।

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()

स्तरीकृत GroupKfold के लिए +1। मैं samrt घड़ी से सेंसर लेकर वरिष्ठों के गिरने का पता लगाने की कोशिश कर रहा हूं। चूंकि हमारे पास बहुत अधिक गिरावट डेटा नहीं है - हम अलग-अलग घड़ियों के साथ सिमुलेशन करते हैं जिन्हें अलग-अलग वर्ग मिलते हैं। मैं इसे प्रशिक्षित करने से पहले डेटा में वृद्धि भी करता हूं। प्रत्येक डेटा बिंदु से मैं 9 अंक बनाता हूं- और यह एक समूह है। यह महत्वपूर्ण है कि एक समूह ट्रेन और परीक्षण दोनों में नहीं होगा जैसा कि समझाया गया है

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

वहाँ वैसे भी सामान्यीकृत करने के लिए है कि बहुलेबल परिदृश्य के लिए (Multilabel_
स्तरीकृतग्रुपकेफोल्ड)?

इसके लिए +1। हम स्पैम के लिए उपयोगकर्ता खातों का विश्लेषण कर रहे हैं, इसलिए हम उपयोगकर्ता द्वारा समूह बनाना चाहते हैं, लेकिन स्तरीकरण भी करना चाहते हैं क्योंकि स्पैम अपेक्षाकृत कम घटना है। हमारे उपयोग के मामले में, कोई भी उपयोगकर्ता जो एक बार स्पैम करता है, उसे सभी डेटा में स्पैमर के रूप में फ़्लैग किया जाता है, इसलिए समूह के सदस्य के पास हमेशा एक ही लेबल होगा।

दस्तावेज़ीकरण को फ्रेम करने के लिए क्लासिक उपयोग केस प्रदान करने के लिए धन्यवाद,
@ फिलिप-iv!

मैंने अपने समान पीआर #15239 में StratifiedGroupShuffleSplit के रूप में $ StratifiedGroupKFold कार्यान्वयन जोड़ा।

यद्यपि आप पीआर में देख सकते हैं कि दोनों के लिए तर्क 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 के पूर्ण संस्करण दिए गए हैं, जिन्हें मैंने और सरल बनाया और कुछ चीजों को बदल दिया। ये कक्षाएं इस डिजाइन का भी पालन करती हैं कि उसी प्रकार के अन्य स्केलेर सीवी कक्षाएं कैसे की जाती हैं।

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 मैं समय-समय पर इस पर पीछे मुड़कर देखने पर काफी उलझन में हूं कि हमने क्या हल किया है। (दुर्भाग्य से मेरा समय वह नहीं है जो पहले हुआ करता था!) ​​क्या आप मुझे इस बात का अंदाजा दे सकते हैं कि आप स्किकिट-लर्न में क्या शामिल करने की सलाह देंगे?

मैंने #15239 में जो किया उससे बेहतर कार्यान्वयन करना चाहता हूं। उस पीआर में कार्यान्वयन काम करता है लेकिन तर्क को सीधा करने के लिए समूहों पर स्तरीकरण करता है, हालांकि यह आदर्श नहीं है।

तो मैंने ऊपर जो किया (जकुबवासिकोव्स्की से @mrunibe और kaggle के लिए धन्यवाद) StratifiedGroupKFold का बेहतर कार्यान्वयन है जो नमूनों पर स्तरीकृत करता है। मैं बेहतर StratifiedGroupShuffleSplit करने के लिए उसी तर्क को पोर्ट करना चाहता हूं और फिर यह तैयार हो जाएगा। मैं पुराने कार्यान्वयन को बदलने के लिए नया कोड #15239 में डालूंगा।

मैं अपने पीआर के बारे में क्षमा चाहता हूं जो अधूरे हैं, मैं अपनी पीएचडी प्राप्त कर रहा हूं इसलिए मेरे पास कभी समय नहीं है!

कार्यान्वयन प्रदान करने के लिए @hermidalc और @mrunibe को धन्यवाद। मैं चिकित्सा डेटा से निपटने के लिए StratifiedGroupKFold विधि की भी तलाश कर रहा हूं जिसमें मजबूत वर्ग असंतुलन और प्रति विषय नमूनों की एक बहुत भिन्न संख्या है। GroupKFold अपने आप में केवल एक वर्ग वाले प्रशिक्षण डेटा उप-सेट बनाता है।

मैं बेहतर स्ट्रैटिफाइडग्रुपशफलस्प्लिट करने के लिए उसी तर्क को पोर्ट करना चाहता हूं और फिर यह तैयार हो जाएगा।

StratifiedGroupShuffleSplit तैयार होने से पहले हम निश्चित रूप से StratifiedGroupKFold को मर्ज करने पर विचार कर सकते हैं।

मैं अपने पीआर के बारे में क्षमा चाहता हूं जो अधूरे हैं, मैं अपनी पीएचडी प्राप्त कर रहा हूं इसलिए मेरे पास कभी समय नहीं है!

अगर आप इसे पूरा करने में सहायता चाहते हैं तो हमें बताएं!

और आपके पीएचडी कार्य के लिए शुभकामनाएँ

यहां @mrunibe कोड का उपयोग करके StratifiedGroupKFold और RepeatedStratifiedGroupKFold के पूर्ण संस्करण दिए गए हैं, जिन्हें मैंने और सरल बनाया और कुछ चीजों को बदल दिया। ये कक्षाएं इस डिजाइन का भी पालन करती हैं कि उसी प्रकार के अन्य स्केलेर सीवी कक्षाएं कैसे की जाती हैं।

क्या इसे आजमाना संभव है? मैंने कुछ विभिन्न निर्भरताओं के साथ कट और पेस्ट करने की कोशिश की लेकिन यह कभी खत्म नहीं हुआ। मैं इस कक्षा को अपने प्रोजेक्ट में आजमाना पसंद करूंगा। बस यह देखने की कोशिश कर रहा हूं कि ऐसा करने का कोई तरीका उपलब्ध है या नहीं।

@hermidalc आशा है कि आपका पीएचडी कार्य सफल हो गया है!
मैं इस कार्यान्वयन को देखने के लिए उत्सुक हूं क्योंकि भूविज्ञान में मेरे पीएचडी कार्य को समूह नियंत्रण के साथ इस स्तरीकरण सुविधा की आवश्यकता है। मैंने अपने प्रोजेक्ट पर मैन्युअल रूप से विभाजित करने के इस विचार को लागू करने में कुछ घंटे बिताए हैं। लेकिन मैंने उसी वजह से इसे खत्म करना छोड़ दिया...पीएचडी की प्रगति। इसलिए, मैं पूरी तरह से समझ सकता हूं कि कैसे पीएचडी का काम किसी व्यक्ति के समय को खराब कर सकता है। एलओएल कोई दबाव नहीं। अभी के लिए, मैं एक विकल्प के रूप में 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 में चलाया और यह काम करता है। मैं लंबे समय से अपने काम में इन कस्टम सीवी इटरेटर्स का उपयोग कर रहा हूं और उन्हें मेरी तरफ से कोई समस्या नहीं है। BTW मैं scikit-learn 0.22.2 0.23.x का उपयोग कर रहा हूं, इसलिए सुनिश्चित नहीं है कि यह समस्या का कारण है या नहीं। क्या आप कृपया नीचे इस उदाहरण को चलाने का प्रयास कर सकते हैं और देख सकते हैं कि क्या आप इसे पुन: पेश कर सकते हैं? यदि आप कर सकते हैं, तो यह आपके काम में 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]

इसलिए मुझे पूरा यकीन नहीं है कि आपके डेटा के साथ क्या हो रहा है, क्योंकि आपके स्क्रीनशॉट से भी आप वास्तव में यह नहीं देख सकते हैं कि आपका डेटा लेआउट क्या है और क्या हो सकता है। मेरा सुझाव है कि आप पहले उन उदाहरणों को पुन: पेश करें जिन्हें मैंने यहां दिखाया था ताकि यह सुनिश्चित हो सके कि यह एक विज्ञान-सीखने वाला संस्करण मुद्दा नहीं है (क्योंकि मैं 0.22.2 का उपयोग कर रहा हूं) और यदि आप इसे पुन: पेश कर सकते हैं तो मेरा सुझाव है कि आप अपने छोटे हिस्सों से शुरू करें डेटा और इसका परीक्षण करें। ~104k नमूनों का उपयोग करना समस्या निवारण के लिए कठिन है।

@hermidalc उत्तर के लिए धन्यवाद!
मैं वास्तव में उपरोक्त परिणाम को पुन: उत्पन्न कर सकता हूं, इसलिए मैं अब एक छोटे डेटा के साथ समस्या निवारण कर रहा हूं।

+1

किसी को भी बुरा लगता है अगर मैं इस मुद्दे को उठाऊं?
ऐसा लगता है कि #15239 https://github.com/scikit-learn/scikit-learn/issues/13621#issuecomment -600894432 के साथ पहले से ही एक कार्यान्वयन है और केवल यूनिट परीक्षण करना बाकी है।