Trinnvis vgg16 implementering I Keras for nybegynnere

VGG16 ER en convolution neural net (CNN ) arkitektur som ble brukt til å vinne ILSVR (Imagenet) konkurranse i 2014. Det anses å være en av de utmerkede visjonsmodellarkitekturen til dato. Mest unike ting OM VGG16 er at i stedet for å ha et stort antall hyper-parameter de fokusert på å ha konvolusjon lag av 3×3 filter med en skrittlengde 1 og alltid brukt samme polstring og maxpool lag av 2×2 filter av skrittlengde 2. Det følger dette arrangementet av convolution og max pool lag konsekvent gjennom hele arkitekturen. Til slutt har den 2 FC (fullt tilkoblede lag) etterfulgt av en softmax for utgang. 16 I VGG16 refererer til den har 16 lag som har vekter. Dette nettverket er et ganske stort nettverk, og det har ca 138 millioner (ca) parametere.

Arkitektur AV VGG16

jeg skal implementere full vgg16 fra bunnen av i keras. Dette implementerer vil bli gjort På Hunder vs Katter datasett. Du kan laste ned datasettet fra linken nedenfor.

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

når du har lastet ned bildene, kan du fortsette med trinnene som er skrevet nedenfor.

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 bibliotekene som JEG må implementere VGG16. Jeg vil bruke Sekvensiell metode som jeg lager en sekvensiell modell. Sekvensiell modell betyr at alle lagene i modellen vil bli arrangert i rekkefølge. Her har jeg importert ImageDataGenerator fra keras.forbehandling. Målet Med ImageDataGenerator er å importere data med etiketter enkelt inn i modellen. Det er en veldig nyttig klasse som den har mange funksjon for å skalere, rotere, zoome, vende etc. Den mest nyttige tingen om denne klassen er at den ikke påvirker dataene som er lagret på disken. Denne klassen endrer dataene på farten mens du sender den 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 lager jeg og objekt Av ImageDataGenerator for både trening og testing av data og passerer mappen som har togdata til objektet trdata og på samme måte passerer mappen som har testdata til objektet tsdata. Mappestrukturen til dataene vil være som følger –

>

mappestruktur av dataene som sendes til imagedatagenerator

imagedatagenerator vil automatisk merke alle dataene i cat-mappen som cat og vis-à-vis for dog-mappen. På denne måten er data lett klar til å bli sendt til det nevrale nettverket.

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 har jeg startet med å initialisere modellen ved å angi at modellen er en sekvensiell modell. Når du initialiserer den modellen jeg vil legge til

→ 2 x ferdige laget av 64 kanal for 3×3 kernal og samme polstring

→ 1 x maxpool lag av 2×2 bassenget størrelse og form 2×2

→ 2 x ferdige laget av 128 kanal for 3×3 kernal og samme polstring

→ 1 x maxpool lag av 2×2 bassenget størrelse og form 2×2

→ 3 x ferdige lag med 256-kanal for 3×3 kernal og samme polstring

→ 1 x maxpool lag av 2×2 bassenget størrelse og form 2×2

→ 3 x ferdige laget av 512 kanal for 3×3 kernal og samme polstring

→ 1 x maxpool lag av 2×2 bassenget størrelse og form 2×2

→ 3 x konvolusjonslag av 512 kanal av 3×3 kjerne og samme polstring

→ 1 x maxpool lag av 2×2 bassengstørrelse og stride 2×2

jeg legger også til relu(Rettet Lineær Enhet) aktivering til hvert lag slik at alle negative verdier ikke overføres til neste 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"))

etter å ha opprettet all konvolusjonen sender jeg dataene til det tette laget slik at jeg flater vektoren som kommer ut av konvoluttene og legger til

→ 1 x Tett lag av 4096 enheter

→ 1 X Tett Softmax lag av 2 enheter

JEG vil bruke RELU aktivering for både det tette laget av 4096 enheter slik at jeg slutter å videresende negative verdier gjennom nettverket. Jeg bruker en 2 enhet tett lag til slutt med softmax aktivering som jeg har 2 klasser å forutsi fra til slutt som er hund og katt. Softmax-laget vil sende ut verdien mellom 0 og 1 basert på modellens tillit til hvilken klasse bildene tilhører.

etter opprettelsen av softmax-laget er modellen endelig forberedt. Nå må jeg kompilere modellen.

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

Her skal jeg bruke Adam optimiser å nå til den globale minima mens trening ut modell. Hvis jeg sitter fast i lokale minima mens trening da adam optimiser vil hjelpe oss å komme ut av lokale minima og nå globale minima. Vi vil også spesifisere læringshastigheten til optimisatoren, her i dette tilfellet er den satt til 0,001. Hvis vår trening hopper mye på epoker, må vi redusere læringshastigheten slik at vi kan nå globale minima.

jeg kan sjekke sammendraget av modellen som jeg opprettet ved å bruke koden nedenfor.

model.summary()

utgangen av dette vil være sammendraget av modellen som jeg nettopp opprettet.

Oppsummering av 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=)

etter opprettelsen av modellen vil jeg importere modelcheckpoint og earlystopping-metoden fra keras. Jeg vil lage et objekt av begge og passere det som tilbakeringingsfunksjoner til fit_generator.

ModelCheckpoint hjelper oss med å lagre modellen ved å overvåke en bestemt parameter av modellen. I dette tilfellet overvåker jeg valideringsnøyaktighet ved å sende val_acc Til ModelCheckpoint. Modellen vil bare bli lagret på disk hvis valideringsnøyaktigheten til modellen i gjeldende epoke er større enn hva den var i forrige epoke.EarlyStopping hjelper oss å stoppe treningen av modellen tidlig hvis det ikke er noen økning i parameteren som jeg har satt til å overvåke I EarlyStopping. I dette tilfellet overvåker jeg valideringsnøyaktighet ved å sende val_acc Til EarlyStopping. Jeg har her satt tålmodighet til 20, noe som betyr at modellen vil slutte å trene hvis den ikke ser noen økning i valideringsnøyaktighet i 20 epoker.

jeg bruker modell.fit_generator som jeg bruker ImageDataGenerator til å sende data til modellen. Jeg vil passere tog og testdata til fit_generator. I fit_generator vil steps_per_epoch sette batchstørrelsen for å passere treningsdata til modellen, og validation_steps vil gjøre det samme for testdata. Du kan justere den basert på systemspesifikasjonene dine.

etter å ha kjørt over linjen modellen vil begynne å trene, og du vil begynne å se trening/validering nøyaktighet og tap.

div modell

når du har trent modellen kan du visualisere trening/validering nøyaktighet og tap. Som du kanskje har lagt merke til, passerer jeg utgangen av modus.fit_generator til hist variabel. All trening / validering nøyaktighet og tap er lagret 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 trening / validering nøyaktighet og tap ved hjelp av matplotlib.

trening/validering nøyaktighet og tap

for å gjøre spådommer på den trente modellen må jeg laste den beste lagrede modellen og pre-behandle bildet og sende bildet til modellen for utgang.

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>

utgang av modellen

her har jeg lastet bildet ved hjelp av bildemetode i keras og konvertert det til numpy array og lagt til en ekstra dimensjon til bildet til bildet for å matche nhwc (tall, høyde, bredde, kanal) format av keras.

Dette er en komplett implementering AV VGG16 i keras ved Hjelp Av ImageDataGenerator. Vi kan få denne modellen til å fungere for et hvilket som helst antall klasser ved å endre enheten til det siste softmax tette laget til det nummeret vi ønsker basert på klassene som vi trenger å klassifisere

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

hvis du har mindre mengde data, kan du i stedet for å trene modellen din fra bunnen av, prøve Å Overføre Læring. Jeg har også skrevet en trinnvis guide for nybegynnere på å utføre overføringslæring PÅ VGG16 ved Hjelp Av Keras. Du kan sjekke det ut på : https://medium.com/@1297rohit/transfer-learning-from-scratch-using-keras-339834b153b9

hvis du ønsker å lære trinn for trinn Om Ansiktsgjenkjenning og Ansiktsgjenkjenning fra bunnen av så kan du gå over til min artikkel om dette emnet på linken:https://medium.com/@1297rohit/step-by-step-face-recognition-code-implementation-from-scratch-in-python-cc95fa041120

Nyt Klassifisering !

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert.