स्क्रैच

Question

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

अब, मेरे पास n आयामी स्थान और कई डेटा बिंदु हैं जिनमें इन आयामों में से प्रत्येक के मान हैं। मैं की तरह व्यापार नियमों के आधार पर दो अंक/समूहों क्लस्टर हैं:

• क्लस्टर दो अंक C1 और C2 यदि आयाम 1 भर में समूहों के बीच की दूरी < T1 है, और आयाम में दूरी 2 < टी 2, .. और आयाम एन < टीएन में दूरी।
• आयाम 1 भर में नियम पूरा किया जाता है और आयाम 2 भर में नियम पूरा किया जाता है, तो उन्हें अन्य आयामों के बारे में परेशान बिना क्लस्टर ...

.... और इसी तरह के कस्टम नियम।

इसके अतिरिक्त, मेरे पास किसी विशेष आयाम में किसी भी दो क्लस्टर के बीच की दूरी को परिभाषित करने और मापने का अपना तरीका है। आयाम केवल तारों को पकड़ सकता है, और मैं अपनी स्ट्रिंग दूरी मीट्रिक को परिभाषित करना चाहता हूं। एक और आयाम में, यह स्थानों के नाम रख सकता है, और इस आयाम के साथ दो बिंदुओं के बीच की दूरी नामित स्थान के बीच भौगोलिक दूरी है, और इसी तरह अन्य आयामों के लिए भी।

क्या कोई ढांचा/सॉफ्टवेयर है जो मुझे कस्टम दूरी मीट्रिक को परिभाषित करने के तरीके को कार्यान्वित करने देता है, और फिर agglomerative क्लस्टरिंग को लागू करने के लिए? बेशक, agglomerative क्लस्टरिंग बंद हो जाती है जब किसी भी समय व्यापार नियमों को पूरा नहीं किया जाता है, और हमारे पास अंत में एन आयामी अंतरिक्ष में क्लस्टर बनते हैं।

धन्यवाद अभिषेक एस

Answer 1

आप Weka साथ यह कर सकता है।

आपको Distance Function लागू करना होगा, और इसे setDistanceFunction(DistanceFunction distanceFunction) विधि का उपयोग करके Hierarchical Clusterer पर पास करना होगा।

Weka में अन्य उपलब्ध clusterers हैं: मकड़ी का जाला, ईएम, FarthestFirst, FilteredClusterer, MakeDensityBasedClusterer, RandomizableClusterer, RandomizableDensityBasedClusterer, RandomizableSingleClustererEnhancer, SimpleKMeans, SingleClustererEnhancer।

एक उदाहरण सुदूर क्रिया, NormalizableDistance वर्ग से:

/** Index in ranges for MIN. */ 
    public static final int R_MIN = 0; 

    /** Index in ranges for MAX. */ 

    public static final int R_MAX = 1; 

    /** Index in ranges for WIDTH. */ 
    public static final int R_WIDTH = 2; 

    /** the instances used internally. */ 
    protected Instances m_Data = null; 

    /** True if normalization is turned off (default false).*/ 
    protected boolean m_DontNormalize = false; 

    /** The range of the attributes. */ 
    protected double[][] m_Ranges; 

    /** The range of attributes to use for calculating the distance. */ 
    protected Range m_AttributeIndices = new Range("first-last"); 

    /** The boolean flags, whether an attribute will be used or not. */ 
    protected boolean[] m_ActiveIndices; 

    /** Whether all the necessary preparations have been done. */ 
    protected boolean m_Validated; 


public double distance(Instance first, Instance second, double cutOffValue, PerformanceStats stats) { 
    double distance = 0; 
    int firstI, secondI; 
    int firstNumValues = first.numValues(); 
    int secondNumValues = second.numValues(); 
    int numAttributes = m_Data.numAttributes(); 
    int classIndex = m_Data.classIndex(); 

    validate(); 

    for (int p1 = 0, p2 = 0; p1 < firstNumValues || p2 < secondNumValues;) { 
     if (p1 >= firstNumValues) 
     firstI = numAttributes; 
     else 
     firstI = first.index(p1); 

     if (p2 >= secondNumValues) 
     secondI = numAttributes; 
     else 
     secondI = second.index(p2); 

     if (firstI == classIndex) { 
     p1++; 
     continue; 
     } 
     if ((firstI < numAttributes) && !m_ActiveIndices[firstI]) { 
     p1++; 
     continue; 
     } 

     if (secondI == classIndex) { 
     p2++; 
     continue; 
     } 
     if ((secondI < numAttributes) && !m_ActiveIndices[secondI]) { 
     p2++; 
     continue; 
     } 

     double diff; 

     if (firstI == secondI) { 
     diff = difference(firstI, 
        first.valueSparse(p1), 
        second.valueSparse(p2)); 
     p1++; 
     p2++; 
     } 
     else if (firstI > secondI) { 
     diff = difference(secondI, 
        0, second.valueSparse(p2)); 
     p2++; 
     } 
     else { 
     diff = difference(firstI, 
        first.valueSparse(p1), 0); 
     p1++; 
     } 
     if (stats != null) 
     stats.incrCoordCount(); 

     distance = updateDistance(distance, diff); 
     if (distance > cutOffValue) 
     return Double.POSITIVE_INFINITY; 
    } 

    return distance; 
    } 

शो है कि आप अलग से विभिन्न आयामों (कि Weka में विशेषताओं कहा जाता है) का इलाज कर सकते हैं। तो आप प्रत्येक आयाम/विशेषता के लिए एक अलग दूरी परिभाषित कर सकते हैं।

व्यवसाय के नियमों के बारे में कुछ उदाहरणों को क्लस्टर करने से बचने के लिए। मुझे लगता है कि आप एक दूरस्थ फ़ंक्शन बना सकते हैं जो Double.positiveInfinity देता है जब व्यवसाय नियम संतुष्ट नहीं होते हैं।

Answer 2

ELKI एक और विकल्प है। इसमें वेका की तुलना में अधिक क्लस्टरिंग एल्गोरिदम हैं (जो वर्गीकरण के लिए अधिकतर उपयोगी है)। उनके पास एक विकी ट्यूटोरियल भी है जो कस्टम दूरी कार्यों को कार्यान्वित करने के बारे में बताता है (जिसे आप पदानुक्रमित क्लस्टरिंग में उपयोग करने में सक्षम होना चाहिए): distance function tutorial।

ध्यान दें कि "व्यापार के नियम" एक बहुत ही आम तरीका एक दूरी समारोह निर्दिष्ट करने के लिए नहीं है ...