Bildklassifizierung eine Aufgabe, die selbst ein Baby in Sekunden erledigen kann, aber für eine Maschine war es bis zu den jüngsten Fortschritten in eine schwierige Aufgabe und Tiefes Lernen . Selbstfahrende Autos können Objekte erkennen und in Echtzeit die erforderlichen Maßnahmen ergreifen. Das meiste davon ist aufgrund von möglich Bildklassifizierung. In diesem Artikel werde ich Sie durch die folgenden Themen führen:
- Was ist TensorFlow?
- Was ist Bildklassifizierung?
- TensorFlow Bildklassifizierung: Mode MNIST
- CIFAR 10: CNN
Was ist TensorFlow?
TensorFlow ist das Open Source Machine Learning Framework von Google für die Datenflussprogrammierung für eine Reihe von Aufgaben. Knoten im Diagramm stellen mathematische Operationen dar, während die Diagrammkanten die zwischen ihnen kommunizierten mehrdimensionalen Datenfelder darstellen.
Tensoren sind nur mehrdimensionale Arrays, eine Erweiterung von zweidimensionalen Tabellen auf Daten mit einer höheren Dimension. Tensorflow verfügt über viele Funktionen, die es für Deep Learning geeignet machen. Die Open Source-Kernbibliothek hilft Ihnen bei der Entwicklung und Schulung von ML-Modellen.
Was ist Bildklassifizierung?
Die Absicht der Bildklassifizierung besteht darin, alle Pixel in einem digitalen Bild in eines von mehreren zu kategorisieren Landbedeckung Klassen oder Themen . Diese kategorisierten Daten können dann zur Erzeugung verwendet werden thematische Karten der Landbedeckung in einem Bild vorhanden.
Abhängig von der Interaktion zwischen dem Analysten und dem Computer während der Klassifizierung gibt es zwei Arten der Klassifizierung:
- Betreut &
- Unbeaufsichtigt
Lassen Sie uns also ohne Zeitverlust in die TensorFlow-Bildklassifizierung springen. Ich habe 2 Beispiele: einfach und schwierig. Fahren wir mit dem einfachen fort.
TensorFlow Bildklassifizierung: Mode MNIST
Mode MNIST Datensatz
Hier verwenden wir den Fashion MNIST-Datensatz, der 70.000 Graustufenbilder in 10 Kategorien enthält. Wir werden 60000 für Schulungen und den Rest 10000 für Testzwecke verwenden. Sie können direkt von TensorFlow aus auf den Fashion MNIST zugreifen. Importieren und laden Sie einfach die Daten.
- Importieren wir zuerst die Bibliotheken
aus __future__ import absolute_import, Division, print_function # TensorFlow und tf.keras importieren Tensorflow als tf aus Tensorflow importieren Keras # Hilfsbibliotheken importieren numpy als np importieren matplotlib.pyplot als plt
- Laden wir die Daten
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- Als nächstes werden wir die Bilder in Klassen abbilden
class_names = ['T-Shirt / Top', 'Hose', 'Pullover', 'Kleid', 'Mantel', 'Sandale', 'Hemd', 'Sneaker', 'Tasche', 'Stiefelette']
- Erkundung der Daten
train_images.gestalten
#Jedes Etikett liegt zwischen 0 und 9
train_labels
test_images.gestalten
- Jetzt ist es Zeit, die Daten vorzuverarbeiten.
plt.Zahl() plt.imshow(train_images[0]) plt.Farbbalken() plt.Gitter(Falsch) plt.Show()
#Wenn Sie das erste Bild im Trainingssatz untersuchen, werden Sie feststellen, dass die Pixelwerte im Bereich von 0 bis 255 liegen.
- Wir müssen die Bilder von 0-1 skalieren, um sie in das neuronale Netzwerk einzuspeisen
train_images = train_images /. 255.0 test_images = test_images /. 255.0
- Lassen Sie uns einige Bilder anzeigen.
plt.Zahl(figsize=(10,10)) zum ich im Angebot(25): plt.Nebenhandlung(5,5,ich+ein) plt.xticks([]) plt.yticks([]) plt.Gitter(Falsch) plt.imshow(train_images[ich], cmap=plt.cm.binär) plt.xlabel(Klassennamen[train_labels[ich]]) plt.Show()
- Richten Sie die Ebenen ein
Modell- = schwer.Sequentiell([ schwer.Schichten.Ebnen(input_shape=(28, 28)), schwer.Schichten.Dicht(128, Aktivierung=tf.nr.relu), schwer.Schichten.Dicht(10, Aktivierung=tf.nr.Softmax) ])
- Kompilieren Sie das Modell
Modell-.kompilieren(Optimierer='Adam', Verlust='sparse_categorical_crossentropy', Metriken=['Richtigkeit'])
- Modelltraining
Modell-.passen(train_images, train_labels, Epochen=10)
- Bewertung der Genauigkeit
test_loss, test_acc = Modell-.bewerten(test_images, test_labels) drucken('Testgenauigkeit:', test_acc)
- Vorhersagen treffen
Vorhersagen = Modell-.vorhersagen(test_images)
Vorhersagen[0]]
Eine Vorhersage ist ein Array von 10 Zahlen. Diese beschreiben das „Vertrauen“ des Modells, dass das Bild jedem der 10 verschiedenen Kleidungsstücke entspricht. Wir können sehen, welches Etikett den höchsten Vertrauenswert hat.
z.B..Argmax(Vorhersagen[0])#Model ist sehr zuversichtlich, dass es sich um einen Stiefel handelt. Mal sehen, ob es richtig istAusgabe: 9
test_labels[0]]
Ausgabe: 9
- Jetzt ist es Zeit, sich den gesamten Satz von 10 Kanälen anzusehen
def plot_image(ich, Vorhersagen_array, true_label, img): Vorhersagen_array, true_label, img = Vorhersagen_array[ich], true_label[ich], img[ich]] plt.Gitter(Falsch) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binär) Predicted_Label = z.B..Argmax(Vorhersagen_array) wenn Predicted_Label == true_label:: Farbe = 'Grün' sonst:: Farbe = 'Netz' plt.xlabel('{} {: 2.0f}% ({}) '.Format(Klassennamen[Predicted_Label], 100* *z.B..max(Vorhersagen_array), Klassennamen[true_label]), Farbe=Farbe) def plot_value_array(ich, Vorhersagen_array, true_label): Vorhersagen_array, true_label = Vorhersagen_array[ich], true_label[ich]] plt.Gitter(Falsch) plt.xticks([]) plt.yticks([]) diese Handlung = plt.Bar(Angebot(10), Vorhersagen_array, Farbe='# 777777') plt.ylim([0, ein]) Predicted_Label = z.B..Argmax(Vorhersagen_array) diese Handlung[Predicted_Label]].set_color('Netz') diese Handlung[true_label]].set_color('Grün')
- Schauen wir uns zuerst das 0. und 10. Bild an
ich = 0 plt.Zahl(figsize=(6,3)) plt.Nebenhandlung(ein,2,ein) plot_image(ich, Vorhersagen, test_labels, test_images) plt.Nebenhandlung(ein,2,2) plot_value_array(ich, Vorhersagen, test_labels) plt.Show()
ich = 10 plt.Zahl(figsize=(6,3)) plt.Nebenhandlung(ein,2,ein) plot_image(ich, Vorhersagen, test_labels, test_images) plt.Nebenhandlung(ein,2,2) plot_value_array(ich, Vorhersagen, test_labels) plt.Show()
- Zeichnen wir nun mehrere Bilder und ihre Vorhersagen. Die richtigen sind grün, während die falschen rot sind.
num_rows = 5 num_cols = 3 num_images = num_rows* *num_cols plt.Zahl(figsize=(2* *2* *num_cols, 2* *num_rows)) zum ich im Angebot(num_images): plt.Nebenhandlung(num_rows, 2* *num_cols, 2* *ich+ein) plot_image(ich, Vorhersagen, test_labels, test_images) plt.Nebenhandlung(num_rows, 2* *num_cols, 2* *ich+2) plot_value_array(ich, Vorhersagen, test_labels) plt.Show()
- Schließlich werden wir das trainierte Modell verwenden, um eine Vorhersage über ein einzelnes Bild zu treffen.
# Nehmen Sie ein Bild aus dem Testdatensatz img = test_images[0]] drucken(img.gestalten)
# Fügen Sie das Bild einem Stapel hinzu, in dem es das einzige Mitglied ist. img = (z.B..expand_dims(img,0)) drucken(img.gestalten)
Vorhersagen_Einzel = Modell-.vorhersagen(img) drucken(Vorhersagen_Einzel)plot_value_array(0, Vorhersagen_Einzel, test_labels) plt.xticks(Angebot(10), Klassennamen, Drehung=Vier fünf) plt.Show()
Vorhersageergebnis = z.B..Argmax(Vorhersagen_Einzel[0])
Ausgabe: 9
CIFAR-10: CNN
Der CIFAR-10-Datensatz besteht aus Flugzeugen, Hunden, Katzen und anderen Objekten. Sie werden die Bilder vorverarbeiten und dann ein Faltungs-Neuronales Netzwerk für alle Samples trainieren. Die Bilder müssen normalisiert und die Beschriftungen müssen One-Hot-codiert sein. Dieser Anwendungsfall wird sicherlich Ihre Zweifel an der TensorFlow-Bildklassifizierung zerstreuen.
- Herunterladen der Daten
von urllib.request importieren urlretrieve von os.path importieren isfile, ist Ruß von tqdm importieren tqdm importieren tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' Klasse DownloadProgress(tqdm): last_block = 0 def Haken(selbst, block_num=ein, Block Größe=ein, Gesamtgröße=Keiner): selbst.gesamt = Gesamtgröße selbst.aktualisieren((block_num - - selbst.last_block) * * Block Größe) selbst.last_block = block_num '' ' Überprüfen Sie, ob die Datendatei (zip) bereits heruntergeladen wurde Wenn nicht, laden Sie es von 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' herunter und speichern Sie es als cifar-10-python.tar.gz '' ' wenn nicht isfile('cifar-10-python.tar.gz'): mit DownloadProgress(Einheit='B', unit_scale=Wahr, Miniter=ein, absteigend='CIFAR-10-Datensatz') wie pbar:: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.Haken) wenn nicht ist Ruß(cifar10_dataset_folder_path): mit tarfile.öffnen('cifar-10-python.tar.gz') wie Teer:: Teer.alles extrahieren() Teer.schließen()
- Notwendige Bibliotheken importieren
importieren Essiggurke importieren numpy wie z.B. importieren matplotlib.pyplot wie plt
- Daten verstehen
Der ursprüngliche Datenstapel ist ein Tensor von 10000 × 3072, ausgedrückt in einem numpy-Array, wobei 10000 die Anzahl der Probendaten ist. Das Bild ist farbig und 32 × 32 groß. Der Vorschub kann entweder in einem Format von (Breite x Höhe x Anzahl_Kanal) oder (Anzahl_Kanal x Breite x Höhe) erfolgen. Definieren wir die Beschriftungen.
def load_label_names(): Rückkehr ['Flugzeug', 'Automobil', 'Vogel', 'Katze', 'Hirsch', 'Hund', 'Frosch', 'Pferd', 'Schiff', 'LKW']]
- Daten umformen
Wir werden die Daten in zwei Schritten umformen
Teilen Sie zunächst den Zeilenvektor (3072) in 3 Teile. Jedes Stück entspricht jedem Kanal. Dies führt zu einer (3 × 1024) Abmessung eines Tensors. Teilen Sie dann den resultierenden Tensor aus dem vorherigen Schritt durch 32. 32 bedeutet hier die Breite eines Bildes. Dies ergibt (3x32x32).
Zweitens müssen wir die Daten von (num_channel, width, height) nach (width, height, num_channel) transponieren. Dafür werden wir die Transponierungsfunktion verwenden.
def load_cfar10_batch(cifar10_dataset_folder_path, Batch-ID): mit öffnen(cifar10_dataset_folder_path + '/ data_batch_' + p(Batch-ID), Modus='rb') wie Datei:: # Beachten Sie, dass der Codierungstyp 'latin1' ist. Stapel = Essiggurke.Belastung(Datei, Codierung='latin1') Eigenschaften = Stapel['Daten']].umformen((len(Stapel['Daten']), 3, 32, 32)).transponieren(0, 2, 3, ein) Etiketten = Stapel['Etiketten']] Rückkehr Eigenschaften, Etikette
- Erkunden der Daten
def display_stats(cifar10_dataset_folder_path, Batch-ID, sample_id): Eigenschaften, Etiketten = load_cfar10_batch(cifar10_dataset_folder_path, Batch-ID) wenn nicht (0 <= sample_id < len(Eigenschaften)): drucken('{}Proben im Batch{}.{}ist außerhalb der Reichweite. '.Format(len(Eigenschaften), Batch-ID, sample_id)) Rückkehr Keiner drucken(' Statistik der Charge #{}: '.Format(Batch-ID)) drucken(Anzahl der Proben:{} '.Format(len(Eigenschaften))) label_names = load_label_names() label_counts = diktieren(Postleitzahl(* *z.B..einzigartig(Etiketten, return_counts=Wahr))) zum Schlüssel, Wert im label_counts.Artikel(): drucken('Label Counts von [{}] ({}):{}'.Format(Schlüssel, label_names[Schlüssel]].Oberer, höher(), Wert)) sample_image = Eigenschaften[sample_id]] sample_label = Etiketten[sample_id]] drucken(' Beispiel eines Bildes{}: '.Format(sample_id)) drucken('Bild - Mindestwert:{}Maximaler Wert:{}'.Format(sample_image.Mindest(), sample_image.max())) drucken('Bild - Form:{}'.Format(sample_image.gestalten)) drucken('Label - Label ID:{}Name:{}'.Format(sample_label, label_names[sample_label])) plt.imshow(sample_image)
%.matplotlib im Einklang %.config InlineBackend.figur_format = 'Retina' importieren numpy wie z.B. # Durchsuchen Sie den Datensatz Batch-ID = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, Batch-ID, sample_id)
- Vorverarbeitungsfunktionen implementieren
Wir werden die Daten über die Min-Max-Normalisierung normalisieren. Dadurch liegen alle x-Werte einfach zwischen 0 und 1.
y = (x-min) / (max-min)
def normalisieren(x): '' ' Streit - x: Eingabe von Bilddaten in Numpy-Array [32, 32, 3] Rückkehr - normalisiert x '' ' min_val = z.B..Mindest(x) max_val = z.B..max(x) x = (x- -min_val) /. (max_val- -min_val) Rückkehr x
- One-Hot-Encode
def one_hot_encode(x): '' ' Streit - x: eine Liste von Etiketten Rückkehr - eine Hot-Codierungsmatrix (Anzahl der Labels, Anzahl der Klassen) '' ' codiert = z.B..Nullen((len(x), 10)) zum idx, Std im aufzählen(x): codiert[idx] [Std]] = ein Rückkehr codiert
- Daten vorverarbeiten und speichern
def Vorverarbeitung und Speichern(normalisieren, one_hot_encode, Eigenschaften, Etiketten, Dateinamen): Eigenschaften = normalisieren(Eigenschaften) Etiketten = one_hot_encode(Etiketten) Essiggurke.Dump((Eigenschaften, Etiketten), öffnen(Dateinamen, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalisieren, one_hot_encode): n_Batches = 5 valid_features = [] valid_labels = [] zum batch_i im Angebot(ein, n_Batches + ein): Eigenschaften, Etiketten = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # finde, dass der Index der Punkt als Validierungsdaten im gesamten Datensatz der Charge ist (10%) Index_der_Validierung = int(len(Eigenschaften) * * 0,1) # 90% des gesamten Datensatzes des Stapels vorverarbeiten # - normalisiere die Funktionen # - one_hot_encode die Etiketten # - Speichern Sie in einer neuen Datei mit dem Namen 'preprocess_batch_' + batch_number # - jede Datei für jeden Stapel Vorverarbeitung und Speichern(normalisieren, one_hot_encode, Eigenschaften[:- -Index_der_Validierung], Etiketten[:- -Index_der_Validierung], 'preprocess_batch_' + p(batch_i) + '.p') # Im Gegensatz zum Trainingsdatensatz wird der Validierungsdatensatz über alle Batch-Datensätze hinzugefügt # - Nehmen Sie 10% des Whold-Datensatzes der Charge # - füge sie einer Liste von hinzu # - valid_features # - valid_labels valid_features.erweitern(Eigenschaften[- -Index_der_Validierung:]) valid_labels.erweitern(Etiketten[- -Index_der_Validierung:]) # Verarbeiten Sie den gesamten gestapelten Validierungsdatensatz vor Vorverarbeitung und Speichern(normalisieren, one_hot_encode, z.B..Array(valid_features), z.B..Array(valid_labels), 'preprocess_validation.p') # Laden Sie den Testdatensatz mit öffnen(cifar10_dataset_folder_path + '/ test_batch', Modus='rb') wie Datei:: Stapel = Essiggurke.Belastung(Datei, Codierung='latin1') # Verarbeiten Sie die Testdaten vor test_features = Stapel['Daten']].umformen((len(Stapel['Daten']), 3, 32, 32)).transponieren(0, 2, 3, ein) test_labels = Stapel['Etiketten']] # Alle Testdaten vorverarbeiten und speichern Vorverarbeitung und Speichern(normalisieren, one_hot_encode, z.B..Array(test_features), z.B..Array(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normalisieren, one_hot_encode)
- Kontrollpunkt
importieren Essiggurke valid_features, valid_labels = Essiggurke.Belastung(öffnen('preprocess_validation.p', Modus='rb'))
- Aufbau des Netzwerks
Das gesamte Modell besteht aus insgesamt 14 Schichten.
Was ist Mehrfachvererbung in Java
importieren Tensorflow wie tf def conv_net(x, keep_prob): conv1_filter = tf.Variable(tf.abgeschnitten_normal(gestalten=[3, 3, 3, 64], bedeuten=0, stddev=0,08)) conv2_filter = tf.Variable(tf.abgeschnitten_normal(gestalten=[3, 3, 64, 128], bedeuten=0, stddev=0,08)) conv3_filter = tf.Variable(tf.abgeschnitten_normal(gestalten=[5, 5, 128, 256], bedeuten=0, stddev=0,08)) conv4_filter = tf.Variable(tf.abgeschnitten_normal(gestalten=[5, 5, 256, 512], bedeuten=0, stddev=0,08)) # 1, 2 conv1 = tf.nr.conv2d(x, conv1_filter, Schritte=[ein,ein,ein,ein], Polsterung='GLEICH') conv1 = tf.nr.relu(conv1) conv1_pool = tf.nr.max_pool(conv1, ksize=[ein,2,2,ein], Schritte=[ein,2,2,ein], Polsterung='GLEICH') conv1_bn = tf.Schichten.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.nr.conv2d(conv1_bn, conv2_filter, Schritte=[ein,ein,ein,ein], Polsterung='GLEICH') conv2 = tf.nr.relu(conv2) conv2_pool = tf.nr.max_pool(conv2, ksize=[ein,2,2,ein], Schritte=[ein,2,2,ein], Polsterung='GLEICH') conv2_bn = tf.Schichten.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.nr.conv2d(conv2_bn, conv3_filter, Schritte=[ein,ein,ein,ein], Polsterung='GLEICH') conv3 = tf.nr.relu(conv3) conv3_pool = tf.nr.max_pool(conv3, ksize=[ein,2,2,ein], Schritte=[ein,2,2,ein], Polsterung='GLEICH') conv3_bn = tf.Schichten.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.nr.conv2d(conv3_bn, conv4_filter, Schritte=[ein,ein,ein,ein], Polsterung='GLEICH') conv4 = tf.nr.relu(conv4) conv4_pool = tf.nr.max_pool(conv4, ksize=[ein,2,2,ein], Schritte=[ein,2,2,ein], Polsterung='GLEICH') conv4_bn = tf.Schichten.batch_normalization(conv4_pool) # 9 eben = tf.beitragen.Schichten.ebnen(conv4_bn) # 10 full1 = tf.beitragen.Schichten.vollständig verbunden(Eingänge=eben, num_outputs=128, Aktivierung_fn=tf.nr.relu) full1 = tf.nr.ausfallen(full1, keep_prob) full1 = tf.Schichten.batch_normalization(full1) # elf full2 = tf.beitragen.Schichten.vollständig verbunden(Eingänge=full1, num_outputs=256, Aktivierung_fn=tf.nr.relu) full2 = tf.nr.ausfallen(full2, keep_prob) full2 = tf.Schichten.batch_normalization(full2) # 12 full3 = tf.beitragen.Schichten.vollständig verbunden(Eingänge=full2, num_outputs=512, Aktivierung_fn=tf.nr.relu) full3 = tf.nr.ausfallen(full3, keep_prob) full3 = tf.Schichten.batch_normalization(full3) # 13 full4 = tf.beitragen.Schichten.vollständig verbunden(Eingänge=full3, num_outputs=1024, Aktivierung_fn=tf.nr.relu) full4 = tf.nr.ausfallen(full4, keep_prob) full4 = tf.Schichten.batch_normalization(full4) # 14 aus = tf.beitragen.Schichten.vollständig verbunden(Eingänge=full3, num_outputs=10, Aktivierung_fn=Keiner) Rückkehr aus
- Hyperparameter
Epochen = 10 batch_size = 128 keep_probability = 0,7 Lernrate = 0,001
logits = conv_net(x, keep_prob) Modell- = tf.Identität(logits, Name='logits') # Name protokolliert Tensor, damit dieser nach dem Training von der Festplatte geladen werden kann # Verlust und Optimierer Kosten = tf.redu_mean(tf.nr.softmax_cross_entropy_with_logits(logits=logits, Etiketten=Y.)) Optimierer = tf.Zug.AdamOptimizer(Lernrate=Lernrate).minimieren(Kosten) # Richtigkeit korrekt_pred = tf.gleich(tf.Argmax(logits, ein), tf.Argmax(Y., ein)) Richtigkeit = tf.redu_mean(tf.Besetzung(korrekt_pred, tf.float32), Name='Richtigkeit')
- Trainiere das Neuronale Netz
#Einzeloptimierung
def train_neural_network(Session, Optimierer, keep_probability, feature_batch, label_batch): Session.Lauf(Optimierer, feed_dict={ x:: feature_batch, Y.:: label_batch, keep_prob:: keep_probability })
#Showing Stats def print_stats(Session, feature_batch, label_batch, Kosten, Richtigkeit): Verlust = sess.Lauf(Kosten, feed_dict={ x:: feature_batch, Y.:: label_batch, keep_prob:: ein. }) valid_acc = sess.Lauf(Richtigkeit, feed_dict={ x:: valid_features, Y.:: valid_labels, keep_prob:: ein. }) drucken('Verlust:{:> 10.4f}Validierungsgenauigkeit:{: .6f}'.Format(Verlust, valid_acc))
- Vollständiges Training und Speichern des Modells
def batch_features_labels(Eigenschaften, Etiketten, batch_size): '' ' Teilen Sie Features und Beschriftungen in Stapel auf '' ' zum Start im Angebot(0, len(Eigenschaften), batch_size): Ende = Mindest(Start + batch_size, len(Eigenschaften)) Ausbeute Eigenschaften[Start::Ende], Etiketten[Start::Ende]] def load_preprocess_training_batch(Batch-ID, batch_size): '' ' Laden Sie die vorverarbeiteten Trainingsdaten und geben Sie sie in Chargen von oder weniger zurück '' ' Dateinamen = 'preprocess_batch_' + p(Batch-ID) + '.p' Eigenschaften, Etiketten = Essiggurke.Belastung(öffnen(Dateinamen, Modus='rb')) # Geben Sie die Trainingsdaten in Stapeln mit einer Größe oder weniger zurück Rückkehr batch_features_labels(Eigenschaften, Etiketten, batch_size)
# Modell und Pfad speichern
save_model_path = './image_classification' drucken('Ausbildung...') mit tf.Session() wie sess:: # Initialisieren der Variablen sess.Lauf(tf.global_variables_initializer()) # Trainingszyklus zum Epoche im Angebot(Epochen): # Alle Chargen durchlaufen n_Batches = 5 zum batch_i im Angebot(ein, n_Batches + ein): zum batch_features, batch_labels im load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, Optimierer, keep_probability, batch_features, batch_labels) drucken('Epoche{:> 2}, CIFAR-10-Charge{}: '.Format(Epoche + ein, batch_i), Ende='') print_stats(sess, batch_features, batch_labels, Kosten, Richtigkeit) # Modell speichern Sparer = tf.Zug.Sparer() save_path = Sparer.sparen(sess, save_model_path)
Nun ist der wichtige Teil der Tensorflow-Bildklassifizierung erledigt. Jetzt ist es Zeit, das Modell zu testen.
- Modell testen
importieren Essiggurke importieren numpy wie z.B. importieren matplotlib.pyplot wie plt von sklearn.preprocessing importieren LabelBinarizer def batch_features_labels(Eigenschaften, Etiketten, batch_size): '' ' Teilen Sie Features und Beschriftungen in Stapel auf '' ' zum Start im Angebot(0, len(Eigenschaften), batch_size): Ende = Mindest(Start + batch_size, len(Eigenschaften)) Ausbeute Eigenschaften[Start::Ende], Etiketten[Start::Ende]] def display_image_predictions(Eigenschaften, Etiketten, Vorhersagen, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.passen(Angebot(n_classes)) label_ids = label_binarizer.inverse_transform(z.B..Array(Etiketten)) Feige, Achsen = plt.Nebenhandlungen(nrows=top_n_predictions, ncols=2, figsize=(zwanzig, 10)) Feige.tight_layout() Feige.suptitle('Softmax-Vorhersagen', Schriftgröße=zwanzig, Y.=1.1) n_Vorhersagen = 3 Spanne = 0,05 ind = z.B..arrangieren(n_Vorhersagen) Breite = (ein. - - 2. * * Spanne) /. n_Vorhersagen zum image_i, (Feature, label_id, pred_indicies, pred_values) im aufzählen(Postleitzahl(Eigenschaften, label_ids, Vorhersagen.Indizes, Vorhersagen.Werte)): wenn (image_i < top_n_predictions): pred_names = [label_names[pred_i]] zum pred_i im pred_indicies]] korrekter Name = label_names[label_id]] Achsen[image_i] [0]].imshow((Feature* *255).Astyp(z.B..int32, Kopieren=Falsch)) Achsen[image_i] [0]].set_title(korrekter Name) Achsen[image_i] [0]].set_axis_off() Achsen[image_i] [ein]].barh(ind + Spanne, pred_values[:3], Breite) Achsen[image_i] [ein]].set_yticks(ind + Spanne) Achsen[image_i] [ein]].set_yticklabels(pred_names[::- -ein]) Achsen[image_i] [ein]].set_xticks([0, 0,5, 1.0])
%.matplotlib im Einklang %.config InlineBackend.figur_format = 'Retina' importieren Tensorflow wie tf importieren Essiggurke importieren zufällig save_model_path = './image_classification' batch_size = 64 n_samples = 10 top_n_predictions = 5 def test_model(): test_features, test_labels = Essiggurke.Belastung(öffnen('preprocess_training.p', Modus='rb')) load_graph = tf.Graph() mit tf.Session(Graph=load_graph) wie sess:: # Modell laden Lader = tf.Zug.import_meta_graph(save_model_path + '.Meta') Lader.wiederherstellen(sess, save_model_path) # Holen Sie sich Tensoren vom geladenen Modell geladen_x = load_graph.get_tensor_by_name('input_x: 0') geladen_y = load_graph.get_tensor_by_name('output_y: 0') load_keep_prob = load_graph.get_tensor_by_name('keep_prob: 0') geladene_Logits = load_graph.get_tensor_by_name('logits: 0') geladen_acc = load_graph.get_tensor_by_name('Genauigkeit: 0') # Erhalten Sie Genauigkeit in Stapeln für Speicherbeschränkungen test_batch_acc_total = 0 test_batch_count = 0 zum train_feature_batch, train_label_batch im batch_features_labels(test_features, test_labels, batch_size): test_batch_acc_total + = sess.Lauf( geladen_acc, feed_dict={geladen_x:: train_feature_batch, geladen_y:: train_label_batch, load_keep_prob:: 1.0}) test_batch_count + = ein drucken('Testgenauigkeit:{} '.Format(test_batch_acc_total/.test_batch_count)) # Zufällige Stichproben drucken random_test_features, random_test_labels = Tupel(Postleitzahl(* *zufällig.Stichprobe(Liste(Postleitzahl(test_features, test_labels)), n_samples))) random_test_predictions = sess.Lauf( tf.nr.top_k(tf.nr.Softmax(geladene_Logits), top_n_predictions), feed_dict={geladen_x:: random_test_features, geladen_y:: random_test_labels, load_keep_prob:: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()
Ausgabe: Testgenauigkeit: 0,5882762738853503
Wenn Sie nun Ihr neuronales Netzwerk für weitere Epochen trainieren oder die Aktivierungsfunktion ändern, erhalten Sie möglicherweise ein anderes Ergebnis mit besserer Genauigkeit.
Damit sind wir am Ende dieses Artikels zur TensorFlow-Bildklassifizierung angelangt. Ich bin sicher, dass Sie jetzt dieselbe Art der Klassifizierung von Bildern verwenden können, und Sie sind kein Anfänger in der Bildklassifizierung.
Edurekas mit Python-Zertifizierung Das Training wird von Branchenfachleuten gemäß den Anforderungen und Anforderungen der Branche kuratiert. Sie beherrschen die Konzepte wie SoftMax-Funktion, Autoencoder Neuronale Netze, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Der Kurs wurde speziell von Branchenexperten mit Echtzeit-Fallstudien kuratiert.