使用 Google Colab 训练的图像分类模型

介绍

图像分类是按照预先确定的原则对图像内的像素组进行分类和识别的过程。在创建分类规则时使用一种或多种光谱或文本质量是可行的。两种流行的分类技术是“有监督的”和“无监督的”。

图像分类如何工作？

使用标记的样本照片，训练模型以检测目标类别（要在图像中识别的对象）。监督学习的一个例子是图像分类。原始像素数据是早期计算机视觉算法的唯一输入。

然而，单独的像素数据并不能提供足够一致的表示来包含图像中表示的项目的许多振荡。对象的位置、其背景、环境照明、相机角度和相机焦距都会影响原始像素数据。

传统的计算机视觉模型添加了源自像素数据的新组件，例如纹理、颜色直方图和形状，以更灵活地对对象进行建模。这种方法的缺点是特征工程变得非常耗时，因为需要更改大量输入。

哪些色调对猫的分类至关重要？形状的定义应该有多灵活？由于特征必须精确地调整，因此很难创建稳健的模型。

训练图像分类模型

本教程使用了一个基本的机器学习工作流程：

· 分析数据集

· 创建输入管道

· 建立模型

· 训练模型

· 分析模型

设置和导入 TensorFlow 和其他库

import itertools

import os

import matplotlib．pylab as plt

import numpy as np

import tensorflow as tf

import tensorflow＿hub as hub

print（＂TF version：＂， tf．＿＿version＿＿）

print（＂Hub version：＂， hub．＿＿version＿＿）

print（＂GPU is＂， ＂available＂ if tf．config．list＿physical＿devices（＇GPU＇） else ＂NOT AVAILABLE＂）

输出如下所示：

选择要使用的 TF2 Saved Model Module

请注意，TF1 Hub 格式的模型在这里不起作用。

有许多模型可以工作。只需从下面单元格中的列表中选择一个不同的选项，然后继续使用Notebook。

在这里，我选择 了 Inception＿v3 并自动从下面的列表中选择图像大小为299 x 299。

model＿name ＝ ＂resnet＿v1＿50＂ ＃ ＠param ［＇efficientnetv2－s＇， ＇efficientnetv2－m＇， ＇efficientnetv2－l＇， ＇efficientnetv2－s－21k＇， ＇efficientnetv2－m－21k＇， ＇efficientnetv2－l－21k＇， ＇efficientnetv2－xl－21k＇， ＇efficientnetv2－b0－21k＇， ＇efficientnetv2－b1－21k＇， ＇efficientnetv2－b2－21k＇， ＇efficientnetv2－b3－21k＇， ＇efficientnetv2－s－21k－ft1k＇， ＇efficientnetv2－m－21k－ft1k＇， ＇efficientnetv2－l－21k－ft1k＇， ＇efficientnetv2－xl－21k－ft1k＇， ＇efficientnetv2－b0－21k－ft1k＇， ＇efficientnetv2－b1－21k－ft1k＇， ＇efficientnetv2－b2－21k－ft1k＇， ＇efficientnetv2－b3－21k－ft1k＇， ＇efficientnetv2－b0＇， ＇efficientnetv2－b1＇， ＇efficientnetv2－b2＇， ＇efficientnetv2－b3＇， ＇efficientnet＿b0＇， ＇efficientnet＿b1＇， ＇efficientnet＿b2＇， ＇efficientnet＿b3＇， ＇efficientnet＿b4＇， ＇efficientnet＿b5＇， ＇efficientnet＿b6＇， ＇efficientnet＿b7＇， ＇bit＿s－r50x1＇， ＇inception＿v3＇， ＇inception＿resnet＿v2＇， ＇resnet＿v1＿50＇， ＇resnet＿v1＿101＇， ＇resnet＿v1＿152＇， ＇resnet＿v2＿50＇， ＇resnet＿v2＿101＇， ＇resnet＿v2＿152＇， ＇nasnet＿large＇， ＇nasnet＿mobile＇， ＇pnasnet＿large＇， ＇mobilenet＿v2＿100＿224＇， ＇mobilenet＿v2＿130＿224＇， ＇mobilenet＿v2＿140＿224＇， ＇mobilenet＿v3＿small＿100＿224＇， ＇mobilenet＿v3＿small＿075＿224＇， ＇mobilenet＿v3＿large＿100＿224＇， ＇mobilenet＿v3＿large＿075＿224＇］

model＿handle＿map ＝ ｛

＂efficientnetv2－s＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿s／feature＿vector／2＂，

＂efficientnetv2－m＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿m／feature＿vector／2＂，

＂efficientnetv2－l＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿l／feature＿vector／2＂，

＂efficientnetv2－s－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿s／feature＿vector／2＂，

＂efficientnetv2－m－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿m／feature＿vector／2＂，

＂efficientnetv2－l－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿l／feature＿vector／2＂，

＂efficientnetv2－xl－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿xl／feature＿vector／2＂，

＂efficientnetv2－b0－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿b0／feature＿vector／2＂，

＂efficientnetv2－b1－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿b1／feature＿vector／2＂，

＂efficientnetv2－b2－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿b2／feature＿vector／2＂，

＂efficientnetv2－b3－21k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿b3／feature＿vector／2＂，

＂efficientnetv2－s－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿s／feature＿vector／2＂，

＂efficientnetv2－m－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿m／feature＿vector／2＂，

＂efficientnetv2－l－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿l／feature＿vector／2＂，

＂efficientnetv2－xl－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿xl／feature＿vector／2＂，

＂efficientnetv2－b0－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿b0／feature＿vector／2＂，

＂efficientnetv2－b1－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿b1／feature＿vector／2＂，

＂efficientnetv2－b2－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿b2／feature＿vector／2＂，

＂efficientnetv2－b3－21k－ft1k＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet21k＿ft1k＿b3／feature＿vector／2＂，

＂efficientnetv2－b0＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿b0／feature＿vector／2＂，

＂efficientnetv2－b1＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿b1／feature＿vector／2＂，

＂efficientnetv2－b2＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿b2／feature＿vector／2＂，

＂efficientnetv2－b3＂： ＂https：／／tfhub．dev／google／imagenet／efficientnet＿v2＿imagenet1k＿b3／feature＿vector／2＂，

＂efficientnet＿b0＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b0／feature－vector／1＂，

＂efficientnet＿b1＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b1／feature－vector／1＂，

＂efficientnet＿b2＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b2／feature－vector／1＂，

＂efficientnet＿b3＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b3／feature－vector／1＂，

＂efficientnet＿b4＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b4／feature－vector／1＂，

＂efficientnet＿b5＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b5／feature－vector／1＂，

＂efficientnet＿b6＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b6／feature－vector／1＂，

＂efficientnet＿b7＂： ＂https：／／tfhub．dev／tensorflow／efficientnet／b7／feature－vector／1＂，

＂bit＿s－r50x1＂： ＂https：／／tfhub．dev／google／bit／s－r50x1／1＂，

＂inception＿v3＂： ＂https：／／tfhub．dev／google／imagenet／inception＿v3／feature－vector／4＂，

＂inception＿resnet＿v2＂： ＂https：／／tfhub．dev／google／imagenet／inception＿resnet＿v2／feature－vector／4＂，

＂resnet＿v1＿50＂： ＂https：／／tfhub．dev／google／imagenet／resnet＿v1＿50／feature－vector／4＂，

＂resnet＿v1＿101＂： ＂https：／／tfhub．dev／google／imagenet／resnet＿v1＿101／feature－vector／4＂，

＂resnet＿v1＿152＂： ＂https：／／tfhub．dev／google／imagenet／resnet＿v1＿152／feature－vector／4＂，

＂resnet＿v2＿50＂： ＂https：／／tfhub．dev／google／imagenet／resnet＿v2＿50／feature－vector／4＂，

＂resnet＿v2＿101＂： ＂https：／／tfhub．dev／google／imagenet／resnet＿v2＿101／feature－vector／4＂，

＂resnet＿v2＿152＂： ＂https：／／tfhub．dev／google／imagenet／resnet＿v2＿152／feature－vector／4＂，

＂nasnet＿large＂： ＂https：／／tfhub．dev／google／imagenet／nasnet＿large／feature＿vector／4＂，

＂nasnet＿mobile＂： ＂https：／／tfhub．dev／google／imagenet／nasnet＿mobile／feature＿vector／4＂，

＂pnasnet＿large＂： ＂https：／／tfhub．dev／google／imagenet／pnasnet＿large／feature＿vector／4＂，

＂mobilenet＿v2＿100＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v2＿100＿224／feature＿vector／4＂，

＂mobilenet＿v2＿130＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v2＿130＿224／feature＿vector／4＂，

＂mobilenet＿v2＿140＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v2＿140＿224／feature＿vector／4＂，

＂mobilenet＿v3＿small＿100＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v3＿small＿100＿224／feature＿vector／5＂，

＂mobilenet＿v3＿small＿075＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v3＿small＿075＿224／feature＿vector／5＂，

＂mobilenet＿v3＿large＿100＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v3＿large＿100＿224／feature＿vector／5＂，

＂mobilenet＿v3＿large＿075＿224＂： ＂https：／／tfhub．dev／google／imagenet／mobilenet＿v3＿large＿075＿224／feature＿vector／5＂，

｝

model＿image＿size＿map ＝ ｛

＂efficientnetv2－s＂： 384，

＂efficientnetv2－m＂： 480，

＂efficientnetv2－l＂： 480，

＂efficientnetv2－b0＂： 224，

＂efficientnetv2－b1＂： 240，

＂efficientnetv2－b2＂： 260，

＂efficientnetv2－b3＂： 300，

＂efficientnetv2－s－21k＂： 384，

＂efficientnetv2－m－21k＂： 480，

＂efficientnetv2－l－21k＂： 480，

＂efficientnetv2－xl－21k＂： 512，

＂efficientnetv2－b0－21k＂： 224，

＂efficientnetv2－b1－21k＂： 240，

＂efficientnetv2－b2－21k＂： 260，

＂efficientnetv2－b3－21k＂： 300，

＂efficientnetv2－s－21k－ft1k＂： 384，

＂efficientnetv2－m－21k－ft1k＂： 480，

＂efficientnetv2－l－21k－ft1k＂： 480，

＂efficientnetv2－xl－21k－ft1k＂： 512，

＂efficientnetv2－b0－21k－ft1k＂： 224，

＂efficientnetv2－b1－21k－ft1k＂： 240，

＂efficientnetv2－b2－21k－ft1k＂： 260，

＂efficientnetv2－b3－21k－ft1k＂： 300，

＂efficientnet＿b0＂： 224，

＂efficientnet＿b1＂： 240，

＂efficientnet＿b2＂： 260，

＂efficientnet＿b3＂： 300，

＂efficientnet＿b4＂： 380，

＂efficientnet＿b5＂： 456，

＂efficientnet＿b6＂： 528，

＂efficientnet＿b7＂： 600，

＂inception＿v3＂： 299，

＂inception＿resnet＿v2＂： 299，

＂nasnet＿large＂： 331，

＂pnasnet＿large＂： 331，

｝

model＿handle ＝ model＿handle＿map．get（model＿name）

pixels ＝ model＿image＿size＿map．get（model＿name， 224）

print（f＂Selected model： ｛model＿name｝ ： ｛model＿handle｝＂）

IMAGE＿SIZE ＝ （pixels， pixels）

print（f＂Input size ｛IMAGE＿SIZE｝＂）

BATCH＿SIZE ＝ 16＃＠param ｛type：＂integer＂｝

输入为所选模块正确缩放。更大的数据集有助于训练，尤其是在微调时（即每次读取图像时图像的随机失真）。

我们的数据集应该如下图所示进行组织。

我们的自定义数据集现在必须上传到云端硬盘。一旦我们的数据集需要扩充，我们必须将数据扩充参数设置为 true。

data＿dir ＝ ＂／content／Images＂

def build＿dataset（subset）：

return tf．keras．preprocessing．image＿dataset＿from＿directory（data＿dir，validation＿split＝．10，subset＝subset，label＿mode＝＂categorical＂，seed＝123，image＿size＝IMAGE＿SIZE，batch＿size＝1）

train＿ds ＝ build＿dataset（＂training＂）

class＿names ＝ tuple（train＿ds．class＿names）

train＿size ＝ train＿ds．cardinality（）．numpy（）

train＿ds ＝ train＿ds．unbatch（）．batch（BATCH＿SIZE）

train＿ds ＝ train＿ds．repeat（）

normalization＿layer ＝ tf．keras．layers．Rescaling（1． ／ 255）

preprocessing＿model ＝ tf．keras．Sequential（［normalization＿layer］）

do＿data＿augmentation ＝ False ＃＠param ｛type：＂boolean＂｝

if do＿data＿augmentation：

preprocessing＿model．add（tf．keras．layers．RandomRotation（40））

preprocessing＿model．add（tf．keras．layers．RandomTranslation（0， 0．2））

preprocessing＿model．add（tf．keras．layers．RandomTranslation（0．2， 0））

＃ Like the old tf．keras．preprocessing．image．ImageDataGenerator（），

＃ image sizes are fixed when reading， and then a random zoom is applied．

＃ RandomCrop with a batch size of 1 and rebatch later．

preprocessing＿model．add（tf．keras．layers．RandomZoom（0．2， 0．2））

preprocessing＿model．add（tf．keras．layers．RandomFlip（mode＝＂horizontal＂））

train＿ds ＝ train＿ds．map（lambda images， labels：（preprocessing＿model（images）， labels））

val＿ds ＝ build＿dataset（＂validation＂）

valid＿size ＝ val＿ds．cardinality（）．numpy（）

val＿ds ＝ val＿ds．unbatch（）．batch（BATCH＿SIZE）

val＿ds ＝ val＿ds．map（lambda images， labels：（normalization＿layer（images）， labels））

输出：

定义模型

所需要做的就是使用 Hub 模块在特征提取器层之上分层线性分类器。

我们最初使用不可训练的特征提取器层来提高速度，但你也可以启用微调以获得更好的精度。

do＿fine＿tuning ＝ True

print（＂Building model with＂， model＿handle）

model ＝ tf．keras．Sequential（［

＃ Explicitly define the input shape so the model can be properly

＃ loaded by the TFLiteConverter

tf．keras．layers．InputLayer（input＿shape＝IMAGE＿SIZE ＋ （3，）），

hub．KerasLayer（model＿handle），

tf．keras．layers．Dropout（rate＝0．2），

tf．keras．layers．Dense（len（class＿names），activation＝＇sigmoid＇，

kernel＿regularizer＝tf．keras．regularizers．l2（0．0001））

］）

model．build（（None，）＋IMAGE＿SIZE＋（3，））

model．summary（）

输出如下

模型训练

model．compile（

optimizer＝tf．keras．optimizers．SGD（learning＿rate＝0．005， momentum＝0．9），

loss＝tf．keras．losses．CategoricalCrossentropy（from＿logits＝True， label＿smoothing＝0．1），

metrics＝［＇accuracy＇］）

steps＿per＿epoch ＝ train＿size ／／ BATCH＿SIZE

validation＿steps ＝ valid＿size ／／ BATCH＿SIZE

hist ＝ model．fit（

train＿ds，

epochs＝50， steps＿per＿epoch＝steps＿per＿epoch，

validation＿data＝val＿ds，

validation＿steps＝validation＿steps）．history

输出如下所示：

训练完成后，我们需要使用以下代码保存模型：

model．save （＂save＿locationmodelname．h5＂）

结论

这篇博文使用卷积神经网络（CNN） 根据图片的视觉内容对图片进行分类。该数据集用于测试和训练 CNN。其准确率大于 98％。我们必须使用微小的灰度图像作为我们的教学资源。与其他常规 JPEG 照片相比，这些照片需要大量的处理时间。用于在 GPU 集群上训练网络的具有更多层和更多图片数据的模型将更准确地对图像进行分类。未来的发展将集中在对图像分割过程非常有用的巨大彩色图像的分类上。

关键要点

· 图像分类是计算机视觉的一个分支，它使用一组经过算法训练的指定标签或类别对图像内的像素或矢量集进行分类和标记。

· 可以区分有监督和无监督分类。

· 在监督分类中，分类算法使用一组图像及其相关标签进行训练。

· 无监督分类算法仅使用原始数据进行训练。

· 你需要大量具有准确标记数据的数据集来创建值得信赖的图片分类器。

原文标题:使用 Google Colab 训练的图像分类模型