trin for trin vgg16 implementering i Keras for begyndere

VGG16 er en convolution neural net (CNN ) arkitektur, der blev brugt til at vinde ILSVR(Imagenet) konkurrence i 2014. Det anses for at være en af de fremragende vision model arkitektur indtil dato. Mest unikke ting ved VGG16 er, at i stedet for at have et stort antal hyper-parameter, de fokuserede på at have foldning lag af 3H3 filter med et skridt 1 og altid brugt samme polstring og makspool lag af 2H2 filter af skridt 2. Det følger dette arrangement af foldning og maksimale poollag konsekvent gennem hele arkitekturen. I sidste ende har den 2 FC(fuldt tilsluttede lag) efterfulgt af en softmaks til udgang. 16 i VGG16 henviser til, at den har 16 lag, der har vægte. Dette netværk er et ret stort netværk, og det har omkring 138 millioner (ca.) parametre.

arkitektur af VGG16

jeg skal implementere fuld vgg16 fra bunden i keras. Dette redskab vil blive gjort på hunde vs katte datasæt. Du kan hente datasættet fra nedenstående link.

https://www.kaggle.com/c/dogs-vs-cats/data

Når du har hentet billederne, kan du fortsætte med nedenstående trin.

import keras,os
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D , Flatten
from keras.preprocessing.image import ImageDataGenerator
import numpy as np

Her importerer jeg først alle de biblioteker, som jeg skal implementere VGG16. Jeg vil bruge sekventiel metode, da jeg opretter en sekventiel model. Sekventiel model betyder, at alle lagene i modellen vil blive arrangeret i rækkefølge. Her har jeg importeret ImageDataGenerator fra keras.forbehandlingsfasen. Formålet med ImageDataGenerator er at importere data med etiketter nemt ind i modellen. Det er en meget nyttig klasse, da den har mange funktioner til at omskalere, rotere, forstørre, vende osv. Det mest nyttige ved denne klasse er, at det ikke påvirker de data, der er gemt på disken. Denne klasse ændrer dataene på farten, mens de overføres til modellen.

trdata = ImageDataGenerator()
traindata = trdata.flow_from_directory(directory="data",target_size=(224,224))
tsdata = ImageDataGenerator()
testdata = tsdata.flow_from_directory(directory="test", target_size=(224,224))

Her opretter jeg og objekt for ImageDataGenerator til både Trænings-og testdata og passerer den mappe, der har togdata til objektet trdata og på samme måde passerer den mappe, der har testdata til objektet tsdata. Mappestrukturen for dataene vil være som følger –

mappestruktur af de data, der skal sendes til imagedatagenerator

imagedatageneratoren vil automatisk mærke alle data inde i Cat-mappen som Cat og vis-Kurt-vis for dog folder. På denne måde er data let klar til at blive videregivet til det neurale netværk.

model = Sequential()model.add(Conv2D(input_shape=(224,224,3),filters=64,kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=64,kernel_size=(3,3),padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))

Her er jeg begyndt med at initialisere modellen ved at angive, at modellen er en sekventiel model. Efter initialisering den model, som jeg tilføje

→ 2 x foldning lag af 64 kanal 3×3 kernal og samme padding

→ 1 x maxpool lag af 2×2 pool størrelse og skridtlængde 2×2

→ 2 x foldning lag af 128 kanal 3×3 kernal og samme padding

→ 1 x maxpool lag af 2×2 pool størrelse og skridtlængde 2×2

→ 3 x foldning lag af 256 kanal 3×3 kernal og samme padding

→ 1 x maxpool lag af 2×2 pool størrelse og skridtlængde 2×2

→ 3 x foldning lag af 512 kanal 3×3 kernal og samme padding

→ 1 x maxpool lag af 2×2 pool størrelse og skridtlængde 2×2

512 512 kanal foldning 3H3 kernal og samme polstring

1 h makspool lag 2H2 pool størrelse og skridt 2H2

Jeg tilføjer også relu(Rectified Linear Unit) aktivering til hvert lag, så alle de negative værdier ikke overføres til det næste lag.

model.add(Flatten())model.add(Dense(units=4096,activation="relu"))model.add(Dense(units=4096,activation="relu"))model.add(Dense(units=2, activation="softmax"))

efter oprettelse af al konvolvering overfører jeg dataene til det tætte lag, så for at jeg flader vektoren, der kommer ud af konvolutterne, og tilføjer

list 1 tæt lag på 4096 enheder

list 1 tæt lag på 4096 enheder

list 1 tæt Softmaks lag på 2 enheder

Jeg vil bruge RELU-aktivering til at både det tætte lag på 4096 enheder, så jeg holder op med at videresende negative værdier gennem netværket. Jeg bruger en 2 enhed tæt lag i slutningen med softmaks aktivering som jeg har 2 klasser til at forudsige fra i sidste ende, som er hund og kat. Softmaks-laget udsender værdien mellem 0 og 1 baseret på modelens tillid, hvilken klasse billederne tilhører.

efter oprettelsen af softmaks lag modellen er endelig forberedt. Nu skal jeg kompilere modellen.

from keras.optimizers import Adam
opt = Adam(lr=0.001)model.compile(optimizer=opt, loss=keras.losses.categorical_crossentropy, metrics=)

Her vil jeg bruge Adam optimiser til at nå de globale minima, mens jeg træner model. Hvis jeg sidder fast i lokale minima under træning, vil adam optimiser hjælpe os med at komme ud af lokale minima og nå globale minima. Vi vil også specificere optimisatorens læringshastighed, her i dette tilfælde er den sat til 0,001. Hvis vores træning hopper meget på epoker, er vi nødt til at reducere læringshastigheden, så vi kan nå globale minima.

Jeg kan kontrollere resumeet af modellen, som jeg oprettede ved hjælp af koden nedenfor.

model.summary()

udgangen af dette vil være resumeet af den model, som jeg lige har oprettet.

oversigt over modellen
from keras.callbacks import ModelCheckpoint, EarlyStoppingcheckpoint = ModelCheckpoint("vgg16_1.h5", monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)early = EarlyStopping(monitor='val_acc', min_delta=0, patience=20, verbose=1, mode='auto')hist = model.fit_generator(steps_per_epoch=100,generator=traindata, validation_data= testdata, validation_steps=10,epochs=100,callbacks=)

efter oprettelsen af modellen vil jeg importere modelcheckpoint og earlystopping metode fra keras. Jeg vil oprette et objekt af begge og videregive det som tilbagekaldsfunktioner til fit_generator.

ModelCheckpoint hjælper os med at gemme modellen ved at overvåge en bestemt parameter for modellen. I dette tilfælde overvåger jeg valideringsnøjagtighed ved at passere val_acc til ModelCheckpoint. Modellen gemmes kun på disken, hvis valideringsnøjagtigheden af modellen i den aktuelle epoke er større end hvad den var i den sidste epoke.

EarlyStopping hjælper os med at stoppe træningen af modellen tidligt, hvis der ikke er nogen stigning i den parameter, som jeg har indstillet til at overvåge i EarlyStopping. I dette tilfælde overvåger jeg valideringsnøjagtighed ved at passere val_acc til EarlyStopping. Jeg har her sat tålmodighed til 20 hvilket betyder, at modellen vil stoppe for at træne, hvis den ikke ser nogen stigning i valideringsnøjagtighed i 20 epoker.

Jeg bruger model.fit_generator som jeg bruger ImageDataGenerator til at videregive data til modellen. Jeg vil passere tog og test data til fit_generator. I fit_generator steps_per_epoch indstiller batchstørrelsen til at videregive træningsdata til modellen, og validation_steps vil gøre det samme for testdata. Du kan justere det baseret på dine systemspecifikationer.

efter at have udført ovenstående linje begynder modellen at træne, og du vil begynde at se Trænings – /valideringsnøjagtigheden og tabet.

træning af model

når du har trænet modellen, kan du visualisere Trænings – / valideringsnøjagtighed og tab. Som du måske har bemærket, passerer jeg output fra mode.fit_generator til hist variabel. Al træning/valideringsnøjagtighed og tab gemmes i hist, og jeg vil visualisere det derfra.

import matplotlib.pyplot as plt
plt.plot(hist.history)
plt.plot(hist.history)
plt.plot(hist.history)
plt.plot(hist.history)
plt.title("model accuracy")
plt.ylabel("Accuracy")
plt.xlabel("Epoch")
plt.legend()
plt.show()

Her vil jeg visualisere træning/valideringsnøjagtighed og tab ved hjælp af matplotlib.

træning/Validering nøjagtighed og tab

for at gøre forudsigelser på den uddannede model skal jeg indlæse den bedst gemte model og forbehandle billedet og videregive billedet til modellen til output.

from keras.preprocessing import imageimg = image.load_img("image.jpeg",target_size=(224,224))
img = np.asarray(img)
plt.imshow(img)
img = np.expand_dims(img, axis=0)from keras.models import load_model
saved_model = load_model("vgg16_1.h5")output = saved_model.predict(img)
if output > output:
print("cat")
else:
print('dog')

div >

output af modellen

Her har jeg indlæst billedet ved hjælp af billedmetode i keras og konverteret det til numpy array og tilføjet en ekstra dimension til billedet til billede for at matche nhvc (nummer, højde, bredde, kanal) format af keras.

dette er en komplet implementering af VGG16 i keras ved hjælp af ImageDataGenerator. Vi kan få denne model til at fungere for et hvilket som helst antal klasser ved at ændre enheden for det sidste softmaks tætte lag til det antal, vi ønsker, baseret på de klasser, som vi har brug for at klassificere

Github repo link : https://github.com/1297rohit/VGG16-In-Keras

Hvis du har mindre mængde data, kan du i stedet for at træne din model fra bunden prøve at overføre læring. Jeg har også skrevet en trinvis vejledning til begyndere om udførelse af overførselsindlæring på VGG16 ved hjælp af Keras. Du kan tjekke det ud på : https://medium.com/@1297rohit/transfer-learning-from-scratch-using-keras-339834b153b9

Hvis du gerne vil lære trin for trin om ansigtsgenkendelse og ansigtsgenkendelse fra bunden, kan du gå over til min artikel om dette emne på linket : https://medium.com/@1297rohit/step-by-step-face-recognition-code-implementation-from-scratch-in-python-cc95fa041120

Nyd klassificering !

Skriv et svar

Din e-mailadresse vil ikke blive publiceret.