Somme des Carrés des Différences (SSD) dans numpy/scipy

Je suis en train d'utiliser Python et Numpy/Scipy pour mettre en œuvre un algorithme de traitement d'image. Le profileur me dit beaucoup de temps passé à la fonction suivante (appelée souvent), ce qui me dit que la somme des carrés des différences entre les deux images

def ssd(A,B):
    s = 0
    for i in range(3):
        s += sum(pow(A[:,:,i] - B[:,:,i],2))
    return s

Comment puis-je accélérer les choses? Merci.

OriginalL'auteur Internet man | 2010-02-17

  1. 34

    Juste

    s = numpy.sum((A[:,:,0:3]-B[:,:,0:3])**2)

    (qui je m'attends est probablement juste sum((A-B)**2) si la forme est toujours (,,3))

    Vous pouvez également utiliser la somme méthode: ((A-B)**2).sum()

    Droit?

    Bang. Je vais avoir une journée lente. Les moitiés de mon temps de course.
    Il est intéressant de noter que, pour cela, vous aurez à utiliser numpy.sum, pas la builtin sum, qui va trouver la somme au cours de la première dimension et de retour d'un nouveau tableau d'une dimension inférieure.
    ((A-B)**2).somme(-1) Si vous voulez seulement ajouter sur le dernier axe, alors l'axe argument doit être spécifié. Juste en utilisant sum() ajoute toutes les entrées de la matrice (raveled première)

    OriginalL'auteur Andrew Jaffe

  2. 1

    Je suis confus, pourquoi vous prenez i in range(3). Est censé être l'ensemble du tableau, ou juste une partie?

    Dans l'ensemble, vous pouvez remplacer la plupart de cela avec les opérations définies dans numpy:

    def ssd(A,B):
    squares = (A[:,:,:3] - B[:,:,:3]) ** 2
    return numpy.sum(squares)

    De cette façon, vous pouvez faire une seule opération au lieu de trois, et à l'aide de numpy.sum peut être en mesure d'optimiser l'ajout de mieux que la builtin sum.

    +1 c'est de Cette façon scipy.stats.stats.ss (somme des carrés) - t-il.

    OriginalL'auteur Mike Graham

  3. 1

    Je ne sais pas si la fonction pow() avec une puissance 2 sera rapide. Essayez:

    def ssd(A,B):
    s = 0
    for i in  range(3):
        s += sum((A[:,:,i] - B[:,:,i])*A[:,:,i] - B[:,:,i])
    return s

    OriginalL'auteur Ritsaert Hornstra

  4. 1

    Plus de Ritsaert Hornstra de la réponse qui a obtenu 2 négatifs marques (certes je n'ai pas la voir dans sa forme originale...)

    Ce qui est vrai.

    Pour un grand nombre d'itérations, il peut souvent prendre deux fois plus longtemps à utiliser les '**' opérateur ou le pow(x,y) méthode comme de juste manuellement multiplier les paires ensemble. Si nécessaire, utiliser les mathématiques.fabs() la méthode si c'est jeter NaN (pour lequel il ne sont, parfois, en particulier lors de l'utilisation de int16s etc.), et toujours il prend seulement environ la moitié du temps des deux fonctions données.

    Que peu d'importance à la question de départ, je sais, mais ça vaut vraiment le savoir.

    OriginalL'auteur Duncan Tait

  5. 0

    Vous pouvez essayer celui-ci:

    dist_sq = np.sum((A[:, np.newaxis, :] - B[np.newaxis, :, :]) ** 2, axis=-1)

    Plus de détails peuvent être trouvés ici (le "k-plus proches Voisins" de l'exemple):
    https://jakevdp.github.io/PythonDataScienceHandbook/02.08-sorting.html

    OriginalL'auteur Xiaoyan Zhuo

  6. -3

    En langage Ruby, vous pouvez atteindre cet objectif dans cette façon

    def diff_btw_sum_of_squars_and_squar_of_sum(from=1,to=100) # use default values from 1..100. 
((1..100).inject(:+)**2) -(1..100).map {|num| num ** 2}.inject(:+)
end

diff_btw_sum_of_squars_and_squar_of_sum #call for above method

    OriginalL'auteur Raza Hussain