Convolve2d seulement par l'utilisation de Numpy

Je suis des études de traitement de l'image à l'aide de Numpy et face à un problème de filtrage avec la convolution.

Je voudrais convolution d'une image en niveaux de gris de l'image. (convolution d'un Tableau 2d avec un petit Tableau 2d)

Quelqu'un a une idée pour affiner ma méthode ?

Je sais que scipy prend en charge convolve2d mais je veux faire un convolve2d que par l'utilisation de Numpy.

Ce que j'ai fait

Tout d'abord, j'ai fait un tableau 2d de la submatrices.

a = np.arange(25).reshape(5,5) # original matrix

submatrices = np.array([
     [a[:-2,:-2], a[:-2,1:-1], a[:-2,2:]],
     [a[1:-1,:-2], a[1:-1,1:-1], a[1:-1,2:]],
     [a[2:,:-2], a[2:,1:-1], a[2:,2:]]])

la submatrices semble compliqué, mais ce que je fais est montré sur le dessin suivant.

Convolve2d seulement par l'utilisation de Numpy

Prochaine, je multiplie chaque submatrices avec un filtre.

conv_filter = np.array([[0,-1,0],[-1,4,-1],[0,-1,0]])
multiplied_subs = np.einsum('ij,ijkl->ijkl',conv_filter,submatrices)

Convolve2d seulement par l'utilisation de Numpy

et additionnés entre eux.

np.sum(np.sum(multiplied_subs, axis = -3), axis = -3)
#array([[ 6,  7,  8],
#       [11, 12, 13],
#       [16, 17, 18]])

Donc ce procudure peut être appelé mon convolve2d.

def my_convolve2d(a, conv_filter):
    submatrices = np.array([
         [a[:-2,:-2], a[:-2,1:-1], a[:-2,2:]],
         [a[1:-1,:-2], a[1:-1,1:-1], a[1:-1,2:]],
         [a[2:,:-2], a[2:,1:-1], a[2:,2:]]])
    multiplied_subs = np.einsum('ij,ijkl->ijkl',conv_filter,submatrices)
    return np.sum(np.sum(multiplied_subs, axis = -3), axis = -3)

Cependant, je trouve cette my_convolve2d gênant pour 3 raisons.

  1. Génération de la submatrices est trop maladroit qui est difficile à lire et peut être utilisé seulement lorsque le filtre est de 3*3
  2. La taille de la variante submatrices semble être trop grand, car il est environ 9 fois plus grand que la matrice d'origine.
  3. Le résumé semble un peu non intuitive. Simplement dit, laid.

Je vous remercie pour la lecture de ce jour.

Genre de mise à jour. J'ai écrit un conv3d pour moi-même. Je vais laisser cela comme un domaine public.

def convolve3d(img, kernel):
    # calc the size of the array of submatracies
    sub_shape = tuple(np.subtract(img.shape, kernel.shape) + 1)

    # alias for the function
    strd = np.lib.stride_tricks.as_strided

    # make an array of submatracies
    submatrices = strd(img,kernel.shape + sub_shape,img.strides * 2)

    # sum the submatraces and kernel
    convolved_matrix = np.einsum('hij,hijklm->klm', kernel, submatrices)

    return convolved_matrix
merci de fournir les dessins de la matrices 🙂 Si je comprends bien, vous voulez des conseils sur la façon de faire de votre solution plus élégante?
Content que ça aide! Oui. Je vous serais reconnaissant si vous pouvez me donner des conseils pour surmonter les 3 problèmes écrite dans les toutes dernières lignes.
Je dois ajouter que les 3 points sont plutôt disposés dans un ordre de priorité. Le premier est assez important pour moi et le dernier semble un peu trivial. Je serai aussi heureux si il y a d'autres problèmes et les améliorations à apporter à ce sujet.
N'est-ce pas le deuxième dessin (après le signe de l'égalité) de mal? Ne devrait pas chaque submatrix être multipliés (élément-sage) avec le filtre, puis les éléments de chaque résultant de la submatrices résumé?
Ils produisent le même résultat.

OriginalL'auteur Allosteric | 2017-03-29

  1. 11

    Vous pouvez générer les sous-réseaux à l'aide de as_strided [1]:

    import numpy as np

a = np.array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

sub_shape = (3,3)
view_shape = tuple(np.subtract(a.shape, sub_shape) + 1) + sub_shape
strides = a.strides + a.strides

sub_matrices = np.lib.stride_tricks.as_strided(a,view_shape,strides)

    Pour se débarrasser de votre deuxième "laid" somme, modifier votre einsum de sorte que le tableau de sortie uniquement a j et k. Cela implique votre deuxième sommation.

    conv_filter = np.array([[0,-1,0],[-1,5,-1],[0,-1,0]])
m = np.einsum('ij,ijkl->kl',conv_filter,sub_matrices)

# [[ 6  7  8]
#  [11 12 13]
#  [16 17 18]]
    si a_s est le strided tableau et le filtre est votre laplacien comme filtre, puis essayer... np.somme(a_s*filtre, axe=(2,3)) en effet, si votre réponse est la matrice de([[ 6, 7, 8], [11, 12, 13], [16, 17, 18]])
    Merci pour l'astuce. J'essaie moi-même maintenant. Peut-être trivial, mais je crois que le nom du filtre n'est pas approprié parce qu'il est une fonction intégrée de python.
    Vous pouvez faire la somme directement dans le Einstein de sommation. Voir la réponse
    Astuce sur le einsum, ne voir qu'une seule.
    Dans cette question, n'est-il pas mieux écrire, sub_shape = conv_filter.shape ?

    OriginalL'auteur Crispin

  2. 5

    Vous pouvez également utiliser la fft (l'une des méthodes plus rapides pour effectuer des circonvolutions)

    from numpy.fft import fft2, ifft2
import numpy as np

def fft_convolve2d(x,y):
    """ 2D convolution, using FFT"""
    fr = fft2(x)
    fr2 = fft2(np.flipud(np.fliplr(y)))
    m,n = fr.shape
    cc = np.real(ifft2(fr*fr2))
    cc = np.roll(cc, -m/2+1,axis=0)
    cc = np.roll(cc, -n/2+1,axis=1)
    return cc

    cheers,
    Dan

    OriginalL'auteur Dan Erez

  3. 2

    Nettoyés à l'aide d' as_strided et @Crispin 's einsum truc à partir de ci-dessus. Applique le filtre de taille dans l'élargissement de la forme. Devraient même permettre à des non-carré entrées si les indices sont compatibles.

    def conv2d(a, f):
    s = f.shape + tuple(np.subtract(a.shape, f.shape) + 1)
    strd = numpy.lib.stride_tricks.as_strided
    subM = strd(a, shape = s, strides = a.strides * 2)
    return np.einsum('ij,ijkl->kl', f, subM)
    simplifier encore plus... voir mon commentaire ci-dessous... np.somme(a_s * filtre, axe=(2,3)) en effet, si votre réponse est la matrice de([[ 6, 7, 8], [11, 12, 13], [16, 17, 18]]) ... où a_s est strided tableau et le filtre est le filtre 3x3
    Je ne sais pas pourquoi que les œuvres @NaN, car il est certainement pas en faisant ce que le problème posé - mais il le fait, même pour arbitraire a matrices
    au moins à numpy v12, une.la forme et la f.la forme est un n-uplet de sorte s devrait être tuple(np.subtract(a.shape, f.shape)+1), je pense.
    Vrai! Toujours utilisé pour shape donner un ndarray. Fixe qui.
    Salut @DanielF, est-il une généralisation de ce qui fonctionne pour le RVB? Pas super familier avec einsum notation, donc une idée de comment généraliser serait génial.

    OriginalL'auteur Daniel F