堆栈内存溢出
  繁体   English   中英

如何在 Matlab 中加速我的代码 [包括示例]？

[英]How to speed up my code [includes example] in Matlab?

 原文  2016-03-11 17:38:31  5   1    algorithm/ performance/ matlab/ image-processing

问题描述

我想加快我的代码。 目前，我使用 if 语句来做到这一点。 但是，如果我们使用卷积方式，它可以制作更快的代码。 但是，它仅适用于简单情况（如成对邻域）。 让我们定义我的问题。

我有一个矩阵I=[1 1 1;2 2 2;2 2 1]有两个标签{1,2} 。 我添加了填充作为其右侧。 对于I中的每个像素，我们可以定义邻域的成对或三元组。 我们将根据规则检查“如果这些邻域值与像素具有相同的类，则设置成本值等于-beta ，否则设置成本等于beta ”。

在此处输入图片说明

例如，让我们考虑上图中的黄色像素。 它的标签是 2。我们需要计算可能的邻域情况的总成本值，如最右侧所示。 有趣像素的值将从标签 {1,2} 设置。 上图中。 我只展示了第一种情况，将黄色像素设置为 1。我们可以有相同的数字，但在下一种情况下设置黄色像素为 2。 我的任务是根据上述规则计算成本函数。

这是我的代码。 但是，它使用 if 语句。 它是如此缓慢。 你能帮我加快速度吗？ 我尝试使用卷积方式，但我不知道如何为邻域三重定义掩码。 谢谢大家

function U=compute_gibbs(Imlabel,beta,num_class)
num_class=2;
Imlabel=[1 1 1;2 2 2;2 2 1]
beta=1;
U=zeros([size(Imlabel) num_class]);
Imlabel = padarray(Imlabel,[1 1],'replicate','both');
[row,col] = size(Imlabel);
for ii = 2:row-1        
    for jj = 2:col-1
        for l = 1:num_class
            U(ii-1,jj-1,l)=GibbsEnergy(Imlabel,ii,jj,l,beta);
        end
    end
end
function energy = GibbsEnergy(img,i,j,label,beta)
    % img is the labeled image
    energy = 0;
    if (label == img(i,j)) energy = energy-beta;
        else energy = energy+beta;end        
    % North, south, east and west
    if (label == img(i-1,j)) energy = energy-beta;
        else energy = energy+beta;end
    if (label == img(i,j+1)) energy = energy-beta;
        else energy = energy+beta;end
    if (label == img(i+1,j)) energy = energy-beta;
        else energy = energy+beta;end
    if (label == img(i,j-1)) energy = energy-beta;
        else energy = energy+beta;end
    % diagonal elements
    if (label == img(i-1,j-1)) energy = energy-beta;
        else energy = energy+beta;end
    if (label == img(i-1,j+1)) energy = energy-beta;
        else energy = energy+beta;end
    if (label == img(i+1,j+1)) energy = energy-beta;
        else energy = energy+beta;end
    if (label == img(i+1,j-1)) energy = energy-beta;
        else energy = energy+beta;end
     %% Triangle elements
    % Case a 
    if(label==img(i-1,j)&label==img(i-1,j-1)) energy = energy-beta;
        else energy = energy+beta;end 
    if(label==img(i,j-1)&label==img(i+1 ,j)) energy = energy-beta;
        else energy = energy+beta;end
    if(label==img(i,j+1)&&label==img(i+1 ,j+1)) energy = energy-beta;
        else energy = energy+beta;end 
    % Case b 
    if(label==img(i-1,j-1)&label==img(i,j-1)) energy = energy-beta;
        else energy = energy+beta;end     
     if(label==img(i-1,j)&label==img(i ,j+1)) energy = energy-beta;
        else energy = energy+beta;end  
     if(label==img(i+1,j)&label==img(i+1,j+1)) energy = energy-beta;
         else energy = energy+beta;end  
    % Case c   
    if(label==img(i,j-1)&label==img(i+1,j-1)) energy = energy-beta;
         else energy = energy+beta;end  
    if(label==img(i+1,j)&label==img(i,j+1)) energy = energy-beta;
         else energy = energy+beta;end  
    if(label==img(i-1 ,j)&label==img(i-1,j+1)) energy = energy-beta;
        else energy = energy+beta;end 
    % Case d 
    if(label==img(i,j-1)&label==img(i-1,j)) energy = energy-beta;
        else energy = energy+beta;end 
    if(label==img(i-1 ,j+1)&label==img(i,j+1)) energy = energy-beta;
        else energy = energy+beta;end 
     if(label==img(i+1,j-1)&label==img(i+1 ,j)) energy = energy-beta;
        else energy = energy+beta;end 

    %% Rectangular
    if(label==img(i-1,j-1)&label==img(i,j-1)&label==img(i-1 ,j)) energy = energy-beta;
        else energy = energy+beta;end 
    if(label==img(i,j-1)&label==img(i+1,j-1)&label==img(i+1 ,j)) energy = energy-beta;
        else energy = energy+beta;end 
     if(label==img(i+1,j)&label==img(i +1 ,j+1)&label==img(i,j+1)) energy = energy-beta;
        else energy = energy+beta;end 
     if(label==img(i-1,j)&label==img(i-1,j+1)&label==img(i ,j+1)) energy = energy-beta;
        else energy = energy+beta;end

这是一种更快的方法。 但它只适用于简单的情况（成对的邻里第一行），而我的情况包括单个、三重......邻里

C = double(bsxfun(@eq, Imlabel, permute(1:num_class, [1 3 2])));
C(C == 0) = 0;
C(C == 1) = beta;
%% Replace if statement
mask = zeros(3,3); mask(2,2) = 1;
Cpad = convn(C, mask);
Cpad(Cpad == 0) = 0;

mask2 = ones(3,3); mask2(2,2) = 0;
energy = convn(Cpad, mask2, 'valid');

1 个解决方案

解决方案1
 1 已采纳  2016-03-14 17:41:59

这是我在这方面的尝试。 我真的不能确定任何一个对你来说是否会更快，因为我使用的是 Octave 而不是 MATLAB，而且时间可能会有很大不同。 例如， for循环在 Octave 中仍然需要永远。 你必须测试它们，看看它们如何比较。

矩阵乘法

正如@AnderBiguri 在评论中指出的那样，一种方法是使用矩阵乘法。 如果你拿一个 3x3 的邻域，说

nbr = [0 0 0;
       1 0 0;
       1 1 0];

并且您想知道左上角的元素是否为1 ，您可以通过掩码执行逐元素乘法

mask = [1 0 0;
        0 0 0;
        0 0 0];

result = sum(mask .* nbr);

（我在这里假设邻域是一个二进制矩阵，这是一个捷径。当我得到实际代码时，我将简单地使用nbr == current_class来实现这一点。）

如果结果与掩码具有相同数量的1元素，那么您就匹配了。 在这种情况下，这两者的逐元素乘法全为零，因此不匹配。

而不是逐元素乘法然后对结果的元素求和，我们可以将nbr和mask转换为向量并使用向量乘法：

m = mask(:).';
n = nbr(:);
result = m * n;

这将为您提供与先前结果相同的值。 如果您有一个掩码矩阵，则可以将其乘以邻域向量并立即获得所有结果。 所以第一步是生成25个掩码向量：

masks = [
   0   0   0   0   1   0   0   0   0;
   0   0   0   0   0   1   0   0   0;
   0   0   0   1   0   0   0   0   0;
   0   0   0   0   0   0   0   1   0;
   0   1   0   0   0   0   0   0   0;
   1   0   0   0   0   0   0   0   0;
   0   0   0   0   0   0   0   0   1;
   0   0   0   0   0   0   1   0   0;
   0   0   1   0   0   0   0   0   0;
   1   1   0   0   0   0   0   0   0;
   1   0   0   1   0   0   0   0   0;
   0   0   0   1   0   0   1   0   0;
   0   0   0   0   0   0   1   1   0;
   0   0   0   0   0   0   0   1   1;
   0   0   0   0   0   1   0   0   1;
   0   0   1   0   0   1   0   0   0;
   0   1   1   0   0   0   0   0   0;
   0   0   0   1   0   0   0   1   0;
   0   0   0   0   0   1   0   1   0;
   0   1   0   1   0   0   0   0   0;
   0   1   0   0   0   1   0   0   0;
   1   1   0   1   0   0   0   0   0;
   0   0   0   1   0   0   1   1   0;
   0   0   0   0   0   1   0   1   1;
   0   1   1   0   0   1   0   0   0];

现在，当您将masks乘以邻域时，您会立即获得所有结果。 然后将结果与masks行的总和进行比较，以查看哪些匹配。

result = masks * n;
matches = sum(masks, 2) == result;
match_count = sum(matches);

对于每场比赛，我们从能量中减去beta 。 对于每个不匹配，我们添加beta ，所以

possible_matches = 25; %// the number of neighborhood types
energy = -beta * match_count + beta * (possible_matches - match_count);

现在我们要做的就是弄清楚如何从我们的图像中获取所有 3x3 邻域。 幸运的是，MATLAB 有im2col函数可以做到这一点。 更好的是，它只需要图像的有效邻域，所以如果它已经被填充，你就可以开始了。

function G = gibbs(img, beta, classcount)

   masks = [
      0   0   0   0   1   0   0   0   0;
      0   0   0   0   0   1   0   0   0;
      0   0   0   1   0   0   0   0   0;
      0   0   0   0   0   0   0   1   0;
      0   1   0   0   0   0   0   0   0;
      1   0   0   0   0   0   0   0   0;
      0   0   0   0   0   0   0   0   1;
      0   0   0   0   0   0   1   0   0;
      0   0   1   0   0   0   0   0   0;
      1   1   0   0   0   0   0   0   0;
      1   0   0   1   0   0   0   0   0;
      0   0   0   1   0   0   1   0   0;
      0   0   0   0   0   0   1   1   0;
      0   0   0   0   0   0   0   1   1;
      0   0   0   0   0   1   0   0   1;
      0   0   1   0   0   1   0   0   0;
      0   1   1   0   0   0   0   0   0;
      0   0   0   1   0   0   0   1   0;
      0   0   0   0   0   1   0   1   0;
      0   1   0   1   0   0   0   0   0;
      0   1   0   0   0   1   0   0   0;
      1   1   0   1   0   0   0   0   0;
      0   0   0   1   0   0   1   1   0;
      0   0   0   0   0   1   0   1   1;
      0   1   1   0   0   1   0   0   0];

   [m,n] = size(img);
   possible_matches = size(masks, 1);
   Imlabel = padarray(img, [1 1], 'replicate', 'both');

   col_label = im2col(Imlabel, [3 3], 'sliding');
   target = repmat(sum(masks, 2), [1, m*n]);

   for ii = 1:classcount
      found = masks*(col_label == ii);
      match_count = sum(found == target, 1);
      energy = -beta * match_count + beta*(possible_matches - match_count);
      G(:,:,ii) = reshape(energy, m, n);
   end

end

查找表

如果您查看矩阵乘法解决方案，它会将每个像素的邻域乘以 25 个掩码。 对于 1000 x 1000 图像，即1000 x 1000 x 25 x 9 = 225M乘法。 但是只有512 (2^9) 个可能的邻居配置。 所以如果我们弄清楚这 512 个配置是什么，将它们乘以掩码，然后总结匹配，我们就有了一个 512 个元素的查找表，我们需要为图像中的每个邻域做的就是计算它的指数。 以下是使用上面的masks创建查找表的方法：

possible_neighborhoods = de2bi(0:511, 9).';
found = masks * possible_neighborhoods;
target = repmat(sum(masks, 2), [1, size(found, 2)]);
LUT = sum(found == target, 1);

这几乎是我们之前在每个循环中所做的，但我们对所有可能的邻域都这样做，这相当于数字0:511所有位模式。

现在，我们想要一个十进制索引到查找表中，而不是每个像素乘以掩码的二进制向量。 为此，我们可以将conv2与一个有效地进行二进制到十进制转换的内核一起使用：

k = [1   8   64;
     2  16  128;
     4  32  256];

or

k = [2^0  2^3  2^6
     2^1  2^4  2^7
     2^2  2^5  2^8];

这将为我们提供每个像素的0:511值，因此我们添加一个以获得1:512并将其用作查找表的索引。 这是完整的代码：

function G = gibbs2(img, beta, classcount)

   masks = [
      0   0   0   0   1   0   0   0   0;
      0   0   0   0   0   1   0   0   0;
      0   0   0   1   0   0   0   0   0;
      0   0   0   0   0   0   0   1   0;
      0   1   0   0   0   0   0   0   0;
      1   0   0   0   0   0   0   0   0;
      0   0   0   0   0   0   0   0   1;
      0   0   0   0   0   0   1   0   0;
      0   0   1   0   0   0   0   0   0;
      1   1   0   0   0   0   0   0   0;
      1   0   0   1   0   0   0   0   0;
      0   0   0   1   0   0   1   0   0;
      0   0   0   0   0   0   1   1   0;
      0   0   0   0   0   0   0   1   1;
      0   0   0   0   0   1   0   0   1;
      0   0   1   0   0   1   0   0   0;
      0   1   1   0   0   0   0   0   0;
      0   0   0   1   0   0   0   1   0;
      0   0   0   0   0   1   0   1   0;
      0   1   0   1   0   0   0   0   0;
      0   1   0   0   0   1   0   0   0;
      1   1   0   1   0   0   0   0   0;
      0   0   0   1   0   0   1   1   0;
      0   0   0   0   0   1   0   1   1;
      0   1   1   0   0   1   0   0   0];

   [m,n] = size(img);
   possible_matches = size(masks, 1);
   possible_neighborhoods = de2bi(0:511, 9).';   %'
   found = masks * possible_neighborhoods;
   target = repmat(sum(masks, 2), [1, size(found, 2)]);
   LUT = sum(found == target, 1);
   
   k = [1   8   64;
        2  16  128;
        4  32  256];
        
   Imlabel = padarray(img, [1 1], 'replicate', 'both');

   for ii = 1:classcount
      filterImage = conv2(double(Imlabel == ii), k, 'valid');
      matchImg = LUT(filterImage + 1);
      G(:,:,ii) = -beta * matchImg + beta * (possible_matches - matchImg);
   end
   
end

由于我们对 1000x1000 图像执行的乘法要少得多，因此这种方法比我的机器上使用 Octave 的矩阵乘法方法快 7 倍。

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 如何加速这个已经矢量化的 matlab 代码 如何加速指数时间码 如何加速Python字符串匹配代码 如何加快我的内存扫描程序？ 如何加快我的双线性插值？ 如何加快算法速度？ 加快python中的代码 如何加快代码解决位删除难题 如何加快可和数字算法？ 如何加快Aho-Corasick算法的速度？
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM