Klasyfikacja obrazów TensorFlow: wszystko, co musisz wiedzieć o klasyfikatorach budynków

Image Klasyfikacja to zadanie, które nawet dziecko może wykonać w kilka sekund, ale dla maszyny było to trudne zadanie aż do ostatnich postępów w i Głęboka nauka . Samojezdne samochody mogą wykrywać obiekty i podejmować wymagane działania w czasie rzeczywistym, a większość z nich jest możliwa dzięki temu Klasyfikacja obrazu. W tym artykule poprowadzę Cię przez następujące tematy:

• Co to jest TensorFlow?
• Co to jest klasyfikacja obrazów?
• Klasyfikacja obrazów TensorFlow: Moda MNIST
• CIFAR 10: CNN

Co to jest TensorFlow?

TensorFlow to platforma Google Open Source Machine Learning Framework do programowania przepływu danych w wielu różnych zadaniach. Węzły na wykresie reprezentują operacje matematyczne, podczas gdy krawędzie wykresu reprezentują wielowymiarowe tablice danych przesyłane między nimi.

Tensory to po prostu tablice wielowymiarowe, rozszerzenie tabel dwuwymiarowych na dane o wyższym wymiarze. Istnieje wiele funkcji Tensorflow, które sprawiają, że jest on odpowiedni do uczenia głębokiego, a jego podstawowa biblioteka open source pomaga w opracowywaniu i trenowaniu modeli ML.

Co to jest klasyfikacja obrazów?

Celem klasyfikacji obrazu jest podzielenie wszystkich pikseli obrazu cyfrowego na jeden z kilku pokrycie terenu zajęcia lub motywy . Te skategoryzowane dane mogą być następnie wykorzystane do tworzenia mapy tematyczne pokrycia terenu obecnego na obrazie.

Teraz, w zależności od interakcji między analitykiem a komputerem podczas klasyfikacji, istnieją dwa rodzaje klasyfikacji:

• Nadzorowane i
• Bez nadzoru

Nie traćmy więc czasu, przejdźmy do klasyfikacji obrazów TensorFlow. Mam 2 przykłady: łatwe i trudne. Przejdźmy do łatwego.

Klasyfikacja obrazów TensorFlow: Moda MNIST

Zestaw danych Fashion MNIST

Tutaj użyjemy Fashion MNIST Dataset, który zawiera 70 000 obrazów w skali szarości w 10 kategoriach. Będziemy używać 60000 do szkolenia, a pozostałe 10000 do celów testowych. Dostęp do Fashion MNIST można uzyskać bezpośrednio z TensorFlow, wystarczy zaimportować i załadować dane.

• Najpierw zaimportujmy biblioteki

from __future__ import bezwzględny import, dzielenie, drukowanie_funkcja # TensorFlow i tf.keras importują tensorflow jako tf z tensorflow import keras # Biblioteki pomocnicze import numpy as np import matplotlib.pyplot as plt

• Załadujmy dane

fashion_mnist = keras.datasets.fashion_mnist (obrazy_pociągu, etykiety_ pociągu), (obrazy_testowe, etykiety_testowe) =mod_mnist.load_data ()

• Następnie zamierzamy zmapować obrazy na klasy

class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Bot boot']

• Badanie danych

obrazy_pociągu.kształt 
# Każda etykieta ma wartość od 0 do 9

etykiety_pociągów 
obrazy_testowe.kształt 

• Nadszedł czas na wstępne przetworzenie danych.

plt.postać() plt.imshow(obrazy_pociągu[0]) plt.pasek kolorów() plt.krata(Fałszywy) plt.pokazać() 
#Jeśli przyjrzysz się pierwszemu obrazowi w zestawie uczącym, zobaczysz, że wartości pikseli mieszczą się w zakresie od 0 do 255. 

• Musimy przeskalować obrazy od 0 do 1, aby wprowadzić je do sieci neuronowej

obrazy_pociągu = obrazy_pociągu / 255,0 obrazy_testowe = obrazy_testowe / 255,0

• Pokażmy kilka obrazów.

plt.postać(rozmiar figi=(10,10)) dla ja w zasięg(25): plt.wątek poboczny(5,5,ja+jeden) plt.xticks([]) plt.yticks([]) plt.krata(Fałszywy) plt.imshow(obrazy_pociągu[ja], cmap=plt.cm.dwójkowy) plt.xlabel(nazwy_klas[etykiety_pociągów[ja]]) plt.pokazać()

• Skonfiguruj warstwy

Model = ciężko.Sekwencyjny([ ciężko.warstwy.Spłaszczyć(input_shape=(28, 28)), ciężko.warstwy.Gęsty(128, aktywacja=tf.nr.relu), ciężko.warstwy.Gęsty(10, aktywacja=tf.nr.softmax) ])

• Skompiluj model

Model.skompilować(optymalizator=„adam”, utrata=„sparse_categorical_crossentropy”, metryka=['precyzja'])

• Trening modelowy

Model.dopasowanie(obrazy_pociągu, etykiety_pociągów, epoki=10)

• Ocena dokładności

test_loss, test_acc = Model.oceniać(obrazy_testowe, etykiety_testowe) wydrukować(„Dokładność testu”:, test_acc)

• Prognozowanie

prognozy = Model.przepowiadać, wywróżyć(obrazy_testowe)

prognozy[0]

Przewidywanie to tablica 10 liczb. Opisują one „pewność” modelu, że obraz odpowiada każdemu z 10 różnych elementów garderoby. Możemy zobaczyć, która etykieta ma najwyższą wartość zaufania.

np.argmax(prognozy[0])#Model jest najbardziej przekonany, że to botki za kostkę. Zobaczmy, czy to prawda

Wyjście: 9

etykiety_testowe[0]

Wyjście: 9

• Czas przyjrzeć się pełnemu zestawowi 10 kanałów

pok plot_image(ja, Predictions_array, true_label, img): Predictions_array, true_label, img = Predictions_array[ja], true_label[ja], img[ja] plt.krata(Fałszywy) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.dwójkowy) predicted_label = np.argmax(Predictions_array) Jeśli predicted_label == true_label: kolor = 'Zielony' jeszcze: kolor = 'netto' plt.xlabel('{} {: 2.0f}% ({}) '.format(nazwy_klas[predicted_label], 100*np.max(Predictions_array), nazwy_klas[true_label]), kolor=kolor) pok plot_value_array(ja, Predictions_array, true_label): Predictions_array, true_label = Predictions_array[ja], true_label[ja] plt.krata(Fałszywy) plt.xticks([]) plt.yticks([]) thisplot = plt.bar(zasięg(10), Predictions_array, kolor=„# 777777”) plt.ylim([0, jeden]) predicted_label = np.argmax(Predictions_array) thisplot[predicted_label].set_color('netto') thisplot[true_label].set_color('Zielony')

• Spójrzmy najpierw na zerowy i dziesiąty obraz

ja = 0 plt.postać(rozmiar figi=(6,3)) plt.wątek poboczny(jeden,2,jeden) plot_image(ja, prognozy, etykiety_testowe, obrazy_testowe) plt.wątek poboczny(jeden,2,2) plot_value_array(ja, prognozy, etykiety_testowe) plt.pokazać()

ja = 10 plt.postać(rozmiar figi=(6,3)) plt.wątek poboczny(jeden,2,jeden) plot_image(ja, prognozy, etykiety_testowe, obrazy_testowe) plt.wątek poboczny(jeden,2,2) plot_value_array(ja, prognozy, etykiety_testowe) plt.pokazać()

• Teraz nakreślmy kilka obrazów i ich przewidywań. Prawidłowe są zielone, a nieprawidłowe czerwone.

num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.postać(rozmiar figi=(2*2*num_cols, 2*num_rows)) dla ja w zasięg(num_images): plt.wątek poboczny(num_rows, 2*num_cols, 2*ja+jeden) plot_image(ja, prognozy, etykiety_testowe, obrazy_testowe) plt.wątek poboczny(num_rows, 2*num_cols, 2*ja+2) plot_value_array(ja, prognozy, etykiety_testowe) plt.pokazać()

• Na koniec użyjemy wytrenowanego modelu, aby przewidzieć pojedynczy obraz.

# Pobierz obraz z testowego zestawu danych img = obrazy_testowe[0] wydrukować(img.kształt)

# Dodaj obraz do partii, w której jest jedynym członkiem. img = (np.expand_dims(img,0)) wydrukować(img.kształt)

Predictions_single = Model.przepowiadać, wywróżyć(img) wydrukować(Predictions_single)

plot_value_array(0, Predictions_single, etykiety_testowe) plt.xticks(zasięg(10), nazwy_klas, obrót=Cztery pięć) plt.pokazać()

• Jak widać prognozę dotyczącą naszego jedynego obrazu w partii.

prediction_result = np.argmax(Predictions_single[0])

Wyjście: 9

CIFAR-10: CNN

Zbiór danych CIFAR-10 obejmuje samoloty, psy, koty i inne obiekty. Przetworzysz wstępnie obrazy, a następnie wytrenujesz konwolucyjną sieć neuronową na wszystkich próbkach. Obrazy muszą zostać znormalizowane, a etykiety muszą być zakodowane na gorąco. Ten przykład użycia z pewnością rozwiąże Twoje wątpliwości dotyczące klasyfikacji obrazów TensorFlow.

• Pobieranie danych

od urllib.request import urlretrieve od os.path import isfile, jest sadzą od tqdm import tqdm import plik tar cifar10_dataset_folder_path = „cifar-10-partie-py” klasa PobierzProgress(tqdm): last_block = 0 pok hak(samego siebie, numer_bloku=jeden, rozmiar bloku=jeden, całkowity rozmiar=Żaden): samego siebie.całkowity = całkowity rozmiar samego siebie.aktualizacja((numer_bloku - samego siebie.last_block) * rozmiar bloku) samego siebie.last_block = numer_bloku '' ' sprawdź, czy plik danych (zip) jest już pobrany jeśli nie, pobierz go z „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz” i zapisz jako cifar-10-python.tar.gz '' ' Jeśli nie isfile(„cifar-10-python.tar.gz”): z PobierzProgress(jednostka='B', unit_scale=Prawdziwe, miniterów=jeden, desc=„Zestaw danych CIFAR-10”) tak jak pbar: urlretrieve( „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz”, „cifar-10-python.tar.gz”, pbar.hak) Jeśli nie jest sadzą(cifar10_dataset_folder_path): z plik tar.otwarty(„cifar-10-python.tar.gz”) tak jak smoła: smoła.Wypakuj wszystko() smoła.blisko()

• Importowanie niezbędnych bibliotek

import marynata import tępy tak jak np import matplotlib.pyplot tak jak plt

• Zrozumienie danych

Oryginalna partia danych to tensor 10000 × 3072 wyrażony w tablicy numpy, gdzie 10000 to liczba przykładowych danych. Obraz jest kolorowy i ma rozmiar 32 × 32. Podawanie można przeprowadzić w formacie (szerokość x wysokość x numer_channel) lub (num_channel x szerokość x wysokość). Zdefiniujmy etykiety.

pok load_label_names(): powrót ['samolot', 'samochód', 'ptak', 'kot', 'jeleń', 'pies', 'żaba', 'koń', 'statek', 'samochód ciężarowy']

• Przekształcanie danych

Będziemy przekształcać dane w dwóch etapach

Najpierw podziel wektor wierszowy (3072) na 3 części. Każdy kawałek odpowiada każdemu kanałowi. Daje to (3 x 1024) wymiar tensora. Następnie podziel wynikowy tensor z poprzedniego kroku przez 32. 32 oznacza tutaj szerokość obrazu. Powoduje to (3x32x32).

Po drugie, musimy przetransponować dane z (num_channel, width, height) do (width, height, num_channel). W tym celu użyjemy funkcji transpozycji.

pok load_cfar10_batch(cifar10_dataset_folder_path, batch_id): z otwarty(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), tryb=„rb”) tak jak plik: # zwróć uwagę, że typ kodowania to „latin1” partia = marynata.Załaduj(plik, kodowanie=„latin1”) funkcje = partia['dane'].przefasonować((len(partia['dane']), 3, 32, 32)).transponować(0, 2, 3, jeden) etykiety = partia[„etykiety”] powrót funkcje, etykieta

• Eksploracja danych

pok display_stats(cifar10_dataset_folder_path, batch_id, sample_id): funkcje, etykiety = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) Jeśli nie (0 <= sample_id < len(funkcje)): wydrukować('{}próbki w partii{}.{}jest poza zasięgiem ”..format(len(funkcje), batch_id, sample_id)) powrót Żaden wydrukować(' Statystyki partii nr{}: '.format(batch_id)) wydrukować(„Liczba próbek:{} '.format(len(funkcje))) label_names = load_label_names() label_counts = dykt(zamek błyskawiczny(*np.wyjątkowy(etykiety, return_counts=Prawdziwe))) dla klucz, wartość w label_counts.przedmiotów(): wydrukować(„Liczba etykiet: [{}] ({}):{}'.format(klucz, label_names[klucz].górny(), wartość)) sample_image = funkcje[sample_id] sample_label = etykiety[sample_id] wydrukować(' Przykład obrazu{}: '.format(sample_id)) wydrukować(Obraz - wartość minimalna:{}Maksymalna wartość:{}'.format(sample_image.min(), sample_image.max())) wydrukować(Obraz - kształt:{}'.format(sample_image.kształt)) wydrukować(„Etykieta - identyfikator etykiety:{}Nazwa:{}'.format(sample_label, label_names[sample_label])) plt.imshow(sample_image)

%matplotlib inline %config InlineBackend.figure_format = 'Siatkówka oka' import tępy tak jak np # Przeglądaj zbiór danych batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Implementowanie funkcji przetwarzania wstępnego

Zamierzamy znormalizować dane poprzez normalizację Min-Max. To po prostu sprawia, że ​​wszystkie wartości x mieszczą się w zakresie od 0 do 1.
y = (x-min) / (max-min)

pok normalizować(x): '' ' argument - x: dane wejściowe obrazu w tablicy numpy [32, 32, 3] powrót - znormalizowany x '' ' min_val = np.min(x) max_val = np.max(x) x = (x-min_val) / (max_val-min_val) powrót x

• Kodowanie na gorąco

pok one_hot_encode(x): '' ' argument - x: lista etykiet powrót - jedna matryca kodowania na gorąco (liczba etykiet, liczba klas) '' ' zakodowane = np.zera((len(x), 10)) dla idx, godz w wyliczać(x): zakodowane[idx] [godz] = jeden powrót zakodowane

• Przetwórz wstępnie i zapisz dane

pok _preprocess_and_save(normalizować, one_hot_encode, funkcje, etykiety, Nazwa pliku): funkcje = normalizować(funkcje) etykiety = one_hot_encode(etykiety) marynata.wysypisko((funkcje, etykiety), otwarty(Nazwa pliku, „wb”)) pok preprocess_and_save_data(cifar10_dataset_folder_path, normalizować, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] dla batch_i w zasięg(jeden, n_batches + jeden): funkcje, etykiety = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # znajdź indeks jako punkt jako dane walidacyjne w całym zbiorze danych partii (10%) index_of_validation = int(len(funkcje) * 0,1) # przetworzyć wstępnie 90% całego zbioru danych partii # - znormalizuj funkcje # - one_hot_encode the lables # - zapisz w nowym pliku o nazwie „preprocess_batch_” + numer_partii # - każdy plik dla każdej partii _preprocess_and_save(normalizować, one_hot_encode, funkcje[:-index_of_validation], etykiety[:-index_of_validation], „preprocess_batch_” + p(batch_i) + „.p”) # w przeciwieństwie do zbioru danych szkoleniowych, zbiór danych walidacyjnych zostanie dodany do wszystkich zestawów danych wsadowych # - weź 10% całego zbioru danych z partii # - dodaj je do listy # - valid_features # - valid_labels valid_features.poszerzać(funkcje[-index_of_validation:]) valid_labels.poszerzać(etykiety[-index_of_validation:]) # przetworzyć wstępnie wszystkie skumulowane zestawy danych walidacyjnych _preprocess_and_save(normalizować, one_hot_encode, np.szyk(valid_features), np.szyk(valid_labels), „preprocess_validation.p”) # załaduj testowy zestaw danych z otwarty(cifar10_dataset_folder_path + „/ test_batch”, tryb=„rb”) tak jak plik: partia = marynata.Załaduj(plik, kodowanie=„latin1”) # wstępnie przetwarza dane testowe test_features = partia['dane'].przefasonować((len(partia['dane']), 3, 32, 32)).transponować(0, 2, 3, jeden) etykiety_testowe = partia[„etykiety”] # Przetwórz wstępnie i zapisz wszystkie dane testowe _preprocess_and_save(normalizować, one_hot_encode, np.szyk(test_features), np.szyk(etykiety_testowe), „preprocess_training.p”)

preprocess_and_save_data(cifar10_dataset_folder_path, normalizować, one_hot_encode)

• Punkt kontrolny

import marynata valid_features, valid_labels = marynata.Załaduj(otwarty(„preprocess_validation.p”, tryb=„rb”))

• Budowanie sieci

Cały model składa się w sumie z 14 warstw.

import tensorflow tak jak tf pok conv_net(x, keep_prob): conv1_filter = tf.Zmienna(tf.truncated_normal(kształt=[3, 3, 3, 64], oznaczać=0, stddev=0,08)) conv2_filter = tf.Zmienna(tf.truncated_normal(kształt=[3, 3, 64, 128], oznaczać=0, stddev=0,08)) conv3_filter = tf.Zmienna(tf.truncated_normal(kształt=[5, 5, 128, 256], oznaczać=0, stddev=0,08)) conv4_filter = tf.Zmienna(tf.truncated_normal(kształt=[5, 5, 256, 512], oznaczać=0, stddev=0,08)) # 1, 2 konw1 = tf.nr.conv2d(x, conv1_filter, kroki=[jeden,jeden,jeden,jeden], wyściółka='PODOBNIE') konw1 = tf.nr.relu(konw1) conv1_pool = tf.nr.max_pool(konw1, ksize=[jeden,2,2,jeden], kroki=[jeden,2,2,jeden], wyściółka='PODOBNIE') conv1_bn = tf.warstwy.normalizacja_seryjna(conv1_pool) # 3. 4 konw2 = tf.nr.conv2d(conv1_bn, conv2_filter, kroki=[jeden,jeden,jeden,jeden], wyściółka='PODOBNIE') konw2 = tf.nr.relu(konw2) conv2_pool = tf.nr.max_pool(konw2, ksize=[jeden,2,2,jeden], kroki=[jeden,2,2,jeden], wyściółka='PODOBNIE') conv2_bn = tf.warstwy.normalizacja_seryjna(conv2_pool) # 5, 6 konw3 = tf.nr.conv2d(conv2_bn, conv3_filter, kroki=[jeden,jeden,jeden,jeden], wyściółka='PODOBNIE') konw3 = tf.nr.relu(konw3) conv3_pool = tf.nr.max_pool(konw3, ksize=[jeden,2,2,jeden], kroki=[jeden,2,2,jeden], wyściółka='PODOBNIE') conv3_bn = tf.warstwy.normalizacja_seryjna(conv3_pool) # 7, 8 konw4 = tf.nr.conv2d(conv3_bn, conv4_filter, kroki=[jeden,jeden,jeden,jeden], wyściółka='PODOBNIE') konw4 = tf.nr.relu(konw4) conv4_pool = tf.nr.max_pool(konw4, ksize=[jeden,2,2,jeden], kroki=[jeden,2,2,jeden], wyściółka='PODOBNIE') conv4_bn = tf.warstwy.normalizacja_seryjna(conv4_pool) # 9 mieszkanie = tf.wkład.warstwy.spłaszczyć(conv4_bn) # 10 pełny 1 = tf.wkład.warstwy.w pełni_łączony(wejścia=mieszkanie, num_outputs=128, aktywacja_fn=tf.nr.relu) pełny 1 = tf.nr.spadkowicz(pełny 1, keep_prob) pełny 1 = tf.warstwy.normalizacja_seryjna(pełny 1) # jedenaście full2 = tf.wkład.warstwy.w pełni_łączony(wejścia=pełny 1, num_outputs=256, aktywacja_fn=tf.nr.relu) full2 = tf.nr.spadkowicz(full2, keep_prob) full2 = tf.warstwy.normalizacja_seryjna(full2) # 12 full3 = tf.wkład.warstwy.w pełni_łączony(wejścia=full2, num_outputs=512, aktywacja_fn=tf.nr.relu) full3 = tf.nr.spadkowicz(full3, keep_prob) full3 = tf.warstwy.normalizacja_seryjna(full3) # 13 full4 = tf.wkład.warstwy.w pełni_łączony(wejścia=full3, num_outputs=1024, aktywacja_fn=tf.nr.relu) full4 = tf.nr.spadkowicz(full4, keep_prob) full4 = tf.warstwy.normalizacja_seryjna(full4) # 14 na zewnątrz = tf.wkład.warstwy.w pełni_łączony(wejścia=full3, num_outputs=10, aktywacja_fn=Żaden) powrót na zewnątrz

• Hyperparameters

epoki = 10 batch_size = 128 keep_probability = 0,7 learning_rate = 0,001

logity = conv_net(x, keep_prob) Model = tf.tożsamość(logity, Nazwa=„logity”) # Nazwa loguje Tensor, dzięki czemu można go załadować z dysku po treningu # Strata i optymalizator koszt = tf.redukuj_średnie(tf.nr.softmax_cross_entropy_with_logits(logity=logity, etykiety=Y)) optymalizator = tf.pociąg.AdamOptimizer(learning_rate=learning_rate).zminimalizować(koszt) # Precyzja correct_pred = tf.równy(tf.argmax(logity, jeden), tf.argmax(Y, jeden)) precyzja = tf.redukuj_średnie(tf.odlew(correct_pred, tf.float32), Nazwa='precyzja')

• Trenuj sieć neuronową

# Pojedyncza optymalizacja 
pok train_neural_network(sesja, optymalizator, keep_probability, feature_batch, label_batch): sesja.biegać(optymalizator, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: keep_probability })

#Showing Stats pok print_stats(sesja, feature_batch, label_batch, koszt, precyzja): utrata = sess.biegać(koszt, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: jeden. }) valid_acc = sess.biegać(precyzja, feed_dict={ x: valid_features, Y: valid_labels, keep_prob: jeden. }) wydrukować('Utrata:{:> 10,4f}Dokładność walidacji:{: .6f}'.format(utrata, valid_acc))

• Pełne szkolenie i zapisywanie modelu

pok batch_features_labels(funkcje, etykiety, batch_size): '' ' Podziel elementy i etykiety na partie '' ' dla początek w zasięg(0, len(funkcje), batch_size): koniec = min(początek + batch_size, len(funkcje)) wydajność funkcje[początek:koniec], etykiety[początek:koniec] pok load_preprocess_training_batch(batch_id, batch_size): '' ' Załaduj wstępnie przetworzone dane szkoleniowe i zwróć je w partiach nie większych niż '' ' Nazwa pliku = „preprocess_batch_” + p(batch_id) + „.p” funkcje, etykiety = marynata.Załaduj(otwarty(Nazwa pliku, tryb=„rb”)) # Zwróć dane treningowe partiami o wielkości lub mniejszej powrót batch_features_labels(funkcje, etykiety, batch_size)

#Saving Model and Path 
save_model_path = „./image_classification” wydrukować('Trening...') z tf.Sesja() tak jak sess: # Inicjalizacja zmiennych sess.biegać(tf.global_variables_initializer()) # Cykl treningowy dla epoka w zasięg(epoki): # Zapętlaj wszystkie partie n_batches = 5 dla batch_i w zasięg(jeden, n_batches + jeden): dla batch_features, batch_labels w load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, optymalizator, keep_probability, batch_features, batch_labels) wydrukować('Epoka{:> 2}, Partia CIFAR-10{}: '.format(epoka + jeden, batch_i), koniec='') print_stats(sess, batch_features, batch_labels, koszt, precyzja) # Zapisz model wygaszacz = tf.pociąg.Saver() Zapisz ścieżkę = wygaszacz.zapisać(sess, save_model_path)

Teraz ważna część klasyfikacji obrazów Tensorflow jest zakończona. Czas przetestować model.

• Testowanie modelu

import marynata import tępy tak jak np import matplotlib.pyplot tak jak plt od sklearn.preprocessing import LabelBinarizer pok batch_features_labels(funkcje, etykiety, batch_size): '' ' Podziel elementy i etykiety na partie '' ' dla początek w zasięg(0, len(funkcje), batch_size): koniec = min(początek + batch_size, len(funkcje)) wydajność funkcje[początek:koniec], etykiety[początek:koniec] pok display_image_predictions(funkcje, etykiety, prognozy, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.dopasowanie(zasięg(n_classes)) label_ids = label_binarizer.inverse_transform(np.szyk(etykiety)) Figa, osie = plt.działki(nrows=top_n_predictions, ncols=2, rozmiar figi=(dwadzieścia, 10)) Figa.tight_layout() Figa.suptitle(„Prognozy Softmax”, rozmiar czcionki=dwadzieścia, Y=1.1) n_predictions = 3 margines = 0,05 ind = np.arange(n_predictions) szerokość = (jeden. - 2. * margines) / n_predictions dla image_i, (funkcja, label_id, pred_indicies, pred_values) w wyliczać(zamek błyskawiczny(funkcje, label_ids, prognozy.indeksy, prognozy.wartości)): Jeśli (image_i < top_n_predictions): pred_names = [label_names[pred_i] dla pred_i w pred_indicies] poprawna_nazwa = label_names[label_id] osie[image_i] [0].imshow((funkcja*255).astype(np.int32, Kopiuj=Fałszywy)) osie[image_i] [0].set_title(poprawna_nazwa) osie[image_i] [0].set_axis_off() osie[image_i] [jeden].barh(ind + margines, pred_values[:3], szerokość) osie[image_i] [jeden].set_yticks(ind + margines) osie[image_i] [jeden].set_yticklabels(pred_names[::-jeden]) osie[image_i] [jeden].set_xticks([0, 0.5, 1.0])

%matplotlib inline %config InlineBackend.figure_format = 'Siatkówka oka' import tensorflow tak jak tf import marynata import losowy save_model_path = „./image_classification” batch_size = 64 n_samples = 10 top_n_predictions = 5 pok test_model(): test_features, etykiety_testowe = marynata.Załaduj(otwarty(„preprocess_training.p”, tryb=„rb”)) załadowany_graf = tf.Wykres() z tf.Sesja(wykres=załadowany_graf) tak jak sess: # Załaduj model ładowarka = tf.pociąg.import_meta_graph(save_model_path + „.meta”) ładowarka.przywracać(sess, save_model_path) # Pobierz tensory z załadowanego modelu załadowany_x = załadowany_graf.get_tensor_by_name(„input_x: 0”) załadowany_y = załadowany_graf.get_tensor_by_name(„output_y: 0”) load_keep_prob = załadowany_graf.get_tensor_by_name(„keep_prob: 0”) load_logits = załadowany_graf.get_tensor_by_name(„logity: 0”) załadowany_acc = załadowany_graf.get_tensor_by_name(„dokładność: 0”) # Uzyskaj dokładność w partiach dla ograniczeń pamięci test_batch_acc_total = 0 test_batch_count = 0 dla train_feature_batch, train_label_batch w batch_features_labels(test_features, etykiety_testowe, batch_size): test_batch_acc_total + = sess.biegać( załadowany_acc, feed_dict={załadowany_x: train_feature_batch, załadowany_y: train_label_batch, load_keep_prob: 1.0}) test_batch_count + = jeden wydrukować(Dokładność testowania:{} '.format(test_batch_acc_total/test_batch_count)) # Drukuj losowe próbki random_test_features, random_test_labels = krotka(zamek błyskawiczny(*losowy.próba(lista(zamek błyskawiczny(test_features, etykiety_testowe)), n_samples))) random_test_predictions = sess.biegać( tf.nr.top_k(tf.nr.softmax(load_logits), top_n_predictions), feed_dict={załadowany_x: random_test_features, załadowany_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()

Wynik: Dokładność testowania: 0,5882762738853503

jak korzystać z usługi teraz

Teraz, jeśli trenujesz swoją sieć neuronową dla większej liczby epok lub zmienisz funkcję aktywacji, możesz otrzymać inny wynik, który może mieć lepszą dokładność.

Tak więc kończymy artykuł dotyczący klasyfikacji obrazów TensorFlow. Jestem pewien, że możesz teraz używać tego samego do klasyfikowania dowolnego rodzaju obrazów i nie jesteś początkującym w klasyfikacji obrazów.

Edureka's with Python Certification Training jest prowadzony przez specjalistów z branży zgodnie z wymaganiami i wymaganiami branży. Opanujesz takie pojęcia, jak funkcja SoftMax, sieci neuronowe autoenkodera, ograniczona maszyna Boltzmanna (RBM), Keras i TFLearn. Kurs został specjalnie wyselekcjonowany przez ekspertów branżowych z analizami przypadków w czasie rzeczywistym.