गोल्फ K- साधन एल्गोरिथ्म

Question

K- साधन एक मानक अनसुनी क्लस्टरिंग एल्गोरिथ्म है, जो "अंक" का एक सेट और क्लस्टर K की संख्या को देखते हुए, K समूहों में से किसी एक को प्रत्येक "बिंदु" प्रदान करेगा।

K- साधनों का छद्म कोड

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

इस चुनौती में, सभी इनपुट 2 डी विमान पर बिंदु होंगे (प्रत्येक बिंदु x और y में इसके निर्देशांक द्वारा दर्शाया गया है)।

Inputs: K, the number of clusters
        P, the set of points

Choose K points of P uniformly at random
Each chosen point is the initial centroid of its cluster

Loop:
     For each point in P:
         Assign to the cluster whose centroid is the nearest (Euclidean distance)
         In case of a tie, any of the tied cluster can be chosen

     Recompute the centroid of each cluster:
         Its x coordinate is the average of all x's of the points in the cluster
         Its y coordinate is the average of all y's of the points in the cluster

Until the clusters don't change from one iteration to the next

Output: the set of clusters    

इनपुट और आउटपुट

• आप के और पी के माध्यम से STDINया एक फ़ंक्शन तर्क के रूप में ले सकते हैं , आदि।
• P और P के बिंदुओं को किसी भी संरचना का उपयोग करके दर्शाया जा सकता है जो आपकी पसंद की भाषा में सेट / सूचियों के लिए स्वाभाविक है।
• K एक सख्ती से धनात्मक पूर्णांक है।
• आप मान सकते हैं कि इनपुट मान्य हैं।
• P में हमेशा कम से कम K अंक होंगे।
• आप समूहों को आउटपुट कर सकते हैं STDOUT, उन्हें एक फ़ंक्शन से वापस कर सकते हैं, आदि।
• समूहों के क्रम और समूहों के अंदर का क्रम महत्वहीन है। -आप या तो समूहों का प्रतिनिधित्व करने के लिए बिंदुओं के समूहों को वापस कर सकते हैं, या क्लस्टर के लिए पहचानकर्ता के साथ लेबल किए गए प्रत्येक बिंदु (जैसे एक पूर्णांक)।

परीक्षण के मामलों

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

इसलिए, आउटपुट को केवल उदाहरण आउटपुट के रूप में लें।

Input:
  K = 1
  P = [[1,2.5]]
Output:
  [[[1,2.5]]]

Input:
  K = 3
  P = [[4,8], [15,16], [23,42], [-13.37,-12.1], [666,-666]]
Output:
  [[[666,-666]],[[-13.37,-12.1],[4,8]],[[15,16],[23,42]]]

Input:
  K = 2
  P = [[1,1], [1,1], [1,1]]
Output:
  [[[1,1]],[[1,1],[1,1]]]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

Comments

जब परिणाम आपके एल्गोरिदम से अप्रभेद्य हैं, तो अंतर्निहित इंस की अनुमति है?

— मार्टिन एंडर

@ मार्टिनबटनर यदि आप यह बता सकते हैं कि एक ही प्रारंभिक अंक दिए गए हैं, तो यह उसी परिणाम में परिवर्तित होता है, हाँ।

— घातक

जोर से यह भी एक बिंदु के लिए एक क्लस्टर की सदस्यता के उत्पादन लेबल के लिए स्वीकार्य हो सकता है? (जैसे पहले क्लस्टर के 1सभी बिंदुओं में लेबल होता है , दूसरे के सभी बिंदुओं पर लेबल 2आदि होता है)

— त्रुटी

@flawr हाँ, यह स्वीकार्य है।

— Fatalize

पतित परीक्षण का मामला: K=2, P = [[1,1], [1,1], [1,1]]।

— पीटर टेलर

Answer 1

मतलाब, 25 बाइट्स

@(x,k)kmeans(x,k,'S','u')

n x 2मैट्रिक्स (एक पंक्ति प्रति बिंदु जैसे [[4,8]; [15,16]; [23,42]; [-13.37,-12.1]; [666,-666]]) को देखते हुए यह फ़ंक्शन प्रत्येक इनपुट बिंदु के लिए लेबल की एक सूची देता है।

Answer 2

सी ++, 479 474 बाइट्स

केवल ~ 20x जितना मतलूब!

golfed

#define V vector<P>
#define f float
struct P{f x,y,i=0;f d(P&p){return(p.x-x)*(p.x-x)+(p.y-y)*(p.y-y);}f n(P&p){return i?x/=i,y/=i,d(p):x=p.x,y=p.y,0;}f a(P&p){x+=p.x,y+=p.y,i++;}};P z;int l(P a,P b){return a.d(z)<b.d(z);}f m(f k,V&p){f s=p.size(),i,j=0,t=1;V c(k),n=c,d;for(random_shuffle(p.begin(),p.end());j<k;c[j].i=j++)c[j]=p[j];for(;t;c=n,n=V(k)){for(i=0;i<s;i++)d=c,z=p[i],sort(d.begin(),d.end(),l),j=d[0].i,p[i].i=j,n[j].a(p[i]);for(j=t=0;j<k;j++)t+=n[j].n(c[j]);}}

एल्गोरिथ्म में इनपुट / आउटपुट अंकों का एक समूह है ( struct P) के साथ xऔर y; और आउटपुट एक ही सेट है, iजो आउटपुट क्लस्टर के सूचकांक को इंगित करने के लिए उनके बिंदु के साथ सेट होता है।

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

यह इसी केन्द्रक की पिछली स्थिति को ध्यान में रखते हुए (खाली क्लस्टर) मामलों को संभालता है (परिभाषा देखें P::n, जो दूरी-से-पिछले-केंद्रित को भी लौटाता है)। कुछ चरों को यह मानकर बचाया जा सकता है कि ये फसल नहीं करेंगे।

असंगठित, मुख्य के साथ

#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <vector>
#include <algorithm>
using namespace std;

#define V vector<P>
#define f float
struct P{
    f x,y,i=0;
    f d(P&p){return(p.x-x)*(p.x-x)+(p.y-y)*(p.y-y);} // distance squared
    f n(P&p){return i?x/=i,y/=i,d(p):x=p.x,y=p.y,0;} // normalize-or-reset
    f a(P&p){x+=p.x,y+=p.y,i++;}                     // add coordinates
};
P z;int l(P a,P b){return a.d(z)<b.d(z);}            // closer-to-z comparator 
f m(f k,V&p){
    f s=p.size(),i,j=0,t=1;V c(k),n=c,d;
    for(random_shuffle(p.begin(),p.end());j<k;c[j].i=j++)
        c[j]=p[j];                                // initial random assignment
    for(;t;c=n,n=V(k)){                           
        for(i=0;i<s;i++)                          // assign to clusters
            d=c,z=p[i],sort(d.begin(),d.end(),l),
            j=d[0].i,p[i].i=j,n[j].a(p[i]);       // and add those coords
        for(j=t=0;j<k;j++)t+=n[j].n(c[j]);        // normalize & count changes
    }        
}

int main(int argc, char **argv) {
    srand((unsigned long)time(0));

    int k;
    V p;
    sscanf(argv[1], "%d", &k);
    printf("Input:\n");
    for (int i=2,j=0; i<argc; i+=2, j++) {
        P n;
        sscanf(argv[i], "%f", &(n.x));
        sscanf(argv[i+1], "%f", &(n.y));
        p.push_back(n);
        printf("%d : %f,%f\n", j, p[j].x, p[j].y);
    }

    m(k,p);
    printf("Clusters:\n");
    for (int q=0; q<k; q++) {
        printf("%d\n", q);
        for (unsigned int i=0; i<p.size(); i++) {
            if (p[i].i == q) printf("\t%f,%f (%d)\n", p[i].x, p[i].y, i);
        }
    }
    return 0;
}

Comments

मुझे लगता है मैं इस टिप्पणी में देर से हो सकता है, लेकिन आप मैक्रो निर्धारित कर सकता है #define R p){returnऔर का दूसरा तर्क को बदलने lके लिए pताकि आप इसे तीन बार इस्तेमाल कर सकते हैं कुल?

— ज़ाचारि

Answer 3

जे, 60 ५४ बाइट्स

p=:[:(i.<./)"1([:+/&.:*:-)"1/
]p](p(+/%#)/.[)^:_(?#){]

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

प्रयोग

K का मान LHS पर पूर्णांक के रूप में दिया जाता है। अंकों की सूची RHS पर 2d सरणी के रूप में दी गई है। यहां इसे उन बिंदुओं की सूची के रूप में निर्दिष्ट किया गया है, जिन्हें 2d सरणी में 5 x 2 में बदल दिया गया है। आउटपुट लेबल होगा जिसके लिए प्रत्येक बिंदु इनपुट के समान क्रम में क्लस्टर होता है।

आप प्रतिलिपि प्रस्तुत करने योग्य परिणामों के लिए एक निश्चित बीज का उपयोग करना चाहते हैं, की जगह ?एक साथ ?.पर (?#)।

   p =: [:(i.<./)"1([:+/&.:*:-)"1/
   f =: ]p](p(+/%#)/.[)^:_(?#){]
   3 f (5 2 $ 4 8 15 16 23 42 _13.37 _12.1 666 _666)
0 1 1 0 2

व्याख्या

[:(i.<./)"1([:+/&.:*:-)"1/  Input: points on LHS, centroids on RHS
           (          )"1/  Form a table between each point and centroid and for each
                     -        Find the difference elementwise
            [:     *:         Square each
              +/&.:           Reduce using addition
                              Apply the inverse of square (square root) to that sum
[:(     )"1                 For each row of that table
     <./                      Reduce using min
   i.                         Find the index of the minimum in that row
                            Returns a list of indices for each point that shows
                            which centroid it belongs to

]p](p(+/%#)/.[)^:_(?#){]  Input: k on LHS, points on RHS
                    #     Count the number of points
                   ?      Choose k values in the range [0, len(points))
                          without repetition
                       ]  Identity function, get points
                      {   Select the points at the indices above
  ]                       Identity function, get points
   (         )^:_         Repeat until convergence
    p                       Get the labels for each point
             [              Identity function, get points
           /.               Partition the points using the labels and for each
      +/                      Take the sums of points elementwise
         #                    Get the number of points
        %                     Divide sum elementwise by the count
                            Return the new values as the next centroids
]                         Identity function, get points
 p                        Get the labels for each point and return it

Comments

मैं +1 देता, लेकिन मुझे डर है कि आपका 3k टूटना मुझे शाप देगा।

— NoOneIsHere

Answer 4

CJam (60 बाइट्स)

{:Pmr<1/2P,#{:z{_:+\,/}f%:C,{P{C\f{.-Yf#:+}_:e<#1$=},\;}%}*}

यह एक फ़ंक्शन है जो k pस्टैक पर फॉर्म में इसका इनपुट लेता है । यह मानता है कि अंकों को अंक के साथ नहीं, युगल के साथ दर्शाया जाता है। यह अंक के आयाम के बारे में कुछ भी अनुमान नहीं लगाता है, इसलिए यह 6-डी यूक्लिडियन स्पेस में समान रूप से अच्छी तरह से क्लस्टर करेगा जैसा कि निर्दिष्ट 2-डी में है।

ऑनलाइन डेमो

Answer 5

गणितज्ञ 14 12 बाइट्स

चूंकि बिल्ट-इन की अनुमति है, इसलिए इसे ऐसा करना चाहिए।

FindClusters

---

उदाहरण

FindClusters[{{4, 8}, {15, 16}, {23, 42}, {-13.37, -12.1}, {666, -666}}, 3]

{{{4, 8}, {-13.37, -12.1}}, {{15, 16}, {23, 42}}, {{666, -666}}}

Comments

आपको कोष्ठक की आवश्यकता नहीं है। f = FindClusters, f[something]।

— NoOneIsHere

ठीक है, धन्यवाद मुझे यकीन नहीं था।

— डेविड जूल

Answer 6

जेली , 24 बाइट्स

_ÆḊ¥þ³i"Ṃ€$
ẊḣµÇÆmƙ³µÐLÇ

इसे ऑनलाइन आज़माएं!

इस चुनौती के लागू होने के बाद लागू की गई सुविधाओं का उपयोग करता है। माना जाता है कि यह अब गैर-प्रतिस्पर्धात्मक नहीं है ।

व्याख्या

_ÆḊ¥þ³i"Ṃ€$  Helper link. Input: array of points
             (Classify) Given a size-k array of points, classifies
             each point in A to the closet point in the size-k array
    þ        Outer product with
     ³       All points, P
   ¥         Dyadic chain
_              Subtract
 ÆḊ            Norm
          $  Monadic chain
      i"     Find first index, vectorized
        Ṃ€   Minimum each

ẊḣµÇÆmƙ³µÐLÇ  Main link. Input: array of points P, integer k
  µ           Start new monadic chain
Ẋ               Shuffle P
 ḣ              Take the first k
        µ     Start new monadic chain
   Ç            Call helper (Classify)
      ƙ         Group with those values the items of
       ³        All points, P
    Æm            Take the mean of each group
         ÐL   Repeat that until the results converge
           Ç  Call helper (Classify)

Answer 7

आर , 273 बाइट्स

function(K,P,C=P[sample(nrow(P),K),]){while(T){D=C
U=sapply(1:nrow(P),function(i)w(dist(rbind(P[i,],C))[1:K]))
C=t(sapply(1:K,function(i)colMeans(P[U==i,,drop=F])))
T=isTRUE(all.equal(C,D))}
cbind(U,P)}
w=function(x,y=seq_along(x)[x==min(x)])"if"(length(y)>1,sample(y,1),y)

इसे ऑनलाइन आज़माएं!

ले जाता है Pके साथ एक मैट्रिक्स के रूप में, xऔर yक्रमशः पहले और दूसरे कॉलम में निर्देशांक। Pपहले कॉलम के साथ रिटर्न जोड़ा जाता है जो क्लस्टर इंडेक्स (पूर्णांक) को इंगित करता है।

मुझे उस आवश्यकता के अनुरूप wस्रोत की प्रतिलिपि बनाकर पुनर्परिभाषित करना पड़ा, ताकि nnet::which.is.maxसंबंधों के मामले में क्लस्टर को यादृच्छिक रूप से चुना जाए। अन्यथा मैं का प्रयोग करेंगे which.minसे base210 बाइट्स के लिए कुल। अभी भी गोल्फ के लिए जगह है, लेकिन मैं इसे अपने कोड के भीतर संभावित मुद्दों को स्पॉट करने के लिए दूसरों को मौका देने के लिए इसे बहुत अधिक नहीं करना चाहता था।

Answer 8

जूलिया 213 बाइट्स

function f(p,k)
A=0
P=size(p,1)
c=p[randperm(P)[1:k],:]
while(true)
d=[norm(c[i]-p[j]) for i in 1:k, j in 1:P]
a=mapslices(indmin,d,1)
a==A&&return a
A=a
c=[mean(p[vec(a.==i),:],1) for i in 1:k]
end
end

उसी लंबाई की एक सरणी देता है p, जैसा कि पूर्णांक दर्शाता है कि संबंधित क्लस्टर किस तत्व से pसंबंधित है।

मुझे लगता है कि चरित्र की गिनती को अनुकूलित करने के लिए अभी भी बहुत कुछ गुंजाइश है।

(बेशक मैं सिर्फ Clustering.jl पैकेज का उपयोग इसे तुच्छ रूप से करने के लिए कर सकता था)