Efficient Multiplication of Matrices with Large Numbers of Zeroes - matlab

Question

I have two arrays that take the following form:
0…0…0 0 0 0…0 0…0…0 0 0 0…0
⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮
0…0 0 0 0 0…0 0…0 0 0 0 0…0
A = 0…0 1 2 3 0…0 B = 0…0 9 8 7 0…0
0…0 4 5 6 0…0 0…0 6 5 4 0…0
0…0 0 0 0 0…0 0…0 0 0 0 0…0
⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮
0…0…0 0 0 0…0 0…0…0 0 0 0…0
The size of the non-zero areas of A and B may not be exactly the same, but the diagram above is already getting a bit unwieldy.
Ultimately, the value I'm after is sum(sum(A .* B)). I feel like there must be a way to only multiply the non-zero elements, but every approach I can come up with seems to cause MATLAB to make a copy of the matrix, which utterly destroys any gains made by reducing the number of operations. B is reused for several iterations of the inner loop, so I can amortize expensive calculations on B over many loop iterations.
I've tried the following approaches so far:
Naive Approach:
function C = innerLoop(A, B)
C = sum(sum(A .* B))
end
innerLoop takes about 4.3 seconds over 86,000 calls using this. (Based on MATLAB's "Run and Time" functionality.)
Shrinking B First:
function B = resize(self, B1)
rows = abs(sum(B, 2)) > 1e-4;
top = find(rows, 1, 'first');
bot = find(rows, 1, 'last');
cols = abs(sum(B, 1)) > 1e-4;
left = find(cols, 1, 'first');
right = find(cols, 1, 'last');
self.Rows = top:bot; % Store in class properties for use in inner loop
self.Cols = left:right; % Store in class properties for use in inner loop
B = B(top:bot, left:right);
end
function C = innerLoop(A, B)
result = A(self.Rows, self.Cols) .* B;
C = sum(sum(result));
end
My hope with this approach was that MATLAB would realize that I wasn't writing to A and elide the copy, but this approach spends about 6.8 seconds in innerLoop.
I also tried only calculation the offsets outside innerLoop in the hopes that MATLAB might be able to pick up on the fact that I'm using the same subscripts on both matrices to optimize things:
function B = resize(self, B1)
rows = abs(sum(B, 2)) > 1e-4;
top = find(rows, 1, 'first');
bot = find(rows, 1, 'last');
cols = abs(sum(B, 1)) > 1e-4;
left = find(cols, 1, 'first');
right = find(cols, 1, 'last');
self.Rows = top:bot; % Store in class properties for use in inner loop
self.Cols = left:right; % Store in class properties for use in inner loop
end
function C = innerLoop(A, B)
result = A(self.Rows, self.Cols) .* B(self.Rows, self.Cols);
C = sum(sum(result));
end
Unfortunately this was the slowest yet at about 8.6 seconds.
I also tried looping with the following code:
function C = innerLoop(A, B)
C = 0;
for i = self.Rows
for j = self.Cols
C = C + field(i, j) * self.Sensitivity.Z(i, j);
end
end
end
I know that looping used to be very slow in MATLAB, but I've read some papers indicating that it is much faster than it used to be. That said, if the loop version ever finishes running, I'll let you know how long it took, but it's well over a couple minutes by now.
Any suggestions on how to optimize this would be greatly appreciated!

Answer 1

You can use sparse matrices for this problem. Matlab handles different sizes of the «non-sparse-part» automatically. To get a sparse matrix, the sparse-function is used. After that you can do the element-wise multiplication and then sum all elements of C in a separate line.
A = [0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 1 2 3 0 0;
0 0 4 5 6 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
B = [0 0 0 0 0 0 0;
0 0 0 0 0 0 0;
0 0 9 8 7 0 0;
0 0 6 5 4 0 0;
0 0 0 0 0 0 0;
0 0 0 0 0 0 0];
A = sparse(A);
B = sparse(B);
C = A .* B;
sum(C(:))

Answer 2

This is a rewrite of my initial post
I stand corrected. I don't know what went wrong in my former test. I thought it may have been a 32 vs 64 bit implementation of the sparse algorithm but not even. After careful re-running of the benchmark on 2 different machines, the sparse method wins then all.
Benchmark code:
function ExecTimes = bench_sum_sparse
nOrder = (1:9).' * 10.^(2:3) ; nOrder = [nOrder(:) ; (1:2).'*1e4] ;
%// nOrder = (1:30)*100 ;
npt = numel(nOrder) ;
ExecTimes = zeros( npt , 3 ) ;
fprintf('\n%s%5d \n','Calculating for N = ',0) ;
for k = 1:npt
% // sample data
N = nOrder(k) ;
fprintf('\b\b\b\b\b\b%5d\n',N) ; % // display progress
A = zeros(N) ;
B = A ;
innerMat = (1:10).'*(1:10) ; %'
ixInnerMat = innerMat + N/2 - 5 ;
A(ixInnerMat) = innerMat ;
B(ixInnerMat) = innerMat ;
% // benchmark
f1 = #() innerLoop(A,B) ;
ExecTimes(k,1) = timeit( f1 ) ;
clear f1
f2 = #() sum_logicIndex(A, B) ;
ExecTimes(k,2) = timeit( f2 ) ;
clear f2
A = sparse(A);
B = sparse(B);
f3 = #() sum_sparse(A,B) ;
ExecTimes(k,3) = timeit( f3 ) ;
clear f3
%// checksum1 = f1() - f2 ()
%// checksum2 = f1() - f3 ()
end
end
function C = innerLoop(A, B)
C = sum(sum(A .* B)) ;
end
function C = sum_logicIndex(A,B)
idx = A>0 & B>0 ;
C = sum(sum(A(idx).*B(idx))) ;
end
function C = sum_sparse(A,B)
C = A .* B;
C = sum(C(:)) ;
end
All tests ran on Matlab 2013b
64 bit Machine : Intel I7-3820 # 3.6GHz - 16 GB RAM - Windows 7
32 bit Machine : Intel E2200 # 2.2GHz - 3GB RAM - Windows 8.1