devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深度学习笔记：卷积神经网络的可视化--特征图_特征图可视化

作者：很楠不爱3 | 2024-02-23 02:24:50

赞

踩

特征图可视化

目录

1. 前言

2. 模型的训练

3. 特征图可视化

3.1 加载保存的模型¶

3.2 图像预处理：将图像转换为张量

3.3 例化一个模型用于返回各层激活输出（即feature map）

3.5 各层各通道汇总可视化

4. 小结

参考文献

1. 前言

        人们常说，深度学习模型是“黑盒”，即模型学到的东西对于人类来说很难理解。对于很多深度学习模型来说的确是这样的，但是对于卷积神经网络（CNN）却并不尽然。CNN学习到的东西非常适合于可视化，因为它就是学习关于视觉概念的表示！自CNN诞生以来，人们已经开发了很多种技术来对卷积神经网络学习到的东西进行可视化和解释。其中最容易理解也最有用是以下三种：

  1. 特征图的可视化。特征图即中间激活层的输出。这个有助于理解CNN的各层如何对输入进行变换，也有助于初步了解CNN中每个过滤器的含义
  2. 过滤器的可视化。有助于精确理解CNN中每个过滤器对应的视觉模式或视觉概念
  3. 热力图的可视化。将图像中类激活的热力图可视化有助于理解图像的哪个部分被识别为属于哪个类别，从而可以定位图像中的物体

        本篇我们先看看特征图的可视化。

        特征图的可视化，是指对于给定输入图像，展示模型处理后的各中间层（包括卷积层和池化层等）输出的特征图（各中间层的激活函数的输出代表该层特征图）。这让我们可以看到输入数据在网络中是如何被分解，不同滤波器分别聚焦于原始图像的什么方面的信息。我们希望在三个维度对特征图进行可视化：宽度、高度和深度（通道，channel）。每个通道都对应相对独立的特征。所以将这些特征图可视化的正确方法是将每个通道的内容分别会支持成二维图像。

2. 模型的训练

        采用之前训练过的一个模型，参见“”。事实上，如果在之前的训练中把这个模型存储下来了的话，可以直接加载已存储的模型而不必重复训练。这个把数据处理到模型训练的代码重新贴一遍只是为了保持本文自身的完备性。详细解说可以参考：利用数据增强在小数据集上从头训练卷积神经网络

  1. import tensorflow as tf
  2. from tensorflow import keras
  3. from tensorflow.keras import layers
  4. from tensorflow.keras import utils
  5. import numpy as np
  6. import matplotlib.pyplot as plt
  7. from PIL import Image
  8. print(tf.__version__)

数据集准备

  1. def make_subset(subset_name, start_index, end_index):
  2.     for category in ("cat", "dog"):
  3.         dir = new_base_dir / subset_name / category
  4.         src_dir = original_dir / category
  5.         print(dir)
  6.         os.makedirs(dir)
  7.         fnames = [f"{i}.jpg" for i in range(start_index, end_index)]
  8.         for fname in fnames:
  9.             shutil.copyfile(src=src_dir / fname, dst=dir / fname)
  10. import os, shutil, pathlib
  11.  
  12. original_dir = pathlib.Path("F:\DL\cats-vs-dogs")
  13. new_base_dir = pathlib.Path("F:\DL\cats_vs_dogs_small")
  14.  
  15. #print(original_dir, new_base_dir)
  16.  
  17. start_index = np.random.randint(0,8000)
  18. end_index   = start_index + 1000
  19.  
  20. start_index3 = end_index
  21. end_index3   = start_index3 + 500
  22.  
  23. if os.path.exists(new_base_dir):
  24.     shutil.rmtree(new_base_dir)
  25.     
  26. make_subset("train", start_index=start_index, end_index=end_index)
  27. make_subset("test", start_index=start_index3, end_index=end_index3)

模型搭建

  1. inputs = keras.Input(shape=(180, 180, 3))
  2. x = layers.Conv2D(filters=32, kernel_size=3, activation="relu")(inputs)
  3. x = layers.MaxPooling2D(pool_size=2)(x)
  4. x = layers.Conv2D(filters=64, kernel_size=3, activation="relu")(x)
  5. x = layers.MaxPooling2D(pool_size=2)(x)
  6. x = layers.Conv2D(filters=128, kernel_size=3, activation="relu")(x)
  7. x = layers.MaxPooling2D(pool_size=2)(x)
  8. x = layers.Conv2D(filters=256, kernel_size=3, activation="relu")(x)
  9. x = layers.MaxPooling2D(pool_size=2)(x)
  10. x = layers.Conv2D(filters=256, kernel_size=3, activation="relu")(x)
  11. x = layers.Flatten()(x)
  12. x = layers.Dropout(0.5)(x)
  13. outputs = layers.Dense(1, activation="sigmoid")(x)
  14. model = keras.Model(inputs=inputs, outputs=outputs)
  15. model.summary()
  16. # Configuring the model for training
  17. model.compile(loss="binary_crossentropy",optimizer="rmsprop",metrics=["accuracy"])

数据预处理及数据增强

  1. import os
  2. from tensorflow.keras.preprocessing.image import ImageDataGenerator
  3.  
  4. batch_size = 32
  5. train_dir = os.path.join('F:\DL\cats_vs_dogs_small', 'train')
  6. test_dir = os.path.join('F:\DL\cats_vs_dogs_small', 'test')
  7. train_datagen = ImageDataGenerator(rescale=1./255,validation_split=0.3,
  8.       rotation_range=40,
  9.       width_shift_range=0.2,
  10.       height_shift_range=0.2,
  11.       shear_range=0.2,
  12.       zoom_range=0.2,
  13.       horizontal_flip=True,
  14.       fill_mode='nearest'
  15.                                   )
  16.  
  17. test_datagen = ImageDataGenerator(rescale=1./255)
  18.  
  19. train_generator = train_datagen.flow_from_directory(
  20.     directory=train_dir,
  21.     target_size=(180, 180),
  22.     color_mode="rgb",
  23.     batch_size=batch_size,
  24.     class_mode="binary",
  25.     subset='training',
  26.     shuffle=True,
  27.     seed=42
  28. )
  29. valid_generator = train_datagen.flow_from_directory(
  30.     directory=train_dir,
  31.     target_size=(180, 180),
  32.     color_mode="rgb",
  33.     batch_size=batch_size,
  34.     class_mode="binary",
  35.     subset='validation',
  36.     shuffle=True,
  37.     seed=42
  38. )
  39. test_generator = test_datagen.flow_from_directory(
  40.     directory=test_dir,
  41.     target_size=(180, 180),
  42.     color_mode="rgb",
  43.     batch_size=batch_size,
  44.     class_mode='binary',
  45.     shuffle=False,
  46.     seed=42
  47. )

模型训练和保存

  1. callbacks = [
  2.     keras.callbacks.ModelCheckpoint(
  3.         filepath="convnet_from_scratch_with_augmentation.keras",
  4.         save_best_only=True,
  5.         monitor="val_loss")
  6. ]
  7. history = model.fit(
  8.     x = train_generator,
  9.     validation_data=valid_generator,
  10.     steps_per_epoch = train_generator.n//train_generator.batch_size,
  11.     validation_steps = valid_generator.n//valid_generator.batch_size,
  12.     epochs=100,    
  13.     callbacks=callbacks)

         训练完以后，大致可以得到在验证集上接近80%的分类准确度。并且训练完的模型被存为文件“convnet_from_scratch_with_augmentation.keras”，以供后续直接加载使用。

3. 特征图可视化

3.1 加载保存的模型

  1. model = keras.models.load_model("convnet_from_scratch_with_augmentation.keras")
  2. model.summary()

3.2 图像预处理：将图像转换为张量

  1. img_path = "F:/DL/cats-vs-dogs/Dog/24.jpg"
  2. def get_img_array(img_path, target_size):
  3.     img = keras.preprocessing.image.load_img(
  4.         img_path, target_size=target_size)
  5.     array = keras.preprocessing.image.img_to_array(img)
  6.     array = np.expand_dims(array, axis=0)
  7.     return array
  8.  
  9. img_tensor = get_img_array(img_path, target_size=(180, 180))
  10. print(img_tensor.shape)
  11.  
  12. # Displaying the test picture
  13. import matplotlib.pyplot as plt
  14. plt.axis("off")
  15. plt.imshow(img_tensor[0].astype("uint8"))
  16. plt.show()

 

3.3 例化一个模型用于返回各层激活输出（即feature map）

        为了提取想要查看的特征图，我们需要创建一个Keras模型，以图像批量作为输入，并输出所有卷积层和池化层的激活。为此，我们需要使用Keras的Model类，模型的实例化需要两个参数，一个是输入张量（或输入张量列表），一个是输出张量（或输出张量列表）。得到的对象就是一个Keras模型，和之前的Sequential模型一样，将特定输入映射为特定输出。Model类运行多个输出，这个和Sequential类不同。

        以下模型接收一张图像输入，将返回原始模型所有各卷积层和池化层的输出。可以理解为这个模型就是原有模型的一个wrapper（套了一层皮），这样我们就可以方便地将所有想观测的中间信息全部引出来。其中，由语句“isinstance(layer, (layers.Conv2D, layers.MaxPooling2D))”进行过滤提取卷积层和池化层。实际上，池化层的输出应该与其前面的卷积层输出大同小异，所以在以下代码将池化层也滤除掉了。

  1. from tensorflow.keras import layers
  2.  
  3. layer_outputs = []
  4. layer_names = []
  5. for layer in model.layers:
  6.     #if isinstance(layer, (layers.Conv2D, layers.MaxPooling2D)):
  7.     if isinstance(layer, layers.Conv2D): 
  8.         layer_outputs.append(layer.output)
  9.         layer_names.append(layer.name)
  10. activation_model = keras.Model(inputs=model.input, outputs=layer_outputs)
  11. print('There are totally {} layers in this model'.format(len(layer_names)))

        原始模型总共有13层，其中有5层卷积层和4层池化层。

        使用这个模型计算并输出中间层输出，看看第一个卷积层输出的几个通道的数据的显示效果。

  1. import matplotlib.pyplot as plt
  2.  
  3. activations = activation_model.predict(img_tensor)
  4. # 确认输出结果的shape与前面model.summary()给出的信息是一致的
  5. first_layer_activation = activations[0]
  6. print(first_layer_activation.shape)
  7.  
  8.  
  9. fig, ax = plt.subplots(1,4,figsize=(12,16))
  10. ax[0].matshow(first_layer_activation[0, :, :, 0], cmap="viridis")
  11. ax[1].matshow(first_layer_activation[0, :, :, 5], cmap="viridis")
  12. ax[2].matshow(first_layer_activation[0, :, :, 11], cmap="viridis")
  13. ax[3].matshow(first_layer_activation[0, :, :, 24], cmap="viridis")

3.5 各层各通道汇总可视化

        以下代码将所有各层的各个通道的输出均以二维图像的方式汇总画出。

  1. images_per_row = 16 # 每行16个小图
  2. for layer_name, layer_activation in zip(layer_names, activations):
  3.     print(layer_name)    
  4.     n_features = layer_activation.shape[-1] # Number of features, i.e, channels of the current layer output.
  5.     size = layer_activation.shape[1]
  6.     n_cols = n_features // images_per_row   # n_cols should be 'number of plots per column', i.e, number of rows.
  7.     display_grid = np.zeros(((size + 1) * n_cols - 1,images_per_row * (size + 1) - 1))
  8.     for col in range(n_cols):
  9.         for row in range(images_per_row):
  10.             channel_index = col * images_per_row + row
  11.             channel_image = layer_activation[0, :, :, channel_index].copy()
  12.             if channel_image.sum() != 0: #数据处理，使其适合于作为图像展示
  13.                 channel_image -= channel_image.mean()
  14.                 channel_image /= channel_image.std()
  15.                 channel_image *= 64
  16.                 channel_image += 128
  17.             channel_image = np.clip(channel_image, 0, 255).astype("uint8")
  18.             display_grid[
  19.                 col * (size + 1): (col + 1) * size + col,
  20.                 row * (size + 1) : (row + 1) * size + row] = channel_image
  21.     scale = 1. / size
  22.     plt.figure(figsize=(scale * display_grid.shape[1],
  23.                         scale * display_grid.shape[0]))
  24.     plt.title(layer_name)
  25.     plt.grid(False)
  26.     plt.axis("off")
  27.     plt.imshow(display_grid, aspect="auto", cmap="viridis")

         输出结果如下所示：

         从以上结果中可以看出：

  1. 第一层是各种边缘检测器的集合，在这一阶段，激活输出几乎保留了原始图像的所有信息
  2. 随着层数的加深，激活输出变得越来越抽象。conv2d_3的输出已经超出了人类直观理解的范围。可以这样理解，随着层数的加深，关于图像视觉内容信息越来越少，而关于类别的信息就越来越多
  3. 激活的稀疏度(sparsity)随着层数的加深而增大。在第一层中，所有滤波器都被输入图像所激活（体现为对应通道有有效的图像信息），而随着层数加深，越来越多的通道对应的图示为空，表明没有被激活，即输入图像中没有找到这些过滤器所习得（编码）的模式。

4. 小结

        以上实验揭示了深度神经网络学到的表示的一个重要的普遍特征：随着层数的加深，层所提取的特征变得越来越抽象，关于特定输入的信息越来越少，而关于目标的信息则越来越多（本例中即图像的类别：猫和狗）。深度神经网络可以有效地作为信息整流管道(information distillation pipeline)，输入原始数据（本例中是RGB信息），反复对其进行变换，将无关信息过滤掉（比如他，图像的具体外观），并放大和细化有用的信息（比如与图像类别有关的信息）。这与人类和动物感知世界的方式类似：人类观察一个场景几秒钟后，可以记住其中有哪些抽象物体（比如说自行车、数或者是哪个人），但是却不一定能记住物体的具体外观。事实上，尽管你可能见过成百上千辆自行车，但是要你试着画一辆自行车出来，估计会是歪歪扭扭的，只具备勉强能让人识别出是自行车的框架性特征。人类的大脑已经学会将视觉输入完全抽象化，将其转换为更高层次的视觉概念，同时过滤掉不想管的视觉细节，这使得大脑很难记住周围事物的具体外观特征。事实上，这也可能是一个明智的自然进化选择。

参考文献

[1] Francois Chollet, Deep Learning with Python, Chapter5.4

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/133013
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号