Hdbscan: क्रैश जब allow_single_cluster का उपयोग क्लस्टर_चयन_एप्सिलॉन के साथ किया जाता है

को निर्मित 21 अप्रैल 2020 · 13टिप्पणियाँ · स्रोत: scikit-learn-contrib/hdbscan

जब मैं cluster_selection_epsilon=x का उपयोग करता हूं जहां x > 0 और allow_single_cluster=True एक साथ, HDBSCAN क्रैश हो जाता है।

मैं no_structure टॉय डेटासेट (नीचे की पंक्ति, वर्ग) को ठीक से प्राप्त करने का प्रयास करने के लिए उन दो विकल्पों का एक साथ उपयोग कर रहा हूं। मैं चाहता हूं कि वर्ग पूरी तरह से नीला हो जैसे डीबीएससीएएन इसे करता है। जब मैं केवल cluster_selection_epsilon का उपयोग करता हूं, तो उस वर्ग में कई क्लस्टर दिखाई देते हैं। जब मैं केवल allow_single_cluster=True का उपयोग करता हूं, तो उस वर्ग का हिस्सा ग्रे होता है। मुझे लगता है कि मैं केवल उन दोनों तर्कों का उपयोग करके वांछित परिणाम प्राप्त कर सकता हूं, लेकिन जब मैं ऐसा करता हूं तो एचडीबीएससीएएन दुर्घटनाग्रस्त हो जाता है।

कोड

import numpy as np
import hdbscan

if __name__ == '__main__':
    no_structure = np.random.rand(1500, 2)
    clusterer = hdbscan.HDBSCAN(min_cluster_size=15, cluster_selection_epsilon=3, allow_single_cluster=True)
    clusterer.fit(no_structure)

अपेक्षित् व्यवहार

बिना क्रैश हुए डेटा को क्लस्टर करने के लिए HDBSCAN। अधिमानतः, वर्णित अनुसार सभी बिंदुओं को वर्गाकार नीले रंग में रंगना।

वास्तविक व्यवहार

HDBSCAN निम्न ट्रेसबैक के साथ क्रैश हो जाता है:

Traceback (most recent call last):
  File "/home/home/PycharmProjects/sandbox/crash_example.py", line 7, in <module>
    clusterer.fit(no_structure)
  File "/home/home/PycharmProjects/sandbox/venv/lib/python3.8/site-packages/hdbscan/hdbscan_.py", line 919, in fit
    self._min_spanning_tree) = hdbscan(X, **kwargs)
  File "/home/home/PycharmProjects/sandbox/venv/lib/python3.8/site-packages/hdbscan/hdbscan_.py", line 632, in hdbscan
    return _tree_to_labels(X,
  File "/home/home/PycharmProjects/sandbox/venv/lib/python3.8/site-packages/hdbscan/hdbscan_.py", line 59, in _tree_to_labels
    labels, probabilities, stabilities = get_clusters(condensed_tree,
  File "hdbscan/_hdbscan_tree.pyx", line 645, in hdbscan._hdbscan_tree.get_clusters
  File "hdbscan/_hdbscan_tree.pyx", line 733, in hdbscan._hdbscan_tree.get_clusters
  File "hdbscan/_hdbscan_tree.pyx", line 631, in hdbscan._hdbscan_tree.epsilon_search
IndexError: index 0 is out of bounds for axis 0 with size 0

स्रोत

danielzgtg

सभी 13 टिप्पणियाँ

मैं भी इस समस्या का सामना कर रहा हूं। केवल cluster_selection_method='eom' का उपयोग करते समय होता है।

._hdbscan_tree.pyx में क्लस्टर_ट्री खाली है क्योंकि रूट नोड के सभी बच्चों के बच्चे का आकार == 1 है। 'पत्ती' विधि इससे दूर हो सकती है क्योंकि 'पत्तियां' भी खाली हो जाती है।

हालांकि, 'eom_clusters' में रूट नोड होता है और epsilon_search() केवल चाइल्ड नोड्स की खोज करने वाले क्लस्टर_ट्री पर निर्भर करता है। मुझे लगता है कि हम रूट नोड को 'eom_clusters' सूची में होने से रोकना चाहते हैं?

neontty 24 अप्रैल 2020

@danielzgtg कृपया अपनी समस्या के संभावित समाधान के लिए मेरा पुल अनुरोध देखें। मैं सकारात्मक नहीं हूं कि यह अंतर्निहित एल्गोरिदम को प्रभावित नहीं करता है, लेकिन मैंने समाधान खोजने के लिए अपनी पूरी कोशिश की और मुझे पूरा भरोसा है।

neontty 24 अप्रैल 2020

इसलिए माल्ज़र और बॉम द्वारा एचडीबीएससीएएन* पेपर पढ़ने के बाद, मुझे लगता है कि शायद 370 के लिए मेरा फिक्स एल्गोरिथम रूप से सही नहीं था; फिक्स हमें उस पैरामीटर के साथ चलने की अनुमति देता है, लेकिन वास्तव में एल्गोरिदम को बिल्कुल एक एकल क्लस्टर वापस करने की अनुमति नहीं देता है।

धारा 4.3 के तहत विवरण में कहा गया है कि एप्सिलॉन के आधार पर विलय का वर्णन करता है "यदि हमें एक _रूट तक पहुंचने से पहले_ मिल जाता है, तो हम इसे एक क्लस्टर के रूप में चुनते हैं और इसके सभी वंशजों को अचयनित करते हैं"।

@lmcinnes या @cmalzer क्या आप पुष्टि कर पाएंगे कि "allow_single_cluster" और "cluster_selection_epsilon" के संयोजन के लिए हम पदानुक्रम के ऊपर की ओर ट्रैवर्सल के दौरान रूट नोड तक पहुंचने की अनुमति देना चाहते हैं? या अगर इसके अनपेक्षित परिणाम हैं? यह सही कदम लगता है।

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

neontty 29 मई 2020

👍1

नमस्ते, इसे इंगित करने के लिए धन्यवाद - मैं "allow_single_cluster" विकल्प के लिए क्लस्टर_चयन_एप्सिलॉन को लागू करना भूल गया। (कागज में वर्णित एल्गोरिथम केवल उस मामले पर विचार करता है जहां हम डेटा सेट को विभाजित करना चाहते हैं)

लेकिन मैंने नवीनतम प्रतिबद्धता पर एक नज़र डाली और रूट को "traverse_upwards" में वापस कर दिया यदि allow_single_cluster सही पर सेट है तो वास्तव में समस्या को ठीक करना चाहिए। आपको धन्यवाद!

cmalzer 29 मई 2020

👍1

त्वरित उत्तर के लिए और इस एल्गोरिथम को डिजाइन करने में आपके काम के लिए धन्यवाद!

neontty 29 मई 2020

@lmcinnes दुर्भाग्य से, यह समस्या हल नहीं हुई है।

मेरे द्वारा किए गए दूसरे पुल अनुरोध ने एक यूनिट परीक्षण पास किया जिसका मैं उपयोग कर रहा था और ज्यादातर मामलों में एकल क्लस्टर की अनुमति देता है, लेकिन @danielzgtg द्वारा प्रदान किए गए कोड के साथ एक बढ़त का मामला है।

मैंने कुछ डिबगिंग करने की कोशिश की और समस्या तब प्रतीत होती है जब _hdbscan_tree पर cluster_tree['lambda_val] खाली है। पीईएक्स: 638 । हालांकि मुझे साइथन को डीबग करने में परेशानी हो रही है (अभी भी साइथन के लिए काफी नया है)। अगर किसी के पास इसकी जांच में मदद करने का समय है, तो मैं इसकी बहुत सराहना करूंगा।

neontty 23 जून 2020

मैंने अभी इसे देखा था। समस्या वास्तव में यह है कि इस बिंदु पर क्लस्टर_ट्री खाली है। इसलिए, क्लस्टर_ट्री ['lambda_val'] [cluster_tree ['child'] == लीफ] एक खाली सरणी है और पहले तत्व ([0]) तक पहुंचने का प्रयास करते समय आपको एक इंडेक्स एरर मिलेगा।

क्लस्टर_ट्री खाली होने का कारण "क्लस्टर_ट्री = ट्री [ट्री ['चाइल्ड_साइज़']> 1]" लाइन है। पेड़ में केवल आकार 1 के बच्चों के साथ एक मूल नोड होता है।

कोड क्लस्टर_सिलेक्शन_मेथोड = "लीफ" के लिए काम करता है क्योंकि पत्तियों की सूची खाली है। "ईओएम" के लिए, पैरेंट क्लस्टर को "लीफ" के रूप में पास किया जाता है।

इसे epsilon_search करने से पहले यह जाँच कर हल किया जा सकता है कि क्या क्लस्टर_ट्री खाली है। उदाहरण के लिए, "अगर क्लस्टर_सेलेक्शन_एप्सिलॉन!= 0.0 और क्लस्टर_ट्री.आकार[0]> 0: ..."

cmalzer 23 जून 2020

👍1

मैंने सशर्त में cluster_tree.shape[0] > 0 के आपके सुझाव के साथ इसका परीक्षण किया, लेकिन यह विफल हो गया। थोड़ा सा प्रिंटफ डिबगिंग करने के बाद, क्लस्टर_ट्री में ~ 26 तत्व थे, और eom_clusters में बिल्कुल एक है, जो रूट नोड है। इसलिए, जब हम लाइन 637 पर cluster_tree['child'] == leaf का मूल्यांकन करते हैं, तो लीफ रूट नोड होता है और यह बिना किसी चाइल्ड एंट्री से मेल खाता है।

इस बारे में कैसा है?

cpdef set epsilon_search(set leaves, np.ndarray cluster_tree, np.double_t cluster_sel\
ection_epsilon, np.intp_t allow_single_cluster):                                      

    selected_clusters = list()                                                        
    processed = list()                                                                
    root_node = cluster_tree['parent'].min()                                          

    for leaf in leaves:                                                               
        if leaf == root_node:                                                         
            if allow_single_cluster:                                                  
                selected_clusters.append(leaf)                                        
                break                                                                 
            continue                                                                  
        eps = 1/cluster_tree['lambda_val'][cluster_tree['child'] == leaf][0]          
        if eps < cluster_selection_epsilon:                                           
            if leaf not in processed:

सच कहूं तो मैं थोड़ा भ्रमित हूं। जब हम एकल क्लस्टर की अनुमति देना चाहते हैं, तो क्या इसका मतलब यह है कि हम इसे केवल शोर क्लस्टर होने देना चाहते हैं? उस स्थिति में यह होगा:

cpdef set epsilon_search(set leaves, np.ndarray cluster_tree, np.double_t cluster_sel\
ection_epsilon, np.intp_t allow_single_cluster):                                      

    selected_clusters = list()                                                        
    processed = list()                                                                
    root_node = cluster_tree['parent'].min()                                          

    for leaf in leaves:                                                               
        if leaf == root_node:                                                         
            if not allow_single_cluster:                                              
                selected_clusters.append(leaf)                                        
            break                                                                     
        eps = 1/cluster_tree['lambda_val'][cluster_tree['child'] == leaf][0]          
        if eps < cluster_selection_epsilon:

neontty 25 जून 2020

ऐसा लगता है कि मैंने यादृच्छिक डेटा बिंदुओं की गलत संख्या के साथ परीक्षण किया, और फिर वही त्रुटि मिली, लेकिन एक अलग कारण से।
इसे कैसे ठीक किया जा सकता है, इसके कई तरीके हैं; यह वास्तव में epsilon_search के बाहर जांच करने के लिए थोड़ा तेज़ हो सकता है, उदाहरण के लिए कुछ ऐसा

if cluster_selection_epsilon != 0.0 and cluster_tree.shape[0] > 0:

            eom_clusters = [c for c in is_cluster if is_cluster[c]]
            if not (len(eom_clusters) == 1 and eom_clusters[0] == cluster_tree['parent'].min()):
                selected_clusters = epsilon_search(set(eom_clusters), cluster_tree, cluster_selection_epsilon, allow_single_cluster)

(कई संपादनों के लिए खेद है)

cmalzer 25 जून 2020

शीघ्र प्रतिक्रिया के लिए शुक्रिया! यह अच्छा प्रतीत होता है। मैं आज रात एक पुल अनुरोध में डालूँगा।

neontty 25 जून 2020

@cmalzer

मैंने आपके सुझाव के साथ एक पुल अनुरोध रखा है।

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

अगर हम वह धारणा नहीं बना सकते हैं तो मैं सशर्त को बदल दूंगा

if (cluster_tree['parent'].min() in eom_clusters)

क्योंकि अगर रूट सूची में बिल्कुल मौजूद है और हम इसे आउटपुट के रूप में अनुमति देते हैं तो यह डिफ़ॉल्ट रूप से खोज से लौटा एकमात्र ईपीएसलॉन बच्चा बन जाएगा।

neontty 4 जुल॰ 2020

यदि HDBSCAN एक क्लस्टर का चयन करता है, तो यह उसके सभी वंशजों को भी अचयनित करता है। इसलिए, वास्तव में ऐसा नहीं होना चाहिए कि रूट क्लस्टर और अन्य क्लस्टर सूची में हैं। हालाँकि, "if .... in eom_clusters" का आपका सुझाव मेरे संस्करण की तुलना में पढ़ने में बहुत आसान है, इसलिए मैं वास्तव में कोड की उस पंक्ति को पसंद करूंगा - हालाँकि पहले लंबाई की जाँच करना थोड़ा तेज़ हो सकता है क्योंकि अन्यथा हम खोज करते हैं रूट नोड के लिए क्लस्टर की पूरी सूची हर बार जब हम एप्सिलॉन पैरामीटर का उपयोग करते हैं, भले ही यह एक दुर्लभ मामला है। लेकिन मुझे यकीन नहीं है कि कितना प्रदर्शन अंतर बनाता है ... (शायद लंबाई की जांच में वैसे भी उतना ही समय लगता है?) मैं किसी भी तरह से ठीक हूं।

cmalzer 5 जुल॰ 2020

स्पष्टीकरण देने के लिए धन्यवाद! मुझे लगता है कि शायद एक मध्य मैदान के रूप में मैं इसे प्रदर्शन के लिए छोड़ दूंगा और ऊपर एक टिप्पणी डालूंगा।

neontty 7 जुल॰ 2020

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स

Hdbscan: क्रैश जब allow_single_cluster का उपयोग क्लस्टर_चयन_एप्सिलॉन के साथ किया जाता है

कोड

अपेक्षित् व्यवहार

वास्तविक व्यवहार

सभी 13 टिप्पणियाँ

संबंधित मुद्दों