Klasyfikacja obrazów CNN w TensorFlow z krokami i przykładami

Co to jest splotowa sieć neuronowa?

Konwolucyjna sieć neuronowa, znany również jako convnets lub CNN, jest dobrze znaną metodą w aplikacjach wizji komputerowej. Jest to klasa głębokich sieci neuronowych, które są używane do analizy obrazów wizualnych. Ten typ architektury jest dominujący w rozpoznawaniu obiektów z obrazu lub wideo. Jest używany w aplikacjach takich jak rozpoznawanie obrazu lub wideo, przetwarzanie języka neuronowego itp.

Archistruktura konwolucyjnej sieci neuronowej

Pomyśl o Facebooku kilka lat temu, gdy po przesłaniu zdjęcia do swojego profilu zostałeś poproszony o ręczne dodanie imienia i nazwiska do twarzy na zdjęciu. Obecnie Facebook używa convnet do automatycznego oznaczania znajomych na zdjęciu.

Sieć neuronowa splotowa do klasyfikacji obrazów nie jest trudna do zrozumienia. Obraz wejściowy jest przetwarzany podczas fazy splotu, a następnie przypisywana jest mu etykieta.

Typową architekturę convnet można podsumować na poniższym rysunku. Najpierw obraz jest przesyłany do sieci; nazywa się to obrazem wejściowym. Następnie obraz wejściowy przechodzi przez nieskończoną liczbę kroków; jest to część splotowa sieci. Na koniec sieć neuronowa może przewidzieć cyfrę na obrazie.

Obraz składa się z tablicy pikseli o wysokości i szerokości. Obraz w skali szarości ma tylko jeden kanał, podczas gdy obraz kolorowy ma trzy kanały (każdy dla koloru czerwonego, zielonego i niebieskiego). Kanały są nałożone jeden na drugi. W tym samouczku użyjesz obrazu w skali szarości z tylko jednym kanałem. Każdy piksel ma wartość od 0 do 255, która odzwierciedla intensywność koloru. Na przykład piksel równy 0 będzie miał kolor biały, natomiast piksel o wartości bliskiej 255 będzie ciemniejszy.

Przyjrzyjmy się obrazowi zapisanemu w pliku Zbiór danych MNIST. Poniższy rysunek pokazuje, jak przedstawić obraz lewej strony w formacie matrycowym. Należy pamiętać, że oryginalna matryca została ujednolicona tak, aby zawierała się w przedziale od 0 do 1. W przypadku ciemniejszego koloru wartość w matrycy wynosi około 0.9, podczas gdy białe piksele mają wartość 0.

Operacja splotowa

Najbardziej krytycznym elementem modelu jest warstwa splotowa. Ta część ma na celu zmniejszenie rozmiaru obrazu w celu szybszego obliczenia wag i poprawy jego uogólnienia.

W części splotowej sieć zachowuje istotne cechy obrazu i wyklucza nieistotne szumy. Modelka uczy się na przykład rozpoznawać słonia na zdjęciu z górą w tle. Jeśli korzystamy z tradycyjnej sieci neuronowej, model przypisuje wagę wszystkim pikselom, także tym z góry, co nie jest istotne i może wprowadzić sieć w błąd.

Zamiast tego plik Keras sieć neuronowa splotowa będzie używać techniki matematycznej do wyodrębniania tylko najbardziej istotnych pikseli. Ta operacja matematyczna nazywana jest splotem. Technika ta pozwala sieci uczyć się coraz bardziej złożonych cech na każdej warstwie. Splot dzieli macierz na małe części, aby nauczyć się najbardziej istotnych elementów w obrębie każdej części.

Składniki konwolucyjnej sieci neuronowej (ConvNet lub CNN)

Istnieją cztery elementy Convnets

1. Skręt
2. Nieliniowość (ReLU)
3. Pooling lub podpróbkowanie
4. Klasyfikacja (warstwa w pełni połączona)

Skręt

Celem splotu jest lokalne wyodrębnienie cech obiektu z obrazu. Oznacza to, że sieć nauczy się określonych wzorców na obrazie i będzie w stanie rozpoznać je w każdym miejscu obrazu.

Splot to mnożenie elementów. Koncepcja jest łatwa do zrozumienia. Komputer skanuje część obrazu, zwykle o wymiarach 3×3 i mnoży ją przez filtr. Wynik mnożenia elementów nazywa się mapą cech. Ten krok jest powtarzany, aż cały obraz zostanie zeskanowany. Należy zauważyć, że po splocie rozmiar obrazu jest zmniejszany.

Poniżej znajduje się adres URL umożliwiający zobaczenie w akcji działania splotu.

Dostępnych jest wiele kanałów. Poniżej wymieniliśmy niektóre kanały. Widać, że każdy filtr ma określony cel. Uwaga, na zdjęciu poniżej; Jądro jest synonimem filtra.

Arytmetyka splotu

Faza splotowa zastosuje filtr do małej tablicy pikseli w obrazie. Filtr będzie się przesuwał wzdłuż obrazu wejściowego o ogólnym kształcie 3×3 lub 5×5. Oznacza to, że sieć przesunie te okna przez cały obraz wejściowy i obliczy splot. Poniższy obraz pokazuje, jak działa splot. Rozmiar łatki wynosi 3×3, a macierz wyjściowa jest wynikiem operacji elementarnej między macierzą obrazu a filtrem.

Zauważasz, że szerokość i wysokość danych wyjściowych mogą różnić się od szerokości i wysokości danych wejściowych. Dzieje się tak dzięki efektowi granicznemu.

Efekt granicy

Obraz zawiera mapę obiektów 5×5 i filtr 3×3. W środku znajduje się tylko jedno okno, w którym filtr może wyświetlać siatkę 3×3. Wyjściowa mapa funkcji zmniejszy się o dwa kafelki wraz z wymiarem 3×3.

Aby uzyskać taki sam wymiar wyjściowy jak wymiar wejściowy, należy dodać dopełnienie. Dopełnienie polega na dodaniu odpowiedniej liczby wierszy i kolumn po każdej stronie macierzy. Umożliwi to wyśrodkowanie splotu dla każdej płytki wejściowej. Na poniższym obrazku macierz wejścia/wyjścia ma ten sam wymiar 5×5

Kiedy definiujesz sieć, funkcje splecione są kontrolowane przez trzy parametry:

1. Głębokość: Definiuje liczbę filtrów do zastosowania podczas splotu. W poprzednim przykładzie widziałeś głębokość 1, co oznacza, że ​​używany jest tylko jeden filtr. W większości przypadków jest więcej niż jeden filtr. Poniższy rysunek pokazuje operacje wykonywane w sytuacji z trzema filtrami

2. Krok: Definiuje liczbę „skoków pikseli” między dwoma wycinkami. Jeśli krok jest równy 1, okna będą się przesuwać z rozrzutem pikseli równym jeden. Jeśli krok jest równy dwa, okna przeskoczą o 2 piksele. Jeśli zwiększysz krok, będziesz mieć mniejsze mapy cech.

Przykładowy krok 1

krok 2

3. Zero wypełnienia: Wypełnienie to operacja polegająca na dodaniu odpowiedniej liczby wierszy i kolumn po każdej stronie map cech wejściowych. W tym przypadku dane wyjściowe mają taki sam wymiar jak dane wejściowe.

Nieliniowość (ReLU)

Na końcu operacji splotu wyjście podlega funkcji aktywacji, aby umożliwić nieliniowość. Zwykłą funkcją aktywacji dla convnet jest Relu. Wszystkie piksele o wartości ujemnej zostaną zastąpione zerem.

Pooling Operacja

Ten krok jest łatwy do zrozumienia. Celem łączenia jest zmniejszenie wymiarowości obrazu wejściowego. Kroki te są wykonywane w celu zmniejszenia złożoności obliczeniowej operacji. Zmniejszając wymiarowość, sieć ma mniejsze wagi do obliczenia, więc zapobiega nadmiernemu dopasowaniu.

Na tym etapie musisz zdefiniować rozmiar i krok. Standardowym sposobem grupowania obrazu wejściowego jest użycie maksymalnej wartości mapy cech. Spójrz na poniższy obrazek. „Pulowanie” przeskanuje cztery podmacierze mapy cech 4×4 i zwróci maksymalną wartość. Pulowanie przyjmuje maksymalną wartość tablicy 2×2, a następnie przesuwa to okno o dwa piksele. Na przykład pierwsza podmacierz to [3,1,3,2], grupowanie zwróci wartość maksymalną, czyli 3.

Istnieje jeszcze inna operacja łączenia, taka jak średnia.

Ta operacja agresywnie zmniejsza rozmiar mapy cech

W pełni połączone warstwy

Ostatnim krokiem jest zbudowanie tradycyjnego sztuczna sieć neuronowa tak jak to zrobiłeś w poprzednim samouczku. Łączysz wszystkie neurony z poprzedniej warstwy do następnej warstwy. Funkcja aktywacji Softmax służy do klasyfikowania liczby na obrazie wejściowym.

Podsumować:

Konwolucyjna sieć neuronowa TensorFlow kompiluje różne warstwy przed dokonaniem prognozy. Sieć neuronowa charakteryzuje się:

• Warstwa splotowa
• Funkcja aktywacji Relu
• Poolinwarstwa g
• Warstwa gęsto połączona

Warstwy splotowe stosują różne filtry na podregionie obrazu. Funkcja aktywacji Relu dodaje nieliniowość, a warstwy łączenia redukują wymiarowość map cech.

Wszystkie te warstwy wydobywają istotne informacje z obrazów. Wreszcie mapa funkcji jest przesyłana do głównej, w pełni połączonej warstwy z funkcją softmax, aby dokonać prognozy.

Trenuj CNN za pomocą TensorFlow

Teraz, gdy znasz już elementy składowe konwnetów, możesz przystąpić do ich zbudowania TensorFlow. Do klasyfikacji obrazów CNN wykorzystamy zbiór danych MNIST.

Przygotowanie danych jest takie samo, jak w poprzednim samouczku. Możesz uruchomić kody i przejść bezpośrednio do architektury CNN.

Aby sklasyfikować obrazy za pomocą CNN, wykonaj poniższe kroki:

Krok 1: Prześlij zbiór danych

Krok 2: Warstwa wejściowa

Krok 3: Warstwa splotowa

Krok 4: Poolinwarstwa g

Krok 5: Druga warstwa splotowa i Pooling Warstwa

Krok 6: Gęsta warstwa

Krok 7: Warstwa logitowa

Krok 1: Prześlij zbiór danych

Zbiór danych MNIST jest dostępny w scikicie, aby się tego dowiedzieć URL. Pobierz go i zapisz w dziale Pobrane. Możesz go przesłać za pomocą fetch_mldata('MNIST Original').

Utwórz zestaw pociągowy/testowy

Musisz podzielić zbiór danych za pomocą train_test_split

Skaluj funkcje

Na koniec możesz skalować funkcję za pomocą MinMaxScaler, jak pokazano w poniższej klasyfikacji obrazów na przykładzie TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Definicja CNN

CNN używa filtrów na surowym pikselu obrazu, aby nauczyć się szczegółowego wzorca w porównaniu do globalnego wzorca z tradycyjną siecią neuronową. Aby zbudować CNN, musisz zdefiniować:

1. Warstwa splotowa: zastosuj n filtrów do mapy obiektów. Po splocie należy użyć funkcji aktywacji Relu, aby dodać nieliniowość do sieci.
2. Poolinwarstwa g: Następnym krokiem po splocie jest zmniejszenie próbkowania funkcji max. Celem jest zmniejszenie wymiarowości mapy funkcji, aby zapobiec nadmiernemu dopasowaniu i poprawić szybkość obliczeń. Łączenie max jest konwencjonalną techniką, która dzieli mapy funkcji na podregiony (zwykle o rozmiarze 2×2) i zachowuje tylko wartości maksymalne.
3. W pełni połączone warstwy: Wszystkie neurony z poprzednich warstw są połączone z kolejnymi warstwami. CNN sklasyfikuje etykietę zgodnie z cechami z warstw splotowych i zredukowanymi warstwą pulowania.

Architektura CNN

• Warstwa splotowa: stosuje 14 filtrów 5×5 (wyodrębnianie podregionów 5×5 pikseli), z funkcją aktywacji ReLU
• PoolinWarstwa g: Wykonuje maksymalne grupowanie z filtrem 2×2 i krokiem 2 (co oznacza, że ​​łączone regiony nie nakładają się)
• Warstwa splotowa: Stosuje 36 filtrów 5×5 z funkcją aktywacji ReLU
• Pooling Warstwa nr 2: Ponownie wykonuje maksymalne grupowanie z filtrem 2×2 i krokiem 2
• 1,764 neurony, przy współczynniku regularyzacji porzucania wynoszącym 0.4 (prawdopodobieństwo wynoszące 0.4, że dowolny element zostanie porzucony podczas treningu)
• Warstwa gęsta (warstwa logitowa): 10 neuronów, po jednym dla każdej klasy docelowej cyfry (0–9).

Do stworzenia CNN potrzebne są trzy ważne moduły:

• konw2d(). Konstruuje dwuwymiarową warstwę splotową z liczbą filtrów, rozmiarem jądra filtra, uzupełnieniem i funkcją aktywacji jako argumentami.
• max_pooling2d(). Konstruuje dwuwymiarową warstwę poolingu przy użyciu algorytmu max-pooling.
• gęsty(). Tworzy gęstą warstwę z ukrytymi warstwami i jednostkami

Zdefiniujesz funkcję do zbudowania CNN. Przyjrzyjmy się szczegółowo, jak skonstruować każdy element konstrukcyjny, zanim zawiniemy wszystko razem w funkcję.

Krok 2: Warstwa wejściowa

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Musisz zdefiniować tensor z kształtem danych. Można w tym celu wykorzystać moduł tf.reshape. W tym module musisz zadeklarować tensor, który ma zostać zmieniony, oraz kształt tensora. Pierwszym argumentem są cechy danych, które są zdefiniowane w argumencie funkcji.

Obraz ma wysokość, szerokość i kanał. Zbiór danych MNIST jest obrazem monochronicznym o wymiarach 28×28. W argumencie kształtu ustawiamy wielkość partii na -1, tak aby przybrała kształt cech [„x”]. Zaletą jest możliwość dostrojenia hiperparametrów wielkości partii. Jeśli rozmiar partii jest ustawiony na 7, tensor poda 5,488 wartości (28*28*7).

Krok 3: Warstwa splotowa

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Pierwsza warstwa splotowa ma 14 filtrów o rozmiarze jądra 5×5 i takim samym wypełnieniu. To samo wypełnienie oznacza, że ​​zarówno tensor wyjściowy, jak i tensor wejściowy powinny mieć tę samą wysokość i szerokość. Tensorflow doda zera do wierszy i kolumn, aby zapewnić ten sam rozmiar.

Korzystasz z funkcji aktywacji Relu. Rozmiar wyjściowy będzie wynosić [28, 28, 14].

Krok 4: Poolinwarstwa g

Następnym krokiem po splocie jest obliczenie puli. Obliczenie puli zmniejszy wymiarowość danych. Możesz użyć modułu max_pooling2d o rozmiarze 2×2 i kroku 2. Używasz poprzedniej warstwy jako danych wejściowych. Rozmiar wyjściowy będzie wynosić [batch_size, 14, 14, 14]

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Krok 5: Druga warstwa splotowa i Pooling Warstwa

Druga warstwa splotowa ma 32 filtry, z rozmiarem wyjściowym [batch_size, 14, 14, 32]. Warstwa pulowania ma ten sam rozmiar co poprzednio, a kształt wyjściowy to [batch_size, 14, 14, 18].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Krok 6: Gęsta warstwa

Następnie należy zdefiniować w pełni połączoną warstwę. Przed połączeniem mapy obiektów z gęstą warstwą należy ją spłaszczyć. Możesz użyć modułu zmiany kształtu o rozmiarze 7*7*36.

Gęsta warstwa połączy 1764 neurony. Dodajesz funkcję aktywacji Relu. Poza tym dodajesz składnik regulujący porzucenie ze współczynnikiem 0.3, co oznacza, że ​​30 procent wag zostanie ustawionych na 0. Należy pamiętać, że porzucenie ma miejsce tylko w fazie szkolenia. Funkcja cnn_model_fn ma tryb argumentów umożliwiający zadeklarowanie, czy model wymaga szkolenia, lub ocenę, jak pokazano w poniższym przykładzie klasyfikacji obrazów CNN TensorFlow.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Krok 7: Warstwa logitowa

Na koniec w przykładzie klasyfikacji obrazu TensorFlow można zdefiniować ostatnią warstwę z przewidywaniem modelu. Kształt wyjściowy jest równy rozmiarowi partii i 10, całkowitej liczbie obrazów.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Możesz utworzyć słownik zawierający klasy i prawdopodobieństwo wystąpienia każdej klasy. Moduł tf.argmax() zwraca najwyższą wartość, jeśli warstwy logitowe. Funkcja softmax zwraca prawdopodobieństwo każdej klasy.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

Chcesz zwrócić przewidywanie słownika tylko wtedy, gdy tryb jest ustawiony na przewidywanie. Dodajesz te kody, aby wyświetlić prognozy

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

Następnym krokiem jest obliczenie straty modelu. W ostatnim samouczku dowiedziałeś się, że funkcją straty dla modelu wieloklasowego jest entropia krzyżowa. Stratę można łatwo obliczyć za pomocą następującego kodu:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

Ostatnim krokiem przykładu TensorFlow CNN jest optymalizacja modelu, czyli znalezienie najlepszych wartości wag. W tym celu używasz optymalizatora gradientu z szybkością uczenia się 0.001. Celem jest minimalizacja strat

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Skończyliście z CNN. Jednakże chcesz wyświetlić metryki wydajności w trybie oceny. Metryki wydajności dla modelu wieloklasowego to metryki dokładności. Tensorflow jest wyposażony w moduł dokładności z dwoma argumentami, etykietami i przewidywanymi wartościami.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Otóż ​​to. Stworzyłeś swój pierwszy CNN i jesteś gotowy, aby wszystko zawinąć w funkcję, aby móc ją wykorzystać do uczenia i oceny modelu.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Poniższe kroki są takie same, jak w poprzednich samouczkach.

Przede wszystkim definiujesz estymator za pomocą modelu CNN do klasyfikacji obrazów.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

Uczenie CNN zajmuje wiele czasu, dlatego tworzysz hak Logging do przechowywania wartości warstw softmax co 50 iteracji.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Jesteś gotowy do oszacowania modelu. Ustawiasz wielkość partii na 100 i tasujesz dane. Pamiętaj, że ustawiliśmy kroki szkoleniowe na 16.000 XNUMX, trenowanie może zająć dużo czasu. Bądź cierpliwy.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

Teraz, gdy model jest już wytrenowany, możesz go ocenić i wydrukować wyniki

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

Przy obecnej architekturze uzyskujesz dokładność 97%. Możesz zmienić architekturę, rozmiar partii i liczbę iteracji, aby poprawić dokładność. Sieć neuronowa CNN działa o wiele lepiej niż ANN lub regresja logistyczna. W samouczku dotyczącym sztucznej sieci neuronowej uzyskałeś dokładność 96%, co jest wartością niższą niż CNN. Wydajność CNN jest imponująca przy większym obrazie zestawzarówno pod względem obliczania prędkości, jak i dokładności.

Podsumowanie

Splotowa sieć neuronowa sprawdza się bardzo dobrze w ocenie obrazu. Ten typ architektury jest dominujący w rozpoznawaniu obiektów ze zdjęcia lub wideo.

Aby zbudować CNN TensorFlow, musisz wykonać siedem kroków:

Krok 1: Prześlij zbiór danych:

Zbiór danych MNIST jest dostępny za pomocą narzędzia scikit do nauki. Pobierz go i zapisz w dziale Pobrane. Możesz go przesłać za pomocą fetch_mldata('MNIST Original').

Krok 2: Warstwa wejściowa:

Ten krok zmienia kształt danych. Kształt jest równy pierwiastkowi kwadratowemu liczby pikseli. Na przykład, jeśli obraz ma 156 pikseli, to kształt wynosi 26×26. Musisz określić, czy obraz ma kolor, czy nie. Jeśli tak, to masz 3 do kształtu - 3 dla RGB-, w przeciwnym razie 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Krok 3: Warstwa splotowa

Następnie musisz utworzyć warstwy splotowe. Stosujesz różne filtry, aby umożliwić sieci nauczenie się ważnych funkcji. Określasz rozmiar jądra i ilość filtrów.

conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Krok 4: Poolinwarstwa g

W trzecim kroku dodajesz warstwę poolingu. Ta warstwa zmniejsza rozmiar danych wejściowych. Robi to poprzez pobranie maksymalnej wartości podmacierzy. Na przykład, jeśli podmacierz to [3,1,3,2], pooling zwróci wartość maksymalną, czyli 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Krok 5: Dodaj warstwę splotową i Pooling Warstwa

W tym kroku możesz dodać tyle warstw conv, ile chcesz i warstw pooling. Google używa architektury z ponad 20 warstwami conv.

Krok 6: Gęsta warstwa

W kroku 6 spłaszcz poprzedni, aby utworzyć w pełni połączone warstwy. Na tym etapie możesz użyć innej funkcji aktywacji i dodać efekt zaniku.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Krok 7: Warstwa logitowa

Ostatnim krokiem jest prognozowanie.

logits = tf.layers.dense(inputs=dropout, units=10)