Keras Tutorial: Hva er Keras? Hvordan installere i Python [Eksempel]
Hva er Keras?
Keras er et Open Source Neural Network-bibliotek skrevet i Python som kjører på toppen av Theano eller Tensorflow. Den er designet for å være modulær, rask og enkel å bruke. Den ble utviklet av François Chollet, en Google-ingeniør. Keras håndterer ikke beregninger på lavt nivå. I stedet bruker den et annet bibliotek for å gjøre det, kalt "Backend.
Keras er API-innpakning på høyt nivå for lavnivå-API, som kan kjøres på toppen av TensorFlow, CNTK eller Theano. Keras High-Level API håndterer måten vi lager modeller på, definerer lag eller setter opp flere input-output-modeller. På dette nivået sammenstiller Keras også vår modell med taps- og optimeringsfunksjoner, treningsprosess med passformfunksjon. Keras inn Python håndterer ikke Low-Level API som å lage beregningsgrafen, lage tensorer eller andre variabler fordi den har blitt håndtert av "backend"-motoren.
Hva er en backend?
Backend er et begrep i Keras som utfører all lavnivåberegning som tensorprodukter, konvolveringer og mange andre ting ved hjelp av andre biblioteker som Tensorflow eller Theano. Så "backend-motoren" vil utføre beregningen og utviklingen av modellene. Tensorflow er standard "backend-motor", men vi kan endre den i konfigurasjonen.
Theano, Tensorflow og CNTK Backend
Theano er et åpen kildekode-prosjekt som ble utviklet av MILA-gruppen ved University of Montreal, Quebec, Canada. Det var det første mye brukte rammeverket. Det er en Python bibliotek som hjelper til med flerdimensjonale arrays for matematiske operasjoner med Numpy eller Scipy. Theano kan bruke GPUer for raskere beregning, den kan også automatisk bygge symbolske grafer for databehandlingsgradienter. På sin nettside hevder Theano at den kan gjenkjenne numerisk ustabile uttrykk og beregne dem med mer stabile algoritmer, dette er veldig nyttig for våre ustabile uttrykk.
På den annen side er Tensorflow den stigende stjernen i rammeverket for dyp læring. Utviklet av Googles Brain-team er det det mest populære dyplæringsverktøyet. Med mange funksjoner, og forskere bidrar til å utvikle dette rammeverket for dyp læringsformål.
En annen backend-motor for Keras er The Microsoft Cognitive Toolkit eller CNTK. Det er en åpen kildekode for dyp læringsramme som ble utviklet av Microsoft Team. Den kan kjøres på flere GPUer eller multimaskiner for å trene dyp læringsmodell i massiv skala. I noen tilfeller ble CNTK rapportert raskere enn andre rammeverk som Tensorflow eller Theano. Neste i denne Keras CNN-opplæringen vil vi sammenligne backends av Theano, TensorFlow og CNTK.
Sammenligning av backends
Vi må gjøre en benchmark for å kjenne sammenligningen mellom disse to backends. Som du kan se i Jeong-Yoon Lees benchmark, sammenlignes ytelsen til 3 forskjellige backends på forskjellig maskinvare. Og resultatet er at Theano er tregere enn den andre backend, er det rapportert 50 ganger tregere, men nøyaktigheten er nær hverandre.
En annen benchmark test utføres av Jasmeet Bhatia. Han rapporterte at Theano er tregere enn Tensorflow for noen tester. Men den generelle nøyaktigheten er nesten den samme for hvert nettverk som ble testet.
Så mellom Theano, Tensorflow og CTK er det åpenbart at TensorFlow er bedre enn Theano. Med TensorFlow er beregningstiden mye kortere og CNN er bedre enn de andre.
Neste i denne Keras Python veiledning, vil vi lære om forskjellen mellom Keras og TensorFlow (Keras vs Tensorflow).
Keras vs Tensorflow
parametere | Keras | tensorflow |
---|---|---|
typen | API-innpakning på høyt nivå | API på lavt nivå |
kompleksitet | Enkel å bruke hvis du Python Språk | Du må lære syntaksen for å bruke noen av Tensorflow-funksjonene |
Formål | Rask distribusjon for å lage modell med standardlag | Lar deg lage en vilkårlig beregningsgraf eller modelllag |
verktøy | Bruker andre API-feilsøkingsverktøy som TFDBG | Du kan bruke Tensorboard-visualiseringsverktøy |
fellesskapet | Store aktive samfunn | Store aktive samfunn og mye delte ressurser |
Fordeler med Keras
Rask distribusjon og enkel å forstå
Keras er veldig rask til å lage en nettverksmodell. Hvis du vil lage en enkel nettverksmodell med noen få linjer, Python Keras kan hjelpe deg med det. Se på Keras-eksemplet nedenfor:
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'))
På grunn av vennlig API, kan vi enkelt forstå prosessen. Skrive koden med en enkel funksjon og ingen grunn til å angi flere parametere.
Stor samfunnsstøtte
Det er mange AI-miljøer som bruker Keras som rammeverk for dyp læring. Mange av dem publiserer kodene sine i tillegg til opplæringsprogrammer for allmennheten.
Har flere backends
Du kan velge Tensorflow, CNTK og Theano som backend med Keras. Du kan velge en annen backend for forskjellige prosjekter avhengig av dine behov. Hver backend har sin egen unike fordel.
På tvers av plattformer og enkel modellimplementering
Med en rekke støttede enheter og plattformer kan du distribuere Keras på hvilken som helst enhet som
- iOS med CoreML
- Android med Tensorflow Android,
- Nettleser med .js-støtte
- Skymotor
- Raspberry Pi
Støtte for flere GPUer
Du kan trene Keras på en enkelt GPU eller bruke flere GPUer samtidig. Fordi Keras har en innebygd støtte for dataparallellisme, slik at den kan behandle store datamengder og øke tiden som trengs for å trene den.
Ulemper med Keras
Kan ikke håndtere API på lavt nivå
Keras håndterer bare API på høyt nivå som kjører på toppen av andre rammeverk eller backend-motorer som Tensorflow, Theano eller CNTK. Så det er ikke veldig nyttig hvis du vil lage ditt eget abstrakte lag for forskningsformål fordi Keras allerede har forhåndskonfigurerte lag.
Installerer Keras
I denne delen vil vi se på ulike metoder som er tilgjengelige for å installere Keras
Direkte installasjon eller virtuelt miljø
Hvilken er bedre? Installere direkte til gjeldende python eller bruke et virtuelt miljø? Jeg foreslår at du bruker et virtuelt miljø hvis du har mange prosjekter. Vil du vite hvorfor? Dette er fordi forskjellige prosjekter kan bruke en annen versjon av et keras-bibliotek.
Jeg har for eksempel et prosjekt som trenger Python 3.5 bruker OpenCV 3.3 med eldre Keras-Theano backend, men i det andre prosjektet må jeg bruke Keras med den nyeste versjonen og en Tensorflow som backend med Python 3.6.6-støtte
Vi vil vel ikke at Keras-biblioteket skal komme i konflikt med hverandre? Så vi bruker et virtuelt miljø for å lokalisere prosjektet med en bestemt type bibliotek, eller vi kan bruke en annen plattform som Cloud Service for å gjøre beregningene våre for oss som Amazon Webtjeneste.
Installerer Keras på Amazon Netttjeneste (AWS)
Amazon Web Service er en plattform som tilbyr Cloud Computing-tjenester og produkter for forskere eller andre formål. AWS leier deres maskinvare, nettverk, database osv. slik at vi kan bruke det direkte fra internett. En av de populære AWS-tjenestene for dyplæringsformål er Amazon Machine Image Deep Learning Service eller DL
For detaljerte instruksjoner om hvordan du bruker AWS, se denne tutorial
Merknad om AMI: Du vil ha følgende AMI tilgjengelig
AWS Deep Learning AMI er et virtuelt miljø i AWS EC2 Service som hjelper forskere eller praktikere å jobbe med Deep Learning. DLAMI tilbyr fra små CPU-motorer opp til kraftige multi-GPU-motorer med forhåndskonfigurert CUDA, cuDNN, og kommer med en rekke dype læringsrammer.
Hvis du vil bruke den umiddelbart, bør du velge Deep Learning AMI fordi den leveres forhåndsinstallert med populære rammeverk for dyp læring.
Men hvis du vil prøve et tilpasset dyplæringsrammeverk for forskning, bør du installere Deep Learning Base AMI fordi det kommer med grunnleggende biblioteker som CUDA, cuDNN, GPU-drivere og andre nødvendige biblioteker for å kjøre med ditt dype læringsmiljø.
Hvordan installere Keras på Amazon SageMaker
Amazon SageMaker er en dyp læringsplattform for å hjelpe deg med opplæring og distribusjon av dyplæringsnettverk med den beste algoritmen.
Som nybegynner er dette den desidert enkleste metoden for å bruke Keras. Nedenfor er en prosess for hvordan du installerer Keras på Amazon SageMaker:
Trinn 1) Åpne Amazon SageMaker
I det første trinnet åpner du Amazon Sagemaker konsollen og klikk på Opprett notatbokforekomst.
Trinn 2) Skriv inn detaljene
- Skriv inn notatboknavnet.
- Opprett en IAM-rolle. Det vil skape en AMI-rolle Amazon IAM rolle i formatet av AmazonSageMaker-Executionrolle-ÅÅÅÅMMDD|HHmmSS.
- Til slutt velger du Opprett notatbokforekomst. Etter noen få øyeblikk, Amazon Sagemaker lanserer en notatbokforekomst.
Merknader: Hvis du ønsker å få tilgang til ressurser fra din VPC, setter du direkte internettilgang som aktivert. Ellers vil ikke denne bærbare forekomsten ha internettilgang, så det er umulig å trene eller være vert for modeller
Trinn 3) Start forekomsten
Klikk på Åpne for å starte forekomsten
Trinn 4) Start kodingen
In Jupyter, Klikk på Ny> conda_tensorflow_p36 og du er klar til å kode
Installer Keras i Linux
For å aktivere Keras med Tensorflow som backend-motor, må vi installere Tensorflow først. Kjør denne kommandoen for å installere tensorflow med CPU (ingen GPU)
pip install --upgrade tensorflow
hvis du vil aktivere GPU-støtten for tensorflow, kan du bruke denne kommandoen
pip install --upgrade tensorflow-gpu
la oss sjekke inn Python for å se om installasjonen vår er vellykket ved å skrive
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 >>>
hvis det ikke er noen feilmelding, er installasjonsprosessen vellykket
Installer Keras
Etter at vi har installert Tensorflow, la oss begynne å installere keras. Skriv inn denne kommandoen i terminalen
pip install keras
den vil begynne å installere Keras og også alle dens avhengigheter. Du bør se noe sånt som dette:
Nå har vi Keras installert i systemet vårt!
Bekrefter
Før vi begynner å bruke Keras, bør vi sjekke om våre Keras bruker Tensorflow som backend ved å åpne konfigurasjonsfilen:
gedit ~/.keras/keras.json
du burde se noe slikt
{ "floatx": "float32", "epsilon": 1e-07, "backend": "tensorflow", "image_data_format": "channels_last" }
som du kan se, bruker "backend" tensorflow. Det betyr at keras bruker Tensorflow som backend som vi forventet
og kjør den nå på terminalen ved å skrive
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. >>>
Hvordan installere Keras på Windows
Før vi installerer tensorflow og Keras, vi burde installere Python, pip og virtualenv. Hvis du allerede har installert disse bibliotekene, bør du fortsette til neste trinn, ellers gjør du dette:
Install Python 3 ved å laste ned fra denne link
Installer pip ved å kjøre denne
Installer virtualenv med denne kommandoen
pip3 install –U pip virtualenv
Install Microsoft Visual C++ 2015 omdistribuerbar oppdatering 3
- Gå til nedlastingssiden for Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Velg Redistribuerbare og byggeverktøy
- Last ned og installer Microsoft Visual C++ 2015 omdistribuerbar oppdatering 3
Kjør deretter dette skriptet
pip3 install virtualenv
Sett opp virtuelt miljø
Dette brukes til å isolere arbeidssystemet med hovedsystemet.
virtualenv –-system-site-packages –p python3 ./venv
Aktiver miljøet
.\venv\Scripts\activate
Etter å ha forberedt miljøet, forblir installasjonen av Tensorflow og Keras den samme som Linux. Neste i denne Deep learning with Keras-opplæringen vil vi lære om Keras grunnleggende for Deep learning.
Keras Fundamentals for Deep Learning
Hovedstrukturen i Keras er modellen som definerer hele grafen til et nettverk. Du kan legge til flere lag til en eksisterende modell for å bygge en tilpasset modell som du trenger for prosjektet ditt.
Her er hvordan du lager en sekvensiell modell og noen få ofte brukte lag i dyp læring
1. Sekvensiell modell
from keras.models import Sequential from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout model = Sequential()
2. Konvolusjonslag
Dette er en Keras Python eksempel på konvolusjonslag som inngangslag med inngangsformen 320x320x3, med 48 filtre i størrelsen 3×3 og bruk ReLU som en aktiveringsfunksjon.
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))
en annen type er
model.add(Conv2D(48, (3, 3), activation='relu'))
3. MaksPooling Lag
For å nedsample inndatarepresentasjonen, bruk MaxPool2d og spesifiser kjernestørrelsen
model.add(MaxPooling2D(pool_size=(2, 2)))
4. Tett lag
legge til et fullstendig tilkoblet lag med bare å spesifisere utdatastørrelsen
model.add(Dense(256, activation='relu'))
5. Frafallslag
Legger til dropout-lag med 50 % sannsynlighet
model.add(Dropout(0.5))
Kompilere, trene og evaluere
Etter at vi har definert modellen vår, la oss begynne å trene dem. Det er nødvendig å kompilere nettverket først med tapsfunksjonen og optimeringsfunksjonen. Dette vil tillate nettverket å endre vekter og minimere tapet.
model.compile(loss='mean_squared_error', optimizer='adam')
Nå for å begynne å trene, bruk fit for å mate trenings- og valideringsdataene til modellen. Dette vil tillate deg å trene nettverket i grupper og sette epoker.
model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))
Vårt siste trinn er å evaluere modellen med testdataene.
score = model.evaluate(x_test, y_test, batch_size=32)
La oss prøve å bruke enkel lineær regresjon
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()
Etter å ha trent dataene, skal utdataene se slik ut
med startvekten
Linear regression model is initialized with weights w: 0.37, b: 0.00
og sluttvekt
Linear regression model is trained to have weight w: 3.70, b: 0.61
Finjuster ferdigtrente modeller i Keras og hvordan du bruker dem
Hvorfor vi bruker Fine Tune-modeller og når vi bruker det
Finjustering er en oppgave for å tilpasse en forhåndstrent modell slik at parameterne tilpasser seg den nye modellen. Når vi skal trene fra bunnen av på en ny modell, trenger vi en stor mengde data, slik at nettverket kan finne alle parametere. Men i dette tilfellet vil vi bruke en forhåndstrent modell slik at parametrene allerede er lært og har en vekt.
For eksempel, hvis vi ønsker å trene vår egen Keras-modell for å løse et klassifiseringsproblem, men vi bare har en liten mengde data, kan vi løse dette ved å bruke en Overfør læring + Finjusteringsmetode.
Ved å bruke et forhåndstrent nettverk og vekter trenger vi ikke å trene hele nettverket. Vi trenger bare å trene det siste laget som brukes til å løse oppgaven vår som vi kaller det Fine-Tuning-metoden.
Forberedelse av nettverksmodell
For den forhåndstrente modellen kan vi laste inn en rekke modeller som Keras allerede har i biblioteket, for eksempel:
- VGG16
- BegynnelseV3
- ResNet
- MobileNet
- Xception
- InceptionResNetV2
Men i denne prosessen vil vi bruke VGG16 nettverksmodell og imageNet som vekt for modellen. Vi vil finjustere et nettverk for å klassifisere 8 forskjellige typer klasser ved å bruke Bilder fra Kaggle Natural Images Datasett
VGG16 modellarkitektur
Laster opp dataene våre til AWS S3 Bucket
For treningsprosessen vår vil vi bruke et bilde av naturlige bilder fra 8 forskjellige klasser som fly, bil, katt, hund, blomst, frukt, motorsykkel og person. Først må vi laste opp dataene våre til Amazon S3 bøtte.
Amazon S3 bøtte
Trinn 1) Etter å ha logget på S3-kontoen din, la oss lage en bøtte ved å klokke Lag bøtte
Trinn 2) Velg nå et bøttenavn og din region i henhold til kontoen din. Sørg for at bøttenavnet er tilgjengelig. Etter det klikk Skape.
Trinn 3) Som du kan se, er bøtten din klar til bruk. Men som du kan se, er tilgangen ikke offentlig, den er bra for deg hvis du vil holde den privat for deg selv. Du kan endre denne bøtten for offentlig tilgang i bøtteegenskaper
Trinn 4) Nå begynner du å laste opp treningsdataene dine til Bucket. Her vil jeg laste opp tar.gz-filen som består av bilder for trening og testprosess.
Trinn 5) Klikk nå på filen og kopier link slik at vi kan laste den ned.
Dataklargjøring
Vi må generere treningsdataene våre ved å bruke Keras ImageDataGenerator.
Først må du laste ned ved hjelp av wget med lenken til filen din fra S3 Bucket.
!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz !tar -xzf images.tar.gz
Etter at du har lastet ned dataene, la oss starte opplæringsprosessen.
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)
BildedataeneGenerator vil lage en X_treningsdata fra en katalog. Underkatalogen i den katalogen vil bli brukt som en klasse for hvert objekt. Bildet vil bli lastet med RGB-fargemodus, med kategorisk klassemodus for Y_treningsdata, med en batchstørrelse på 16. Til slutt blander du dataene.
La oss se bildene våre tilfeldig ved å plotte dem med matplotlib
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()
La oss deretter lage vår nettverksmodell fra VGG16 med forhåndstrent imageNet vekt. Vi vil fryse disse lagene slik at lagene ikke er trenbare for å hjelpe oss med å redusere beregningstiden.
Oppretter vår modell fra VGG16
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())
Som du kan se nedenfor, sammendraget av nettverksmodellen vår. Fra en inngang fra VGG16 Layers legger vi til 2 Fully Connected Layer som vil trekke ut 1024 funksjoner og et utgangslag som vil beregne de 8 klassene med softmax-aktiveringen.
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
Kurs
# # 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()
Resultater
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
Som du kan se, er tapene våre betydelig redusert og nøyaktigheten er nesten 100 %. For å teste modellen vår valgte vi tilfeldig bilder over internett og la dem i testmappen med en annen klasse for å teste
Tester vår modell
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()
Og testen vår er som gitt nedenfor! Kun 1 bilde er spådd feil fra en test av 14 bilder!
Ansiktsgjenkjenning nevralt nettverk med Keras
Hvorfor vi trenger anerkjennelse
Vi trenger anerkjennelse for å gjøre det lettere for oss å gjenkjenne eller identifisere en persons ansikt, gjenstandstype, beregnet alder på en person fra ansiktet hans, eller til og med kjenne ansiktsuttrykkene til den personen.
Kanskje du innser at hver gang du prøver å merke vennens ansikt i et bilde, har funksjonen i Facebook gjort det for deg, det vil si å merke vennens ansikt uten at du trenger å merke det først. Dette er ansiktsgjenkjenning brukt av Facebook for å gjøre det enklere for oss å tagge venner.
Så hvordan fungerer det? Hver gang vi markerer ansiktet til vennen vår, vil Facebooks AI lære det og vil prøve å forutsi det til det får det riktige resultatet. Det samme systemet vil vi bruke til å lage vår egen ansiktsgjenkjenning. La oss begynne å lage vår egen ansiktsgjenkjenning ved hjelp av Deep Learning
Nettverksmodell
Vi vil bruke en VGG16 nettverksmodell, men med VGGFace-vekt.
VGG16 modellarkitektur
Hva er VGGFace? det er Keras implementering av Deep Face Recognition introdusert av Parkhi, Omkar M. et al. "Dyp ansiktsgjenkjenning." BMVC (2015). Rammeverket bruker VGG16 som nettverksarkitektur.
Du kan laste ned VGGFace fra 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()
Som du kan se nettverkssammendraget
_________________________________________________________________ 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):
vi vil gjøre en Overfør læring + Finjustering for å gjøre treningen raskere med små datasett. Først skal vi fryse grunnlagene slik at lagene ikke er trenbare.
for layer in face_model.layers: layer.trainable = False
så legger vi til vårt eget lag for å gjenkjenne testansiktene våre. Vi vil legge til 2 fullt tilkoblede lag og et utgangslag med 5 personer for å oppdage.
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)
La oss se nettverkssammendraget vårt
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
Som du kan se ovenfor, etter pool5-laget, vil det bli flatet ut til en enkelt funksjonsvektor som vil bli brukt av det tette laget for den endelige gjenkjenningen.
Forbereder ansiktene våre
La oss nå forberede ansiktene våre. Jeg laget en katalog bestående av 5 kjente personer
- Jack Ma
- Jason Statham
- Johnny Depp
- Robert Downey jr
- Rowan Atkinson
Hver mappe inneholder 10 bilder, for hver opplærings- og evalueringsprosess. Det er en veldig liten mengde data, men det er utfordringen, ikke sant?
Vi vil bruke hjelpen fra Keras-verktøyet for å hjelpe oss med å forberede dataene. Denne funksjonen vil iterere i datasettmappen og deretter forberede den slik at den kan brukes i opplæringen.
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, )
Trening vår modell
La oss begynne treningsprosessen vår ved å kompilere nettverket vårt med tapsfunksjon og optimizer. Her bruker vi sparse_categorical_crossentropy som vår tapsfunksjon, ved hjelp av SGD som vår læringsoptimalisator.
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
Som du kan se, er vår valideringsnøyaktighet opptil 64 %, dette er et godt resultat for en liten mengde treningsdata. Vi kan forbedre dette ved å legge til flere lag eller legge til flere treningsbilder slik at modellen vår kan lære mer om ansiktene og oppnå mer nøyaktighet.
La oss teste modellen vår med et testbilde
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']
ved å bruke Robert Downey Jr.-bilde som vårt testbilde, viser det at det forutsagte ansiktet er sant!
Forutsigelse ved hjelp av Live Cam!
Hva med om vi tester ferdighetene våre med å implementere det med innspill fra et webkamera? Ved å bruke OpenCV med Haar Face-kaskade for å finne ansiktet vårt, og ved hjelp av vår nettverksmodell kan vi gjenkjenne personen.
Det første trinnet er å forberede deg og vennens ansikter. Jo mer data vi har, jo bedre blir resultatet!
Forbered og tren nettverket ditt som forrige trinn, etter at treningen er fullført, legg til denne linjen for å få inndatabildet fra cam
#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()
Hvilken er bedre? Keras eller Tensorflow
Keras tilbyr enkelhet når du skriver manuset. Vi kan begynne å skrive og forstå direkte med Keras, siden det ikke er så vanskelig å forstå. Det er mer brukervennlig og enkelt å implementere, du trenger ikke lage mange variabler for å kjøre modellen. Så vi trenger ikke å forstå alle detaljer i backend-prosessen.
På den annen side er Tensorflow operasjonene på lavt nivå som tilbyr fleksibilitet og avanserte operasjoner hvis du vil lage en vilkårlig beregningsgraf eller modell. Tensorflow kan også visualisere prosessen ved hjelp av TensorBoard og et spesialisert feilsøkingsverktøy.
Så hvis du vil begynne å jobbe med dyp læring med ikke så mye kompleksitet, bruk Keras. Fordi Keras tilbyr enkelhet og brukervennlig å bruke og enkel å implementere enn Tensorflow. Men hvis du vil skrive din egen algoritme i dyplæringsprosjekt eller forskning, bør du bruke Tensorflow i stedet.
Oppsummering
Så la oss oppsummere alt vi har diskutert og gjort i denne opplæringen.
- Keras i et høynivå-API som brukes til å gjøre dyplæringsnettverk enklere ved hjelp av backend-motoren.
- Keras er lett å bruke og forstå med python-støtte, så det føles mer naturlig enn noen gang. Det er bra for nybegynnere som ønsker å lære om dyp læring og for forskere som ønsker brukervennlig API.
- Installasjonsprosessen er enkel og du kan bruke et virtuelt miljø eller bruke en ekstern plattform som f.eks AWS.
- Keras kommer også med ulike typer nettverksmodeller slik at det gjør oss lettere å bruke den tilgjengelige modellen for å forhåndstrene og finjustere vår egen nettverksmodell.
- Det er også mange opplæringsprogrammer og artikler om bruk av Keras fra fellesskap over hele verden for dyplæringsformål.