lépésről lépésre vgg16 implementáció keras kezdőknek

A VGG16 egy konvolúciós neurális háló (CNN ) architektúra, amelyet az ILSVR(Imagenet) verseny megnyerésére használtak 2014-ben. Úgy tartják, hogy az egyik kiváló látás modell architektúra eddig. A legegyedibb dolog a VGG16-ban az, hogy a nagyszámú hiper-paraméter helyett a 3×3 szűrő konvolúciós rétegeire összpontosítottak egy stride 1-vel, és mindig ugyanazt a padding és maxpool réteget használták 2×2 stride 2 szűrővel. A konvolúció és a Max pool rétegek ezen elrendezését következetesen követi az egész architektúrában. A végén 2 FC (teljesen csatlakoztatott rétegek), majd egy softmax kimenet. A 16 a VGG16-ban arra utal, hogy 16 rétege van, amelyek súlyokkal rendelkeznek. Ez a hálózat elég nagy hálózat, és körülbelül 138 millió (kb.) paraméterrel rendelkezik.

a VGG16 architektúrája

a teljes vgg16-ot a semmiből fogom megvalósítani keras-ban. Ez a megvalósítás a kutyák vs macskák adatkészletén történik. Az adatkészletet az alábbi linkről töltheti le.

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

Miután letöltötte a képeket, folytathatja az alábbi lépéseket.

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

itt először importálom az összes könyvtárat, amelyre szükségem lesz a VGG16 megvalósításához. Szekvenciális módszert fogok használni, mivel szekvenciális modellt hozok létre. A szekvenciális modell azt jelenti, hogy a modell összes rétege sorrendben lesz elrendezve. Itt már importált ImageDataGenerator származó keras.előfeldolgozás. Az ImageDataGenerator célja, hogy címkékkel ellátott adatokat egyszerűen importáljon a modellbe. Ez egy nagyon hasznos osztály, mivel számos funkcióval rendelkezik az átméretezéshez, forgatáshoz, nagyításhoz, fliphez stb. A leghasznosabb dolog ebben az osztályban az, hogy nem befolyásolja a lemezen tárolt adatokat. Ez az osztály menet közben megváltoztatja az adatokat, miközben továbbítja azokat a modellnek.

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))

itt létrehozom az ImageDataGenerator objektumát mind a képzési, mind a tesztelési adatok számára, és átadom a trdata objektumnak a vonatadatokat tartalmazó mappát, és hasonlóan átadom a tesztadatokat tartalmazó mappát a tsdata objektumnak. A mappa szerkezet az adatok a következők:

Mappa szerkezet az adatokat át ImageDataGenerator

A ImageDataGenerator automatikusan címke minden adatot be macska a mappába, mint a macska-vis-à-vis a kutya mappát. Ily módon az adatok könnyen készen állnak a neurális hálózat átadására.

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)))

itt a modell inicializálásával kezdtem annak megadásával, hogy a modell szekvenciális modell. Miután inicializálása a modell hozzáadása

→ 2 x konvolúció réteg 64 csatorna 3×3 kernal, illetve azonos padding

→ 1 x maxpool réteg 2×2 medence mérete stride 2×2

→ 2 x konvolúció réteg 128 csatorna 3×3 kernal, illetve azonos padding

→ 1 x maxpool réteg 2×2 medence mérete stride 2×2

→ 3 x konvolúció réteg 256 csatorna 3×3 kernal, illetve azonos padding

→ 1 x maxpool réteg 2×2 medence mérete stride 2×2

→ 3 x konvolúció réteg 512 csatorna 3×3 kernal, illetve azonos padding

→ 1 x maxpool réteg 2×2 medence mérete stride 2×2

3 x konvolúciós réteg 512 csatorna 3×3 kernal és azonos padding

1 x maxpool réteg 2×2 medence mérete és lépés 2×2

azt is hozzá relu(egyenirányított lineáris egység) aktiválás minden réteg úgy, hogy az összes negatív értékek nem kerülnek át a következő réteg.

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

az összes konvolúció létrehozása után átadom az adatokat a sűrű rétegnek, hogy ehhez ellapítsam a konvolúciókból kilépő vektort, és hozzáadom

1 x sűrű, 4096 egységből álló réteg

1 x sűrű, 4096 egységből álló réteg

1 x sűrű, 2 egységből álló Softmax réteg

Relu aktiválást fogok használni mind a 4096 egység sűrű rétegére, hogy megállítsam a negatív értékek továbbítását a hálózaton keresztül. Én használ egy 2 egység sűrű réteg a végén softmax aktiválás, mint én 2 osztályok megjósolni a végén, amelyek kutya és macska. A softmax réteg a 0 és 1 közötti értéket adja ki annak alapján, hogy a modell melyik osztályba tartozik.

a softmax réteg létrehozása után a modell végül elkészül. Most össze kell állítanom a modellt.

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

itt fogom használni Adam optimiser elérni a globális minimumok edzés közben ki modell. Ha edzés közben elakadok a helyi minimumokban, akkor az adam optimiser segít abban, hogy kilépjünk a helyi minimumokból és elérjük a globális minimumokat. Megadjuk az optimalizáló tanulási sebességét is, itt ebben az esetben 0,001-re van beállítva. Ha a képzés pattogó sokat korszakok akkor csökkentenünk kell a tanulási Arány, hogy el tudjuk érni a globális minimumok.

az alábbi kód segítségével ellenőrizhetem az általam létrehozott modell összefoglalását.

model.summary()

ennek kimenete lesz az imént létrehozott modell összefoglalója.

a modell összefoglalása
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=)

a modell létrehozása után importálom a modelcheckpoint és earlystopping metódust a keras-ból. Létrehozok egy objektumot mindkettőből, és ezt visszahívási funkcióként átadom a fit_generator-nak.

a ModelCheckpoint segít a modell mentésében a modell egy adott paraméterének megfigyelésével. Ebben az esetben az érvényesítési pontosságot a Val_acc átadásával a ModelCheckpoint felé irányítom. A modell csak akkor kerül lemezre mentésre, ha a modell érvényesítési pontossága az aktuális korszakban nagyobb, mint az előző korszakban.

az EarlyStopping segít abban, hogy korán leállítsuk a modell edzését, ha nem növekszik a paraméter, amelyet a EarlyStopping során beállítottam. Ebben az esetben az érvényesítési pontosságot a Val_acc átadásával a EarlyStopping felé irányítom. Itt állítottam türelmet 20 ami azt jelenti, hogy a modell megáll a vonat, ha nem látja az érvényesítési pontosság növekedését 20 korszakok.

modellt használok.fit_generator ahogy én használ ImageDataGenerator átadni az adatokat a modell. Átadom a vonat – és tesztadatokat a fit_generátornak. A fit_generator-ban a steps_per_epoch beállítja a köteg méretét, hogy átadja a képzési adatokat a modellnek, a validation_steps pedig ugyanezt teszi a tesztadatoknál. A rendszer specifikációi alapján módosíthatja.

a fenti sor végrehajtása után a modell elkezd edzeni, és elkezdi látni az edzés/érvényesítés pontosságát és veszteségét.

odel

miután betanította a modellt, megjelenítheti az edzés/validálás pontosságát és veszteségét. Mint talán észrevette én halad a kimeneti mód.fit_generator hogy Hist változó. Az összes képzési / validációs pontosságot és veszteséget a hist tárolja, és onnan vizualizálom.

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()

itt vizualizálom az edzés/validálás pontosságát és a veszteséget a matplotlib segítségével.

képzési/validációs pontosság és veszteség

a betanított modellre vonatkozó előrejelzésekhez be kell töltenem a legjobban mentett modellt, elő kell dolgoznom a képet, majd továbbítanom a képet a modellnek a kimenethez.

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')

a modell kimenete

itt betöltöttem a képet a keras image metódusával, és átalakítottam numpy array-re, és hozzáadtam egy extra dimenziót a képhez a keras nhwc (szám, magasság, szélesség, csatorna) formátumának megfelelő formátumához.

Ez a vgg16 teljes megvalósítása keras-ban az ImageDataGenerator használatával. Tudjuk, hogy ez a modell a munka tetszőleges számú osztályok megváltoztatásával az egység utolsó softmax sűrű réteg bármilyen számot akarunk alapján osztályok, amelyek meg kell osztályozni

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

ha kevesebb adatmennyiség, akkor ahelyett, hogy a képzés a modell a semmiből meg lehet próbálni transfer Learning. Azt is írtam egy lépésről lépésre útmutató kezdőknek végző transzfer tanulás VGG16 segítségével Keras. Akkor nézd meg a : https://medium.com/@1297rohit/transfer-learning-from-scratch-using-keras-339834b153b9

Ha lépésről lépésre szeretne tanulni az Arcfelismerésről és az Arcfelismerésről a semmiből, akkor a következő linken érheti el a témáról szóló cikkemet : https://medium.com/@1297rohit/step-by-step-face-recognition-code-implementation-from-scratch-in-python-cc95fa041120

élvezze a besorolást !

Vélemény, hozzászólás?

Az e-mail-címet nem tesszük közzé.