Co to jest konwolucyjna sieć neuronowa?
Konwolucyjna sieć neuronowa, znana również jako convnets lub CNN, jest dobrze znaną metodą w aplikacjach widzenia komputerowego. Ten typ architektury dominuje w rozpoznawaniu obiektów ze zdjęcia lub wideo.
W tym samouczku dowiesz się, jak zbudować convnet i jak używać TensorFlow do rozwiązywania odręcznego zbioru danych.
W tym samouczku dowiesz się
- Konwolucyjna sieć neuronowa
- Architektura konwolucyjnej sieci neuronowej
- Komponenty konwetów
- Trenuj CNN z TensorFlow
- Krok 1: Prześlij zbiór danych
- Krok 2: Warstwa wejściowa
- Krok 3: Warstwa splotowa
- Krok 4: Warstwa łącząca
- Krok 5: Druga warstwa splotowa i warstwa puli
- Krok 6: Gęsta warstwa
- Krok 7: Logit Layer
Architektura konwolucyjnej sieci neuronowej
Pomyśl o Facebooku kilka lat temu, po przesłaniu zdjęcia do swojego profilu poproszono Cię o ręczne dodanie nazwy do twarzy na zdjęciu. Obecnie Facebook używa convnet do automatycznego oznaczania znajomego na zdjęciu.
Konwolucyjna sieć neuronowa nie jest trudna do zrozumienia. Obraz wejściowy jest przetwarzany w fazie splatania, a następnie przypisywany jest do etykiety.
Typową architekturę convnet można podsumować na poniższym obrazku. Przede wszystkim obraz jest przesyłany do sieci; nazywa się to obrazem wejściowym. Następnie obraz wejściowy przechodzi nieskończoną liczbę kroków; to jest konwolucyjna część sieci. Wreszcie 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ł, a obraz kolorowy ma trzy kanały (każdy dla koloru czerwonego, zielonego i niebieskiego). Kanały są ułożone jeden na drugim. W tym samouczku użyjesz obrazu w skali szarości tylko z jednym kanałem. Każdy piksel ma wartość od 0 do 255, aby odzwierciedlić intensywność koloru. Na przykład piksel równy 0 pokaże biały kolor, podczas gdy piksel o wartości bliskiej 255 będzie ciemniejszy.
Przyjrzyjmy się obrazowi przechowywanemu w zbiorze danych MNIST. Poniższy rysunek pokazuje, jak przedstawić obraz lewej strony w formacie macierzy. Zwróć uwagę, że oryginalna matryca została ustandaryzowana tak, aby zawierała się w przedziale od 0 do 1. W przypadku ciemniejszych kolorów wartość matrycy wynosi około 0,9, podczas gdy białe piksele mają wartość 0.
Operacja konwolucyjna
Najbardziej krytycznym elementem modelu jest warstwa konwolucyjna. Ta część ma na celu zmniejszenie rozmiaru obrazu w celu szybszych obliczeń wag i poprawę jego uogólnienia.
W części konwolucyjnej sieć zachowuje istotne cechy obrazu i wyklucza nieistotny szum. Na przykład model uczy się, jak rozpoznać słonia na zdjęciu z górą w tle. Jeśli korzystasz z tradycyjnej sieci neuronowej, model przypisze wagę wszystkim pikselom, w tym pikselom górskim, co nie jest niezbędne i może wprowadzać w błąd sieć.
Zamiast tego splotowa sieć neuronowa będzie wykorzystywać technikę matematyczną do wyodrębniania tylko najbardziej odpowiednich pikseli. Ta operacja matematyczna nazywa się splotem. Technika ta umożliwia sieci poznanie coraz bardziej złożonych funkcji na każdej warstwie. Splot dzieli matrycę na małe części, aby nauczyć się najważniejszych elementów w każdym kawałku.
Komponenty konwetów
Istnieją cztery elementy Convnets
- Skręt
- Nieliniowość (ReLU)
- Łączenie lub pobieranie próbek podrzędnych
- Klasyfikacja (w pełni połączona warstwa)
- Skręt
Celem splotu jest lokalne wyodrębnienie cech obiektu na obrazie. 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 jest mnożeniem elementarnym. Koncepcja jest łatwa do zrozumienia. Komputer skanuje część obrazu, zwykle o wymiarach 3x3 i mnoży go do filtra. Wynik mnożenia według elementów nazywany jest mapą cech. Ten krok jest powtarzany aż do zeskanowania całego obrazu. Zwróć uwagę, że po splocie rozmiar obrazu jest zmniejszany.
Poniżej znajduje się adres URL, aby zobaczyć w akcji, jak działa konwolucja.
Dostępnych jest wiele kanałów. Poniżej wymieniliśmy niektóre kanały. Możesz zobaczyć, że każdy filtr ma określony cel. Uwaga, na poniższym obrazku; Jądro jest synonimem filtru.
Źródło
Arytmetyka stojąca za splotem
Faza splotu zastosuje filtr do małej tablicy pikseli w obrazie. Filtr przesunie się wzdłuż obrazu wejściowego i będzie miał ogólny kształt 3x3 lub 5x5. Oznacza to, że sieć przesunie te okna po całym obrazie wejściowym i obliczy splot. Poniższy obraz pokazuje, jak działa splot. Rozmiar plamki to 3x3, a macierz wyjściowa jest wynikiem elementarnej operacji między matrycą obrazu a filtrem.
Źródło
Zauważysz, że szerokość i wysokość danych wyjściowych mogą różnić się od szerokości i wysokości danych wejściowych. Dzieje się tak z powodu efektu granicznego.
Efekt graniczny
Obraz ma mapę funkcji 5x5 i filtr 3x3. W środku jest tylko jedno okno, w którym filtr może przesłonić siatkę 3x3. Mapa funkcji wyjściowych zmniejszy się o dwa kafelki wraz z wymiarem 3x3.
Aby uzyskać ten sam wymiar wyjściowy, co wymiar wejściowy, należy dodać dopełnienie. Wypełnienie polega na dodaniu odpowiedniej liczby wierszy i kolumn po każdej stronie macierzy. Pozwoli to splotowi na wyśrodkowanie każdej płytki wejściowej. Na poniższym obrazku macierz wejścia / wyjścia ma ten sam wymiar 5x5
Podczas definiowania sieci, elementy splątane są kontrolowane przez trzy parametry:
- Głębokość: określa liczbę filtrów do zastosowania podczas splotu. W poprzednim przykładzie zobaczył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 przedstawia operacje wykonane w sytuacji z trzema filtrami
- Stride: Określa liczbę „skoków piksela” między dwoma wycinkami. Jeśli krok jest równy 1, okna będą przesuwać się z rozpiętością piksela równą jeden. Jeśli krok jest równy dwa, okna przeskoczą o 2 piksele. Jeśli zwiększysz krok, uzyskasz mniejsze mapy funkcji.
Przykład kroku 1
Obraz krok 2
- Wypełnienie zerami: Dopełnienie to operacja polegająca na dodaniu odpowiedniej liczby wierszy i kolumn po każdej stronie map elementów wejściowych. W tym przypadku wyjście ma taki sam wymiar jak wejście.
- Nieliniowość (ReLU)
Pod koniec operacji splotu wyjście podlega funkcji aktywacji, aby umożliwić nieliniowość. Zwykłą funkcją aktywującą convnet jest Relu. Wszystkie piksele z wartością ujemną zostaną zastąpione przez zero.
- Operacja max-pooling
Ten krok jest łatwy do zrozumienia. Celem łączenia jest zmniejszenie wymiarowości obrazu wejściowego. Kroki mają na celu zmniejszenie złożoności obliczeniowej operacji. Zmniejszając wymiarowość, sieć ma mniejsze wagi do obliczeń, więc zapobiega nadmiernemu dopasowaniu.
Na tym etapie musisz zdefiniować rozmiar i krok. Standardowym sposobem łączenia obrazu wejściowego jest użycie maksymalnej wartości mapy elementów. Spójrz na obrazek poniżej. „Pooling” wyświetli cztery podmacierze mapy funkcji 4x4 i zwróci wartość maksymalną. Pule przyjmuje maksymalną wartość tablicy 2x2, a następnie przesuwa to okno o dwa piksele. Na przykład pierwsza podmacierz to [3,1,3,2], pula zwróci maksimum, które wynosi 3.
Jest jeszcze jedna operacja puli, taka jak średnia.
Ta operacja agresywnie zmniejsza rozmiar mapy obiektów
- W pełni połączone warstwy
Ostatni krok polega na zbudowaniu tradycyjnej sztucznej sieci neuronowej, tak jak w poprzednim samouczku. Łączysz wszystkie neurony z poprzedniej warstwy z następną. Używasz funkcji aktywacji softmax, aby sklasyfikować liczbę na obrazie wejściowym.
Podsumować:
Konwolucyjna sieć neuronowa kompiluje różne warstwy przed dokonaniem prognozy. Sieć neuronowa ma:
- Warstwa splotowa
- Funkcja Relu Activation
- Warstwa łącząca
- Warstwa gęsto połączona
Warstwy splotowe nakładają różne filtry na podregion obrazu. Funkcja aktywacji Relu dodaje nieliniowość, a warstwy łączące zmniejszają wymiarowość map cech.
Wszystkie te warstwy wydobywają istotne informacje z obrazów. W końcu mapa cech jest przekazywana do pierwotnej, w pełni połączonej warstwy z funkcją softmax, aby dokonać prognozy.
Trenuj CNN z TensorFlow
Teraz, gdy znasz już blok konstrukcyjny konwnetów, możesz go zbudować za pomocą TensorFlow. Do klasyfikacji obrazów użyjemy zbioru danych MNIST.
Przygotowanie danych przebiega tak samo, jak w poprzednim samouczku. Możesz uruchomić kody i przejść bezpośrednio do architektury CNN.
Będziesz postępować zgodnie z poniższymi krokami:
Krok 1: Prześlij zbiór danych
Krok 2: Warstwa wejściowa
Krok 3: Warstwa splotowa
Krok 4: Warstwa łącząca
Krok 5: Druga warstwa splotowa i warstwa puli
Krok 6: Gęsta warstwa
Krok 7: Logit Layer
Krok 1: Prześlij zbiór danych
Zbiór danych MNIST jest dostępny w scikit, aby dowiedzieć się o tym pod tym adresem URL. Pobierz go i zapisz w Pobrane. Możesz go przesłać za pomocą funkcji fetch_mldata („oryginał MNIST”).
Utwórz pociąg / zestaw testowy
Musisz podzielić zbiór danych za pomocą train_test_split
Skaluj funkcje
Wreszcie możesz skalować funkcję za pomocą MinMaxScaler
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_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 )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_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:]
Zdefiniuj CNN
CNN używa filtrów na surowym pikselu obrazu, aby poznać wzór szczegółów w porównaniu z wzorcem globalnym w tradycyjnej sieci neuronowej. Aby zbudować CNN, musisz zdefiniować:
- Warstwa splotowa: zastosuj liczbę filtrów n do mapy obiektów. Po splocie musisz użyć funkcji aktywacji Relu, aby dodać nieliniowość do sieci.
- Warstwa łącząca: Następnym krokiem po splocie jest zmniejszenie próbkowania funkcji max. Celem jest zmniejszenie wymiarowości mapy obiektów, aby zapobiec nadmiernemu dopasowaniu i poprawić szybkość obliczeń. Max pooling to konwencjonalna technika, która dzieli mapy obiektów na podregiony (zwykle o rozmiarze 2x2) i zachowuje tylko wartości maksymalne.
- W pełni połączone warstwy: Wszystkie neurony z poprzednich warstw są połączone z następnymi warstwami. CNN sklasyfikuje etykietę zgodnie z cechami z warstw splotowych i zmniejszy się wraz z warstwą łączącą.
Architektura CNN
- Warstwa splotowa: stosuje 14 filtrów 5x5 (wyodrębniających podregiony 5x5 pikseli), z funkcją aktywacji ReLU
- Warstwa puli: Wykonuje maksymalne łączenie z filtrem 2x2 i krokiem 2 (co oznacza, że regiony w puli nie nakładają się)
- Warstwa splotowa: stosuje 36 filtrów 5x5 z funkcją aktywacji ReLU
- Warstwa pulowania nr 2: Ponownie wykonuje maksymalne łączenie z filtrem 2x2 i krokiem 2
- 1764 neurony, ze współczynnikiem regularyzacji porzucania 0,4 (prawdopodobieństwo 0,4, że jakikolwiek element zostanie usunięty podczas treningu)
- Gęsta warstwa (warstwa logitów): 10 neuronów, po jednym na każdą klasę docelową cyfry (0-9).
Istnieją trzy ważne moduły, których można użyć do utworzenia CNN:
- conv2d (). Konstruuje dwuwymiarową warstwę konwolucyjną z liczbą filtrów, rozmiarem jądra filtru, wypełnieniem i funkcją aktywacji jako argumentami.
- max_pooling2d (). Konstruuje dwuwymiarową warstwę pulowania przy użyciu algorytmu max-pooling.
- gęsty(). Tworzy gęstą warstwę z ukrytymi warstwami i jednostkami
Zdefiniujesz funkcję do zbudowania CNN. Zobaczmy szczegółowo, jak skonstruować każdy blok konstrukcyjny, zanim zawiniemy wszystko razem w funkcji.
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. W tym celu możesz użyć modułu tf.reshape. W tym module musisz zadeklarować tensor do zmiany kształtu i kształtu tensora. Pierwszym argumentem są cechy danych, które są zdefiniowane w argumencie funkcji.
Obraz ma wysokość, szerokość i kanał. Zbiór danych MNIST to monochroniczny obraz o rozmiarze 28x28. Ustawiamy rozmiar wsadu na -1 w argumencie kształtu, aby przybierał kształt cech ["x"]. Zaletą jest dostosowanie hiperparametrów wielkości partii. Jeśli rozmiar partii jest ustawiony na 7, tensor poda 5488 wartości (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = 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 5x5 z tym samym wypełnieniem. To samo wypełnienie oznacza, że tensor wyjściowy i wejściowy powinny mieć tę samą wysokość i szerokość. Tensorflow doda zera do wierszy i kolumn, aby zapewnić ten sam rozmiar.
Używasz funkcji aktywacji Relu. Rozmiar wyjściowy to [28, 28, 14].
Krok 4: Warstwa łącząca
Następnym krokiem po splocie jest obliczenie puli. Obliczenie puli zmniejszy wymiarowość danych. Możesz użyć modułu max_pooling2d o rozmiarze 2x2 i kroku 2. Używasz poprzedniej warstwy jako danych wejściowych. Rozmiar wyjściowy to [rozmiar_batchu, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Krok 5: Druga warstwa splotowa i warstwa puli
Druga warstwa splotowa ma 32 filtry o rozmiarze wyjściowym [batch_size, 14, 14, 32]. Warstwa puli ma taki sam rozmiar jak poprzednio, a kształt wyjściowy to [rozmiar_batchu, 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 musisz zdefiniować w pełni połączoną warstwę. Mapa obiektów musi zostać spłaszczona przed połączeniem z gęstą warstwą. Możesz użyć zmiany kształtu modułu o rozmiarze 7 * 7 * 36.
Gęsta warstwa połączy 1764 neuronów. Dodajesz funkcję aktywacji Relu. Poza tym dodajesz termin regularyzacji rezygnacji ze współczynnikiem 0,3, co oznacza, że 30 procent wag zostanie ustawionych na 0. Należy pamiętać, że rezygnacja ma miejsce tylko w fazie treningu. Funkcja cnn_model_fn ma tryb argumentów do zadeklarowania, czy model wymaga trenowania lub oceny.
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: Logit Layer
Na koniec możesz zdefiniować ostatnią warstwę z prognozą modelu. Kształt wyjściowy jest równy rozmiarowi partii i 10, całkowitej liczbie obrazów.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Możesz utworzyć słownik zawierający klasy i prawdopodobieństwo każdej z nich. Moduł tf.argmax () with zwraca najwyższą wartość, jeśli warstwy logit. 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ć słownikową prognozę 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)
Kolejny krok polega na obliczeniu utraty modelu. W ostatnim samouczku dowiedziałeś się, że funkcją strat 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 jest optymalizacja modelu, czyli znalezienie najlepszych wartości wag. W tym celu używasz optymalizatora zejścia gradientu z szybkością uczenia się wynoszącą 0,001. Celem jest zminimalizowanie strat
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Skończyłeś z CNN. Jednak 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. Utworzyłeś swój pierwszy CNN i jesteś gotowy, aby opakować wszystko w funkcję, aby użyć jej do trenowania i oceny modelu.
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = 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 Layerpool2_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 Layerlogits = 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 Lossloss = 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 modeeval_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.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
Trenowanie CNN zajmuje wiele razy, dlatego tworzysz hak Logging, aby przechowywać wartości warstw softmax co 50 iteracji.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Jesteś gotowy do oszacowania modelu. Ustawiasz rozmiar partii na 100 i tasujesz dane. Pamiętaj, że ustawiliśmy kroki treningowe na 16 000, trenowanie może zająć dużo czasu. Bądź cierpliwy.
# Train the modeltrain_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 resultseval_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:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO: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ść na poziomie 97%. Możesz zmienić architekturę, rozmiar partii i liczbę iteracji, aby poprawić dokładność. Sieć neuronowa CNN działa znacznie lepiej niż sieć ANN lub regresja logistyczna. W samouczku o sztucznej sieci neuronowej miałeś dokładność 96%, co jest mniejszą wartością CNN. Wydajność CNN jest imponująca przy większym zestawie obrazów , zarówno pod względem szybkości obliczania, jak i dokładności.
Podsumowanie
Do oceny obrazu bardzo dobrze sprawdza się konwolucyjna sieć neuronowa. Ten typ architektury dominuje w rozpoznawaniu obiektów ze zdjęcia lub wideo.
Aby zbudować CNN, musisz wykonać sześć kroków:
Krok 1: Warstwa wejściowa:
Ten krok zmienia kształt danych. Kształt jest równy pierwiastkowi kwadratowemu z liczby pikseli. Na przykład, jeśli obraz ma 156 pikseli, to kształt ma wymiary 26x26. Musisz określić, czy obraz ma kolor, czy nie. Jeśli tak, to miałeś 3 do kształtu - 3 dla RGB-, w przeciwnym razie 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Krok 2: Warstwa splotowa
Następnie musisz utworzyć warstwy konwolucyjne. Stosujesz różne filtry, aby umożliwić sieci poznanie ważnych funkcji. Określasz rozmiar jądra i liczbę filtrów.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Krok 3: Warstwa łącząca
W trzecim kroku dodajesz warstwę puli. Ta warstwa zmniejsza rozmiar wejścia. Czyni to, przyjmując maksymalną wartość podmacierzy. Na przykład, jeśli podmacierz to [3,1,3,2], zestawienie zwróci maksimum, które wynosi 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Krok 4: Dodaj warstwę splotową i warstwę łączącą
Na tym etapie możesz dodać tyle, ile chcesz, konwertować warstwy i łączyć warstwy. Google używa architektury z ponad 20 warstwami konw.
Krok 5: Gęsta warstwa
Krok 5 spłaszcza poprzedni, aby utworzyć w pełni połączone warstwy. Na tym etapie możesz użyć różnych funkcji aktywacji i dodać efekt rezygnacji.
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 6: Logit Layer
Ostatnim krokiem jest przewidywanie.
logits = tf.layers.dense(inputs=dropout, units=10)