0
1

特殊图像的色彩特征工程：非自然图像的颜色编码

并非所有彩色的图像都应该是彩色的，或者换句话说并非所有使用 RGB（红、绿、蓝）编码的图像都应该使用这些颜色！ 在本文中，我们将探讨特征工程的不同方式（将原始颜色值进行展开）如何有助于提高卷积神经网络的分类性能。

有多种方法可以更改和调整 RGB 图像的颜色编码（例如，将 RGB 转换为 HSV、LAB 或 XYZ 值；scikit-image 提供了许多很棒的例程来执行此操作） - 但是本文不是关于此的，而更多的是思考数据试图捕获什么以及如何利用它。

数据集

为了更好地突出本文的目的，让我们看一下以下三个数据集（每张图像显示该数据集中的 100 张单独图像）：

这三个数据集是 MedMNIST 数据集的一部分——图像取自相应的论文。

这些数据集的共同点是，来自给定数据集的单个图像都有其特定的颜色范围。 虽然粉红色或红色色调存在波动，但对于这些图像中的大多数，图像之间的对比度差异比实际 RGB 颜色值所代表的差异更为重要。

这为我们提供了一个独特的特征工程机会。 我们可以不使用原始的RGB颜色值，而是研究数据集对特定颜色空间的适应度是否有助于并改进我们最终结果指标。

为了研究这个主题，我们使用MedMNIST的增强血细胞数据集(见原论文)。这个数据集包含了大约17000张来自10种不同血细胞类型的图像。让我们来看看这个数据集中的一些图片!

  1. # Download dataset
  2. !wget https://zenodo.org/record/5208230/files/bloodmnist.npz
  4. # Load packages
  5. import numpy as np
  6. from glob import glob
  7. import matplotlib.pyplot as plt
  8. from tqdm.notebook import tqdm
  9. import pandas as pd
  11. import seaborn as sns
  13. sns.set_context("talk")
  14. %config InlineBackend.figure_format = 'retina'
  16. # Load data set
  17. data = np.load("bloodmnist.npz")
  18. X_tr = data["train_images"].astype("float32") / 255
  19. X_va = data["val_images"].astype("float32") / 255
  20. X_te = data["test_images"].astype("float32") / 255
  21. y_tr = data["train_labels"]
  22. y_va = data["val_labels"]
  23. y_te = data["test_labels"]
  25. labels = ["basophils", "eosinophils", "erythroblasts",
  26.           "granulocytes_immature", "lymphocytes",
  27.           "monocytes", "neutrophils", "platelets"]
  29. labels_tr = np.array([labels[j] for j in y_tr.ravel()])
  30. labels_va = np.array([labels[j] for j in y_va.ravel()])
  31. labels_te = np.array([labels[j] for j in y_te.ravel()])

图像取自原始论文，并描述符合数据集的十种血细胞类型。

  1. def plot_dataset(X):
  2.     """Helper function to visualize first few images of a dataset."""
  3.     fig, axes = plt.subplots(12, 12, figsize=(15.5, 16))
  4.     for i, ax in enumerate(axes.flatten()):
  5.         if X.shape[-1] == 1:
  6.             ax.imshow(np.squeeze(X[i]), cmap="gray")
  7.         else:
  8.             ax.imshow(X[i])
  9.         ax.axis("off")
  10.         ax.set_aspect("equal")
  11.     plt.subplots_adjust(wspace=0, hspace=0)
  12.     plt.show()
  14. # Plot dataset
  15. plot_dataset(X_tr)

我们可以看到以下内容： 背景颜色以及主要目标对象颜色在大多数情况下是相同的（但并非总是如此）！ 为了更好地理解为什么这能够为我们提供了颜色值特征工程的机会，让我们先看看这些图像占据的 RGB 颜色空间。

  1. # Extract a few RGB color values
  2. X_colors = X_tr.reshape(-1, 3)[::100]
  4. # Plot color values in 3D space
  5. fig = plt.figure(figsize=(16, 5))
  7. # Loop through 3 different views
  8. for i, view in enumerate([[-45, 10], [40, 80], [60, 10]]):
  9.     ax = fig.add_subplot(1, 3, i + 1, projection="3d")
  10.     ax.scatter(X_colors[:, 0], X_colors[:, 1], X_colors[:, 2], facecolors=X_colors, s=2)
  11.     ax.set_xlabel("R")
  12.     ax.set_ylabel("G")
  13.     ax.set_zlabel("B")
  14.     ax.xaxis.set_ticklabels([])
  15.     ax.yaxis.set_ticklabels([])
  16.     ax.zaxis.set_ticklabels([])
  17.     ax.view_init(azim=view[0], elev=view[1], vertical_axis="z")
  18.     ax.set_xlim(0, 1)
  19.     ax.set_ylim(0, 1)
  20.     ax.set_zlim(0, 1)
  21. plt.suptitle("Colors in RGB space", fontsize=20)
  22. plt.show()

这是原始数据集相同 RGB 颜色空间上的三个不同视图。 这个数据集只覆盖了整个立方体的一小部分，即所有 16'777'216 个可能的颜色值。 这为我们现在提供了三个独特的机会：

  • 我们可以通过将 RGB 颜色转换为灰度图像来降低图像复杂性。
  • 我们可以重新对齐和拉伸颜色值，以便 RGB 值更好地填充 RGB 颜色空间。
  • 我们可以重新调整颜色值的方向，使三个立方体轴延伸到最大方差的方向。 这最好通过 PCA 方法完成。

其实还有多种其他方式来操作颜色值，但对于本文我们将使用上面提到的三种方式。

数据集扩充

1.灰度变换

首先，让我们将 RGB 图像转换为灰度图像（即从 3D 到 1D 数据集）。 灰度图像不仅仅是对 RGB 进行简单的平均，而是对其进行轻微不平衡的加权。 本文使用使用 scikit-image 的 rgb2gray 来执行这个转换。 此外我们将拉伸灰度值以完全覆盖图像的 0 到 255 值范围。

  1. # Install scikit-image if not already done
  2. !pip install -U scikit-image
  4. from skimage.color import rgb2gray
  6. # Create grayscale images
  7. X_tr_gray = rgb2gray(X_tr)[..., None]
  8. X_va_gray = rgb2gray(X_va)[..., None]
  9. X_te_gray = rgb2gray(X_te)[..., None]
  11. # Stretch color range to training min, max
  12. gmin_tr = X_tr_gray.min()
  13. X_tr_gray -= gmin_tr
  14. X_va_gray -= gmin_tr
  15. X_te_gray -= gmin_tr
  17. gmax_tr = X_tr_gray.max()
  18. X_tr_gray /= gmax_tr
  19. X_va_gray /= gmax_tr
  20. X_te_gray /= gmax_tr
  22. X_va_gray = np.clip(X_va_gray, 0, 1)
  23. X_te_gray = np.clip(X_te_gray, 0, 1)

让我们看看这些灰度颜色值是如何在之前的 RGB 颜色空间中定位的。

  1. # Put 1D values into 3D space
  2. X_tr_show = np.concatenate([X_tr_gray, X_tr_gray, X_tr_gray], axis=-1)
  4. # Extract a few grayscale color values
  5. X_grays = X_tr_show.reshape(-1, 3)[::100]
  7. # Plot color values in 3D space
  8. fig = plt.figure(figsize=(16, 5))
  10. # Loop through 3 different views
  11. for i, view in enumerate([[-45, 10], [40, 80], [60, 10]]):
  12.     ax = fig.add_subplot(1, 3, i + 1, projection="3d")
  13.     ax.scatter(X_grays[:, 0], X_grays[:, 1], X_grays[:, 2], facecolors=X_grays, s=2)
  14.     ax.set_xlabel("R")
  15.     ax.set_ylabel("G")
  16.     ax.set_zlabel("B")
  17.     ax.xaxis.set_ticklabels([])
  18.     ax.yaxis.set_ticklabels([])
  19.     ax.zaxis.set_ticklabels([])
  20.     ax.view_init(azim=view[0], elev=view[1], vertical_axis="z")
  21.     ax.set_xlim(0, 1)
  22.     ax.set_ylim(0, 1)
  23.     ax.set_zlim(0, 1)
  24. plt.suptitle("Colors in Grayscale space", fontsize=20)
  25. plt.show()

灰度颜色值正好位于立方体对角线上。我们将三维数据集减少到一维，现在看看单元格图像在灰度格式下的样子。

  1. # Plot dataset
  2. plot_dataset(X_tr_gray)

2.颜色调整和拉伸

在第一个 RGB 立方体图中，我们看到该数据集的颜色值仅占整个立方体的一部分。 当将该点云与第二个 RGB 立方图中的黑白对角线进行比较时，我们可以看到原始颜色偏离轴并略微弯曲。

为了更好地说明我们的意思，这里尝试找到支持该点云的等距“云质心”（或质心）。

  1. # Get RGB color values
  2. X_colors = X_tr.reshape(-1, 3)
  4. # Get distance of all color values to black (0,0,0)
  5. dist_origin = np.linalg.norm(X_colors, axis=-1)
  7. # Find index of 0.1% smallest entry
  8. perc_sorted = np.argsort(np.abs(dist_origin - np.percentile(dist_origin, 0.1)))
  10. # Find centroid of lowest 0.1% RGBs
  11. centroid_low = np.mean(X_colors[perc_sorted][: len(X_colors) // 1000], axis=0)
  13. # Order all RGB values with regards to distance to low centroid
  14. order_idx = np.argsort(np.linalg.norm(X_colors - centroid_low, axis=-1))
  16. # According to this order, divide all RGB values into N equal sized chunks
  17. nth = 256
  18. splits = np.array_split(np.arange(len(order_idx)), nth, axis=0)
  20. # Compute centroids, i.e. RGB mean values of each segment
  21. centroids = np.array([np.median(X_colors[order_idx][s], axis=0) for s in tqdm(splits)])
  23. # Only keep centroids that are spaced enough
  24. new_centers = [centroids[0]]
  25. for i in range(len(centroids)):
  26.     if np.linalg.norm(new_centers[-1] - centroids[i]) > 0.03:
  27.         new_centers.append(centroids[i])
  28. new_centers = np.array(new_centers)

找到这些中心后，在 RGB 颜色立方体中可视化它们。 为了对比，还要在该图中添加灰度对角线。

  1. # Plot centroids in 3D space
  2. fig = plt.figure(figsize=(16, 5))
  4. # Loop through 3 different views
  5. for i, view in enumerate([[-45, 10], [40, 80], [60, 10]]):
  6.     ax = fig.add_subplot(1, 3, i + 1, projection="3d")
  7.     ax.scatter(X_grays[:, 0], X_grays[:, 1], X_grays[:, 2], facecolors=X_grays, s=10)
  8.     ax.scatter(
  9.         new_centers[:, 0],
  10.         new_centers[:, 1],
  11.         new_centers[:, 2],
  12.         facecolors=new_centers,
  13.         s=10)
  14.     ax.set_xlabel("R")
  15.     ax.set_ylabel("G")
  16.     ax.set_zlabel("B")
  17.     ax.xaxis.set_ticklabels([])
  18.     ax.yaxis.set_ticklabels([])
  19.     ax.zaxis.set_ticklabels([])
  20.     ax.set_xlim(0, 1)
  21.     ax.set_ylim(0, 1)
  22.     ax.set_zlim(0, 1)
  23.     ax.view_init(azim=view[0], elev=view[1], vertical_axis="z")
  24. plt.suptitle("Color centroids in RGB space", fontsize=20)
  25. plt.show()

那么我们如何使用这两个信息（云质心和灰度对角线）来重新对齐和拉伸我们的原始数据集？一种有效方法如下：

  1. 对于原始数据集中的每个颜色值，我们计算到最近的云质心的距离向量。
  2. 然后将此距离向量添加到灰度对角线（即重新对齐质心）。
  3. 拉伸和剪切颜色值，以确保 99.9% 的所有值都在所需的颜色范围内。
  1. # Create grayscale diagonal centroids (equal numbers to cloud centroids)
  2. steps = np.linspace(0.2, 0.8, len(new_centers))
  4. # Realign and stretch images
  5. X_tr_stretch = np.array(
  6.     [x - new_centers[np.argmin(np.linalg.norm(x - new_centers, axis=1))]
  7.      + steps[np.argmin(np.linalg.norm(x - new_centers, axis=1))]
  8.      for x in tqdm(X_tr.reshape(-1, 3))])
  9. X_va_stretch = np.array(
  10.     [x - new_centers[np.argmin(np.linalg.norm(x - new_centers, axis=1))]
  11.      + steps[np.argmin(np.linalg.norm(x - new_centers, axis=1))]
  12.      for x in tqdm(X_va.reshape(-1, 3))])
  13. X_te_stretch = np.array(
  14.     [x - new_centers[np.argmin(np.linalg.norm(x - new_centers, axis=1))]
  15.      + steps[np.argmin(np.linalg.norm(x - new_centers, axis=1))]
  16.      for x in tqdm(X_te.reshape(-1, 3))])
  18. # Stretch and clip data
  19. xmin_tr = np.percentile(X_tr_stretch, 0.05, axis=0)
  20. X_tr_stretch -= xmin_tr
  21. X_va_stretch -= xmin_tr
  22. X_te_stretch -= xmin_tr
  23. xmax_tr = np.percentile(X_tr_stretch, 99.95, axis=0)
  24. X_tr_stretch /= xmax_tr
  25. X_va_stretch /= xmax_tr
  26. X_te_stretch /= xmax_tr
  27. X_tr_stretch = np.clip(X_tr_stretch, 0, 1)
  28. X_va_stretch = np.clip(X_va_stretch, 0, 1)
  29. X_te_stretch = np.clip(X_te_stretch, 0, 1)

那么，原始 RGB 颜色值在重新对齐和拉伸后会是什么样子？

  1. # Plot color values in 3D space
  2. fig = plt.figure(figsize=(16, 5))
  4. stretch_colors = X_tr_stretch[::100]
  6. # Loop through 3 different views
  7. for i, view in enumerate([[-45, 10], [40, 80], [60, 10]]):
  8.     ax = fig.add_subplot(1, 3, i + 1, projection="3d")
  9.     ax.scatter(
  10.         stretch_colors[:, 0],
  11.         stretch_colors[:, 1],
  12.         stretch_colors[:, 2],
  13.         facecolors=stretch_colors,
  14.         s=2)
  15.     ax.set_xlabel("R")
  16.     ax.set_ylabel("G")
  17.     ax.set_zlabel("B")
  18.     ax.xaxis.set_ticklabels([])
  19.     ax.yaxis.set_ticklabels([])
  20.     ax.zaxis.set_ticklabels([])
  21.     ax.view_init(azim=view[0], elev=view[1], vertical_axis="z")
  22.     ax.set_xlim(0, 1)
  23.     ax.set_ylim(0, 1)
  24.     ax.set_zlim(0, 1)
  25. plt.suptitle("Colors in realigned and stretched space", fontsize=20)
  26. plt.show()

这看起来已经很有不错了。 点云更好地与立方体对角线对齐，并且似乎点云向各个方向延伸了一点。 在这种新的颜色编码中，细胞图像是什么样的？

  1. # Convert data back into image space
  2. X_tr_stretch = X_tr_stretch.reshape(X_tr.shape)
  3. X_va_stretch = X_va_stretch.reshape(X_va.shape)
  4. X_te_stretch = X_te_stretch.reshape(X_te.shape)
  6. # Plot dataset
  7. plot_dataset(X_tr_stretch)

3.PCA 转换

最后一个选项，让我们使用 PCA 方法将原始 RGB 颜色值转换为新的 3D 空间，这三个新轴中的每一个都尽可能多地解释差异。对于这种方法，本文将使用原始 RGB 颜色值，但也可以使用刚刚重新对齐和拉伸的值。

那么在这个新的 PCA 颜色空间中，原始的 RGB 颜色值是什么样的呢？

  1. # Train PCA decomposition on original RGB values
  2. from sklearn.decomposition import PCA
  4. pca = PCA()
  5. pca.fit(X_tr.reshape(-1, 3))
  7. # Transform all data sets into new PCA space
  8. X_tr_pca = pca.transform(X_tr.reshape(-1, 3))
  9. X_va_pca = pca.transform(X_va.reshape(-1, 3))
  10. X_te_pca = pca.transform(X_te.reshape(-1, 3))
  12. # Stretch and clip data
  13. xmin_tr = np.percentile(X_tr_pca, 0.05, axis=0)
  14. X_tr_pca -= xmin_tr
  15. X_va_pca -= xmin_tr
  16. X_te_pca -= xmin_tr
  17. xmax_tr = np.percentile(X_tr_pca, 99.95, axis=0)
  18. X_tr_pca /= xmax_tr
  19. X_va_pca /= xmax_tr
  20. X_te_pca /= xmax_tr
  21. X_tr_pca = np.clip(X_tr_pca, 0, 1)
  22. X_va_pca = np.clip(X_va_pca, 0, 1)
  23. X_te_pca = np.clip(X_te_pca, 0, 1)
  25. # Flip first component
  26. X_tr_pca[:, 0] = 1 - X_tr_pca[:, 0]
  27. X_va_pca[:, 0] = 1 - X_va_pca[:, 0]
  28. X_te_pca[:, 0] = 1 - X_te_pca[:, 0]
  30. # Extract a few RGB color values
  31. X_colors = X_tr_pca[::100].reshape(-1, 3)
  33. # Plot color values in 3D space
  34. fig = plt.figure(figsize=(16, 5))
  36. # Loop through 3 different views
  37. for i, view in enumerate([[-45, 10], [40, 80], [60, 10]]):
  38.     ax = fig.add_subplot(1, 3, i + 1, projection="3d")
  39.     ax.scatter(X_colors[:, 0], X_colors[:, 1], X_colors[:, 2], facecolors=X_colors, s=2)
  40.     ax.set_xlabel("PC1")
  41.     ax.set_ylabel("PC2")
  42.     ax.set_zlabel("PC3")
  43.     ax.xaxis.set_ticklabels([])
  44.     ax.yaxis.set_ticklabels([])
  45.     ax.zaxis.set_ticklabels([])
  46.     ax.view_init(azim=view[0], elev=view[1], vertical_axis="z")
  47.     ax.set_xlim(0, 1)
  48.     ax.set_ylim(0, 1)
  49.     ax.set_zlim(0, 1)
  50. plt.suptitle("Colors in PCA space", fontsize=20)
  51. plt.show()

拉伸效果很好！ 但是图像呢？ 让我们来看看。

  1. # Convert data back into image space
  2. X_tr_pca = X_tr_pca.reshape(X_tr.shape)
  3. X_va_pca = X_va_pca.reshape(X_va.shape)
  4. X_te_pca = X_te_pca.reshape(X_te.shape)
  6. # Plot dataset
  7. plot_dataset(X_tr_pca)

这看起来也很有意思。 各部分的颜色都不太相同，例如 背景、原子核和原子核周围的东西都有不同的颜色。 但是 PCA 转换也带来了图像中的一个伪影——图像中间的类似交叉的颜色边界。 目前尚不清楚这是从哪里来的，但我认为这是由于 MedMNIST 通过对原始数据集进行下采样而引入的数据集操作。

特征的相关性

在继续我们的下一部分研究之前(即测试这些颜色操作是否能帮助卷积神经网络对10个目标类进行分类)，让我们快速地看看这些新的颜色值是如何相互关联的。

  1. # Combine all images in one big dataframe
  2. X_tr_all = np.vstack([X_tr.T, X_tr_gray.T, X_tr_stretch.T, X_tr_pca.T]).T
  3. X_va_all = np.vstack([X_va.T, X_va_gray.T, X_va_stretch.T, X_va_pca.T]).T
  4. X_te_all = np.vstack([X_te.T, X_te_gray.T, X_te_stretch.T, X_te_pca.T]).T
  6. # Compute correlation matrix between all color features
  7. corr_all = np.corrcoef(X_tr_all.reshape(-1, X_tr_all.shape[-1]).T)
  8. cols = ["Red", "Green", "Blue", "Gray",
  9.         "Stretch1", "Stretch2", "Stretch3",
  10.         "PC1", "PC2", "PC3"]
  12. plt.figure(figsize=(8, 8))
  13. sns.heatmap(
  14.     100 * corr_all,
  15.     square=True,
  16.     center=0,
  17.     annot=True,
  18.     fmt=".0f",
  19.     cbar=False,
  20.     xticklabels=cols,
  21.     yticklabels=cols,
  22. )

正如我们所看到的，许多新的颜色特征与原始的RGB值高度相关(除了第二和第三个PCA特征)。下面就可以测试颜色处理是否对图像分类有帮助。

测试图像分类

看看我们的颜色处理是否能帮助卷积神经网络对8个目标类进行分类。我们创建一个“小的”ResNet模型，并在数据集的所有4个版本(即原始，灰度，拉伸，和PCA)上训练它。

  1. # The code for this ResNet architecture was adapted from here:
  2. # https://towardsdatascience.com/building-a-resnet-in-keras-e8f1322a49ba
  3. from tensorflow import Tensor
  4. from tensorflow.keras.layers import (Input, Conv2D, ReLU, BatchNormalization, Add,
  5.                                      AveragePooling2D, Flatten, Dense, Dropout)
  6. from tensorflow.keras.models import Model
  8. def relu_bn(inputs: Tensor) -> Tensor:
  9.     relu = ReLU()(inputs)
  10.     bn = BatchNormalization()(relu)
  11.     return bn
  13. def residual_block(x: Tensor, downsample: bool, filters: int, kernel_size: int = 3) -> Tensor:
  14.     y = Conv2D(
  15.         kernel_size=kernel_size,
  16.         strides=(1 if not downsample else 2),
  17.         filters=filters,
  18.         padding="same")(x)
  19.     y = relu_bn(y)
  20.     y = Conv2D(kernel_size=kernel_size, strides=1, filters=filters, padding="same")(y)
  22.     if downsample:
  23.         x = Conv2D(kernel_size=1, strides=2, filters=filters, padding="same")(x)
  24.     out = Add()([x, y])
  25.     out = relu_bn(out)
  26.     return out
  29. def create_res_net(in_shape=(28, 28, 3)):
  31.     inputs = Input(shape=in_shape)
  32.     num_filters = 32
  34.     t = BatchNormalization()(inputs)
  35.     t = Conv2D(kernel_size=3, strides=1, filters=num_filters, padding="same")(t)
  36.     t = relu_bn(t)
  38.     num_blocks_list = [2, 2]
  39.     for i in range(len(num_blocks_list)):
  40.         num_blocks = num_blocks_list[i]
  41.         for j in range(num_blocks):
  42.             t = residual_block(t, downsample=(j == 0 and i != 0), filters=num_filters)
  43.         num_filters *= 2
  45.     t = AveragePooling2D(4)(t)
  46.     t = Flatten()(t)
  47.     t = Dense(128, activation="relu")(t)
  48.     t = Dropout(0.5)(t)
  49.     outputs = Dense(8, activation="softmax")(t)
  51.     model = Model(inputs, outputs)
  53.     model.compile(
  54.         optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
  56.     return model
  58. def run_resnet(X_tr, y_tr, X_va, y_va, epochs=200, verbose=0):
  59.     """Support function to train ResNet model"""
  61.     # Create Model
  62.     model = create_res_net(in_shape=X_tr.shape[1:])
  64.     # Creates 'EarlyStopping' callback
  65.     from tensorflow import keras
  67.     earlystopping_cb = keras.callbacks.EarlyStopping(
  68.         patience=10, restore_best_weights=True)
  70.     # Train model
  71.     history = model.fit(
  72.         X_tr,
  73.         y_tr,
  74.         batch_size=120,
  75.         epochs=epochs,
  76.         validation_data=(X_va, y_va),
  77.         callbacks=[earlystopping_cb],
  78.         verbose=verbose)
  80.     return model, history
  82. def plot_history(history):
  83.     """Support function to plot model history"""
  85.     # Plots neural network performance metrics for train and validation
  86.     fig, axs = plt.subplots(1, 2, figsize=(15, 4))
  87.     results = pd.DataFrame(history.history)
  88.     results[["accuracy", "val_accuracy"]].plot(ax=axs[0])
  89.     results[["loss", "val_loss"]].plot(ax=axs[1], logy=True)
  90.     plt.tight_layout()
  91.     plt.show()
  93. def plot_classification_report(X_te, y_te, model):
  94.     """Support function to plot classification report"""
  96.     # Show classification report
  97.     from sklearn.metrics import classification_report
  99.     y_pred = model.predict(X_te).argmax(axis=1)
  100.     print(classification_report(y_te.ravel(), y_pred))
  102.     # Show confusion matrix
  103.     from sklearn.metrics import ConfusionMatrixDisplay
  105.     fig, ax = plt.subplots(1, 2, figsize=(16, 7))
  106.     ConfusionMatrixDisplay.from_predictions(
  107.         y_te.ravel(), y_pred, ax=ax[0], colorbar=False, cmap="inferno_r")
  109.     from sklearn.metrics import ConfusionMatrixDisplay
  111.     ConfusionMatrixDisplay.from_predictions(
  112.         y_te.ravel(), y_pred, normalize="true", ax=ax[1],
  113.         values_format=".1f", colorbar=False, cmap="inferno_r")

原始数据集的分类性能

首先在原始数据集上训练一个 ResNet 模型来建立一个基线。 下面显示了模型在训练期间的性能（准确率和损失）。

  1. # Train model
  2. model_orig, history_orig = run_resnet(X_tr, y_tr, X_va, y_va)
  4. # Show model performance during training
  5. plot_history(history_orig)

  1. # Evaluate Model
  2. loss_orig_tr, acc_orig_tr = model_orig.evaluate(X_tr, y_tr)
  3. loss_orig_va, acc_orig_va = model_orig.evaluate(X_va, y_va)
  4. loss_orig_te, acc_orig_te = model_orig.evaluate(X_te, y_te)
  6. # Report classification report and confusion matrix
  7. plot_classification_report(X_te, y_te, model_orig)
  9. Train score: loss = 0.0537 - accuracy = 0.9817
  10. Valid score: loss = 0.1816 - accuracy = 0.9492
  11. Test score:  loss = 0.1952 - accuracy = 0.9421

模型已经训练好了，通过查看相应的混淆矩阵来看看它在检测 8 个目标类别方面的能力如何。 左侧的混淆矩阵显示了正确/错误识别的样本数量，而右侧则显示了每个目标类别的比例值。

灰度数据集的分类性能

对灰度转换的图像做同样的事情。 训练期间的模型性能如何？

  1. # Train model
  2. model_gray, history_gray = run_resnet(X_tr_gray, y_tr, X_va_gray, y_va)
  4. # Show model performance during training
  5. plot_history(history_gray)

那么混淆矩阵呢？

  1. # Evaluate Model
  2. loss_gray_tr, acc_gray_tr = model_gray.evaluate(X_tr_gray, y_tr)
  3. loss_gray_va, acc_gray_va = model_gray.evaluate(X_va_gray, y_va)
  4. loss_gray_te, acc_gray_te = model_gray.evaluate(X_te_gray, y_te)
  6. # Report classification report and confusion matrix
  7. plot_classification_report(X_te_gray, y_te, model_gray)
  9. Train score: loss = 0.1118 - accuracy = 0.9619
  10. Valid score: loss = 0.2255 - accuracy = 0.9287
  11. Test score:  loss = 0.2407 - accuracy = 0.9220

重新对齐和拉伸数据集的分类性能

对重新对齐和拉伸的图像做同样的事情。 

  1. # Train model
  2. model_stretch, history_stretch = run_resnet(X_tr_stretch, y_tr, X_va_stretch, y_va)
  4. # Show model performance during training
  5. plot_history(history_stretch)

混淆矩阵

  1. # Evaluate Model
  2. loss_stretch_tr, acc_stretch_tr = model_stretch.evaluate(X_tr_stretch, y_tr)
  3. loss_stretch_va, acc_stretch_va = model_stretch.evaluate(X_va_stretch, y_va)
  4. loss_stretch_te, acc_stretch_te = model_stretch.evaluate(X_te_stretch, y_te)
  6. # Report classification report and confusion matrix
  7. plot_classification_report(X_te_stretch, y_te, model_stretch)
  9. Train score: loss = 0.0229 - accuracy = 0.9921
  10. Valid score: loss = 0.1672 - accuracy = 0.9533
  11. Test score:  loss = 0.1975 - accuracy = 0.9491

PCA 转换的数据集的分类性能

  1. # Train model
  2. model_pca, history_pca = run_resnet(X_tr_pca, y_tr, X_va_pca, y_va)
  4. # Show model performance during training
  5. plot_history(history_pca)

混淆矩阵

  1. # Evaluate Model
  2. loss_pca_tr, acc_pca_tr = model_pca.evaluate(X_tr_pca, y_tr)
  3. loss_pca_va, acc_pca_va = model_pca.evaluate(X_va_pca, y_va)
  4. loss_pca_te, acc_pca_te = model_pca.evaluate(X_te_pca, y_te)
  6. # Report classification report and confusion matrix
  7. plot_classification_report(X_te_pca, y_te, model_pca)
  9. Train score: loss = 0.0289 - accuracy = 0.9918
  10. Valid score: loss = 0.1459 - accuracy = 0.9509
  11. Test score:  loss = 0.1898 - accuracy = 0.9448

模型对比

训练了所有这些单独的模型，让我们看看它们之间的关系以及它们之间的区别。 首先，将它们各自对测试集的预测画在一起，比较这些不同的模型预测相同值的方式。

  1. # Compute model specific predictions
  2. y_pred_orig = model_orig.predict(X_te).argmax(axis=1)
  3. y_pred_gray = model_gray.predict(X_te_gray).argmax(axis=1)
  4. y_pred_stretch = model_stretch.predict(X_te_stretch).argmax(axis=1)
  5. y_pred_pca = model_pca.predict(X_te_pca).argmax(axis=1)
  7. # Aggregate all model predictions
  8. target = y_te.ravel()
  9. predictions = np.array([y_pred_orig, y_pred_gray, y_pred_stretch, y_pred_pca])[
  10.     :, np.argsort(target)]
  12. # Plot model individual predictions
  13. plt.figure(figsize=(20, 3))
  14. plt.imshow(predictions, aspect="auto", interpolation="nearest", cmap="rainbow")
  15. plt.xlabel(f"Predictions for all {predictions.shape[1]} test samples")
  16. plt.ylabel("Model")
  17. plt.yticks(ticks=range(4), labels=["Orig", "Gray", "Stretched", "PCA"]);

我们可以看到，除了原始数据集，其他模型在第8个目标类(红色部分)中都不会出错。所以我们的操作似乎是有用的。在这三种方法中，“重新排列和拉伸”的数据集似乎表现最好。为了支持这一说法，让我们看看我们四个模型的测试准确性。

  1. # Collect accuracies
  2. accs_te = np.array([acc_orig_te, acc_gray_te, acc_stretch_te, acc_pca_te]) * 100
  4. # Plot accuracies
  5. plt.figure(figsize=(8, 3))
  7. plt.title("Test accuracy for our four models")
  8. plt.bar(["Orig", "Gray", "Stretched", "PCA"], accs_te, alpha=0.5)
  9. plt.hlines(accs_te[0], -0.4, 3.4, colors="black", linestyles="dotted")
  10. plt.ylim(90, 98);

模型叠加

4个模型都有一些不同，让我们试着进一步训练一个“元”模型，它使用我们4个模型的预测作为输入。

  1. # Compute prediction probabilities for all models and data sets
  2. y_prob_tr_orig = model_orig.predict(X_tr)
  3. y_prob_tr_gray = model_gray.predict(X_tr_gray)
  4. y_prob_tr_stretch = model_stretch.predict(X_tr_stretch)
  5. y_prob_tr_pca = model_pca.predict(X_tr_pca)
  7. y_prob_va_orig = model_orig.predict(X_va)
  8. y_prob_va_gray = model_gray.predict(X_va_gray)
  9. y_prob_va_stretch = model_stretch.predict(X_va_stretch)
  10. y_prob_va_pca = model_pca.predict(X_va_pca)
  12. y_prob_te_orig = model_orig.predict(X_te)
  13. y_prob_te_gray = model_gray.predict(X_te_gray)
  14. y_prob_te_stretch = model_stretch.predict(X_te_stretch)
  15. y_prob_te_pca = model_pca.predict(X_te_pca)
  17. # Combine prediction probabilities into meta data sets
  18. y_prob_tr = np.concatenate(
  19.     [y_prob_tr_orig, y_prob_tr_gray, y_prob_tr_stretch, y_prob_tr_pca], axis=1)
  20. y_prob_va = np.concatenate(
  21.     [y_prob_va_orig, y_prob_va_gray, y_prob_va_stretch, y_prob_va_pca], axis=1)
  22. y_prob_te = np.concatenate(
  23.     [y_prob_te_orig, y_prob_te_gray, y_prob_te_stretch, y_prob_te_pca], axis=1)
  25. # Combine training and validation dataset
  26. y_prob_train = np.concatenate([y_prob_tr, y_prob_va], axis=0)
  27. y_train = np.concatenate([y_tr, y_va], axis=0).ravel()

有许多不同的分类模型可供选择，但为了保持简短和紧凑，让我们快速训练一个多层感知器分类器，并将其得分与其他四种模型进行比较。

  1. from sklearn.neural_network import MLPClassifier
  3. # Create MLP classifier
  4. clf = MLPClassifier(
  5.     hidden_layer_sizes=(32, 16), activation="relu", solver="adam", alpha=0.42, batch_size=120,
  6.     learning_rate="adaptive", learning_rate_init=0.001, max_iter=100, shuffle=True, random_state=24,
  7.     early_stopping=True, validation_fraction=0.15)
  9. # Train model
  10. clf.fit(y_prob_train, y_train)
  12. # Compute prediction accuracy of meta classifier
  13. acc_meta_te = np.mean(clf.predict(y_prob_te) == y_te.ravel())
  15. # Collect accuracies
  16. accs_te = np.array([acc_orig_te, acc_gray_te, acc_stretch_te, acc_pca_te, 0]) * 100
  17. accs_meta = np.array([0, 0, 0, 0, acc_meta_te]) * 100
  19. # Plot accuracies
  20. plt.figure(figsize=(8, 3))
  22. plt.title("Test accuracy for all five models")
  23. plt.bar(["Orig", "Gray", "Stretched", "PCA", "Meta"], accs_te, alpha=0.5)
  24. plt.bar(["Orig", "Gray", "Stretched", "PCA", "Meta"], accs_meta, alpha=0.5)
  25. plt.hlines(accs_te[0], -0.4, 4.4, colors="black", linestyles="dotted")
  26. plt.ylim(90, 98);

太棒了!在原始数据集和三种颜色变换数据集上训练四种不同的模型，然后利用这些预测概率训练一种新的元分类器，帮助我们将初始预测准确率从94%提高到96.4%!

本文地址：https://miykael.github.io/blog/2021/color_engineering_medmnist/

作者：michael notter

标签： 计算机视觉 特征工程 深度学习
登录后发布评论

“特殊图像的色彩特征工程：非自然图像的颜色编码”的评论:

还没有评论
关于作者
...
Deephub
更多文章请关注公众号：Deephub-IMBA
相关阅读

比扩散策略更高效的生成模型：流匹配的理论基础与Pytorch代码实现

从零实现基于扩散模型的文本到视频生成系统：技术详解与Pytorch代码实现

18个常用的强化学习算法整理：从基础方法到高级模型的理论技术与代码实现

PyTorch CUDA内存管理优化：深度理解GPU资源分配与缓存机制

LangChain RAG入门教程：构建基于私有文档的智能问答助手

基于LlamaIndex实现CodeAct Agent：代码执行工作流的技术架构与原理

频率派与贝叶斯统计在营销组合建模中的应用比较：隐私优先时代的方法选择