arrayfun peut être significativement plus lent qu'une boucle explicite dans matlab. Pourquoi?

vous pouvez obtenir l'idée en exécutant d'autres versions de votre code. Envisager d'écrire explicitement les calculs, au lieu d'utiliser une fonction dans votre boucle

tic
Soln3 = ones(T, N);
for t = 1:T
    for n = 1:N
        Soln3(t, n) = 3*x(t, n)^2 + 2*x(t, n) - 1;
    end
end
toc

temps de calculer sur mon ordinateur:

Soln1  1.158446 seconds.
Soln2  10.392475 seconds.
Soln3  0.239023 seconds.
Oli    0.010672 seconds.

maintenant, alors que la solution entièrement 'vectorisée' est clairement la plus rapide, vous pouvez voir que la définition d'une fonction à appeler pour chaque entrée x est un énorme overhead. Juste en écrivant explicitement la le calcul nous a permis d'accélérer le facteur 5. Je suppose que cela montre que le compilateur MATLABs JIT ne supporte pas les fonctions en ligne . Selon la réponse de gnovice, il est en fait préférable d'écrire une fonction normale plutôt qu'une fonction anonyme. Essayer.

la Prochaine étape est de supprimer (vectorisation) la boucle interne:

tic
Soln4 = ones(T, N);
for t = 1:T
    Soln4(t, :) = 3*x(t, :).^2 + 2*x(t, :) - 1;
end
toc

Soln4  0.053926 seconds.

un autre facteur d'accélération 5: Il ya quelque chose dans ces déclarations disant que vous devriez éviter les boucles dans MATLAB... Ou est-il vraiment?

tic
Soln5 = ones(T, N);
for n = 1:N
    Soln5(:, n) = 3*x(:, n).^2 + 2*x(:, n) - 1;
end
toc

Soln5   0.013875 seconds.

beaucoup plus proche de la version "entièrement" vectorisée. Matlab stocke des matrices au niveau des colonnes. Vous devriez toujours (quand c'est possible) structurer vos calculs pour être vectorisés 'par colonne'.

nous pouvons retourner à Soln3 maintenant. L'ordre de boucle y est 'row-wise'.

tic
Soln6 = ones(T, N);
for n = 1:N
    for t = 1:T
        Soln6(t, n) = 3*x(t, n)^2 + 2*x(t, n) - 1;
    end
end
toc

Soln6  0.201661 seconds.

mieux, mais encore très mauvais. Boucle unique de bien - être. Double boucle-mauvais. Je je suppose que MATLAB a fait du bon travail sur l'amélioration de la performance des boucles, mais la boucle aérienne est toujours là. Si vous aviez un travail plus lourd à l'intérieur, vous ne le remarqueriez pas. Mais puisque ce calcul est limité par la bande passante mémoire, vous voyez la boucle au-dessus. Et vous will encore plus clairement voir le au-dessus de L'appel Func1 là.

qu'est-ce qui se passe avec arrayfun? Aucune fonction inlinig là non plus, donc beaucoup de frais généraux. Mais pourquoi bien pire qu'une double boucle imbriquée? En fait, le sujet de l'utilisation de cellfun/arrayfun a été longuement discuté à de nombreuses reprises (par exemple ici , ici , ici et ici ). Ces fonctions sont tout simplement lents, vous ne pouvez pas les utiliser pour de tels calculs à grain fin. Vous pouvez les utiliser pour la concision du code et des conversions fantaisistes entre les cellules et les tableaux. Mais la fonction doit être plus lourd que ce que vous avez écrit:

tic
Soln7 = arrayfun(@(a)(3*x(:,a).^2 + 2*x(:,a) - 1), 1:N, 'UniformOutput', false);
toc

Soln7  0.016786 seconds.

notez que Soln7 est une cellule maintenant.. parfois, c'est utile. La performance du Code est assez bonne maintenant, et si vous avez besoin de la cellule comme sortie, vous n'avez pas besoin de convertir votre matrice après avoir utilisé la solution entièrement vectorisée.

alors pourquoi arrayfun est plus lent qu'une simple structure de boucle? Malheureusement, il nous est impossible de le dire avec certitude, puisqu'il n'y a pas de code source disponible. Vous ne pouvez que supposer que puisque arrayfun est un général fonction de but, qui traite toutes sortes de structures de données et d'arguments différents, il n'est pas nécessairement très rapide dans les cas simples, que vous pouvez exprimer directement comme nids de boucle. D'où la surcharge venons, nous ne pouvons pas savoir. Une meilleure mise en œuvre permettrait-elle d'éviter les frais généraux? Peut-être pas. Mais malheureusement, la seule chose que nous pouvons faire est d'étudier la performance pour identifier les cas, dans lesquels il fonctionne bien, et ceux, où il ne fonctionne pas.

mise à Jour puisque le temps d'exécution de ce test est court, pour obtenir des résultats fiables j'ai ajouté maintenant une boucle autour des tests:

for i=1:1000
   % compute
end

plusieurs fois indiqué ci-dessous:

Soln5   8.192912 seconds.
Soln7  13.419675 seconds.
Oli     8.089113 seconds.

vous voyez que le arrayfun est toujours mauvais, mais au moins pas trois ordres de grandeur pire que la solution vectorisée. D'un autre côté, une seule boucle avec des calculs par colonne est aussi rapide que la version entièrement vectorisée... Tout cela a été fait sur un seul CPU. Les résultats pour Soln5 et Soln7 ne changent pas si je passe à 2 noyaux - dans Soln5, je devrais utiliser un parfor pour l'obtenir parallélisé. Oublier speedup... Soln7 ne fonctionne pas en parallèle car arrayfun ne fonctionne pas en parallèle. Olis version vectorisée d'un autre côté:

Oli  5.508085 seconds.