Question

我正在寻找一种编程这个总和比率的最佳方法。作为输入，我有两个向量v_mn和x_mn，每个向量都有(M*N)x1元素。

该比例的形式如下：

$r=\dfrac{v_{mn}x_{mn}}{1+\sum\limits_{m'=1,m'\neq m}^{M}\sum\limits_{n'=1,n'\neq n}^{N}v_{mn'}x_{m'n'}}$

向量x_mn是0-1向量，因此在x_mn=1时，上面给出了r，而x_mn=0时的比率为0

向量v_mn是一个包含实数的向量。

我做了这样的分母，但需要很多次。

function r_ij = denominator(v_mn, M, N, i, j)
%here x_ij=1, to get r_ij.
S = [];
for m = 1:M
  for n = 1:N
    if (m ~= i)
      if (n ~= j)
        S = [S v_mn(i, n)];
      else
        S = [S 0];
      end
    else
      S = [S 0];
    end
  end
end
r_ij = 1+S;
end

你能在matlab中做一个好方法吗？你可以忽略这个比例，给我一个更复杂的分母。

编辑：对不起，我写的不是很好。 i和j分别是1..M和1..N之间的一些数字。如您所见，比率r是多个值（M*N值）。所以我只计算了值i和j。更准确地说，我认为x_ij=1。另外，我将向量v_mn转换为一个矩阵，这就是我使用双索引的原因。

Answer 1

如果重塑数据，则总和只是重复的矩阵/向量乘法。

以下是单个m和n的实现，以及简单的速度/相等性测试：

clc

%# some arbitrary test parameters
M = 250;
N = 1000;
v = rand(M,N);   %# (you call it v_mn)
x = rand(M,N);   %# (you call it x_mn)

m0 = randi(M,1); %# m of interest
n0 = randi(N,1); %# n of interest 


%# "Naive" version
tic
S1 = 0;
for mm = 1:M %# (you call this m')
    if mm == m0, continue; end
    for nn = 1:N %# (you call this n')
        if nn == n0, continue; end
        S1 = S1 + v(m0,nn) * x(mm,nn);
    end
end
r1 = v(m0,n0)*x(m0,n0) / (1+S1);
toc


%# MATLAB version: use matrix multiplication!
tic

ninds = [1:m0-1 m0+1:M];
minds = [1:n0-1 n0+1:N];
S2 = sum( x(minds, ninds) * v(m0, ninds).' );
r2 = v(m0,n0)*x(m0,n0) / (1+S2);

toc


%# Test if values are equal
abs(r1-r2) < 1e-12

我机器上的输出：

Elapsed time is 0.327004 seconds.   %# loop-version
Elapsed time is 0.002455 seconds.   %# version with matrix multiplication
ans =  
     1                              %# and yes, both are equal

所以加速是~133×

现在只有m和n的单个值。要为m和n的所有值执行此操作，您可以使用（优化的）双循环：

r = zeros(M,N);
for m0 = 1:M   
    xx = x([1:m0-1 m0+1:M], :);
    vv = v(m0,:).';
    for n0 = 1:N
        ninds    = [1:n0-1 n0+1:N];        
        denom    = 1 + sum( xx(:,ninds) * vv(ninds) );
        r(m0,n0) = v(m0,n0)*x(m0,n0)/denom;        
    end
end

在我的电脑上用M = 250, N= 1000（R2010a）在~15秒内完成。

编辑：实际上，经过多一点思考，我能够将其全部减少到这一点：

denom = zeros(M,N);
for mm = 1:M    
    xx = x([1:mm-1 mm+1:M],:);
    denom(mm,:) = sum( xx*v(mm,:).' ) - sum( bsxfun(@times, xx, v(mm,:)) );    
end
denom = denom + 1;

r_mn = x.*v./denom;

，N = 250和M = 1000 :)

在不到1秒的时间内完成

Answer 2

首先，您需要预先分配S矩阵。它会改变每个循环的大小，所以

S = zeros(m*n, 1)

在你的功能开始时。这也将允许您取消其他条件语句，即它们将减少到：

if (m ~= i)
   if (n ~= j)
      S(m*M + n) = v_mn(i, n);

否则，因为你必须访问每个元素，我担心它可能无法更快。

如果你迫切需要更高的速度，你可以考虑做一些mex编码，这是c / c ++中的代码，但是在matlab中运行。

http://www.mathworks.com.au/help/matlab/matlab_external/introducing-mex-files.html

Answer 3

您可能需要修改上述内容以确保它能够执行您想要的操作，而不是首先跳转到双循环的矢量化。在此代码中，没有数据的求和，而是在每次迭代时调整向量S。同样，签名可以包括矩阵V和X，以便乘法发生在公式中（而不是仅仅依赖于X的值为零或一，让我们传递该矩阵）。

该函数可能看起来更像下面的内容（我用m替换了i，j输入，n更像是等式）：

function result = denominator(V,X,m,n)

% use the size of V to determine M and N
[M,N] = size(V);

% initialize the summed value to one (to account for one at the end)
result = 1;

% outer loop
for i=1:M
    % ignore the case where m==i
    if i~=m
        for j=1:N
            % ignore the case where n==j
            if j~=n
                result = result + V(m,j)*X(i,j);
            end
         end
     end
 end

注意第一个if如何在内部for循环之外，因为它不依赖于j。试试上面的内容，看看会发生什么！

Answer 4

您可以在Matlab中进行矢量化以加快计算速度。每次使用＆＃34;。^＆＃34;等操作时或＆＃34;。*＆＃34;或者对于这个问题的任何矩阵运算，Matlab将并行执行，这比迭代每个项目快得多。

在这种情况下，请查看您在矩阵方面所做的工作。首先，在你的循环中，你只处理$ V_ {nm} $的第m行，我们可以将其用作自身的向量。

如果你仔细看一下你的公式，你可以看出你几乎到了那里，如果你只是把这个行向量写成一个列向量，并使用标准矩阵将矩阵$ X_ {nm} $从左边乘以它乘法。结果向量包含所有n的总和。要获得最终结果，只需总结一下这个向量。

function result = denominator_vectorized(V,X,m,n)

% get the part of V with the first index m
Vm = V(m,:)';
% remove the parts of X you don't want to iterate over. Note that, since I
% am inside the function, I am only editing the value of X within the scope
% of this function.
X(m,:) = 0;
X(:,n) = 0;

%do the matrix multiplication and the summation at once
result = 1-sum(X*Vm);

为了向您展示如何优化您的操作，我将其与另一位评论者提出的代码进行比较：

function result = denominator(V,X,m,n)

% use the size of V to determine M and N
[M,N] = size(V);

% initialize the summed value to one (to account for one at the end)
result = 1;

% outer loop
for i=1:M
% ignore the case where m==i
if i~=m
    for j=1:N
        % ignore the case where n==j
        if j~=n
            result = result + V(m,j)*X(i,j);
        end
     end
 end
end

测试：

V=rand(10000,10000);
X=rand(10000,10000);
disp('looped version')
tic
denominator(V,X,1,1)
toc
disp('matrix operation')
tic
denominator_vectorized(V,X,1,1)
toc

结果：

looped version

ans =

   2.5197e+07

Elapsed time is 4.648021 seconds.
matrix operation

ans =

   2.5197e+07

Elapsed time is 0.563072 seconds.

这几乎是循环迭代速度的十倍。因此，请始终注意代码中可能的矩阵运算。如果您安装了Parallel Computing Toolbox并安装了支持CUDA的图形卡，Matlab甚至可以在您的图形卡上执行这些操作，而无需您做任何进一步的努力！

编辑：最后一点并非完全正确。你仍然需要采取一些步骤来对CUDA硬件进行操作，但它们并不是很多。请参阅Matlab文档。

在matlab中有效地计算双和？

4 个答案: