hurdle模型matlab实现,Nested for loops extremely slow in MATLAB (preallocated)

问题

I am trying to learn MATLAB and one of the first problems I encountered was to guess the background from an image sequence with a static camera and moving objects. For a start I just want to do a mean or median on pixels over time, so it's just a single function I would like to apply to one of the rows of the 4 dimensional array.

I have loaded my RGB images in a 4 dimensional array with the following dimensions:

uint8 [ num_images, width, height, RGB ]

Here is the function I wrote which includes 4 nested loops. I use preallocation but still, it is extremely slow. In C++ I believe this function could run at least 10x-20x faster, and I think on CUDA it could actually run in real time. In MATLAB it takes about 20 seconds with the 4 nested loops. My stack is 100 images with 640x480x3 dimensions.

function background = calc_background(stack)

tic;

si = size(stack,1);

sy = size(stack,2);

sx = size(stack,3);

sc = size(stack,4);

background = zeros(sy,sx,sc);

A = zeros(si,1);

for x = 1:sx

for y = 1:sy

for c = 1:sc

for i = 1:si

A(i) = stack(i,y,x,c);

end

background(y,x,c) = median(A);

end

end

end

background = uint8(background);

disp(toc);

end

Could you tell me how to make this code much faster? I have tried experimenting with somehow getting the data directly from the array using only the indexes and it seems MUCH faster. It completes in 3 seconds vs. 20 seconds, so that’s a 7x performance difference, just by writing a smaller function.

function background = calc_background2(stack)

tic;

% bad code, confusing

% background = uint8(squeeze(median(stack(:, 1:size(stack,2), 1:size(stack,3), 1:3 ))));

% good code (credits: Laurent)

background=uint8((squeeze(median(stack,1)));

disp(toc);

end

So now I don't understand if MATLAB could be this fast then why is the nested loop version so slow? I am not making any dynamic resizing and MATLAB must be running the same 4 nested loops inside.

Why is this happening?

Is there any way to make nested loops run fast, like it would happen naturally in C++?

Or should I get used to the idea of programming MATLAB in this crazy one line statements way to get optimal performance?

Update

Thank you for all the great answers, now I understand a lot more. My original code with stack(:, 1:size(stack,2), 1:size(stack,3), 1:3 )) didn't make any sense, it is exactly the same as stack, I was just lucky with median's default option of using the 1st dimension for its working range.

I think it's better to ask how to write an efficient question in an other question, so I asked it here:

How to write vectorized functions in MATLAB

回答1:

If I understand your question, you're asking why Matlab is faster for matrix operations than for procedural programming calls. The answer is simply that that's how it's designed. If you really want to know what makes it that way, you can read this newsletter from Matlab's website which discusses some of the underlying technology, but you probably won't get a great answer, as the software is proprietary. I also found some relevant pages by simply googling, and this old SO question

also seems to address your question.

回答2:

Matlab is an interpreted language, meaning that it must evaluate each line of code of your script.

Evaluating is a lengthy process since it must parse, 'compile' and interpret each line*.

Using for loops with simple operations means that matlab takes far more time parsing/compiling than actually executing your code.

Builtin functions, on the other hand are coded in a compiled language and heavily optimized. They're very fast, hence the speed difference.

Bottom line: we're very used to procedural language and for loops, but there's almost always a nice and fast way to do the same things in a vectorized way.

* To be complete and to pay honour to whom honour is due: recent versions of Matlab actually tries to accelerate loops by analyzing repeated operations to compile chunks of repetitive operations into native executable. This is called Just In Time compilation (JIT) and was pointed out by Jonas in the following comments.

Original answer:

If I understood well (and you want the median of the first dimension) you might try:

background=uint8((squeeze(median(stack,1)));

回答3:

Well, the difference between both is their method of executing code. To sketch it very roughly: in C you feed your code to a compiler which will try to optimize your code or at any rate convert it to machine code. This takes some time, but when you actually execute your program, it is in machine code already and therefore executes very fast. You compiler can take a lot of time trying to optimize the code for you, in general you don't care whether it takes 1 minute or 10 minutes to compile a distribution-ready program.

MATLAB (and other interpreted languages) don't generally work that way. When you execute your program, an interpreter will interprete each line of code and transform it into a sequence of machine code on the fly. This is a bit slower if you write for-loops as it has to interprete the code over and over again (at least in principle, there are other overheads which might matter more for the newest versions of MATLAB). Here the hurdle is the fact that everything has to be done at runtime: the interpreter can perform some optimizations, but it is not useful to perform time-consuming optimizations that might increase performance by a lot in some cases as they will cause performance to suffer in most other cases.

You might ask what you gain by using MATLAB? You gain flexibility and clear semantics. When you want to do a matrix multiplication, you just write it as such; in C this would yield a double for loop. You have to worry very little about data types, memory management, ...

Behind the scenes, MATLAB uses compiled code (Fortan/C/C++ if I'm not mistaken) to perform large operations: so a matrix multiplication is really performed by a piece of machine code which was compiled from another language. For smaller operations, this is the case as well, but you won't notice the speed of these calculations as most of your time is spent in management code (passing variables, allocating memory, ...).

To sum it all up: yes you should get used to such compact statements. If you see a line of code like Laurent's example, you immediately see that it computes a median of stack. Your code requires 11 lines of code to express the same, so when you are looking at code like yours (which might be embedded in hundreds of lines of other code), you will have a harder time understanding what is happening and pinpointing where a certain operation is performed.

To argue even further: you shouldn't program in MATLAB in the same way as you'd program in C/C++; nor should you do the other way round. Each language has its stronger and weaker points, learn to know them and use each language for what it's made for. E.g. you could write a whole compiler or webserver in MATLAB but in general that will be really slow as MATLAB was not intended to handle or concatenate strings (it can, but it might be very slow).

来源：https://stackoverflow.com/questions/7811239/nested-for-loops-extremely-slow-in-matlab-preallocated