Keras-zelfstudie: Wat is Keras? Hoe te installeren in Python [Voorbeeld]

Wat is Keras?

Keras is een Open Source Neural Network-bibliotheek geschreven in Python en draait bovenop Theano of Tensorflow. Het is ontworpen om modulair, snel en gemakkelijk te gebruiken te zijn. Het is ontwikkeld door François Chollet, een Google-ingenieur. Keras kan geen berekeningen op laag niveau uitvoeren. In plaats daarvan gebruikt het een andere bibliotheek om dit te doen, genaamd de “Backend.

Keras is een API-wrapper op hoog niveau voor de API op laag niveau, die bovenop TensorFlow, CNTK of Theano kan worden uitgevoerd. Keras High-Level API regelt de manier waarop we modellen maken, lagen definiëren of meerdere input-output-modellen opzetten. Op dit niveau stelt Keras ook ons ​​model samen met verlies- en optimalisatiefuncties, trainingsproces met fit-functie. Keras in Python verwerkt geen Low-Level API, zoals het maken van de computationele grafiek, het maken van tensoren of andere variabelen, omdat dit wordt afgehandeld door de "backend" -engine.

Wat is een backend?

Backend is een term in Keras die alle berekeningen op laag niveau uitvoert, zoals tensorproducten, convoluties en vele andere dingen, met behulp van andere bibliotheken zoals Tensorflow of Theano. De “backend-engine” zal dus de berekening en ontwikkeling van de modellen uitvoeren. Tensorflow is de standaard “backend-engine”, maar we kunnen dit in de configuratie wijzigen.

Theano, Tensorflow en CNTK-backend

Backend van Theano

Theano is een open source-project dat is ontwikkeld door de MILA-groep aan de Universiteit van Montreal, Quebec, Canada. Het was het eerste veelgebruikte raamwerk. Het is een Python-bibliotheek die helpt bij multidimensionale arrays voor wiskundige bewerkingen met behulp van Numpy of Scipy. Theano kan GPU's gebruiken voor snellere berekeningen, maar kan ook automatisch symbolische grafieken bouwen voor het berekenen van gradiënten. Op zijn website beweert Theano dat het numeriek onstabiele uitdrukkingen kan herkennen en deze kan berekenen met stabielere algoritmen, dit is erg handig voor onze onstabiele uitdrukkingen.

Backend van TensorFlow

Aan de andere kant is Tensorflow de rijzende ster in het deep learning-framework. Het is ontwikkeld door het Brain-team van Google en is de populairste deep learning-tool. Met veel functies, en onderzoekers dragen bij aan de ontwikkeling van dit raamwerk voor diepgaande leerdoeleinden.

Backend van CNTK

Een andere backend-engine voor Keras is The Microsoft Cognitieve Toolkit of CNTK. Het is een open-source deep learning-framework dat is ontwikkeld door Microsoft Team. Het kan draaien op meerdere GPU's of meerdere machines voor het op grote schaal trainen van een deep learning-model. In sommige gevallen werd CNTK sneller gerapporteerd dan andere raamwerken zoals Tensorflow of Theano. Vervolgens vergelijken we in deze Keras CNN-tutorial de backends van Theano, TensorFlow en CNTK.

Vergelijking van de backends

We moeten een benchmark uitvoeren om de vergelijking tussen deze twee backends te kennen. Zoals je daarin kunt zien De maatstaf van Jeong-Yoon Lee, worden de prestaties van 3 verschillende backends op verschillende hardware vergeleken. En het resultaat is dat Theano langzamer is dan de andere backend, zo wordt gemeld 50 keer langzamer, maar de nauwkeurigheid ligt dicht bij elkaar.

Nog een benchmark test wordt uitgevoerd door Jasmeet Bhatia. Hij meldde dat Theano voor sommige tests langzamer is dan Tensorflow. Maar de algehele nauwkeurigheid is vrijwel hetzelfde voor elk getest netwerk.

Dus tussen Theano, Tensorflow en CTK is het duidelijk dat TensorFlow beter is dan Theano. Met TensorFlow is de rekentijd veel korter en is CNN beter dan de andere.

Vervolgens zullen we in deze Keras Python-tutorial leren over het verschil tussen Keras en TensorFlow (Keras versus Tensorflow).

Keras versus Tensorflow

parameters Keras tensorstroom
Type API-wrapper op hoog niveau API op laag niveau
complexity Gemakkelijk te gebruiken als je Python-taal gebruikt U moet de syntaxis leren van het gebruik van een deel van de Tensorflow-functie
Doel Snelle implementatie voor het maken van modellen met standaardlagen Hiermee kunt u een willekeurige computergrafiek of modellagen maken
Tools Maakt gebruik van een ander API-foutopsporingsprogramma, zoals TFDBG U kunt Tensorboard-visualisatietools gebruiken
Gemeenschap Grote actieve gemeenschappen Grote actieve gemeenschappen en breed gedeelde bronnen

Voordelen van Keras

Snelle implementatie en gemakkelijk te begrijpen

Keras maakt heel snel een netwerkmodel. Als je met een paar regels een eenvoudig netwerkmodel wilt maken, kan Python Keras je daarbij helpen. Kijk naar het Keras-voorbeeld hieronder:

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

Dankzij de vriendelijke API kunnen we het proces gemakkelijk begrijpen. Het schrijven van de code met een eenvoudige functie en het is niet nodig om meerdere parameters in te stellen.

Grote gemeenschapsondersteuning

Er zijn veel AI-gemeenschappen die Keras gebruiken voor hun Deep Learning-framework. Velen van hen publiceren hun codes en tutorials voor het grote publiek.

Zorg voor meerdere backends

U kunt Tensorflow, CNTK en Theano kiezen als uw backend met Keras. Afhankelijk van uw behoeften kunt u voor verschillende projecten een andere backend kiezen. Elke backend heeft zijn eigen unieke voordeel.

Platformonafhankelijke en eenvoudige modelimplementatie

Met een verscheidenheid aan ondersteunde apparaten en platforms kunt u Keras op elk apparaat implementeren

  • iOS met CoreML
  • Android met Tensorflow Android,
  • Webbrowser met .js-ondersteuning
  • Cloud-motor
  • Raspberry Pi

Ondersteuning voor meerdere GPU's

Je kunt Keras op één GPU trainen of meerdere GPU's tegelijk gebruiken. Omdat Keras ingebouwde ondersteuning voor gegevensparallellisme heeft, kan het grote hoeveelheden gegevens verwerken en de tijd die nodig is om deze te trainen versnellen.

Nadelen van Keras

Kan API op laag niveau niet verwerken

Keras verwerkt alleen API's op hoog niveau die draaien op een ander framework of een backend-engine zoals Tensorflow, Theano of CNTK. Het is dus niet erg handig als u uw eigen abstracte laag wilt maken voor uw onderzoeksdoeleinden, omdat Keras al vooraf geconfigureerde lagen heeft.

Keras installeren

In deze sectie zullen we kijken naar de verschillende methoden die beschikbaar zijn om Keras te installeren

Directe installatie of virtuele omgeving

Welke is beter? Direct installeren op de huidige Python of een virtuele omgeving gebruiken? Ik stel voor om een ​​virtuele omgeving te gebruiken als je veel projecten hebt. Wil je weten waarom? Dit komt omdat verschillende projecten mogelijk een andere versie van een Keras-bibliotheek gebruiken.

Ik heb bijvoorbeeld een project dat Python 3.5 nodig heeft met OpenCV 3.3 met oudere Keras-Theano-backend, maar in het andere project moet ik Keras gebruiken met de nieuwste versie en een Tensorflow als backend met Python 3.6.6-ondersteuning

We willen niet dat de Keras-bibliotheek met elkaar in conflict komt, toch? We gebruiken dus een virtuele omgeving om het project te lokaliseren met een specifiek type bibliotheek, of we kunnen een ander platform zoals Cloud Service gebruiken om onze berekeningen voor ons uit te voeren, zoals Amazon Webservice.

Keras installeren Amazon Webservice (AWS)

Amazon Web Service is een platform dat Cloud Computing-services en -producten aanbiedt voor onderzoekers of andere doeleinden. AWS verhuurt hun hardware, netwerken, database, etc. zodat we deze rechtstreeks vanaf internet kunnen gebruiken. Een van de populaire AWS-services voor deep learning-doeleinden is de Amazon Machine Image Deep Learning Service of DL

Raadpleeg dit voor gedetailleerde instructies over het gebruik van AWS zelfstudie

Opmerking over de AMI: u krijgt de volgende informatiewing AMI beschikbaar

Keras installeren op AWS

AWS Deep Learning AMI is een virtuele omgeving in AWS EC2 Service die onderzoekers of praktijkmensen helpt om met Deep Learning te werken. DLAMI biedt een kleine CPU-engine tot krachtige multi-GPU-engines met vooraf geconfigureerde CUDA, cuDNN en wordt geleverd met een verscheidenheid aan deep learning-frameworks.

Als je het direct wilt gebruiken, moet je Deep Learning AMI kiezen, omdat het vooraf is geïnstalleerd met populaire deep learning-frameworks.

Maar als u een aangepast deep learning-framework voor onderzoek wilt uitproberen, moet u de Deep Learning Base AMI installeren, omdat deze wordt geleverd met fundamentele bibliotheken zoals CUDA, cuDNN, GPU's-stuurprogramma's en andere benodigde bibliotheken die met uw deep learning-omgeving kunnen worden uitgevoerd.

Hoe Keras te installeren op Amazon SageMaker

Amazon SageMaker is een deep learning-platform dat u helpt bij het trainen en inzetten van een deep learning-netwerk met het beste algoritme.

Als beginner is dit veruit de gemakkelijkste methode om Keras te gebruiken. Hieronder vindt u een proces voor het installeren van Keras Amazon SalieMaker:

Stap 1) Openen Amazon SageMaker

In de eerste stap opent u het Amazon Saliemaker console en klik op Notebook-instantie maken.

Installeer Keras op Amazon SageMaker

Stap 2) Voer de de intails

  1. Voer uw notitieboekjenaam in.
  2. Maak een IAM-rol. Het zal een AMI-rol creëren Amazon IAM-rol in het formaat van AmazonSageMaker-uitvoeringsrol-JJJJMMDD|HHmmSS.
  3. Kies ten slotte Notebook-exemplaar maken. Na enkele ogenblikken, Amazon Sagemaker lanceert een notebookinstantie.

Installeer Keras op Amazon SageMaker

Note: Als u toegang wilt krijgen tot bronnen vanaf uw VPC, stelt u de directe internettoegang in als ingeschakeld. Anderwise, heeft deze notebookinstantie geen internettoegang, dus het is onmogelijk om modellen te trainen of te hosten

Stap 3) Start de instantie

Klik op Openen om het exemplaar te starten

Installeer Keras op Amazon SageMaker

Stap 4) Begin met coderen

In Jupyter, Klik op Nieuw> conda_tensorflow_p36 en je bent klaar om te coderen

Installeer Keras op Amazon SageMaker

Installeer Keras onder Linux

Om Keras met Tensorflow als backend-engine in te schakelen, moeten we eerst Tensorflow installeren. Voer deze opdracht uit om tensorflow met CPU (geen GPU) te installeren

pip install --upgrade tensorflow

als u de GPU-ondersteuning voor tensorflow wilt inschakelen, kunt u deze opdracht gebruiken

pip install --upgrade tensorflow-gpu

Installeer Keras op Linux

laten we Python controleren om te zien of onze installatie succesvol is door te typen

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

als er geen foutmelding is, is het installatieproces succesvol

Keras installeren

Nadat we Tensorflow hebben geïnstalleerd, gaan we Keras installeren. Typ deze opdracht in de terminal

pip install keras

het zal beginnen met het installeren van Keras en ook al zijn afhankelijkheden. Je zou zoiets als dit moeten zien:

Keras installeren

Nu hebben we Keras in ons systeem geïnstalleerd!

Het verifiëren

Voordat we Keras gaan gebruiken, moeten we controleren of onze Keras Tensorflow als backend gebruiken door het configuratiebestand te openen:

gedit ~/.keras/keras.json

zoiets zou je moeten zien

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

zoals je kunt zien, gebruikt de “backend” tensorflow. Het betekent dat Keras Tensorflow als backend gebruikt, zoals we hadden verwacht

en voer het nu uit op de terminal door te typen

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

Hoe Keras te installeren op Windows

Voordat we installeren tensorstroom en Keras, we moeten Python, pip en virtualenv installeren. Als u deze bibliotheken al hebt geïnstalleerd, moet u doorgaan naar de volgende stap, anderswise doe dit:

Installeer Python 3 door hiervan te downloaden link

Installeer pip door te rennen dit

Installeer virtualenv met deze opdracht

pip3 install –U pip virtualenv

Install Microsoft Visual C++ 2015 herdistribueerbare update 3

Voer vervolgens dit script uit

pip3 install virtualenv

Virtuele omgeving instellen

Dit wordt gebruikt om het werkende systeem te isoleren van het hoofdsysteem.

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

Activeer de omgeving

.\venv\Scripts\activate

Na het voorbereiden van de omgeving blijft de installatie van Tensorflow en Keras hetzelfde als die van Linux. Vervolgens zullen we in deze Deep learning met Keras-tutorial meer leren over de basisbeginselen van Keras voor Deep learning.

Keras-fundamenten voor diep leren

De hoofdstructuur in Keras is het model dat de volledige grafiek van een netwerk definieert. U kunt meer lagen aan een bestaand model toevoegen om een ​​aangepast model te bouwen dat u nodig heeft voor uw project.

Hier leest u hoe u een sequentieel model maakt en enkele veelgebruikte lagen bij deep learning

1. Sequentieel model

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

model = Sequential()

2. Convolutionele laag

Dit is een Keras Python-voorbeeld van een convolutionele laag als invoerlaag met de invoervorm van 320x320x3, met 48 filters van grootte 3x3 en gebruik ReLU als activeringsfunctie.

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

een ander soort is

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

3. MaxPooling Laag

Om de invoerrepresentatie te downsamplen, gebruikt u MaxPool2d en specificeert u de kernelgrootte

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

4. Dichte laag

het toevoegen van een volledig verbonden laag door alleen de uitvoergrootte op te geven

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

5. Uitvallaag

Uitvallaag toevoegen met een waarschijnlijkheid van 50%

model.add(Dropout(0.5))

Samenstellen, trainen en evalueren

Nadat we ons model hebben gedefinieerd, gaan we ze trainen. Het is vereist om eerst het netwerk te compileren met de verliesfunctie en de optimalisatiefunctie. Hierdoor kan het netwerk de gewichten wijzigen en wordt het verlies geminimaliseerd.

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

Om te beginnen met trainen, gebruikt u fit om de trainings- en validatiegegevens aan het model toe te voegen. Hierdoor kunt u het netwerk in batches trainen en de tijdperken instellen.

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

Onze laatste stap is het evalueren van het model met de testgegevens.

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

Laten we proberen eenvoudige lineaire regressie te gebruiken

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

Na het trainen van de gegevens zou de uitvoer er als volgt uit moeten zien

Lineaire regressie

met het initiële gewicht

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

en eindgewicht

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

Verfijn vooraf getrainde modellen in Keras en hoe u ze kunt gebruiken

Waarom we Fine Tune Models gebruiken en wanneer we het gebruiken

Fijnafstemming is een taak waarbij een vooraf getraind model zodanig wordt aangepast dat de parameters zich aanpassen aan het nieuwe model. Als we vanaf nul willen trainen op een nieuw model, hebben we een grote hoeveelheid data nodig, zodat het netwerk alle parameters kan vinden. Maar in dit geval zullen we een vooraf getraind model gebruiken, zodat de parameters al geleerd zijn en een gewicht hebben.

Als we bijvoorbeeld ons eigen Keras-model willen trainen om een ​​classificatieprobleem op te lossen, maar we hebben slechts een kleine hoeveelheid gegevens, dan kunnen we dit oplossen door een Transfer leren + Fine-tuning-methode.

Met behulp van een vooraf getraind netwerk en gewichten hoeven we niet het hele netwerk te trainen. We hoeven alleen maar de laatste laag te trainen die wordt gebruikt om onze taak op te lossen, omdat we dit de Fine-Tuning-methode noemen.

Voorbereiding van netwerkmodellen

Voor het vooraf getrainde model kunnen we een verscheidenheid aan modellen laden die Keras al in zijn bibliotheek heeft, zoals:

  • VGG16
  • AanvangV3
  • ResNet
  • MobielNet
  • Xceptie
  • InceptionResNetV2

Maar in dit proces zullen we het VGG16-netwerkmodel en imageNet als ons gewicht voor het model gebruiken. We zullen een netwerk verfijnen om 8 verschillende soorten klassen te classificeren met behulp van Afbeeldingen van Kaggle Natural Images-gegevensset

VGG16-model architectuur

VGG16-model architectuur

(bron)

Onze gegevens uploaden naar AWS S3 Bucket

Voor ons trainingsproces gebruiken we een foto van natuurlijke afbeeldingen uit 8 verschillende klassen, zoals vliegtuigen, auto, kat, hond, bloem, fruit, motor en persoon. Eerst moeten we onze gegevens uploaden naar Amazon S3 Emmer.

Amazon S3-emmer

Stap 1) Nadat u zich heeft aangemeld bij uw S3-account, gaan we een bucket maken door te klokken Maak een bucket

Gegevens uploaden naar AWS S3-bucket

Stap 2) Kies nu een bucketnaam en uw regio op basis van uw account. Zorg ervoor dat de bucketnaam beschikbaar is. Daarna klik Maken.

Gegevens uploaden naar AWS S3-bucket

Stap 3) Zoals u ziet is uw Bucket klaar voor gebruik. Maar zoals u kunt zien, is de toegang niet openbaar. Het is goed voor u als u deze privé voor uzelf wilt houden. U kunt deze bucket wijzigen voor openbare toegang in de Bucket-eigenschappen

Gegevens uploaden naar AWS S3-bucket

Stap 4) Nu begin je met het uploaden van je trainingsgegevens naar je Bucket. Hier zal ik het tar.gz-bestand uploaden dat bestaat uit afbeeldingen voor het training- en testproces.

Gegevens uploaden naar AWS S3-bucket

Stap 5) Klik nu op uw bestand en kopieer het Link zodat we het kunnen downloaden.

Gegevens uploaden naar AWS S3-bucket

Data voorbereiding

We moeten onze trainingsgegevens genereren met behulp van Keras ImageDataGenerator.

Eerst moet u downloaden met wget met de link naar uw bestand vanuit S3 Bucket.

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

Nadat u de gegevens heeft gedownload, starten we het trainingsproces.

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)

De BeeldgegevensGenerator maakt een X_training-gegevens uit een map. De submap in die map wordt als klasse voor elk object gebruikt. De afbeelding wordt geladen met de RGB-kleurmodus, met de categorische klassenmodus voor de Y_training-gegevens, met een batchgrootte van 16. Schud ten slotte de gegevens in willekeurige volgorde.

Laten we onze afbeeldingen willekeurig bekijken door ze te plotten met 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()

Data voorbereiding

Laten we daarna ons netwerkmodel van VGG16 maken met voorgetraind imageNet-gewicht. We zullen deze lagen bevriezen zodat de lagen niet trainbaar zijn, zodat we de rekentijd kunnen verkorten.

Ons model maken op basis van 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())

Zoals u hieronder kunt zien, de samenvatting van ons netwerkmodel. Uit een invoer van VGG16-lagen voegen we 2 volledig verbonden lagen toe die 1024 functies zullen extraheren en een uitvoerlaag die de 8 klassen zal berekenen met de softmax-activering.

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

Trainingen

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

Resultaten

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

Trainingen

Zoals u kunt zien, zijn onze verliezen aanzienlijk gedaald en is de nauwkeurigheid bijna 100%. Om ons model te testen, hebben we willekeurig afbeeldingen via internet uitgekozen en in de testmap met een andere klasse geplaatst om te testen

Ons model testen

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

En onze test is zoals hieronder weergegeven! Uit een test van 1 afbeeldingen wordt slechts 14 afbeelding verkeerd voorspeld!

Testmodel

Gezichtsherkenning Neuraal netwerk met Keras

Waarom we erkenning nodig hebben

We hebben herkenning nodig om het gemakkelijker voor ons te maken om het gezicht van een persoon, het type voorwerp, de geschatte leeftijd van een persoon aan zijn gezicht te herkennen of te identificeren, of zelfs de gezichtsuitdrukkingen van die persoon te kennen.

Gezichtsherkenning Neuraal netwerk met Keras

Misschien realiseer je je elke keer dat je het gezicht van je vriend op een foto probeert te markeren, de functie op Facebook het voor je heeft gedaan: het gezicht van je vriend markeren zonder dat je het eerst hoeft te markeren. Dit is gezichtsherkenning die door Facebook wordt toegepast om het voor ons gemakkelijker te maken om vrienden te taggen.

Dus hoe werkt het? Elke keer dat we het gezicht van onze vriend markeren, zal de AI van Facebook dit leren en proberen het te voorspellen totdat het het juiste resultaat oplevert. Hetzelfde systeem zullen we gebruiken om onze eigen gezichtsherkenning te maken. Laten we beginnen met het maken van onze eigen gezichtsherkenning met behulp van Deep Learning

Netwerkmodel

We zullen een VGG16-netwerkmodel gebruiken, maar met VGGFace-gewicht.

VGG16-model architectuur

Netwerkmodel

Wat is VGGFace? het is Kera's implementatie van Deep Face Recognition geïntroduceerd door Parkhi, Omkar M. et al. “Diepe gezichtsherkenning.” BMVC (2015). Het raamwerk gebruikt VGG16 als netwerk archistructuur.

U kunt de VGGFace downloaden van 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()

Zoals u kunt zien in het netwerkoverzicht

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

wij zullen een doen Transfer leren + Fijnafstemming om de training sneller te maken met kleine datasets. Eerst gaan we de basislagen invriezen zodat de lagen niet trainbaar zijn.

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

vervolgens voegen we onze eigen laag toe om onze testgezichten te herkennen. We zullen 2 volledig verbonden lagen toevoegen en een uitvoerlaag met 5 personen om te detecteren.

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)

Laten we ons netwerkoverzicht bekijken

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

Zoals u hierboven kunt zien, wordt deze na de pool5-laag afgevlakt tot een enkele featurevector die door de dichte laag zal worden gebruikt voor de uiteindelijke herkenning.

Onze gezichten voorbereiden

Laten we nu onze gezichten voorbereiden. Ik heb een directory gemaakt die bestaat uit 5 beroemde mensen

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

Elke map bevat 10 foto's, voor elk training- en evaluatieproces. Het is een heel kleine hoeveelheid gegevens, maar dat is de uitdaging, toch?

We zullen de hulp van Keras-tool gebruiken om ons te helpen bij het voorbereiden van de gegevens. Deze functie herhaalt zich in de datasetmap en bereidt deze vervolgens voor, zodat deze in de training kan worden gebruikt.

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

Ons model trainen

Laten we ons trainingsproces beginnen door ons netwerk samen te stellen met verliesfunctie en optimalisatie. Hier gebruiken we sparse_categorical_crossentropy als onze verliesfunctie, met de hulp van SGD als onze leeroptimalisatie.

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

Zoals u kunt zien is onze validatienauwkeurigheid maximaal 64%, dit is een goed resultaat voor een kleine hoeveelheid trainingsgegevens. We kunnen dit verbeteren door meer lagen toe te voegen of meer trainingsafbeeldingen toe te voegen, zodat ons model meer over de gezichten kan leren en meer nauwkeurigheid kan bereiken.

Laten we ons model testen met een testfoto

Test afbeelding

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

Door de foto van Robert Downey Jr. als testfoto te gebruiken, blijkt dat het voorspelde gezicht waar is!

Voorspelling met Live Cam!

Hoe zit het als we onze vaardigheden testen door het te implementeren met de input van een webcam? Met behulp van OpenCV met Haar Face cascade kunnen we ons gezicht vinden en met behulp van ons netwerkmodel kunnen we de persoon herkennen.

De eerste stap is om de gezichten van jou en je vriend voor te bereiden. Hoe meer gegevens we hebben, hoe beter het resultaat is!

Bereid uw netwerk voor en train het zoals in de vorige stap. Nadat de training is voltooid, voegt u deze regel toe om het invoerbeeld van de cam te verkrijgen

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

Welke is beter? Keras of Tensorflow

Keras biedt eenvoud bij het schrijven van het script. We kunnen direct met Keras beginnen met schrijven en begrijpen, omdat het niet zo moeilijk te begrijpen is. Het is gebruiksvriendelijker en eenvoudiger te implementeren. U hoeft niet veel variabelen te maken om het model uit te voeren. We hoeven dus niet elk detail van het backend-proces te begrijpen.

Aan de andere kant zijn Tensorflow de bewerkingen op laag niveau die flexibiliteit en geavanceerde bewerkingen bieden als u een willekeurige computationele grafiek of model wilt maken. Tensorflow kan het proces ook visualiseren met behulp van TensorBoard en een gespecialiseerde debugger-tool.

Dus als je wilt gaan werken met deep learning met niet zoveel complexGebruik Keras. Omdat Keras eenvoud en gebruiksvriendelijker in gebruik en eenvoudiger te implementeren biedt dan Tensorflow. Maar als u uw eigen algoritme wilt schrijven in een deep learning-project of onderzoek, moet u in plaats daarvan Tensorflow gebruiken.

Samengevat

Laten we dus alles samenvatten wat we in deze tutorial hebben besproken en gedaan.

  • Keras in een API op hoog niveau die wordt gebruikt om deep learning-netwerken eenvoudiger te maken met behulp van een backend-engine.
  • Keras is gemakkelijk te gebruiken en te begrijpen met Python-ondersteuning, zodat het natuurlijker aanvoelt dan ooit. Het is goed voor beginners die willen leren over deep learning en voor onderzoekers die een eenvoudig te gebruiken API willen.
  • Het installatieproces is eenvoudig en u kunt een virtuele omgeving gebruiken of een extern platform zoals AWS.
  • Keras wordt ook geleverd met verschillende soorten netwerkmodellen, zodat we het beschikbare model gemakkelijker kunnen gebruiken voor het vooraf trainen en verfijnen van ons eigen netwerkmodel.
  • Er zijn ook veel tutorials en artikelen over het gebruik van Keras uit codes van gemeenschappen over de hele wereld voor diepgaande leerdoeleinden.