Sieć konwolucyjna w Tensorflow do klasyfikacji cyfr z MNIST

Trzeci wpis z serii związanej tworzeniem sieci neuronowych w Tensorflow, tym razem budujemy sieć konwolucyjną do klasyfikacji cyfr z MNIST. Omawiam idee operacji konwolucji dla sieci neuronowych oraz jak ją poprawnie zaimplementować w Tensorflow. W stosunku do poprzednich wpisów z serii sieć ta osiąga najlepszą dokładność klasyfikacji równą 0.9880.

Wpis ten jest kontynuację serii tekstów o klasyfikacji cyfr z MNIST z wykorzystaniem Tensorflow:

  • zaczęliśmy z jednowarstwową siecią neuronową, która osiągnęła 0.9237 dokładności, służy ona jako baseline dla dalszych naszych modeli
  • w drugim wpisie zbudowaliśmy pięć wariantów wielowarstwowej sieci neuronowej, które w zależności od architektury osiągają dokładność od 0.9541 do 0.9817
  • w tym poście zbudujemy sieć konwolucyjną osiągającą dokładnośc na poziomie 0.9880

Artykuł ten ma na celu wprowadzić się w świat sieci konwolucyjnych oraz ich implementacji w Tensorflow. Jestem zwolennikiem nie tylko praktyki, ale lubię także wpleść trochę teorii. Daje ona intuicję i pozwala na zastosowanie praktyki w innych kontekstach. Na początku przeczytasz o samej zasadzie działania operacji konwolucji, dzięki temu mam nadzieję będziesz lepiej rozumiał i umiał poprawnie zastosować.

Operacja konwolucji w sieciach neuronowych

Operacja konwolucji jest matematyczą operacją znaną już od 1754 roku, natomiast ostatnio została wykorzystana z ogromnym sukcesem w sieciach neuronowych. Znalazła zastosowanie przy klasyfikacji obrazów oraz w technikach z NLP.  W ogromnym skrócie jej idea polega na przefiltrowaniu sygnału poruszając się po nim w ramach mniejszego okna, tak aby uchwycić cechy z sąsiedztwa. W przypadku obrazu filtrem jest np. macierz 3×3 z wagami, którą przesuwamy po obrazie, a w przypadku słów jest to wektor, który przesuwamy po sąsiedztwie dwóch poprzedających i następnych słów. Jeżeli chcesz dobrze zrozumieć zasadę działania konwolucji to odsyłam do dosyć szczegółowego wpisu na temat operacji konwolucji(splotu), podaję tam jej formalną matematyczną definicję z licznymi przykładami z przetwarzania obrazów.

Konwolucja jako filtr

W kontekście sieci neuronowych intuicję stojącą za operacją konwolucji doscyć dobrze oddaje następujący przykład:

Image convolution example

Operacja konwolucji na obrazie. Duża macierz to obraz, a mała pomarańczowa to filtr konwolucyjny.

Duża macierz to jest nasz obraz wraz z wartościami poszczególnych pikseli. Mała pomarańczowa macierz to jeden z przykładowych filtrów(ang. kernel, jądro konwolucji). Przemieszczająć nasz filtr wzdłuż obrazu wykonujemy operację mnożenia wartości fitru i odpowiadajacych wartości pikseli, następnie wszystko to dodajemy do siebie. W ten sposób otrzymamy wartość nowego piksela przefiltrowanego obrazu.

Do czego służą filtry

No dobra, ale po co nam te filtry, do czego one służą? Młody adepcie sztuki konwolucji, otóż fitlry pozwalają uwypuklić różne cechy na obrazie, w zależności od dobranych wag pozwalają na:

  • wydobycie krawędzi na obrazie,
  • rozmycie lub wyostrzenie obrazu,
  • wykrycie charakterystycznych układów lini np. trójkątów, lini równoległych, owali itp.
  • i wiele inych

Aaaa, już rozumiem, stosując jednocześnie wiele filtrów na obrazie mogę wykrywać różne charaktrystyczne prymitywne cechy lub obiekty. Czyli jeden filtr wykryje mi linie równoległe, inny prostopadłe, jeszcze inny trójkąty i składając tą wiedzę razem mogę wnioskować co się na obrazie znajduje. Czy w takim razie nie jest to coś w rodzaju odkrywania cech obrazu (ang. feature enginniering)? Brawo, właśnie to robi konwolucja.

Ok, rozumiem do czego filtry służą, ale skąd wziąć wartości do poszczególnych filtrów? Mnie na początku mojej przygody z operacją konwolucji takze to nie dawało spokoju. Tu mam dla ciebie dwie odpowiedzi, w klasycznym przetwarzaniu obrazów te wartości są już eksperymentalnie opracowane. Zaglądasz do książki i tam masz napisane, że filtr do wykrywania krawędzi to ma takie a nie inne wagi. W kontekście uczenia maszynowego i sieci, odpowiedź jest jeszcze prostsza – Sieć sama wyucza się tych wag! Dzieje się to na tej samej zasadzie jak w tradycyjnej sieci neuronowej, w trakcie treningu macierz “W” jest aktualizowana, tak tutaj wartości poszczególnych filtrów są także aktualizowane.

Zastosowanie wielu filtrów na raz – macierz konwolucji

W poprzednim przykładzie mieliśmy uproszczoną sytuacje, po pierwsze obraz składał się tylko z jednego kanału, w odróżnieniu od obrazu kolorowego składającego się z trzech kanałów RGB. Po drugie stosowaliśmy tylko jeden filtr na raz. Poniżej mamy bardziej realistyczny przykład. Obraz składa się z trzech warstw (kanały czerwony, zielony, niebieski), stąd macierz wejściowa (obraz) jest trójwymiarowa, ponadto mamy dwa filtry \(W_1\) i \(W_2\), które obejmują 4 sąsiednie piksele (4×4). Biorąc to wszystko pod uwagę nasza warstwa konwolucyjna jest macierzą o wymiarach \( W=[4,4,3,2] \). Dwa pierwsze wymiary oznaczają szerekość i wysokość filtrów (4×4), kolejny wymiar głębokość warstwy wejściowej (3), a ostatni głębokość warstwy wyjściowej (co jest równoważne ilości filtrów).

Credits to Martin Gorner @martin_gorner https://codelabs.developers.google.com/codelabs/cloud-tensorflow-mnist/#0

 

Obliczajać wartości dla warstwy wyjściowej, postępujemy podobnie jak w poprzednim przykładzie, odpowiadające sobie komórki macierzy przemnażamy oraz dodajemy do siebie. W tym przypadku aby obliczyć jedną wartość wyjściową będziemy musieli dokonać 4x4x3 mnożenia oraz wyniki te zsumować. Następnie przechodząć do następnego położenia operację powtarzamy otrzymująć kolejną wartość wyjściową, całą procedurę powtarzamy dla kolejnych filtrów. Miejcie na uwadzę, że operacja ta w Tensorflow jest dużo bardziej zoptymalizowana i wiele z tych obliczeń dzieje się równolegle.

Sieć konwolucyjna w Tensorflow – omówienie kodu

Kod dla całej serii wpisów znajduje się na moim githubie “Tensorflow MNIST Convolutional Network Tutorial” a obecnie interesował nas będzie plik mnist_3.0_3layer_convnet.py. Do jego uruchomienie będziecie potrzebowali python3 oraz zainstalowanej biblioteki Tensorflow w wersji min. 1.3.

Nie będę się rozpisywał o zbiorze MNIST bo już pojawił się w poprzednich postach z serii, więc szybko przejdę do meritum.

Architektura sieci konwolucyjnej

Zbudujemy pięcio warstwową sieć, w której zastosujemy 3 warstwy konwolucyjne wraz z operacją “max pooling”. Przedostatnią warstwą będzie warstwa w pełni połączona (ang. fully connected) i ostatnia warstwa wyjściowa z 10 neuronami wyjściowymi okręslającymi prawdopodobieństwo bycia jedną z 10 cyfr.

Na wejściu podajemy obrazki z zbioru MNIST mają one wymiary 28x28x1, cyfra 1 na końcu wskazuje że mamy tylko jeden kanał czyli obrazy są w odcieniach szarości. Całość podajemy do sieci w paczkach o rozmiarze ‘batch’.

Dane z warstwy wejściowej przepuszczamy przez pierwszą warstwę konwolucyjną o wymiarach \( W_1=[5,5,1,4] \), czyli mamy 4 filtry o rozmiarze 5×5. Warstwą wejściową jest obraz o głębokości 1, stąd na trzeciej pozycji mamy jedynkę.

Zaraz po pierwszej warstwie konwolucyjnej dodaliśmy drugą o wymiarach \( W_2=[3,3,4,8] \), tym razem mamy 8 filtrów o rozmiarze 3×3, a dane wejściowe z warstwy powyżej mają głębokość 4 (tyle ile filtrów w poprzedniej warstwie). Po tych operacjach stosujemy max_pooling zmieniający rozdzielczość naszego obrazu o połowę z 28×28 pikseli do 14×14.

W tym momecie muszę się usprawiedliwić, bo pominąłem w opisie całą arytmetykę związaną z wielkością filtra, o ile chcemy go przesuwać (ang. strides) oraz jaki wpływ ma ‘max_pooling’. Wszystkie te trzy rzeczy mają wpływ na wielkość docelowego ‘obrazu’ wyjściowego. Dla mnie jest to najtrudniejsza część całego procesu składania warstw ze sobą, tak aby poszczególne wymiary w kolejnych warstwach się zgadzały. W tym celu polecam do przeczytania publikację “A guide to convolution arithmetic for deep learning” [1]

Trzecia warstwa konwolucyjna składa się z 16 filtrów \( W_3=[3,3,8,16] \), rozmiar filtra 3×3 a dane wejściowe z warstwy powyżej mają głębokość 8. Po tej operacji stosujemy powtórnie “max_pooling” zmniejszając rozdzielczość dwukrotnie z 14×14 do 7×7 pikseli.

Obraz nasz przechodząc powyższe przekształcenia ma teraz wymiary [7,7,16], przed ostateczną klasyfikacją dodajemy jeszcze jedną warstwę w pełni połączoną o wymiarach 256 neuronów, na na koniec warstwę z ‘softmax’ z 10 wyjściowymi neuronami.

Proszę nie pytajcie mnie skąd wziąłem wymiary poszczególnych warstw. Nie ma tutaj jakiejś jednej przyjętej teorii, ilość neuronów w warstwach dobrałem eksperymentalnie, tak aby wyniki były dobre ale jednocześnie nie było ich za dużo.

Stworzenie odpowiednich zmiennych w Tensorflow

Przejdźmy zatem do kodu, który zbuduje nam model. W tym celu musimy zdefiniować wejście sieci ‘placeholdery’ oraz poszczególne macierze o odpowiednich wymiarach.

Musimy stworzyć dwa pudełka, które pozwolą na wrzucenie danych do sieci, pierwszy ‘X‘ o wymiarach [None, 28,28,1], jedyne co może zastanawiać jak pierwszy wymiar może być równy None. Określa on ‘batch_size’ ilość obrazków, które naraz chcemy przetważać. Otóż jest to pewien tric z Tensorflow polegający na tym, że biblioteka sama sobie wyliczy ile tych obrazów my przekazaliśmy, pozwala to na napisanie elastycznego kodu. Podony placeholder (Y_)  tworzymy dla rzeczywistych etykiet.

Następnie dałem trzy zmienne określający rozmiar poszczególnych warstw konwolucyjnych (C1,C2,C3) oraz ilość neuronowów w warstwie w pełni połączonej (FC4).

Sama definicja modelu wymaga określenia zmiennych (w sensie TF), może lepiej nazywać je parametrrami modelu są to poszczególne macierze W1, W2, W3, W4, W5. Wszystkie są od razu zainicjalizowane losowymi wartościami z rozkładu normalnego. Przestroga na przyszłość nie inicjalizujcie parametrów modelu zerami, to nie zadziała 🙁

Dodatkowo prócz macierzy inicjalizowane są bias b1, b2, b3, b4, b5 (te już mogą być inicjalizowane zerami)

Łączymy warstwy w sieć

Mając określone parametry modelu (zmienne z TF – variables) powinniśmy połączyć je ze sobą, tak aby dane swobodnie przepływały (ang. Flow – łapiecie skąd już nazwa TensorFlow) z jednej warstwy do drugiej. Każdą warstwę można rozumieć jako transformacje danych.

Tworzymy pierwszą warstwę, na danych z naszego placholdera X stosujemy operację konwolucji (tf.nn.conv2d) z macierzą W1 a następnie wszystko przepuszczamy przez funkcję aktywacji ReLu, w ten sposób otrzymujemy wyjście pierwszej warstwy Y1. Powtarzamy operację, lecz już jako wejście do drugiej warstwy stosujemy wyjście z pierwszej Y1. Wykonujemy konwolucję Y1 z macierzą W2 i stosujemy na wyniku funkcję aktywacji ReLu. Następnie stosujemy operację ‘max_pool‘, która z kwadrata 2×2 piksele wybiera największą wartość, pozwala to na zmniejszenie wrażliwości na przesunięcia obiektów na obrazie (choć najnowsze publikację z 2017 roku poddają to w wątpliwość) oraz skutkuje zminiejszeniem wymiaru z 28×28 do 14×14.

Wyjście z warstwy drugiej Y2 stosujemy jako wejście do warstwy trzeciej, poddając je operacji konwolucji z macierzą W3, przepuszczamy przez funkcję aktywacji i stosujemy poling.

Następnie musimy “rozwinąć” wyjście z warstwy Y3 aby móć połączyć z warstwą czwartą już w pełni połączoną. W tym celu stosujemy funkcję tf.reshape i otrzymujemy macierz 2 wymiarową, gdzie pierwszy wymiar określa numer obrazka w paczce (‘batch’) a drugi to rozciągnięty wektor z danymi. Obliczamy wyjście warstwy Y4 poprzez zwykłe mnożenie macierzy YY i W4.

Na koniec obliczamy wyjście sieci Y, mnożąc Y4 poprzez macierz W5 otrzymujemy surowe wartości (Ylogits, zapamiętujem je bo się jeszcze przydadzą) i aby otrzymać prawdopodowbieństwa stosujemy tf.nn.softmax

Mając połączone warstwy z sobą przejdźmy do sposobu uczenia sieci.

Uczenie – wybór funkcji straty i algorytm optymalizacji

W tym przypadku sytuacja jest raczej standardowa. Podobnie jak w poprzednich przypadkach stosujemy funkcję starty ‘cross entropy‘. Funkcja ta porównuje wartości obliczone przez z sieć (Ylogits) z rzeczywistymi etykietami (Y_). Gdy wartości zgadzają się to nie nalicza błędu, a jezeli nie to dodaje do całkowitej sumy błędów błędy cząstkowe.

Cały proces uczenia polega na minimalizacji wartości funkcji straty poprzez odpowiednie dostosowywanie naszych zmiennych (ang. variables). Dzieje się to poprzez modyfikację wag w naszych macierzach W1 do W5. Drogi czytelniku wybacz za ogromny skrót myślowy, ale nie chcę wchodzić w szczegóły alg. wstecznej propagacji błędu oraz optymalizację.

Na końcu określamy algorytm, który zastosujemy do minimalizacji naszej funkcji straty. Wybraliśmy ‘AdamOptimizer’, który magicznie będzie wiedział jak dokonać minimalizacji naszej funkcji straty. Kolejno przechodzą w górę naszej całej sieci i ostatecznie będzie modyfikował wagi w sieci. Zwrócicie uwagę, że minimalizacja jest zpisana pod zmienną ‘train_step’. Na razie jescze niczego nie uruchomiliśmy i nie ruszyły żadne obliczenia, dopiero poniżej uruchomimy uczenie sieci.

Pętla ucząca

Mamy już wszystko zdefiniowane, wystarczy tylko uruchomić całą naszą maszynerię. Bo jak pamiętacie, idea Tensorflow polega na tym, że najpierw tworzymy graf obliczeń. Jest to swoisty przepis łączący poszczególne elementy sieci oraz procesu uczenia ze sobą. Na koniec w ramach sesji (ang. Session) uruchamiamy poszczególne kroki, dla nas najważniejsza jest linia ostatnia

sess.run(train_step, feed_dict={X: batch_X, Y_: batch_Y, pkeep: 0.75}) 

uruchamia ona krok algorymtmu optymalizacji jednocześnie poprzez słownik feed_dict przekazuje część danych na których proces uczenia ma się odbyć.
Zapętlająć to N-razy i za każdym razem losująć paczkę (ang. batch) danych

batch_X, batch_Y = mnist.train.next_batch(BATCH)

dokonujemy optymalizacji wag, czyli uczenia sieci.

Pozostała część pętli służy tylko wyświetleniu statystyk co DISPLAY_STEP kroków, tak aby można w konsoli śledzić proces uczenia. Jak zmienia się funkcja starty na danych treningowych i testowych.

Wyniki

Uruchamiając skrypt powinniście otrymać dokładność powyżej 0.9880, przynajmniej wcześniej taką zawsze otrzymywałem. Po aktualizacji do TF do wersji 1.4 accuracy podskoczyło do 0.9910 nie wiem dlaczego. Skrypt powinien wygenerować wam także następujący wykres z wartościami loss function i accuracy.

Sieć konwolucyjna W Tensorflow wykresy loss i accuracy

Wartości accuracy i loss dla zbioru treningowego i testowego dla sieci konwolucyjnej

 

Podsumowanie

Wpis ten kończy serię artykułów związanych z budową sieci neuronowych w Tensorflow. W trakcie całej serii zbudowaliśmy najpierw prostą sieć jednowarstwową, następnie 5 warstwową a na końcu konwolucyjną. Chciałem wam pokazać jak krok po kroku można zbudować coraz to wydajniejsze modele służące do klasyfikacji obrazów. Oczywiście pozostało jeszcze wiele kwestii nie poruszonych takich jak: batch normalization, residual connections, inception modules itp. To pozostawiam sobie i wam na przyszłość.

Jeżeli byście chcieli wykorzystać materiały do zbudowania swojego własnego klasyfikatora to zwróćcie uwagę na kilka kwestii:

  • Rozmiar placeholdera X zależy od rozmiaru waszych danych. Nie tylko rozdzielczość (28×28) należało by zmienić ilość kanałów jeżeli przetwarzacie obrazy kolorowe RGB
  • Rozmiar warstwy wyjściowej zależny jest od ilości klas, my w tych przykładach mieliśmy ich 10 u was może ich być znacznie więcej np. 1000
  • Architektura tej sieci jest raczej prosta i może nie dawać zadowalających rezultatów na waszych danych, tak więc polecam eksperymentowanie
    • z ilością filtrów, można zwiększyć wartości C1, C2, C3
    • a także z dodawaniem nowych warstw, wymagać to bedzie od was dodanie nowych zmiennych W oraz odpowiednie ich połączenie

 

PS. Jeżeli wpis był pomocny, to proszę daj znać w komentarzu. Nie chcę pisać tylko dla siebie 🙂

[1] V. Dumoulin and F. Visin, “A guide to convolution arithmetic for deep learning,” , 2016.
[Bibtex]
@article{convnet_arithmetic,
archivePrefix = {arXiv},
author = {Dumoulin, Vincent and Visin, Francesco},
citeulike-article-id = {14128483},
citeulike-linkout-0 = {http://arxiv.org/abs/1603.07285},
citeulike-linkout-1 = {http://arxiv.org/pdf/1603.07285},
day = {23},
eprint = {1603.07285},
keywords = {convolutional\_neural\_networks, deep\_learning\_architectures, networks, neural},
month = mar,
posted-at = {2016-09-01 19:22:00},
priority = {2},
title = {{A guide to convolution arithmetic for deep learning}},
url = {http://arxiv.org/abs/1603.07285},
year = {2016}
}

10 Comments Sieć konwolucyjna w Tensorflow do klasyfikacji cyfr z MNIST

  1. Pingback: Jednowarstwowa sieć neuronowa w Tensorflow do klasyfikacji cyfr z MNIST - About Data

    1. ksopyla

      Powoli zbieram się do tego, ale jest na mojej liście TODO, ale dzięki twojemu komentarzowi daję temu wyższy priorytet 🙂

      Reply
  2. Bartosz

    Trafiłem na tego bloga przez ten artykuł i zostanę tu na dłużej! Czeka mnie dużo tematów do nadrobienia i z niecierpliwością czekam na kolejne 😀

    Reply

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *