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 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.
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.
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
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.
Samm 2) Sisestage üksikasjad
- Sisestage oma märkmiku nimi.
- Looge IAM-i roll. See loob AMI rolli Amazon IAM-i roll vormingus AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
- Lõpuks valige Loo märkmiku eksemplar. Mõne hetke pärast Amazon Sagemaker käivitab sülearvuti eksemplari.
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
4. samm) alustage kodeerimist
In Jupyter, Klõpsake nuppu Uus> conda_tensorflow_p36 ja oletegi kodeerimiseks valmis
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
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:
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
- Minge Visual Studio allalaadimissaidile https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Valige Edasilevitatavad ja koostamise tööriistad
- Laadige alla ja installige 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
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
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
Step 2) Nüüd valige vastavalt oma kontole ämbri nimi ja piirkond. Veenduge, et ämbri nimi oleks saadaval. Pärast seda klõpsake Loo.
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
Step 4) Nüüd hakkate oma treeningandmeid Bucketti üles laadima. Siia laadin üles faili tar.gz, mis koosneb piltidest koolituse ja testimise jaoks.
Step 5) Nüüd klõpsake oma failil ja kopeerige see on siin et saaksime selle alla laadida.
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()
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
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!
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.
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
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
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.