Φροντιστήριο Keras

Τι είναι το Keras;

Keras είναι μια βιβλιοθήκη νευρωνικού δικτύου ανοιχτού κώδικα γραμμένη σε Python που τρέχει πάνω από το Theano ή το Tensorflow. Είναι σχεδιασμένο να είναι αρθρωτό, γρήγορο και εύκολο στη χρήση. Αναπτύχθηκε από τον François Chollet, μηχανικό της Google. Η Keras δεν χειρίζεται υπολογισμούς χαμηλού επιπέδου. Αντίθετα, χρησιμοποιεί μια άλλη βιβλιοθήκη για να το κάνει, που ονομάζεται "Backend.

Το Keras είναι ένα περιτύλιγμα API υψηλού επιπέδου για το API χαμηλού επιπέδου, με δυνατότητα εκτέλεσης πάνω από το TensorFlow, το CNTK ή το Theano. Το Keras High-Level API χειρίζεται τον τρόπο με τον οποίο φτιάχνουμε μοντέλα, ορίζοντας επίπεδα ή ρυθμίζουμε πολλαπλά μοντέλα εισόδου-εξόδου. Σε αυτό το επίπεδο, η Keras συντάσσει επίσης το μοντέλο μας με λειτουργίες απώλειας και βελτιστοποίησης, διαδικασία προπόνησης με λειτουργία fit. Κεράς μέσα Python δεν χειρίζεται το API χαμηλού επιπέδου, όπως τη δημιουργία του υπολογιστικού γραφήματος, τη δημιουργία τανυστών ή άλλες μεταβλητές, επειδή έχει χειριστεί από τη μηχανή "backend".

Τι είναι ένα Backend;

Το Backend είναι ένας όρος στο Keras που εκτελεί όλους τους υπολογισμούς χαμηλού επιπέδου, όπως προϊόντα τανυστή, συνελίξεις και πολλά άλλα πράγματα με τη βοήθεια άλλων βιβλιοθηκών όπως η Tensorflow ή η Theano. Έτσι, η «μηχανή υποστήριξης» θα εκτελέσει τον υπολογισμό και την ανάπτυξη των μοντέλων. Το Tensorflow είναι η προεπιλεγμένη «μηχανή υποστήριξης» αλλά μπορούμε να την αλλάξουμε στη διαμόρφωση.

Theano, Tensorflow και CNTK Backend

Το Theano είναι ένα έργο ανοιχτού κώδικα που αναπτύχθηκε από τον όμιλο MILA στο Πανεπιστήμιο του Μόντρεαλ, Κεμπέκ, Καναδάς. Ήταν το πρώτο Πλαίσιο που χρησιμοποιήθηκε ευρέως. Είναι ένα Python βιβλιοθήκη που βοηθά σε πολυδιάστατους πίνακες για μαθηματικές πράξεις χρησιμοποιώντας Numpy ή Scipy. Το Theano μπορεί να χρησιμοποιήσει GPU για ταχύτερους υπολογισμούς, μπορεί επίσης να δημιουργήσει αυτόματα συμβολικά γραφήματα για υπολογιστικές κλίσεις. Στην ιστοσελίδα της, η Theano ισχυρίζεται ότι μπορεί να αναγνωρίσει αριθμητικά ασταθείς εκφράσεις και να τις υπολογίσει με πιο σταθερούς αλγόριθμους, αυτό είναι πολύ χρήσιμο για τις ασταθείς εκφράσεις μας.

Από την άλλη πλευρά, το Tensorflow είναι το ανερχόμενο αστέρι στο πλαίσιο βαθιάς μάθησης. Αναπτύχθηκε από την ομάδα Brain της Google και είναι το πιο δημοφιλές εργαλείο βαθιάς εκμάθησης. Με πολλά χαρακτηριστικά και οι ερευνητές συμβάλλουν στην ανάπτυξη αυτού του πλαισίου για σκοπούς βαθιάς μάθησης.

Ένας άλλος κινητήρας backend για το Keras είναι το The Microsoft Cognitive Toolkit ή CNTK. Είναι ένα ανοιχτού κώδικα πλαίσιο βαθιάς μάθησης που αναπτύχθηκε από Microsoft Ομάδα. Μπορεί να λειτουργήσει σε πολλαπλές GPU ή πολυμηχανήματα για εκπαίδευση μοντέλων βαθιάς εκμάθησης σε τεράστια κλίμακα. Σε ορισμένες περιπτώσεις, το CNTK αναφέρθηκε ταχύτερα από άλλα πλαίσια όπως το Tensorflow ή το Theano. Στη συνέχεια, σε αυτό το σεμινάριο Keras CNN, θα συγκρίνουμε τα backends των Theano, TensorFlow και CNTK.

Συγκρίνοντας τα Backends

Πρέπει να κάνουμε ένα σημείο αναφοράς για να γνωρίζουμε τη σύγκριση μεταξύ αυτών των δύο backend. Όπως μπορείτε να δείτε στο Το σημείο αναφοράς του Jeong-Yoon Lee, συγκρίνεται η απόδοση 3 διαφορετικών backend σε διαφορετικό υλικό. Και το αποτέλεσμα είναι ότι η Θεανώ είναι πιο αργή από το άλλο backend, αναφέρεται φορές 50 πιο αργά, αλλά η ακρίβεια είναι κοντά η μία στην άλλη.

Άλλος δοκιμή αναφοράς εκτελείται από Jasmeet Bhatia. Ανέφερε ότι η Theano είναι πιο αργή από τον Tensorflow για κάποια δοκιμή. Αλλά η συνολική ακρίβεια είναι σχεδόν η ίδια για κάθε δίκτυο που δοκιμάστηκε.

Έτσι, μεταξύ Theano, Tensorflow και CTK είναι προφανές ότι το TensorFlow είναι καλύτερο από το Theano. Με το TensorFlow, ο χρόνος υπολογισμού είναι πολύ μικρότερος και το CNN είναι καλύτερο από τα άλλα.

Επόμενο σε αυτό το Keras Python σεμινάριο, θα μάθουμε για τη διαφορά μεταξύ Keras και TensorFlow (Keras vs Tensorflow).

Keras vs Tensorflow

Παράμετροι	Keras	Τάση ροής
Χαρακτηριστικά	Περιτύλιγμα API υψηλού επιπέδου	API χαμηλού επιπέδου
Περίπλοκο	Εύκολο στη χρήση αν Python Γλώσσα	Πρέπει να μάθετε τη σύνταξη της χρήσης ορισμένων συναρτήσεων Tensorflow
Σκοπός	Γρήγορη ανάπτυξη για κατασκευή μοντέλου με τυπικά στρώματα	Σας επιτρέπει να δημιουργήσετε ένα αυθαίρετο υπολογιστικό γράφημα ή επίπεδα μοντέλων
Εργαλεία	Χρησιμοποιεί άλλο εργαλείο εντοπισμού σφαλμάτων API όπως το TFDBG	Μπορείτε να χρησιμοποιήσετε εργαλεία οπτικοποίησης Tensorboard
Κοινότητα	Μεγάλες ενεργές κοινότητες	Μεγάλες ενεργές κοινότητες και ευρέως κοινόχρηστοι πόροι

Πλεονεκτήματα του Keras

Γρήγορη ανάπτυξη και εύκολη κατανόηση

Ο Keras είναι πολύ γρήγορος να φτιάξει ένα μοντέλο δικτύου. Αν θέλετε να φτιάξετε ένα απλό μοντέλο δικτύου με λίγες γραμμές, Python Η Keras μπορεί να σας βοηθήσει σε αυτό. Δείτε το παράδειγμα Keras παρακάτω:

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

Λόγω του φιλικού του API, μπορούμε εύκολα να κατανοήσουμε τη διαδικασία. Γράψτε τον κώδικα με μια απλή λειτουργία και δεν χρειάζεται να ορίσετε πολλές παραμέτρους.

Μεγάλη κοινοτική υποστήριξη

Υπάρχουν πολλές κοινότητες AI που χρησιμοποιούν το Keras για το πλαίσιο Deep Learning. Πολλοί από αυτούς δημοσιεύουν τους κωδικούς τους καθώς και μαθήματα στο ευρύ κοινό.

Έχετε πολλά Backend

Μπορείτε να επιλέξετε Tensorflow, CNTK και Theano ως backend σας με το Keras. Μπορείτε να επιλέξετε διαφορετικό backend για διαφορετικά έργα ανάλογα με τις ανάγκες σας. Κάθε backend έχει το δικό του μοναδικό πλεονέκτημα.

Cross-Platform και εύκολη ανάπτυξη μοντέλου

Με μια ποικιλία υποστηριζόμενων συσκευών και πλατφορμών, μπορείτε να αναπτύξετε το Keras σε οποιαδήποτε συσκευή όπως

• iOS με CoreML
• Android με το Tensorflow Android,
• Πρόγραμμα περιήγησης Ιστού με υποστήριξη .js
• Cloud κινητήρας
• Raspberry Pi

Υποστήριξη πολλαπλών GPU

Μπορείτε να εκπαιδεύσετε το Keras σε μία μόνο GPU ή να χρησιμοποιήσετε πολλές GPU ταυτόχρονα. Επειδή το Keras διαθέτει ενσωματωμένη υποστήριξη για παραλληλισμό δεδομένων, ώστε να μπορεί να επεξεργάζεται μεγάλους όγκους δεδομένων και να επιταχύνει τον χρόνο που απαιτείται για την εκπαίδευσή τους.

Μειονεκτήματα του Keras

Δεν είναι δυνατός ο χειρισμός του API χαμηλού επιπέδου

Το Keras χειρίζεται μόνο API υψηλού επιπέδου που εκτελείται πάνω από άλλο πλαίσιο ή μηχανή υποστήριξης όπως το Tensorflow, το Theano ή το CNTK. Επομένως, δεν είναι πολύ χρήσιμο εάν θέλετε να δημιουργήσετε το δικό σας αφηρημένο επίπεδο για τους ερευνητικούς σας σκοπούς, επειδή τα Keras έχουν ήδη προρυθμισμένα επίπεδα.

Εγκατάσταση Keras

Σε αυτήν την ενότητα, θα εξετάσουμε διάφορες διαθέσιμες μεθόδους για την εγκατάσταση του Keras

Άμεση εγκατάσταση ή εικονικό περιβάλλον

Ποιό είναι καλύτερο? Απευθείας εγκατάσταση στην τρέχουσα python ή χρήση εικονικού περιβάλλοντος; Προτείνω να χρησιμοποιήσετε ένα εικονικό περιβάλλον εάν έχετε πολλά έργα. Θέλετε να μάθετε γιατί; Αυτό συμβαίνει επειδή διαφορετικά έργα ενδέχεται να χρησιμοποιούν διαφορετική έκδοση μιας βιβλιοθήκης keras.

Για παράδειγμα, έχω ένα έργο που χρειάζεται Python 3.5 χρησιμοποιώντας OpenCV 3.3 με παλαιότερο backend Keras-Theano αλλά στο άλλο έργο πρέπει να χρησιμοποιήσω το Keras με την πιο πρόσφατη έκδοση και ένα Tensorflow ως backend με Python Υποστήριξη 3.6.6

Δεν θέλουμε η βιβλιοθήκη Keras να συγκρούεται μεταξύ τους σωστά; Επομένως, χρησιμοποιούμε ένα εικονικό περιβάλλον για να τοπικοποιήσουμε το έργο με έναν συγκεκριμένο τύπο βιβλιοθήκης ή μπορούμε να χρησιμοποιήσουμε μια άλλη πλατφόρμα όπως η Υπηρεσία Cloud για να κάνουμε τους υπολογισμούς μας για εμάς όπως Amazon Web Service.

Εγκατάσταση Keras σε Amazon Υπηρεσία Ιστού (AWS)

Amazon Η Web Service είναι μια πλατφόρμα που προσφέρει υπηρεσίες και προϊόντα Cloud Computing για ερευνητές ή για οποιονδήποτε άλλο σκοπό. Η AWS νοικιάζει το υλικό, τη δικτύωση, τη βάση δεδομένων κ.λπ. ώστε να μπορούμε να το χρησιμοποιήσουμε απευθείας από το διαδίκτυο. Μία από τις δημοφιλείς υπηρεσίες AWS για σκοπούς βαθιάς μάθησης είναι η Amazon Machine Image Deep Learning Service ή DL

Για λεπτομερείς οδηγίες σχετικά με τον τρόπο χρήσης του AWS, ανατρέξτε σε αυτό φροντιστήριο

Σημείωση για το AMI: Θα έχετε διαθέσιμο το ακόλουθο AMI

Το AWS Deep Learning AMI είναι ένα εικονικό περιβάλλον στην υπηρεσία AWS EC2 που βοηθά τους ερευνητές ή τους επαγγελματίες να εργαστούν με το Deep Learning. Η DLAMI προσφέρει από μηχανές μικρών CPU έως κινητήρες πολλαπλών GPU υψηλής ισχύος με προρυθμισμένο CUDA, cuDNN και διαθέτει μια ποικιλία πλαισίων βαθιάς εκμάθησης.

Εάν θέλετε να το χρησιμοποιήσετε άμεσα, θα πρέπει να επιλέξετε το Deep Learning AMI επειδή έρχεται προεγκατεστημένο με δημοφιλή πλαίσια βαθιάς εκμάθησης.

Ωστόσο, εάν θέλετε να δοκιμάσετε ένα προσαρμοσμένο πλαίσιο βαθιάς εκμάθησης για έρευνα, θα πρέπει να εγκαταστήσετε το Deep Learning Base AMI επειδή συνοδεύεται από βασικές βιβλιοθήκες όπως CUDA, cuDNN, προγράμματα οδήγησης GPU και άλλες απαραίτητες βιβλιοθήκες για εκτέλεση με το περιβάλλον βαθιάς μάθησης.

Πώς να εγκαταστήσετε το Keras στο Amazon SageMaker

Amazon Το SageMaker είναι μια πλατφόρμα βαθιάς εκμάθησης που σας βοηθά με την εκπαίδευση και την ανάπτυξη δικτύου βαθιάς μάθησης με τον καλύτερο αλγόριθμο.

Ως αρχάριος, αυτή είναι μακράν η πιο εύκολη μέθοδος χρήσης του Keras. Παρακάτω ακολουθεί μια διαδικασία για τον τρόπο εγκατάστασης του Keras Amazon SageMaker:

Βήμα 1) Ανοίξτε Amazon SageMaker

Στο πρώτο βήμα, Ανοίξτε το Amazon Ψαλίδι κονσόλα και κάντε κλικ στο Create instance notebook.

Βήμα 2) Εισαγάγετε τις λεπτομέρειες

1. Εισαγάγετε το όνομα του σημειωματάριου σας.
2. Δημιουργήστε έναν ρόλο IAM. Θα δημιουργήσει έναν ρόλο AMI Amazon ρόλος IAM στη μορφή του AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
3. Τέλος, επιλέξτε Δημιουργία παρουσίας σημειωματάριου. Μετά από λίγες στιγμές, Amazon Το Sagemaker λανσάρει μια παρουσία σημειωματάριου.

Σημείωση: Εάν θέλετε να αποκτήσετε πρόσβαση σε πόρους από το VPC σας, ορίστε την άμεση πρόσβαση στο Διαδίκτυο ως ενεργοποιημένη. Διαφορετικά, αυτό το παράδειγμα notebook δεν θα έχει πρόσβαση στο διαδίκτυο, επομένως είναι αδύνατο να εκπαιδεύσετε ή να φιλοξενήσετε μοντέλα

Βήμα 3) Εκκινήστε την παρουσία

Κάντε κλικ στο Άνοιγμα για να εκκινήσετε το παράδειγμα

Βήμα 4) Ξεκινήστε την κωδικοποίηση

In Jupyter, Κάντε κλικ στο New> conda_tensorflow_p36 και είστε έτοιμοι να κωδικοποιήσετε

Εγκαταστήστε το Keras σε Linux

Για να ενεργοποιήσουμε το Keras με το Tensorflow ως backend κινητήρα του, πρέπει πρώτα να εγκαταστήσουμε το Tensorflow. Εκτελέστε αυτήν την εντολή για να εγκαταστήσετε το tensorflow με CPU (χωρίς GPU)

pip install --upgrade tensorflow

Εάν θέλετε να ενεργοποιήσετε την υποστήριξη GPU για tensorflow, μπορείτε να χρησιμοποιήσετε αυτήν την εντολή

pip install --upgrade tensorflow-gpu

ας κάνουμε check in Python για να δούμε αν η εγκατάστασή μας είναι επιτυχής πληκτρολογώντας

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

εάν δεν υπάρχει μήνυμα σφάλματος, η διαδικασία εγκατάστασης είναι επιτυχής

Εγκαταστήστε το Keras

Αφού εγκαταστήσουμε το Tensorflow, ας ξεκινήσουμε την εγκατάσταση των keras. Πληκτρολογήστε αυτήν την εντολή στο τερματικό

pip install keras

θα αρχίσει να εγκαθιστά το Keras και όλες τις εξαρτήσεις του. Θα πρέπει να δείτε κάτι σαν αυτό:

Τώρα έχουμε εγκατεστημένο το Keras στο σύστημά μας!

Επαλήθευση

Πριν αρχίσουμε να χρησιμοποιούμε το Keras, θα πρέπει να ελέγξουμε αν το Keras μας χρησιμοποιεί το Tensorflow ως backend ανοίγοντας το αρχείο διαμόρφωσης:

gedit ~/.keras/keras.json

πρέπει να δείτε κάτι τέτοιο

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

όπως μπορείτε να δείτε, το "backend" χρησιμοποιεί tensorflow. Σημαίνει ότι οι keras χρησιμοποιούν το Tensorflow ως backend όπως περιμέναμε

και τώρα εκτελέστε το στο τερματικό πληκτρολογώντας

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

Πώς να εγκαταστήσετε το Keras στο Windows

Πριν εγκαταστήσουμε Τάση ροής και Keras, θα πρέπει να εγκαταστήσουμε Python, pip και virtualenv. Εάν έχετε ήδη εγκαταστήσει αυτές τις βιβλιοθήκες, θα πρέπει να συνεχίσετε στο επόμενο βήμα, διαφορετικά κάντε το εξής:

εγκαταστήστε Python 3 κάνοντας λήψη από αυτό σύνδεσμος

Εγκαταστήστε το pip τρέχοντας αυτό

Εγκαταστήστε το virtualenv με αυτήν την εντολή

pip3 install –U pip virtualenv

εγκαταστήστε Microsoft Οπτικό C++ Ενημερωμένη έκδοση 2015 με δυνατότητα αναδιανομής 3

• Μεταβείτε στον ιστότοπο λήψης του Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Επιλέξτε Αναδιανεμητέα και Εργαλεία δημιουργίας
• Κατεβάστε και εγκαταστήστε το Microsoft Οπτικό C++ Ενημερωμένη έκδοση 2015 με δυνατότητα αναδιανομής 3

Στη συνέχεια, εκτελέστε αυτό το σενάριο

pip3 install virtualenv

Ρύθμιση εικονικού περιβάλλοντος

Αυτό χρησιμοποιείται για την απομόνωση του συστήματος εργασίας με το κύριο σύστημα.

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

Ενεργοποιήστε το περιβάλλον

.\venv\Scripts\activate

Μετά την προετοιμασία του περιβάλλοντος, η εγκατάσταση του Tensorflow και του Keras παραμένει ίδια με το Linux. Στη συνέχεια, σε αυτό το σεμινάριο Deep learning with Keras, θα μάθουμε για τις βασικές αρχές Keras για Deep Learning.

Keras Fundamentals for Deep Learning

Η κύρια δομή στον Keras είναι το Μοντέλο που ορίζει το πλήρες γράφημα ενός δικτύου. Μπορείτε να προσθέσετε περισσότερα επίπεδα σε ένα υπάρχον μοντέλο για να δημιουργήσετε ένα προσαρμοσμένο μοντέλο που χρειάζεστε για το έργο σας.

Δείτε πώς μπορείτε να δημιουργήσετε ένα Διαδοχικό μοντέλο και μερικά κοινά χρησιμοποιούμενα επίπεδα στη βαθιά εκμάθηση

1. Διαδοχικό Μοντέλο

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

model = Sequential()

2. Συνδυαστικό στρώμα

Αυτό είναι ένα Keras Python παράδειγμα συνελικτικού στρώματος ως στρώμα εισόδου με το σχήμα εισόδου 320x320x3, με 48 φίλτρα μεγέθους 3×3 και χρησιμοποιήστε το ReLU ως συνάρτηση ενεργοποίησης.

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

άλλος τύπος είναι

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

3. ΜέγPooling Στρώμα

Για τη μείωση του δείγματος της αναπαράστασης εισόδου, χρησιμοποιήστε το MaxPool2d και καθορίστε το μέγεθος του πυρήνα

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

4. Πυκνό στρώμα

προσθέτοντας ένα πλήρως συνδεδεμένο επίπεδο με τον καθορισμό μόνο του μεγέθους εξόδου

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

5. Επίπεδο εγκατάλειψης

Προσθήκη στρώματος εγκατάλειψης με πιθανότητα 50%.

model.add(Dropout(0.5))

Σύνταξη, Εκπαίδευση και Αξιολόγηση

Αφού ορίσουμε το μοντέλο μας, ας αρχίσουμε να τους εκπαιδεύουμε. Απαιτείται η μεταγλώττιση του δικτύου πρώτα με τη συνάρτηση απώλειας και τη λειτουργία βελτιστοποίησης. Αυτό θα επιτρέψει στο δίκτυο να αλλάξει βάρη και θα ελαχιστοποιήσει την απώλεια.

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

Τώρα για να ξεκινήσετε την εκπαίδευση, χρησιμοποιήστε το fit για να τροφοδοτήσετε τα δεδομένα εκπαίδευσης και επικύρωσης στο μοντέλο. Αυτό θα σας επιτρέψει να εκπαιδεύσετε το δίκτυο σε παρτίδες και να ορίσετε τις εποχές.

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

Το τελευταίο μας βήμα είναι να αξιολογήσουμε το μοντέλο με τα δεδομένα δοκιμής.

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

Ας δοκιμάσουμε να χρησιμοποιήσουμε απλή γραμμική παλινδρόμηση

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

Μετά την εκπαίδευση των δεδομένων, η έξοδος θα πρέπει να μοιάζει με αυτό

με το αρχικό βάρος

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

και τελικό βάρος

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

Βελτιώστε τα προεκπαιδευμένα μοντέλα στο Keras και πώς να τα χρησιμοποιήσετε

Γιατί χρησιμοποιούμε μοντέλα Fine Tune και πότε τα χρησιμοποιούμε

Η μικρορύθμιση είναι μια εργασία για την προσαρμογή ενός προεκπαιδευμένου μοντέλου έτσι ώστε οι παράμετροι να προσαρμόζονται στο νέο μοντέλο. Όταν θέλουμε να εκπαιδεύσουμε από την αρχή σε ένα νέο μοντέλο, χρειαζόμαστε μεγάλο όγκο δεδομένων, ώστε το δίκτυο να μπορεί να βρει όλες τις παραμέτρους. Αλλά σε αυτή την περίπτωση, θα χρησιμοποιήσουμε ένα προεκπαιδευμένο μοντέλο, ώστε οι παράμετροι να έχουν ήδη μάθει και να έχουν βάρος.

Για παράδειγμα, αν θέλουμε να εκπαιδεύσουμε το δικό μας μοντέλο Keras για να λύσουμε ένα πρόβλημα ταξινόμησης, αλλά έχουμε μόνο ένα μικρό όγκο δεδομένων, τότε μπορούμε να το λύσουμε χρησιμοποιώντας ένα Μεταφορά μάθησης + Μέθοδος μικρορύθμισης.

Χρησιμοποιώντας ένα προεκπαιδευμένο δίκτυο και βάρη δεν χρειάζεται να εκπαιδεύσουμε ολόκληρο το δίκτυο. Απλώς πρέπει να εκπαιδεύσουμε το τελευταίο επίπεδο που χρησιμοποιείται για να λύσουμε την εργασία μας, όπως την ονομάζουμε μέθοδο Fine-Tuning.

Προετοιμασία μοντέλου δικτύου

Για το προεκπαιδευμένο μοντέλο, μπορούμε να φορτώσουμε μια ποικιλία μοντέλων που έχει ήδη η Keras στη βιβλιοθήκη της, όπως:

• VGG16
• InceptionV3
• ResNet
• MobileNet
• Εξαίρεση
• InceptionResNetV2

Αλλά σε αυτή τη διαδικασία, θα χρησιμοποιήσουμε το μοντέλο δικτύου VGG16 και το imageNet ως βάρος μας για το μοντέλο. Θα ρυθμίσουμε με ακρίβεια ένα δίκτυο για να ταξινομήσουμε 8 διαφορετικούς τύπους κλάσεων χρησιμοποιώντας Εικόνες από Σύνολο δεδομένων Kaggle Natural Images

Αρχιτεκτονική μοντέλου VGG16

πηγή

Μεταφόρτωση των δεδομένων μας στον κάδο AWS S3

Για τη διαδικασία εκπαίδευσής μας, θα χρησιμοποιήσουμε μια εικόνα φυσικών εικόνων από 8 διαφορετικές κατηγορίες όπως αεροπλάνα, αυτοκίνητο, γάτα, σκύλος, λουλούδι, φρούτα, μοτοσικλέτες και άτομα. Πρώτα, πρέπει να ανεβάσουμε τα δεδομένα μας στο Amazon Κάδος S3.

Amazon Κάδος S3

Βήμα 1) Αφού συνδεθείτε στον λογαριασμό σας στο S3, ας δημιουργήσουμε έναν κουβά χρονομετρώντας Δημιουργία κάδου

Βήμα 2) Τώρα επιλέξτε ένα όνομα κάδου και την περιοχή σας σύμφωνα με τον λογαριασμό σας. Βεβαιωθείτε ότι το όνομα του κάδου είναι διαθέσιμο. Μετά από αυτό κάντε κλικ Δημιουργία.

Βήμα 3) Όπως μπορείτε να δείτε, ο κάδος σας είναι έτοιμος για χρήση. Αλλά όπως μπορείτε να δείτε, η Access δεν είναι δημόσια, είναι καλό για εσάς αν θέλετε να την κρατήσετε ιδιωτική για τον εαυτό σας. Μπορείτε να αλλάξετε αυτόν τον κάδο για δημόσια πρόσβαση στις Ιδιότητες κάδου

Βήμα 4) Τώρα ξεκινάτε να ανεβάζετε τα δεδομένα προπόνησής σας στο Bucket σας. Εδώ θα ανεβάσω το αρχείο tar.gz που αποτελείται από εικόνες για τη διαδικασία εκπαίδευσης και δοκιμών.

Βήμα 5) Τώρα κάντε κλικ στο αρχείο σας και αντιγράψτε το Σύνδεσμος για να το κατεβάσουμε.

Προετοιμασία δεδομένων

Πρέπει να δημιουργήσουμε τα δεδομένα προπόνησής μας χρησιμοποιώντας το Keras ImageDataGenerator.

Πρώτα πρέπει να κάνετε λήψη χρησιμοποιώντας το wget με τον σύνδεσμο προς το αρχείο σας από το S3 Bucket.

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

Αφού κατεβάσετε τα δεδομένα, ας ξεκινήσουμε την Εκπαιδευτική Διαδικασία.

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

Τα ImageDataGenerator θα δημιουργήσει δεδομένα X_training από έναν κατάλογο. Ο υποκατάλογος σε αυτόν τον κατάλογο θα χρησιμοποιηθεί ως κλάση για κάθε αντικείμενο. Η εικόνα θα φορτωθεί με τη λειτουργία χρώματος RGB, με τη λειτουργία κατηγορίας κατηγορίας για τα δεδομένα Y_training, με μέγεθος παρτίδας 16. Τέλος, ανακατέψτε τα δεδομένα.

Ας δούμε τις εικόνες μας τυχαία σχεδιάζοντάς τες με το matplotlib

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

Μετά από αυτό, ας δημιουργήσουμε το μοντέλο δικτύου μας από το VGG16 με προεκπαιδευμένο βάρος imageNet. Θα παγώσουμε αυτά τα στρώματα, έτσι ώστε τα στρώματα να μην είναι εκπαιδεύσιμα για να μας βοηθήσουν να μειώσουμε τον χρόνο υπολογισμού.

Δημιουργία του Μοντέλου μας από το 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())

Όπως μπορείτε να δείτε παρακάτω, η περίληψη του μοντέλου δικτύου μας. Από μια είσοδο από τα επίπεδα VGG16, στη συνέχεια προσθέτουμε 2 πλήρως συνδεδεμένο επίπεδο που θα εξαγάγει 1024 χαρακτηριστικά και ένα επίπεδο εξόδου που θα υπολογίζει τις 8 κλάσεις με την ενεργοποίηση softmax.

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

Προπόνηση

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

Αποτελέσματα

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

Όπως μπορείτε να δείτε, οι απώλειές μας μειώνονται σημαντικά και η ακρίβεια είναι σχεδόν 100%. Για τη δοκιμή του μοντέλου μας, επιλέξαμε τυχαία εικόνες μέσω του Διαδικτύου και τις τοποθετήσαμε στον φάκελο δοκιμής με διαφορετική κατηγορία για δοκιμή

Δοκιμάζοντας το μοντέλο μας

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

Και η δοκιμή μας είναι όπως δίνεται παρακάτω! Μόνο 1 εικόνα προβλέπεται λάθος από μια δοκιμή 14 εικόνων!

Νευρωνικό δίκτυο αναγνώρισης προσώπου με Keras

Γιατί χρειαζόμαστε την Αναγνώριση

Χρειαζόμαστε Αναγνώριση για να μας διευκολύνει να αναγνωρίσουμε ή να αναγνωρίσουμε το πρόσωπο ενός ατόμου, τον τύπο αντικειμένων, την εκτιμώμενη ηλικία ενός ατόμου από το πρόσωπό του ή ακόμα και να γνωρίζουμε τις εκφράσεις του προσώπου αυτού του ατόμου.

Ίσως συνειδητοποιείτε κάθε φορά που προσπαθείτε να μαρκάρετε το πρόσωπο του φίλου σας σε μια φωτογραφία, η λειτουργία στο Facebook το έχει κάνει για εσάς, δηλαδή μαρκάρει το πρόσωπο του φίλου σας χωρίς να χρειάζεται να το μαρκάρετε πρώτα. Αυτό είναι το Face Recognition που εφαρμόζεται από το Facebook για να μας διευκολύνει να κάνουμε tag φίλους.

Πως λειτουργεί, λοιπόν? Κάθε φορά που σημαδεύουμε το πρόσωπο του φίλου μας, το AI του Facebook θα το μάθει και θα προσπαθήσει να το προβλέψει μέχρι να πάρει το σωστό αποτέλεσμα. Το ίδιο σύστημα θα χρησιμοποιήσουμε για να φτιάξουμε το δικό μας Face Recognition. Ας αρχίσουμε να φτιάχνουμε τη δική μας Αναγνώριση Προσώπου χρησιμοποιώντας το Deep Learning

Μοντέλο δικτύου

Θα χρησιμοποιήσουμε ένα μοντέλο δικτύου VGG16 αλλά με βάρος VGGFace.

Αρχιτεκτονική μοντέλου VGG16

Τι είναι το VGGFace; είναι η εφαρμογή Keras της Deep Face Recognition που εισήχθη από τους Parkhi, Omkar M. et al. «Βαθιά Αναγνώριση Προσώπου». BMVC (2015). Το πλαίσιο χρησιμοποιεί το VGG16 ως αρχιτεκτονική δικτύου.

Μπορείτε να κάνετε λήψη του VGGFace από 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()

Όπως μπορείτε να δείτε τη σύνοψη του δικτύου

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

θα κάνουμε ένα Μεταφορά μάθησης + Fine Tuning για να κάνετε την εκπαίδευση πιο γρήγορη με μικρά σύνολα δεδομένων. Αρχικά, θα παγώσουμε τα βασικά στρώματα έτσι ώστε τα στρώματα να μην μπορούν να εκπαιδεύονται.

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

στη συνέχεια προσθέτουμε το δικό μας στρώμα για να αναγνωρίσουμε τα δοκιμαστικά μας πρόσωπα. Θα προσθέσουμε 2 πλήρως συνδεδεμένα στρώματα και ένα επίπεδο εξόδου με 5 άτομα προς ανίχνευση.

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)

Ας δούμε τη σύνοψη του δικτύου μας

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

Όπως μπορείτε να δείτε παραπάνω, μετά το επίπεδο pool5, θα ισοπεδωθεί σε ένα ενιαίο διάνυσμα χαρακτηριστικών που θα χρησιμοποιηθεί από το πυκνό στρώμα για την τελική αναγνώριση.

Προετοιμασία των Προσώπων μας

Τώρα ας ετοιμάσουμε τα πρόσωπά μας. Έφτιαξα έναν κατάλογο που αποτελείται από 5 διάσημους ανθρώπους

• Jack Ma
• Jason Statham
• Johnny Depp
• Ρόμπερτ Ντάουνι Τζούνιορ
• Rowan Atkinson

Κάθε φάκελος περιέχει 10 εικόνες, για κάθε διαδικασία εκπαίδευσης και αξιολόγησης. Είναι ένας πολύ μικρός όγκος δεδομένων, αλλά αυτή είναι η πρόκληση, σωστά;

Θα χρησιμοποιήσουμε τη βοήθεια του εργαλείου Keras για να μας βοηθήσει να προετοιμάσουμε τα δεδομένα. Αυτή η συνάρτηση θα επαναληφθεί στον φάκελο δεδομένων και στη συνέχεια θα την προετοιμάσει ώστε να μπορεί να χρησιμοποιηθεί στην εκπαίδευση.

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

Εκπαίδευση του μοντέλου μας

Ας ξεκινήσουμε τη διαδικασία εκπαίδευσής μας συντάσσοντας το δίκτυό μας με λειτουργία απώλειας και βελτιστοποιητή. Εδώ, χρησιμοποιούμε sparse_categorical_crossentropy ως συνάρτηση απώλειας, με τη βοήθεια του SGD ως βελτιστοποιητή μάθησης.

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

Όπως μπορείτε να δείτε, η ακρίβεια επικύρωσής μας είναι έως και 64%, αυτό είναι ένα καλό αποτέλεσμα για έναν μικρό όγκο δεδομένων εκπαίδευσης. Μπορούμε να το βελτιώσουμε προσθέτοντας περισσότερο στρώμα ή προσθέτοντας περισσότερες εικόνες εκπαίδευσης, ώστε το μοντέλο μας να μπορεί να μάθει περισσότερα για τα πρόσωπα και να επιτύχει μεγαλύτερη ακρίβεια.

Ας δοκιμάσουμε το μοντέλο μας με μια δοκιμαστική εικόνα

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

Χρησιμοποιώντας την εικόνα του Robert Downey Jr ως δοκιμαστική εικόνα, δείχνει ότι το προβλεπόμενο πρόσωπο είναι αληθινό!

Πρόβλεψη χρησιμοποιώντας Live Cam!

Τι θα λέγατε αν δοκιμάσουμε τις ικανότητές μας με την εφαρμογή της με μια είσοδο από μια κάμερα web; Χρησιμοποιώντας το OpenCV με καταρράκτη Haar Face για να βρούμε το πρόσωπό μας και με τη βοήθεια του μοντέλου δικτύου μας, μπορούμε να αναγνωρίσουμε το άτομο.

Το πρώτο βήμα είναι να προετοιμάσετε εσάς και τα πρόσωπα του φίλου σας. Όσο περισσότερα δεδομένα έχουμε τότε τόσο καλύτερο είναι το αποτέλεσμα!

Προετοιμάστε και εκπαιδεύστε το δίκτυό σας όπως το προηγούμενο βήμα, αφού ολοκληρωθεί η εκπαίδευση, προσθέστε αυτήν τη γραμμή για να λάβετε την εικόνα εισόδου από την κάμερα

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

Ποιό είναι καλύτερο? Keras ή Tensorflow

Ο Κέρας προσφέρει απλότητα κατά τη συγγραφή του σεναρίου. Μπορούμε να αρχίσουμε να γράφουμε και να καταλαβαίνουμε απευθείας με τον Keras, καθώς δεν είναι πολύ δύσκολο να το καταλάβουμε. Είναι πιο φιλικό προς το χρήστη και εύκολο στην εφαρμογή, δεν χρειάζεται να κάνετε πολλές μεταβλητές για να εκτελέσετε το μοντέλο. Έτσι, δεν χρειάζεται να κατανοούμε κάθε λεπτομέρεια στη διαδικασία του backend.

Από την άλλη πλευρά, το Tensorflow είναι οι λειτουργίες χαμηλού επιπέδου που προσφέρουν ευελιξία και προηγμένες λειτουργίες εάν θέλετε να δημιουργήσετε ένα αυθαίρετο υπολογιστικό γράφημα ή μοντέλο. Το Tensorflow μπορεί επίσης να απεικονίσει τη διαδικασία με τη βοήθεια του TensorBoard και ένα εξειδικευμένο εργαλείο εντοπισμού σφαλμάτων.

Έτσι, εάν θέλετε να ξεκινήσετε να εργάζεστε με βαθιά μάθηση με όχι τόσο πολυπλοκότητα, χρησιμοποιήστε το Keras. Επειδή το Keras προσφέρει απλότητα και φιλικό προς το χρήστη στη χρήση και εύκολο στην εφαρμογή από το Tensorflow. Αλλά αν θέλετε να γράψετε τον δικό σας αλγόριθμο σε έργο βαθιάς μάθησης ή έρευνα, θα πρέπει να χρησιμοποιήσετε το Tensorflow.

Περίληψη

Ας συνοψίσουμε λοιπόν όλα όσα έχουμε συζητήσει και κάνει σε αυτό το σεμινάριο.

• Το Keras σε ένα API υψηλού επιπέδου που χρησιμοποιείται για να διευκολύνει τα δίκτυα βαθιάς εκμάθησης με τη βοήθεια του μηχανισμού υποστήριξης.
• Το Keras είναι εύκολο στη χρήση και κατανοητό με υποστήριξη python, ώστε να αισθάνεται πιο φυσικό από ποτέ. Είναι καλό για αρχάριους που θέλουν να μάθουν για τη βαθιά μάθηση και για ερευνητές που θέλουν εύκολο στη χρήση API.
• Η διαδικασία εγκατάστασης είναι εύκολη και μπορείτε να χρησιμοποιήσετε ένα εικονικό περιβάλλον ή χρησιμοποιώντας μια εξωτερική πλατφόρμα όπως π.χ AWS.
• Το Keras διαθέτει επίσης διάφορα είδη μοντέλων δικτύου, ώστε να μας διευκολύνει να χρησιμοποιούμε το διαθέσιμο μοντέλο για προεκπαιδευμένο και τελειοποιημένο μοντέλο δικτύου.
• Επίσης, υπάρχουν πολλά σεμινάρια και άρθρα σχετικά με τη χρήση κωδικών Keras από κοινότητες σε όλο τον κόσμο για σκοπούς βαθιάς εκμάθησης.