Αυτόματος κωδικοποιητής στο TensorFlow με Παράδειγμα

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

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

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

Πώς λειτουργεί ο αυτόματος κωδικοποιητής TensorFlow;

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

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

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

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

Παράδειγμα στοιβαγμένου αυτόματου κωδικοποιητή

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

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

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

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

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

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

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

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

Πρέπει να κατεβάσετε τις εικόνες από το Σελίδα συνόλου δεδομένων CIFAR-10 και αποσυμπιέστε το αρχείο. Ο φάκελος cifar-10-batches-py περιέχει πέντε δέσμες δεδομένων με 10000 εικόνες η καθεμία σε τυχαία σειρά.

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

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

Σημείωση έκδοσης: Ο κώδικας σε αυτό το σεμινάριο στοχεύει στο TensorFlow 1.x. Στο TensorFlow 2, η ενότητα tf.contrib δεν υπάρχει πλέον και τα placeholders, οι συνεδρίες και ο αρχικοποιήσιμος επαναλήπτης βρίσκονται κάτω από το tf.compat.v1. Η κλήση της tf.compat.v1.disable_v2_behavior() μετά την εισαγωγή είναι ο γρηγορότερος τρόπος για να εκτελέσετε τις καταχωρίσεις αμετάβλητες.

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

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

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

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with 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. Τα pixel 32*32 είναι πλέον πεπλατυσμένα σε 1024.

# Load the data into memory
data, labels = [], []
## Loop over the b
for 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) Κατασκευάστε το σύνολο δεδομένων εκπαίδευσης

Για να κάνετε την εκπαίδευση πιο γρήγορη και ευκολότερη, θα εκπαιδεύσετε ένα μοντέλο μόνο στις εικόνες των αλόγων. Τα άλογα φέρουν την ετικέτα 7 στα δεδομένα της ετικέτας. Όπως αναφέρεται στην τεκμηρίωση του συνόλου δεδομένων 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) Κατασκευάστε ένα οπτικοποιητή εικόνας

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

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

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def 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")

Η κλήση επιστρέφει την παρακάτω μικρογραφία σε κλίμακα του γκρι και επιβεβαιώνει ότι η αναδιαμόρφωση από τιμές 1024 σε εικόνα 32×32 είναι σωστή.

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

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

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

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

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

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

Σημειώστε ότι το x είναι ένα σύμβολο κράτησης θέσης σε σχήμα [Καμία, n_είσοδοι]. Η πρώτη διάσταση ορίζεται σε Καμία επειδή ο αριθμός των εικόνων που τροφοδοτούνται στο δίκτυο είναι ίσος με το μέγεθος της παρτίδας, το οποίο αποφασίζεται μόνο κατά τον χρόνο εκτέλεσης. Για λεπτομέρειες, ανατρέξτε στο σεμινάριο στο γραμμική παλινδρόμηση με TensorFlow.

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

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

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

Ορίζετε το μέγεθος παρτίδας σε 1 επειδή θέλετε να τροφοδοτήσετε το σύνολο δεδομένων μόνο με μία εικόνα. Μπορείτε να δείτε τη διάσταση των δεδομένων με την εντολή print(sess.run(features).shape). Ισούται με (1, 1024). Το 1 σημαίνει ότι τροφοδοτείται μία μόνο εικόνα με 1024 τιμές κάθε φορά. Εάν το μέγεθος παρτίδας οριστεί σε δύο, τότε δύο εικόνες θα περάσουν από τη διοχέτευση. Μην αλλάξετε το μέγεθος παρτίδας, διαφορετικά θα εμφανιστεί σφάλμα, επειδή μόνο μία εικόνα κάθε φορά μπορεί να μεταφερθεί στη συνάρτηση plot_image().

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.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)

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

Φτιάξτε το δίκτυο

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

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

Το μπλοκ κωδικοποιητή θα έχει ένα άνω κρυφό επίπεδο με 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

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

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

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Σημείωση έκδοσης: Το tf.contrib αφαιρέθηκε στο TensorFlow 2. Οι άμεσες αντικαταστάσεις είναι tf.keras.initializers.GlorotUniform() για το xavier_initializer() και tf.keras.regularizers.l2() για το l2_regularizer().

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

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

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

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

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

## Make the mat mul
hidden_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) Ορίστε τη βελτιστοποίηση

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

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

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

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

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

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

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

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

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

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

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

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.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 shown
            print("\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.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

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

Τώρα που έχετε εκπαιδεύσει το μοντέλο σας, ήρθε η ώρα να το αξιολογήσετε. Πρέπει να εισαγάγετε το σύνολο δοκιμών από το αρχείο /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 = unpickle(r”E:\cifar-10-batches-py\test_batch”)

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

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

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

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

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

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

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

1. Αλλάξτε το σχήμα της εικόνας στη σωστή διάσταση, π.χ. 1, 1024
2. Τροφοδοτήστε το μοντέλο με την αόρατη εικόνα, κωδικοποιήστε/αποκωδικοποιήστε την εικόνα
3. Εκτυπώστε την πραγματική και ανακατασκευασμένη εικόνα

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_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 image
    with 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 image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = 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.ckpt
Model restored.
(1, 1024)

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

Συχνές Ερωτήσεις