La visualisation de la sortie de convolution de la couche dans tensorflow

J'essaye de visualiser la sortie d'une convolution de la couche dans tensorflow à l'aide de la fonction tf.image_summary. Je suis déjà en train de l'utiliser avec succès dans d'autres instances (e. g. la visualisation de l'image d'entrée), mais certains ont des difficultés remodelage de la sortie ici correctement. J'ai le texte suivant conv couche:

img_size = 256
x_image = tf.reshape(x, [-1,img_size, img_size,1], "sketch_image")

W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

La sortie de h_conv1 aurait la forme [-1, img_size, img_size, 32]. Juste à l'aide de tf.image_summary("first_conv", tf.reshape(h_conv1, [-1, img_size, img_size, 1])) Ne tient pas compte de l'32 les différents noyaux, donc je suis fondamentalement de découpage à travers différentes fonctionnalités des cartes ici.

Comment puis-je les remodeler correctement? Ou est-il une autre fonction d'aide je pourrais utiliser, y compris pour cette sortie dans le résumé?

InformationsquelleAutor panmari | 2015-11-19

conv-neural-network tensorflow

34

Je ne sais pas d'une fonction d'assistance, mais si vous voulez voir tous les filtres que vous pouvez les emballer dans une image avec un peu de fantaisie utilise de tf.transpose.

Donc, si vous avez un tenseur qui est images x ix x iy x channels
```
>>> V = tf.Variable()
>>> print V.get_shape()

TensorShape([Dimension(-1), Dimension(256), Dimension(256), Dimension(32)])
```
Donc dans cet exemple ix = 256, iy=256, channels=32

première tranche de 1 image, et de supprimer le image dimension
```
V = tf.slice(V,(0,0,0,0),(1,-1,-1,-1)) #V[0,...]
V = tf.reshape(V,(iy,ix,channels))
```
Ajoutez ensuite un couple de pixels de zéro de remplissage autour de l'image
```
ix += 4
iy += 4
V = tf.image.resize_image_with_crop_or_pad(image, iy, ix)
```
Puis remodeler, de sorte qu'au lieu de 32 canaux que vous avez 4x8 canaux, permet de les appeler cy=4 et cx=8.
```
V = tf.reshape(V,(iy,ix,cy,cx)) 
```
Maintenant la partie la plus délicate. tf semble renvoyer les résultats de C-commande, numpy par défaut.

L'ordre actuel, si aplaties, de la liste de tous les canaux pour le premier pixel (une itération sur cx et cy), avant de lister les canaux de la deuxième pixel (l'incrémentation ix). Aller à travers les lignes de pixels (ix) avant l'incrémentation à la ligne suivante (iy).

Nous voulons l'ordre, qui jetterait les images dans une grille.
Si vous allez à travers une ligne d'une image (ix), avant de marcher le long de la ligne de canaux (cx), lorsque vous atteignez la fin de la ligne de canaux étape à la ligne suivante dans l'image (iy) et lors de l'exécution ou de lignes de l'image, vous incrément à la prochaine rangée de canaux (cy). donc:
```
V = tf.transpose(V,(2,0,3,1)) #cy,iy,cx,ix
```
Personnellement, je préfère np.einsum de fantaisie transpose, pour des raisons de lisibilité, mais il n'est pas dans tf encore.
```
newtensor = np.einsum('yxYX->YyXx',oldtensor)
```
de toute façon, maintenant que les pixels sont dans le bon ordre, nous pouvons en toute sécurité l'aplatir en un 2d tenseur:
```
# image_summary needs 4d input
V = tf.reshape(V,(1,cy*iy,cx*ix,1))
```
essayer tf.image_summary sur ce, vous devriez obtenir une grille de peu d'images.

Ci-dessous est une image de ce que l'on obtient après avoir suivi toutes les étapes ici.
- Merci pour votre réponse, j'ai été bloqué sur la transposition de la partie. J'ai fini par utiliser un version légèrement différente depuis que je suis ok avec le fait de voir que les premières circonvolutions (je n'ai pas besoin de toutes les assemblées dans une grille). La grille est un peu difficile à inspecter sur le tensorboard.
- Il me semble que le dernier exercice et fx vous avez écrit sont en fait cy cx
- Ce qui est plus, vous pouvez seulement passer 4D tenseur des tf.image_summary de sorte que vous aurez à remodeler V=tf.reshape(V,(1,4*256,8*256,1))
- Mais grâce à cette utilisation de transposer à permuter les axes est en fait assez pratique !
- Merci! ils continuent à obtenir de moi avec cette 4d exigence sur les choses (Lot Norme par exemple), j'ai corrigé dans la réponse.
- Si la ligne est V = tf.image.resize_image_with_crop_or_pad(image, iy, ix) de V comme premier argument la place de l'image? Je ne vois pas où l'image vient d'où?
- Je suppose que dans cette ligne de V = tf.image.resize_image_with_crop_or_pad(image, iy, ix) , "l'image", devrait être remplacé par V. Et quelque chose de tf.résumé.image("nom_image", V ) pour la version récente du tenseur de flux. Il fonctionne vraiment bien!
InformationsquelleAutor mdaoust

Au cas où quelqu'un voudrait faire "sauter" à numpy et de visualiser le "il" est ici un exemple sur la façon d'afficher à la fois Weights et processing result. Toutes les transformations sont basés sur prev réponse par mdaoust.

# to visualize 1st conv layer Weights
vv1 = sess.run(W_conv1)
# to visualize 1st conv layer output
vv2 = sess.run(h_conv1,feed_dict = {img_ph:x, keep_prob: 1.0})
vv2 = vv2[0,:,:,:]   # in case of bunch out - slice first img
def vis_conv(v,ix,iy,ch,cy,cx, p = 0) :
v = np.reshape(v,(iy,ix,ch))
ix += 2
iy += 2
npad = ((1,1), (1,1), (0,0))
v = np.pad(v, pad_width=npad, mode='constant', constant_values=p)
v = np.reshape(v,(iy,ix,cy,cx)) 
v = np.transpose(v,(2,0,3,1)) #cy,iy,cx,ix
v = np.reshape(v,(cy*iy,cx*ix))
return v
# W_conv1 - weights
ix = 5  # data size
iy = 5
ch = 32   
cy = 4   # grid from channels:  32 = 4x8
cx = 8
v  = vis_conv(vv1,ix,iy,ch,cy,cx)
plt.figure(figsize = (8,8))
plt.imshow(v,cmap="Greys_r",interpolation='nearest')
#  h_conv1 - processed image
ix = 30  # data size
iy = 30
v  = vis_conv(vv2,ix,iy,ch,cy,cx)
plt.figure(figsize = (8,8))
plt.imshow(v,cmap="Greys_r",interpolation='nearest')

InformationsquelleAutor rgr

vous pouvez essayer d'obtenir la convolution de la couche d'activation de l'image de cette façon:

    h_conv1_features = tf.unpack(h_conv1, axis=3)
h_conv1_imgs = tf.expand_dims(tf.concat(1, h_conv1_features_padded), -1)

cela devient une bande verticale avec toutes les images concaténé à la verticale.

si vous le souhaitez collier (dans mon cas de relu les activations de pad avec ligne blanche):

    h_conv1_features = tf.unpack(h_conv1, axis=3)
h_conv1_max = tf.reduce_max(h_conv1)
h_conv1_features_padded = map(lambda t: tf.pad(t-h_conv1_max, [[0,0],[0,1],[0,0]])+h_conv1_max, h_conv1_features)
h_conv1_imgs = tf.expand_dims(tf.concat(1, h_conv1_features_padded), -1)

InformationsquelleAutor Anton Suslov

1

Personnellement, j'essaie à chaque tuile 2d-filtre dans une seule image.

Pour ce faire, _{-si je ne suis pas terriblement erronée depuis que je suis tout à fait nouveau pour DL-} j'ai trouvé qu'il pourrait être utile d'exploiter les depth_to_space fonction, car il faut 4d tenseur

[batch, height, width, depth]

et produit une sortie de la forme

[batch, height*block_size, width*block_size, depth/(block_size*block_size)]

Où taille_bloc est le nombre de "tuiles" dans l'image de sortie. La seule limitation est que la profondeur doit être la place de taille_bloc, qui est un entier, sinon il ne peut pas "remplir" l'image correctement.
Une solution possible pourrait être de rembourrage de la profondeur de l'entrée du tenseur jusqu'à une profondeur qui est accepté par la méthode, mais je sill havn pas essayé ce.

InformationsquelleAutor EdoardoG

Vous devez vous connecter pour publier un commentaire.