TensorFlow Autoencoder: Σύνολο δεδομένων με Παράδειγμα Deep Learning

Πίνακας περιεχομένων:

Anonim

Τι είναι ο Αυτόματος κωδικοποιητής;

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

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

Σε αυτό το σεμινάριο TensorFlow Autoencoder, θα μάθετε:

  • Τι είναι ο Αυτόματος κωδικοποιητής;
  • Πώς λειτουργεί το Autoencoder;
  • Παράδειγμα Stacked Autoencoder
  • Δημιουργήστε έναν αυτόματο κωδικοποιητή με TensorFlow
  • Προεπεξεργασία εικόνας
  • Ορισμός εκτιμητή συνόλου δεδομένων
  • Δημιουργήστε το δίκτυο

Πώς λειτουργεί το Autoencoder;

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

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

Εργασία του Autoencoder

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

Συγκεκριμένα, φανταστείτε μια εικόνα με μέγεθος 50x50 (δηλαδή, 250 pixel) και ένα νευρικό δίκτυο με ένα μόνο κρυφό στρώμα που αποτελείται από εκατό νευρώνες. Η εκμάθηση γίνεται σε έναν χάρτη χαρακτηριστικών που είναι δύο φορές μικρότερος από την είσοδο. Αυτό σημαίνει ότι το δίκτυο πρέπει να βρει έναν τρόπο για την ανακατασκευή 250 pixel με μόνο ένα φορέα νευρώνων ίσο με 100.

Παράδειγμα Stacked Autoencoder

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

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

Η άλλη χρήσιμη οικογένεια του Autoencoder Deep Learning είναι η αυτόματη κωδικοποίηση παραλλαγής. Αυτός ο τύπος δικτύου μπορεί να δημιουργήσει νέες εικόνες. Φανταστείτε ότι εκπαιδεύετε ένα δίκτυο με την εικόνα ενός άνδρα. ένα τέτοιο δίκτυο μπορεί να παράγει νέα πρόσωπα.

Δημιουργήστε έναν αυτόματο κωδικοποιητή με TensorFlow

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

Θα χρησιμοποιήσετε το σύνολο δεδομένων CIFAR-10 που περιέχει 60000 έγχρωμες εικόνες 32x32. Το σύνολο δεδομένων του Αυτόματου κωδικοποιητή έχει ήδη χωριστεί μεταξύ 50000 εικόνων για εκπαίδευση και 10000 για δοκιμή. Υπάρχουν έως και δέκα τάξεις:

  • Αεροπλάνο
  • Αυτοκίνητο
  • Πουλί
  • Γάτα
  • Ελάφι
  • Σκύλος
  • Βάτραχος
  • Αλογο
  • Πλοίο
  • Φορτηγό

Πρέπει να κατεβάσετε τις εικόνες σε αυτήν τη διεύθυνση URL https://www.cs.toronto.edu/~kriz/cifar.html και να την αποσυμπιέσετε. Ο φάκελος for-10-batches-py περιέχει πέντε παρτίδες δεδομένων με 10000 εικόνες η καθεμία σε τυχαία σειρά.

Πριν δημιουργήσετε και εκπαιδεύσετε το μοντέλο σας, πρέπει να εφαρμόσετε κάποια επεξεργασία δεδομένων. Θα προχωρήσετε ως εξής:

  1. Εισαγάγετε τα δεδομένα
  2. Μετατρέψτε τα δεδομένα σε ασπρόμαυρη μορφή
  3. Προσθέστε όλες τις παρτίδες
  4. Κατασκευάστε το σύνολο δεδομένων εκπαίδευσης
  5. Δημιουργήστε έναν οπτικοποιητή εικόνας

Προεπεξεργασία εικόνας

Βήμα 1) Εισαγάγετε τα δεδομένα.

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

import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='latin1')return dict

Βήμα 2) Μετατρέψτε τα δεδομένα σε ασπρόμαυρη μορφή

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

def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Βήμα 3) Προσθέστε όλες τις παρτίδες

Τώρα που έχουν δημιουργηθεί και οι δύο λειτουργίες και το σύνολο δεδομένων φορτώνεται, μπορείτε να γράψετε έναν βρόχο για να προσθέσετε τα δεδομένα στη μνήμη. Εάν ελέγξετε προσεκτικά, το αρχείο αποσυμπίεσης με τα δεδομένα ονομάζεται data_batch_ με έναν αριθμό από το 1 έως το 5. Μπορείτε να κάνετε βρόχο στα αρχεία και να το προσαρτήσετε στα δεδομένα.

Όταν ολοκληρωθεί αυτό το βήμα, μετατρέπετε τα δεδομένα χρωμάτων σε μορφή γκρι κλίμακας. Όπως μπορείτε να δείτε, το σχήμα των δεδομένων είναι 50000 και 1024. Τα 32 * 32 pixel είναι πλέον ισοπεδωμένα έως το 2014.

# Load the data into memorydata, labels = [], []## Loop over the bfor i in range(1, 6):filename = './cifar-10-batches-py/data_batch_' + str(i)open_data = unpickle(filename)if len(data)> 0:data = np.vstack((data, open_data['data']))labels = np.hstack((labels, open_data['labels']))else:data = open_data['data']labels = open_data['labels']data = grayscale(data)x = np.matrix(data)y = np.array(labels)print(x.shape)(50000, 1024)

Σημείωση: Αλλάξτε το './cifar-10-batches-py/data_batch_' στην πραγματική τοποθεσία του αρχείου σας. Για παράδειγμα, για υπολογιστή Windows, η διαδρομή θα μπορούσε να είναι όνομα αρχείου = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)

Βήμα 4) Κατασκευάστε το σύνολο δεδομένων εκπαίδευσης

Για να κάνετε την προπόνηση πιο γρήγορη και ευκολότερη, θα εκπαιδεύσετε ένα μοντέλο μόνο στις εικόνες αλόγων. Τα άλογα είναι η έβδομη κατηγορία στα δεδομένα της ετικέτας. Όπως αναφέρεται στην τεκμηρίωση του συνόλου δεδομένων CIFAR-10, κάθε τάξη περιέχει 5000 εικόνες. Μπορείτε να εκτυπώσετε το σχήμα των δεδομένων για να επιβεβαιώσετε ότι υπάρχουν 5.000 εικόνες με 1024 στήλες όπως φαίνεται στο παρακάτω παράδειγμα TensorFlow Autoencoder.

horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)

Βήμα 5) Κατασκευάστε έναν οπτικοποιητή εικόνας

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

Ένας εύκολος τρόπος εκτύπωσης εικόνων είναι η χρήση του αντικειμένου που εμφανίζεται από τη βιβλιοθήκη matplotlib. Σημειώστε ότι, πρέπει να μετατρέψετε το σχήμα των δεδομένων από 1024 σε 32 * 32 (δηλαδή μορφή εικόνας).

# To plot pretty figures%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltdef plot_image(image, shape=[32, 32], cmap = "Greys_r"):plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")plt.axis("off")

Η συνάρτηση περιλαμβάνει 3 ορίσματα:

  • Εικόνα: η είσοδος
  • Σχήμα: λίστα, η διάσταση της εικόνας
  • Cmap: επιλέξτε τον χρωματικό χάρτη. Από προεπιλογή, γκρι

Μπορείτε να προσπαθήσετε να σχεδιάσετε την πρώτη εικόνα στο σύνολο δεδομένων. Θα πρέπει να δείτε έναν άνδρα σε ένα άλογο.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

Ορισμός εκτιμητή συνόλου δεδομένων

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

Θα δημιουργήσετε ένα σύνολο δεδομένων με εκτιμητή TensorFlow. Για να ανανεώσετε το μυαλό σας, πρέπει να χρησιμοποιήσετε:

  • από_tensor_slices
  • επαναλαμβάνω
  • σύνολο παραγωγής

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

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

Σημειώστε ότι, το x είναι ένα σύμβολο κράτησης θέσης με το ακόλουθο σχήμα:

  • [Κανένα, n_inputs]: Ορίστε σε Κανένα επειδή ο αριθμός της τροφοδοσίας εικόνας στο δίκτυο είναι ίσος με το μέγεθος της παρτίδας.

για λεπτομέρειες, ανατρέξτε στο σεμινάριο για τη γραμμική παλινδρόμηση.

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

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

Τώρα που ο αγωγός είναι έτοιμος, μπορείτε να ελέγξετε αν η πρώτη εικόνα είναι η ίδια όπως πριν (δηλαδή, ένας άντρας σε ένα άλογο).

Μπορείτε να ορίσετε το μέγεθος της παρτίδας σε 1 επειδή θέλετε να τροφοδοτήσετε το σύνολο δεδομένων με μία εικόνα. Μπορείτε να δείτε τη διάσταση των δεδομένων με εκτύπωση (sess.run (χαρακτηριστικά). Σχήμα). Είναι ίσο με (1, 1024). 1 σημαίνει ότι μόνο μία εικόνα με 1024 τροφοδοτείται η καθεμία. Εάν το μέγεθος της παρτίδας έχει οριστεί σε δύο, τότε δύο εικόνες θα περάσουν από τον αγωγό. (Μην αλλάζετε το μέγεθος της παρτίδας. Διαφορετικά, θα εμφανίσει σφάλμα. Μόνο μία εικόνα τη φορά μπορεί να μεταβεί στη συνάρτηση plot_image ().

## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print(sess.run(features).shape)plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")(1, 1024)

Δημιουργήστε το δίκτυο

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

Το δίκτυό σας θα έχει ένα επίπεδο εισόδου με 1024 σημεία, δηλαδή, 32x32, το σχήμα της εικόνας.

Το μπλοκ κωδικοποιητή θα έχει ένα άνω κρυφό στρώμα με 300 νευρώνες, ένα κεντρικό στρώμα με 150 νευρώνες. Το μπλοκ αποκωδικοποιητή είναι συμμετρικό στον κωδικοποιητή. Μπορείτε να οπτικοποιήσετε το δίκτυο στην παρακάτω εικόνα. Λάβετε υπόψη ότι μπορείτε να αλλάξετε τις τιμές των κρυφών και κεντρικών επιπέδων.

Δημιουργία δικτύου για τον Αυτόματο κωδικοποιητή

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

Θα κατασκευάσετε το μοντέλο ακολουθώντας αυτά τα βήματα:

  1. Ορίστε τις παραμέτρους
  2. Ορίστε τα επίπεδα
  3. Ορίστε την αρχιτεκτονική
  4. Ορίστε τη βελτιστοποίηση
  5. Εκτελέστε το μοντέλο
  6. Αξιολογήστε το μοντέλο

Στην προηγούμενη ενότητα, μάθατε πώς να δημιουργείτε έναν αγωγό για να τροφοδοτείτε το μοντέλο, οπότε δεν χρειάζεται να δημιουργήσετε ξανά το σύνολο δεδομένων. Θα δημιουργήσετε έναν αυτόματο κωδικοποιητή με τέσσερα επίπεδα. Χρησιμοποιείτε την αρχικοποίηση Xavier. Αυτή είναι μια τεχνική για τον καθορισμό των αρχικών βαρών ίσων με τη διακύμανση τόσο της εισόδου όσο και της εξόδου. Τέλος, χρησιμοποιείτε τη λειτουργία ενεργοποίησης elu. Ρυθμίζετε τη λειτουργία απώλειας με τον τακτοποιητή L2.

Βήμα 1) Ορίστε τις παραμέτρους

Το πρώτο βήμα συνεπάγεται τον καθορισμό του αριθμού των νευρώνων σε κάθε στρώμα, του ρυθμού εκμάθησης και του υπερπαραμέτρου του κανονικοποιητή.

Πριν από αυτό, εισαγάγετε τη συνάρτηση μερικώς. Είναι μια καλύτερη μέθοδος για τον καθορισμό των παραμέτρων των πυκνών στρωμάτων. Ο παρακάτω κώδικας καθορίζει τις τιμές της αρχιτεκτονικής αυτόματου κωδικοποιητή. Όπως αναφέρθηκε προηγουμένως, ο αυτόματος κωδικοποιητής έχει δύο στρώματα, με 300 νευρώνες στα πρώτα στρώματα και 150 στα δεύτερα στρώματα. Οι τιμές τους αποθηκεύονται σε n_hidden_1 και n_hidden_2.

Πρέπει να καθορίσετε το ποσοστό εκμάθησης και το υπερπαραμέτρο L2. Οι τιμές αποθηκεύονται σε learning_rate και l2_reg

from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001

Η τεχνική αρχικοποίησης Xavier καλείται με το αντικείμενο xavier_initializer από τον συντελεστή εκτιμητή. Στον ίδιο εκτιμητή, μπορείτε να προσθέσετε τον κανονικοποιητή με το l2_regularizer

## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Βήμα 2) Ορίστε τα επίπεδα

Έχουν ρυθμιστεί όλες οι παράμετροι των πυκνών στρωμάτων. μπορείτε να συσκευάσετε τα πάντα στη μεταβλητή dense_layer χρησιμοποιώντας το αντικείμενο μερικό. dense_layer που χρησιμοποιεί την ενεργοποίηση ELU, αρχικοποίηση Xavier και κανονικοποίηση L2.

## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)

Βήμα 3) Ορίστε την αρχιτεκτονική

Αν κοιτάξετε την εικόνα της αρχιτεκτονικής, σημειώστε ότι το δίκτυο στοιβάζει τρία επίπεδα με ένα επίπεδο εξόδου. Στον παρακάτω κώδικα, συνδέετε τα κατάλληλα επίπεδα. Για παράδειγμα, το πρώτο στρώμα υπολογίζει το προϊόν κουκκίδων μεταξύ των χαρακτηριστικών του πίνακα εισόδου και των πινάκων που περιέχουν τα 300 βάρη. Αφού υπολογιστεί το προϊόν κουκκίδων, η έξοδος πηγαίνει στη λειτουργία ενεργοποίησης Elu. Η έξοδος γίνεται η είσοδος του επόμενου επιπέδου, γι 'αυτό το χρησιμοποιείτε για τον υπολογισμό του κρυμμένου_2 και ούτω καθεξής. Ο πολλαπλασιασμός των πινάκων είναι ο ίδιος για κάθε επίπεδο επειδή χρησιμοποιείτε την ίδια λειτουργία ενεργοποίησης. Σημειώστε ότι το τελευταίο επίπεδο, εξέρχεται, δεν εφαρμόζει συνάρτηση ενεργοποίησης. Είναι λογικό γιατί αυτή είναι η ανακατασκευασμένη είσοδος

## Make the mat mulhidden_1 = dense_layer(features, n_hidden_1)hidden_2 = dense_layer(hidden_1, n_hidden_2)hidden_3 = dense_layer(hidden_2, n_hidden_3)outputs = dense_layer(hidden_3, n_outputs, activation=None)

Βήμα 4) Ορίστε τη βελτιστοποίηση

Το τελευταίο βήμα είναι η κατασκευή του βελτιστοποιητή. Χρησιμοποιείτε το Σφάλμα Mean Square ως συνάρτηση απώλειας. Εάν θυμάστε το σεμινάριο για τη γραμμική παλινδρόμηση, γνωρίζετε ότι το MSE υπολογίζεται με τη διαφορά μεταξύ της προβλεπόμενης εξόδου και της πραγματικής ετικέτας. Εδώ, η ετικέτα είναι το χαρακτηριστικό επειδή το μοντέλο προσπαθεί να ανακατασκευάσει την είσοδο. Επομένως, θέλετε το μέσο όρο του αθροίσματος της διαφοράς του τετραγώνου μεταξύ της προβλεπόμενης εξόδου και της εισόδου. Με το TensorFlow, μπορείτε να κωδικοποιήσετε τη λειτουργία απώλειας ως εξής:

loss = tf.reduce_mean(tf.square(outputs - features))

Στη συνέχεια, πρέπει να βελτιστοποιήσετε τη λειτουργία απώλειας. Χρησιμοποιείτε το πρόγραμμα βελτιστοποίησης Adam για να υπολογίσετε τις διαβαθμίσεις. Η αντικειμενική λειτουργία είναι να ελαχιστοποιηθεί η απώλεια.

## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Μια ακόμη ρύθμιση πριν από την εκπαίδευση του μοντέλου. Θέλετε να χρησιμοποιήσετε ένα μέγεθος παρτίδας 150, δηλαδή, τροφοδοτήστε τον αγωγό με 150 εικόνες κάθε επανάληψη. Πρέπει να υπολογίσετε τον αριθμό των επαναλήψεων με μη αυτόματο τρόπο. Αυτό είναι ασήμαντο να κάνετε:

Εάν θέλετε να περνάτε 150 εικόνες κάθε φορά και γνωρίζετε ότι υπάρχουν 5000 εικόνες στο σύνολο δεδομένων, ο αριθμός των επαναλήψεων είναι ίσος με. Στο python μπορείτε να εκτελέσετε τους ακόλουθους κωδικούς και να βεβαιωθείτε ότι η έξοδος είναι 33:

BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33

Βήμα 5) Εκτελέστε το μοντέλο

Τελευταίο αλλά όχι λιγότερο σημαντικό, εκπαιδεύστε το μοντέλο. Εκπαιδεύετε το μοντέλο με 100 εποχές. Δηλαδή, το μοντέλο θα δει 100 φορές τις εικόνες σε βελτιστοποιημένα βάρη.

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

Ενδιαφέρεστε να εκτυπώσετε την απώλεια μετά από δέκα εποχές για να δείτε αν το μοντέλο μαθαίνει κάτι (δηλαδή, η απώλεια μειώνεται). Η εκπαίδευση διαρκεί 2 έως 5 λεπτά, ανάλογα με το υλικό του μηχανήματός σας.

## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print('Training… ')print(sess.run(features).shape)for epoch in range(n_epochs):for iteration in range(n_batches):sess.run(train)if epoch % 10 == 0:loss_train = loss.eval() # not shownprint("\r{}".format(epoch), "Train MSE:", loss_train)#saver.save(sess, "./my_model_all_layers.ckpt")save_path = saver.save(sess, "./model.ckpt")print("Model saved in path: %s" % save_path)Training… (150, 1024)0 Train MSE: 2934.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt

Βήμα 6) Αξιολογήστε το μοντέλο

Τώρα που έχετε εκπαιδεύσει το μοντέλο σας, είναι καιρός να το αξιολογήσετε. Πρέπει να εισαγάγετε το sert δοκιμής από το αρχείο / cifar-10-batches-py /.

test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])

ΣΗΜΕΙΩΣΗ: Για έναν υπολογιστή Windows, ο κωδικός γίνεται test_data = unickle (r "E: \ cifar-10-batches-py \ test_batch")

Μπορείτε να δοκιμάσετε να εκτυπώσετε τις εικόνες 13, που είναι άλογο

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

Για να αξιολογήσετε το μοντέλο, θα χρησιμοποιήσετε την τιμή pixel αυτής της εικόνας και θα δείτε αν ο κωδικοποιητής μπορεί να ανακατασκευάσει την ίδια εικόνα μετά τη συρρίκνωση των 1024 pixel. Σημειώστε ότι, ορίζετε μια συνάρτηση για την αξιολόγηση του μοντέλου σε διαφορετικές εικόνες. Το μοντέλο πρέπει να λειτουργεί καλύτερα μόνο σε άλογα.

Η συνάρτηση περιλαμβάνει δύο ορίσματα:

  • df: Εισαγωγή των δεδομένων δοκιμής
  • image_number: υποδείξτε ποια εικόνα θα εισαχθεί

Η συνάρτηση χωρίζεται σε τρία μέρη:

  1. Αναμορφώστε την εικόνα στη σωστή διάσταση, δηλαδή 1, 1024
  2. Τροφοδοτήστε το μοντέλο με την αόρατη εικόνα, κωδικοποιήστε / αποκωδικοποιήστε την εικόνα
  3. Εκτυπώστε την πραγματική και ανακατασκευασμένη εικόνα
def reconstruct_image(df, image_number = 1):## Part 1: Reshape the image to the correct dimension i.e 1, 1024x_test = df[image_number]x_test_1 = x_test.reshape((1, 32*32))## Part 2: Feed the model with the unseen image, encode/decode the imagewith tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(iter.initializer, feed_dict={x: x_test_1,batch_size: 1})## Part 3: Print the real and reconstructed image# Restore variables from disk.saver.restore(sess, "./model.ckpt")print("Model restored.")# Reconstruct imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = fig.add_subplot(122)plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")plt.tight_layout()fig = plt.gcf()

Τώρα που έχει καθοριστεί η λειτουργία αξιολόγησης, μπορείτε να ρίξετε μια ματιά στον αριθμό δεκατριών που ανακατασκευάστηκε

reconstruct_image(df =test_x, image_number = 13) 
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)

Περίληψη

Ο πρωταρχικός σκοπός ενός αυτόματου κωδικοποιητή είναι να συμπιέσει τα δεδομένα εισόδου και στη συνέχεια να το αποσυμπιέσει σε μια έξοδο που μοιάζει πολύ με τα αρχικά δεδομένα.

Η αρχιτεκτονική ενός αυτόματου κωδικοποιητή συμμετρική με ένα περιστρεφόμενο στρώμα που ονομάζεται κεντρικό στρώμα

Μπορείτε να δημιουργήσετε τον αυτόματο κωδικοποιητή χρησιμοποιώντας:

  • Μερικό: για να δημιουργήσετε τα πυκνά στρώματα με την τυπική ρύθμιση:
  • tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
  • dense_layer (): για τον πολλαπλασιασμό της μήτρας

μπορείτε να ορίσετε τη λειτουργία απώλειας και τη βελτιστοποίηση με:

loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Τελευταία εκτέλεση μιας συνεδρίας για την εκπαίδευση του μοντέλου.