Keras opetusohjelma
Evelyn Clarke
Mikä on Keras?
Keras on avoimen lähdekoodin hermoverkkokirjasto, joka on kirjoitettu sisään Python joka kulkee Theanon tai Tensorflow:n päällä. Se on suunniteltu modulaariseksi, nopeaksi ja helppokäyttöiseksi. Sen on kehittänyt François Chollet, Googlen insinööri. Keras ei käsittele matalan tason laskentaa. Sen sijaan se käyttää toista kirjastoa, nimeltään "Backend.
Keras on korkean tason API-kääre matalan tason API:lle, joka pystyy toimimaan TensorFlow-, CNTK- tai Theanon päällä. Keras High-Level API käsittelee tapaa, jolla teemme malleja, määritämme tasoja tai määritämme useita syöttö-lähtömalleja. Tällä tasolla Keras kokoaa myös mallimme häviö- ja optimointitoiminnoilla, harjoitusprosessin sovitustoiminnolla. Keras sisään Python ei käsittele matalan tason API:ta, kuten laskennallisen graafin tekemistä, tensorien tai muiden muuttujien tekemistä, koska "taustakone" on käsitellyt niitä.
Mikä on taustaohjelma?
Backend on Kerasissa termi, joka suorittaa kaiken matalan tason laskennan, kuten tensoritulot, konvoluutit ja monet muut asiat muiden kirjastojen, kuten Tensorflow tai Theano, avulla. Joten "taustamoottori" suorittaa mallien laskennan ja kehittämisen. Tensorflow on oletusarvoinen "taustamoottori", mutta voimme muuttaa sitä kokoonpanossa.
Theano, Tensorflow ja CNTK backend
Theano on avoimen lähdekoodin projekti, jonka on kehittänyt MILA-ryhmä Montrealin yliopistossa Quebecissä, Kanadassa. Se oli ensimmäinen laajalti käytetty Framework. Se on a Python kirjasto, joka auttaa moniulotteisissa taulukoissa matemaattisia operaatioita varten Numpyn tai Scipyn avulla. Theano voi käyttää GPU:ita nopeampaan laskentaan, se voi myös rakentaa automaattisesti symbolisia kaavioita gradienttien laskemiseen. Theano väittää verkkosivustollaan, että se tunnistaa numeerisesti epävakaat lausekkeet ja laskee ne vakaammilla algoritmeilla, mikä on erittäin hyödyllistä epävakaille lausekkeillemme.
Toisaalta Tensorflow on nouseva tähti syvän oppimisen viitekehyksessä. Googlen Brain-tiimin kehittämä se on suosituin syväoppimistyökalu. Monien ominaisuuksien ansiosta tutkijat auttavat kehittämään tätä puitteet syvään oppimiseen.
Toinen Kerasin taustamoottori on The Microsoft Kognitiivinen työkalupakki tai CNTK. Se on avoimen lähdekoodin syväoppimiskehys, jonka on kehittänyt Microsoft Tiimi. Se voi toimia useilla GPU:illa tai useilla koneilla syvän oppimismallin harjoittamiseksi massiivisessa mittakaavassa. Joissakin tapauksissa CNTK ilmoitettiin nopeammin kuin muut puitteet, kuten Tensorflow tai Theano. Seuraavaksi tässä Keras CNN -opetusohjelmassa vertaamme Theanon, TensorFlown ja CNTK:n taustaohjelmia.
Taustaohjelmien vertailu
Meidän on tehtävä vertailu, jotta voimme tietää vertailun näiden kahden taustaohjelman välillä. Kuten näette Jeong-Yoon Leen vertailukohta, verrataan kolmen eri taustaohjelman suorituskykyä eri laitteilla. Ja tuloksena on, että Theano on hitaampi kuin toinen taustajärjestelmä, kerrotaan 50 kertaa hitaammin, mutta tarkkuus on lähellä toisiaan.
Toinen vertailutesti suorittaa Jasmeet Bhatia. Hän kertoi, että Theano on hitaampi kuin Tensorflow jossain testissä. Mutta yleinen tarkkuus on lähes sama jokaisessa testatussa verkossa.
Joten Theanon, Tensorflow:n ja CTK:n välillä on selvää, että TensorFlow on parempi kuin Theano. TensorFlow'lla laskenta-aika on paljon lyhyempi ja CNN on muita parempi.
Seuraavaksi tässä Kerassa Python opetusohjelmassa opimme erosta Kerasin ja TensorFlow'n välillä (Keras vs Tensorflow).
Keras vs Tensorflow
| parametrit | Keras | Tensorflow |
|---|---|---|
| Tyyppi | Korkean tason API-kääre | Matalan tason API |
| Monimutkaisuus | Helppo käyttää, jos Python Kieli | Sinun on opittava joidenkin Tensorflow-funktioiden käytön syntaksi |
| Tarkoitus | Nopea käyttöönotto mallin tekemiseen vakiokerroksilla | Mahdollistaa mielivaltaisen laskennallisen kaavion tai mallikerroksen tekemisen |
| Työkalut | Käyttää muuta API-virheenkorjaustyökalua, kuten TFDBG | Voit käyttää Tensorboardin visualisointityökaluja |
| yhteisö | Suuret aktiiviset yhteisöt | Suuret aktiiviset yhteisöt ja laajasti jaetut resurssit |
Keran edut
Nopea käyttöönotto ja helppo ymmärtää
Keras on erittäin nopea tehdä verkkomallin. Jos haluat tehdä yksinkertaisen verkkomallin, jossa on muutama rivi, Python Keras voi auttaa sinua tässä. Katso Keras-esimerkki alla:
from keras.models import Sequential from keras.layers import Dense, Activation model = Sequential() model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50 model.add(Dense(28, activation='relu')) #input shape of 50 model.add(Dense(10, activation='softmax'))
Ystävällisen API:n ansiosta ymmärrämme prosessin helposti. Koodin kirjoittaminen yksinkertaisella toiminnolla, eikä useita parametreja tarvitse asettaa.
Suuri yhteisön tuki
Monet tekoälyyhteisöt käyttävät Kerasta Deep Learning -kehykseensä. Monet heistä julkaisevat koodinsa sekä opetusohjelmansa suurelle yleisölle.
Sinulla on useita taustaohjelmia
Voit valita Tensorflow-, CNTK- ja Theanon taustaohjelmaksi Kerasin kanssa. Voit valita eri taustaohjelman erilaisille projekteille tarpeidesi mukaan. Jokaisella taustalla on oma ainutlaatuinen etunsa.
Monialustainen ja helppo mallin käyttöönotto
Useiden tuettujen laitteiden ja alustojen avulla voit ottaa Kerasin käyttöön kaikilla laitteilla, kuten
- iOS CoreML:llä
- Android Tensorflowin kanssa Android,
- Web-selain .js-tuella
- Pilvi moottori
- Raspberry Pi
Useiden GPU:iden tuki
Voit harjoitella Kerasta yhdellä grafiikkasuorittimella tai käyttää useita GPU:ita kerralla. Koska Kerasissa on sisäänrakennettu tuki tietojen rinnakkaisuudelle, joten se pystyy käsittelemään suuria tietomääriä ja nopeuttamaan sen kouluttamiseen tarvittavaa aikaa.
Keran huonot puolet
Ei voi käsitellä matalan tason APIa
Keras käsittelee vain korkean tason API:ta, joka toimii muissa puitteissa tai taustakoneissa, kuten Tensorflow, Theano tai CNTK. Joten se ei ole kovin hyödyllistä, jos haluat tehdä oman abstraktin kerroksen tutkimustarkoituksiin, koska Kerassa on jo valmiiksi määritettyjä tasoja.
Keran asennus
Tässä osiossa tarkastellaan erilaisia Keras-asennustapoja
Suora asennus tai virtuaaliympäristö
Kumpi on parempi? Asennetaanko suoraan nykyiseen pythoniin vai käytetäänkö virtuaalista ympäristöä? Suosittelen käyttämään virtuaaliympäristöä, jos sinulla on monia projekteja. Haluatko tietää miksi? Tämä johtuu siitä, että eri projektit voivat käyttää eri versiota keras-kirjastosta.
Minulla on esimerkiksi projekti, joka tarvitsee Python 3.5 käyttäen OpenCV 3.3:a vanhemman Keras-Theano-taustajärjestelmän kanssa, mutta toisessa projektissa minun on käytettävä Kerasta uusimmalla versiolla ja Tensorflow-taustaohjelmalla. Python 3.6.6-tuki
Emmekö halua, että Keras-kirjasto on ristiriidassa toistensa kanssa? Käytämme siis virtuaaliympäristöä lokalisoidaksemme projektin tietyntyyppisellä kirjastolla tai voimme käyttää toista alustaa, kuten pilvipalvelua, suorittaaksemme laskentamme puolestamme, kuten Amazon Verkkopalvelu.
Kerasin asennus Amazon Verkkopalvelu (AWS)
Amazon Web Service on alusta, joka tarjoaa Cloud Computing -palvelua ja -tuotteita tutkijoille tai mihin tahansa muuhun tarkoitukseen. AWS vuokraa laitteistonsa, verkkonsa, tietokantansa jne. jotta voimme käyttää niitä suoraan Internetistä. Yksi suosituista syväoppimisen AWS-palveluista on Amazon Machine Image Deep Learning Service tai DL
Katso tästä yksityiskohtaiset ohjeet AWS:n käytöstä oppitunti
Huomautus AMI:stä: Käytettävissäsi on seuraava AMI
AWS Deep Learning AMI on AWS EC2 -palvelun virtuaalinen ympäristö, joka auttaa tutkijoita tai harjoittajia työskentelemään Deep Learningin kanssa. DLAMI tarjoaa pienistä suorittimista suuritehoisiin usean näytönohjaimen moottoreihin, joissa on esikonfiguroitu CUDA, cuDNN, ja mukana tulee useita syvällisiä oppimiskehyksiä.
Jos haluat käyttää sitä välittömästi, sinun kannattaa valita Deep Learning AMI, koska siihen on esiasennettu suosittuja syväoppimiskehyksiä.
Mutta jos haluat kokeilla mukautettua syväoppimiskehystä tutkimukseen, sinun tulee asentaa Deep Learning Base AMI, koska sen mukana tulee peruskirjastot, kuten CUDA, cuDNN, GPU-ohjaimet ja muut tarvittavat kirjastot toimiakseen syvän oppimisympäristösi kanssa.
Kuinka Keras asennetaan Amazon SageMaker
Amazon SageMaker on syväoppimisalusta, joka auttaa sinua koulutuksessa ja syväoppimisverkoston käyttöönotossa parhaalla algoritmilla.
Aloittelijana tämä on ylivoimaisesti helpoin tapa käyttää Kerasta. Alla on prosessi Kerasin asentamiseen Amazon SageMaker:
Vaihe 1) Avaa Amazon SageMaker
Avaa ensimmäisessä vaiheessa Amazon Sagemaker konsoli ja napsauta Luo muistikirjan esiintymä.
Vaihe 2) Anna tiedot
- Kirjoita muistikirjasi nimi.
- Luo IAM-rooli. Se luo AMI-roolin Amazon IAM-rooli muodossa AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
- Valitse lopuksi Luo muistikirjan esiintymä. Muutaman hetken kuluttua Amazon Sagemaker lanseeraa kannettavan ilmentymän.
Huomautuksia: Jos haluat käyttää VPC:n resursseja, aseta suora Internet-yhteys käyttöön. Muutoin tällä kannettavalla instanssilla ei ole Internet-yhteyttä, joten malleja on mahdotonta kouluttaa tai isännöidä
Vaihe 3) Käynnistä ilmentymä
Napsauta Avaa käynnistääksesi ilmentymä
Vaihe 4) Aloita koodaus
In Jupyter, Napsauta Uusi> conda_tensorflow_p36 ja olet valmis koodaamaan
Asenna Keras Linuxiin
Jotta Keras, jonka taustamoottorina on Tensorflow, voidaan ottaa käyttöön, meidän on ensin asennettava Tensorflow. Suorita tämä komento asentaaksesi tensorflow CPU:lla (ei GPU:ta)
pip install --upgrade tensorflow
Jos haluat ottaa GPU-tuen käyttöön tensorflowlle, voit käyttää tätä komentoa
pip install --upgrade tensorflow-gpu
mennään sisään Python nähdäksesi onnistuuko asennus kirjoittamalla
user@user:~$ python Python 3.6.4 (default, Mar 20 2018, 11:10:20) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import tensorflow >>>
jos virheilmoitusta ei tule, asennus on onnistunut
Asenna Keras
Kun olemme asentaneet Tensorflown, aloitetaan keraksen asentaminen. Kirjoita tämä komento terminaaliin
pip install keras
se alkaa asentaa Kerasta ja myös kaikkia sen riippuvuuksia. Sinun pitäisi nähdä jotain tämän kaltaista:
Nyt meillä on Keras asennettuna järjestelmäämme!
Tarkistetaan
Ennen kuin aloitamme Kerasin käytön, meidän tulee tarkistaa, käyttääkö Kerasimme Tensorflowa taustana avaamalla asetustiedosto:
gedit ~/.keras/keras.json
sinun pitäisi nähdä jotain tällaista
{
"floatx": "float32",
"epsilon": 1e-07,
"backend": "tensorflow",
"image_data_format": "channels_last"
}
kuten näet, "tausta" käyttää tensorflowa. Se tarkoittaa, että keras käyttää Tensorflowa taustaympäristönä, kuten odotimme
ja nyt suorita se terminaalissa kirjoittamalla
user@user:~$ python3 Python 3.6.4 (default, Mar 20 2018, 11:10:20) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import keras Using TensorFlow backend. >>>
Kuinka Keras asennetaan Windows
Ennen kuin asennamme Tensorflow ja Keras, meidän pitäisi asentaa Python, pip ja virtualenv. Jos olet jo asentanut nämä kirjastot, jatka seuraavaan vaiheeseen, muussa tapauksessa toimi näin:
install Python 3 lataamalla tästä linkkiä
Asenna pip suorittamalla tätä
Asenna virtualenv tällä komennolla
pip3 install –U pip virtualenv
install Microsoft Visuaalinen C++ 2015 jaettava päivitys 3
- Siirry Visual Studion lataussivustolle https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Valitse Levitys- ja rakennustyökalut
- Lataa ja asenna Microsoft Visuaalinen C++ 2015 jaettava päivitys 3
Suorita sitten tämä skripti
pip3 install virtualenv
Asenna virtuaalinen ympäristö
Tätä käytetään eristämään toimiva järjestelmä pääjärjestelmästä.
virtualenv –-system-site-packages –p python3 ./venv
Aktivoi ympäristö
.\venv\Scripts\activate
Ympäristön valmistelun jälkeen Tensorflow- ja Keras-asennus pysyy samana kuin Linux. Seuraavaksi tässä Deep learning with Keras -opetusohjelmassa opimme Kerasin perusteet syväoppimisessa.
Keras Fundamentals for Deep Learning
Kerasin päärakenne on malli, joka määrittelee verkon täydellisen graafin. Voit lisätä tasoja olemassa olevaan malliin luodaksesi mukautetun mallin, jota tarvitset projektiisi.
Näin luot peräkkäisen mallin ja muutamia yleisesti käytettyjä kerroksia syväoppimisessa
1. Sekvenssimalli
from keras.models import Sequential from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout model = Sequential()
2. Konvoluutiokerros
Tämä on Keras Python esimerkki konvoluutiokerroksesta syöttökerroksena, jonka tulomuoto on 320x320x3, jossa on 48 suodatinta, joiden koko on 3 × 3, ja käytä ReLU:ta aktivointitoimintona.
input_shape=(320,320,3) #this is the input shape of an image 320x320x3 model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))
toinen tyyppi on
model.add(Conv2D(48, (3, 3), activation='relu'))
3. EnintäänPooling Kerros
Voit pienentää näytteenottoa syötteestä käyttämällä MaxPool2d:tä ja määrittämällä ytimen koon
model.add(MaxPooling2D(pool_size=(2, 2)))
4. Tiheä kerros
Täysin yhdistetyn kerroksen lisääminen määrittämällä vain tulosteen koko
model.add(Dense(256, activation='relu'))
5. Dropout Layer
Pudotuskerroksen lisääminen 50 %:n todennäköisyydellä
model.add(Dropout(0.5))
Kokoaminen, koulutus ja arviointi
Kun olemme määrittäneet mallimme, aloitetaan niiden kouluttaminen. Verkko on ensin käännettävä häviötoiminnolla ja optimointitoiminnolla. Näin verkko voi muuttaa painoja ja minimoida häviön.
model.compile(loss='mean_squared_error', optimizer='adam')
Aloita harjoittelu syöttämällä koulutus- ja validointitiedot malliin käyttämällä fit-toimintoa. Näin voit kouluttaa verkkoa erissä ja asettaa aikakaudet.
model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))
Viimeinen vaiheemme on arvioida malli testitiedoilla.
score = model.evaluate(x_test, y_test, batch_size=32)
Yritetään käyttää yksinkertaista lineaarista regressiota
import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3
model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))
model.compile(optimizer='sgd', loss='mse', metrics=['mse'])
weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init))
model.fit(x,y, batch_size=1, epochs=30, shuffle=False)
weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))
predict = model.predict(data)
plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()
Tietojen harjoittamisen jälkeen tulosteen pitäisi näyttää tältä
alkuperäisen painon kanssa
Linear regression model is initialized with weights w: 0.37, b: 0.00
ja lopullinen paino
Linear regression model is trained to have weight w: 3.70, b: 0.61
Hienosäädä esikoulutetut mallit Kerasissa ja kuinka niitä käytetään
Miksi käytämme Fine Tune -malleja ja milloin käytämme niitä
Hienosäätö on tehtävä esikoulutetun mallin säätämiseksi siten, että parametrit mukautuvat uuteen malliin. Kun haluamme harjoitella tyhjästä uudella mallilla, tarvitsemme suuren määrän dataa, jotta verkko löytää kaikki parametrit. Mutta tässä tapauksessa käytämme esikoulutettua mallia, jotta parametrit ovat jo opittuja ja niillä on painoarvo.
Jos esimerkiksi haluamme kouluttaa oman Keras-mallimme ratkaisemaan luokitusongelman, mutta meillä on vain pieni määrä dataa, voimme ratkaista tämän käyttämällä Siirrä oppiminen + Hienosäätömenetelmä.
Käyttämällä esikoulutettua verkkoa ja painoja meidän ei tarvitse harjoitella koko verkkoa. Meidän täytyy vain kouluttaa viimeinen kerros, jota käytetään tehtävämme ratkaisemiseen, kuten kutsumme sitä hienosäätömenetelmäksi.
Verkkomallin valmistelu
Valmiiksi koulutettua mallia varten voimme ladata erilaisia malleja, jotka Kerasilla on jo kirjastossaan, kuten:
- VGG16
- Perustaminen V3
- ResNet
- MobileNet
- Xception
- InceptionResNetV2
Mutta tässä prosessissa käytämme VGG16-verkkomallia ja imageNetiä mallin painona. Hienosäädämme verkon luokittelemaan 8 erilaista luokkaa käyttämällä Images from Kaggle Natural Images Dataset
VGG16-mallin arkkitehtuuri
Tietojemme lähettäminen AWS S3 -ämpäriin
Harjoitteluprosessissamme käytämme kuvaa luonnonkuvista 8 eri luokasta, kuten lentokoneista, autosta, kissasta, koirasta, kukkasta, hedelmistä, moottoripyörästä ja ihmisestä. Ensin meidän on ladattava tietomme osoitteeseen Amazon S3 Kauha.
Amazon S3 Kauha
Vaihe 1) Kun olet kirjautunut S3-tilillesi, luodaan ämpäri kellottamalla Luo ämpäri
Vaihe 2) Valitse nyt ryhmän nimi ja alueesi tilisi mukaan. Varmista, että kauhan nimi on saatavilla. Napsauta sen jälkeen Luoda.
Vaihe 3) Kuten näet, kauhasi on käyttövalmis. Mutta kuten näet, pääsy ei ole julkinen, se on hyvä sinulle, jos haluat pitää sen yksityisenä itsellesi. Voit muuttaa tämän ryhmän julkista käyttöä varten Säilön ominaisuuksissa
Vaihe 4) Nyt alat ladata harjoitustietojasi Bucketiin. Lataan tähän tar.gz-tiedoston, joka koostuu kuvista koulutus- ja testausprosessia varten.
Vaihe 5) Napsauta nyt tiedostoa ja kopioi se Linkki jotta voimme ladata sen.
Tietojen valmistelu
Meidän on luotava harjoitustietomme Keras ImageDatan avullaGenerator.
Ensin sinun on ladattava tiedosto wgetillä, jossa on linkki tiedostoosi S3 Bucketista.
!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz !tar -xzf images.tar.gz
Kun olet ladannut tiedot, aloitetaan koulutusprosessi.
from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt
train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8
train_datagen = ImageDataGenerator(validation_split=0.3,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
directory=train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='categorical',
color_mode='rgb',
shuffle=True)
KuvatiedotGenerator tekee X_training-tiedot hakemistosta. Tämän hakemiston alihakemistoa käytetään kunkin objektin luokkana. Kuva ladataan RGB-väritilassa, Y_training-tietojen kategorisella luokkatilalla, eräkoolla 16. Sekoita lopuksi tiedot.
Katsotaanpa kuviamme satunnaisesti piirtämällä ne matplotlibillä
x_batch, y_batch = train_generator.next()
fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
num = np.random.randint(batch_size)
image = x_batch[num].astype(np.int)
fig.add_subplot(rows, columns, i)
plt.imshow(image)
plt.show()
Sen jälkeen luodaan verkkomallimme VGG16:sta imageNetin esiopetetulla painolla. Jäädytämme nämä kerrokset, jotta kerrokset eivät ole koulutettavissa, mikä auttaa meitä lyhentämään laskenta-aikaa.
Mallin luominen VGG16:sta
import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16
#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))
print(base_model.summary())
# Freeze the layers
for layer in base_model.layers:
layer.trainable = False
# # Create the model
model = keras.models.Sequential()
# # Add the vgg convolutional base model
model.add(base_model)
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
# # Show a summary of the model. Check the number of trainable parameters
print(model.summary())
Kuten alla näet, yhteenveto verkkomallistamme. VGG16 Layersin syötteestä lisäämme sitten 2 täysin yhdistettyä kerrosta, jotka poimivat 1024 ominaisuutta, ja tuloskerroksen, joka laskee 8 luokkaa softmax-aktivoinnin avulla.
Layer (type) Output Shape Param # ================================================================= vgg16 (Model) (None, 7, 7, 512) 14714688 _________________________________________________________________ flatten_1 (Flatten) (None, 25088) 0 _________________________________________________________________ dense_1 (Dense) (None, 1024) 25691136 _________________________________________________________________ dense_2 (Dense) (None, 1024) 1049600 _________________________________________________________________ dense_3 (Dense) (None, 8) 8200 ================================================================= Total params: 41,463,624 Trainable params: 26,748,936 Non-trainable params: 14,714,688
koulutus
# # Compile the model
from keras.optimizers import SGD
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-3),
metrics=['accuracy'])
# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)
# # #save the model
# model.save('catdog.h5')
history = model.fit_generator(
train_generator,
steps_per_epoch=train_generator.n/batch_size,
epochs=10)
model.save('fine_tune.h5')
# summarize history for accuracy
import matplotlib.pyplot as plt
plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()
tulokset
Epoch 1/10 432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 Epoch 2/10 432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831 Epoch 3/10 432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871 Epoch 4/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926 Epoch 5/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938 Epoch 6/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936 Epoch 7/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958 Epoch 8/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959 Epoch 9/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942 Epoch 10/10 432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947
Kuten näette, häviömme ovat pienentyneet merkittävästi ja tarkkuus on lähes 100%. Mallimme testaamista varten poimimme satunnaisesti kuvia Internetistä ja laitoimme ne testikansioon eri luokan kanssa testattavaksi.
Testaamme malliamme
model = load_model('fine_tune.h5')
test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
directory=train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='categorical',
color_mode='rgb',
shuffle=True)
test_generator = test_datagen.flow_from_directory(
directory=test_path,
target_size=(image_size, image_size),
color_mode='rgb',
shuffle=False,
class_mode='categorical',
batch_size=1)
filenames = test_generator.filenames
nb_samples = len(filenames)
fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
x_batch, y_batch = test_generator.next()
name = model.predict(x_batch)
name = np.argmax(name, axis=-1)
true_name = y_batch
true_name = np.argmax(true_name, axis=-1)
label_map = (test_generator.class_indices)
label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
predictions = [label_map[k] for k in name]
true_value = [label_map[k] for k in true_name]
image = x_batch[0].astype(np.int)
fig.add_subplot(rows, columns, i)
plt.title(str(predictions[0]) + ':' + str(true_value[0]))
plt.imshow(image)
plt.show()
Ja testimme on alla kuvattu! Vain 1 kuva on ennustettu väärin 14 kuvan testistä!
Kasvojentunnistushermoverkko Kerasin kanssa
Miksi tarvitsemme tunnustusta
Tarvitsemme tunnistusta, jotta voimme helpommin tunnistaa tai tunnistaa henkilön kasvot, esinetyypin, henkilön arvioidun iän hänen kasvoistaan tai edes tuntea kyseisen henkilön ilmeet.
Ehkä huomaat joka kerta kun yrität merkitä ystäväsi kasvot valokuvaan, Facebookin ominaisuus on tehnyt sen puolestasi, eli merkitsee ystäväsi kasvot ilman, että sinun tarvitsee merkitä niitä ensin. Tämä on Facebookin käyttämä kasvojentunnistus, joka helpottaa ystävien merkitsemistä.
Joten miten se toimii? Joka kerta kun merkitsemme ystävämme kasvot, Facebookin tekoäly oppii sen ja yrittää ennustaa sen, kunnes se saa oikean tuloksen. Samaa järjestelmää käytämme oman kasvojentunnistuksen tekemiseen. Aloitetaan oman kasvojentunnistuksen tekeminen Deep Learningin avulla
Verkkomalli
Käytämme VGG16-verkkomallia, mutta VGGFace-painolla.
VGG16-mallin arkkitehtuuri
Mikä on VGGFace? se on Keras-toteutus Deep Face Recognitionista, jonka esitteli Parkhi, Omkar M. et al. "Syvä kasvojen tunnistus." BMVC (2015). Kehys käyttää VGG16:ta verkkoarkkitehtuurina.
Voit ladata VGGFacen osoitteesta GitHub
from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace
face_model = VGGFace(model='vgg16',
weights='vggface',
input_shape=(224,224,3))
face_model.summary()
Kuten näet verkon yhteenvedosta
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ conv1_1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ conv1_2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ pool1 (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ conv2_1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ conv2_2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ pool2 (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ conv3_1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ conv3_2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ conv3_3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ pool3 (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ conv4_1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ conv4_2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ conv4_3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ pool4 (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ conv5_1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ pool5 (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc6 (Dense) (None, 4096) 102764544 _________________________________________________________________ fc6/relu (Activation) (None, 4096) 0 _________________________________________________________________ fc7 (Dense) (None, 4096) 16781312 _________________________________________________________________ fc7/relu (Activation) (None, 4096) 0 _________________________________________________________________ fc8 (Dense) (None, 2622) 10742334 _________________________________________________________________ fc8/softmax (Activation) (None, 2622) 0 ================================================================= Total params: 145,002,878 Trainable params: 145,002,878 Non-trainable params: 0 _________________________________________________________________ Traceback (most recent call last):
teemme a Siirrä oppiminen + Hienosäätö nopeuttaa harjoittelua pienillä tietojoukoilla. Ensin jäädytetään pohjakerrokset, jotta kerrokset eivät ole koulutettavissa.
for layer in face_model.layers:
layer.trainable = False
sitten lisäämme oman kerroksen tunnistaaksemme testikasvomme. Lisäämme 2 täysin yhdistettyä kerrosta ja tuloskerroksen, jossa on 5 henkilöä havaittavaksi.
from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation
person_count = 5
last_layer = face_model.get_layer('pool5').output
x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)
custom_face = Model(face_model.input, out)
Katsotaanpa verkostomme yhteenveto
Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ conv1_1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ conv1_2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ pool1 (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ conv2_1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ conv2_2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ pool2 (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ conv3_1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ conv3_2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ conv3_3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ pool3 (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ conv4_1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ conv4_2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ conv4_3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ pool4 (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ conv5_1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ pool5 (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc6 (Dense) (None, 1024) 25691136 _________________________________________________________________ fc7 (Dense) (None, 1024) 1049600 _________________________________________________________________ fc8 (Dense) (None, 5) 5125 ================================================================= Total params: 41,460,549 Trainable params: 26,745,861 Non-trainable params: 14,714,688
Kuten yllä näkyy, pool5-kerroksen jälkeen se litistetään yhdeksi piirrevektoriksi, jota tiheä kerros käyttää lopulliseen tunnistukseen.
Valmistelemme kasvojamme
Valmistellaan nyt kasvomme. Tein hakemiston, jossa oli 5 kuuluisaa henkilöä
- Jack Ma
- Jason Statham
- Johnny Depp
- Robert Downey Jr
- Rowan Atkinson
Jokainen kansio sisältää 10 kuvaa jokaisesta koulutus- ja arviointiprosessista. Se on hyvin pieni määrä dataa, mutta se on haaste, eikö?
Käytämme Keras-työkalun apua tietojen valmistelussa. Tämä toiminto toistuu tietojoukkokansiossa ja valmistelee sen sitten käytettäväksi koulutuksessa.
from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'
train_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
valid_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='sparse',
color_mode='rgb')
valid_generator = valid_datagen.flow_from_directory(
directory=eval_path,
target_size=(224, 224),
color_mode='rgb',
batch_size=batch_size,
class_mode='sparse',
shuffle=True,
)
Koulutamme malliamme
Aloitetaan koulutusprosessimme kokoamalla verkkomme häviötoiminnolla ja optimoijalla. Tässä käytämme sparse_categorical_crossentropya häviöfunktionamme SGD:n avulla oppimisen optimoijamme.
from keras.optimizers import SGD
custom_face.compile(loss='sparse_categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
history = custom_face.fit_generator(
train_generator,
validation_data=valid_generator,
steps_per_epoch=49/batch_size,
validation_steps=valid_generator.n,
epochs=50)
custom_face.evaluate_generator(generator=valid_generator)
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266
Kuten näet, validointitarkkuus on jopa 64 %, tämä on hyvä tulos pienelle harjoitustietojen määrälle. Voimme parantaa tätä lisäämällä kerroksia tai lisäämällä harjoituskuvia, jotta mallimme voi oppia lisää kasvoista ja saavuttaa enemmän tarkkuutta.
Testataan malliamme testikuvalla
from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input
test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)
labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']
käyttämällä Robert Downey Jr.:n kuvaa testikuvana, se osoittaa, että ennustetut kasvot ovat totta!
Ennustaminen Live Camilla!
Entä jos testaamme taitojamme toteuttamalla se verkkokameran syötteellä? Käyttämällä OpenCV:tä Haar Face -kaskadilla kasvomme löytämiseen ja verkkomallimme avulla tunnistamme henkilön.
Ensimmäinen askel on valmistella itsesi ja ystäväsi kasvot. Mitä enemmän tietoa meillä on, sitä parempi tulos on!
Valmistele ja harjoittele verkkoasi kuten edellisessä vaiheessa. Kun koulutus on suoritettu, lisää tämä rivi saadaksesi syöttökuvan kamerasta
#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2
image_size = 224
device_id = 0 #camera_device id
model = load_model('my faces.h5')
#make labels according to your dataset folder
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)
cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)
while camera.isOpened():
ok, cam_frame = camera.read()
if not ok:
break
gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)
for (x,y,w,h) in faces:
cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
roi_color = cam_frame [y:y+h, x:x+w]
roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
roi_color = cv2.resize(roi_color, (image_size, image_size))
image = roi_color.astype(np.float32, copy=False)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image, version=1) # or version=2
preds = model.predict(image)
predicted_class=np.argmax(preds,axis=1)
labels = dict((v,k) for k,v in labels.items())
name = [labels[k] for k in predicted_class]
cv2.putText(cam_frame,str(name),
(x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
cv2.imshow('video image', cam_frame)
key = cv2.waitKey(30)
if key == 27: # press 'ESC' to quit
break
camera.release()
cv2.destroyAllWindows()
Kumpi on parempi? Keras tai Tensorflow
Keras tarjoaa yksinkertaisuutta käsikirjoituksen kirjoittamiseen. Voimme aloittaa kirjoittamisen ja ymmärtämisen suoraan Kerasin kanssa, koska se ei ole liian vaikea ymmärtää. Se on käyttäjäystävällisempi ja helpompi toteuttaa, ei tarvitse tehdä monia muuttujia mallin suorittamiseksi. Joten meidän ei tarvitse ymmärtää kaikkia taustaprosessin yksityiskohtia.
Toisaalta Tensorflow on matalan tason operaatioita, jotka tarjoavat joustavuutta ja edistyneitä operaatioita, jos haluat tehdä mielivaltaisen laskennallisen graafin tai mallin. Tensorflow voi myös visualisoida prosessin avulla Tensorboard ja erikoistunut virheenkorjaustyökalu.
Joten jos haluat aloittaa syväoppimisen ilman niin kovin monimutkaista, käytä Kerasta. Koska Keras tarjoaa yksinkertaisuutta ja käyttäjäystävällisyyttä käyttää ja helppokäyttöisyyttä kuin Tensorflow. Mutta jos haluat kirjoittaa oman algoritmi syväoppimisprojektiin tai -tutkimukseen, sinun kannattaa käyttää Tensorflowa sen sijaan.
Yhteenveto
Tehdään siis yhteenveto kaikesta, mitä olemme keskustelleet ja tehneet tässä opetusohjelmassa.
- Keras korkean tason API:ssa, jota käytetään helpottamaan syväoppimisverkkoja taustamoottorin avulla.
- Keras on helppokäyttöinen ja ymmärrettävä python-tuen ansiosta, joten se tuntuu luonnollisemmalta kuin koskaan. Se on hyvä aloittelijoille, jotka haluavat oppia syvästä oppimisesta, ja tutkijoille, jotka haluavat helppokäyttöisen API:n.
- Asennusprosessi on helppoa ja voit käyttää virtuaaliympäristöä tai ulkoista alustaa, kuten AWS.
- Keraan mukana tulee myös erilaisia verkkomalleja, joten meidän on helpompi käyttää saatavilla olevaa mallia oman verkkomallimme esikouluttamiseen ja hienosäätöön.
- Lisäksi on olemassa paljon opetusohjelmia ja artikkeleita Kerasin käyttämisestä yhteisöiltä maailmanlaajuisesti koodien syvään oppimiseen.
