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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Βήμα 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. Τα 32*32 pixel έχουν πλέον ισοπεδωθεί στο 2014.

# 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) Κατασκευάστε το σύνολο δεδομένων εκπαίδευσης

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

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 ορίσματα:

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

Δημιουργήστε το Δίκτυο — Δημιουργία δικτύου για Autoencoder

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

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

Καθορίστε τις παραμέτρους
Καθορίστε τα επίπεδα
Ορίστε την αρχιτεκτονική
Ορίστε τη βελτιστοποίηση
Εκτελέστε το μοντέλο
Αξιολογήστε το μοντέλο

Στην προηγούμενη ενότητα, μάθατε πώς να δημιουργείτε μια διοχέτευση για την τροφοδοσία του μοντέλου, επομένως δεν χρειάζεται να δημιουργήσετε ξανά το σύνολο δεδομένων. Θα κατασκευάσετε έναν αυτόματο κωδικοποιητή με τέσσερα επίπεδα. Χρησιμοποιείτε την προετοιμασία 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)

Βήμα 2) Καθορίστε τα επίπεδα

Όλες οι παράμετροι των πυκνών στρωμάτων έχουν οριστεί. μπορείτε να συσκευάσετε τα πάντα στη μεταβλητή dense_layer χρησιμοποιώντας το αντικείμενο partal. 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 optimizer για να υπολογίσετε τις διαβαθμίσεις. Η αντικειμενική λειτουργία είναι η ελαχιστοποίηση της απώλειας.

## Optimize
loss = 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 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")

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

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

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

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

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

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)

Περίληψη

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

Μερική: για να δημιουργήσετε τα πυκνά στρώματα με την τυπική ρύθμιση:

  	tf.layers.dense,                         
  	activation=tf.nn.elu,                         
  	kernel_initializer=xav_init,                         
  	kernel_regularizer=l2_regularizer

πυκνό_στρώμα(): για να γίνει ο πολλαπλασιασμός του πίνακα

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

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

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