Keras-Tutorial
Evelyn Clarke
Was ist Keras?
Keras ist eine Open Source-Bibliothek fรผr neuronale Netzwerke, geschrieben in Python das auf Theano oder Tensorflow lรคuft. Es ist modular, schnell und benutzerfreundlich konzipiert. Es wurde von Franรงois Chollet, einem Google-Ingenieur, entwickelt. Keras รผbernimmt keine Berechnungen auf niedriger Ebene. Stattdessen verwendet es dafรผr eine andere Bibliothek, das sogenannte โBackendโ.
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 Input-Output-Modelle einrichten. Auf dieser Ebene kompiliert Keras auch unser Modell mit Verlust- und Optimierungsfunktionen sowie den Trainingsprozess mit der Anpassungsfunktion. Keras in Python verarbeitet keine Low-Level-APIs wie das Erstellen von Berechnungsdiagrammen, Tensoren oder anderen Variablen, da dies bereits von der โBackendโ-Engine รผbernommen wurde.
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
Theano ist ein Open-Source-Projekt, das von der MILA-Gruppe an der Universitรคt von Montreal, Quebec, Kanada, entwickelt wurde. Es war das erste weit verbreitete Framework. Es ist ein Python Bibliothek, die bei mehrdimensionalen Arrays fรผr mathematische Operationen mit Numpy oder Scipy hilft. Theano kann GPUs fรผr schnellere Berechnungen verwenden und automatisch symbolische Graphen zum Berechnen von Gradienten 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.
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.
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 in diesem Keras Python Tutorial lernen wir den Unterschied zwischen Keras und TensorFlow kennen (Keras vs. Tensorflow).
Keras vs. Tensorflow
| Kenngrรถรen | Keras | Tensorflow |
|---|---|---|
| Typ | High-Level-API-Wrapper | Low-Level-API |
| Komplexitรคt | Einfach zu bedienen, wenn Sie Python Sprache | 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 |
| Zubehรถr | 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 ist sehr schnell, um ein Netzwerkmodell zu erstellen. Wenn Sie ein einfaches Netzwerkmodell mit wenigen Zeilen erstellen mรถchten, Python Keras kann Ihnen dabei helfen. Sehen Sie sich das folgende Keras-Beispiel 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 only handles high-level API which runs on top other framework or backend engine such as Tensorflow, Theano, or CNTK. So itโs not very useful if you want to make your own abstract layer for your research purposes because Keras already have pre-configured layers.
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, aber im anderen Projekt muss ich Keras mit der neuesten Version und einem Tensorflow als Backend verwenden mit Python 3.6.6 Unterstรผtzung
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: Ihnen steht folgendes AMI zur Verfรผgung
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.
Schritt 2) Geben Sie die Details ein
- Geben Sie den Namen Ihres Notizbuchs ein.
- Erstellen Sie eine IAM-Rolle. Es wird eine AMI-Rolle erstellt Amazon IAM-Rolle im Format von AmazonSageMaker-Ausfรผhrungsrolle-JJJJMMTT|HHmmSS.
- Wรคhlen Sie abschlieรend โNotebook-Instanz erstellenโ. Nach ein paar Augenblicken, Amazon Sagemaker startet eine Notebook-Instanz.
Hinweis: Wenn Sie auf Ressourcen aus Ihrem VPC zugreifen mรถchten, aktivieren Sie den direkten Internetzugang. Andernfalls hat diese Notebook-Instanz keinen Internetzugang und es ist nicht mรถglich, Modelle zu trainieren oder zu hosten.
Schritt 3) Starten Sie die Instanz
Klicken Sie auf รffnen, um die Instanz zu starten
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 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
Lass uns einchecken Python to see if our installation is successful by typing
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:
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
and now run it on the terminal by typing
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 auf Windows
Bevor wir installieren Tensorflow und Keras, wir sollten installieren Python, pip und virtualenv. Wenn Sie diese Bibliotheken bereits installiert haben, sollten Sie mit dem nรคchsten Schritt fortfahren, andernfalls gehen Sie wie folgt vor:
Installieren Python 3 durch Herunterladen von diesem 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 visuell C++ 2015 Weiterverteilbares Update 3
- Gehen Sie zur Visual Studio-Download-Site https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Wรคhlen Sie Redistributables und Build Tools aus
- Laden Sie die Microsoft visuell C++ 2015 Weiterverteilbares 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 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 Ebene
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
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
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
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.
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
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.
Schritt 5) Klicken Sie nun auf Ihre Datei und kopieren Sie die verbindung damit wir es herunterladen kรถnnen.
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()
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())
As you can see below, the summary of our network model. From an input from VGG16 Layers, then we add 2 Fully Connected Layer which will extract 1024 features and an output layer that will compute the 8 classes with the softmax activation.
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
Training
# # 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()
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
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!
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.
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
Was ist VGGFace? Es handelt sich um eine Keras-Implementierung der Deep Face Recognition, die von Parkhi, Omkar M. et al. eingefรผhrt wurde. โDeep Face Recognition.โ 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
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 bietet Tensorflow Low-Level-Operationen, 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 Deep Learning ohne allzu groรe Komplexitรคt beginnen mรถchten, verwenden Sie Keras. Denn Keras ist einfacher zu verwenden und benutzerfreundlicher und lรคsst sich leichter implementieren als Tensorflow. Wenn Sie jedoch Ihren eigenen Algorithmus fรผr ein Deep-Learning-Projekt oder eine 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.
