Efficace (plus rapide) pour faire la somme des éléments de la matrice dans matlab

Permet d'avoir de la matrice A dire A = magic(100);. J'ai vu 2 manières de calculer la somme de tous les éléments de la matrice A.

sumOfA = sum(sum(A));

sumOfA = sum(A(:));

Est l'un des plus rapides (ou meilleure pratique) alors que d'autres? Si oui, lequel est-il? Ou sont-ils à la fois tout aussi rapide?

Chaque méthode doit marcher à travers chaque élément de la matrice. Donc, ils sont la même chose quand il s'agit de la complexité. Je vous recommande de faire deux scripts avec les différentes méthodes, énorme matrices, et de calculer leur temps d'exécution. Prendre un long shot ici, je dirais que la deuxième est mieux, car elle n'implique mémoire alloc opérations, mais comme je l'ai dit, c'est un long shot, et j'ai peut-être raté quelque chose ici.
Vous pouvez utiliser Matlab tic et toc fonctions pour réaliser l'expérience.
J'ai fait un test rapide et il n'y a pas de différence de vitesse. Un avantage de sum(A(:)) est que vous n'avez pas besoin de savoir combien de dimensions A a; il va travailler pour un certain nombre de s'estompe.

OriginalL'auteur Rasto | 2012-07-01

15

Il semble que vous ne pouvez pas faire votre esprit quant à savoir si la performance ou à virgule flottante de précision est plus importante.

Si à virgule flottante de précision ont été d'une extrême précision, alors vous devez séparer les éléments positifs et négatifs, le tri de chaque segment. Ensuite somme dans l'ordre croissant de valeur absolue. Ouais, je sais, c'est plus de travail que n'importe qui ferait, et ce sera probablement une perte de temps.

Au lieu de cela, utilisez suffisamment de précision tels que les erreurs faites il ne sera pas pertinent. L'utilisation de bonnes pratiques numériques sur les tests, etc, qu'il n'y ait pas de problèmes générés.

Aussi loin que le temps passe, pour une matrice NxM,

somme(A(:)) nécessitera N*M-1 additions.

sum(sum(A)) il sera nécessaire de (N-1)*M + M-1 = N*M-1 additions.

Soit la méthode nécessite le même nombre de ajoute, donc, pour un grand tableau, même si l'interprète n'est pas assez intelligent pour reconnaître qu'ils sont tous les deux de la même op, qui s'en soucie?

Il n'est tout simplement pas un problème. Ne pas faire une montagne d'une mole hill à vous inquiéter à ce sujet.

Edit: en réponse à Amro commentaire sur les erreurs pour une méthode par rapport à l'autre, il ya peu que vous pouvez contrôler. Les ajouts seront fait dans un ordre différent, mais il n'y a aucune certitude à propos de séquence sera mieux.
```
A = randn(1000);
format long g
```
Les deux solutions sont assez proches. En fait, par rapport à l'eps, la différence est à peine significative.
```
sum(A(:))
ans =
          945.760668102446

sum(sum(A))
ans =
          945.760668102449

sum(sum(A)) - sum(A(:))
ans =
      2.72848410531878e-12

eps(sum(A(:)))
ans =
      1.13686837721616e-13
```
Supposons que vous choisissez de les séparer et trier les truc que j'ai mentionné. Voir que le négatif et le positif parties sera assez grand qu'il y aura une perte de précision.
```
sum(sort(A(A<0),'descend'))
ans =
          -398276.24754782

sum(sort(A(A<0),'descend')) + sum(sort(A(A>=0),'ascend'))
ans =
            945.7606681037
```
Alors vous vraiment besoin d'accumuler les morceaux dans une plus grande précision de la matrice de toute façon. Nous pourrions essayer ceci:
```
[~,tags] = sort(abs(A(:)));
sum(A(tags))
ans =
          945.760668102446
```
Un problème intéressant se pose même dans ces tests. Sera-t-il un problème parce que les tests sont effectués sur un aléatoire (normal) tableau? Essentiellement, nous pouvons le voir sum(A(:)) comme une marche aléatoire, un ivrogne à pied. Mais considérer la somme(sum(A)). Chaque élément de la somme(A) (c'est à dire, l'interne de la somme) est lui-même une somme de 1000 s'écarte de la normale. Oeil à quelques-uns d'entre eux:
```
sum(A)
ans =
  Columns 1 through 6
         -32.6319600960983          36.8984589766173          38.2749084367497          27.3297721091922          30.5600109446534          -59.039228262402
  Columns 7 through 12
          3.82231962760523          4.11017616179294         -68.1497901792032          35.4196443983385          7.05786623564426         -27.1215387236418
  Columns 13 through 18
```
Lorsque nous ajouter, il y aura une perte de précision. Donc, potentiellement, l'opération de somme(A (:)), pourrait être un peu plus précis. Est-ce donc? Que faire si nous utilisons une plus grande précision de l'accumulation? Alors d'abord, je vais former la somme en bas les colonnes à l'aide de doubles, puis de les convertir à 25 chiffres de précision décimale, et la somme des lignes. (J'ai affiché seulement 20 chiffres ici, en laissant de 5 chiffres cachés comme garde chiffres.)
```
sum(hpf(sum(A)))
ans =
945.76066810244807408
```
Ou, au contraire, de les convertir immédiatement à 25 chiffres de précision, puis en additionnant les résultats.
```
sum(hpf(A(:))
945.76066810244749807
```
De sorte que les deux formes en double précision ont été tout aussi mal ici, dans des directions opposées. En fin de compte, c'est tout à fait discutable, puisque toutes les autres solutions que j'ai montré sont beaucoup plus de temps par rapport à la simple somme des variations(A(:)) ou sum(sum(A)). Il suffit de choisir l'un d'eux et ne vous inquiétez pas.

Merci à vous, super réponse. C'est pourquoi j'ai posé cette question: j'ai 2 morceaux de code que les deux font la même réflexion (toujours produire le même résultat). Mais l'une des pistes de deux fois plus long que les autres. Il y a très peu de différences entre eux et la façon dont ils somme des matrices a été l'un d'eux. C'était je suppose que cela pourrait être la partie qui fait que la différence de performances. Je l ai regarder ailleurs. La Performance est donc important ici, car c'est le problème d'optimisation sur des données de grande taille... Et je préfère attendre 1 jour pour le résultat de 2 jours.
Avez-vous essayé de profilage de votre code? Vous dites avoir "très peu de différences entre eux", ce qui est un seul. Avez-vous regardé les autres? Je serais très surpris, que dis-je, interloqué si le "goulot d'étranglement" dans un "problème d'optimisation sur les grandes données" est la somme des éléments d'une matrice.
Une des inquiétudes que j'aurais avec sum(sum(A)) est que si l'interprète décide d'allouer une matrice temporaire pour contenir le résultat de l'intérieur de la sum. Si vous êtes en train de faire cela au milieu d'une boucle, et vous avez un très grand nombre de colonnes, d'allouer et de libérer cette matrice temporaire pourrait se transformer en une véritable performance de glisser. Il est possible que le Matlab JIT peut optimiser cette distance, mais j'ai vu un genre de situations similaires où il n'a pas.
super réponse, comme toujours. @sfstewman: sum(A(:)) crée également un temp linéarisée de la matrice/vecteur avant d'effectuer l'extérieur somme
La température de la matrice créée par A(:) devrait être la copie sur écriture optimisée. Matlab va allouer de la surcharge pour une matrice (qui est un peu octets), mais doit réutiliser les données. En revanche, l'intérieur de la somme de sum(sum(A(:))) prend une matrice MxN et génère un 1xN de la matrice. Si l'équipe n'a pas d'optimiser correctement, ce qui nécessite un 1xN matrice être attribués. Il n'y a pas de copie sur écriture d'optimisation disponibles.

OriginalL'auteur
3

En terme de Performance, je dirais que les deux sont très similaires (en supposant une récente MATLAB version). Voici test rapide à l'aide de la TIMEIT fonction:
```
function sumTest()
    M = randn(5000);
    timeit( @() func1(M) )
    timeit( @() func2(M) )
end
function v = func1(A)
    v = sum(A(:));
end
function v = func2(A)
    v = sum(sum(A));
end
```
les résultats étaient les suivants:
```
>> sumTest
ans =
    0.0020917
ans =
    0.0017159
```
Ce que je voudrais vous inquiéter, c'est à virgule flottante questions. Exemple:
```
>> M = randn(1000);
>> abs( sum(M(:)) - sum(sum(M)) )
ans =
   3.9108e-11
```
Erreur de magnitude augmente pour les matrices de grandes

Donc, parler à virgule flottante questions de méthode qui est préférable?
Il n'y a AUCUN moyen de savoir qui l'on va donner une meilleure réponse. Les deux résultats seront complètement aléatoire dans le bas de l'ordre des bits. Tout dépend de l'ordre dans lequel les numéros sont ajoutés, ce qui est quelque chose que ni matlab ou vous inquiéter.

OriginalL'auteur Amro
1

je pense que d'une façon simple à comprendre est que s'applique " tic_ table des matières fonction "dans la première et la dernière de votre code.
```
tic
A = randn(5000);
format long g
sum(A(:));
toc
```
mais quand vous avez utilisé la fonction randn ,certains de ses éléments sont aléatoires et le temps de calcul peut
différents dans chaque cycle CPU de calcul .
Mieux vous avez utilisé une unique matrice de pentecôte donc de grands éléments à comparer le temps de calcul.

OriginalL'auteur M Poorpanah

Vous devez vous connecter pour publier un commentaire.