【Tool】Keras 基础学习 V 网络可视化

可视化网络每一层输出

5H324J.png
5H3oe3.png
5H3g36.png
5H3qRK.png
5H376B.png
5H3nMp.png
5H59SE.png
5H530G.png
5H55Pn.png

从网络每一层输出的激活可以看出随着网络加深，提取到的特征也越来月抽象。

可视化卷积核

不同卷积核对不同特征的敏感程度不同，通过可gradient descent 算法可以看卷积核对什么样的输入有最大的response，从而可视化卷积核。

5H58US.png
5H5nNO.png
5H5Snh.png
5H5gZA.png
5H5iWH.png
5H5xcN.png
5H52iu.png
5H5Rm9.png
5H5wbe.png
5H5q9q.png
5H93Kd.png

from keras.models import load_model
from keras.models import Model
from keras.models import Input
from keras import backend as K
from keras.preprocessing import image
from keras.applications.vgg16 import VGG16
import numpy as np

import matplotlib.pyplot as plt


model = load_model("cat_dog_classification/tuneModel.h5")
model.summary()

img_path = "/Users/yuhua.cheng/Documents/study/Keras/cat_dog_classification/data/test/9999.jpg"
img = image.load_img(img_path, target_size=(150, 150))
img_tensor = image.img_to_array(img)
img_tensor = np.expand_dims(img_tensor, axis=0)
img_tensor /= 255.

# visualize activations
layer_outputs = [layer.output for layer in model.layers[1:16]]
activation_model = Model(inputs=model.input, outputs=layer_outputs)

activations = activation_model.predict(x=img_tensor, batch_size=1)

layer_names = []
for layer in model.layers[1:16]:
    layer_names.append(layer.name)
images_per_row = 16
for layer_name, layer_activation in zip(layer_names, activations):
    n_features = layer_activation.shape[-1]
    size = layer_activation.shape[1]
    n_cols = n_features // images_per_row
    display_grid = np.zeros((size*n_cols, images_per_row*size))

    for col in range(n_cols):
        for row in range(images_per_row):
            channel_image = layer_activation[0,:,:,col*images_per_row + row]
            channel_image -= channel_image.mean()
            channel_image /= channel_image.std()
            channel_image *= 64
            channel_image += 128
            channel_image = np.clip(channel_image, 0, 255).astype('uint8')
            display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image

    scale = 1./size
    plt.figure(figsize=(scale*display_grid.shape[1], scale*display_grid.shape[0]))
    plt.title(layer_name)
    plt.grid(False)
    plt.imshow(display_grid, aspect='auto', cmap='viridis')
    plt.savefig(layer_name)
plt.show()

# visualize kernels
def deprocess_image(x):
    x -= x.mean();
    x /= (x.std() + 1e-5)
    x *= 0.1

    x += 0.5
    x = np.clip(x, 0, 1)
    x *= 255
    x = np.clip(x, 0, 255).astype('uint8')
    # print("x:", x)
    return x

def generate_pattern(layer_name, filter_index, size=150):
    layer_output = model.get_layer(layer_name).output
    loss = K.mean(layer_output[:,:,:,filter_index])

    grads = K.gradients(loss, model.input)[0]
    grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)

    iterate = K.function([model.input], [loss, grads])

    input_img_data = np.random.random((1, size, size, 3))*20 + 128
    step = 1
    for i in range(40):
        loss_value, grads_value = iterate([input_img_data])
        input_img_data += grads_value*step

    img = input_img_data[0]
    # print("img:",img)
    return deprocess_image(img)

for layer_name in layer_names:
    size = 64
    margin = 5

    results = np.zeros((8*size + 7*margin, 8*size + 7*margin, 3), dtype='uint8')

    for i in range(8):
        for j in range(8):
            filter_img = generate_pattern(layer_name, i+(j*8), size=size)
            # print("filter_img:", filter_img)
            horizontal_start = i*size + i*margin
            horizontal_end = horizontal_start + size
            vertical_start = j*size + j*margin
            vertical_end = vertical_start + size
            results[horizontal_start: horizontal_end, vertical_start:vertical_end,:] = filter_img

    # print("sum of results:", np.sum(results))
    # print(results.dtype)
    plt.figure(figsize=(20,20))
    plt.imshow(results)
    plt.savefig(layer_name)
    
plt.show()