Ściąga programisty: Konwolucyjne sieci neuronowe (CNN)

Przykład rozpoznawania slash, backslash, kółko i krzyżyk
Bazując na filmach:

Zakładamy, że obrazki slash and backslash mają wymiary 2x2 piksele.
Rozkładamy na postać 4x1 :

Filtr backslash
Mamy wzorzec backslash, gdzie wartości 1 odpowiada + a wartości -1 odpowiada -.

Kiedy nałożymy filtr backslash na obrazek backslash wynik sumowania znaków po kolumnach (dla rozmiaru 4x1) daje nam wartość 4: (+1) + (+1) + (+1) + (+1) = 1 + 1 + 1 + 1 = 4 .
Jest to najwyższy wynik mówiący, że badany element jest zgodny z filtrem.

Przykładowy test rozpoznania backslash
Nakładamy wzorzec backslash na badany element.
Ustalamy znaki pomiędzy wzorcem a testowanym elementem.
Wzorzec ma znaki: +, -, -, +. Testowany element ma znaki: +, +, -, +.

Wynik sumowania znaków po kolumnach (dla rozmiaru 4x1): +, -, +, + (plus i minus daje minus , plus i plus daje plus). Następnie sumujemy jedynki.
Przykład dla pierwszego wzorca: (+1) + (-1) + (+1) + (+1) = 1-1+1+1=2
Im wyższa wartość tym element testujący jest podobny do wzorca.

Drugi przykład

Wartość -2 sugeruje, że podany przykład daleko odbiega od wzorca.

--------------------------------------------------------------------------------------------------------------------------

Przykład rozpoznawania slash, backslash, kółka i krzyżyka.

Obrazki mają tym razem wymiary 3x3.
Możemy zauważyć, że każdy z obrazków 3x3 składa się ze złożenia elementów 2x2 odpowiadających slash i backslash.

Oto sieć którą będzie analizować:

--------------------------------------------------------------------------------------------------------------------------

Tworzenie Convolution Layer

Warstwę konwolucyjną tworzą filtry wykrywające pewną niskopoziomową cechę obrazka.
Naszymi filtrami są obrazki reprezentujące backslasha i slash:

Analiza dla obrazka X
Nasze filtry (2x2 piksele) mogą wystąpić w dowolnym obszarze obrazka więc w każdym obszarze musimy je wykrywać w taki sam sposób:

UWAGA

Jeśli mielibyśmy obrazek o wymiarach m× n, a chcielibyśmy skonstruować filtr obejmujący obszar o rozmiarze k× l (dla k < m i l < n ), to potrzebowalibyśmy co najmniej (m − k+ 1) × (n − l + 1) neuronów filtrujących daną cechę (czasami rozszerza się obrazek o piksele zerowe na brzegach, np. aby zachować taką samą liczbę neuronów z warstwy wejściowej i neuronów filtrujących).

W naszym przykładzie dla jednego filtra potrzebne jest (3-2+1)x(3-2+1)=2x2=4 neurony na filtr. Czyli mając dwa filtry / i \ mamy 8 neuronów kodujących.

--------------------------------------------------------------------------------------------------------------------------

Tworzenie Pooling Layer

Badamy nasz obrazek wejściowy poprzez nałożenie naszego pierwszego filtra na wszystkie fragmenty badanego obrazka (równe co do wielkości wielkości filtra 2x2).
Jeśli wynikiem jest nasza liczba zgodności (liczba dodatnia 4) to znaczy ze znaleźliśmy nasz wzorzec.

W poniższym przypadku nie mamy zgodności (liczba ujemna -4) ze wzorcem czyli nic nie znaleźliśmy.

To samo robimy dla dolnych elementów z siatki 3x3.

To samo robimy z drugim filtrem (dolnym):

Doszliśmy do przekształcenia obrazka 3x3 na obrazek 2x2 wykorzystując do tego filtry warstwy konwolucyjnej:

Powyższy wynikowy obrazek jest tym co komputer widzi po konwolucji - z większego obrazka mamy mniejszy zawierające elementy pasujące do filtrów.

Warstwa konwolucyjna wprowadza redundancje danych. Sąsiednie jednostki częściowo pokrywają te same obszary danych wejściowych. W celu poradzenia sobie z tym zjawiskiem wprowadzony jest kolejny rodzaj warstwy – tzw. pooling layer albo subsampling layer.

Warstwy pooling pomagają wydobyć najważniejsze cechy z wcześniejszych warstw.

Analiza dla obrazka O:

Dla \ :

Dla / :

--------------------------------------------------------------------------------------------------------------------------

Jak tworzymy Fully Connected Layer

Do wsparcia ostatecznej klasyfikacji obrazka stosuje się tzw. warstwę gęstą (ang. dense layer lub fully connected layer).

Analiza dla X:
Zamieniamy teraz nasz obrazek 2x2 na 4x1 :

Następnie tworzymy matryce, w której umieszczamy informację, gdzie znaleźliśmy nasze bazowe filtry \ i / w obrazku 4x1 :

Oto kolejne etapy wypełnienia matrycy dla \ i / :

Oto jak wyglądają macierze dla wszystkich obrazków:

Nasze matrycę są ostatecznie filtrami (składającymi sie z + i - ) dla poszczególnych obrazków:

Następnie porównujemy każdą macierz z każdym filtrem.
Przykład dla X:

Jak wyliczamy pojedynczą macierz dla pierwszego filtra:

Jak to wygląda dla pozostałych filtrów:

Filtr z najwyższą wartością "8" jest właściwym filtrem dla obrazka wejściowego.

Oto jak wygląda Fully Connected Layer dla wszystkich symboli:

--------------------------------------------------------------------------------------------------------------------------

Oto cała sieć po połączeniu wszystkiego w całość:

--------------------------------------------------------------------------------------------------------------------------
Oto jaka jest ścieżka dla rozpoznania X:

--------------------------------------------------------------------------------------------------------------------------

Rozpatrzmy bardziej rozbudowany przypadek

Rozwiążmy problem czy obrazek po prawej stronie odpowiada obrazkowi na lewej stronie.

CNN porównują obrazek kawałek po kawałku. Te kawałki nazywamy cechami (features).

Dzięki znalezieniu dopasowań przybliżonych elementów w mniej więcej w tych samych pozycjach na dwóch obrazach, CNN uzyskuje lepsze dopasowanie niż dopasowywanie całego obrazu.

Każda cecha jest mini dwuwymiarowym obrazkiem.W przypadku obrazów X, cechy składające się z ukośnych linii i krzyżyków przechwytują wszystkie ważne cechy większości X-ów. Te cechy będą prawdopodobnie pasować do ramion i środka dowolnego obrazu X.

--------------------------------------------------------------------------------------------------------------------------

Konwolucja

Konwolucja ma za zadanie określenie stopnia dopasowania filtra (w naszym przypadku obrazek o wymiarach 3x3) do poszczególnych fragmentów obrazka wejściowego.

Przykład obliczeń konwolucyjnych dla filtra backslash:

Wynik konwolucji przeprowadzony na całym obrazie:

Jeden obraz stał się stosem przefiltrowanych obrazów

Oto jak wygląda wynik konwolucji dla wszystkich filtrów backslash, X i slash:

--------------------------------------------------------------------------------------------------------------------------

Pooling layer

Pooling layer kompresuje obraz. Najpopularniej poprzez wybranie maksymalnej wartości (max-pooling) z danego analizowanego fragmentu obrazu.

Pooling przeprowadzony dla wszystkich filtrów:

--------------------------------------------------------------------------------------------------------------------------

ReLU (Rectified Linear Units) layer

Można wprowadzić dodatkową warstwę ReLu pomiędzy warstwe konwolucji a pooling.

Normalizacja - operacji na obrazie polega na zamianie wszystkich ujemnych wartości na zero.

Wynik operacji warstwy ReLU dla wszystkich obrazków:

--------------------------------------------------------------------------------------------------------------------------

Oto jak wyglądają wszystkie warstwy razem:

Warstwy można powielać:

--------------------------------------------------------------------------------------------------------------------------

Full Connected Layer

Decyzja przynależności obrazka wejściowego do odpowiedniej klasy wyjściowej w przypadku obrazka idealnie spełniającego wymagania jednej z klas jest prosta.

Poniżej sieć jest skonstruowana do rozpoznawania X więc komórki z wartością 1 wykazują na wzorzec X.

Dla wzorca rozpoznającego O:

Rozpatrzmy przykład gdzie obrazek wejściowy nie jest jednoznaczny:

Ponieważ dla wzorcowego przypadku X i O wiemy, która połączenia neuronów prowadzą do które klasy obiektu, wyliczamy średnią wartość: poniżej jest to wartość .92: