Discussion :

[Gooby]

Bonjour à tous, j'ai une question très simple.

J'effectue le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
superposition_seuillage = zeros(size(img_rad));
for i = 1:length(seuillage_pondere)
    superposition_seuillage = superposition_seuillage + seuillage_pondere{i};
end

img_rad est une matrice de taille 500x215.
Seuillage pondéré est une variable de type cellule, pouvant contenir entre 5 et 100 matrices. Je ne connais pas sa taille par avance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
seuillage_pondere = 
 
    [500x215 double]
    [500x215 double]
    [500x215 double]
    [500x215 double]
    [500x215 double]
    [500x215 double]
    [500x215 double]

Je me demandais simplement si je pouvais effectuer cette somme plus rapidement (en temps de calcul, pas en ligne de code) qu'en passant par une boucle et si oui, quelle est la méthode à utiliser?
PS: quand je veux dire plus rapide, c'est au centième de seconde près, donc même si vous ne savez pas si telle méthode est plus rapide, voyez un autre moyen d'effectuer cette somme de matrice?

En vous remerciant!

[Dombrai]

je sais pas si c'est plus rapide, mais tu peux tester ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
seuill = [seuillage_pondere{:}]
seuill = reshape(seuill,500,215,length(seuillage_pondere))
seuill_somme = sum(seuill,3);
superposition_seuillage = superposition_seuillage + seuill_somme;

[Gooby]

Bonjour Dombrai,

Merci pour la réponse, d'autant plus que c'est effectivement plus rapide qu'une boucle for. Pour ceux que cela intéresse je passe, pour une somme de 7 éléments, je passe de 0.011 secondes en moyenne avec ma boucle à 0.0065 avec la méthode de Dombrai. Je vais jeter un œil pour des sommes d'un plus grand nombres d'éléments, afin de voir si cette tendance s'accentue.

Je ne mets pas le sujet comme résolu, car quelqu'un a peut-être une autre méthode à proposer!

[shaiHulud]

Vu que tu pars d'une matrice nulle, ceci devrait être un poil plus rapide, (c'est la même solution sans lignes superflues)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
superposition_seuillage = sum(reshape([seuillage_pondere{:}],500,215,length(seuillage_pondere)),3);

Cela dit attention, ces méthodes vectorisés sont certes plus rapides, mais toucheront la limite mémoire plus vite que les boucles (car création du 3d-array)

Peut etre le reshape sur chaque élément via cellfun, puis un cat( ...,3) serait plus rapide (à essayer mais je n'y crois pas trop) ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
seuillage_pondere= cellfun(@(x) reshape(x,500,215,1),seuillage_pondere,'uni',0);
seuillage_pondere= cat(seuillage_pondere{:},3);
superposition_seuillage = superposition_seuillage  + squeeze(sum(seuillage_pondere,3));

[Gooby]

Bonjour VV33D,

J'ai également essayé ta méthode et son temps d’exécution est sensiblement le même que la méthode proposé par Dombrai; c'est à dire plus rapide que ma boucle for. Je vous remercie pour ces alternatives, j'avais également pensé à utiliser la fonction sum mais je n'avais pas réussi à l'appliquer dans ce cas... ( matrices dans tableau de cellules).

J'ai l'intuition qu'il n'existe pas de méthode plus rapide pour cette sommation, je laisse cependant le sujet ouvert car il se peut que je me trompe, et j'aurai peut être également bientôt une autre question similaire que celle posée dans ce sujet.

[Jerome Briot]

Pour ma part, je n'aurais pas utilisé un tableau de cellules, mais directement un tableau MxNxP.
Un tableau de dimension 500x125 demande 0.8 Mo de mémoire (en Double). Il faut donc environ 80 Mo pour stocker 100 de ces tableaux. C'est ridicule sur les machines modernes où la quantité de RAM se compte en Go.

Sinon, je préfère toujours faire un comparatif des méthodes proposées avant de me prononcer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
clc
clear all
 
u = 1;
 
for N = 10:10:100;
 
    for n = 1:N
        tmp = rand(500, 215);
        seuillage_pondere{n} = tmp;
        seuillage_pondere_Dut(:,:,n) = tmp;
    end    
 
    whos seuillage_pondere seuillage_pondere_Dut
 
    for k = 1:10
 
        % Gooby
        tic
        superposition_seuillage = zeros(500, 215);
        for i = 1:numel(seuillage_pondere)
            superposition_seuillage = superposition_seuillage + seuillage_pondere{i};
        end
        t(k,1) = toc;
 
        S{1} = superposition_seuillage;
 
        clear superposition_seuillage
 
        % Dombrai
        tic
        seuill = [seuillage_pondere{:}];
        seuill = reshape(seuill,500,215,numel(seuillage_pondere));
        superposition_seuillage = sum(seuill,3);
        t(k,2) = toc;
 
        S{2} = superposition_seuillage;
 
        clear superposition_seuillage seuill        
 
        % VV33D
        tic
        superposition_seuillage = sum(reshape([seuillage_pondere{:}],500,215,numel(seuillage_pondere)),3);
        t(k,3) = toc;
 
        S{3} = superposition_seuillage;
 
        clear superposition_seuillage
 
        %Dut        
        tic
        superposition_seuillage = sum(seuillage_pondere_Dut, 3);
        t(k,4) = toc;
 
        S{4} = superposition_seuillage;
 
        clear superposition_seuillage
 
    end   
 
    flag = all(S{1}(:)==S{2}(:)) && all(S{1}(:)==S{3}(:)) && all(S{1}(:)==S{4}(:));
 
    if flag
        T(u,:) = mean(t);        
    else
        T(u,:) = NaN;
    end
 
    u = u+1;
 
    clear seuillage_pondere seuillage_pondere_Dut
    clear functions
 
end
 
figure
 
p = plot(10:10:100,T);
 
legend(p, {'Gooby (for)' 'Dombrai (cat+reshape)' 'VV33D (one-liner)', 'Dut (MxNxP)'}, ...
    'location', 'northwest')
 
xlabel('Nombre de cellules [500,215]')
ylabel('Temps (s)')

J'espère ne pas avoir faire d'erreur…

Ma machine est équipée d'un processeur Intel Core i7-3770K (3.50GHz) et de 16 Go de RAM. Code exécuté avec MATLAB R2014a

N'hésitez pas à faire tourner ce code sur vos machines et à nous faire un retour. Postez juste les valeur de T si vous ne voulez pas vous embêter avec la capture du graphique. Pensez à nous donner les caractéristiques (CPU, RAM, version de MATLAB)

[Gooby]

MATLAB R2013a

IntelCore2 Quad CPU Q6950 3GHz
3.25Go de RAM

PS: j'avais comparé les méthodes directement dans mon script de base et en l’occurrence ma méthode était la plus lente.