performance मटैब में गति-कुशल वर्गीकरण




matlab machine-learning (2)

मेरे पास आरजीबी uint8(576,720,3) रूप में आकार की एक छवि है, जहां मैं रंगों के सेट में प्रत्येक पिक्सेल को वर्गीकृत करना चाहता हूं मैंने आरजीबी से एलएबी स्पेस के लिए आरजीबी 2 rgb2lab का उपयोग कर बदल दिया है, और फिर एल परत को हटा दिया है, इसलिए अब यह एबी से मिलकर एक double(576,720,2)

अब, मैं इसे ऐसे कुछ रंगों में वर्गीकृत करना चाहता हूं जिन्हें मैंने किसी अन्य छवि पर प्रशिक्षित किया है, और उनके संबंधित एबी के अभ्यावेदन की गणना की है:

Cluster 1: -17.7903  -13.1170
Cluster 2: -30.1957   40.3520
Cluster 3:  -4.4608   47.2543
Cluster 4:  46.3738   36.5225
Cluster 5:  43.3134  -17.6443
Cluster 6:  -0.9003    1.4042
Cluster 7:   7.3884   11.5584

अब, प्रत्येक पिक्सेल को क्लस्टर 1-7 में वर्गीकृत / लेबल करने के लिए, मैं वर्तमान में निम्न (छद्म कोड) करता हूं:

clusters;
for each x
  for each y
    ab = im(x,y,2:3);
    dist = norm(ab - clusters); // norm of dist between ab and each cluster
    [~, idx] = min(dist);
  end
end

हालांकि, छवि संकल्प की वजह से यह बहुत धीमी गति से (52 सेकंड) है और मैं मैन्युअल रूप से प्रत्येक एक्स और वाई के माध्यम से पाश है।

क्या कुछ अंतर्निहित कार्य हैं जो मैं उसी काम का उपयोग कर सकता हूं? वहाँ होना चाहिए।

संक्षेप करने के लिए: मुझे एक वर्गीकरण विधि की आवश्यकता है जो पिक्सेल छवियों को पहले से परिभाषित समूहों के समूह में वर्गीकृत करता है


Answer #1

pdist2 तरीके से दूरी को मापने के लिए pdist2 (सांख्यिकी टूलबॉक्स) का उपयोग करें:

ab = im(:,:,2:3);                              % // get A, B components
ab = reshape(ab, [size(im,1)*size(im,2) 2]);   % // reshape into 2-column
dist = pdist2(clusters, ab);                   % // compute distances
[~, idx] = min(dist);                          % // find minimizer for each pixel
idx = reshape(idx, size(im,1), size(im,2));    % // reshape result

यदि आपके पास सांख्यिकी टूलबॉक्स नहीं है, तो आप तीसरे पंक्ति को प्रतिस्थापित कर सकते हैं

dist = squeeze(sum(bsxfun(@minus, clusters, permute(ab, [3 2 1])).^2, 2));

यह दूरी के बजाय स्क्वेयर दूरी देता है, लेकिन कम से कम करने के प्रयोजनों के लिए कोई फर्क नहीं पड़ता।


Answer #2

दृष्टिकोण # 1

N x 2 आकार के अंक / पिक्सेल सरणी के लिए, लुइस द्वारा अन्य समाधान में सुझाव दिए गए अनुसार आप permute से बच सकते हैं, जो चीजों को थोड़ी धीमा कर सकते हैं, इसके एक प्रकार का "permute-unrolled" संस्करण बना सकते हैं और यह भी bsxfun काम करते हैं एक 3D सरणी के बजाय 2D सरणी की ओर, जो प्रदर्शन के साथ बेहतर होना चाहिए।

इस प्रकार, समूहों को N x 2 आकार की सरणी के रूप में मानते हुए, आप इस अन्य bsxfun आधारित दृष्टिकोण की कोशिश कर सकते हैं -

%// Get a's and b's
im_a = im(:,:,2);
im_b = im(:,:,3);

%// Get the minimum indices that correspond to the cluster IDs
[~,idx]  = min(bsxfun(@minus,im_a(:),clusters(:,1).').^2 + ...
    bsxfun(@minus,im_b(:),clusters(:,2).').^2,[],2);
idx = reshape(idx,size(im,1),[]);

दृष्टिकोण # 2

आप एक अन्य दृष्टिकोण की कोशिश कर सकते हैं fast matrix multiplication in MATLAB लाभ उठाता है और यह स्मार्ट समाधान पर आधारित है -

d = 2; %// dimension of the problem size

im23 = reshape(im(:,:,2:3),[],2);

numA = size(im23,1);
numB = size(clusters,1);

A_ext = zeros(numA,3*d);
B_ext = zeros(numB,3*d);
for id = 1:d
    A_ext(:,3*id-2:3*id) = [ones(numA,1), -2*im23(:,id), im23(:,id).^2 ];
    B_ext(:,3*id-2:3*id) = [clusters(:,id).^2 ,  clusters(:,id), ones(numB,1)];
end
[~, idx] = min(A_ext * B_ext',[],2); %//'
idx = reshape(idx, size(im,1),[]); %// Desired IDs

मैट्रिक्स गुणा आधारित दूरी मैट्रिक्स गणना के साथ क्या हो रहा है?

आइए हम दो मैट्रिक्स A और B पर विचार करें जिनके बीच हम दूरी मैट्रिक्स की गणना करना चाहते हैं। अगले आसान ढंग से एक सरल व्याख्या के लिए, आइए 3 x 2 और B रूप में 4 x 2 आकार के एरे पर विचार करें, इस प्रकार यह दर्शाता है कि हम एक्सवाई अंक के साथ काम कर रहे हैं। अगर हमारे पास A N x 3 और B रूप में M x 3 आकार के एरे थे, तो वे XYZ अंक होंगे।

अब, यदि हमें मैन्युअल रूप से दूरी मैट्रिक्स के वर्ग के पहले तत्व की गणना करनी है, तो यह ऐसा दिखेगा -

first_element = ( A(1,1)B(1,1) )^2 + ( A(1,2)B(1,2) )^2         

जो होगा -

first_element = A(1,1)^2 + B(1,1)^2 -2*A(1,1)* B(1,1)   +  ...
                A(1,2)^2 + B(1,2)^2 -2*A(1,2)* B(1,2)Equation  (1)

अब, हमारे प्रस्तावित मैट्रिक्स गुणा के अनुसार, यदि आप पहले कोड में लूप के बाद A_ext और B_ext के आउटपुट को A_ext , तो वे निम्नलिखित की तरह दिखाई देंगे -

इसलिए, यदि आप A_ext और A_ext बीच मैट्रिक्स गुणा करते हैं, तो उत्पाद का पहला तत्व A_ext और B_ext की पहली पंक्तियों के बीच तत्ववत् गुणा का योग होगा, अर्थात ये राशि -

इसका परिणाम Equation (1) से प्राप्त परिणाम के समान होगा। यह B सभी तत्वों के विरुद्ध A के सभी तत्वों के लिए जारी रहेगा जो A में समान स्तंभ में हैं। इस प्रकार, हम पूर्ण स्क्वेर्ड दूरी मैट्रिक्स के साथ समाप्त होगा। यह सब वहाँ है !!

वेक्टर वैराइजेशन

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

बदलाव # 1

[nA,dim] = size(A);
nB = size(B,1);

A_ext = ones(nA,dim*3);
A_ext(:,2:3:end) = -2*A;
A_ext(:,3:3:end) = A.^2;

B_ext = ones(nB,dim*3);
B_ext(:,1:3:end) = B.^2;
B_ext(:,2:3:end) = B;

distmat = A_ext * B_ext.';

बदलाव # 2

[nA,dim] = size(A);
nB = size(B,1);

A_ext = [ones(nA*dim,1) -2*A(:) A(:).^2];
B_ext = [B(:).^2 B(:) ones(nB*dim,1)];

A_ext = reshape(permute(reshape(A_ext,nA,dim,[]),[1 3 2]),nA,[]);
B_ext = reshape(permute(reshape(B_ext,nB,dim,[]),[1 3 2]),nB,[]);

distmat = A_ext * B_ext.';

इसलिए, इन्हें प्रायोगिक संस्करणों के रूप में भी माना जा सकता है।





data-mining