《keras 3 内卷神经网络》

keras 3 内卷神经网络

作者：Aritra Roy Gosthipaty
创建日期：2021/07/25
末了修改时间：2021/07/25
描述：深入研究特定于位置和通道无关的“内卷”内核。

   （i） 此示例使用 Keras 3  

 在 Colab 中检察 

 GitHub 源

---

介绍

卷积不绝是大多数现代神经的基础 计算机视觉网络。卷积核是 空间不可知且特定于通道。因此，它无法 顺应不同的视觉模式，包括 不同的空间位置。除了与位置相干的问题外， 卷积的感受野对捕获提出了挑战 长途空间交互。

为了办理上述问题，Li 等人。重新思量属性 卷积 in Involution： Inverting the Interence of Convolution for VisualRecognition. 作者提出了“内卷核”，即特定于位置的 通道不可知。由于操作的特定位置性质， 作者说，自我注意属于 退化。

此示例描述了 involution 内核，比较了两个图像 分类模子，一个具有卷积，另一个具有 内卷，并试图与自我关注相提并论。

---

设置

  

1. import os
3. os.environ["KERAS_BACKEND"] = "tensorflow"
5. import tensorflow as tf
6. import keras
7. import matplotlib.pyplot as plt
9. # Set seed for reproducibility.
10. tf.random.set_seed(42)

复制代码

---

卷积

卷积仍旧是计算机视觉深度神经网络的支柱。 要理解 Involution，有必要谈谈 卷积操作。

思量一个维度为 H、W 和 C_in 的输入张量 X。我们接纳 C_out 个卷积内核的集合，每个 外形 K、K C_in。使用 multiply-add 运算 输入张量和我们得到输出张量 Y 的内核 尺寸 H、W C_out。

在上图中。这使得外形为 H 的输出张量 W 和 3.可以注意到，卷积核并不依赖于 输入张量的空间位置，使其与位置无关。另一方面，output 中的每个通道 Tensor 基于特定的卷积滤波器，这使得 IS 特定于通道。C_out=3

---

退化

这个想法是有一个既特定于位置又与通道无关的操作。尝试实现这些特定属性姿势 一个挑战。具有固定数量的内卷 kernel（对于每个 空间位置），我们将无法处理可变分辨率 input 张量。

为了办理这个问题，作者思量天生每个 核以特定空间位置为条件。通过这种方法，我们 应该可以或许轻松处理可变分辨率的输入张量。 下图提供了有关此内核天生的直观 方法。

  

1. class Involution(keras.layers.Layer):
2.     def __init__(
3.         self, channel, group_number, kernel_size, stride, reduction_ratio, name
4.     ):
5.         super().__init__(name=name)
7.         # Initialize the parameters.
8.         self.channel = channel
9.         self.group_number = group_number
10.         self.kernel_size = kernel_size
11.         self.stride = stride
12.         self.reduction_ratio = reduction_ratio
14.     def build(self, input_shape):
15.         # Get the shape of the input.
16.         (_, height, width, num_channels) = input_shape
18.         # Scale the height and width with respect to the strides.
19.         height = height // self.stride
20.         width = width // self.stride
22.         # Define a layer that average pools the input tensor
23.         # if stride is more than 1.
24.         self.stride_layer = (
25.             keras.layers.AveragePooling2D(
26.                 pool_size=self.stride, strides=self.stride, padding="same"
27.             )
28.             if self.stride > 1
29.             else tf.identity
30.         )
31.         # Define the kernel generation layer.
32.         self.kernel_gen = keras.Sequential(
33.             [
34.                 keras.layers.Conv2D(
35.                     filters=self.channel // self.reduction_ratio, kernel_size=1
36.                 ),
37.                 keras.layers.BatchNormalization(),
38.                 keras.layers.ReLU(),
39.                 keras.layers.Conv2D(
40.                     filters=self.kernel_size * self.kernel_size * self.group_number,
41.                     kernel_size=1,
42.                 ),
43.             ]
44.         )
45.         # Define reshape layers
46.         self.kernel_reshape = keras.layers.Reshape(
47.             target_shape=(
48.                 height,
49.                 width,
50.                 self.kernel_size * self.kernel_size,
51.                 1,
52.                 self.group_number,
53.             )
54.         )
55.         self.input_patches_reshape = keras.layers.Reshape(
56.             target_shape=(
57.                 height,
58.                 width,
59.                 self.kernel_size * self.kernel_size,
60.                 num_channels // self.group_number,
61.                 self.group_number,
62.             )
63.         )
64.         self.output_reshape = keras.layers.Reshape(
65.             target_shape=(height, width, num_channels)
66.         )
68.     def call(self, x):
69.         # Generate the kernel with respect to the input tensor.
70.         # B, H, W, K*K*G
71.         kernel_input = self.stride_layer(x)
72.         kernel = self.kernel_gen(kernel_input)
74.         # reshape the kerenl
75.         # B, H, W, K*K, 1, G
76.         kernel = self.kernel_reshape(kernel)
78.         # Extract input patches.
79.         # B, H, W, K*K*C
80.         input_patches = tf.image.extract_patches(
81.             images=x,
82.             sizes=[1, self.kernel_size, self.kernel_size, 1],
83.             strides=[1, self.stride, self.stride, 1],
84.             rates=[1, 1, 1, 1],
85.             padding="SAME",
86.         )
88.         # Reshape the input patches to align with later operations.
89.         # B, H, W, K*K, C//G, G
90.         input_patches = self.input_patches_reshape(input_patches)
92.         # Compute the multiply-add operation of kernels and patches.
93.         # B, H, W, K*K, C//G, G
94.         output = tf.multiply(kernel, input_patches)
95.         # B, H, W, C//G, G
96.         output = tf.reduce_sum(output, axis=3)
98.         # Reshape the output kernel.
99.         # B, H, W, C
100.         output = self.output_reshape(output)
102.         # Return the output tensor and the kernel.
103.         return output, kernel

复制代码

---

测试 Involution 层

  

1. # Define the input tensor.
2. input_tensor = tf.random.normal((32, 256, 256, 3))
4. # Compute involution with stride 1.
5. output_tensor, _ = Involution(
6.     channel=3, group_number=1, kernel_size=5, stride=1, reduction_ratio=1, name="inv_1"
7. )(input_tensor)
8. print(f"with stride 1 ouput shape: {
9.       
10.        output_tensor.shape}")
12. # Compute involution with stride 2.
13. output_tensor, _ = Involution(
14.     channel=3, group_number=1, kernel_size=5, stride=2, reduction_ratio=1, name="inv_2"
15. )(input_tensor)
16. print(f"with stride 2 ouput shape: {
17.       
18.        output_tensor.shape}")
20. # Compute involution with stride 1, channel 16 and reduction ratio 2.
21. output_tensor, _ = Involution(
22.     channel=16, group_number=1, kernel_size=5, stride=1, reduction_ratio=2, name="inv_3"
23. )(input_tensor)
24. print(
25.     "with channel 16 and reduction ratio 2 ouput shape: {}".format(output_tensor.shape)
26. )

复制代码

     

1. with stride 1 ouput shape: (32, 256, 256, 3) with stride 2 ouput shape: (32, 128, 128, 3) with channel 16 and reduction ratio 2 ouput shape: (32, 256, 256, 3)

复制代码

   

---

图像分类

在本节中，我们将构建一个图像分类器模子。会有 是两个模子，一个带有卷积，另一个带有内卷。

图像分类模子深受 Google 的卷积神经网络 （CNN） 教程的启发。

---

获取 CIFAR10 数据集

  

1. # Load the CIFAR10 dataset.
2. print("loading the CIFAR10 dataset...")
3. (
4.     (train_images, train_labels),
5.     (
6.         test_images,
7.         test_labels,
8.     ),
9. ) = keras.datasets.cifar10.load_data()
11. # Normalize pixel values to be between 0 and 1.
12. (train_images, test_images) = (train_images / 255.0, test_images / 255.0)
14. # Shuffle and batch the dataset.
15. train_ds = (
16.     tf.data.Dataset.from_tensor_slices((train_images, train_labels))
17.     .shuffle(256)
18.     .batch(256)
19. )
20. test_ds = tf.data.Dataset.from_tensor_slices((test_images, test_labels)).batch(256)

复制代码

     

1. loading the CIFAR10 dataset...

复制代码

   

---

可视化数据

  

1. class_names = [
2.     "airplane",
3.     "automobile",
4.     "bird",
5.     "cat",
6.     "deer",
7.     "dog",
8.     "frog",
9.     "horse",
10.     "ship",
11.     "truck",
12. ]
14. plt.figure(figsize=(10, 10))
15. for i in range(25):
16.     plt.subplot(5, 5, i + 1)
17.     plt.xticks([])
18.     plt.yticks([])
19.     plt.grid(False)
20.     plt.imshow(train_images[i])
21.     plt.xlabel(class_names[train_labels[i][0]])
22. plt.show()

复制代码

---

卷积神经网络

  

1. # Build the conv model.
2. print("building the convolution model...")
3. conv_model = keras.Sequential(
4.     [
5.         keras.layers.Conv2D(32, (3, 3), input_shape=(32, 32, 3), padding="same"),
6.         keras.layers.ReLU(name="relu1"),
7.         keras.layers.MaxPooling2D((2, 2)),
8.         keras.layers.Conv2D(64, (3, 3), padding="same"),
9.         keras.layers.ReLU(name="relu2"),
10.         keras.layers.MaxPooling2D((2, 2)),
11.         keras.layers.Conv2D(64, (3, 3), padding="same"),
12.         keras.layers.ReLU(name="relu3"),
13.         keras.layers.Flatten(),
14.         keras.layers.Dense(64, activation="relu"),
15.         keras.layers.Dense(10),
16.     ]
17. )
19. # Compile the mode with the necessary loss function and optimizer.
20. print("compiling the convolution model...")
21. conv_model.compile(
22.     optimizer="adam",
23.     loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
24.     metrics=["accuracy"],
25. )
27. # Train the model.
28. print("conv model training...")
29. conv_hist = conv_model.fit(train_ds, epochs=20, validation_data=test_ds)

复制代码

     

1. building the convolution model... compiling the convolution model... conv model training... Epoch 1/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 6s 15ms/step - accuracy: 0.3068 - loss: 1.9000 - val_accuracy: 0.4861 - val_loss: 1.4593 Epoch 2/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.5153 - loss: 1.3603 - val_accuracy: 0.5741 - val_loss: 1.1913 Epoch 3/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.5949 - loss: 1.1517 - val_accuracy: 0.6095 - val_loss: 1.0965 Epoch 4/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.6414 - loss: 1.0330 - val_accuracy: 0.6260 - val_loss: 1.0635 Epoch 5/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.6690 - loss: 0.9485 - val_accuracy: 0.6622 - val_loss: 0.9833 Epoch 6/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.6951 - loss: 0.8764 - val_accuracy: 0.6783 - val_loss: 0.9413 Epoch 7/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.7122 - loss: 0.8167 - val_accuracy: 0.6856 - val_loss: 0.9134 Epoch 8/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.7299 - loss: 0.7709 - val_accuracy: 0.7001 - val_loss: 0.8792 Epoch 9/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.7467 - loss: 0.7288 - val_accuracy: 0.6992 - val_loss: 0.8821 Epoch 10/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.7591 - loss: 0.6982 - val_accuracy: 0.7235 - val_loss: 0.8237 Epoch 11/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.7725 - loss: 0.6550 - val_accuracy: 0.7115 - val_loss: 0.8521 Epoch 12/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.7808 - loss: 0.6302 - val_accuracy: 0.7051 - val_loss: 0.8823 Epoch 13/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.7860 - loss: 0.6101 - val_accuracy: 0.7122 - val_loss: 0.8635 Epoch 14/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.7998 - loss: 0.5786 - val_accuracy: 0.7214 - val_loss: 0.8348 Epoch 15/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.8117 - loss: 0.5473 - val_accuracy: 0.7139 - val_loss: 0.8835 Epoch 16/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.8168 - loss: 0.5267 - val_accuracy: 0.7155 - val_loss: 0.8840 Epoch 17/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.8266 - loss: 0.5022 - val_accuracy: 0.7239 - val_loss: 0.8576 Epoch 18/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.8374 - loss: 0.4750 - val_accuracy: 0.7262 - val_loss: 0.8756 Epoch 19/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.8452 - loss: 0.4505 - val_accuracy: 0.7235 - val_loss: 0.9049 Epoch 20/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.8531 - loss: 0.4283 - val_accuracy: 0.7304 - val_loss: 0.8962

复制代码

   

---

内卷神经网络

  

1. # Build the involution model.
2. print("building the involution model...")
4. inputs = keras.Input(shape=(32, 32, 3))
5. x, _ = Involution(
6.     channel=3, group_number=1, kernel_size=3, stride=1, reduction_ratio=2, name="inv_1"
7. )(inputs)
8. x = keras.layers.ReLU()(x)
9. x = keras.layers.MaxPooling2D((2, 2))(x)
10. x, _ = Involution(
11.     channel=3, group_number=1, kernel_size=3, stride=1, reduction_ratio=2, name="inv_2"
12. )(x)
13. x = keras.layers.ReLU()(x)
14. x = keras.layers.MaxPooling2D((2, 2))(x)
15. x, _ = Involution(
16.     channel=3, group_number=1, kernel_size=3, stride=1, reduction_ratio=2, name="inv_3"
17. )(x)
18. x = keras.layers.ReLU()(x)
19. x = keras.layers.Flatten()(x)
20. x = keras.layers.Dense(64, activation="relu")(x)
21. outputs = keras.layers.Dense(10)(x)
23. inv_model = keras.Model(inputs=[inputs], outputs=[outputs], name="inv_model")
25. # Compile the mode with the necessary loss function and optimizer.
26. print("compiling the involution model...")
27. inv_model.compile(
28.     optimizer="adam",
29.     loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
30.     metrics=["accuracy"],
31. )
33. # train the model
34. print("inv model training...")
35. inv_hist = inv_model.fit(train_ds, epochs=20, validation_data=test_ds)

复制代码

     

1. building the involution model... compiling the involution model... inv model training... Epoch 1/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 9s 25ms/step - accuracy: 0.1369 - loss: 2.2728 - val_accuracy: 0.2716 - val_loss: 2.1041 Epoch 2/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.2922 - loss: 1.9489 - val_accuracy: 0.3478 - val_loss: 1.8275 Epoch 3/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.3477 - loss: 1.8098 - val_accuracy: 0.3782 - val_loss: 1.7435 Epoch 4/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.3741 - loss: 1.7420 - val_accuracy: 0.3901 - val_loss: 1.6943 Epoch 5/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.3931 - loss: 1.6942 - val_accuracy: 0.4007 - val_loss: 1.6639 Epoch 6/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.4057 - loss: 1.6622 - val_accuracy: 0.4108 - val_loss: 1.6494 Epoch 7/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4134 - loss: 1.6374 - val_accuracy: 0.4202 - val_loss: 1.6363 Epoch 8/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4200 - loss: 1.6166 - val_accuracy: 0.4312 - val_loss: 1.6062 Epoch 9/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.4286 - loss: 1.5949 - val_accuracy: 0.4316 - val_loss: 1.6018 Epoch 10/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.4346 - loss: 1.5794 - val_accuracy: 0.4346 - val_loss: 1.5963 Epoch 11/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4395 - loss: 1.5641 - val_accuracy: 0.4388 - val_loss: 1.5831 Epoch 12/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.4445 - loss: 1.5502 - val_accuracy: 0.4443 - val_loss: 1.5826 Epoch 13/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4493 - loss: 1.5391 - val_accuracy: 0.4497 - val_loss: 1.5574 Epoch 14/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4528 - loss: 1.5255 - val_accuracy: 0.4547 - val_loss: 1.5433 Epoch 15/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.4575 - loss: 1.5148 - val_accuracy: 0.4548 - val_loss: 1.5438 Epoch 16/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4599 - loss: 1.5072 - val_accuracy: 0.4581 - val_loss: 1.5323 Epoch 17/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4664 - loss: 1.4957 - val_accuracy: 0.4598 - val_loss: 1.5321 Epoch 18/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4701 - loss: 1.4863 - val_accuracy: 0.4575 - val_loss: 1.5302 Epoch 19/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4737 - loss: 1.4790 - val_accuracy: 0.4676 - val_loss: 1.5233 Epoch 20/20 196/196 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.4771 - loss: 1.4740 - val_accuracy: 0.4719 - val_loss: 1.5096

复制代码

   

---

比较

在本节中，我们将检察这两个模子并比较 几个指针。

参数

可以看到，在雷同的架构中，CNN 中的 parameters 比 INN（内卷神经网络）大得多。

  

1. conv_model.summary()
3. inv_model.summary()

复制代码

1. <strong>Model: "sequential_3"</strong>

复制代码

1. ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
2. ┃<strong> Layer (type)                    </strong>┃<strong> Output Shape              </strong>┃<strong>    Param # </strong>┃
3. ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩
4. │ conv2d_6 (Conv2D)               │ (None, 32, 32, 32)        │        896 │
5. ├─────────────────────────────────┼───────────────────────────┼────────────┤
6. │ relu1 (ReLU)                    │ (None, 32, 32, 32)        │          0 │
7. ├─────────────────────────────────┼───────────────────────────┼────────────┤
8. │ max_pooling2d (MaxPooling2D)    │ (None, 16, 16, 32)        │          0 │
9. ├─────────────────────────────────┼───────────────────────────┼────────────┤
10. │ conv2d_7 (Conv2D)               │ (None, 16, 16, 64)        │     18,496 │
11. ├─────────────────────────────────┼───────────────────────────┼────────────┤
12. │ relu2 (ReLU)                    │ (None, 16, 16, 64)        │          0 │
13. ├─────────────────────────────────┼───────────────────────────┼────────────┤
14. │ max_pooling2d_1 (MaxPooling2D)  │ (None, 8, 8, 64)          │          0 │
15. ├─────────────────────────────────┼───────────────────────────┼────────────┤
16. │ conv2d_8 (Conv2D)               │ (None, 8, 8, 64)          │     36,928 │
17. ├─────────────────────────────────┼───────────────────────────┼────────────┤
18. │ relu3 (ReLU)                    │ (None, 8, 8, 64)          │          0 │
19. ├─────────────────────────────────┼───────────────────────────┼────────────┤
20. │ flatten (Flatten)               │ (None, 4096)              │          0 │
21. ├─────────────────────────────────┼───────────────────────────┼────────────┤
22. │ dense (Dense)                   │ (None, 64)                │    262,208 │
23. ├─────────────────────────────────┼───────────────────────────┼────────────┤
24. │ dense_1 (Dense)                 │ (None, 10)                │        650 │
25. └─────────────────────────────────┴───────────────────────────┴────────────┘

复制代码

1. <strong> Total params: </strong>957,536 (3.65 MB)

复制代码

1. <strong> Trainable params: </strong>319,178 (1.22 MB)

复制代码

1. <strong> Non-trainable params: </strong>0 (0.00 B)

复制代码

1. <strong> Optimizer params: </strong>638,358 (2.44 MB)

复制代码

1. <strong>Model: "inv_model"</strong>

复制代码

1. ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
2. ┃<strong> Layer (type)                    </strong>┃<strong> Output Shape              </strong>┃<strong>    Param # </strong>┃
3. ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩
4. │ input_layer_4 (InputLayer)      │ (None, 32, 32, 3)         │          0 │
5. ├─────────────────────────────────┼───────────────────────────┼────────────┤
6. │ inv_1 (Involution)              │ [(None, 32, 32, 3),       │         26 │
7. │                                 │ (None, 32, 32, 9, 1, 1)]  │            │
8. ├─────────────────────────────────┼───────────────────────────┼────────────┤
9. │ re_lu_4 (ReLU)                  │ (None, 32, 32, 3)         │          0 │
10. ├─────────────────────────────────┼───────────────────────────┼────────────┤
11. │ max_pooling2d_2 (MaxPooling2D)  │ (None, 16, 16, 3)         │          0 │
12. ├─────────────────────────────────┼───────────────────────────┼────────────┤
13. │ inv_2 (Involution)              │ [(None, 16, 16, 3),       │         26 │
14. │                                 │ (None, 16, 16, 9, 1, 1)]  │            │
15. ├─────────────────────────────────┼───────────────────────────┼────────────┤
16. │ re_lu_6 (ReLU)                  │ (None, 16, 16, 3)         │          0 │
17. ├─────────────────────────────────┼───────────────────────────┼────────────┤
18. │ max_pooling2d_3 (MaxPooling2D)  │ (None, 8, 8, 3)           │          0 │
19. ├─────────────────────────────────┼───────────────────────────┼────────────┤
20. │ inv_3 (Involution)              │ [(None, 8, 8, 3), (None,  │         26 │
21. │                                 │ 8, 8, 9, 1, 1)]           │            │
22. ├─────────────────────────────────┼───────────────────────────┼────────────┤
23. │ re_lu_8 (ReLU)                  │ (None, 8, 8, 3)           │          0 │
24. ├─────────────────────────────────┼───────────────────────────┼────────────┤
25. │ flatten_1 (Flatten)             │ (None, 192)               │          0 │
26. ├─────────────────────────────────┼───────────────────────────┼────────────┤
27. │ dense_2 (Dense)                 │ (None, 64)                │     12,352 │
28. ├─────────────────────────────────┼───────────────────────────┼────────────┤
29. │ dense_3 (Dense)                 │ (None, 10)                │        650 │
30. └─────────────────────────────────┴───────────────────────────┴────────────┘

复制代码

1. <strong> Total params: </strong>39,230 (153.25 KB)

复制代码

1. <strong> Trainable params: </strong>13,074 (51.07 KB)

复制代码

1. <strong> Non-trainable params: </strong>6 (24.00 B)

复制代码

1. <strong> Optimizer params: </strong>26,150 (102.15 KB)

复制代码

丧失和正确率图

在这里，丧失图和正确率图表明 INN 很慢 学习者（参数较低）。

  

1. plt.figure(figsize=(20, 5))
3. plt.subplot(1, 2, 1)
4. plt.title("Convolution Loss")
5. plt.plot(conv_hist.history["loss"], label="loss")
6. plt.plot(conv_hist.history["val_loss"], label="val_loss")
7. plt.legend()
9. plt.subplot(1, 2, 2)
10. plt.title("Involution Loss")
11. plt.plot(inv_hist.history["loss"], label="loss")
12. plt.plot(inv_hist.history["val_loss"], label="val_loss")
13. plt.legend()
15. plt.show()
17. plt.figure(figsize=(20, 5))
19. plt.subplot(1, 2, 1)
20. plt.title("Convolution Accuracy")
21. plt.plot(conv_hist.history["accuracy"], label="accuracy")
22. plt.plot(conv_hist.history["val_accuracy"], label="val_accuracy")
23. plt.legend()
25. plt.subplot(1, 2, 2)
26. plt.title("Involution Accuracy")
27. plt.plot(inv_hist.history["accuracy"], label="accuracy")
28. plt.plot(inv_hist.history["val_accuracy"], label="val_accuracy")
29. plt.legend()
31. plt.show()

复制代码

---

可视化 Involution Kernel

为了可视化内核，我们从每个内核中获取 K×K 值的总和 involution 内核。不同空间的全部代表 locations 框架相应的热图。

作者提到：

“我们发起的内卷让人想起自我注意和 基本上可以成为它的广义版本。

通过内核的可视化，我们确实可以得到 图像的映射。学习的内卷核关注 输入张量的单个空间位置。特定于位置的特性使 involution 成为模子的通用空间 自我关注属于此中。

  

1. layer_names = ["inv_1", "inv_2", "inv_3"]
2. outputs = [inv_model.get_layer(name).output[1] for name in layer_names]
3. vis_model = keras.Model(inv_model.input, outputs)
5. fig, axes = plt.subplots(nrows=10, ncols=4, figsize=(10, 30))
7. for ax, test_image in zip(axes, test_images[:10]):
8.     (inv1_kernel, inv2_kernel, inv3_kernel) = vis_model.predict(test_image[None, ...])
9.     inv1_kernel = tf.reduce_sum(inv1_kernel, axis=[-1, -2, -3])
10.     inv2_kernel = tf.reduce_sum(inv2_kernel, axis=[-1, -2, -3])
11.     inv3_kernel = tf.reduce_sum(inv3_kernel, axis=[-1, -2, -3])
13.     ax[0].imshow(keras.utils.array_to_img(test_image))
14.     ax[0].set_title("Input Image")
16.     ax[1].imshow(keras.utils.array_to_img(inv1_kernel[0, ..., None]))
17.     ax[1].set_title("Involution Kernel 1")
19.     ax[2].imshow(keras.utils.array_to_img(inv2_kernel[0, ..., None]))
20.     ax[2].set_title("Involution Kernel 2")
22.     ax[3].imshow(keras.utils.array_to_img(inv3_kernel[0, ..., None]))
23.     ax[3].set_title("Involution Kernel 3")

复制代码

     

1. 1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 503ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step

复制代码

   

---

结论

在此示例中，主要重点是构建一个层，该层 可以很容易地重复使用。虽然我们的比较是基于特定的 使命，请随意使用该图层来完成不同的使命并陈诉您的 效果。Involution

在我看来，内卷的关键要点是它的 与自我注意的关系。特定位置背后的直觉 通道特异性处理在许多使命中都故意义。

展望未来，您可以：

• 观看 Yannick 的视频 内卷，以便更好地理解。
  
• 试验内卷层的各种超参数。
  
• 使用内卷层构建不同的模子。
  
• 尝试完全构建不同的内核天生方法。
  

您可以使用 Hugging Face Hub 上托管的练习模子，并尝试 Hugging Face Spaces 上的演示。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。