Keras opetusohjelma

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

1. Kirjoita muistikirjasi nimi.
2. Luo IAM-rooli. Se luo AMI-roolin Amazon IAM-rooli muodossa AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
3. 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

lähde

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.