Εισαγωγή
Η υπερπροσαρμογή στα ConvNets είναι μια πρόκληση στη βαθιά μάθηση και στα νευρωνικά δίκτυα, όπου ένα μοντέλο μαθαίνει πάρα πολλά από τα δεδομένα εκπαίδευσης, οδηγώντας σε κακή απόδοση σε νέα δεδομένα. Αυτό το φαινόμενο είναι ιδιαίτερα διαδεδομένο σε πολύπλοκες νευρωνικές αρχιτεκτονικές, οι οποίες μπορούν να μοντελοποιήσουν περίπλοκες σχέσεις. Η αντιμετώπιση της υπερπροσαρμογής στο convnet είναι ζωτικής σημασίας για τη δημιουργία αξιόπιστων μοντέλων νευρωνικών δικτύων. Αυτό το άρθρο παρέχει έναν οδηγό για την κατανόηση και τον μετριασμό της υπερπροσαρμογής, την εξέταση των βασικών αιτιών όπως η πολυπλοκότητα του μοντέλου, τα περιορισμένα δεδομένα εκπαίδευσης και οι θορυβώδεις λειτουργίες. Συζητά επίσης τεχνικές για την πρόληψη της υπερβολικής προσαρμογής, όπως στρατηγικές αύξησης δεδομένων και μεθόδους τακτοποίησης.
Θα συνιστούσα να διαβάσετε αυτά τα άρθρα για βασική κατανόηση υπερπροσαρμογή, υποτοπισμός και αντιστάθμιση διακύμανσης μεροληψίας.
Μάθετε Στόχους
- Κατανοήστε τις αιτίες, τις συνέπειες και τα σενάρια της υπερβολικής προσαρμογής ConvNets.
- Ερμηνεύστε τις καμπύλες μάθησης για να ανιχνεύσετε την υπερπροσαρμογή και την υποπροσαρμογή σε μοντέλα νευρωνικών δικτύων.
- Μάθετε διάφορες τεχνικές για τον μετριασμό της υπερπροσαρμογής, όπως πρώιμη διακοπή, εγκατάλειψη, ομαλοποίηση παρτίδας, τακτοποίηση και αύξηση δεδομένων.
- Εφαρμόστε αυτές τις τεχνικές χρησιμοποιώντας TensorFlow και Keras για την εκπαίδευση των ConvNets στο σύνολο δεδομένων CIFAR-10.
- Αναλύστε τον αντίκτυπο των διαφορετικών τεχνικών στην απόδοση και τη γενίκευση του μοντέλου.
Πίνακας περιεχομένων
Συνήθη σενάρια για υπερπροσαρμογή στο ConvNet
Ας δούμε μερικά κοινά σενάρια υπερπροσαρμογής στο ConvNet:
Σενάριο 1: Εξαιρετικά σύνθετο μοντέλο με ανεπαρκή δεδομένα
Η χρήση ενός πολύ περίπλοκου μοντέλου, όπως ένα βαθύ νευρωνικό δίκτυο, σε ένα μικρό σύνολο δεδομένων μπορεί να οδηγήσει σε υπερπροσαρμογή. Το μοντέλο μπορεί να απομνημονεύει τα παραδείγματα εκπαίδευσης αντί να μαθαίνει το γενικό μοτίβο. Για παράδειγμα, η εκπαίδευση ενός βαθιού νευρωνικού δικτύου με μερικές μόνο εκατοντάδες εικόνες για μια περίπλοκη εργασία όπως η αναγνώριση εικόνων θα μπορούσε να οδηγήσει σε υπερπροσαρμογή.
Συνέπεια
Το μοντέλο μπορεί να αποδίδει πολύ καλά στα δεδομένα εκπαίδευσης, αλλά δεν μπορεί να γενικευτεί σε νέα, αόρατα δεδομένα, με αποτέλεσμα κακή απόδοση σε εφαρμογές του πραγματικού κόσμου.
Πώς να επιλύσετε αυτό το ζήτημα;
Λάβετε περισσότερα δεδομένα εκπαίδευσης, κάντε αύξηση εικόνας για να γενικεύσετε το σύνολο δεδομένων μας. Ξεκινήστε με ένα λιγότερο σύνθετο μοντέλο και αν η χωρητικότητα είναι μικρότερη, αυξήστε την πολυπλοκότητα.
Σενάριο 2: Υπερβολική προπόνηση
Η συνεχής εκπαίδευση ενός μοντέλου για πάρα πολλές εποχές μπορεί να οδηγήσει σε υπερβολική προσαρμογή. Καθώς το μοντέλο βλέπει τα δεδομένα εκπαίδευσης επανειλημμένα, μπορεί να αρχίσει να τα απομνημονεύει αντί να μαθαίνει τα υποκείμενα μοτίβα.
Συνέπεια
Η απόδοση του μοντέλου μπορεί να φθάσει ή ακόμα και να υποβαθμιστεί σε αόρατα δεδομένα, καθώς εξειδικεύεται ολοένα και περισσότερο στο σετ εκπαίδευσης.
Πώς να επιλύσετε αυτό το ζήτημα;
Χρησιμοποιήστε πρόωρη στάση για να αποφύγετε την υπερβολική εφαρμογή του μοντέλου και αποθηκεύστε το καλύτερο μοντέλο.
Σενάριο 3: Αγνοώντας την τακτοποίηση
Τεχνικές κανονικοποίησης, όπως η τακτοποίηση L1 ή L2, χρησιμοποιούνται για την αποφυγή υπερβολικής προσαρμογής τιμωρώντας πολύπλοκα μοντέλα. Η παράβλεψη ή η ακατάλληλη ρύθμιση των παραμέτρων τακτοποίησης μπορεί να οδηγήσει σε υπερβολική προσαρμογή.
Συνέπεια
Το μοντέλο μπορεί να γίνει υπερβολικά περίπλοκο και να μην μπορεί να γενικευτεί καλά σε νέα δεδομένα, με αποτέλεσμα κακή απόδοση εκτός του σετ εκπαίδευσης.
Πώς να επιλύσετε αυτό το ζήτημα;
Εφαρμογή τακτοποίησης, διασταυρούμενη επικύρωση, συντονισμός υπερπαραμέτρων.
Τι είναι η χωρητικότητα του μοντέλου;
Η χωρητικότητα ενός μοντέλου αναφέρεται στο μέγεθος και την πολυπλοκότητα των μοτίβων που μπορεί να μάθει. Για τα νευρωνικά δίκτυα, αυτό θα καθοριστεί σε μεγάλο βαθμό από το πόσους νευρώνες έχει και πώς συνδέονται μεταξύ τους. Εάν φαίνεται ότι το δίκτυό σας δεν πληροί τα δεδομένα, θα πρέπει να προσπαθήσετε να αυξήσετε τη χωρητικότητά του.
Μπορείτε να αυξήσετε τη χωρητικότητα ενός δικτύου είτε διευρύνοντάς το (περισσότερες μονάδες σε υπάρχοντα επίπεδα) είτε κάνοντάς το βαθύτερο (προσθέτοντας περισσότερα επίπεδα). Τα ευρύτερα δίκτυα μαθαίνουν πιο εύκολα γραμμικές σχέσεις, ενώ τα βαθύτερα δίκτυα προτιμούν πιο μη γραμμικά. Το ποιο είναι καλύτερο εξαρτάται απλώς από το σύνολο δεδομένων.
Ερμηνεία καμπυλών μάθησης
Το Keras παρέχει τη δυνατότητα καταγραφής ανακλήσεων κατά την εκπαίδευση α μοντέλο βαθιάς μάθησης. Μία από τις προεπιλεγμένες επανακλήσεις που καταγράφονται κατά την εκπαίδευση όλων των μοντέλων βαθιάς εκμάθησης είναι η επανάκληση ιστορικού. Καταγράφει μετρήσεις εκπαίδευσης για κάθε εποχή. Αυτό περιλαμβάνει την απώλεια και την ακρίβεια (για προβλήματα ταξινόμησης) και την απώλεια και την ακρίβεια για το σύνολο δεδομένων επικύρωσης, εάν έχει οριστεί.
Το αντικείμενο ιστορικού επιστρέφεται από κλήσεις στη συνάρτηση fit() που χρησιμοποιείται για την εκπαίδευση του μοντέλου. Οι μετρήσεις αποθηκεύονται σε ένα λεξικό στο μέλος ιστορικού του αντικειμένου που επιστρέφεται.
Για παράδειγμα, μπορείτε να παραθέσετε τις μετρήσεις που συλλέγονται σε ένα αντικείμενο ιστορικού χρησιμοποιώντας το ακόλουθο απόσπασμα κώδικα μετά την εκπαίδευση ενός μοντέλου:
# list all data in history
print(history.history.keys())Παραγωγή:
['accuracy', 'loss', 'val_accuracy', 'val_loss']
Τύπος πληροφοριών
Μπορείτε να σκεφτείτε ότι οι πληροφορίες στα δεδομένα εκπαίδευσης είναι δύο ειδών:
- Σήμα: Το σήμα είναι το μέρος που γενικεύει, το μέρος που μπορεί να βοηθήσει το μοντέλο μας να κάνει προβλέψεις από νέα δεδομένα.
- Θόρυβος: Ο θόρυβος είναι εκείνο το μέρος που ισχύει μόνο για τα δεδομένα εκπαίδευσης. Ο θόρυβος είναι όλη η τυχαία διακύμανση που προέρχεται από δεδομένα στον πραγματικό κόσμο ή όλα τα τυχαία, μη ενημερωτικά μοτίβα που δεν μπορούν να βοηθήσουν το μοντέλο να κάνει προβλέψεις. Ο θόρυβος είναι το μέρος που μπορεί να φαίνεται χρήσιμο, αλλά στην πραγματικότητα δεν είναι.
Όταν εκπαιδεύουμε ένα μοντέλο, σχεδιάζουμε την απώλεια στο σετ εκπαίδευσης κάθε εποχή. Σε αυτό θα προσθέσουμε και μια γραφική παράσταση των δεδομένων επικύρωσης. Αυτά τα διαγράμματα ονομάζουμε καμπύλες μάθησης. Για να εκπαιδεύσουμε αποτελεσματικά μοντέλα βαθιάς μάθησης, πρέπει να είμαστε σε θέση να τα ερμηνεύσουμε.
Στο παραπάνω σχήμα μπορούμε να δούμε ότι η απώλεια εκπαίδευσης μειώνεται καθώς αυξάνονται οι εποχές, αλλά η απώλεια επικύρωσης μειώνεται στην αρχή και αυξάνεται καθώς το μοντέλο αρχίζει να συλλαμβάνει τον θόρυβο που υπάρχει στο σύνολο δεδομένων. Τώρα θα δούμε πώς να αποφύγετε την υπερβολική προσαρμογή στα ConvNets μέσω διαφόρων τεχνικών.
Μέθοδοι για να αποφύγετε την υπερβολική τοποθέτηση
Τώρα που είδαμε ορισμένα σενάρια και πώς να ερμηνεύσουμε τις καμπύλες μάθησης για να ανιχνεύσουμε την υπερβολική προσαρμογή. Ας δούμε μερικές μεθόδους για να αποφύγουμε την υπερβολική προσαρμογή σε ένα νευρωνικό δίκτυο:
Μέθοδος 1: Χρησιμοποιήστε περισσότερα δεδομένα
Η αύξηση του μεγέθους του συνόλου δεδομένων σας μπορεί να βοηθήσει το μοντέλο να γενικευτεί καλύτερα, καθώς έχει περισσότερα διαφορετικά παραδείγματα για να μάθει. Το μοντέλο θα βρει σημαντικά μοτίβα που υπάρχουν στο σύνολο δεδομένων και θα αγνοήσει το θόρυβο καθώς το μοντέλο συνειδητοποιεί ότι αυτά τα συγκεκριμένα μοτίβα (θόρυβος) δεν υπάρχουν σε όλο το σύνολο δεδομένων.
Μέθοδος 2: Πρόωρη διακοπή
Η πρόωρη διακοπή είναι μια τεχνική που χρησιμοποιείται για την αποφυγή της υπερπροσαρμογής παρακολουθώντας την απόδοση του μοντέλου σε ένα σετ επικύρωσης κατά τη διάρκεια της εκπαίδευσης. Η εκπαίδευση διακόπτεται όταν η απόδοση στο σετ επικύρωσης αρχίσει να υποβαθμίζεται, υποδεικνύοντας ότι το μοντέλο αρχίζει να υπερπροσαρμόζεται. Συνήθως, χρησιμοποιείται ένα ξεχωριστό σύνολο επικύρωσης για την παρακολούθηση της απόδοσης και η εκπαίδευση διακόπτεται όταν η απόδοση δεν έχει βελτιωθεί για έναν καθορισμένο αριθμό εποχών.
Μέθοδος 3: Εγκατάλειψη
Γνωρίζουμε ότι η υπερπροσαρμογή προκαλείται από την εκμάθηση του δικτύου ψευδών μοτίβων (θόρυβος) στα δεδομένα εκπαίδευσης. Για να αναγνωρίσει αυτά τα πλαστά μοτίβα ένα δίκτυο θα βασίζεται συχνά σε πολύ συγκεκριμένους συνδυασμούς βάρους, ένα είδος «συνωμοσίας» βαρών. Όντας τόσο συγκεκριμένα, τείνουν να είναι εύθραυστα: αφαιρέστε ένα και η συνωμοσία καταρρέει.
Αυτή είναι η ιδέα πίσω από την εγκατάλειψη. Για να διαλύσουμε αυτές τις συνωμοσίες, απορρίπτουμε τυχαία ένα μέρος των μονάδων εισόδου ενός επιπέδου σε κάθε βήμα της εκπαίδευσης, καθιστώντας πολύ πιο δύσκολο για το δίκτυο να μάθει αυτά τα πλαστά μοτίβα στα δεδομένα εκπαίδευσης. Αντίθετα, πρέπει να αναζητήσει ευρεία, γενικά μοτίβα, των οποίων τα μοτίβα βάρους τείνουν να είναι πιο στιβαρά.
Θα μπορούσατε επίσης να σκεφτείτε την εγκατάλειψη ως τη δημιουργία ενός είδους συνόλου δικτύων. Οι προβλέψεις δεν θα γίνονται πλέον από ένα μεγάλο δίκτυο, αλλά από μια επιτροπή μικρότερων δικτύων. Τα άτομα στην επιτροπή τείνουν να κάνουν διαφορετικά είδη λαθών, αλλά έχουν δίκιο ταυτόχρονα, καθιστώντας την επιτροπή ως σύνολο καλύτερη από οποιοδήποτε άτομο. (Εάν είστε εξοικειωμένοι με τα τυχαία δάση ως ένα σύνολο δέντρων απόφασης, είναι η ίδια ιδέα.)
Μέθοδος 4: Κανονικοποίηση παρτίδας
Η επόμενη ειδική μέθοδος που θα εξετάσουμε εκτελεί την «ομαλοποίηση παρτίδας» (ή «ομαλοποίηση παρτίδας»), η οποία μπορεί να βοηθήσει στη διόρθωση της προπόνησης που είναι αργή ή ασταθής.
Με τα νευρωνικά δίκτυα, είναι γενικά καλή ιδέα να τοποθετείτε όλα τα δεδομένα σας σε μια κοινή κλίμακα, ίσως με κάτι όπως το StandardScaler του scikit-learn ή το MinMaxScaler. Ο λόγος είναι ότι το SGD θα μετατοπίσει τα βάρη του δικτύου ανάλογα με το πόσο μεγάλη ενεργοποίηση παράγουν τα δεδομένα. Χαρακτηριστικά που τείνουν να παράγουν ενεργοποιήσεις πολύ διαφορετικών μεγεθών μπορεί να δημιουργήσουν ασταθή συμπεριφορά προπόνησης.
Τώρα, αν είναι καλό να ομαλοποιήσετε τα δεδομένα πριν μπουν στο δίκτυο, ίσως και η κανονικοποίηση μέσα στο δίκτυο θα ήταν καλύτερη! Στην πραγματικότητα, έχουμε ένα ειδικό είδος στρώματος που μπορεί να το κάνει αυτό, το επίπεδο ομαλοποίησης παρτίδας. Ένα επίπεδο κανονικοποίησης παρτίδας εξετάζει κάθε παρτίδα καθώς εισέρχεται, πρώτα κανονικοποιώντας την παρτίδα με τη δική της μέση και τυπική απόκλιση και στη συνέχεια τοποθετώντας τα δεδομένα σε μια νέα κλίμακα με δύο παραμέτρους επανακλιμάκωσης που μπορούν να εκπαιδευτούν. Το Batchnorm, στην πραγματικότητα, εκτελεί ένα είδος συντονισμένης επανακλιμάκωσης των εισόδων του.
Τις περισσότερες φορές, το batchnorm προστίθεται ως βοήθεια στη διαδικασία βελτιστοποίησης (αν και μερικές φορές μπορεί επίσης να βοηθήσει στην πρόβλεψη της απόδοσης). Τα μοντέλα με batchnorm τείνουν να χρειάζονται λιγότερες εποχές για να ολοκληρώσουν την εκπαίδευση. Επιπλέον, το batchnorm μπορεί επίσης να διορθώσει διάφορα προβλήματα που μπορεί να προκαλέσουν «κολλήσει» της εκπαίδευσης. Εξετάστε το ενδεχόμενο να προσθέσετε κανονικοποίηση παρτίδας στα μοντέλα σας, ειδικά εάν αντιμετωπίζετε προβλήματα κατά τη διάρκεια της εκπαίδευσης.
Μέθοδος 5: Τακτοποίηση L1 και L2
Η τακτοποίηση L1 και L2 είναι τεχνικές που χρησιμοποιούνται για την πρόληψη της υπερπροσαρμογής τιμωρώντας μεγάλα βάρη στο νευρωνικό δίκτυο. Η τακτοποίηση L1 προσθέτει έναν όρο ποινής στη συνάρτηση απώλειας ανάλογο με την απόλυτη τιμή των βαρών. Ενθαρρύνει την αραιότητα στα βάρη και μπορεί να οδηγήσει σε επιλογή χαρακτηριστικών. Η τακτοποίηση L2, γνωστή και ως μείωση βάρους, προσθέτει έναν όρο ποινής ανάλογο με το τετράγωνο των βαρών στη συνάρτηση απώλειας. Αποτρέπει το να γίνουν πολύ μεγάλα τα βάρη και ενθαρρύνει την κατανομή των βαρών πιο ομοιόμορφα.
Η επιλογή μεταξύ της τακτοποίησης L1 και L2 εξαρτάται συχνά από το συγκεκριμένο πρόβλημα και τις επιθυμητές ιδιότητες του μοντέλου.
Η ύπαρξη μεγάλων τιμών για την τακτοποίηση L1/L2 θα έχει ως αποτέλεσμα το μοντέλο να μην μαθαίνει γρήγορα και να φτάσει σε ένα οροπέδιο στη μάθηση με αποτέλεσμα το μοντέλο να μην ταιριάζει.
Μέθοδος 6: Επαύξηση δεδομένων
Ο καλύτερος τρόπος για να βελτιώσετε την απόδοση ενός μοντέλου μηχανικής μάθησης είναι να το εκπαιδεύσετε σε περισσότερα δεδομένα. Όσο περισσότερα παραδείγματα πρέπει να μάθει το μοντέλο, τόσο καλύτερα θα είναι σε θέση να αναγνωρίσει ποιες διαφορές στις εικόνες έχουν σημασία και ποιες όχι. Περισσότερα δεδομένα βοηθούν το μοντέλο να γενικεύει καλύτερα.
Ένας εύκολος τρόπος για να αποκτήσετε περισσότερα δεδομένα είναι να χρησιμοποιήσετε τα δεδομένα που έχετε ήδη. Εάν μπορούμε να μετατρέψουμε τις εικόνες στο σύνολο δεδομένων μας με τρόπους που να διατηρούν την κλάση (παράδειγμα: Ταξινόμηση ψηφίων MNIST, αν δοκιμάσουμε την προσθήκη 6, θα είναι δύσκολο να γίνει διάκριση μεταξύ 6 και 9), μπορούμε να διδάξουμε στον ταξινομητή μας να αγνοεί αυτά τα είδη μετασχηματισμών. Για παράδειγμα, εάν ένα αυτοκίνητο είναι στραμμένο προς τα αριστερά ή προς τα δεξιά σε μια φωτογραφία δεν αλλάζει το γεγονός ότι είναι αυτοκίνητο και όχι φορτηγό. Έτσι, αν αυξήσουμε τα δεδομένα προπόνησής μας με αναποδογυρισμένες εικόνες, ο ταξινομητής μας θα μάθει ότι "αριστερά ή δεξιά" είναι μια διαφορά που πρέπει να αγνοήσει.
Και αυτή είναι η όλη ιδέα πίσω από την αύξηση δεδομένων: προσθέστε μερικά επιπλέον πλαστά δεδομένα που μοιάζουν εύλογα με τα πραγματικά δεδομένα και ο ταξινομητής σας θα βελτιωθεί.
Θυμηθείτε, το κλειδί για να αποφύγετε την υπερβολική τοποθέτηση είναι να βεβαιωθείτε ότι το μοντέλο σας γενικεύεται καλά. Ελέγχετε πάντα την απόδοση του μοντέλου σας σε ένα σετ επικύρωσης, όχι μόνο στο σετ εκπαίδευσης.
Υλοποίηση των παραπάνω μεθόδων με δεδομένα
Ας διερευνήσουμε τα βήματα υλοποίησης για τις παραπάνω μεθόδους:
Βήμα 1: Φόρτωση απαραίτητων βιβλιοθηκών
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras import datasets, layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import ModelCheckpoint
import keras
from keras.preprocessing import image
from keras import models, layers, regularizers
from tqdm import tqdm
import warnings
warnings.filterwarnings(action='ignore')
Βήμα 2: Φόρτωση συνόλου δεδομένων και προεπεξεργασία
#Here all the images are in the form of a numpy array
cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0
Βήμα 3: Εκμάθηση συνόλου δεδομένων
x_train.shape, y_train.shape, x_test.shape, y_test.shape Παραγωγή:
np.unique(y_train)
Παραγωγή:
#These labels are in the order and taken from the documentaion
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']
Βήμα 4: Οπτικοποίηση εικόνας από το σύνολο δεδομένων
def show_image(IMG_INDEX):
plt.imshow(x_train[20] ,cmap=plt.cm.binary)
plt.xlabel(class_names[y_train[IMG_INDEX][0]])
plt.show()
show_image(20)
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.summary()
Ας αρχικοποιήσουμε τώρα τις υπερπαραμέτρους και το μοντέλο μεταγλώττισης με βελτιστοποιητή, συνάρτηση απώλειας και μετρική αξιολόγησης.
train_hyperparameters_config={'optim':keras.optimizers.Adam(learning_rate=0.001),
'epochs':20,
'batch_size':16
}
model.compile(optimizer=train_hyperparameters_config['optim'],
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
Βήμα 6: Μοντέλο εκπαίδευσης
history = model.fit(x_train, y_train,
epochs=train_hyperparameters_config['epochs'],
batch_size=train_hyperparameters_config['batch_size'],
verbose=1,
validation_data=(x_test, y_test))
Βήμα 7: Αξιολογήστε το μοντέλο
Αυτά θα μας πουν τις πληροφορίες που περιέχονται στο αντικείμενο ιστορικού και τις χρησιμοποιούμε για να δημιουργήσουμε τις καμπύλες πληροφοριών μας.
print(history.history.keys()) 
def learning_curves(history):
# Plotting Accuracy
plt.figure(figsize=(14, 5)) # Adjust the figure size as needed
plt.subplot(1, 2, 1) # Subplot with 1 row, 2 columns, and index 1
plt.plot(history.history['accuracy'], label='train_accuracy', marker='s', markersize=4)
plt.plot(history.history['val_accuracy'], label='val_accuracy', marker='*', markersize=4)
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend(loc='lower right')
# Plotting Loss
plt.subplot(1, 2, 2) # Subplot with 1 row, 2 columns, and index 2
plt.plot(history.history['loss'], label='train_loss', marker='s', markersize=4)
plt.plot(history.history['val_loss'], label='val_loss', marker='*', markersize=4)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend(loc='lower right')
plt.show()
learning_curves(history)
Από τις καμπύλες μπορούμε να δούμε ότι η ακρίβεια επικύρωσης φτάνει σε ένα οροπέδιο μετά την 4η εποχή και το μοντέλο αρχίζει να καταγράφει θόρυβο. Ως εκ τούτου, θα εφαρμόσουμε πρόωρη διακοπή για να αποφύγουμε την υπερβολική προσαρμογή του μοντέλου και να επαναφέρουμε τα καλύτερα βάρη με βάση το val_loss. Θα χρησιμοποιήσουμε το val_loss για την παρακολούθηση της πρόωρης διακοπής, καθώς το νευρωνικό μας δίκτυο προσπαθεί να μειώσει τις απώλειες χρησιμοποιώντας βελτιστοποιητές. Η ακρίβεια και η ακρίβεια επικύρωσης εξαρτώνται από το όριο (Πιθανότητα διαχωρισμού κλάσεων - συνήθως 0.5 για δυαδική ταξινόμηση), οπότε εάν το σύνολο δεδομένων μας δεν είναι ισορροπημένο, θα πρέπει να ανησυχούμε στις περισσότερες περιπτώσεις.
Βήμα 8: Εφαρμογή πρόωρης διακοπής
Εφόσον δεν ανησυχούμε για την υπερβολική εφαρμογή του μοντέλου μας, καθώς η πρόωρη διακοπή θα αποτρέψει την εμφάνιση του μοντέλου μας. Είναι μια καλή επιλογή να επιλέξετε μεγαλύτερο αριθμό εποχών και κατάλληλη υπομονή. Τώρα θα χρησιμοποιήσουμε την ίδια αρχιτεκτονική μοντέλου και θα εκπαιδεύσουμε με πρόωρη διακοπή κλήσης.
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.AveragePooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.summary()
# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
'optim': keras.optimizers.Adam(learning_rate=0.001),
'patience': 5,
'epochs': 50,
'batch_size': 32,
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0.001, # minimium amount of change to count as an improvement
patience=train_hyperparameters_config['patience'],
restore_best_weights=True)
def model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config):
model.compile(optimizer=train_hyperparameters_config['optim'],
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
ht = model.fit(x_train, y_train,
epochs=train_hyperparameters_config['epochs'],
batch_size=train_hyperparameters_config['batch_size'],
callbacks=[callback],
verbose=1,
validation_data=(x_test, y_test))
return ht
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)
learning_curves(ht)
Να γνωρίζουμε τα καλύτερα βάρη μας που έχει πάρει το μοντέλο.
print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)
Βήμα 9: Αύξηση της πολυπλοκότητας του μοντέλου
Δεδομένου ότι το μοντέλο μας δεν έχει καλή απόδοση και δεν ταιριάζει, καθώς δεν μπορεί να συλλάβει αρκετά δεδομένα. Θα πρέπει να αυξήσουμε την πολυπλοκότητα του μοντέλου μας και να αξιολογήσουμε.
model = models.Sequential()
model.add(layers.Conv2D(128, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
Μπορούμε να δούμε ότι υπάρχει αύξηση στις συνολικές παραμέτρους. Αυτό θα βοηθούσε στην εύρεση πιο περίπλοκων σχέσεων στο μοντέλο μας. Σημείωση: Το σύνολο δεδομένων μας αποτελείται από εικόνες 32Χ32. αυτές είναι σχετικά μικρές εικόνες. Ως εκ τούτου, η χρήση πιο σύνθετων μοντέλων στην αρχή σίγουρα θα ταιριάζει περισσότερο με το μοντέλο, επομένως τείνουμε να αυξάνουμε την πολυπλοκότητα του μοντέλου μας αργά.
# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
'optim': keras.optimizers.Adam(learning_rate=0.001),
'patience': 5,
'epochs': 50,
'batch_size': 32,
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0.001, # minimium amount of change to count as an improvement
patience=train_hyperparameters_config['patience'],
restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)
learning_curves(ht)
print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)
Από τα παραπάνω γραφήματα μπορούμε ξεκάθαρα να πούμε ότι το μοντέλο είναι υπερβολικά προσαρμοσμένο, επομένως θα χρησιμοποιήσουμε μια άλλη μέθοδο που ονομάζεται Drop out normalization και Batch normalization.
Βήμα 10: Χρήση επιπέδων εγκατάλειψης και επιπέδων κανονικοποίησης παρτίδων
model = models.Sequential()
model.add(layers.Conv2D(128, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(256, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.3))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.3))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
'optim': keras.optimizers.Adam(learning_rate=0.001),
'patience': 5,
'epochs': 50,
'batch_size': 32,
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0.001, # minimium amount of change to count as an improvement
patience=train_hyperparameters_config['patience'],
restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)
learning_curves(ht)
print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)
Από τα γραφήματα εκμάθησης μπορούμε να δούμε ότι το μοντέλο ταιριάζει υπερβολικά ακόμη και με επίπεδα ομαδοποίησης και εγκατάλειψης. Ως εκ τούτου, αντί να αυξηθεί η πολυπλοκότητα αλλά να αυξηθεί ο αριθμός των φίλτρων. Θα προσθέταμε περισσότερα επίπεδα συνέλιξης για να εξαγάγουμε περισσότερες δυνατότητες.
Βήμα 11: Αύξηση των επιπέδων συνέλιξης
Μειώστε την εκπαιδεύσιμη παράμετρο αλλά αυξήστε τα επίπεδα συνέλιξης για να εξαγάγετε περισσότερες δυνατότητες.
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
'optim': keras.optimizers.Adam(learning_rate=0.001),
'patience': 5,
'epochs': 50,
'batch_size': 32,
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0.001, # minimium amount of change to count as an improvement
patience=train_hyperparameters_config['patience'],
restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)
learning_curves(ht)
print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)
Από την παραπάνω καμπύλη εξόδου και μάθησης μπορούμε να συμπεράνουμε ότι το μοντέλο έχει αποδώσει πολύ καλά και έχει αποφύγει την υπερβολική προσαρμογή. Η ακρίβεια εκπαίδευσης και η ακρίβεια επικύρωσης είναι πολύ κοντά. Σε αυτό το σενάριο δεν θα χρειαστούμε περισσότερες μεθόδους για να μειώσουμε την υπερπροσαρμογή. Ωστόσο, θα διερευνήσουμε την τακτοποίηση L1/L2.
Βήμα 12: Χρήση της τακτοποίησης L1/L2
from tensorflow.keras import regularizers
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', kernel_regularizer=regularizers.l1(0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', kernel_regularizer=regularizers.l2(0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu', kernel_regularizer=regularizers.l1_l2(0.0005, 0.0005)))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
'optim': keras.optimizers.Adam(learning_rate=0.001),
'patience': 7,
'epochs': 70,
'batch_size': 32,
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0.001, # minimium amount of change to count as an improvement
patience=train_hyperparameters_config['patience'],
restore_best_weights=True)
ht=model_train(model, x_train, y_train, x_test, y_test, train_hyperparameters_config)
learning_curves(ht)
print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)
Τώρα μπορούμε να δούμε ότι η τακτοποίηση L1/L2, ακόμη και μετά τη χρήση χαμηλής βαθμολογίας ποινής 0.0001, έκανε το μοντέλο μας να υποφέρει κατά 4%. Ως εκ τούτου, συνιστάται να χρησιμοποιείτε προσεκτικά όλες τις μεθόδους μαζί. Καθώς η κανονικοποίηση παρτίδας και η τακτοποίηση επηρεάζουν το μοντέλο με παρόμοιο τρόπο, δεν θα χρειαζόμασταν τακτοποίηση L1/L2.
Βήμα 13: Αύξηση δεδομένων
Θα χρησιμοποιήσουμε το ImageDataGenerator από το tensorflow keras.
# creates a data generator object that transforms images
datagen = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
# pick an image to transform
test_img = x_train[20]
img = image.img_to_array(test_img) # convert image to numpy arry
img = img.reshape((1,) + img.shape) # reshape image
i = 0
for batch in datagen.flow(img, save_prefix='test', save_format='jpeg'): # this loops runs forever until we break, saving images to current directory with specified prefix
plt.figure(i)
plot = plt.imshow(image.img_to_array(batch[0]))
i += 1
if i > 4: # show 4 images
break
plt.show()
Αυτές είναι τέσσερις επαυξημένες εικόνες και μία πρωτότυπη εικόνα.
# Create an instance of the ImageDataGenerator
datagen = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest'
)
# Create an iterator for the data generator
data_generator = datagen.flow(x_train, y_train, batch_size=32)
# Create empty lists to store the augmented images and labels
augmented_images = []
augmented_labels = []
# Loop over the data generator and append the augmented data to the lists
num_batches = len(x_train) // 32
progress_bar = tqdm(total=num_batches, desc="Augmenting data", unit="batch")
for i in range(num_batches):
batch_images, batch_labels = next(data_generator)
augmented_images.append(batch_images)
augmented_labels.append(batch_labels)
progress_bar.update(1)
progress_bar.close()
# Convert the lists to NumPy arrays
augmented_images = np.concatenate(augmented_images, axis=0)
augmented_labels = np.concatenate(augmented_labels, axis=0)
# Combine the original and augmented data
x_train_augmented = np.concatenate((x_train, augmented_images), axis=0)
y_train_augmented = np.concatenate((y_train, augmented_labels), axis=0)
Χρησιμοποιήσαμε τη βιβλιοθήκη tqdm για να γνωρίζουμε την πρόοδο της επαύξησής μας.
x_train_augmented.shape, y_train_augmented.shape
Αυτό είναι το σύνολο δεδομένων μας μετά την αύξηση. Τώρα ας χρησιμοποιήσουμε αυτό το σύνολο δεδομένων και ας εκπαιδεύσουμε το μοντέλο μας.
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.2))
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.3))
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPool2D((2, 2)))
model.add(layers.Dropout(0.4))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
# Here we have used more epochs than needed since we use patience parameter which we stop the model from overfitting
train_hyperparameters_config = {
'optim': keras.optimizers.Adam(learning_rate=0.001),
'patience': 10,
'epochs': 70,
'batch_size': 32,
}
print('Setting the callback and early stopping configurations...')
callback = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0.001, # minimium amount of change to count as an improvement
patience=train_hyperparameters_config['patience'],
restore_best_weights=True)
ht=model_train(model, x_train_augmented, y_train_augmented, x_test, y_test, train_hyperparameters_config)
learning_curves(ht)
print('Testing ..................')
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss : ', test_loss, 'test_accuracy : ', test_acc)
Μπορούμε να δούμε ότι το μοντέλο είναι πιο γενικευμένο και μια μείωση της απώλειας. Έχουμε επίσης καλύτερη ακρίβεια επικύρωσης. Ως εκ τούτου, η αύξηση δεδομένων έχει αυξήσει την ακρίβεια του μοντέλου μας.
Συμπέρασμα
Η υπερπροσαρμογή είναι ένα κοινό ζήτημα στη βαθιά μάθηση, ειδικά με πολύπλοκες αρχιτεκτονικές νευρωνικών δικτύων όπως τα ConvNets. Οι επαγγελματίες μπορούν να αποτρέψουν την υπερβολική προσαρμογή στα ConvNets κατανοώντας τις βασικές αιτίες και αναγνωρίζοντας τα σενάρια όπου συμβαίνει. Τεχνικές όπως η πρόωρη διακοπή, η εγκατάλειψη, η ομαλοποίηση παρτίδας, η τακτοποίηση και η αύξηση δεδομένων μπορούν να βοηθήσουν στον μετριασμό αυτού του ζητήματος. Η εφαρμογή αυτών των τεχνικών στο σύνολο δεδομένων CIFAR-10 έδειξε σημαντικές βελτιώσεις στη γενίκευση και την απόδοση του μοντέλου. Η γνώση αυτών των τεχνικών και η κατανόηση των αρχών τους μπορεί να οδηγήσει σε ισχυρά και αξιόπιστα μοντέλα νευρωνικών δικτύων.
Συχνές Ερωτήσεις
Α. Η υπερπροσαρμογή συμβαίνει όταν ένα μοντέλο μαθαίνει πολύ καλά τα δεδομένα εκπαίδευσης, συμπεριλαμβανομένου του θορύβου και των άσχετων μοτίβων του, με αποτέλεσμα κακή απόδοση σε νέα, αόρατα δεδομένα. Είναι ένα πρόβλημα επειδή τα υπερπροσαρμοσμένα μοντέλα αποτυγχάνουν να γενικεύσουν αποτελεσματικά, περιορίζοντας την πρακτική τους χρησιμότητα.
Α. Μπορείτε να εντοπίσετε την υπερπροσαρμογή στα ConvNets ερμηνεύοντας τις καμπύλες εκμάθησης, οι οποίες σχεδιάζουν τις μετρήσεις εκπαίδευσης και επικύρωσης (π.χ. απώλεια, ακρίβεια) σε εποχές. Εάν οι μετρήσεις επικύρωσης σταματήσουν να βελτιώνονται ή αρχίσουν να υποβαθμίζονται ενώ οι μετρήσεις εκπαίδευσης συνεχίζουν να βελτιώνονται, αυτό είναι σημάδι υπερβολικής προσαρμογής.
A. Η πρόωρη διακοπή είναι μια τεχνική που παρακολουθεί την απόδοση του μοντέλου σε ένα σετ επικύρωσης κατά τη διάρκεια της εκπαίδευσης και σταματά τη διαδικασία εκπαίδευσης όταν η απόδοση στο σετ επικύρωσης αρχίζει να υποβαθμίζεται, υποδεικνύοντας την υπερβολική προσαρμογή. Βοηθά στην αποφυγή υπερβολικής προσαρμογής του μοντέλου σταματώντας την εκπαίδευση την κατάλληλη στιγμή.
Α. Η επαύξηση δεδομένων είναι η διαδικασία δημιουργίας νέων, συνθετικών δεδομένων εκπαίδευσης με την εφαρμογή μετασχηματισμών (π.χ. αναστροφή, περιστροφή, κλιμάκωση) στα υπάρχοντα δεδομένα. Βοηθά το μοντέλο να γενικευτεί καλύτερα εκθέτοντάς το σε πιο διαφορετικά παραδείγματα, μειώνοντας τον κίνδυνο υπερπροσαρμογής στα ConvNets στα περιορισμένα δεδομένα εκπαίδευσης.
- SEO Powered Content & PR Distribution. Ενισχύστε σήμερα.
- PlatoData.Network Vertical Generative Ai. Ενδυναμώστε τον εαυτό σας. Πρόσβαση εδώ.
- PlatoAiStream. Web3 Intelligence. Ενισχύθηκε η γνώση. Πρόσβαση εδώ.
- PlatoESG. Ανθρακας, Cleantech, Ενέργεια, Περιβάλλον, Ηλιακός, Διαχείριση των αποβλήτων. Πρόσβαση εδώ.
- PlatoHealth. Ευφυΐα βιοτεχνολογίας και κλινικών δοκιμών. Πρόσβαση εδώ.
- πηγή: https://www.analyticsvidhya.com/blog/2024/04/understanding-overfitting-in-convnets/
