Comprendre la fonction de convolution en utilisant le traitement d'image comme exemple

introduction

En tant qu'exercice dans "Learn from Mosaic Removal: Cutting-edge Deep Learning" écrit par koshian2, la fonction de pliage a été prise comme exemple. Cette fois, je voudrais résumer ce que j'ai compris de cette fonction de convolution. https://qiita.com/koshian2/items/aefbe4b26a7a235b5a5e

Ce livre est compréhensible même pour des personnes comme moi qui ont commencé l'apprentissage automatique. Il est expliqué dans un ordre facile à comprendre à partir des bases. Surtout, c'était bien que le dernier article ait été examiné. Les derniers articles distribués dans les librairies générales datent d'environ un an ou deux. C'est un livre qui vous passionne pour l'apprentissage en profondeur, et je suis heureux que vous l'ayez acheté.

Quelle est la convolution

La convolution est utilisée dans le réseau de neurones convolutifs, célèbre pour l'apprentissage en profondeur. D'une certaine manière, c'est un mot qui ressemble à une cuisine, et j'ai le sentiment que je veux le dire avec des mots pour le moment.

Le calcul de la convolution se fait par la méthode montrée dans l'image. Prenez une cellule 3x3 de la matrice d'entrée, multipliez-la par une matrice appelée noyau de convolution et additionnez la somme en sortie. 　 Ceci est différent du réseau dit de propagation directe dans lequel les unités de la couche adjacente sont entièrement connectées (voir la figure ci-dessous).

Calcul de pliage

X=\left(
\begin{array}{cc} 
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 \\
\end{array}
\right)

\\
kernel=\left(
\begin{array}{cc} 
0 & 1 & 2  \\
3 & 4 & 5 \\
6 & 7 & 8 \\

\end{array}
\right)

Cette fois, nous définissons l'entrée comme X sur 5x5 lignes et le coefficient de noyau comme noyau sur 3x3 lignes.

c.ipynp

import numpy as np

def conv(inputs, kernel):
  outputs = np.zeros((3,3),inputs.dtype)
  for i in range(3): #Calculez trois fois dans le sens de la ligne.
    for j in range (3):　#Calculez trois fois dans la direction de la colonne.
      patch= X[i:i+3,j:j+3]
      prod = patch * kernel #Multipliez la masse et le noyau.
      sum =  np.sum(prod)　#Ajoutez les blocages.
      outputs[i,j] = sum　#Mettez une valeur dans la couche de sortie.
  return outputs

#Définit une matrice de X. Le but est de le convertir en 5x5 par remodelage.
X = np.arange(25,dtype=np.float32).reshape(5,5)

#Mettez une valeur dans la couche de sortie.
kernel = np.arange(9, dtype = np.float32).reshape(3,3)
conv(X,kernel)

Outputs=\left(
\begin{array}{cc} 
312 & 348 & 384  \\
492 & 528 & 564 \\
672 & 708 & 744 \\

\end{array}
\right)

J'ai pu calculer.

Traitement de convolution d'image à l'aide de Tensorflow

Le traitement d'image peut être utilisé pour estomper l'image, la rendre en noir et blanc et améliorer les bords. Ceci est fait par le processus de convolution que nous venons de résumer.

Voici la photo originale. C'est une photo que j'ai prise quand je suis allé à l'aquarium l'année dernière.

Traitez l'image avec un filtre d'amélioration des contours. Lors de l'utilisation de Tensorflow, l'ordre des axes des tenseurs est logique. Dans l'image, l'ordre est essentiellement le lot, la résolution verticale, la résolution horizontale et le canal. Par conséquent, lors de l'ajout d'axes (dimensions), il faut faire attention à cet ordre. Également au programme comme ci-dessous

c.ipynp

float_img[　:,　:,　:,　i:i+1]

Puisqu'il y a 3 canaux (R, V, B) pour les images couleur, il est nécessaire de tourner i pour le 4ème canal.

c.ipynp

kernel = []
kernel = np.array([0,0,0,0,10,0,0,0,0]).reshape(3,3,1,1)
kernel = 0.5* kernel.astype(np.float32)


outputs = []
float_img = tf.cast(img,tf.float32)/255.0
for i in range(3):
  conv_result = tf.nn.conv2d(float_img[:,:,:,i:i+1],kernel,1,'SAME')
  outputs.append(conv_result)
outputs = tf.concat(outputs, axis = -1)

fig = plt.figure(figsize=(14,14))
ax = fig.gca()
ax.imshow(outputs[0].numpy())

Le noyau de filtre d'amélioration des bords utilisé est le suivant.

kernel=\frac{1}{2}\left(
\begin{array}{cc} 
-1 & -1 & -1  \\
-1 & 10 & -1 \\
-1 & -1 & -1 \\

\end{array}
\right)

De cette manière, nous avons pu obtenir le même effet que ImageFilter.EDGE_ENHANCE dans PIL, une bibliothèque souvent utilisée dans le traitement d'images. À partir de là, nous avons pu confirmer que ce qui est fait dans l'opération de pliage et le traitement d'image est le même. Le noyau peut être flou, noir et blanc, ou la sortie peut être modifiée comme spécifié. Vous pouvez également obtenir un autre effet en modifiant cette valeur en fonction de la position de l'entrée. J'aimerais en savoir plus sur ce noyau.

Le programme complet peut être trouvé ici. https://github.com/Fumio-eisan/convol_20200307