बहुत आसानी से alorithm

Question

KMeans साथ

मैं गणना कर सकते हैं क्लस्टर सदस्यता क्लस्टरिंग KMeans साथ आंशिक सदस्यता खोजें:

open System 
open System.IO 
open Utils 
open Accord 
open Accord.Math 
open Accord.MachineLearning 

let vals = [| 
    [|1.0; 2.0; 3.0; 2.0|] 
    [|1.1; 1.9; 3.1; 4.0|] 
    [|2.0; 3.0; 4.0; 4.0|]  
    [|3.0; 3.1; 2.0; 3.0|] 
    [|2.0; 4.0; 3.0; 6.0|] 
    [|1.0; 5.0; 5.0; 7.0|] 
    [|4.0; 3.0; 6.0; 8.0|] 
    [|5.0; 4.0; 3.0; 6.0|] 
    [|6.0; 4.0; 8.0; 7.0|] 
    [|5.0; 6.0; 5.0; 9.0|] 
    [|4.0; 2.0; 7.0; 8.0|] 
    [|8.0; 9.0; 3.1; 2.2|] 
    [|8.0; 9.0; 2.0; 2.0|] 
    [|10.0; 2.0; 3.0; 2.0|] 
    [|10.1; 1.9; 3.1; 4.0|] 
    [|20.0; 3.0; 4.0; 4.0|] 
    [|22.0; 7.0; 2.0; 3.0|] 
    [|21.0; 4.0; 3.0; 6.0|] 
|] 

let kmeans = new KMeans 5 
let clusterModel = kmeans.Learn vals 
let clusters = clusterModel.Decide vals 

मैं मानक KMeans एल्गोरिथ्म के साथ आंशिक सदस्यता की गणना कर सकते हैं? एक सहकर्मी ने आनुपातिक सदस्यता निर्धारित करने के लिए क्लस्टर सदस्यों के माध्य और भिन्नताओं का उपयोग करने का सुझाव दिया और आज मैं F# के लिए अस्पष्ट सेट और उनके कार्यान्वयन में देख रहा हूं। उदाहरण के लिए, here is some documentation for the Accord.net implementation for fuzzy sets. मैं F# के लिए उदाहरण का अनुवाद/रन कर सकता हूं लेकिन पहली नज़र में, मुझे आंशिक सदस्यता असाइन करने के प्रारूप को फिट करने के लिए ऊपर दिए गए Kmeans से डेटा प्राप्त करने का एक आसान तरीका नहीं दिख रहा है।

सवाल:

1. मैं कैसे क्लस्टर के सदस्यों की औसत/विचरण का उपयोग आंशिक सदस्यता की गणना करने के हैं?

2. क्या Accord.net लाइब्रेरी के साथ KMeans क्लस्टरिंग के साथ आंशिक सदस्यता की गणना करने का कोई आसान तरीका है?

3. Accord.net में केएमन्स एल्गोरिदम लागू करने के लिए आसान है; क्या मुझे अपनी जरूरतों के अनुसार किमन्स क्लस्टरिंग की कोशिश करने और मजबूर करने के बजाय अपनी समस्या के अनुरूप क्लस्टरिंग/सदस्यता के इस तरीके को सीखने का प्रयास करने में कुछ समय व्यतीत करना चाहिए?

Answer 1

जैसा कि टॉमस द्वारा उल्लेख किया गया है, Accord.NET आपको पहले से ही कई बिल्डिंग ब्लॉक देता है। विशेष रूप से, बुला clusterModel.Scores आप क्लस्टर centroids के लिए (नकारात्मक) दूरी, see source code

नकारात्मक दूरी से देता है, आप exponentials, आप एक गाऊसी पीडीएफ गणना करने के लिए क्या करेंगे के समान लेने के द्वारा एक अनुमानित वर्ग की सदस्यता के स्कोर की गणना कर सकता ।एफ # में, कि देखो की तरह होगा: एकॉर्ड में

• स्टैंडर्ड KMeans का उपयोग करता है इयूक्लिडियन दूरी जिसका अर्थ है कि प्रत्येक दिशा में एक ही वजन वहन करती है,:

  // Scores returns the negative distances between each point 
  // and the cluster centroid 
  let negDistances = clusterModel.Scores vals 
  // Compute an estimated cluster assigment score 
  let clusterMembership = 
      negDistances 
      |> Array.map (fun distances -> 
       // Take the Exponential of the (negative) distances, 
       // as in computing a Gaussian pdf 
       let expDist = distances |> Array.map Math.Exp 
       let total = Array.sum expDist 
       expDist 
       |> Array.map (fun d -> d/total) 
      ) 
  

  यहाँ चेतावनियां के एक जोड़े हैं। आपके डेटा की प्रकृति के आधार पर, इससे उचित परिणाम नहीं हो सकते हैं (चित्र 2 क्लस्टर, प्रत्येक एक लंबे सिगार की तरह आकार दिया जाता है)

• उपरोक्त वर्ग सदस्यता गणना गणना खाते में क्लस्टर कॉन्वर्सिस नहीं ले रही है। सच्चाई के करीब होने के लिए, आपको भट्टाचार्य दूरी, एक्सपोनेंटिएट, और फिर कॉन्वर्सिस मैट्रिक्स के विपरीत रूप से स्केल करना होगा। यह सिंगलटन क्लस्टर के लिए असफल हो जाएगा।

आपके तीसरे प्रश्न के बारे में: मैं फिर से लागू नहीं करूँगा। यह शुरुआत में आसान प्रतीत हो सकता है, लेकिन आमतौर पर कोने के मामलों और स्थिरता के मुद्दों के बहुत सारे होते हैं जिन्हें आप केवल कुछ समय बाद ही चलाते हैं।

Answer 2

आप Accord.NET उपयोग करने के लिए समूहों के "centroids" प्राप्त करने के लिए है कि एल्गोरिथ्म पाता है कश्मीर का मतलब है सक्षम होना चाहिए। वे अनिवार्य रूप से व्यक्तिगत क्लस्टर के केंद्र हैं। इसके बाद आपको अपने नए डेटा पॉइंट और प्रत्येक सेंट्रॉइड के बीच की दूरी की गणना करने में सक्षम होना चाहिए ताकि यह देखने के लिए कि कौन से सेंट्रॉइड आपके बिंदु के करीब हैं। (Decide विधि सिर्फ पहले एक देता है।)

मैं इस प्रयास नहीं किया है, लेकिन ऐसा लगता है कि KMeans को उजागर करता है Clusters है, जो एक KMeansClusterCollection है और Centroids संपत्ति है (the docs देखें)। यह Distance संपत्ति का भी खुलासा करता है जो डेटा बिंदुओं के बीच दूरी की गणना के लिए फ़ंक्शन देता है।

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

स्क्रैच से के-साधन लागू करना कठिन नहीं है (इस पर nice post from Mathias Brandewinder है), लेकिन ऐसा लगता है कि Accord.NET आपको इस विशेष मामले में आवश्यक सभी जानकारी का खुलासा करता है - तो शायद आपको बस इतना ही चाहिए कस्टम कार्यान्वयन में सही सभी विवरण हमेशा सबसे कठिन हिस्सा है ...)।