Kerase õpetus: mis on Keras? Kuidas sisse installida Python [Näide]

Mis on Keras?

Keras on avatud lähtekoodiga närvivõrgu teek, mis on sisse kirjutatud Python mis jookseb Theano või Tensorflow peal. See on loodud olema modulaarne, kiire ja lihtne kasutada. Selle töötas välja Google'i insener François Chollet. Keras ei tegele madala tasemega arvutustega. Selle asemel kasutab see selleks teist teeki, mida nimetatakse "taustaprogrammiks.

Keras on kõrgetasemeline API ümbris madala taseme API jaoks, mis on võimeline töötama TensorFlow, CNTK või Theano peal. Kerase High-Level API haldab viisi, kuidas me koostame mudeleid, määratleme kihte või seadistame mitut sisend-väljundmudelit. Sellel tasemel koostab Keras ka meie mudeli kadu- ja optimeerija funktsioonidega, treeningprotsessi sobivuse funktsiooniga. Keras sisse Python ei käsitle madala taseme API-sid, nagu arvutusgraafiku koostamine, tensorite või muude muutujate loomine, kuna seda on käsitlenud taustamootor.

Mis on taustaprogramm?

Taustaprogramm on Kerase termin, mis teostab teiste teekide (nt Tensorflow või Theano) abil kõiki madala taseme arvutusi, nagu tensorproduktid, konvolutsioonid ja palju muud. Niisiis, "taustamootor" teostab mudelite arvutamise ja arendamise. Tensorflow on vaikimisi "taustamootor", kuid me saame seda konfiguratsioonis muuta.

Theano, Tensorflow ja CNTK taustaprogramm

Theano tagakülg

Theano on avatud lähtekoodiga projekt, mille töötas välja Kanada Quebeci osariigi Montreali ülikooli MILA grupp. See oli esimene laialdaselt kasutatav raamistik. See on a Python teek, mis aitab luua mitmemõõtmelisi massiive matemaatilisi tehteid kasutades Numpy või Scipy abil. Theano saab kasutada GPU-sid kiiremaks arvutamiseks, samuti saab see automaatselt koostada sümboolseid graafikuid gradientide arvutamiseks. Theano väidab oma veebisaidil, et suudab ära tunda arvuliselt ebastabiilseid avaldisi ja arvutada neid stabiilsemate algoritmidega, mis on meie ebastabiilsete avaldiste jaoks väga kasulik.

TensorFlow taustaprogramm

Teisest küljest on Tensorflow tõusev täht sügavas õpperaamistikus. Google'i Brain meeskonna poolt välja töötatud see on kõige populaarsem süvaõppe tööriist. Paljude funktsioonidega teadlased aitavad seda raamistikku süvaõppe eesmärgil arendada.

CNTK taustaprogramm

Teine Kerase taustamootor on The Microsoft Kognitiivne tööriistakomplekt või CNTK. See on avatud lähtekoodiga süvaõpperaamistik, mille töötas välja Microsoft Meeskond. See võib töötada mitmel GPU-l või mitmel masinal sügava õppemudeli massiliseks treenimiseks. Mõnel juhul teatati CNTK-st kiiremini kui teistest raamistikest, nagu Tensorflow või Theano. Järgmisena selles Kerase CNN-i õpetuses võrdleme Theano, TensorFlow ja CNTK taustaprogramme.

Taustaprogrammide võrdlemine

Peame tegema võrdlusuuringu, et teada saada nende kahe taustaprogrammi võrdlust. Nagu näete Jeong-Yoon Lee etalon, võrreldakse 3 erineva taustaprogrammi jõudlust erinevatel riistvaradel. Tulemuseks on see, et Theano on aeglasem kui teine ​​taustaprogramm, teatatakse 50 korda aeglasemad, kuid täpsus on üksteisele lähedane.

Teine võrdlustest teostab Jasmeet Bhatia. Ta teatas, et Theano on mõne testi jaoks aeglasem kui Tensorflow. Kuid üldine täpsus on iga testitud võrgu puhul peaaegu sama.

Seega on Theano, Tensorflow ja CTK vahel ilmne, et TensorFlow on parem kui Theano. TensorFlow puhul on arvutusaeg palju lühem ja CNN on teistest parem.

Järgmine selles Keras Python õpetusest saame teada Kerase ja TensorFlow erinevuste kohta (Keras vs Tensorflow).

Keras vs Tensorflow

parameetrid Keras Tensorivoog
KASUTUSALA Kõrgetasemeline API ümbris Madala taseme API
Keerukus Lihtne kasutada, kui Python keel Peate õppima mõne Tensorflow funktsiooni kasutamise süntaksit
Eesmärk Kiire kasutuselevõtt standardkihtidega mudeli loomiseks Võimaldab luua suvalise arvutusgraafiku või mudelikihte
TÖÖRIISTAD Kasutab muud API silumistööriista, näiteks TFDBG Saate kasutada Tensorboardi visualiseerimistööriistu
kogukond Suured aktiivsed kogukonnad Suured aktiivsed kogukonnad ja laialt jagatud ressursid

Kerase eelised

Kiire juurutamine ja hõlpsasti mõistetav

Keras on väga kiire võrgumudeli tegemisega. Kui soovite luua lihtsa, mõne joonega võrgumudeli, Python Keras saab teid selles aidata. Vaadake allolevat Kerase näidet:

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

Tänu sõbralikule API-le saame protsessist hõlpsasti aru. Koodi kirjutamine lihtsa funktsiooniga ja ei pea määrama mitut parameetrit.

Suur kogukonna tugi

On palju AI-kogukondi, mis kasutavad Kerast oma süvaõppe raamistiku jaoks. Paljud neist avaldavad üldsusele oma koode ja õpetusi.

Teil on mitu taustaprogrammi

Kerase taustaprogrammiks saate valida Tensorflow, CNTK ja Theano. Sõltuvalt teie vajadustest saate erinevate projektide jaoks valida erineva taustaprogrammi. Igal taustaprogrammil on oma ainulaadne eelis.

Platvormideülene ja lihtne mudeli juurutamine

Erinevate toetatud seadmete ja platvormidega saate Kerast juurutada mis tahes seadmes, näiteks

  • iOS CoreML-iga
  • Android Tensorflow'ga Android,
  • js-toega veebibrauser
  • Pilve mootor
  • Raspberry Pi

Mitme GPU tugi

Saate Kerast treenida ühel GPU-l või kasutada korraga mitut GPU-d. Kuna Kerasel on sisseehitatud andmete paralleelsuse tugi, nii et see suudab töödelda suuri andmemahtusid ja kiirendada nende koolitamiseks kuluvat aega.

Kerase miinused

Madala taseme API-ga ei saa hakkama

Keras tegeleb ainult kõrgetasemelise API-ga, mis töötab teiste raamistike või taustamootorite peal, nagu Tensorflow, Theano või CNTK. Seega pole see eriti kasulik, kui soovite oma uurimistöö jaoks abstraktset kihti teha, kuna Kerasel on juba eelnevalt konfigureeritud kihid.

Kerase paigaldamine

Selles jaotises käsitleme erinevaid Kerase installimise meetodeid

Otsene installimine või virtuaalne keskkond

Kumb on parem? Kas installida otse praegusesse pythoni või kasutada virtuaalset keskkonda? Kui teil on palju projekte, soovitan kasutada virtuaalset keskkonda. Kas soovite teada, miks? Seda seetõttu, et erinevad projektid võivad kasutada kerase teegi erinevat versiooni.

Näiteks mul on projekt, mis vajab Python 3.5 kasutades OpenCV 3.3 vanema Keras-Theano taustaprogrammiga, kuid teises projektis pean kasutama Kerast uusima versiooniga ja Tensorflow'ga, kuna see on koos taustaprogrammiga Python 3.6.6i tugi

Me ei taha, et Kerase raamatukogu omavahel konfliktiks läheks? Seega kasutame projekti lokaliseerimiseks teatud tüüpi teegiga virtuaalset keskkonda või saame kasutada teist platvormi, näiteks pilveteenust, et teha meie eest arvutusi, näiteks Amazon Veebiteenus.

Kerase installimine Amazon Veebiteenus (AWS)

Amazon Veebiteenus on platvorm, mis pakub pilvandmetöötluse teenust ja tooteid teadlastele või muudel eesmärkidel. AWS rendib oma riistvara, võrkude, andmebaasi jne, et saaksime seda otse Internetist kasutada. Üks populaarsemaid AWS-i teenust süvaõppe eesmärgil on Amazon Machine Image Deep Learning Service ehk DL

Üksikasjalikud juhised AWS-i kasutamise kohta leiate siit juhendaja

Märkus AMI kohta: teil on saadaval järgmine AMI

Kerase installimine AWS-ile

AWS Deep Learning AMI on AWS EC2 teenuse virtuaalne keskkond, mis aitab teadlastel või praktikutel süvaõppega töötada. DLAMI pakub alates väikestest protsessoritest kuni suure võimsusega mitme GPU mootoriteni koos eelkonfigureeritud CUDA ja cuDNN-iga ning kaasas mitmesugused süvaõppe raamistikud.

Kui soovite seda kohe kasutada, peaksite valima Deep Learning AMI, kuna see on eelinstallitud populaarsete süvaõppe raamistikega.

Kuid kui soovite proovida kohandatud süvaõppe raamistikku uurimistööks, peaksite installima Deep Learning Base AMI, kuna see sisaldab põhiteeke, nagu CUDA, cuDNN, GPU-draiverid ja muud vajalikud teegid, et töötada teie süvaõppekeskkonnaga.

Kuidas Kerast installida Amazon SageMaker

Amazon SageMaker on süvaõppeplatvorm, mis aitab teil treenida ja juurutada süvaõppevõrku parima algoritmiga.

Algajana on see Kerase kõige lihtsam kasutusviis. Allpool on toodud Kerase installimise protsess Amazon SageMaker:

Samm 1) Avage Amazon SageMaker

Esimeses etapis avage Amazon Salveitegija konsooli ja klõpsake nuppu Loo märkmiku eksemplar.

Installige Keras sisse Amazon SageMaker

Samm 2) Sisestage üksikasjad

  1. Sisestage oma märkmiku nimi.
  2. Looge IAM-i roll. See loob AMI rolli Amazon IAM-i roll vormingus AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
  3. Lõpuks valige Loo märkmiku eksemplar. Mõne hetke pärast Amazon Sagemaker käivitab sülearvuti eksemplari.

Installige Keras sisse Amazon SageMaker

märkused: Kui soovite oma VPC-st ressurssidele juurde pääseda, määrake otsene Interneti-juurdepääs lubatud. Vastasel juhul ei ole sellel sülearvuti eksemplaril Interneti-juurdepääsu, mistõttu on võimatu mudeleid koolitada ega hostida

Samm 3) Käivitage eksemplar

Eksemplari käivitamiseks klõpsake nuppu Ava

Installige Keras sisse Amazon SageMaker

4. samm) alustage kodeerimist

In Jupyter, Klõpsake nuppu Uus> conda_tensorflow_p36 ja oletegi kodeerimiseks valmis

Installige Keras sisse Amazon SageMaker

Installige Keras Linuxi

Kerase lubamiseks koos Tensorflow taustamootoriga peame esmalt installima Tensorflow. Käivitage see käsk, et installida tensorflow CPU-ga (ilma GPU-ta)

pip install --upgrade tensorflow

kui soovite lubada tensorflow GPU toe, saate seda käsku kasutada

pip install --upgrade tensorflow-gpu

Installige Keras Linuxile

läheme sisse Python tippides, et näha, kas meie installimine õnnestub

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

kui veateadet pole, on installiprotsess edukas

Installige Keras

Pärast Tensorflow installimist alustame kerase installimist. Tippige see käsk terminali

pip install keras

see alustab Kerase ja ka kõigi selle sõltuvuste installimist. Peaksite nägema midagi sellist:

Installige Keras

Nüüd on Keras meie süsteemi installitud!

Kinnitamine

Enne Kerase kasutamise alustamist peaksime kontrollima, kas meie Keras kasutab taustaprogrammina Tensorflow't, avades konfiguratsioonifaili:

gedit ~/.keras/keras.json

sa peaksid nägema midagi sellist

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

nagu näete, kasutab "taustaprogramm" tensorflow'i. See tähendab, et keras kasutab Tensorflow'i taustaprogrammina, nagu me eeldasime

ja käivitage see nüüd terminalis tippides

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

Kuidas Kerast installida Windows

Enne paigaldamist Tensorivoog ja Keras, peaksime installima Python, pip ja virtualenv. Kui olete need teegid juba installinud, peaksite jätkama järgmise sammuga, vastasel juhul tehke järgmist.

paigaldama Python 3 siit alla laadides link

Installige pip käivitades see

Installige virtualenv selle käsuga

pip3 install –U pip virtualenv

paigaldama Microsoft Visuaalne C++ 2015. aasta taaslevitatav värskendus 3

Seejärel käivitage see skript

pip3 install virtualenv

Virtuaalse keskkonna seadistamine

Seda kasutatakse töötava süsteemi isoleerimiseks põhisüsteemiga.

virtualenv –-system-site-packages –p python3 ./venv

Aktiveerige keskkond

.\venv\Scripts\activate

Pärast keskkonna ettevalmistamist jääb Tensorflow ja Keras installimine samaks nagu Linux. Järgmisena selles Kerasega süvaõppimise õpetuses õpime tundma Kerase süvaõppe põhialuseid.

Kerase alused süvaõppeks

Kerase põhistruktuur on mudel, mis määratleb võrgu täieliku graafiku. Saate lisada olemasolevale mudelile rohkem kihte, et luua oma projekti jaoks vajalik kohandatud mudel.

Siit saate teada, kuidas luua järjestikust mudelit ja mõnda süvaõppes sagedamini kasutatavat kihti

1. Järjestusmudel

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. Konvolutsioonikiht

See on Keras Python näide konvolutsioonikihist sisendkihina sisendkujuga 320x320x3, 48 filtriga suurusega 3 × 3 ja aktiveerimisfunktsioonina kasutage ReLU-d.

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

teine ​​tüüp on

model.add(Conv2D(48, (3, 3), activation='relu'))

3. MaksPooling Kiht

Sisendesituse alladiskreetmiseks kasutage MaxPool2d ja määrake tuuma suurus

model.add(MaxPooling2D(pool_size=(2, 2)))

4. Tihe kiht

Täielikult ühendatud kihi lisamine, määrates lihtsalt väljundi suuruse

model.add(Dense(256, activation='relu'))

5. Väljalangemise kiht

Väljalangemise kihi lisamine 50% tõenäosusega

model.add(Dropout(0.5))

Koostamine, väljaõpe ja hindamine

Kui oleme oma mudeli määratlenud, hakkame neid koolitama. Esmalt tuleb võrk kompileerida kadufunktsiooni ja optimeerija funktsiooniga. See võimaldab võrgul muuta kaalu ja minimeerida kadu.

model.compile(loss='mean_squared_error', optimizer='adam')

Treenimise alustamiseks kasutage treening- ja valideerimisandmete mudelile sisestamiseks funktsiooni fit. See võimaldab teil koolitada võrku partiidena ja määrata ajastud.

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

Meie viimane samm on mudeli hindamine katseandmetega.

score = model.evaluate(x_test, y_test, batch_size=32)

Proovime kasutada lihtsat lineaarset regressiooni

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

Pärast andmete treenimist peaks väljund välja nägema selline

lineaarne regressioon

algkaaluga

Linear regression model is initialized with weights w: 0.37, b: 0.00

ja lõplik kaal

Linear regression model is trained to have weight w: 3.70, b: 0.61

Peenhäälestage Keras eelkoolitatud mudeleid ja kuidas neid kasutada

Miks me kasutame Fine Tune'i mudeleid ja millal me seda kasutame?

Peenhäälestus on ülesanne kohandada eelkoolitatud mudelit nii, et parameetrid kohaneksid uue mudeliga. Kui tahame uue mudeliga nullist treenida, vajame suurt hulka andmeid, et võrk leiaks kõik parameetrid. Kuid sel juhul kasutame eelkoolitatud mudelit, nii et parameetrid on juba õpitud ja neil on kaal.

Näiteks kui tahame koolitada oma Kerase mudelit klassifikatsiooniprobleemi lahendamiseks, kuid meil on vaid väike hulk andmeid, saame selle lahendada, kasutades Ülekandeõpe + Peenhäälestusmeetod.

Kasutades eelkoolitatud võrku ja raskusi, ei pea me kogu võrku treenima. Peame lihtsalt koolitama viimast kihti, mida kasutatakse meie ülesande lahendamiseks, nagu me nimetame seda peenhäälestusmeetodiks.

Võrgumudeli ettevalmistamine

Eelkoolitatud mudeli jaoks saame laadida mitmesuguseid mudeleid, mis Kerasel juba oma teegis on, näiteks:

  • VGG16
  • AlgusV3
  • ResNet
  • MobileNet
  • Xception
  • InceptionResNetV2

Kuid selles protsessis kasutame mudeli kaaluna VGG16 võrgumudelit ja imageNeti. Täpsustame võrku, et klassifitseerida 8 erinevat tüüpi klassi, kasutades Pilte Kaggle'i looduspiltide andmestik

VGG16 mudeli arhitektuur

VGG16 mudeli arhitektuur

allikas

Oma andmete üleslaadimine AWS S3 ämbrisse

Treeningprotsessis kasutame pilti looduspiltidest 8 erinevast klassist nagu lennuk, auto, kass, koer, lill, puuvili, mootorratas ja inimene. Esiteks peame oma andmed üles laadima Amazon S3 kopp.

Amazon S3 kopp

Step 1) Pärast oma S3 kontole sisselogimist loome kella abil ämbri Loo ämber

Andmete üleslaadimine AWS S3 ämbrisse

Step 2) Nüüd valige vastavalt oma kontole ämbri nimi ja piirkond. Veenduge, et ämbri nimi oleks saadaval. Pärast seda klõpsake Loo.

Andmete üleslaadimine AWS S3 ämbrisse

Step 3) Nagu näete, on teie ämber kasutamiseks valmis. Kuid nagu näete, pole juurdepääs avalik, see on teile kasulik, kui soovite selle enda jaoks privaatseks jätta. Saate seda ämbrit avalikuks juurdepääsuks muuta jaotises Salve atribuudid

Andmete üleslaadimine AWS S3 ämbrisse

Step 4) Nüüd hakkate oma treeningandmeid Bucketti üles laadima. Siia laadin üles faili tar.gz, mis koosneb piltidest koolituse ja testimise jaoks.

Andmete üleslaadimine AWS S3 ämbrisse

Step 5) Nüüd klõpsake oma failil ja kopeerige see on siin et saaksime selle alla laadida.

Andmete üleslaadimine AWS S3 ämbrisse

Andmete ettevalmistamine

Peame oma treeningandmed genereerima Keras ImageData abilGenerator.

Esmalt peate alla laadima kasutades wget-i koos lingiga oma failile S3 Bucketist.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

Pärast andmete allalaadimist alustame koolitusprotsessi.

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)

ImageDataGenerator teeb X_training andmed kataloogist. Selle kataloogi alamkataloogi kasutatakse iga objekti klassina. Pilt laaditakse RGB värvirežiimis, Y_training andmete kategoorilise klassi režiimiga, partii suurusega 16. Lõpuks segage andmed.

Vaatame oma pilte juhuslikult, joonistades need matplotlibiga

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

Andmete ettevalmistamine

Pärast seda loome oma võrgumudeli VGG16-st imageNeti eeltreenitud kaaluga. Külmutame need kihid nii, et kihid ei oleks treenitavad, et aidata meil arvutusaega vähendada.

Meie mudeli loomine VGG16-st

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

Nagu allpool näete, on meie võrgumudeli kokkuvõte. VGG16 kihtide sisendist lisame 2 täielikult ühendatud kihti, mis eraldavad 1024 funktsiooni, ja väljundkihi, mis arvutab 8 klassi softmaxi aktiveerimisega.

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

koolitus

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

Tulemused

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

koolitus

Nagu näete, on meie kahjud oluliselt vähenenud ja täpsus on peaaegu 100%. Meie mudeli testimiseks valisime Internetist juhuslikult pildid ja panime need testimiseks teise klassiga testkausta

Meie mudeli testimine

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 meie test on järgmine! 1 pildist koosneva testi põhjal ennustatakse ainult 14 kujutist valesti!

Testimismudel

Näotuvastuse närvivõrk Kerasega

Miks me vajame tunnustust

Vajame äratundmist, et meil oleks lihtsam tuvastada või tuvastada inimese nägu, objektide tüüpi, inimese hinnangulist vanust tema näo järgi või isegi teada selle inimese näoilmeid.

Näotuvastuse närvivõrk Kerasega

Võib-olla mõistate iga kord, kui proovite oma sõbra nägu fotol märkida, et Facebooki funktsioon on seda teie eest teinud, st märgib teie sõbra nägu ilma, et peaksite seda kõigepealt märkima. See on näotuvastus, mida Facebook kasutab, et hõlbustada sõprade märgistamist.

Kuidas see siis töötab? Iga kord, kui märgime oma sõbra nägu, õpib Facebooki tehisintellekt selle ära ja proovib seda ennustada, kuni see saab õige tulemuse. Sama süsteem, mida kasutame oma näotuvastuse tegemiseks. Alustame süvaõppe abil oma näotuvastuse loomist

Võrgu mudel

Kasutame VGG16 võrgumudelit, kuid VGGFace kaaluga.

VGG16 mudeli arhitektuur

Võrgu mudel

Mis on VGGFace? see on Keras Deep Face Recognitioni juurutamine, mille tutvustasid Parkhi, Omkar M. jt. "Sügav näotuvastus." BMVC (2015). Raamistik kasutab võrguarhitektuurina VGG16.

VGGFace'i saate alla laadida saidilt 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()

Nagu näete võrgu kokkuvõttest

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

teeme a Ülekandeõpe + Peenhäälestus, et muuta treening väikeste andmekogumitega kiiremaks. Kõigepealt külmutame aluskihid, et kihid ei oleks treenitavad.

for layer in face_model.layers:
    layer.trainable = False

seejärel lisame oma kihi, et tuvastada meie testnäod. Lisame tuvastamiseks 2 täielikult ühendatud kihti ja väljundkihi 5 inimesega.

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)

Vaatame meie võrgu kokkuvõtet

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

Nagu ülal näete, tasandatakse see pärast pool5 kihti üheks funktsioonivektoriks, mida tihe kiht kasutab lõplikuks tuvastamiseks.

Meie nägude ettevalmistamine

Nüüd valmistame oma näod ette. Tegin kataloogi 5 kuulsast inimesest

  • Jack Ma
  • Jason Statham
  • Johnny Depp
  • Robert Downey Jr
  • Rowan Atkinson

Igas kaustas on 10 pilti iga koolitus- ja hindamisprotsessi kohta. See on väga väike andmemaht, kuid see on väljakutse, eks?

Andmete koostamisel kasutame Kerase tööriista abi. See funktsioon kordub andmestiku kaustas ja valmistab selle seejärel ette, et seda saaks koolitusel kasutada.

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

Meie mudeli väljaõpe

Alustame oma koolitusprotsessi, koostades oma võrgu koos kadufunktsiooni ja optimeerijaga. Siin kasutame kadufunktsioonina sparse_categorical_crossentropy ja õppimise optimeerijana SGD.

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

Nagu näete, on meie valideerimise täpsus kuni 64%, see on hea tulemus väikese hulga treeningandmete puhul. Saame seda parandada, lisades rohkem kihti või lisades rohkem treeningpilte, et meie mudel saaks nägude kohta rohkem teada ja saavutada suurem täpsus.

Testime oma mudelit testpildiga

Testi pilt

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

kasutades meie testpildina Robert Downey Jr pilti, näitab see, et ennustatud nägu on tõsi!

Ennustamine otsekaamera abil!

Kuidas oleks, kui testiksime oma oskusi selle rakendamisel veebikaamera sisendiga? Kasutades OpenCV-d koos Haar Face kaskaadiga oma näo leidmiseks ja meie võrgumudeli abil saame inimese ära tunda.

Esimene samm on enda ja su sõbra näod ette valmistada. Mida rohkem andmeid meil on, seda parem on tulemus!

Valmistage ette ja treenige oma võrku nagu eelmises etapis. Pärast treeningu lõpetamist lisage see rida, et saada kaamerast sisendpilt

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

Kumb on parem? Keras või Tensorflow

Keras pakub stsenaariumi kirjutamisel lihtsust. Saame Kerasega otse kirjutama ja aru saama, sest sellest pole liiga raske aru saada. See on kasutajasõbralikum ja hõlpsasti rakendatav, mudeli käitamiseks pole vaja teha palju muutujaid. Seega ei pea me taustaprotsessis iga detaili mõistma.

Teisest küljest on Tensorflow madala taseme toimingud, mis pakuvad paindlikkust ja täiustatud toiminguid, kui soovite luua suvalise arvutusgraafiku või mudeli. Tensorflow saab protsessi ka visualiseerida abiga Tensorboard ja spetsiaalne siluritööriist.

Seega, kui soovite alustada süvaõppega töötamist mitte nii keeruliselt, kasutage Kerast. Kuna Keras pakub lihtsust ja kasutajasõbralikkust kasutada ning hõlpsasti rakendatavat kui Tensorflow. Kuid kui soovite süvaõppeprojekti või -uuringusse kirjutada oma algoritmi, peaksite selle asemel kasutama Tensorflow'i.

kokkuvõte

Seega võtame kokku kõik, mida oleme selles õpetuses arutanud ja teinud.

  • Keras kõrgetasemelises API-s, mida kasutatakse süvaõppevõrkude lihtsustamiseks taustamootori abil.
  • Kerast on Pythoni toega lihtne kasutada ja arusaadav, nii et see tundub loomulikum kui kunagi varem. See on hea algajatele, kes soovivad õppida süvaõppe kohta, ja teadlastele, kes soovivad hõlpsasti kasutatavat API-t.
  • Installiprotsess on lihtne ja saate kasutada virtuaalset keskkonda või välist platvormi, näiteks AWS.
  • Kerasel on kaasas ka erinevad võrgumudelid, mis muudab olemasoleva mudeli kasutamise lihtsamaks oma võrgumudeli eelkoolitamiseks ja peenhäälestamiseks.
  • Lisaks on maailmas palju õpetusi ja artikleid kogukondade Kerase kasutamise kohta süvaõppe eesmärkidel.