Visualización de la salida de la capa convolucional en tensorflow

En caso de que alguien quiera "saltar" a numpy y visualizar "allí", aquí hay un ejemplo de cómo mostrar Weights y processing result. Todas las transformaciones se basan en la respuesta anterior de 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')

Puede intentar obtener la imagen de activación de la capa de convolución de esta manera:

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

Esto obtiene una franja vertical con todas las imágenes concatenadas verticalmente.

Si los quieres acolchados (en mi caso de las activaciones relu para rellenar con línea blanca):

    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)

Personalmente trato de teja cada filtro 2d en una sola imagen.

Para hacer esto _{-si no estoy terriblemente equivocado ya que soy bastante nuevo en DL -} Descubrí que podría ser útil explotar la función depth_to_space , ya que toma un tensor 4d

[batch, height, width, depth]

Y produce una salida de forma

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

Donde block_size es el número de "tiles" en la imagen de salida. La única limitación a esto es que la profundidad debe ser el cuadrado de block_size, que es un entero, de lo contrario no puede "llenar" la imagen resultante correctamente. Una posible solución podría ser de relleno de la profundidad del tensor de entrada hasta una profundidad que es aceptada por el método, pero yo no he probado esto.