Keras-Tutorial: Was ist Keras? So installieren Sie in Python [Beispiel]

Was ist Keras?

Keras ist eine in Python geschriebene Open-Source-Bibliothek für neuronale Netze, die auf Theano oder Tensorflow läuft. Es ist modular, schnell und einfach zu bedienen konzipiert. Es wurde von François Chollet, einem Google-Ingenieur, entwickelt. Keras übernimmt keine Low-Level-Berechnungen. Stattdessen wird dafür eine andere Bibliothek namens „Backend“ verwendet.

Keras ist ein High-Level-API-Wrapper für die Low-Level-API, der auf TensorFlow, CNTK oder Theano ausgeführt werden kann. Die Keras High-Level-API verwaltet die Art und Weise, wie wir Modelle erstellen, Ebenen definieren oder mehrere Eingabe-Ausgabe-Modelle einrichten. Auf dieser Ebene kompiliert Keras auch unser Modell mit Verlust- und Optimierungsfunktionen sowie den Trainingsprozess mit Anpassungsfunktionen. Keras in Python verarbeitet keine Low-Level-APIs wie die Erstellung des Rechendiagramms, die Erstellung von Tensoren oder anderen Variablen, da dies von der „Backend“-Engine verwaltet wird.

Was ist ein Backend?

Backend ist ein Begriff in Keras, der alle Berechnungen auf niedriger Ebene wie Tensorprodukte, Faltungen und viele andere Dinge mit Hilfe anderer Bibliotheken wie Tensorflow oder Theano durchführt. Die „Backend-Engine“ übernimmt also die Berechnung und Entwicklung der Modelle. Tensorflow ist die standardmäßige „Backend-Engine“, wir können sie jedoch in der Konfiguration ändern.

Theano, Tensorflow und CNTK-Backend

Backend von Theano

Theano ist ein Open-Source-Projekt, das von der MILA-Gruppe an der Universität Montreal, Quebec, Kanada, entwickelt wurde. Es war das erste weit verbreitete Framework. Es handelt sich um eine Python-Bibliothek, die in mehrdimensionalen Arrays für mathematische Operationen mit Numpy oder Scipy hilft. Theano kann GPUs für schnellere Berechnungen verwenden und außerdem automatisch symbolische Diagramme zur Berechnung von Farbverläufen erstellen. Auf seiner Website behauptet Theano, dass es numerisch instabile Ausdrücke erkennen und mit stabileren Algorithmen berechnen kann, was für unsere instabilen Ausdrücke sehr nützlich ist.

Backend von TensorFlow

Andererseits ist Tensorflow der aufstrebende Stern im Deep-Learning-Framework. Es wurde vom Brain-Team von Google entwickelt und ist das beliebteste Deep-Learning-Tool. Mit vielen Funktionen tragen Forscher dazu bei, dieses Framework für Deep-Learning-Zwecke zu entwickeln.

Backend von CNTK

Eine weitere Backend-Engine für Keras ist The Microsoft Cognitive Toolkit oder CNTK. Es handelt sich um ein Open-Source-Deep-Learning-Framework, das von entwickelt wurde Microsoft Team. Es kann auf mehreren GPUs oder mehreren Maschinen ausgeführt werden, um Deep-Learning-Modelle in großem Umfang zu trainieren. In einigen Fällen wurde berichtet, dass CNTK schneller ist als andere Frameworks wie Tensorflow oder Theano. Als Nächstes vergleichen wir in diesem Keras CNN-Tutorial die Backends von Theano, TensorFlow und CNTK.

Vergleich der Backends

Wir müssen einen Benchmark durchführen, um den Vergleich zwischen diesen beiden Backends zu ermitteln. Wie Sie darin sehen können Jeong-Yoon Lees Maßstab, wird die Leistung von 3 verschiedenen Backends auf unterschiedlicher Hardware verglichen. Das Ergebnis ist Berichten zufolge, dass Theano langsamer ist als das andere Backend 50 mal langsamer, aber die Genauigkeit liegt nahe beieinander.

Ein anderer Benchmark-Test wird durchgeführt von Jasmeet Bhatia. Er berichtete, dass Theano für einige Tests langsamer als Tensorflow sei. Die Gesamtgenauigkeit ist jedoch für jedes getestete Netzwerk nahezu gleich.

Zwischen Theano, Tensorflow und CTK ist es also offensichtlich, dass TensorFlow besser als Theano ist. Mit TensorFlow ist die Rechenzeit viel kürzer und CNN ist besser als die anderen.

Als Nächstes lernen wir in diesem Keras-Python-Tutorial den Unterschied zwischen Keras und TensorFlow kennen (Keras vs. Tensorflow).

Keras vs. Tensorflow

Parameter Keras Tensorflow
Art High-Level-API-Wrapper Low-Level-API
Mitplexity Einfach zu verwenden, wenn Sie Python-Sprache verwenden Sie müssen die Syntax für die Verwendung einiger Tensorflow-Funktionen erlernen
Zweck Schnelle Bereitstellung für die Modellerstellung mit Standardebenen Ermöglicht die Erstellung eines beliebigen Rechendiagramms oder von Modellebenen
Tools Verwendet ein anderes API-Debug-Tool wie TFDBG Sie können Tensorboard-Visualisierungstools verwenden
Gemeinschaft Große aktive Gemeinschaften Große aktive Communities und weithin gemeinsam genutzte Ressourcen

Vorteile von Keras

Schnelle Bereitstellung und leicht verständlich

Keras erstellt sehr schnell ein Netzwerkmodell. Wenn Sie ein einfaches Netzwerkmodell mit wenigen Zeilen erstellen möchten, kann Ihnen Python Keras dabei helfen. Schauen Sie sich das Keras-Beispiel unten an:

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

Aufgrund der benutzerfreundlichen API können wir den Prozess leicht verstehen. Schreiben Sie den Code mit einer einfachen Funktion, ohne dass mehrere Parameter festgelegt werden müssen.

Große Community-Unterstützung

Es gibt viele KI-Communitys, die Keras für ihr Deep-Learning-Framework verwenden. Viele von ihnen veröffentlichen ihre Codes sowie Tutorials für die breite Öffentlichkeit.

Haben Sie mehrere Backends

Sie können Tensorflow, CNTK und Theano als Backend mit Keras wählen. Je nach Bedarf können Sie für verschiedene Projekte ein anderes Backend wählen. Jedes Backend hat seinen eigenen einzigartigen Vorteil.

Plattformübergreifende und einfache Modellbereitstellung

Mit einer Vielzahl unterstützter Geräte und Plattformen können Sie Keras auf jedem beliebigen Gerät bereitstellen

  • iOS mit CoreML
  • Android mit Tensorflow Android,
  • Webbrowser mit .js-Unterstützung
  • Cloud-Engine
  • Raspberry Pi

Unterstützung mehrerer GPUs

Sie können Keras auf einer einzelnen GPU trainieren oder mehrere GPUs gleichzeitig verwenden. Da Keras über eine integrierte Unterstützung für Datenparallelität verfügt, kann es große Datenmengen verarbeiten und die für das Training erforderliche Zeit verkürzen.

Nachteile von Keras

Die Low-Level-API kann nicht verarbeitet werden

Keras verarbeitet nur High-Level-APIs, die auf anderen Frameworks oder Backend-Engines wie Tensorflow, Theano oder CNTK ausgeführt werden. Daher ist es nicht sehr nützlich, wenn Sie für Ihre Forschungszwecke eine eigene abstrakte Ebene erstellen möchten, da Keras bereits über vorkonfigurierte Ebenen verfügt.

Keras installieren

In diesem Abschnitt werden wir verschiedene Methoden zur Installation von Keras untersuchen

Direktinstallation oder virtuelle Umgebung

Welches ist besser? Direkte Installation auf dem aktuellen Python oder Verwendung einer virtuellen Umgebung? Ich empfehle die Verwendung einer virtuellen Umgebung, wenn Sie viele Projekte haben. Möchten Sie wissen, warum? Dies liegt daran, dass verschiedene Projekte möglicherweise eine unterschiedliche Version einer Keras-Bibliothek verwenden.

Ich habe zum Beispiel ein Projekt, das Python 3.5 mit OpenCV 3.3 mit älterem Keras-Theano-Backend benötigt, aber in dem anderen Projekt muss ich Keras mit der neuesten Version und einen Tensorflow als Backend mit Python 3.6.6-Unterstützung verwenden

Wir wollen nicht, dass die Keras-Bibliothek miteinander in Konflikt gerät, oder? Wir verwenden also eine virtuelle Umgebung, um das Projekt mit einem bestimmten Bibliothekstyp zu lokalisieren, oder wir können eine andere Plattform wie einen Cloud-Service verwenden, um unsere Berechnungen für uns durchzuführen Amazon Internetservice.

Keras installieren auf Amazon Webdienst (AWS)

Amazon Web Service ist eine Plattform, die Cloud-Computing-Dienste und -Produkte für Forscher oder andere Zwecke anbietet. AWS vermietet seine Hardware, Netzwerke, Datenbanken usw., damit wir sie direkt aus dem Internet nutzen können. Einer der beliebtesten AWS-Dienste für Deep-Learning-Zwecke ist der Amazon Machine Image Deep Learning Service oder DL

Ausführliche Anweisungen zur Verwendung von AWS finden Sie hier Lernprogramm

Hinweis zum AMI: Sie erhalten Folgendeswing AMI verfügbar

Keras auf AWS installieren

AWS Deep Learning AMI ist eine virtuelle Umgebung im AWS EC2 Service, die Forschern oder Praktikern bei der Arbeit mit Deep Learning hilft. DLAMI bietet von kleinen CPU-Engines bis hin zu leistungsstarken Multi-GPU-Engines mit vorkonfiguriertem CUDA, cuDNN und einer Vielzahl von Deep-Learning-Frameworks.

Wenn Sie es sofort verwenden möchten, sollten Sie sich für Deep Learning AMI entscheiden, da beliebte Deep-Learning-Frameworks vorinstalliert sind.

Wenn Sie jedoch ein benutzerdefiniertes Deep-Learning-Framework für die Forschung ausprobieren möchten, sollten Sie das Deep Learning Base AMI installieren, da es grundlegende Bibliotheken wie CUDA, cuDNN, GPU-Treiber und andere benötigte Bibliotheken für die Ausführung mit Ihrer Deep-Learning-Umgebung enthält.

So installieren Sie Keras auf Amazon SageMaker

Amazon SageMaker ist eine Deep-Learning-Plattform, die Sie beim Training und Einsatz von Deep-Learning-Netzwerken mit dem besten Algorithmus unterstützt.

Als Anfänger ist dies bei weitem die einfachste Methode, Keras zu verwenden. Nachfolgend finden Sie einen Prozess zur Installation von Keras Amazon SageMaker:

Schritt 1) Öffnen Amazon SageMaker

Öffnen Sie im ersten Schritt die Amazon Sagemaker Konsole und klicken Sie auf Notebook-Instanz erstellen.

Installieren Sie Keras auf Amazon SageMaker

Schritt 2) Geben Sie die de eintails

  1. Geben Sie den Namen Ihres Notizbuchs ein.
  2. Erstellen Sie eine IAM-Rolle. Es wird eine AMI-Rolle erstellt Amazon IAM-Rolle im Format von AmazonSageMaker-Ausführungsrolle-JJJJMMTT|HHmmSS.
  3. Wählen Sie abschließend „Notebook-Instanz erstellen“. Nach ein paar Augenblicken, Amazon Sagemaker startet eine Notebook-Instanz.

Installieren Sie Keras auf Amazon SageMaker

Note: Wenn Sie von Ihrer VPC aus auf Ressourcen zugreifen möchten, stellen Sie den direkten Internetzugriff auf aktiviert ein. Andernfalls verfügt diese Notebook-Instanz nicht über einen Internetzugang, sodass es nicht möglich ist, Modelle zu trainieren oder zu hosten

Schritt 3) Starten Sie die Instanz

Klicken Sie auf Öffnen, um die Instanz zu starten

Installieren Sie Keras auf Amazon SageMaker

Schritt 4) Beginnen Sie mit dem Codieren

In Jupyter, Klicken Sie auf Neu > conda_tensorflow_p36 und Sie können mit dem Codieren beginnen

Installieren Sie Keras auf Amazon SageMaker

Installieren Sie Keras unter Linux

Um Keras mit Tensorflow als Backend-Engine zu aktivieren, müssen wir zuerst Tensorflow installieren. Führen Sie diesen Befehl aus, um Tensorflow mit CPU (keine GPU) zu installieren.

pip install --upgrade tensorflow

Wenn Sie die GPU-Unterstützung für Tensorflow aktivieren möchten, können Sie diesen Befehl verwenden

pip install --upgrade tensorflow-gpu

Installieren Sie Keras unter Linux

Lassen Sie uns in Python überprüfen, ob unsere Installation durch Eingabe erfolgreich ist

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

Wenn keine Fehlermeldung angezeigt wird, ist der Installationsvorgang erfolgreich

Installieren Sie Keras

Nachdem wir Tensorflow installiert haben, beginnen wir mit der Installation von Keras. Geben Sie diesen Befehl im Terminal ein

pip install keras

Es beginnt mit der Installation von Keras und allen seinen Abhängigkeiten. Sie sollten etwa Folgendes sehen:

Installieren Sie Keras

Jetzt haben wir Keras in unserem System installiert!

Überprüfen

Bevor wir Keras verwenden, sollten wir prüfen, ob unsere Keras Tensorflow als Backend verwenden, indem wir die Konfigurationsdatei öffnen:

gedit ~/.keras/keras.json

Sie sollten so etwas sehen

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

Wie Sie sehen können, verwendet das „Backend“ Tensorflow. Das bedeutet, dass Keras wie erwartet Tensorflow als Backend verwendet

und führen Sie es nun durch Eingabe auf dem Terminal aus

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

So installieren Sie Keras unter Windows

Bevor wir installieren Tensorflow und Keras sollten wir Python, Pip und Virtualenv installieren. Wenn Sie diese Bibliotheken bereits installiert haben, sollten Sie mit dem nächsten Schritt fortfahren, andernfalls gehen Sie wie folgt vor:

Installieren Sie Python 3, indem Sie es hier herunterladen Link

Installieren Sie pip, indem Sie es ausführen fehlen uns die Worte.

Installieren Sie virtualenv mit diesem Befehl

pip3 install –U pip virtualenv

Installieren Microsoft Visual C++ 2015 Redistributable Update 3

Führen Sie dann dieses Skript aus

pip3 install virtualenv

Richten Sie eine virtuelle Umgebung ein

Dies wird verwendet, um das Arbeitssystem vom Hauptsystem zu isolieren.

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

Aktivieren Sie die Umgebung

.\venv\Scripts\activate

Nach der Vorbereitung der Umgebung bleibt die Installation von Tensorflow und Keras dieselbe wie bei Linux. Als nächstes lernen wir in diesem Deep Learning mit Keras-Tutorial die Keras-Grundlagen für Deep Learning kennen.

Keras-Grundlagen für Deep Learning

Die Hauptstruktur in Keras ist das Modell, das den vollständigen Graphen eines Netzwerks definiert. Sie können einem vorhandenen Modell weitere Ebenen hinzufügen, um ein benutzerdefiniertes Modell zu erstellen, das Sie für Ihr Projekt benötigen.

Hier erfahren Sie, wie Sie ein sequentielles Modell und einige häufig verwendete Ebenen beim Deep Learning erstellen

1. Sequentielles Modell

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

model = Sequential()

2. Faltungsschicht

Dies ist ein Keras-Python-Beispiel einer Faltungsschicht als Eingabeschicht mit der Eingabeform 320 x 320 x 3, mit 48 Filtern der Größe 3 x 3 und der Verwendung von ReLU als Aktivierungsfunktion.

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

ein anderer Typ ist

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

3. MaxPooling-Schicht

Um die Eingabedarstellung herunterzurechnen, verwenden Sie MaxPool2d und geben Sie die Kernelgröße an

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

4. Dichte Schicht

Hinzufügen einer vollständig verbundenen Ebene mit lediglich Angabe der Ausgabegröße

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

5. Dropout-Ebene

Dropout-Schicht mit 50 % Wahrscheinlichkeit hinzufügen

model.add(Dropout(0.5))

Kompilieren, trainieren und auswerten

Nachdem wir unser Modell definiert haben, beginnen wir mit dem Training. Es ist erforderlich, das Netzwerk zunächst mit der Verlustfunktion und der Optimierungsfunktion zu kompilieren. Dadurch kann das Netzwerk Gewichte ändern und der Verlust wird minimiert.

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

Um nun mit dem Training zu beginnen, verwenden Sie fit, um die Trainings- und Validierungsdaten in das Modell einzuspeisen. Dadurch können Sie das Netzwerk stapelweise trainieren und die Epochen festlegen.

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

Unser letzter Schritt besteht darin, das Modell mit den Testdaten auszuwerten.

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

Versuchen wir es mit einer einfachen linearen Regression

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

Nach dem Training der Daten sollte die Ausgabe so aussehen

Lineare Regression

mit dem Ausgangsgewicht

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

und Endgewicht

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

Feinabstimmung vorab trainierter Modelle in Keras und deren Verwendung

Warum wir Fine-Tuning-Modelle verwenden und wann wir sie verwenden

Bei der Feinabstimmung geht es darum, ein vorab trainiertes Modell so zu optimieren, dass sich die Parameter an das neue Modell anpassen. Wenn wir ein neues Modell von Grund auf trainieren möchten, benötigen wir eine große Datenmenge, damit das Netzwerk alle Parameter finden kann. In diesem Fall verwenden wir jedoch ein vorab trainiertes Modell, sodass die Parameter bereits gelernt sind und eine Gewichtung haben.

Wenn wir beispielsweise unser eigenes Keras-Modell trainieren möchten, um ein Klassifizierungsproblem zu lösen, aber nur über eine kleine Datenmenge verfügen, können wir dies mithilfe von a lösen Lernen übertragen + Feinabstimmungsmethode.

Mit einem vorab trainierten Netzwerk und Gewichten müssen wir nicht das gesamte Netzwerk trainieren. Wir müssen nur die letzte Ebene trainieren, die zur Lösung unserer Aufgabe verwendet wird, was wir als Feinabstimmungsmethode bezeichnen.

Vorbereitung des Netzwerkmodells

Für das vorab trainierte Modell können wir eine Vielzahl von Modellen laden, die Keras bereits in seiner Bibliothek hat, wie zum Beispiel:

  • VGG16
  • EinführungV3
  • ResNet
  • MobileNet
  • Xception
  • InceptionResNetV2

Aber in diesem Prozess werden wir das VGG16-Netzwerkmodell und das ImageNet als Gewicht für das Modell verwenden. Wir werden ein Netzwerk verfeinern, um 8 verschiedene Arten von Klassen mithilfe von Bildern von zu klassifizieren Kaggle Natural Images-Datensatz

VGG16-Modellarchitektur

VGG16-Modellarchitektur

Quelle

Hochladen unserer Daten in den AWS S3 Bucket

Für unseren Trainingsprozess verwenden wir ein Bild natürlicher Bilder aus 8 verschiedenen Klassen wie Flugzeuge, Auto, Katze, Hund, Blume, Obst, Motorrad und Person. Zuerst müssen wir unsere Daten hochladen Amazon S3-Eimer.

Amazon S3-Eimer

Schritt 1) Nachdem Sie sich bei Ihrem S3-Konto angemeldet haben, erstellen wir durch Takten einen Bucket Neues Bucket

Hochladen von Daten in den AWS S3 Bucket

Schritt 2) Wählen Sie nun einen Bucket-Namen und Ihre Region entsprechend Ihrem Konto. Stellen Sie sicher, dass der Bucket-Name verfügbar ist. Klicken Sie danach Erstellen.

Hochladen von Daten in den AWS S3 Bucket

Schritt 3) Wie Sie sehen, ist Ihr Bucket einsatzbereit. Aber wie Sie sehen, ist der Zugriff nicht öffentlich, es ist gut für Sie, wenn Sie ihn für sich privat halten möchten. Sie können diesen Bucket in den Bucket-Eigenschaften für den öffentlichen Zugriff ändern

Hochladen von Daten in den AWS S3 Bucket

Schritt 4) Jetzt beginnen Sie mit dem Hochladen Ihrer Trainingsdaten in Ihren Bucket. Hier werde ich die Datei tar.gz hochladen, die aus Bildern für den Schulungs- und Testprozess besteht.

Hochladen von Daten in den AWS S3 Bucket

Schritt 5) Klicken Sie nun auf Ihre Datei und kopieren Sie die Link damit wir es herunterladen können.

Hochladen von Daten in den AWS S3 Bucket

Datenaufbereitung

Wir müssen unsere Trainingsdaten mithilfe der Keras ImageData generierenGenerator.

Zuerst müssen Sie mit wget den Link zu Ihrer Datei aus S3 Bucket herunterladen.

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

Nachdem Sie die Daten heruntergeladen haben, beginnen wir mit dem Trainingsprozess.

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)

Die ImageDataGenerator erstellt X_training-Daten aus einem Verzeichnis. Das Unterverzeichnis in diesem Verzeichnis wird als Klasse für jedes Objekt verwendet. Das Bild wird mit dem RGB-Farbmodus, mit dem kategorialen Klassenmodus für die Y_training-Daten und einer Stapelgröße von 16 geladen. Zum Schluss werden die Daten gemischt.

Sehen wir uns unsere Bilder zufällig an, indem wir sie mit matplotlib plotten

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

Datenaufbereitung

Danach erstellen wir unser Netzwerkmodell aus VGG16 mit vorab trainiertem ImageNet-Gewicht. Wir werden diese Schichten einfrieren, sodass sie nicht trainierbar sind, um die Rechenzeit zu verkürzen.

Erstellen unseres Modells aus 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())

Wie Sie unten sehen können, ist die Zusammenfassung unseres Netzwerkmodells. Aus einer Eingabe von VGG16-Schichten fügen wir dann zwei vollständig verbundene Schichten hinzu, die 2 Features extrahieren, und eine Ausgabeschicht, die die 1024 Klassen mit der Softmax-Aktivierung berechnet.

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

Ausbildung

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

Die Ergebnisse

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

Ausbildung

Wie Sie sehen, sind unsere Verluste deutlich gesunken und die Genauigkeit liegt bei fast 100 %. Um unser Modell zu testen, haben wir zufällig Bilder aus dem Internet ausgewählt und sie mit einer anderen Klasse zum Testen in den Testordner gelegt

Testen unseres Modells

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

Und unser Test ist wie unten angegeben! Aus einem Test mit 1 Bildern wurde nur 14 Bild falsch vorhergesagt!

Testmodell

Neuronales Netzwerk zur Gesichtserkennung mit Keras

Warum wir Anerkennung brauchen

Wir brauchen die Erkennung, damit wir das Gesicht einer Person, den Objekttyp, das geschätzte Alter einer Person anhand ihres Gesichts leichter erkennen oder identifizieren oder sogar den Gesichtsausdruck dieser Person kennen können.

Neuronales Netzwerk zur Gesichtserkennung mit Keras

Vielleicht stellen Sie fest, dass jedes Mal, wenn Sie versuchen, das Gesicht Ihres Freundes auf einem Foto zu markieren, die Funktion in Facebook dies für Sie erledigt hat, nämlich das Gesicht Ihres Freundes zu markieren, ohne dass Sie es zuerst markieren müssen. Dabei handelt es sich um die Gesichtserkennung von Facebook, die uns das Markieren von Freunden erleichtert.

Wie funktioniert es also? Jedes Mal, wenn wir das Gesicht unseres Freundes markieren, lernt die KI von Facebook dies und versucht, es vorherzusagen, bis das richtige Ergebnis erzielt wird. Das gleiche System werden wir verwenden, um unsere eigene Gesichtserkennung zu erstellen. Beginnen wir mit der Entwicklung unserer eigenen Gesichtserkennung mithilfe von Deep Learning

Netzwerkmodell

Wir werden ein VGG16-Netzwerkmodell verwenden, jedoch mit VGGFace-Gewicht.

VGG16-Modellarchitektur

Netzwerkmodell

Was ist VGGFace? Es handelt sich um Keras Implementierung der Deep Face Recognition, die von Parkhi, Omkar M. et al. eingeführt wurde. „Tiefe Gesichtserkennung.“ BMVC (2015). Das Framework verwendet VGG16 als Netzwerkarchitektur.

Sie können das VGGFace herunterladen unter 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()

Wie Sie der Netzwerkzusammenfassung entnehmen können

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

Wir werden eins machen Lernen übertragen + Feinabstimmung, um das Training bei kleinen Datensätzen zu beschleunigen. Zuerst werden wir die Basisschichten einfrieren, sodass die Schichten nicht trainierbar sind.

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

Dann fügen wir unsere eigene Ebene hinzu, um unsere Testgesichter zu erkennen. Wir werden zwei vollständig verbundene Schichten und eine Ausgabeschicht mit 2 zu erkennenden Personen hinzufügen.

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)

Sehen wir uns unsere Netzwerkzusammenfassung an

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

Wie Sie oben sehen können, wird die Pool5-Ebene nach der Ebene zu einem einzelnen Merkmalsvektor abgeflacht, der von der dichten Ebene für die endgültige Erkennung verwendet wird.

Unsere Gesichter vorbereiten

Jetzt bereiten wir unsere Gesichter vor. Ich habe ein Verzeichnis mit fünf berühmten Personen erstellt

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

Jeder Ordner enthält 10 Bilder für jeden Schulungs- und Bewertungsprozess. Es handelt sich um eine sehr kleine Datenmenge, aber das ist die Herausforderung, oder?

Zur Vorbereitung der Daten nutzen wir das Keras-Tool. Diese Funktion durchläuft den Datensatzordner und bereitet ihn dann vor, damit er im Training verwendet werden kann.

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

Training unseres Modells

Beginnen wir unseren Trainingsprozess mit der Zusammenstellung unseres Netzwerks mit Verlustfunktion und Optimierer. Hier verwenden wir sparse_categorical_crossentropy als unsere Verlustfunktion mit Hilfe von SGD als unserem Lernoptimierer.

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

Wie Sie sehen, beträgt unsere Validierungsgenauigkeit bis zu 64 %, was für eine kleine Menge an Trainingsdaten ein gutes Ergebnis ist. Wir können dies verbessern, indem wir mehr Ebenen oder Trainingsbilder hinzufügen, damit unser Modell mehr über die Gesichter erfahren und eine höhere Genauigkeit erreichen kann.

Testen wir unser Modell mit einem Testbild

Bild testen

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

Wenn wir das Bild von Robert Downey Jr. als unser Testbild verwenden, zeigt sich, dass das vorhergesagte Gesicht wahr ist!

Vorhersage mit Live-Cam!

Wie wäre es, wenn wir unsere Fähigkeit testen würden, es mit einem Input von einer Webcam umzusetzen? Mithilfe von OpenCV und der Haar Face-Kaskade können wir unser Gesicht finden und mit Hilfe unseres Netzwerkmodells die Person erkennen.

Der erste Schritt besteht darin, die Gesichter von Ihnen und Ihren Freunden vorzubereiten. Je mehr Daten wir haben, desto besser ist das Ergebnis!

Bereiten Sie Ihr Netzwerk wie im vorherigen Schritt vor und trainieren Sie es. Fügen Sie nach Abschluss des Trainings diese Zeile hinzu, um das Eingabebild von der Kamera zu erhalten

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

Welches ist besser? Keras oder Tensorflow

Keras bietet Einfachheit beim Schreiben des Skripts. Wir können mit Keras direkt mit dem Schreiben beginnen und es verstehen, da es nicht allzu schwer zu verstehen ist. Es ist benutzerfreundlicher und einfacher zu implementieren, da zum Ausführen des Modells nicht viele Variablen erstellt werden müssen. Wir müssen also nicht jedes Detail im Backend-Prozess verstehen.

Auf der anderen Seite handelt es sich bei Tensorflow um Operationen auf niedriger Ebene, die Flexibilität und erweiterte Operationen bieten, wenn Sie ein beliebiges Rechendiagramm oder Modell erstellen möchten. Tensorflow kann den Prozess auch mithilfe von visualisieren TensorBoard und ein spezielles Debugger-Tool.

Wenn Sie also mit wenig Aufwand mit Deep Learning arbeiten möchtenplexVerwenden Sie Keras. Weil Keras einfacher und benutzerfreundlicher zu bedienen und einfacher zu implementieren ist als Tensorflow. Wenn Sie jedoch Ihren eigenen Algorithmus für ein Deep-Learning-Projekt oder eine Deep-Learning-Forschung schreiben möchten, sollten Sie stattdessen Tensorflow verwenden.

Zusammenfassung

Fassen wir also alles zusammen, was wir in diesem Tutorial besprochen und getan haben.

  • Keras in einer High-Level-API, die mithilfe der Backend-Engine zur Vereinfachung von Deep-Learning-Netzwerken verwendet wird.
  • Keras ist mit Python-Unterstützung einfach zu verwenden und zu verstehen, sodass es sich natürlicher anfühlt als je zuvor. Es ist gut für Anfänger, die etwas über Deep Learning lernen möchten, und für Forscher, die eine einfach zu verwendende API wünschen.
  • Der Installationsprozess ist einfach und Sie können eine virtuelle Umgebung oder eine externe Plattform wie z. B. verwenden AWS.
  • Keras verfügt außerdem über verschiedene Arten von Netzwerkmodellen, sodass wir das verfügbare Modell einfacher für das Vortraining und die Feinabstimmung unseres eigenen Netzwerkmodells verwenden können.
  • Außerdem gibt es zahlreiche Tutorials und Artikel über die Verwendung von Keras-Codes aus Communitys weltweit für Deep-Learning-Zwecke.