介紹

圖像分類是按照預(yù)先確定的原則對圖像內(nèi)的像素組進行分類和識別的過程。在創(chuàng)建分類規(guī)則時使用一種或多種光譜或文本質(zhì)量是可行的。兩種流行的分類技術(shù)是“有監(jiān)督的”和“無監(jiān)督的”。

圖像分類如何工作？

使用標(biāo)記的樣本照片，訓(xùn)練模型以檢測目標(biāo)類別（要在圖像中識別的對象）。監(jiān)督學(xué)習(xí)的一個例子是圖像分類。原始像素數(shù)據(jù)是早期計算機視覺算法的唯一輸入。

然而，單獨的像素數(shù)據(jù)并不能提供足夠一致的表示來包含圖像中表示的項目的許多振蕩。對象的位置、其背景、環(huán)境照明、相機角度和相機焦距都會影響原始像素數(shù)據(jù)。

傳統(tǒng)的計算機視覺模型添加了源自像素數(shù)據(jù)的新組件，例如紋理、顏色直方圖和形狀，以更靈活地對對象進行建模。這種方法的缺點是特征工程變得非常耗時，因為需要更改大量輸入。

哪些色調(diào)對貓的分類至關(guān)重要？形狀的定義應(yīng)該有多靈活？由于特征必須精確地調(diào)整，因此很難創(chuàng)建穩(wěn)健的模型。

訓(xùn)練圖像分類模型

本教程使用了一個基本的機器學(xué)習(xí)工作流程：

· 分析數(shù)據(jù)集

· 創(chuàng)建輸入管道

· 建立模型

· 訓(xùn)練模型

· 分析模型

設(shè)置和導(dǎo)入 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 格式的模型在這里不起作用。

有許多模型可以工作。只需從下面單元格中的列表中選擇一個不同的選項，然后繼續(xù)使用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＂｝

輸入為所選模塊正確縮放。更大的數(shù)據(jù)集有助于訓(xùn)練，尤其是在微調(diào)時（即每次讀取圖像時圖像的隨機失真）。

我們的數(shù)據(jù)集應(yīng)該如下圖所示進行組織。

我們的自定義數(shù)據(jù)集現(xiàn)在必須上傳到云端硬盤。一旦我們的數(shù)據(jù)集需要擴充，我們必須將數(shù)據(jù)擴充參數(shù)設(shè)置為 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．a(chǎn)dd（tf．keras．layers．RandomRotation（40））

 preprocessing＿model．a(chǎn)dd（tf．keras．layers．RandomTranslation（0， 0．2））

 preprocessing＿model．a(chǎn)dd（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．a(chǎn)dd（tf．keras．layers．RandomZoom（0．2， 0．2））

 preprocessing＿model．a(chǎn)dd（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 模塊在特征提取器層之上分層線性分類器。

我們最初使用不可訓(xùn)練的特征提取器層來提高速度，但你也可以啟用微調(diào)以獲得更好的精度。

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（）

輸出如下

模型訓(xùn)練

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

輸出如下所示：

訓(xùn)練完成后，我們需要使用以下代碼保存模型：

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

結(jié)論

這篇博文使用卷積神經(jīng)網(wǎng)絡(luò)（CNN） 根據(jù)圖片的視覺內(nèi)容對圖片進行分類。該數(shù)據(jù)集用于測試和訓(xùn)練 CNN。其準確率大于 98％。我們必須使用微小的灰度圖像作為我們的教學(xué)資源。與其他常規(guī) JPEG 照片相比，這些照片需要大量的處理時間。用于在 GPU 集群上訓(xùn)練網(wǎng)絡(luò)的具有更多層和更多圖片數(shù)據(jù)的模型將更準確地對圖像進行分類。未來的發(fā)展將集中在對圖像分割過程非常有用的巨大彩色圖像的分類上。

關(guān)鍵要點

· 圖像分類是計算機視覺的一個分支，它使用一組經(jīng)過算法訓(xùn)練的指定標(biāo)簽或類別對圖像內(nèi)的像素或矢量集進行分類和標(biāo)記。

· 可以區(qū)分有監(jiān)督和無監(jiān)督分類。

· 在監(jiān)督分類中，分類算法使用一組圖像及其相關(guān)標(biāo)簽進行訓(xùn)練。

· 無監(jiān)督分類算法僅使用原始數(shù)據(jù)進行訓(xùn)練。

· 你需要大量具有準確標(biāo)記數(shù)據(jù)的數(shù)據(jù)集來創(chuàng)建值得信賴的圖片分類器。

       原文標(biāo)題 : 使用 Google Colab 訓(xùn)練的圖像分類模型