使用 skimage 增强图像— Python
个人电脑:Flickr
嘿伙计们，最近我在解决一个图像分类问题。但不幸的是，其中一个班级没有足够的样本。我在网上搜索，了解到一种叫做图像增强的技术。在这里，我分享了我对这种技术的理解，并分享了一些使用 skimage 的代码。你可以在底部找到 jupyter 笔记本。
什么是图像增强？
影像增强是一种用于人为增加影像数据集大小的技术。这可以通过对图像进行随机变换来实现。
我们知道，当深度学习模型能够看到更多数据时，它们能够很好地进行归纳。数据扩充可以创建现有图像的变体，这有助于更好地进行归纳。
但是你也需要小心。我们可以使用增强图像进行训练，但不能用于测试。因此，在应用任何增强之前，请将您的数据分成训练集和测试集。使用图像增强功能扩展您的训练数据。
图像增强主要应用于图像的两个领域
- 位置增强
- 增色
什么是位置增强？
位置增强很简单，我们在像素位置上应用不同的变换。
缩放、旋转、裁剪、翻转、填充、缩放、平移、剪切和其他仿射变换是位置增强的示例。让我们尝试应用其中的一些转换。
import numpy as np
from skimage.io import imread, imsave
import matplotlib.pyplot as plt
from skimage import transform
from skimage.transform import rotate, AffineTransform
from skimage.util import random_noise
from skimage.filters import gaussian
from scipy import ndimage# load Image
img = imread('./butterfly.jpg') / 255# plot original Image
plt.imshow(img)
plt.show()
原始图像 PC: Flickr
# image rotation using skimage.transformation.rotate
rotate30 = rotate(img, angle=30)
rotate45 = rotate(img, angle=45)
rotate60 = rotate(img, angle=60)
rotate90 = rotate(img, angle=90)fig = plt.figure(tight_layout='auto', figsize=(10, 7))fig.add_subplot(221)
plt.title('Rotate 30')
plt.imshow(rotate30)fig.add_subplot(222)
plt.title('Rotate 45')
plt.imshow(rotate45)fig.add_subplot(223)
plt.title('Rotate 60')
plt.imshow(rotate60)fig.add_subplot(224)
plt.title('Rotate 90')
plt.imshow(rotate90)plt.show()
# image shearing using sklearn.transform.AffineTransform
# try out with differnt values of shear
tf = AffineTransform(shear=-0.5)
sheared = transform.warp(img, tf, order=1, preserve_range=True, mode='wrap')sheared_fig = plot_side_by_side(img, sheared, 'Original', 'Sheared')
# Image rescaling with sklearn.transform.rescale
rescaled = transform.rescale(img, 1.1)rescaled_fig = plot_side_by_side(img, rescaled, 'Original', 'Rescaled')
plt.show()print('Original Shape: ',img.shape)
print('Rescaled Shape: ',rescaled.shape)Output:
Original Shape: (684, 1024, 3)
Rescaled Shape: (752, 1126, 3)
# flip up-down using np.flipud
up_down = np.flipud(img)fig_updown = plot_side_by_side(img, up_down, 'Original', 'Up-Down')
plt.show()
# flip up-down using np.flipud
left_right = np.fliplr(img)fig_lr = plot_side_by_side(img, left_right, 'Original', 'Up-Right')
plt.show()
什么是增色？
色彩增强是一种我们利用像素强度值的技术。
我们通过调整亮度、对比度、饱和度来再现不同的图像，我们还可以给图像添加随机噪声。
# Apply Random Noise to image using skimage.utils.random_noise
noised = random_noise(img, var=0.1**2)fig_noised = plot_side_by_side(img, noised, 'Original', 'Noised')
plt.show()
# Increasing the brighness of the Image
# Note: Here we add 100/255 since we scaled Intensity values of Image when loading (by dividing it 255)
highB = img + (100/255)fig_highB = plot_side_by_side(img, highB, 'Original', 'highB')
plt.show()
# Increasing the contrast of the Image
# Note: Here we add 100/255 since we scaled Intensity values of Image when loading (by dividing it 255)
highC = img * 1.5fig_highB = plot_side_by_side(img, highC, 'Original', 'highC')
plt.show()
你有没有注意到一件事，我们已经从一个图像创建了 11 个不同的图像。请注意，我们仍然可以使用参数并创建更多的参数。
当训练神经网络时，我们可以向图像加载器添加随机变换。还有其他高级技术，比如使用 GAN 进行数据扩充，我们可以在另一篇文章中看到。我希望你现在明白什么是图像增强。
使用深度学习的医疗报告生成
利用编解码模型和注意机制生成胸部 x 光医学报告。
内容:
- 介绍——理解问题
- 先决条件
- 数据
- 获取结构化数据
- 准备文本数据— 自然语言处理
- 获取图像特征 — 迁移学习
- 输入管道 — 数据生成器
- 编解码模型 — 训练、贪婪搜索、波束搜索、BLEU
- 注意机制——训练、贪婪搜索、光束搜索、BLEU
- 总结
- 未来工作
- 参考文献
1.介绍
图像字幕是一个具有挑战性的人工智能问题，它是指根据图像内容从图像中生成文本描述的过程。例如，请看下图:
由 Anthony Tran 在 Unsplash 上拍摄的照片|你会如何描述这张照片？
一个常见的答案是“一个弹吉他的女人”。我们人类可以看着一幅画，用适当的语言描述里面的任何东西。这很简单。让我给你看另一个:
嗯，你怎么描述这个？
对于我们这些“非放射科医生”来说，一个常见的答案是“胸透”。嗯，我们没有错，但是放射学家可能会有一些不同的解释。他们撰写文字报告，叙述成像研究中检查的身体各部位的发现，特别是各部位是否发现正常、异常或潜在异常。他们可以从一幅这样的图像中获得如此有价值的信息并做出医疗报告。
对于缺乏经验的放射科医生和病理学家，尤其是那些在医疗质量相对较低的农村地区工作的放射科医生和病理学家来说，撰写医学成像报告是一项艰巨的任务，或者另一方面，对于有经验的放射科医生和病理学家来说，撰写成像报告可能是乏味且耗时的。
因此，为了解决所有这些问题，如果一台计算机能够像放射科医生那样将如上图所示的胸部 x 光片作为输入，并将结果以文本形式输出，岂不是很棒？
图片作者|我们现在是在要求机器做医生吗？！！
但是，你真的能写出这样的计算机程序吗？如果答案是否定的，你就不会读到这个故事。
2.先决条件
这项工作假设一些深度学习熟悉的主题，如神经网络，CNN，RNNs，迁移学习，Python 编程和 Keras 库。下面提到的两个模型将用于解决我们的问题，稍后将在本博客中简要说明:
- 编码器-解码器模型
- 注意机制
对它们有足够的了解将有助于你更好地理解模型。
3.数据
您可以从以下链接获得解决此问题所需的数据:
图像数据集包含一个人的多张胸部 x 光照片。例如:x 射线的侧视图、多个正视图等。正如放射科医师使用所有这些图像来编写发现一样，模型也将一起使用所有这些图像来生成相应的发现。数据集中有 3955 个报告，每个报告都有一个或多个相关联的图像。
3.1.从 XML 文件中提取所需的数据
数据集中的报告是 XML 文件，每个文件对应一个人。与该人相关联的图像 id 和相应的发现包含在这些文件中。下面显示了一个示例:
作者图片|左图显示文件中的“发现”,而右图显示同一文件的给定图片 id
突出显示的信息是您需要从这些文件中提取的内容。这可以在 python 的 XML 库的帮助下完成。
注:调查结果也将被称为报告。它们将在博客的其余部分互换使用。
从 XML 文件中提取结果和报告
4.获取结构化数据
从 XML 文件中提取所需数据后，数据被转换成结构化格式，以便于理解和访问。如前所述，有多个图像与单个报告相关联。因此，我们的模型在生成报告时也需要看到这些图像。但是有些报告只有 1 个相关联的图像，而有些报告有 2 个，最多 4 个。
按作者分类的图片|显示每份报告相关图片数量的图表
所以问题来了，我们应该一次向模型中输入多少图像来生成一个报告？为了使模型输入一致，一次选择成对的图像，即两幅图像作为输入。如果一个报表只有一个图像，那么同一个图像将作为第二个输入被复制。
作者图片|结构化数据外观一览
现在我们有了一个合适的、可理解的结构化数据来处理。图像以其绝对地址的名称保存。这将有助于加载数据。
训练-测试 _ 拆分
在最后一步之后，我们将多次获得一个人的数据点。例如，如果一个人有四个与报告相关联的图像，并且由于我们正在拍摄成对的图像，将会生成该人的多个数据点。因此，有必要将该数据集分割成个体，而不是生成的数据点，以避免数据泄露问题。
在制作图像对之前，确保使用独特的“person_id”功能将数据分为 train、cv 和 test，然后训练模型。
5.准备文本数据
从 XML 文件中获得结果后，在将结果输入模型之前，应该对它们进行适当的清理和准备。下图显示了清理前的一些结果示例。
作者图片|清理前的示例调查结果
我们将通过以下方式清理文本:
- 将所有字符转换成小写。
- 执行基本的解收缩，即像不会、不能等单词将分别转换为不会、不能等。
- 删除文本中的标点符号。请注意，句号不会被删除，因为调查结果包含多个句子，所以我们需要模型通过识别句子以类似的方式生成报告。
- 删除文本中的所有数字。
- 删除所有长度小于或等于 2 的单词。例如，删除了“是”、“到”等。这些话没有提供太多信息。但是“不”这个词不会被删除，因为它增加了价值。在句子中加上“不”会完全改变它的意思。因此，在执行这些清洁步骤时，我们必须小心。你需要确定哪些词要保留，哪些词要避免。
- 还发现一些文本包含多个句号、空格或重复多次的“X”。这样的字符也被删除。
我们将开发的模型将生成一个报告，给出两个图像的组合，该报告将一次生成一个单词。将提供先前生成的单词序列作为输入。因此，我们将需要一个’首字来开始生成过程，并需要一个’*尾字’*来表示报告的结束。为此，我们将使用字符串’ startseq’ 和’ endseq’ 。这些字符串被添加到我们的发现。现在这样做很重要，因为当我们对文本进行编码时，我们需要这些字符串被正确编码。
编码文本的主要步骤是创建从单词到唯一整数值的一致映射，称为标记化。为了让我们的计算机理解任何文本，我们需要以我们的机器能够理解的方式来分解那个单词或句子。如果不执行标记化，我们就无法处理文本数据。标记化是一种将一段文本分成称为标记的更小单元的方法。记号可以是单词或字符，但在我们的例子中是单词。Keras 为此提供了一个内置的库。
from tensorflow.keras.preprocessing.text import Tokenizer
tokenizer = Tokenizer(filters='!"#$%&()*+,-/:;<=>?@[\\]^_`{|}~\t\n')
tokenizer.fit_on_texts(reports)
现在，我们已经对文本进行了适当的清理和标记，以备将来使用。在我的 GitHub 账户中可以找到所有这些的完整代码，在这个故事的结尾提供了它的链接。
6.获取图像特征
图像和部分报告是我们模型的输入。我们需要将每张图像转换成固定大小的向量，然后作为模型的输入。为此，我们将使用迁移学习。
“在迁移学习中，我们首先在一个基本数据集和任务上训练一个基本网络，然后我们重新调整已学习的特征，或者将它们转移到第二个目标网络，以便在目标数据集和任务上进行训练。如果特性是通用的，即既适合基本任务又适合目标任务，而不是特定于基本任务，那么这个过程将会起作用。”
VGG16、VGG19 或 InceptionV3 是迁移学习常用的 CNN。这些是在像 Imagenets 这样的数据集上训练的，这些数据集的图像与胸部 x 光照片完全不同。所以从逻辑上来说，他们似乎不是我们任务的好选择。那么，我们应该使用哪个网络来解决我们的问题呢？
如果你不熟悉，我给你介绍一下 CheXNet 。CheXNet 是一个在 ChestX-ray14 上训练的 121 层卷积神经网络，ChestX-ray 14 是目前最大的公开可用胸部 X 射线数据集，包含 14 种疾病的 100，000 多幅正面 X 射线图像。然而，我们在这里的目的不是对图像进行分类，而仅仅是获得每个图像的瓶颈特征。因此，不需要该网络的最后一个分类层。
你可以从 这里 下载 CheXNet 训练好的权重。
from tensorflow.keras.applications import densenetchex = densenet.DenseNet121(include_top=False, weights = None, input_shape=(224,224,3), pooling="avg")X = chex.output
X = Dense(14, activation="sigmoid", name="predictions")(X)model = Model(inputs=chex.input, outputs=X)model.load_weights('load_the_downloaded_weights.h5')chexnet = Model(inputs = model.input, outputs = model.layers[-2].output)
作者图片 CheXNet 的最后几层
如果你忘了，我们有 2 张图片作为模型的输入。下面是瓶颈特征是如何获得的:
每个图像的大小被调整为(224，224，3)并通过 CheXNet，获得 1024 长度的特征向量。稍后，这两个特征向量被连接以获得 2048 个特征向量。如果你注意到，我们已经添加了一个平均池层作为最后一层。这有一个具体原因。因为我们要连接两个图像，所以模型可能会知道一些连接的顺序。例如，image1 总是在 image2 之后，反之亦然，但这里不是这样。在连接它们时，我们不保持任何顺序。这个问题是通过创建位置差异的池来解决的。
作者图片|获取图片特征
这方面的代码如下:
这些特性以 pickle 格式存储在一个字典中，可以供将来使用。
7.输入管道
考虑这样一种情况，您有大量的数据，多到无法一次将所有数据都存储在 RAM 中。购买更多 RAM 显然不是每个人的选择。
解决方案可以是将我们的小批量数据动态地输入到模型中。这正是数据生成器要做的事情。它们可以动态生成模型输入，从而形成从存储器到 RAM 的管道，以便在需要时加载数据。这种管道的另一个优点是，在准备将数据输入模型时，可以很容易地对这些小批量数据应用预处理例程。
我们将使用TF . data来解决我们的问题。
我们首先将数据集分为两部分，一个训练数据集和一个验证数据集。在划分的时候，要确保你有足够的数据点用于训练，也有足够的数据点用于验证。我选择的比例允许我在训练集中有 2560 个数据点，在验证集中有 1147 个数据点。
现在是时候为数据集创建生成器了。
数据生成程序
这里我们创建了两个数据生成器，用于训练的 train_dataset 和用于验证的 cv_dataset。create_dataset 函数获取 id(这是字典的键，用于前面创建的瓶颈特性)和预处理报告，并创建生成器。生成器一次生成 BATCH_SIZE 数量的数据点。
如前所述，我们将要创建的模型将是一个逐字逐句的模型。该模型将图像特征和部分序列作为输入，以生成序列中的下一个单词。
例如:假设对应于“图像 _ 特征 _1”的报告是“开始序列心脏轮廓和纵隔尺寸在正常范围内结束序列”。
那么输入序列将被分成 11 个输入-输出对来训练模型:
作者图片|模型将图片和部分报告作为输入，并输出输出单词
注意我们是而不是通过生成器创建这些输入输出对。生成器一次只为我们提供 BATCH_SIZE 数量的图像特征及其相应的完整报告。输入-输出对是在训练过程中稍后生成的，稍后将对此进行解释。
8.编码器-解码器模型
照片由 Sergi Kabrera 在 Unsplash |让我们解码一些序列！！
序列到序列模型是一种深度学习模型，它采用一个项目序列(在我们的情况下，是图像的特征)并输出另一个项目序列(报告)。
编码器处理输入序列中的每一项，它将捕获的信息编译成一个称为上下文的向量。处理完整个输入序列后，编码器将上下文发送给解码器，解码器开始逐项产生输出序列。
在我们的例子中，编码器是一个 CNN，它通过获取我们的图像特征来产生一个上下文向量。解码器是一个递归神经网络。
Marc Tanti 在他的论文 中介绍了许多架构，如 init-inject、par-inject、pre-inject 和 merge，指定了在创建图像标题生成器时应该在哪里注入图像。对于我们的问题，我们将使用他的论文中指定的合并架构。
作者图片|建筑
在“合并”架构中，RNN 在任何点都不暴露于图像向量(或从图像向量导出的向量)。相反，在前缀被 RNN 完整编码后，图像被引入语言模型。这是一个后期绑定架构，它不会在每个时间步修改图像表示。
他的论文中的一些重要结论被用于我们实现的架构中。它们是:
- RNN 输出需要与辍学正规化。
- 图像向量不应该具有非线性激活函数，也不应该用丢失来正则化。
- 图像输入向量在被馈送到神经网络之前必须被归一化，这是在从 CheXNet 获得特征时完成的。
嵌入层:
单词嵌入是一类使用密集向量表示来表示单词和文档的方法。Keras 提供了一个 嵌入 层，可用于文本数据上的神经网络。它也可以用一个从别处学来的单词嵌入。在自然语言处理领域中，学习、保存和自由使用单词嵌入是很常见的。
在我们的模型中，利用嵌入层，每个单词已经使用预先训练的 手套 模型被映射成 300 维表示。使用预训练嵌入时，请记住，应通过设置参数“trainable = False”来冻结层的权重，以便权重在训练时不会更新。
型号代码:
型号汇总:
模型参数汇总
8.1 培训
损失函数:
为此问题创建了掩蔽损失函数。例如:
如果我们有一个令牌序列- [3]、[10]、[7]、[0]、[0]、[0]、[0]、[0]
我们在这个序列中只有 3 个单词，零对应于实际上不是报告一部分的填充。但是模型会认为零也是序列的一部分，并开始学习它们。当模型开始正确预测零点时，损失将会减少，因为对于模型来说，它正在正确地学习。但对我们来说，只有当模型正确预测实际单词(非零)时，损失才会减少。
因此，我们应该屏蔽序列中的零，这样模型就不会关注它们，只学习报告中需要的单词。
隐蔽损失
输出字是一个热编码，因此分类交叉熵将是我们的损失函数。
optimizer = tf.keras.optimizers.Adam(0.001)
encoder_decoder.compile(optimizer, loss = maskedLoss)
还记得我们的数据生成器吗？现在是时候使用它们了。
这里，生成器提供的批次不是我们用于训练的实际数据批次。请记住，它们不是逐字的输入输出对。他们只是返回图像及其相应的整个报告。
我们将从生成器中检索每一批数据，并从该批数据中手动创建输入-输出序列，也就是说，我们将为训练创建我们自己的定制数据批。所以在这里，BATCH_SIZE 逻辑上是模型在单个批次中看到的图像对的数量。我们可以根据我们的系统能力改变它。我发现这种方法比其他博客中提到的传统定制生成器要快得多。
由于我们正在创建自己的训练数据批次，因此我们将使用“train_on_batch”来训练我们的模型。
培训步骤
代码中提到的 convert 函数将来自生成器的数据转换为一个字一个字的输入输出对表示。然后，部分报告被填充到报告的最大长度。
转换功能:
Adam optimizer 的学习率为 0.001。该模型被训练了 40 个时期，但是在第 35 个时期获得了最好的结果。由于随机性，您得到的结果可能会有所不同。
图片由作者| Tensorboard 提供，显示了模型的损耗图
**注:**以上培训已在 Tensorflow 2.1 中实现。
8.2 推理
既然我们已经训练了我们的模型，是时候准备我们的模型来预测报告了。
为此，我们必须对我们的模型进行一些调整。这将为我们节省一些测试时间。
首先，我们将编码器和解码器部分从模型中分离出来。编码器预测的特征将与部分报告一起用作解码器的输入。
推理设置
通过这样做，我们将只需要预测编码器特征一次，同时我们将它用于我们的贪婪搜索和波束搜索算法。
我们将实现这两种生成文本的算法，并看看哪一种效果最好。
8.3 贪婪搜索算法
贪婪搜索是一种算法范式，它一点一点地构建解决方案，总是选择下一个提供最明显好处的方案。
贪婪搜索步骤 :
- 编码器输出我们图像的特征。编码器的工作到此结束。一旦我们有了我们需要的特性，我们就不需要关心编码器了。
- 这个特征向量连同开始标记-‘start seq’(我们的初始输入序列)作为第一个输入提供给解码器。
- 解码器预测整个词汇的概率分布，具有最大概率的单词将被选为下一个单词。
- 这个预测的字连同先前的输入序列将是我们对解码器的下一个输入序列。
- 继续步骤 3-4，直到我们遇到结束标记，即‘end seq’。
让我们检查一下在使用 greedysearch 生成报告之后，我们的模型表现如何。
BLEU 评分—贪婪搜索:
双语评估替角评分，简称 BLEU，是一个将生成的句子评估为参考句子的度量。
完全匹配的得分为 1.0，而完全不匹配的得分为 0.0。该方法通过计算候选文本中的 n 元语法与参考文本中的 n 元语法的匹配来工作，其中 1 元语法或单元语法将是每个单词，双元语法比较将是每个单词对。
通过贪婪搜索生成报告后的 BLEU 分数
满分在实践中是不可能的，因为译文必须与参考文献完全匹配。这甚至是人类翻译所做不到的。用于计算 BLEU 分数的参考文献的数量和质量意味着跨数据集比较分数可能会很麻烦。
想了解更多关于 BLEU 的信息，点击 这里 。
8.4 波束搜索
波束搜索是一种算法，它扩展了贪婪搜索并返回最可能的输出序列列表。每个序列都有一个与之相关的分数。得分最高的序列作为最终结果。
在构建序列时，波束搜索不是贪婪地选择最有可能的下一步，而是扩展所有可能的下一步，并保持最有可能的 k ，其中 k(称为波束宽度)是用户指定的参数，控制波束的数量或概率序列中的并行搜索。
波束宽度为 1 的波束搜索只不过是你的贪婪搜索。常见的波束宽度值为 5-10，但甚至高达 1000 或 2000 以上的值也用于研究，以从模型中挤出最佳性能。点击 此处 阅读更多关于光束搜索的内容。
但是请记住，随着波束宽度的增加，时间复杂度也会增加。因此，这些比贪婪搜索慢得多。
波束搜索
波束搜索并不总是保证更好的结果，但在大多数情况下，它给你一个。
您可以使用上面给出的函数检查光束搜索的 BLEU 分数。但是请记住，评估它们需要一段时间(几个小时)。
8.5 示例
现在让我们来看一些胸部 x 光的预测报告:
训练图像对 1
图像对 1 的原始报告:心脏正常大小。纵隔不明显。肺部没问题。
预测的报告为图像对 1:心脏正常大小。纵隔不明显。肺清。”
对于这个示例，模型预测的是完全相同的报告。
训练图像对 2
图像对 2 的原始报告:“心脏大小和肺血管分布在正常范围内。未发现局部浸润性胸腔积液。
图像对 2 的预测报告:“心脏大小和肺部血管分布在正常范围内。肺部是自由的局灶性空域疾病。没有胸腔积液。”
虽然不完全相同，但预测结果与原始报告几乎相似。
训练图像对 3
图像对 3 的原始报告:“肺部过度膨胀但清晰。没有局灶性浸润渗出。心脏和纵隔轮廓在正常范围内。发现钙化的纵隔。
图像对 3 的预测报告:“心脏大小正常。纵隔轮廓在正常范围内。肺部没有任何病灶浸润。没有结节肿块。没有可见的气胸。没有明显的胸腔积液。这是非常正常的。横膈膜下无可见的腹腔内自由空气
你并不期望这个模型完美无缺，对吧？没有一个模型是完美的，这个也不是。尽管从图像对 3 中可以正确识别出一些细节，但是产生了许多额外的细节，这些细节可能是正确的，也可能是不正确的。
我们创建的模型绝不是完美的，但它确实为我们的图像生成了不错的报告。
现在让我们来看一个高级模型，看看它是否提高了当前的性能！！
9。注意机制
保罗·斯科鲁普斯卡斯在 Unsplash 拍摄的照片|现在让我们来关注一下吧！！
注意机制是对编解码模型的一种改进。上下文向量被证明是这类模型的瓶颈。这对他们处理长句子来说是一个挑战。在 Bahdanau 等人，2014 和 Luong 等人， 2015 中提出了解决方案。这些论文介绍并完善了一种叫做“注意力”的技术，这种技术极大地提高了机器翻译系统的质量。注意力允许模型根据需要关注输入序列的相关部分。后来这个想法被实现为图像字幕在论文中， 展示，出席，讲述:视觉注意的神经图像字幕生成。
那么，我们如何为图像的注意力机制建模呢？
马库斯·温克勒在 Unsplash 上拍摄的照片
在文本的情况下，我们对输入序列的每个位置都有一个表示。但是对于图像，我们通常使用来自网络的完全连接层之一的表示，但是该表示不包含任何位置信息(想想看，它们是完全连接的)。我们需要查看图像的特定部分(位置)来描述那里有什么。例如，要从 x 光片上描述一个人心脏的大小，我们只需要看他的心脏区域，而不是他的手臂或任何其他部位。那么注意力机制的输入应该是什么呢？
好吧，我们使用具有空间信息的卷积层之一(迁移学习)的输出，而不是完全连接的表示。
图片作者| Conv 图层包含空间信息
例如，假设最后一个卷积层的输出是一个(7141024)大小的特征图。这里，“714”是对应于图像中某些部分的实际位置，1024 是通道。我们不是关注通道，而是关注图像的位置。因此，这里我们有 714 = 98 个这样的位置。我们可以把它想象成 98 个位置，每个位置都有一个 1024 维的表示。
作者图片|关注组件
现在我们有 98 个时间步，每个时间步有 1024 个维度表示。我们现在需要决定模型应该如何关注这 98 个时间步长或位置。一个简单的方法是给每个位置分配一些权重，得到所有这 98 个位置的加权和。如果特定的时间步长在预测输出时非常重要，则该时间步长将具有较高的权重。让这些重量被表示为阿尔法。
现在我们知道，阿尔法决定了一个特定位置的重要性。阿尔法值越高，重要性越高。但是我们如何找到α的值呢？没有人会给我们这些值，模型本身应该从数据中学习这些值。为此，我们定义了一个函数:
这个量捕获了第 j 个输入对于解码第 t 个输出的重要性。h_j 是第 j 个位置表示，s_t-1 是解码器直到该点的状态。我们需要这两个提到的量来确定 e_jt。ATT 只是一个函数，我们将在后面定义。
在所有输入中，现在我们希望这个量(e_jt)的总和为 1。这就像一个概率分布，其中输入的重要性是多少。通过取 softmax 将 e_jt 转换成概率分布。
使用 softmax 将 e_jt 转换为概率分布
现在我们有阿尔法战士了。！阿尔法是我们 e _ jts 的软 max。α_ JT 表示聚焦于第 j 个输入以产生第 t 个输出的概率。
是时候定义函数 f_ATT 了。许多其他可能的选择之一如下:
v、U 和 W 是将在训练期间学习的参数，以确定 e_jt 的值。
我们有阿尔法，我们有输入，现在我们只需要得到加权和，以产生新的上下文向量，它将被馈送到解码器。实际上，这些模型比编码器解码器模型工作得更好。
模型实现:
像上面提到的编码器-解码器模型一样，这个模型也将由两部分组成，一个编码器和一个解码器，但这次解码器将有一个额外的注意力组件，即一步注意力解码器。为了更好地理解，现在让我们用代码编写上面解释的注意步骤:
***The onestep attention layer will consist of the attention part which
will be calculated for each time step of the decoder.******# Calculating e_jts***
score = self.Vattn(tf.nn.tanh(self.Uattn(features) + self.Wattn(hidden_with_time_axis)))***# Converting our scores to probability distributions using softmax***
attention_weights = tf.nn.softmax(score, axis=1)***# Calculating the context vector(weighted sum)***
context_vector = attention_weights * features
我们将使用 keras 的子类 API，这给了我们更多的可定制性和对我们架构的控制。你可以从文档本身 中阅读更多关于子类 API 这里 。
我们将实现教师强制训练我们的模型，这一次我们不必将我们的文本转换成逐字逐句的模型。但是对于图像特征，我们将从 CheXNet 网络的最后一个 conv 层获取特征。
作者图片|提取图像特征以引起注意
组合我们的两个图像后的最终输出形状将是(无，7，14，1024)。因此，整形后编码器的输入将是(None，98，1024)。为什么要整形？嗯，这已经在注意介绍中解释过了，如果你有任何疑问，请确保你再次阅读解释。
型号:
- 编码器
编码器层只是对我们的图像执行一些操作，并输出将作为输入提供给解码器的特征。
2.解码器
解码器为每个解码器时间步长调用单步关注层，并计算分数和关注权重。每个时间步的所有输出都存储在“所有输出”变量中。每个解码器步骤的输出是序列中的下一个字。“全力输出”将是我们的最终输出。
3.单步解码器
4.创建模型
**model1 = Attention_Model(vocab_size, units, max_capt_len, att_units, BATCH_SIZE)**
9.1 培训
如前所述，我们将使用教师强制来训练我们的模型。因此，我们将不需要我们用于编码器解码器模型的额外功能。我们可以直接使用来自生成器的自定义报告。
“train_dataset”是我们的生成器，它为我们提供图像特征和相应的 155 维填充报告。
**# teacher forcing
res = model1.train_on_batch([img, rep[:,:-1]], rep[:,1:])**
可以看到，解码器的输入比输出落后一个时间步长。我们不希望模型预测的输入与输出相同。我们希望它能预测序列中的下一个单词。
为了引起注意，Adam optimizer 以 0.001 的学习率使用。该模型仅用 10 个时期的训练就给出了不错的结果。由于随机性，您得到的结果可能会有所不同。稀疏分类交叉熵是在这种情况下使用的损失函数，因为我们没有将输出转换为 OHE 向量。
图片由作者| Tensorboard 提供，显示了损失图
所有东西的代码都可以从我的 GitHub 上获取。它的链接已经在这个博客的末尾提供了。
9.2 推理
9.3 贪婪搜索
现在我们已经建立了模型，让我们检查一下获得的 BLEU 分数是否确实比以前的模型有所改进:
贪婪搜索后注意模型的 BLEU 分数
我们可以看到，它比带有贪婪搜索的编码器-解码器模型具有更好的性能。因此，这肯定是对前一个的改进。
9.4 波束搜索
现在让我们看看光束搜索的一些分数:
波束搜索后的 BLEU 分数
BLEU 分数低于 greedy 分数，但相差不远。但是值得注意的是，随着波束宽度的增加，分数实际上也在增加。因此，可能存在一些 beam_width 值，分数实际上与贪婪值交叉。
9.5 示例
以下是模型使用贪婪搜索生成的一些报告:
训练图像对 1
图像对 1 的原始报告:“心脏大小和肺血管分布在正常范围内。未发现局部浸润性胸腔积液。
图像对 1 的预测报告:“心脏大小和纵隔轮廓在正常范围内。肺部没问题。没有胸腔积液。没有急性骨质发现。
这些预测几乎与原始报告相似。
训练图像对 2
图像对 2 的原始报告:“心脏大小和肺部血管分布在正常范围内。肺部是自由的局灶性空域疾病。没有胸腔积液。”
图像对 2 的预测报告:“心脏大小和肺部血管分布在正常范围内。肺部是自由的局灶性空域疾病。没有胸腔积液。
预测的报告一模一样！！
训练图像对 3
图像对 3 的原始报告:心脏正常大小。纵隔不明显。肺部没问题。
预测的图像对 3 的报告:心脏正常大小。纵隔不明显。肺部没问题。
在这个例子中，模型也做得非常好。
训练图像对 4
图像对 4 的原始报告:“双肺清晰。具体来说，没有证据表明局灶性实变气胸胸腔积液。心脏纵隔轮廓不起眼。可视化骨骼结构胸部无急性异常。”
图像对 4 的预测报告:“心脏大小和纵隔轮廓在正常范围内。肺部没问题。没有胸腔积液。”
你可以看到这个预测并没有真正的说服力。
" But本例中的波束搜索预测了完全相同的报告，尽管它对整个测试数据组合产生了较低的 BLEU 分数！！!"
那么，选哪个呢？好吧，这取决于我们。只需选择一个通用的方法。
在这里，即使我们的注意力模型也不能准确预测每一幅图像。正如我们从示例中看到的，这一对没有侧视图像，或者如果我们查看原始报告中的单词，会发现有些复杂的单词通过一些 EDA 并不经常出现。这些可能是我们在某些情况下没有一个好的预测的一些原因。请记住，我们只是在 2560 个数据点上训练这个模型。为了了解更复杂的特征，模型将需要更多的数据。
10.摘要
既然我们已经结束了这个项目，让我们总结一下我们所做的一切:
- 我们刚刚看到了图像字幕在医学领域的应用。我们理解这个问题和对这种应用的需要。
- 我们看到了如何为输入管道使用数据生成器。
- 创建了一个编码器-解码器模型，给了我们不错的结果。
- 通过建立注意力模型改进了基本结果。
11.未来的工作
- 正如我们提到的，我们没有一个大的数据集来完成这项任务。更大的数据集将产生更好的结果。
- 没有对任何模型进行主要的超参数调整。因此，更好的超参数调整可能会产生更好的结果。
- 利用更先进的技术，如变压器或 BERT，可能会产生更好的结果。
12.参考
- https://www.appliedaicourse.com/
- https://arxiv.org/abs/1502.03044
- 【https://www.aclweb.org/anthology/P18-1240/
- https://arxiv.org/abs/1703.09137
- https://arxiv.org/abs/1409.0473
- https://machine learning mastery . com/develop-a-deep-learning-caption-generation-model-in-python/
这个项目的完整代码可以从我的GitHub中访问。
也可以在我的LinkedIn上和我联系。
希望你喜欢这个项目。感谢阅读:)
用 Tensorflow 和 FastAPI 构建影像分类 API
从零开始学习用 Tensorflow 和 FastAPI 构建图像分类 API。
资料来源:aniketmaurya
FastAPI 是一个高性能的异步框架，用于在 Python 中构建 API。
这个博客也有视频教程
这个博客的源代码是可用的aniketmaurya/tensor flow-fastapi-starter-pack
让我们从一个简单的 hello-world 示例开始
首先，我们导入FastAPI类并创建一个对象app。这个类有有用的参数，比如我们可以为 Swagger UI 传递标题和描述。
from fastapi import FastAPI
app **=** FastAPI**(**title**=**'Hello world'**)**
我们定义一个函数并用@app.get来修饰它。这意味着我们的 API /index支持 GET 方法。这里定义的函数是异步的，FastAPI 通过为普通的 def 函数创建一个线程池来自动处理异步和非异步方法，并为异步函数使用一个异步事件循环。
**@**app**.**get**(**'/index'**)**
**async** **def** **hello_world():**
**return** "hello world"
图像识别 API
我们将创建一个 API 来对图像进行分类，我们将其命名为predict/image。我们将使用 Tensorflow 创建图像分类模型。
tensor flow图像分类教程
我们创建一个函数load_model，它将返回一个带有预训练权重的 MobileNet CNN 模型，也就是说，它已经被训练来分类 1000 个独特的图像类别。
import tensorflow **as** tf**def** **load_model():**
model **=** tf**.**keras**.**applications**.**MobileNetV2**(**weights**=**"imagenet"**)**
**print(**"Model loaded"**)**
**return** modelmodel **=** load_model**()**
我们定义了一个predict函数，它将接受一幅图像并返回预测结果。我们将图像的大小调整为 224x224，并将像素值归一化为[-1，1]。
from tensorflow.keras.applications.imagenet_utils import decode_predictions
decode_predictions用于解码预测对象的类名。这里我们将返回前 2 个可能的类。
**def** **predict(**image**:** Image**.**Image**):** image **=** np**.**asarray**(**image**.**resize**((**224**,** 224**)))[...,** **:**3**]**
image **=** np**.**expand_dims**(**image**,** 0**)**
image **=** image **/** 127.5 **-** 1.0 result **=** decode_predictions**(**model**.**predict**(**image**),** 2**)[**0**]** response **=** **[]**
**for** i**,** res **in** *enumerate***(**result**):**
resp **=** **{}**
resp**[**"class"**]** **=** res**[**1**]**
resp**[**"confidence"**]** **=** f"{res[2]*100:0.2f} %" response**.**append**(**resp**)** **return** response
现在我们将创建一个支持文件上传的 API /predict/image。我们将过滤文件扩展名，仅支持 jpg、jpeg 和 png 格式的图像。
我们将使用 Pillow 来加载上传的图像。
**def** **read_imagefile(***file***)** **->** Image**.**Image**:**
image **=** Image**.***open***(**BytesIO**(***file***))**
**return** image**@**app**.**post**(**"/predict/image"**)**
**async** **def** **predict_api(***file***:** UploadFile **=** File**(...)):**
extension **=** *file***.**filename**.**split**(**"."**)[-**1**]** **in** **(**"jpg"**,** "jpeg"**,** "png"**)**
**if** **not** extension**:**
**return** "Image must be jpg or png format!"
image **=** read_imagefile**(await** *file***.**read**())**
prediction **=** predict**(**image**)** **return** prediction
最终代码
import uvicorn
from fastapi import FastAPI**,** File**,** UploadFilefrom application.components import predict**,** read_imagefileapp **=** FastAPI**()****@**app**.**post**(**"/predict/image"**)**
**async** **def** **predict_api(***file***:** UploadFile **=** File**(...)):**
extension **=** *file***.**filename**.**split**(**"."**)[-**1**]** **in** **(**"jpg"**,** "jpeg"**,** "png"**)**
**if** **not** extension**:**
**return** "Image must be jpg or png format!"
image **=** read_imagefile**(await** *file***.**read**())**
prediction **=** predict**(**image**)** **return** prediction **@**app**.**post**(**"/api/covid-symptom-check"**)**
**def** **check_risk(**symptom**:** Symptom**):**
**return** symptom_check**.**get_risk_level**(**symptom**)** **if** __name__ **==** "__main__"**:**
uvicorn**.**run**(**app**,** debug**=***True***)**
FastAPI 文档是了解框架核心概念的最佳地方。
希望你喜欢这篇文章。
欢迎在评论中提出你的问题，或者亲自联系我
👉推特:https://twitter.com/aniketmaurya
👉领英:【https://linkedin.com/in/aniketmaurya
2020 年影像分类基线模型
如何使用 fastai 建立强基线模型进行图像分类？
TL；DR —要使用的代码片段
有一些基本的想法，这里只是一段代码来构建您的基线模型？用这个:
from fastai.vision import ***# Defining the data and the model** path = untar_data(URLs.CIFAR)
tfms = get_transforms(do_flip=False)
data = ImageDataBunch.from_folder(path, valid='test', ds_tfms=tfms, size=128)
learn = cnn_learner(data, models.resnet50, metrics=accuracy)**# Estimate learning rate**
learn.lr_find()
learn.recorder.plot()**# Training** learn.fit_one_cycle(3, max_lr=1e-3)**# Finetuning** learn.unfreeze()
learn.fit_one_cycle(3, max_lr=slice(1e-6, 1e-4))**# Test Time Augmentation** preds,targs = learn.TTA()
accuracy(preds, targs).item()
介绍
自 20 世纪 50 年代以来，计算机视觉就一直存在，但直到最近十年，该领域才完全改变了自己(事实上，特殊的时刻发生在 2012 年，当时 AlexNet 赢得了 ImageNet 挑战赛)。
在过去的几年中，出现了许多强大的框架。我们将使用 fastai，因为在编写本文时，它提供了最简单的 API 和最强的默认设置。这是 PyTorch 的高级包装。我们的目标是到 2020 年建立一个通用的图像分类基准。
图片来自 Pixabay 的Gerhard ge linger
图像分类任务
让我们使用流行的 CIFAR-10 数据集，它包含 10 个不同类别的 60，000 幅 32x32 彩色图像。它分为 50，000 个训练样本和 10，000 个测试样本。fastai 库中已经提供了 CIFAR 数据集作为样本数据集。
from fastai.vision import *
path = untar_data(URLs.CIFAR)
让我们从直接来自文档的一个最小的例子开始，并随着我们的进展修改它
tfms = get_transforms(do_flip=False)
data = ImageDataBunch.from_folder(path, valid='test', ds_tfms=tfms)
learn = cnn_learner(data, models.resnet50, metrics=accuracy)
learn.fit(3)
让我们来分解一下这里发生的 3 件最重要的事情:
- 数据扩充:在训练用于图像分类的大型神经网络时，通常使用诸如裁剪、填充和水平翻转等技术。这有助于避免过度拟合和更好地概括，而不必实际收集任何新数据。最简单的方法是使用 fastai 中的
get_transforms,它允许你从一组标准的变换中进行选择，其中默认的是为照片设计的。 - 将数据集分割成训练验证测试集:我们应该总是将数据集分割成训练验证测试集。如果我们使用验证集来调优任何超参数(比如模型架构、学习率等)，那么如果您想要报告最终度量(比如准确性)，也需要有一个测试集。在这个例子中，我们没有使用验证集来调优任何超参数，所以我们没有使用测试集。实际上，你可以用 50000 个例子来训练，5000 个例子来验证，5000 个例子来测试。fastai 中的 ImageDatabunch API 提供了一种简单的方法来加载你的数据，并在数据已经以一些标准格式存储时将其拆分。如果你想对如何选择、分割和标记数据进行更多的自定义控制，你也可以使用数据块 API 。
- 迁移学习:迁移学习包括采用在一项任务中训练过的模型，然后将其用于另一项任务。这里我们使用的是在 ImageNet 上训练的名为 ResNet50 的架构，它包含大约 1400 万张图像。一旦有了基线，您还可以尝试其他架构，包括更深的 ResNet 模型。迁移学习背后的想法是，网络的大多数早期层将识别对任何图像的分类都有用的一般特征，如边缘。当我们为新任务进行训练时，我们将保持所有卷积层(称为模型的主体或主干)的权重在 ImageNet 上预先训练，但将定义一个随机初始化的新头部。该头部适应于新分类任务所需的类别数量。通过默认调用
cnn_learner上的fit，我们保持身体冻结，只训练头部。
3 个时代的训练
经过 3 个时期的训练，我们在这一点上获得了大约 70%的准确率。
修改输入图像尺寸
ResNet 最初是在 224x224 图像上训练的，我们的数据集有 32x32 个图像。如果您使用的输入图像与原始大小相差太大，那么它对于模型来说不是最佳的。让我们来看看将这些图像的大小调整为 128x128 后，对精确度的影响。ImageDataBunch API 允许您传入一个大小。
tfms = get_transforms(do_flip=False)
data = ImageDataBunch.from_folder(path, valid='test', ds_tfms=tfms, size=128)
learn = cnn_learner(data, models.resnet50, metrics=accuracy)
learn.fit(3)
调整输入大小后训练 3 个时期
准确率高达 94%。在这项任务中，我们已经达到了人类的水平。我们也可以将尺寸调整到 224x224，但这将增加训练时间，而且由于这些图像分辨率很低，当我们放大很多时，可能会留下伪像。一旦你有了一个基线，你可以根据需要在以后进行试验。
修改学习率
学习率通常是训练神经网络时要调整的最重要的超参数。它影响网络的权重随每个训练批次而修改的速率。非常小的学习率会导致训练缓慢。另一方面，非常大的学习率会导致损失函数在最小值附近波动，甚至发散。传统上，它是一个超参数，使用网格搜索和可选公式进行调整和设置，使用特定策略(如基于时间的衰减、阶跃衰减等)降低学习速率。
莱斯利·史密斯在 2015 年提出了一种设定学习率的新方法，称为循环学习率 (CLR)。这种方法不是单调地降低学习率，而是让学习率在合理的边界值之间循环变化。这消除了寻找学习率的最佳值的需要。Fastai 有一个单周期 CLR 策略的实现，其中学习速率从一个低值开始，增加到一个非常大的值，然后降低到一个比其初始值低得多的值。
Fastai 还提供了一种简便的方法来估计单周期策略中使用的最大学习速率。为此，它开始训练模型，同时将学习率从非常低的值增加到非常大的值。最初，损失会下降，但随着学习率的不断上升，损失开始增加。当损失在最小值左右时，学习率已经过高。经验法则是将最大学习率设置为比最小值小一个数量级。
learn = cnn_learner(data, models.resnet50, metrics=accuracy)
learn.lr_find()
learn.recorder.plot()
使用 lr_find 估计学习率
在这里，您可以尝试将学习率设置在 1e-03 和 1-e02 之间。目前，我们只使用 1e-03。
learn = cnn_learner(data, models.resnet50, metrics=accuracy)
learn.fit_one_cycle(3, max_lr=1e-3)
使用单周期策略训练 3 个时期
在 3 个时期内，我们在验证集上达到了大约 95%的准确率。
微调
我们之前只训练了新的随机初始化的头部，保持身体的重量不变。我们现在可以解冻身体，训练整个网络。在此之前，让我们使用lr_find并估计要使用的新学习率。
learn.lr_find()
learn.recorder.plot()
使用 lr_find 再次估计学习率
训练曲线似乎已经从之前的曲线移动了一个数量级，并且看起来 1e-4 似乎是一个合理的训练速率。与以前不同，我们可能不想对身体的所有层使用相同的最大学习速率。我们可能希望使用区别学习率，其中早期层获得小得多的学习率。这个想法是，早期的层将学习更多的基本特征，如边缘(这对您的新任务也很有用)，而后期的层将学习更复杂的特征(如可能识别头部，这对您的新任务不一定有用)。Fastai 允许您发送一个切片，其中第一个值将用作第一层的学习率，第二个值将是最后一层的学习率，中间各层的值介于两者之间。
learn.unfreeze()
learn.fit_one_cycle(3, max_lr=slice(1e-6, 1e-4))
微调 3 个以上的时代
我们可以看到精度还在提高。
测试时间增加
您可以为通用基准测试做的最后一件事是测试时间增加(TTA)。TTA 是在测试/验证集上完成的，以提高预测质量-它包括首先使用数据增强创建每个图像的多个版本，然后我们通过我们训练的模型获得多个预测，最后我们取这些预测的平均值以获得最终预测。TTA 经常给我们一个更好的表现，而不需要任何额外的训练，但它对最终的预测时间有影响。
preds,targs = learn.TTA()
accuracy(preds, targs).item()
TTA 后的精确度
我们达到了超过 96%的准确率。太好了。另一个可以提高我们准确度的简单方法就是针对更多的时期进行训练和微调。但是我们暂时就此打住。
我们的立场是什么？
查看 CIFAR-10 上实现的最先进的基准。96%以上只是最近几年才达到的。那里的大多数模型训练的时间要长得多，使用的资源比 collab 笔记本更多，参数也更多——因此我们可以确信，我们对这种通用图像分类的 96%是非常好的。
结论
在一个新的机器学习项目开始时，你可以做的最有用的事情之一就是建立一个基线。对于图像分类，fastai 帮助您快速创建一个强基线，几乎不需要调整超参数。
你可以在这个 T4 笔记本中找到这篇文章的完整代码。请随意使用它并在您的项目中使用它。如果您有任何想法或问题，我很乐意与您讨论。
基于 CNN 的图像分类
使用 CNN 和代码对漫威字符进行分类
数据集中使用的漫威人物(来源: Instagram ，作者创建的拼贴)
我们怎么看？
在深入探讨背后的技术细节之前，让我们先来谈谈生物。他们是如何识别和感知图像的。我们每秒钟看到多幅图像，我们能够处理它，我们能够在未来识别它。所有这一切都归功于人脑**，世界上最强大的机器。让我们来谈谈我们是如何感知图像的，以便更好地理解 CNN 。看看下面的图片**
来源: Pinterest
我们可以看到两幅图像
- 右脸的男人
- 一个面向我们的男人
基于我们对图像的聚焦我们看到不同的视图，我们的大脑太强大了，它自动识别模式并帮助我们识别物体。这是 CNN 背后的基本原理，它搜索模式并区分图像。
狮子狗(图片来源:Fredrik hlander 在 Unsplash 拍摄)狮子(图片来源:Arleen wiese 在 Unsplash 拍摄)
考虑上面的图像，我们能够通过观察一些模式来识别 A 和 B。我们能够做到这一点是因为我们在过去看到过这些图像，我们的大脑观察到了其中的一些模式，这有助于我们区分它们。如果我们问一个孩子或一个一生中从未见过狮子或狗的人。他能对上述图像进行分类吗？肯定没有。
上图不仅适用于 CNN 也普遍适用于机器学习。让我们关注 CNN，因为这篇文章就是关于它的。我们向 CNN 发送一堆图像进行训练， CNN 在其中寻找与人类相似的模式，因此当我们要求 CNN 识别这些图像时，它将能够识别其中的模式。因此，如果我们将图像发送给未经训练的 CNN，它也会像人类一样失败。
CNN 步行道:
如何让机器读取图像？是困扰我们大多数人的常见问题，这是图像处理的第一步。
计算机视觉如何工作。在最左边我们有一个图像，像素值是根据亮度分配的
机器通过**像素值读取图像。**每幅图像都是像素值的组合，改变像素值会改变图像。这些像素值在输入 CNN 之前必须经过处理。像素值的数量取决于图像的大小，因此如果图像的大小太大，又会出现问题。一个完全连接的网络会将二维像素阵列展平为一维阵列，并根据像素值识别图像。
卷积层:
卷积层与汇集来拯救我们。它从图像中提取某些特征并缩小图像的尺寸。
一个过滤器在没有填充的二维图像上的卷积(来源:Pinterest
我们把 66 矩阵的图像转换成 33 矩阵。我们的权重初始化为 33 矩阵。加权矩阵穿过我们图像，并产生 33 矩阵的卷积输出。权重覆盖我们的图像中的所有像素值至少一次，并且执行逐元素乘法。
当您查看元素乘法以获得卷积层时，另一个问题出现了，边缘处的像素值仅被覆盖一次。借助衬垫可以解决这个问题。
当我们应用填充时，图像的大小保持不变。类似于【MLP】学习权重，即最小化损失函数或帮助模型正确预测图像。我们不会在实际应用中只使用一个滤镜，滤镜数量的使用会影响旋绕层的深度。卷积输出的深度取决于我们使用的滤波器的数量。
彩色图像的卷积层:
每幅彩色图像都可以用红色、蓝色和绿色的组合来表示。我们把它分成三层，并遵循同样的程序应用于灰度图像的情况。****
汇集层:
池化的唯一目的是减小图像的大小。大多数情况下首选最大池。池在每个层上独立运行，因此卷积层的深度保持不变。您可以观察到我们一次应用两个步长**。尺寸随着步数的增加而减小。**
Gif 由谷歌开发者
输出层:
我们的最终目标是预测一幅图像是否属于某个特定的类别。但是卷积层给了我们一个 3 D 激活图，使用卷积层不容易获得输出类，所以我们需要将其展平以产生所需数量的输出类。进行前向和反向传播以减少损耗。
来源:研究门
正如我们可以观察到的，我们在开始时应用卷积以从中提取有用的特征，随后是最大汇集以减小图像的大小，随后是展平**，最后输出预测图像属于特定类别的概率。**
使用 CNN 对图像进行分类:(代码)
五个漫威角色被选中，分别是黑寡妇、钢铁侠、雷神、美国队长和绿巨人。按照 70: 30 的比例划分训练和测试装置，并观察性能。
钢铁侠(来源: Pinterest
from zipfile import ZipFile
filename= "marvel.zip"
with ZipFile(filename,'r')as zip:
zip.extractall()
您可以忽略前三个块，因为它处理图像加载和导入依赖项。由 5 个漫威角色组成的 zip 文件在上面的代码块中被加载和提取。
#Importing
import os
import numpy as np
import glob
import shutil
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D
from tensorflow.keras.preprocessing.image import ImageDataGenerator
base_dir = os.path.join(os.path.dirname(filename), 'marvel')
所有必需的依赖项都会被导入，如果在导入这些依赖项时出现错误，您必须安装它。使用 pip 安装(Jupyter 笔记本)
# Accessing the images and setting 0.7 of images for training and the rest for testingclasses=['Black Widow','Captain America','Hulk','Iron Man','Thor']
for m in classes:
img_path = os.path.join(base_dir, m)
images = glob.glob(img_path + '/*.jpg')
num_train = int(round(len(images)*0.7))
train, val = images[:num_train], images[num_train:]# Creating separate directories for training datafor t in train:
if not os.path.exists(os.path.join(base_dir, 'train', m)):
os.makedirs(os.path.join(base_dir, 'train', m))
shutil.move(t, os.path.join(base_dir, 'train', m))# Creating separate directories for validating datafor v in val:
if not os.path.exists(os.path.join(base_dir, 'val', m)):
os.makedirs(os.path.join(base_dir, 'val', m))
shutil.move(v, os.path.join(base_dir, 'val', m))
在上面的代码块中，为训练和验证数据创建了单独的目录。训练和验证数据按照 70:30 的比例分割。所有的图像扩展名都被转换成 jpg 。
train_dir = os.path.join(base_dir, 'train')
val_dir = os.path.join(base_dir, 'val')
为培训和验证创建了两个目录。
# Setting batch size and a constant image shapebatch_size = 130IMG_SHAPE = 150# Rescaling the images so all the values lie between 0 and 1 and applying horizontal flip and training the dataimage_gen = ImageDataGenerator(rescale=1./255, horizontal_flip=True)train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,directory=train_dir,shuffle=True,target_size=(IMG_SHAPE,IMG_SHAPE))# Rescaling the images so all the values lie between 0 and 1 and rotating and training the dataimage_gen = ImageDataGenerator(rescale=1./255, rotation_range=45)train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,directory=train_dir,shuffle=True,target_size=(IMG_SHAPE, IMG_SHAPE))#Rescaling and zooming the dataimage_gen_train = ImageDataGenerator(rescale=1./255,rotation_range=45,width_shift_range=.15,height_shift_range=.15,horizontal_flip=True,zoom_range=0.5)train_data_gen = image_gen_train.flow_from_directory(batch_size=batch_size,directory=train_dir,shuffle=True,target_size=(IMG_SHAPE,IMG_SHAPE),class_mode='sparse')
由于收集的图像大小不同，因此对图像进行调整大小。选择 150 * 150 的图像尺寸。图像的像素值范围从 0 到 255，为了提供更好的结果，像素值被重新缩放，因此所有值都位于 0 和 1 之间。不同的技术如水平翻转**、缩放、旋转都是在现有的一组图像上进行。**
image_gen_val = ImageDataGenerator(rescale=1./255)val_data_gen = image_gen_val.flow_from_directory(batch_size=batch_size,directory=val_dir,target_size=(IMG_SHAPE, IMG_SHAPE),class_mode='sparse')model = Sequential()model.add(Conv2D(16, 3, padding='same', activation='relu', input_shape=(IMG_SHAPE,IMG_SHAPE, 3)))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Conv2D(32, 3, padding='same', activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Conv2D(64, 3, padding='same', activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))# Adding dropout to turn down some neuronsmodel.add(Flatten())model.add(Dropout(0.2))model.add(Dense(512, activation='relu'))model.add(Dropout(0.2))model.add(Dense(5, activation='softmax'))
卷积和最大池应用于数据集，在将其发送到输出层之前，模型被展平**。剔除用于防止图像的过拟合。**
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])epochs = 120history = model.fit_generator(train_data_gen,steps_per_epoch=int(np.ceil(train_data_gen.n / float(batch_size))),epochs=epochs,validation_data=val_data_gen,validation_steps=int(np.ceil(val_data_gen.n / float(batch_size))))
模型编译观察性能。您可以使用超参数来获得最佳结果。
github(代码)的链接附在下面
permalink dissolve GitHub 是 4000 多万开发人员的家园，他们一起工作来托管和审查代码，管理…
github.com](https://github.com/VishnuBhaarath/Computervisionprojects/blob/master/Imageclassification.ipynb)**
数据科学中的图像分类
什么是数据科学中的图像分类和用 Python 构建我们自己的图像分类器
在 Unsplash 上由 René Peters 拍摄的照片
欢迎阅读“Python 数据科学”迷你系列的第 2 部分！在这一课中，我们将讨论什么是图像分类，并训练一个图像分类器，它可以相当准确地识别猫和狗(反之亦然)。
什么是图像分类？
考虑上面的图像。我相信我们都同意这是一辆车。但是退一步，分析一下你是如何得出这个结论的——你看到了一张图片，你将归类到它所属的类别(在这个例子中是一辆汽车)。简而言之，这就是图像分类的全部内容。
潜在地，给定图像可以被分类成无数种类(例如，汽车可以被分类成轿车、掀背车、SUV 等。反过来，它们又可以被分为奥迪、玛莎拉蒂甚至丰田。手动检查和分类图像是一个非常繁琐的过程，当你面对大量的图像，比如 10，000 甚至 100，000 张时，这几乎是不可能的。
图像分类是获取输入(如图片)并输出类别(如“猫”)或输入是特定类别的概率(该输入有 90%的概率是猫)的过程。
你可以看着一张照片，知道你在看一只猫，但计算机如何才能学会这样做呢？
用卷积神经网络！
我已经在 CNN 上写了一篇文章，值得一读，尤其是如果你是数据科学的新手。
事实证明，
计算机不像人类那样看图像。他们看到的是一个像素矩阵，每个像素有三个分量:红、绿、蓝(听说过 RGB 吗？)
因此，对我们来说，1000 像素的图像对计算机来说将有 3000 像素。这 3000 个像素中的每一个都将被赋予一个值或强度。结果是 3000 个精确像素强度的矩阵，计算机必须以某种方式将其解释为一个或多个对象。
对于黑白图像，像素被解释为 2D 阵列(例如，2x2 像素)。每个像素的值都在 0 到 255 之间。(零全黑，255 全白。灰度存在于这些数字之间。)基于这些信息，计算机可以开始处理这些数据。
对于彩色图像(红色、绿色和蓝色的组合)，这是一个 3D 阵列。每种颜色的值都在 0 到 255 之间。可以通过组合三层中每一层的值来找到颜色。
设置图像数据的结构
在数据科学中，我们构建的图像分类器必须经过训练才能识别对象/模式——这向我们的分类器显示了准确(或大致)要识别的内容。
想象一下我给你看下面的图像:
有一个船屋，一艘小船，小山，一条河和其他物体。你会注意到它们，但你不会确切知道我指的是什么对象。现在，如果我给你看另一张照片:
本杰明·沃罗斯在 Unsplash 上拍摄的照片
另一个:
Kurt Cotoaga 在 Unsplash 上拍摄的照片
你会认识到我想让你认识一座“山”。通过展示前两张图片，我基本上训练了你的大脑在第三张图片中识别一座山。
对计算机来说，这个过程(几乎)是一样的——我们的数据需要有特定的格式。我们将在本文的后面看到这一点，但是请记住这些要点。
我们的模型将在“训练”集中存在的图像上训练，并且标签预测将在测试集图像上发生。
构建我们的模型
对于本文，我将使用 Google Colab——一种基于 Jupyter 笔记本的免费云服务，支持免费 GPU。
Colab 提供了一个 GPU，而且完全免费。说真的！
这篇文章的全部代码可以在这里找到。
导入包和加载数据
在本文中，我们将利用 Kaggle 的狗对猫数据集的过滤版本。你可以从这里下载数据集的存档版本。
数据集具有以下目录结构:
**cats_and_dogs_filtered**
|__ **train**
|______ **cats**: [cat.0.jpg, cat.1.jpg, cat.2.jpg ....]
|______ **dogs**: [dog.0.jpg, dog.1.jpg, dog.2.jpg ...]
|__ **validation**
|______ **cats**: [cat.2000.jpg, cat.2001.jpg, cat.2002.jpg ....]
|______ **dogs**: [dog.2000.jpg, dog.2001.jpg, dog.2002.jpg ...]
接下来，我们将为训练集和验证集分配具有适当文件路径的变量。
如果您想知道猫和狗的图像在训练和验证目录中，请使用以下代码:
如果您得到了不同的输出，不要担心——您可能使用了不同的数据集
准备我们的数据
我们的图像必须被格式化成经过适当预处理的浮点张量，然后才能提供给网络。
可视化训练图像
我们现在将从训练生成器中提取一批图像，然后用matplotlib绘制其中的五幅。
5 幅训练图像
创建模型
编译模型
在本文中，我们将使用 ADAM 优化器和二元交叉熵损失函数。
训练我们的模型
我们将使用ImageDataGenerator类的fit_generator方法来训练我们的网络。
让它运行—这需要一些时间。要有耐心！
用图可视化训练结果
培训和验证图
从图中可以看出，训练精度和验证精度相差很大，模型在验证集上仅达到大约 70% 的精度。
过度拟合
在上面的图中，训练精度随时间线性增加，而验证精度在训练过程中停滞在 70%左右。此外，训练和验证准确性之间的差异也很明显——这是过度拟合的迹象。
当训练样本数量较少时，模型有时会从训练样本的噪声(不需要的细节)中学习。这对新示例的模型性能有负面影响。这种现象被称为过度拟合。
过度拟合选举优先级(来源: XKCD
这意味着模型将很难对新数据集进行概化。
在训练过程中有多种方法来对抗过度适应。在本文中，我们将使用数据扩充并将退出添加到我们的模型中。
数据扩充
过度拟合通常发生在训练样本数量很少的时候。解决这个问题的一个方法是增加数据集，使其具有足够数量的训练示例。
我们的目标是，在训练阶段，我们的模型永远不会看到同一个图片两次。这有助于将它暴露给数据的更多方面，这将最终提高它的识别准确性。
扩充和可视化数据
在本文中，我们将对数据集应用随机旋转 和 缩放 增强，并查看单个图像在转换后的样子。
创建验证数据生成器
一般来说，我们只对训练样本应用数据扩充。在这种情况下，我们将重新缩放验证图像，并将其转换为批次。
拒绝传统社会的人
另一种减少过拟合的技术是将下降引入网络。
Dropout 是正则化的一种形式，它从你的神经网络中随机剔除单元(即神经元),因此在每次迭代中，你都以一个更小的神经网络结束工作。
这里的直觉是:不能依赖任何一个特征，要把权重分散开来。
当您对图层应用“丢弃”时，它会在训练过程中随机丢弃(设置为零)输出单位的数量。它接受一个分数作为输入，比如 0.1、0.3 等。(这意味着从它所应用的层中随机丢弃 10%或 30%的输出单元)。
创建一个有辍学者的新网络
可视化新模型
你会注意到过度拟合比以前明显减少了。在对模型进行更多时期的训练后，精确度应该会上升。
更精确的模型
就是这样！我们已经成功地建立了一个图像分类器来识别图像中的猫和狗。与所有神经网络一样，我们无法达到 100%的准确性，但我们能够通过将模型暴露于相同数量的图像来提高模型的准确性水平，但使用了增强功能，如旋转、翻转和缩放。
训练一个神经网络，以相当高的准确度识别猫和狗，整个细节都在本…
github.com](https://github.com/jasmcaus/image-classifier-python)**
一如既往，非常感谢您的阅读！请告诉我你的想法或者希望我接下来在评论中写些什么。我也乐于接受批评！
下期帖子再见！😄
X 射线扫描的图像分类
通过人工智能检测新冠肺炎症状
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
医疗保健行业正处于巨大的范式转变之中，技术是驱动力。在这一转变中，尽管人工智能已经取得了巨大的进步，但它还没有成熟到可以进行最终的诊断；它仅仅是为了帮助医疗专业人员给出他们的最终诊断。根据世界卫生组织(世卫组织)，重症新冠肺炎最常见的诊断是重症肺炎。这是这个项目背后的关键驱动力。为了帮助对新冠肺炎的研究，我使用了我在哥伦比亚大学的第一门人工智能课程中学到的关于数据集的概念，将肺部 X 射线扫描分类为正常或肺炎感染的肺部。
来源:作者
外行人不可能如上所述区分正常人的肺和肺炎感染者的肺。
让我们戴上博士帽，深入研究数据集吧！
资料来源: Giphy
数据文件包含以下文件夹:
Train: 这个文件夹有 5309 张图片，每张图片都以图片 id 命名，例如 IM-0131–0001.jpeg
**测试:**这个文件夹以类似的方式存储了 624 张图像
**Chest _ x ray _ Corona _ metadata . CSV:**这具有从图像 id 到标签的映射，即从 IM-0131–0001.jpeg 到正常。有些图像没有贴图，因此被丢弃
**Chest _ x ray _ Corona _ dataset _ summary . CSV:**该 excel 文件包含属于每个类别的图像数量的明细
来源:作者
使用 python 对图像进行了处理并存储在本地。通过改变尺寸(300 x 300)和格式(PNG)使它们变得一致。
来源:作者
该标签用于在 python 中重命名图像，以便于分类。选择这些维度是为了平衡信息损失(太小)和训练模型时更高的计算时间(太大)之间的权衡。
处理后的图像被推送到 Google drive，因为模型训练必须在 Collab (GPU 支持和 25 GB RAM)上完成。正常图像标记为 1，肺炎图像标记为 0。训练图像被转换成从 0 到 255(像素)的数字数组，并与它们的标签一起存储在一个列表中，以传递给神经网络。20%的训练数据被保留用于验证(超参数调整)。
遵循的网络 架构是一个流行的、有效的、简单的架构，叫做 VGGnet 。
来源:快照(爱思唯尔)
这里使用的架构是图中所示的较小版本，但有趣的是，随着我们越往下，滤波器的尺寸越大。使用了以下过滤器:
32 → 64 → 128 → 512 → 1
隐藏层均由 Relu(校正线性单位)激活函数激活。二维卷积网络使用大小为[3，3]的核。这指定了二维卷积窗口的高度和宽度。滤波器大小[32]是输出维度的大小(卷积中输出滤波器的数量)。输入形状为[300，300，1]。前两个维度是图像的大小，最后一个维度是图像中通道的数量(1 表示图像为灰度)。
在编译网络之前，进行数据扩充以增加输入图像的数量。Keras 有一个图像数据生成器，这是一个标准的工具。生成器有助于重新缩放像素值以及生成新形式的图像。例如，放大和缩小、按特定角度旋转会创建同一图像的相似版本，并增加数据的大小。x 射线图像水平翻转的想法在这里得到了验证。使用生成器，像素值也被缩放到 0 和 1 之间。
损失函数被设置为二进制交叉熵当输出取二进制值时，选择的优化器是学习率为 0.0001 的亚当，选择的度量是准确度。网络的其他规范在 GitHub 上的代码中。
来源:作者
历元的数量被认为是 60。可以看到，精度在大约 50 个时期后趋于稳定，我们可以认为权重已经得到了相当好的优化。可以通过像提前停止这样的方法来进一步微调这些时期。
使用这些权重，在 624 幅测试图像上的准确率为 92.1% 。下面是结果的快照，其中每个图像的标题显示了实际的和预测的标签(代码中有更多的结果)。
来源:作者
来源:作者
TL；速度三角形定位法(dead reckoning)
对于未来的范围，如果有更多的新冠肺炎病例和其他病毒的标记图像，可以进行多级分类。神经网络是数据饥渴模型，有了海量的数据集，可以建立更深层次的网络，结果会好得多。此外，使用交叉验证(5 倍)来监控样本外性能可能是一个好主意，因为这将更能代表学习。也可以对时期的数量进行微调，以提高测试集的准确性。
在结束语中，我要再次强调这样一个事实，即人工智能算法应该作为做出重要决策的补充支持，特别是在医疗保健等领域(至少在我们到达终结者时代之前)！
来源: Giphy
基于 gRPC 或 REST 调用推理的张量流图像分类
通过 gRPC 或 rest API 调用为生产和推理中的影像分类模型提供服务
使用后墙创建的图像
Tensorflow 提供了多种部署模型的方法。我已经探索了为生产中的模型服务的大多数方法。我一直在寻找一个简单、安全、健壮的解决方案，它应该既能在边缘设备上访问，也能在用其他编程语言编写的服务器上访问。模型服务器非常适合我的需求。我通过 REST API 连接边缘设备，并对我的另一台服务器进行内部 RPC 调用。我还能够为不同的设备提供不同的版本，我可以很容易地从中央服务器控制这些设备。在本文中，我演示了如何以两种方式调用模型服务器，并找出哪种方法适合您的问题陈述。
我们开始吧
我们将部署一个在 Keras 上训练的图像分类器。为了让我们的模型在模型服务器上运行，我们需要以下面提到的特定格式导出我们的权重。
model_name/
version/
saved_model.pb
variables/
variables.index
variables.data-000-of-n
在 TensorFlow 2 中我们可以用tf.keras.models.save_model函数直接导出训练好的模型。
MODEL_DIR = './cat_dog_classifier'
version = 1
export_path = os.path.join(MODEL_DIR, str(version))tf.keras.models.save_model(
model,
export_path,
overwrite=True,
include_optimizer=True,
save_format=None,
signatures=None,
options=None
)
验证元图和签名定义
我们将使用saved_model_cli工具来检查图形。这将有助于找出输入和输出节点名称。
saved_model_cli show --dir ./cat_dog_classifier/1/ --all
安装模型服务器
*echo "deb [arch=amd64]* [*http://storage.googleapis.com/tensorflow-serving-apt*](http://storage.googleapis.com/tensorflow-serving-apt) *stable tensorflow-model-server tensorflow-model-server-universal" | sudo tee /etc/apt/sources.list.d/tensorflow-serving.list && \
curl* [*https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg*](https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg) *| sudo apt-key add -*sudo apt-get updatesudo apt-get install tensorflow-model-server
运行模型服务器
我们将在 grpc 的默认端口 8500 和 HTTP 的默认端口 8501 上运行模型服务器。如果需要，您还可以指定不同的端口。
假设您的终端位置与模型文件夹位于同一文件夹中。
export MODEL_DIR=$(pwd)/cat_dog_classifiertensorflow_model_server --port=8500 --rest_api_port=8501 --model_name=cat_dog_classifier --model_base_path="${MODEL_DIR}"
在使用您保存的模型成功运行模型服务器之后，您将获得与您的模型类似的输出。
2020–06–30 15:22:57.309568:I tensor flow _ serving/core/loader _ harness . cc:87]成功加载可服务版本{ name:cat _ dog _ classifier version:1 }
2020–06–30 15:22:57.311296:I tensor flow _ serving/model _ servers/server . cc:355]运行 gRPC model server 0 . 0 . 0:8500
图像推理
拨打 GRPC 电话
必要进口:
import grpc
import numpy as np
import nsvision as nv
import tensorflow as tf
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc
设置 gRPC 通道:
label = ['cat', 'dog']
GRPC_MAX_RECEIVE_MESSAGE_LENGTH = 4096 * 4096 * 3
channel = grpc.insecure_channel('localhost:8500', options=[('grpc.max_receive_message_length', GRPC_MAX_RECEIVE_MESSAGE_LENGTH)])
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
grpc_request = predict_pb2.PredictRequest()
grpc_request.model_spec.name = 'cat_dog_classifier'
grpc_request.model_spec.signature_name = 'serving_default'
预测图像的输出:
确保为 gRPC 请求对象指定了正确的输入和输出。如果你想知道你的模型的输入输出键是什么，你可以使用元数据来检查，元数据可以通过在浏览器中调用一个系统化的 URL 来找到。在这种情况下，它是:
[http://localhost:8501/v1/models/cat_dog_classifier/metadata](http://localhost:8501/v1/models/cat_dog_classifier/metadata)
我的输入层名称是conv2d_input和输出层名称是dense_1，但它会因型号而异。
image = nv.imread('golden-retriever-royalty-free-image-506756303-1560962726.jpg',resize=(150,150),normalize=True)
image = nv.expand_dims(image,axis=0)
grpc_request.inputs['conv2d_input'].CopyFrom(tf.make_tensor_proto(image, shape=image.shape))
result = stub.Predict(grpc_request,10)
result = int(result.outputs['dense_1'].float_val[0])
print(label[result])
#This printed 'dog' on my console
进行 REST API 调用
Rest API 比 grpc 需要更少的库和设置。
进口:
import json
import requests
import nsvision as nv
为 REST 调用创建 JSON:
label = ['cat','dog']
image = nv.imread('cat.2033.jpg',resize=(150,150),normalize=True)
image = nv.expand_dims(image,axis=0)
data = json.dumps({
"instances": image.tolist()
})
headers = {"content-type": "application/json"}
预测图像的输出:
REST API 调用需要一个 URL 用于 POST 调用，模型服务器已经为 API 调用指定了一个 URL 格式:
http://host_ip:port/version_number/models/model_name:predict
在这种情况下，API URL 将是:
[http://localhost:8501/v1/models/cat_dog_classifier:predict](http://localhost:8501/v1/models/cat_dog_classifier:predict)
response = requests.post('[http://localhost:8501/v1/models/cat_dog_classifier:predict'](http://localhost:8501/v1/models/cat_dog_classifier:predict'), data=data, headers=headers)
result = int(response.json()['predictions'][0][0])
print(label[result])
#This printed 'cat' on my console
由于它是一个 REST API，您可以将端点连接到 javascript 等 web 客户端或 Android、Ios 等边缘设备或 Raspberry Pi 或 Jetson Nano 等物联网设备。
Github 资源库:
该存储库包含在模型服务器上部署生产中的 Keras 模型的代码，以及使用 GRPC 或 HTTP…
github.com](https://github.com/novasush/image-classifier-in-production)
这是所有的乡亲
采用英特尔神经计算棒 2 (NCS2)的图像分类管道
借助这份全面的指南，使用 NCS2 从数据集到影像分类
图片由 Oleksii Sheremet 使用 Adobe Photoshop 创建
简介
我们将在这个故事中讲述的内容:
- 安装 OpenVINO toolkit for Ubuntu。
- 用 Google Colab 进行数据预处理和模型训练。
- 将张量流模型保存为协议缓冲区(pb)格式。
- 将张量流模型转换成中间表示。
- 使用 NCS2 设备运行训练好的模型并获得预测。
在过去的几年里，机器学习已经被积极地引入到工业任务解决方案中。机器学习可以让你解决人类无法应对的问题。这可以在难以到达地方、在危险的化学生产中、在辐射增加的条件下等工作。机器学习适用于人类智能也可以应用，但无效的领域:预测关键故障、预防突发设备故障、视情维修、预测设备剩余寿命。
通常，在工业企业中，没有机会使用工作站进行数据分析和处理。因此，需要能够容易地连接到现有设备(通常是工业微型计算机)的特殊装置。计算模块 NCS2 就是这样的设备之一。
我们公司 AI Labs 定期收到解决一些与机器学习相关的工业问题的请求。不久前，我们有机会利用第二次全国人口普查提供的机会。因此，我使用 NCS2 开发了一个图像分类管道。我愿意与读者分享这项工作的成果。
安装 OpenVINO toolkit for Ubuntu
首先你需要下载并安装当前版本的 OpenVINO 。你可以从这里得到 OpenVINO。你可以在这里找到详细的安装指南。快速安装指南:
- 转到包含下载的档案的文件夹(例如， Downloads ):
cd ~/Downloads/
2.打开包装。tgz 文件(其中 <版本> 是下载存档的版本，你会在文件名中看到):
tar -xvzf l_openvino_toolkit_p_<version>.tgz
3.进入 l_openvino_toolkit_p_ <版本> 目录:
cd l_openvino_toolkit_p_<version>
4.以 root 用户身份运行安装脚本:
sudo ./install.sh
5.按照屏幕上的说明进行操作。
6.通过编辑设置环境变量。bashrc 文件。转到用户目录并打开*。bashrc* 文件进行编辑(例如，用 nano ):
cd ~
nano .bashrc
将下面一行添加到。bashrc 文件，保存并重新加载:
source /opt/intel/openvino/bin/setupvars.sh
source .bashrc
仅此而已。已经准备好了使用 NCS2 进行本地工作的所有必要功能。您可以执行数据预处理和模型训练。
使用 Google Colab 进行数据预处理和模型训练
Animals-10 数据集用于解决分类问题。为了简化问题，从动物中选择 5 个类别(动物种类)-10:猫、狗、鸡、马、羊。与每个类别相关的图像被分组到相应的文件夹中(“猫”、“狗”、“鸡”、“马”、“羊”)。模型是在 Google Colab 中训练出来的。让我们仔细看看。
首先，您需要安装一个适合与 NCS2 配合使用的 TensorFlow 版本:
!pip install tensorflow==1.15.2
导入库:
import tensorflow.compat.v1 as tf
import tensorflow_hub as hub
import matplotlib.pylab as plt
import numpy as np
将 Google Drive(包含数据集)安装到 Google Colab:
from google.colab import drive
drive.mount(‘/content/drive’)
转到上传数据的目录(“动物”):
%cd ‘drive/My Drive/animals’
文件夹结构应该如下所示:
Oleksii Sheremet 使用树命令创建图像
创建类别(标签)列表:
image_dir = 'animals'
import osclass_labels = []
for x in tf.gfile.Walk(image_dir):
try:
y = os.path.basename(x[0])
if y != 'animals':
class_labels.append(y)
except:
pass
print(class_labels)
我们得到以下列表:
[‘cat’, ‘chicken’, ‘dog’, ‘horse’, ‘sheep’]
基于这个列表，索引“0”对应于猫的图像，“1”对应于鸡，“2”对应于狗，“3”对应于马，“4”对应于羊。
设置图像的尺寸(224 x 224)。在训练模型时，我们使用 ImageDataGenerator 从文件夹中创建图像流。
IMAGE_SIZE = (224,224)image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1/255, validation_split=0.2)training_set = image_generator.flow_from_directory(str(image_dir), target_size=IMAGE_SIZE, subset='training')validation_set = image_generator.flow_from_directory(str(image_dir), target_size=IMAGE_SIZE, subset='validation')
正在检索预训练的 MobileNet 网络:
feature_extractor = tf.keras.applications.MobileNet(weights='imagenet',
include_top=False,
input_shape=(IMAGE_SIZE+(3,)))
feature_extractor.trainable=False
构建模型:
try:
del model
except:
passx=feature_extractor.output
x=tf.keras.layers.GlobalAveragePooling2D()(x)classifier=tf.keras.layers.Dense(label_batch.shape[1],activation='softmax')(x)model=tf.keras.Model(inputs=feature_extractor.input,outputs=classifier)model.build((None,)+IMAGE_SIZE+(3,))
model.summary()
编译模型:
model.compile(
optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
metrics=['acc'])
收集日志的回调方法:
class CollectBatchStats(tf.keras.callbacks.Callback):
def __init__(self):
self.batch_losses = []
self.batch_acc = []
self.validation_losses = []
self.validation_acc = []def on_train_batch_end(self, batch, logs=None):
self.batch_losses.append(logs['loss'])
self.batch_acc.append(logs['acc'])
try:
self.validation_losses.append(logs['val_loss'])
self.validation_acc.append(logs['val_acc'])
except:
self.validation_losses.append(None)
self.validation_acc.append(None)
self.model.reset_metrics()
训练模型:
steps_per_epoch = np.ceil(training_set.samples/training_set.batch_size)batch_stats_callback = CollectBatchStats()history = model.fit_generator(training_set, epochs=5,
steps_per_epoch=steps_per_epoch,
validation_data=validation_set,
callbacks = [batch_stats_callback])
检查预测:
for image_batch, label_batch in validation_set:
print("Image batch shape: ", image_batch.shape)
print("Label batch shape: ", label_batch.shape)
break
我们有以下形状:
Image batch shape: (32, 224, 224, 3)
Label batch shape: (32, 5)
我们可以得到预测和它们的类别:
predictions = model.predict(image_batch)
predicted_class = np.argmax(predictions, axis=-1)
将结果可视化:
plt.figure(figsize=(12,10))
plt.subplots_adjust(hspace=0.5)
for n in range(30):
plt.subplot(6,5,n+1)
plt.imshow(image_batch[n])
plt.title(f'pred: {class_labels[predicted_class[n]]}\norig: {class_labels[np.array(label_batch[n]).argmax()]}')
plt.axis('off')
_ = plt.suptitle("Animals")
图像由 Oleksii Sheremet 使用 matplotlib 模块创建
将 TensorFlow 模型保存为协议缓冲区(pb)格式
冻结并保存模型:
from tensorflow.compat.v1.keras import backend as Ksession = K.get_session()
graph = session.graph
with graph.as_default():
freeze_var_names = list(set(v.op.name for v in tf.global_variables()).difference([]))
output_names = [out.op.name for out in model.outputs]
output_names += [v.op.name for v in tf.global_variables()]
input_graph_def = graph.as_graph_def()
for node in input_graph_def.node:
node.device = ""
frozen_graph = tf.graph_util.convert_variables_to_constants(session, input_graph_def, output_names, freeze_var_names)
tf.train.write_graph(frozen_graph, "animals", "animals.pb", as_text=False)
因此，训练好的模型被保存到 animals.pb 文件中。
将张量流模型转换为中间表示法
有详细的教程关于转换张量流模型。若要转换训练好的模型，您需要执行下面描述的操作。
进入模型 _ 优化器文件夹(需要 mo_tf.py ):
cd ~/intel/openvino/deployment_tools/model_optimizer
使用以下命令运行 mo_tf.py (请注意，您必须使用 255 的缩放因子，与图像预处理阶段相同):
python mo_tf.py --input_model <path_to_model>/animals.pb --batch 1 --scale 255
如果转换成功，您将在控制台中看到以下消息:
[ SUCCESS ] Generated IR version 10 model.
[ SUCCESS ] XML file: /home/user_name/intel/openvino_2020.4.287/deployment_tools/model_optimizer/./animals.xml
[ SUCCESS ] BIN file: /home/user_name/intel/openvino_2020.4.287/deployment_tools/model_optimizer/./animals.bin
[ SUCCESS ] Total execution time: 31.81 seconds.
[ SUCCESS ] Memory consumed: 370 MB.
因此，作为转换的结果，我们得到 3 个文件: animals.xml 和 animals.bin，animals.mapping 。建议将这些文件复制到一个单独的文件夹中(例如， test_folder )。
用 NCS2 设备运行训练好的模型并获得预测
要在 NCS2 上检查模型的性能，可以使用classification _ sample . py脚本，它包含在 open vino(/home/user _ name/Intel/open vino/deployment _ tools/inference _ engine/samples/python/classification _ sample/classification _ sample . py)中。将这个脚本复制到包含 3 个训练好的模型文件的文件夹中( animals.xml，animals.bin，animals.mapping )。此外，为了检查功能，您可以将几幅图像(例如，001.jpeg和002.jpeg)复制到同一个文件夹中。
将 NCS2 连接到 USB，进入 test_folder 并运行( MYRIAD 键在 NCS2 上运行模型):
python classification_sample.py -m animals.xml -i 001.jpeg -d MYRIAD
在控制台中测试图像和 NCS2 的输出:
图片由 Oleksii Sheremet 使用 Adobe Photoshop 创建
python classification_sample.py -m animals.xml -i 002.jpeg -d MYRIAD
图片由 Oleksii Sheremet 使用 Adobe Photoshop 创建
从给出的例子中可以看出，分类是正确的。图像001.jpeg显示一匹马(classid=3)，图像002.jpeg显示一只鸡(classid=1)。
结论
所展示的管道允许您快速通过从数据预处理和模型训练到基于 NCS2 模块的测试的所有阶段。实践表明，NCS2 很好地处理了图像分类任务，可以推荐用于解决简单的工业分类任务。
参考文献
在 Colab 上使用 Fastai v2 进行图像分类
一步一步的指导训练和分类图像，只需几行代码
瑞安·卡彭特在 Unsplash 上拍摄的照片
介绍
Fastai 是一个基于 PyTorch 构建的库，用于深度学习应用。他们的使命是让深度学习更容易使用，并让更多来自各种背景的人参与进来。他们还为 Fastai 提供免费课程。
Fastai v2 于 8 月发布，我将使用它来构建和训练一个深度学习模型，在 Colab 上对不同的运动领域进行分类，只需几行代码。
数据收集
首先，我需要收集图像供模型学习。我希望有一个模型来分类不同的运动领域:棒球，篮球，足球，网球和美式足球。我搜索并下载了这些图片，保存在不同的文件夹中，然后上传到 Google Drive。
文件夹包含运动场图片。(图片由作者提供)
设置 Colab 环境
一旦数据集准备好了，我就可以开始 Colab 的工作了。
首次升级 fastai，
!pip install fastai --upgrade -q
并导入fastai.vision，
from fastai.vision.all import *
然后安装 Google Drive 并设置路径
from google.colab import drive
drive.mount(‘/content/gdrive’, force_remount=True)
root_dir = ‘gdrive/My Drive/Colab Notebooks/’
base_dir = root_dir + ‘ball_class’
path=Path(base_dir)
现在我们准备好出发了。
数据块和数据加载器
Fastai 提供了一个中级 API: DataBlock 来处理数据，它非常容易使用。
fields = DataBlock(blocks=(ImageBlock, CategoryBlock),
get_items=get_image_files,
get_y=parent_label,
splitter=RandomSplitter(valid_pct=0.2, seed=42),
item_tfms=RandomResizedCrop(224, min_scale=0.5),
batch_tfms=aug_transforms())
可以使用不同的blocks，在这种情况下，我们使用ImageBlock作为 x，使用CategoryBlock作为标签。对于不同的应用，也可以使用其他块，例如 MultiCategoryBlock、MaskBlock、PointBlock、BBoxBlock、BBoxLblBlock。
我使用 fastai 中的get_image_files函数获得图像的路径作为 x，并使用parent_label方法找到文件夹名称作为标签。fastai 中有一些内置函数，你也可以自己写函数来做这个。
然后我用RandomSplitter分割训练和验证数据集。
然后使用RandomResizedCrop将图像调整为 224，使用aug_transforms()进行数据扩充。
这是 Fastai 数据块的一种模板，它非常灵活，你可以根据你的情况改变它。你可以在这里找到详细的 tutoria l。
准备好数据块后，我们可以创建数据加载器:
并使用vocab检查标签
展示一些带有标签的图片
火车
现在我们准备好训练了。
我使用 resnet34 创建了一个 CNN 学习者:
learn = cnn_learner(dls, resnet34, metrics=error_rate)
并使用lr_find()找到合适的学习率
然后我们可以使用fit_one_cycle训练模型
只有经过 5 个历元，我们才能达到> 90%的准确率。
现在我们可以解冻网络，训练整个网络。
让我们来看看，仅仅经过几个纪元，我们就达到了 95%的准确率。
解释
我们也可以解释这个模型。混淆矩阵可以用以下公式绘制:
我们也可以用这个来看损失最高的图像。
本文展示了一个使用 fastai 进行图像分类的简单快捷的例子。使用这个强大的库可以创建更复杂和有趣的应用程序。
感谢阅读，编码快乐。
基于 GluonCV 的图像分类
使用 GluonCV 的预训练图像分类网络实现网球检测器
在的上一篇文章中，我们讨论了使用 GluonCV 的物体检测。在本文中，我们将讨论如何实现一个二值图像分类器，使用 GluonCV 的预训练图像分类网络对给定图像是否是网球进行分类。我们一步一步地实现机器学习管道，从加载和转换输入图像，到加载和使用预训练的模型。
- 导入库
为了开始一些初始设置，我们将导入包并设置数据的路径。
import mxnet as mx
import gluoncv as gcv
import matplotlib.pyplot as plt
import numpy as np
import os
from pathlib import Path
2。加载图像
为了加载图像，让我们实现一个函数，在给定文件路径的情况下从磁盘加载图像。该函数应该返回一个 8 位图像数组，这是在 MXNet 的 NDArray 格式和 HWC 布局(即高度，宽度，然后通道)。
def **load_image**(filepath):
image = mx.image.imread(filepath)
return image
3。变换图像
加载图像后，我们应该转换图像，以便它可以用作预训练网络的输入。我们计划在 **ImageNet 上使用预先训练好的网络。**因此，图像转换应遵循用于 ImageNet 预训练的相同步骤。图像应通过以下方式进行转换:
- 将最短尺寸调整为 224。例如(448，1792) -> (224，896)。
- 裁剪到尺寸为(224，224)的中心正方形。
- 将图像从 HWC 布局转换为 CHW 布局。
- 使用 ImageNet 统计数据标准化图像(即每个颜色通道的平均值和方差)。
- 创建一批 1 个图像。
这可以使用下面的函数来实现。
def **transform_image**(array):
image = gcv.data.transforms.presets.imagenet.transform_eval(array)
return image
4。加载模型
我们将使用已经在 ImageNet 上预先训练好的 MobileNet 1.0 图像分类模型。该模型可以从 GluonCV 模型动物园加载，如下所示:
def **load_pretrained_classification_network**():
model = gcv.model_zoo.get_model('MobileNet1.0', pretrained=True, root = M3_MODELS)
return model
5。使用型号
加载图像后，下一个任务是通过预训练的网络传递变换后的图像，以获得所有 ImageNet 类的预测概率(现在忽略网球类)。
提示 1 :不要忘记你通常是在处理一批图像，即使你只有一张图像。
提示 2:记住我们网络的直接输出不是概率。
def **predict_probabilities**(network, data):
prediction = network(data)
prediction = prediction[0]
probability = mx.nd.softmax(prediction)
return probability
6。查找类别标签
在 imageNet 中有 1000 个类。对于网球分类，我们需要找到与网球相关的概率(在 1000 个类别中)。这可以通过实现返回给定类标签的索引的函数来完成(例如，admiral是索引321)。
def **find_class_idx**(label):
for i in range(len(network.classes)):
if label == network.classes[i]:
return i
使用上面的函数来查找网球的正确索引，您应该实现一个函数来从网络计算的 1000 个类概率中分割网球的计算概率。它还应该将概率从 MXNet NDArray转换为 NumPy float32。我们将使用它作为图像是一个网球的置信度得分。
def **slice_tennis_ball_class**(pred_probas):
tennis_prob = pred_probas[find_class_idx('tennis ball')]
return tennis_prob.astype('float32').asscalar()
7。网球图像分类
把所有的碎片放在一起，我们就可以对一个图像进行分类，可以分辨出一个图像是不是网球。这可以通过创建一个名为TennisBallClassifier的类来实现整个分类管道来实现。您应该注意到，预训练模型在初始化期间被加载一次，然后它应该在classify方法中使用。
class **TennisBallClassifier**():
def **__init__**(self):
self._network = load_pretrained_classification_network()
def **classify**(self, filepath):
image = **load_image**(filepath)
transformed_image = **transform_image**(image)
self._visualize(transformed_image)
probabilities = **predict_probabilities**(self._network, transformed_image)
pred_proba = **slice_tennis_ball_class**(probabilities)
print('{0:.2%} confidence that image is a tennis ball.'.format(pred_proba))
return pred_proba
def **_visualize**(self, transformed_image):
chw_image = transformed_image[0].transpose((1,2,0))
chw_image = ((chw_image * 64) + 128).clip(0, 255).astype('uint8')
plt.imshow(chw_image.asnumpy())classifier = TennisBallClassifier()
filepath = Path(M3_IMAGES, 'erik-mclean-D23_XPbsx-8-unsplash.jpg')
pred_proba = classifier.classify(filepath)
np.testing.assert_almost_equal(pred_proba, 2.0355723e-05, decimal=3)
filepath = Path(M3_IMAGES, 'marvin-ronsdorf-CA998Anw2Lg-unsplash.jpg')
pred_proba = classifier.classify(filepath)
np.testing.assert_almost_equal(pred_proba, 0.9988895, decimal=3)
因此，使用预先训练的模型，我们可以正确地分类图像是否是网球。如上所示，在对足球进行分类时，我们看到该模型给出了 0%的置信度认为它是网球，而对网球图像进行了 99.9%置信度的正确分类。
成为媒体会员这里支持独立写作，每月 5 美元，获得媒体上的所有故事。
利用 Python 中的张量流进行图像分类
什么是图像分类，如何使用 Python 中的 TensorFlow 进行图像分类？
来源: Pixabay
简介
在之前的帖子中，我们看到了如何在一个简单的数据集上使用 TensorFlow。在这个例子中，我们将使用 TensorFlow 进行图像分类。我们将要使用的数据集是 MNIST 数据集，它是张量流数据集的一部分。
什么是图像分类？
图像分类是指计算机视觉中可以根据图像的视觉内容对图像进行分类的过程。例如，图像分类算法可以被设计成辨别图像是否包含人形。
导入库
首先，我们需要导入所需的库。在本例中，我们需要:
- Numpy—Python 编程语言的库，增加了对大型多维数组和矩阵的支持，以及对这些数组进行操作的大量高级数学函数。
- TensorFlow —一个免费的开源软件库，用于数据流和跨一系列任务的差异化编程。
- TensorFlow 数据集— 一组随时可用的数据集，使用 TensorFlow 或其他 Python ML 框架。
加载和解包数据
现在，我们需要加载数据。MNIST 数据库由具有手写数字的 28×28 大小的图像组成。
此外，我们需要解开数据——我们这样做是因为我们需要培训、验证和测试集。
缩放图像
我们将定义一个函数来缩放图像。我们这样做是因为 RGB 值(红、绿、蓝)每个都是 8 位。每种颜色的范围是 0-255(2⁸= 256 种可能性)。组合范围是 256256256。通过除以 255，0–255 范围可以描述为 0.0–1.0 范围，其中 0.0 表示 0 (0x00)，1.0 表示 255 (0xFF)。
洗牌数据
因为数据可能在一个部分中包含相同的值，所以我们需要对其进行混排。缓冲区大小是一个标量，它影响转换的随机性。它维护一个 buffer_size 元素的缓冲区，并从该缓冲区中随机选择下一个元素(如果下一个输入元素可用，则用下一个输入元素替换它)，而不是对整个数据集进行洗牌。洗牌后，我们需要批量数据集。批处理将数据集的 n 个连续元素堆栈到单个元素中的最简单形式是使用 batch 方法。Dataset.batch()转换正是这样做的。
概述模型
我们需要定义输出大小—在我们的例子中，我们期望输出从 0 到 9，所以大小将是 10。
接下来，我们需要定义隐藏层的大小。隐藏层的大小应介于输入层和输出层的大小之间。在这种情况下，隐藏层大小将为 50。
唯一剩下的事情就是定义模型。本例中的模型是使用 keras 定义的。顺序模型是层的线性堆叠。当我们定义模型时，我们需要为隐藏层和输出层选择激活函数。如果你想了解更多关于激活功能的内容，在之前的帖子里有完整的解释—https://towardsdatascience . com/deep-learning-with-tensor flow-5d 3a 7 a 8 c 55 CD
编译模型
在这一步中，我们将为培训配置模型。Compile 定义了损失函数、优化器和指标。我们需要一个编译好的模型来训练(因为训练使用了损失函数和优化器)。
- 优化器:优化算法或策略负责减少损失，并尽可能提供最准确的结果。在这个例子中，我们使用了一种叫做 Adam 的优化算法。Adam 是一种优化算法，可以用来代替经典的随机梯度下降过程，根据训练数据迭代地更新网络权重。
- 损失:这是一种评估特定算法对给定数据的建模程度的方法。如果预测与实际结果相差太多，损失函数就会产生一个非常大的数字。分类交叉熵和稀疏分类交叉熵具有相同的损失函数，唯一的区别是，当输入是一次热编码时，我们使用分类交叉熵，当输入是整数时，我们使用稀疏分类交叉熵。
- 指标:指标是用来判断模型性能的函数。
训练模型
当我们拟合模型时，我们实际上是在为固定数量的历元(数据集上的迭代)训练模型。我们需要定义批量大小、最大时期和提前停止。
- 批量 —一次正向/反向传递中训练样本的数量
- 时期数 —训练模型的时期数。一个历元是对所提供的整个 x 和 y 数据的迭代。
- 提前停止 —当监测的数量停止提高时，停止训练。耐心是一个数字，它定义了产生无改善的监控量的时期数，在此之后训练将停止。
结果
我们可以通过 epoch 监控训练过程。使用训练和验证集，每个历元给我们提供关于准确性和损失的信息。
评估模型
该函数返回测试集上模型的损失值和度量值。在这个函数中，输入数据将是我们的测试集。我们可以打印测试损失和测试准确度——在这个例子中，我们的准确度接近 97%。
结论
这只是图像分类的一个简单例子。我们可以对图像进行许多更复杂的修改。例如，我们可以对图像应用各种过滤器，这些过滤器使用数学算法来修改图像。有些过滤器非常容易使用，而有些则需要大量的技术知识。
如果你对这个话题感兴趣，请随时联系我。
领英简介:https://www.linkedin.com/in/ceftimoska/
博文原文可从以下链接获得:https://interworks . com . MK/image-class ification-using-tensor flow-in-python/
另外，你可以在下面的链接中找到另一篇类似的博文:https://interworks.com.mk/focusareas/data-management/
时尚 MNIST 图像分类:为什么卷积神经网络优于传统的机器学习算法
在最近十年，随着深度学习的发现，图像分类领域经历了一次复兴。传统的机器学习方法已经被更新更强大的深度学习算法所取代，例如卷积神经网络。然而，要真正理解和欣赏深度学习，我们必须知道为什么它在其他方法失败的地方成功了。在本文中，我们试图通过在时尚 MNIST 数据集上应用各种分类算法来回答其中的一些问题。
因贾·帕夫里奇在 Unsplash 拍摄的照片
数据集信息时尚 MNIST 于 2017 年 8 月由 Zalando Fashion 的研究实验室推出。它的目标是作为测试机器学习算法的新基准，因为 MNIST 变得太容易了，被过度使用了。MNIST 由手写数字组成，而时尚 MNIST
则由 10 种不同的服装物件的图像组成。每个图像具有以下属性:
- 其尺寸为 28 × 28 像素。
- 相应地旋转并以灰度表示，整数值范围从 0 到 255。
- 用黑色表示的空白区域，值为 0。
在数据集中，我们区分以下服装对象:
- t 恤/上衣
- 裤子
- 套衫
- 连衣裙
- 外套
- 凉鞋
- 衬衫
- 运动鞋
- 包
- 踝靴
探索性数据分析由于数据集是作为 Keras 库的一部分提供的，并且图像已经过处理，因此我们不需要进行太多的预处理。我们所做的唯一改变是将图像从 2D 阵列转换成 1D 阵列，因为这使得它们更容易处理。
数据集由 70000 幅图像组成，其中 60000 幅作为训练集，10000 幅作为测试集。像在原始 MNIST 数据集中一样，项目是均匀分布的(每个训练集 6000 个，测试集中 1000 个)。
不同服装的图片示例。作者照片。
然而，一幅图像仍然有 784 个维度，所以我们转向主成分分析(PCA)，看看哪些像素是最重要的。我们设置了 80%累积方差的传统基准，该图告诉我们，仅用大约 25 个主成分(PC 总数的 3%)就可以做到这一点。然而，这并不奇怪，因为我们可以在上面的照片中看到，在每个图像中有许多共享的未使用空间，不同类别的服装有不同的黑色图像部分。后者可能与以下事实有关:大约 70%的累积方差仅由 8 个主成分解释。
解释的累积差异百分比。作者照片。
我们将在逻辑回归、随机森林和支持向量机中应用主成分。
图像分类问题只是分类问题的一小部分。使用最多的图像分类方法是深度学习算法，其中一种是卷积神经网络。其余采用的方法将是常用分类方法的一个小集合。由于分类标签是均匀分布的，没有错误分类的惩罚，我们将使用准确性度量来评估算法。
卷积神经网络(CNN) 我们采用的第一种方法是 CNN。由于图像是灰度的，我们只应用了一个通道。我们选择了以下架构:
- 两个卷积层，32 和 64 个滤波器，3 × 3 内核大小，以及 relu 激活。
- 选择轮询层来操作尺寸为 2 × 2 的瓦片，并选择其中的最大元素。
- 两组密集层，第一组选择 128 个特征，具有 relu 和 softmax 激活。
这个架构没什么特别的。事实上，这是我们可以用于 CNN 的最简单的架构之一。这向我们展示了这类方法的真正威力:用一个基准结构获得很好的结果。
对于损失函数，我们选择分类交叉熵。为了避免过度拟合，我们从训练集中选择了 9400 幅图像作为我们参数的验证集。我们使用了新型优化器 adam，它改进了
标准梯度下降法，并对每个参数使用不同的学习率，批量大小等于 64。该模型被训练了 50 个时期。我们在下图中展示了精确度和损耗值。
作者照片。
作者照片。
我们看到该算法在 15 个周期后收敛，它没有被过度训练，所以我们对它进行了测试。获得的测试精度等于
89%，这是所有方法中获得的最好结果！
在讨论其他方法之前，让我们解释一下卷积层的作用。一个直观的解释是，第一层捕捉直线，第二层捕捉曲线。在这两层上，我们应用了最大池，它选择内核中的最大值，将衣服部分与空白空间分开。通过这种方式，我们获得了数据的代表性。在其他情况下，神经网络自己执行特征选择。在最后一个池层之后，我们得到一个人工神经网络。因为我们正在处理分类问题，最后一层
使用 softmax 激活来获得类别概率。由于类别概率遵循一定的分布，交叉熵表示与网络优选分布的距离。
多项式逻辑回归由于像素值是分类变量，我们可以应用多项式逻辑回归。我们以 one vs rest 的方式应用它，训练十个二元逻辑回归分类器，我们将使用它们来选择项目。为了不过度训练，我们使用了 L2 正则化。我们在这个算法上得到 80%的准确率，比卷积神经网络低 9%。但我们必须考虑到，这种算法适用于居中且正常旋转的灰度图像，有很多空白空间，因此它可能不适用于更复杂的图像。
最近邻居和质心算法我们使用了两种不同的最近距离算法:
- k-最近邻
- 最近质心
最近质心算法找到每一类元素的平均值，并将测试元素分配给被分配了最近质心的类。这两种算法都是针对 L1 和 L2 距离实现的。k-最近算法的准确率为 85%，而质心算法的准确率为 67%。这些结果是在 k=12 时获得的。k-最近邻的高精度告诉我们，属于同一类的图像往往在图像上占据相似的位置，并且也具有相似的像素强度。虽然最近邻获得了良好的结果，但它们的性能仍然比 CNN 差，因为它们不在每个特定特征的邻域中操作，而质心失败，因为它们不能区分相似外观的对象(例如套头衫与 t 恤/上衣)
随机森林为了选择用于估计的最佳参数，我们使用平方根(bagging)和全部数量的特征、基尼和熵标准以及具有最大深度 5 和 6 的树来执行网格搜索。网格搜索建议我们应该使用具有熵标准的特征的平方根数量(两者都是分类任务所期望的)。然而，所获得的准确性仅等于 77%，这意味着随机森林对于该任务来说不是特别好的方法。失败的原因是主成分不代表图像可以拥有的矩形分区，随机森林在其上操作。同样的推理也适用于全尺寸图像，因为树会太深，失去可解释性。
支持向量机(SVM) 我们使用径向和多项式核来应用 SVM。径向核有 77%的准确率，而多项式核失败得很惨，只有 46%的准确率。虽然图像分类不是他们的强项，但对于其他二元分类任务仍然非常有用。他们最大的警告是，他们需要特征选择，这会降低准确性，如果没有它，他们的计算成本会很高。此外，他们以一对一的方式应用多类分类，这使得有效地创建分离超平面变得更加困难，从而在处理非二进制分类任务时失去了价值。
结论在本文中，我们对一个图像分类问题应用了多种分类方法。我们已经解释了为什么 CNN 是我们可以采用的最佳方法，以及为什么其他方法会失败。CNN 是最实用且通常是最准确的方法的一些原因是:
- 他们可以通过层次转移学习，保存推论，并在随后的层次上做出新的推论。
- 在使用该算法之前不需要特征提取，它是在训练期间完成的。
- 它识别重要的特征。
然而，他们也有自己的警告。众所周知，它们在旋转和缩放不同的图像上是失败的，但在这里不是这样，因为数据是经过预处理的。尽管其他方法无法在该数据集上给出良好的结果，但它们仍然用于与图像处理相关的其他任务(锐化、平滑等)。).
代码:https://github . com/raden jeci 153/Stat _ ML/blob/master/project . ipynb
影像分类器-使用 Monk 库进行房屋类型分类
关于如何使用 Monk 库解决计算机视觉分类问题的文章。
这篇文章是一个关于如何使用 Monk 库来分类房间类型的教程，比如客厅、餐厅等等。
详细教程可在 GitHub 上获得。
数据集中的一些样本图像
关于数据集
- 该数据集包含总共 145436 幅图像，分为七类，即“外部”、“卧室”、“厨房”、“起居室”、“内部”、“浴室”、“餐厅”。
- 可以从这里下载。
关于 Monk 库和 Monk 如何让图像分类变得简单
- 编写更少的代码，创建端到端的应用程序。
- 只学习一种语法，使用任何深度学习库——py torch、Mxnet、Keras、TensorFlow 等，创建应用。
- 通过多个实验轻松管理您的整个项目。
这座图书馆是为谁而建的
- 学生:使用我们的综合学习路线图无缝学习计算机视觉。
- 研究人员和开发人员:创建和管理多个深度学习项目。
- Kaggle、Codalab、HackerEarth、AiCrowd 等上的比赛参与者。
目录
- 安装 Monk
2.将预训练模型用于部分房屋分类数据集
3.从头开始训练分类器
- 使用 ResNet 变体训练部分 house 分类器
- 了解在 ResNets 变体之间切换时发生的所有差异。
- 理解更大更深的网络并不总是意味着更好的结果
- 在这个实验中，您将使用 mxnet 后端
4.结论。
1.安装 Monk
*#using cuda10.0 download monk using following command***pip install -U monk-gluon-cuda100**
更多安装方法请访问 Monk 库。
2.使用预先训练好的模型进行演示
首先，从 google drive 下载预先训练好的模型。
**! wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=10SrowcOJp8GWqEB21BfCIinqUCHS7PMv' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=10SrowcOJp8GWqEB21BfCIinqUCHS7PMv" -O cls_house_scene_trained.zip && rm -rf /tmp/cookies.txt**
上面会下载预训练模型的 zip 文件，命名为 cls_house_scene_trained.zip，现在我们要解压文件了。
**! unzip -qq cls_house_scene_trained.zip**
导入monk . glon _ prototype用于使用和尚库。
**#Using mxnet-gluon backend*
*# When installed using pip*
**from** **monk.gluon_prototype** **import** **prototype***
让我们以推断模式加载模型，对演示数据进行分类。
**# Load project in inference mode*
**gtf = prototype(verbose=1);
gtf.Prototype("Task", "gluon_resnet18_v1_train_all_layers", eval_infer=True);***
根据一些样本推断
***img_name = "workspace/test/2.jpg"
predictions = gtf.Infer(img_name=img_name);
from IPython.display import Image
Image(filename=img_name, height=300, width=300)***
***img_name = "workspace/test/3.jpg"
predictions = gtf.Infer(img_name=img_name);
from IPython.display import Image
Image(filename=img_name, height=300, width=300)***
***img_name = "workspace/test/6.jpg"
predictions = gtf.Infer(img_name=img_name);
from IPython.display import Image
Image(filename=img_name, height=300, width=300)***
更多例子请访问笔记本。
3.从头开始训练自定义分类器
什么是 ResNet？
来自https://towards data science . com/an-overview-of-resnet-and-its-variants-5281 e2f 56035
*- The core idea of ResNet is introducing a so-called “identity shortcut connection” that **skips one or more layers**
- The deeper model should not produce a training error higher than its shallower counterparts.
- solves the problem of **vanishing gradients** as network depth increased*
ResNet18 架构
近期内容
- 加载数据集
- 训练模型采用 resnet18_v1(只训练最后一层)架构进行迁移学习。
- 训练模型采用 resnet18_v1(训练所有层)架构进行迁移学习。
- 训练模型采用 resnet18_v2(只训练最后一层)架构进行迁移学习。
- 训练模型采用 resnet34_v1(只训练最后一层)架构进行迁移学习。
- 比较所有的型号。
1.加载数据集
数据集学分:https://omidpoursaeed . github . io/publication/vision-based-real-estate-price-estimate/
步骤 1:下载数据集。
***! wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=0BxDIywue_VABY1dRcFVvZ3BodnM' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=0BxDIywue_VABY1dRcFVvZ3BodnM" -O dataset.zip && rm -rf /tmp/cookies.txt***
步骤 2:解压缩数据集。
***! unzip -qq dataset.zip***
2.训练模型采用 resnet18_v1(只训练最后一层)架构进行迁移学习。
步骤 1:加载实验并插入数据。更多详情请访问。
**# Load experiment*
**monk_gln = prototype(verbose=1);
monk_gln.Prototype("Task", "gluon_resnet18_v1");** *# Insert data and set params in default mode*
**monk_gln.Default(dataset_path="Train",
model_name="resnet18_v1",
freeze_base_network=True,
num_epochs=10);***
步骤 2:训练模型。
**#Start Training*
**monk_gln.Train();***
3.训练模型采用 resnet18_v1(训练所有层)架构进行迁移学习。
步骤 1:加载实验并插入数据。更多详情请访问。参数freeze _ base _ network**将被设置为 false 以训练所有层。**
***# Load experiment*
**monk_gln = prototype(verbose=1);
monk_gln.Prototype("Task", "gluon_resnet18_v1_train_all_layers");**
*# Insert data and set params in default mode*
**monk_gln.Default(dataset_path="Train",
model_name="resnet18_v1",
freeze_base_network=False,
num_epochs=10);****
步骤 2:训练模型。
***#Start Training*
**monk_gln.Train();****
4.训练模型采用 resnet18_v2(只训练最后一层)架构进行迁移学习。
步骤 1:加载实验并插入数据。欲了解更多详情，请访问。
***# Load experiment* **monk_gln = prototype(verbose=1);
monk_gln.Prototype("Task", "gluon-resnet18_v2");**
*# Insert data and set params in default mode*
**monk_gln.Default(dataset_path="Train",
model_name="resnet18_v2",
freeze_base_network=True,
num_epochs=10);****
步骤 2:训练模型。
***#Start Training*
**monk_gln.Train()****
5。训练模型采用 resnet34_v1( 只训练最后一层)架构进行迁移学习。
步骤 1:加载实验并插入数据。更多详情请访问。
***# Load experiment* **monk_gln = prototype(verbose=1);
monk_gln.Prototype("Task", "gluon-resnet18_v2");***# Insert data and set params in default mode*
**monk_gln.Default(dataset_path="Train",
model_name="resnet34_v1",
freeze_base_network=True,
num_epochs=10);****
步骤 2:训练模型。
***#Start Training*
**monk_gln.Train()****
6.比较所有的模型。
步骤 1:使用 Monk 库的比较类。更多详情请访问。
***# Invoke the comparison class*
**from** **monk.compare_prototype** **import** **compare****
步骤 2:创建和管理比较实验。提供项目名称。
****gtf = compare(verbose=1);
gtf.Comparison("Comparison-1");****
这将按照以下结构创建文件和目录
**workspace
|
|--------comparison
|
|
|-----Compare-1
|
|------stats_best_val_acc.png
|------stats_max_gpu_usage.png
|------stats_training_time.png
|------train_accuracy.png
|------train_loss.png
|------val_accuracy.png
|------val_loss.png
|-----comparison.csv (Contains necessary details of all experiments)**
步骤 3:将实验添加到比较对象中。
- 第一个参数——项目名称。
- 第二个参数——实验名称。
***#add the models trained above.* **gtf.Add_Experiment("Task", "gluon_resnet18_v1");
gtf.Add_Experiment("Task", "gluon_resnet18_v1_train_all_layers");
gtf.Add_Experiment("Task", "gluon-resnet18_v2");
gtf.Add_Experiment("Task", "gluon-resnet34_v1");****
步骤 4:运行分析。该步骤生成七幅图像。
****gtf.Generate_Statistics();****
步骤 5:可视化研究比较指标。
- 训练准确度曲线
****from IPython.display import Image
Image(filename="workspace/comparison/Comparison-1/train_accuracy.png")****
- 训练损失曲线
****Image(filename="workspace/comparison/Comparison-1/train_loss.png")****
- 验证准确度曲线
****Image(filename="workspace/comparison/Comparison-1/val_accuracy.png")****
- 验证损失曲线
****Image(filename="workspace/comparison/Comparison-1/val_loss.png")****
- 培训时间被占用
****Image(filename="workspace/comparison/Comparison-1/stats_training_time.png")****
- 最大 GPU 使用率
****Image(filename="workspace/comparison/Comparison-1/stats_max_gpu_usage.png")****
- 最佳验证准确性
****Image(filename="workspace/comparison/Comparison-1/stats_best_val_acc.png")****
结论
- Monk library 让学生、研究人员和竞争对手可以非常轻松地创建深度学习模型，并尝试不同的超参数调整来提高模型的准确性。
- 预先训练的模型可以直接下载使用，而无需进入模型创建部分。
- 从上面的图表中，我们可以看到，在这个数据集中，所有层都是可训练的模型比其他模型更准确。但这并不总是正确的，所以直到明智的尝试两者。
- 此外，与仅最后一层可训练的模型相比，所有层可训练时所花费的时间大约多 40%。
感谢阅读。请给出你的建议。
Rohit 是一个 BTech。最后一年学生。他有机器学习和深度学习的知识。他有兴趣在人工智能和人工智能领域工作。目前，他在 Tessellate Imaging 担任计算机视觉实习生。在 LinkedIn 上和他联系。
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
