Konwolucyjne sieci neuronowe wykorzystujące Keras i TPU

1. Omówienie

W tym module dowiesz się, jak połączyć warstwę splotową w model sieci neuronowej rozpoznającej kwiaty. Tym razem samodzielnie zbudujesz model od podstaw i wykorzystasz moc TPU, aby wytrenować go w kilku sekundach i powtarzać jego projekt.

Ten moduł zawiera niezbędne wyjaśnienia teorii dotyczące splotowych sieci neuronowych i jest dobrym punktem wyjścia dla deweloperów, którzy chcą poznać deep learning.

Ten moduł jest częścią 3. serii „Keras na TPU”. Możesz je wykonać w podanej kolejności lub niezależnie od siebie.

• Potoki danych o szybkości TPU: tf.data.Dataset i TFRecords
• Pierwszy model Keras z wykorzystaniem uczenia transferowego
• [THIS LAB] Splotowe sieci neuronowe wykorzystujące Keras i TPU
• Nowoczesne konwnety, squeezenet, Xception z wykorzystaniem Keras i TPU

Czego się nauczysz

• Aby utworzyć konwolucyjny klasyfikator obrazów za pomocą modelu Keras Sequential.
• Trenowanie modelu Keras na TPU
• Dostroj model, wybierając odpowiednie warstwy konwolucyjne.

Prześlij opinię

Jeśli zauważysz w tym laboratorium kodowania coś nie tak, daj nam znać. Opinię można przesłać, korzystając z formularza dotyczącego problemów na GitHubie [link do przesyłania opinii].

2. Krótki przewodnik po Google Colaboratory

Ten moduł wykorzystuje Google Collaboratory i nie wymaga żadnej konfiguracji. Colaboratory to internetowa platforma do tworzenia notatek przeznaczona do użytku edukacyjnego. Oferuje on bezpłatne szkolenie dotyczące procesora CPU, GPU i TPU.

Możesz otworzyć ten przykładowy notatnik i uruchomić kilka komórek, aby zapoznać się z Colaboratory.

Welcome to Colab.ipynb

Wybieranie backendu TPU

W menu Colab kliknij Środowisko wykonawcze > Zmień typ środowiska wykonawczego, a potem wybierz TPU. W tym module z kodem wykorzystasz potężną jednostkę TPU (Tensor Processing Unit) wyposażoną w procesor akceleracji sprzętowej. Połączenie ze środowiskiem wykonawczym zostanie nawiązane automatycznie przy pierwszym uruchomieniu. Możesz też użyć przycisku „Połącz” w prawym górnym rogu.

Wykonywanie notatnika

Uruchom po kolei komórki, klikając wybraną komórkę i naciskając klawisze Shift+ENTER. Aby uruchomić cały notatnik, możesz też kliknąć Środowisko wykonawcze > Uruchom wszystko.

Spis treści

Wszystkie notatniki mają spis treści. Możesz go otworzyć, klikając czarną strzałkę po lewej stronie.

Ukryte komórki

W niektórych komórkach będzie widoczny tylko tytuł. Jest to funkcja notatnika specyficzna dla Colab. Można je dwukrotnie kliknąć, aby zobaczyć w nich kod, ale zwykle nie jest to zbyt interesujące. Zwykle są to funkcje obsługi lub wizualizacji. Nadal musisz uruchomić te komórki, aby zdefiniować funkcje znajdujące się w nich.

Uwierzytelnianie

Colab może uzyskać dostęp do Twoich prywatnych zasobników Google Cloud Storage, jeśli uwierzytnisz się za pomocą autoryzowanego konta. Powyższy fragment kodu spowoduje uruchomienie procesu uwierzytelniania.

3. [INFO] Czym są jednostki Tensor Processing Unit (TPU)?

W skrócie

TPU to akceleratory sprzętowe specjalizujące się w zadaniach deep learning. Z tego modułu dotyczącego kodu dowiesz się, jak używać ich w przypadku Keras i TensorFlow 2. Cloud TPU są dostępne w konfiguracji podstawowej z 8 rdzeniami, a także w większych konfiguracjach zwanych „podstawami TPU” z maksymalnie 2048 rdzeniami. Dodatkowy sprzęt może przyspieszyć trenowanie przez zwiększenie rozmiaru wsadu do trenowania.

Kod do trenowania modelu w TPU w Keras (i korzystania z GPU lub CPU, jeśli jednostka TPU jest niedostępna):

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

Dzisiaj użyjemy TPU do tworzenia i optymalizowania klasyfikatora kwiatów w czasie rzeczywistym (trening trwający kilka minut).

Dlaczego TPU?

Nowoczesne procesory graficzne są zorganizowane wokół programowalnych „rdzeni”, czyli bardzo elastycznej architektury, która umożliwia im wykonywanie różnych zadań, takich jak renderowanie 3D, deep learning, symulacje fizyczne itp. TPU łączy klasyczny procesor wektorowy z dedykowaną jednostką mnożenia macierzy i doskonale sprawdza się w przypadku zadań, w których dominuje mnożenie dużych macierzy, np. w sieciach neuronowych.

Ilustracja: gęsta warstwa sieci neuronowej jako mnożenie macierzy z ośmioma obrazami przetwarzanymi przez sieć neuronową jednocześnie. Wykonaj mnożenie wiersza przez kolumnę, aby sprawdzić, czy rzeczywiście jest to ważona suma wszystkich wartości pikseli obrazu. Warstwy konwolucyjne można też przedstawić jako mnożenie macierzy, choć jest to nieco bardziej skomplikowane (wyjaśnienie w sekcji 1).

Sprzęt

MXU i VPU

Rdzeń TPU v2 składa się z jednostki mnożenia macierzy (MXU), która wykonuje mnożenie macierzy, oraz jednostki przetwarzania wektorów (VPU) do wykonywania wszystkich innych zadań, takich jak aktywacje, softmax itp. VPU obsługuje obliczenia float32 i int32. Z kolei moduł MXU działa w mieszanym, 16-32-bitowym formacie zmiennoprzecinkowym o mieszanej dokładności.

Mieszana precyzja zmiennoprzecinkowa i bfloat16

MXU oblicza mnożniki macierzy, używając danych wejściowych bfloat16 i danych wyjściowych float32. Zbiorcze gromadzenie danych jest wykonywane z dokładnością do float32.

Trenowanie sieci neuronowych jest zwykle odporne na szum generowany przez zmniejszoną precyzję liczby zmiennoprzecinkowej. W niektórych przypadkach szum może nawet pomóc optymalizatorowi w konwergencji. 16-bitowa precyzja zmiennoprzecinkowa jest tradycyjnie używana do przyspieszania obliczeń, ale formaty float16 i float32 mają bardzo różne zakresy. Zmniejszenie precyzji z float32 do float16 zazwyczaj skutkuje przekroczeniem i niedopuszczalnym przepływem. Rozwiązania istnieją, ale do poprawnego działania typu float16 zazwyczaj trzeba się przyłożyć.

Dlatego w procesorach TPU wprowadziliśmy format bfloat16. Jest to skrócona wersja typu float32 z tymi samymi bitami wykładniczymi i zakresem co typ float32. W związku z tym, że jednostki TPU mnożą macierz obliczeniową z mieszaną precyzją z danymi wejściowymi bfloat16, ale z danymi wyjściowymi float32, oznacza to, że zwykle nie trzeba wprowadzać żadnych zmian w kodzie, aby skorzystać ze zmniejszonej dokładności, aby uzyskać wzrost wydajności.

W jednostkach TPU domyślnie używana jest precyzja mieszanej parametrów bfloat16/float32. Włączenie tej funkcji nie wymaga zmiany kodu w Twoim kodzie Tensorflow. Nadal pracujesz z float32 w całym kodzie. Podczas wykonywania mnożenia macierzy TPU automatycznie skróci dane wejściowe do bfloat16. Wynikowa macierz to float32.

Tablica skurczowa

MXU implementuje mnożenie macierzy na sprzęcie, korzystając z tzw. architektury „mnożnika systolicznego”, w której elementy danych przepływają przez tablicę jednostek obliczeniowych sprzętowych. (W medycynie termin „skurczowy” odnosi się do skurczów serca i przepływu krwi, a tutaj mówimy o przepływie danych.

Podstawowym elementem mnożenia macierzy jest iloczyn skalarny wiersza jednej macierzy i kolumny drugiej macierzy (patrz ilustracja na początku tej sekcji). W przypadku mnożenia macierzy Y=X*W jeden element wyniku będzie miał postać:

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

W przypadku GPU zaprogramowano ten iloczyn skalarny na „rdzeń” GPU, a następnie uruchamiał go równolegle na dowolnej liczbie dostępnych rdzeni, aby spróbować naraz obliczyć wszystkie wartości wynikowej macierzy. Jeśli wynikowa matryca ma rozmiar 128 x 128, wymaga to dostępności 128 x 128 = 16 tys. „rdzeni”, co zwykle jest niemożliwe. Największe procesory graficzne mają około 4000 rdzeni. Z drugiej strony TPU używa minimalnej ilości sprzętu dla jednostek obliczeniowych w MXU: tylko bfloat16 x bfloat16 => float32 mnożniki i akumulatory, nic więcej. Są one tak małe, że TPU może umieścić ich 16 KB w rozmiarze 128 x 128 MXU i przetworzyć to mnożenie macierzy za jednym razem.

Ilustracja: macierz skurczowa MXU. Elementy obliczeniowe to mnożniki akumulacji. Wartości jednej macierzy są ładowane do tablicy (czerwone kropki). Wartości z innej macierzy przepływają przez tablicę (szare kropki). Linie pionowe rozprzestrzeniają wartości w górę. Linie poziome rozprzestrzeniają sumy częściowe. Użytkownik musi samodzielnie sprawdzić, czy dane przepływające przez tablicę dają wynik mnożenia macierzy, który jest zwracany po prawej stronie.

Poza tym, chociaż iloczyn skalarny są obliczane na MXU, sumy pośrednie przepływają po prostu między sąsiednimi jednostkami obliczeniowymi. Nie trzeba ich przechowywać ani pobierać do/z pamięci czy nawet do pliku rejestru. W efekcie architektura układów skurczowych TPU charakteryzuje się znaczną gęstością i mocą, a przy mnożeniu macierzy ma istotny wzrost szybkości w porównaniu z GPU.

Cloud TPU

Gdy poprosisz o „Cloud TPU v2” na Google Cloud Platform, otrzymasz maszynę wirtualną (VM) z kartą TPU podłączoną przez interfejs PCI. Karta TPU ma 4 podwójne rdzenie TPU. Każdy rdzeń TPU obejmuje jednostkę VPU (Vector Processing Unit) i jednostkę mnożenia matriX o wymiarach 128 x 128 MXU. Ta „Cloud TPU” jest wtedy zazwyczaj połączona przez sieć z maszyną wirtualną, która jej zażądała. Pełny obraz wygląda więc tak:

Ilustracja: maszyna wirtualna z akceleratorem „Cloud TPU” podłączonym do sieci. „Cloud TPU” składa się z maszyny wirtualnej z kartą TPU podłączoną do gniazda PCI z 4 podwójnymi rdzeniami TPU.

podsumowanie TPU

W centrach danych Google jednostki TPU są połączone z połączeniami międzysieciowymi o wysokiej wydajności (HPC), co może sprawić, że będą one postrzegane jako jeden bardzo duży akcelerator. Google nazywa je podami i mogą one obejmować do 512 rdzeni TPU v2 lub 2048 rdzeni TPU v3.

Ilustracja: pod TPU v3. Płyty TPU i szafy rackowe połączone przez połączenie HPC.

Podczas trenowania gradienty są wymieniane między rdzeniami TPU przy użyciu algorytmu all-reduce ( dobre wyjaśnienie funkcji all-reduce znajdziesz tutaj). Wytrenowany model może wykorzystywać możliwości sprzętowe przez trenowanie na dużych wielkościach wsadu.

Ilustracja: synchronizacja gradientów podczas treningu za pomocą algorytmu all-reduce w 2D sieci HPC z siatką toroidalną na Google TPU.

Oprogramowanie

Szkolenie z dużą liczbą elementów w sasdzie

Idealny rozmiar wsadu dla jednostek TPU to 128 elementów danych na rdzeń TPU, ale sprzęt może już wykazywać dobre wykorzystanie z 8 elementów danych na rdzeń TPU. Pamiętaj, że jedna z Cloud TPU ma 8 rdzeni.

W tym laboratorium kodu będziemy używać interfejsu Keras API. W Keras określona wsad jest reprezentowana przez globalny rozmiar wsadu dla całej jednostki TPU. Wsady zostaną automatycznie podzielone na 8 i będą uruchamiane w 8 rdzeniach TPU.

Więcej wskazówek dotyczących wydajności znajdziesz w przewodniku po wydajności TPU. W przypadku niektórych modeli należy zachować szczególną ostrożność w przypadku bardzo dużych wsadów. Więcej informacji znajdziesz w artykule LARSOptimizer.

Na zapleczu: XLA

Programy Tensorflow definiują grafy obliczeniowe. TPU nie uruchamia bezpośrednio kodu Pythona, tylko wykonuje obliczenia zdefiniowane przez program Tensorflow. W tle kompilator XLA (kompilator przyspieszonej algebry liniowej) przekształca graf Tensorflow z węzłami obliczeniowymi w kod maszynowy TPU. Ten kompilator przeprowadza też wiele zaawansowanych optymalizacji kodu i układu pamięci. Kompilacja odbywa się automatycznie, gdy dane są przesyłane do TPU. Nie musisz dodawać XLA do łańcucha tworzenia.

Ilustracja: aby działał w TPU, graf obliczeniowy zdefiniowany w programie Tensorflow jest najpierw przekształcany w reprezentację formatu XLA (przyspieszonego kompilatora algebry liniowej), a następnie skompilowany przez XLA do kodu maszynowego TPU.

Korzystanie z TPU w Keras

Jednostki TPU są obsługiwane przez interfejs Keras API od Tensorflow 2.1. Obsługa Keras działa na TPU i podach TPU. Ten przykład działa z użyciem TPU, GPU i CPU:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

W tym fragmencie kodu:

• TPUClusterResolver().connect() znajduje TPU w sieci. Działa bez parametrów w większości systemów Google Cloud (zadań na AI Platform, Colaboratory, Kubeflow, maszyn wirtualnych do deep learningu utworzonych za pomocą narzędzia „ctpu up”). Te systemy wiedzą, gdzie znajduje się ich TPU dzięki zmiennej środowiskowej TPU_NAME. Jeśli tworzysz TPU ręcznie, ustaw zmienną środowiska TPU_NAME w maszynie wirtualnej, w której jej używasz, lub wywołaj funkcję TPUClusterResolver z jawnymi parametrami: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy to część, która wdraża rozkład i algorytm synchronizacji gradientowej „all-reduce”.
• Strategia jest stosowana w ramach zakresu. Model musi być zdefiniowany w zakresie strategii (zakres).
• Funkcja tpu_model.fit oczekuje obiektu tf.data.Dataset jako danych wejściowych do trenowania na TPU.

Częste zadania związane z przenoszeniem aplikacji na TPU

• Dane do modelu Tensorflow można wczytywać na wiele sposobów, ale w przypadku TPU wymagane jest użycie interfejsu tf.data.Dataset API.
• TPU są bardzo szybkie, a pozyskiwanie danych często staje się wąskim gardłem działające na nich. W przewodniku po wydajności TPU znajdziesz narzędzia, które pomogą Ci wykrywać wąskie gardła danych i korzystać z innych wskazówek dotyczących wydajności.
• Wartości int8 i int16 są traktowane jako int32. TPU nie ma sprzętu z liczbami całkowitymi działającymi na mniej niż 32 bitach.
• Niektóre operacje Tensorflow nie są obsługiwane. Listę znajdziesz tutaj. Dobra wiadomość jest taka, że to ograniczenie dotyczy tylko kodu treningowego, czyli przejść do przodu i do tyłu przez model. Nadal możesz używać wszystkich operacji Tensorflow w potoku danych wejściowych, ponieważ będą one wykonywane na CPU.
• Model tf.py_func nie jest obsługiwany przez TPU.

4. [INFO] Klasyfikator sieci neuronowych 101

W skrócie

Jeśli znasz już wszystkie terminy w pogrubieniu w następnym akapicie, możesz przejść do następnego ćwiczenia. Jeśli dopiero zaczynasz korzystać z głębokiego uczenia się, czytaj dalej.

Klasyfikator sieci neuronowej składa się z kilku warstw neuronów. W przypadku klasyfikacji obrazów mogą to być warstwy gęste, a częściej konwolucyjne. Zazwyczaj aktywuje się je za pomocą funkcji aktywacji relu. Ostatnia warstwa używa tylu neuronów, ile jest klas, i jest aktywowana za pomocą funkcji softmax. W przypadku klasyfikacji entropia międzynarodowa to najczęściej wykorzystywana funkcja straty, która porównuje jedno gorące etykiety (tzn. poprawne odpowiedzi) z prawdopodobnymi prawdopodobieństwami przewidzianymi przez sieć neuronowa. Aby zminimalizować straty, najlepiej wybrać optymalizatora dynamiczny, np. AdamOptimizer, i trenować na grupach obrazów i etykiet do trenowania.

W przypadku modeli utworzonych jako sekwencja warstw Keras oferuje interfejs Sequential API. Na przykład klasyfikator obrazów korzystający z 3 gęstych warstw można napisać w Keras w ten sposób:

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

Gęsta sieć neuronowa

Jest to najprostsza sieć neuronowa do klasyfikowania obrazów. Składa się z „neuronów” ułożonych w warstwach. Pierwsza warstwa przetwarza dane wejściowe, a potem wprowadza dane wyjściowe do innych warstw. Nazywa się ją „gęstą”, ponieważ każdy neuron jest połączony ze wszystkimi neuronami w poprzedniej warstwie.

Można przekazać obraz do takiej sieci, spłaszczając wartości RGB wszystkich jego pikseli do długiego wektora i używając go jako danych wejściowych. Nie jest to najlepsza metoda rozpoznawania obrazów, ale postaramy się ją ulepszyć.

Neurony, aktywacje, RELU

„Neuron” oblicza ważoną sumę wszystkich swoich wejść, dodaje wartość zwaną „uśrednieniem” i przekazuje wynik przez tak zwaną „funkcję aktywacji”. Wagi i odchylenia są na początku nieznane. Zostaną one zainicjowane losowo i „nauczone” przez trenowanie sieci neuronowej na podstawie wielu znanych danych.

Najpopularniejszą funkcją aktywacji jest RELU (prostej jednostki liniowej). Jest to bardzo prosta funkcja, jak widać na wykresie powyżej.

Aktywacja softmaxa

Sieć kończy się warstwą 5-neuronową, ponieważ kwiaty są klasyfikowane do 5 kategorii (róża, tulipan, mniszek lekarski, stokrotka, słonecznik). Neurony w warstwach pośrednich są aktywowane za pomocą klasycznej funkcji aktywacji RELU. Na ostatniej warstwie chcemy jednak obliczyć liczby z zakresu od 0 do 1, które reprezentują prawdopodobieństwo, że dany kwiat to róża, tulipan itd. W tym celu użyjemy funkcji aktywacji o nazwie „softmax”.

Zastosowanie softmaxa do wektora polega na podniesieniu każdego elementu do potęgi, a następnie znormalizowaniu wektora, zwykle przy użyciu normy L1 (suma wartości bezwzględnych), tak aby wartości sumowały się do 1 i mogły być interpretowane jako prawdopodobieństwa.

Dlaczego „softmax” nazywa się softmax? Funkcja wykładnicza jest funkcją o stromym tempie. Zwiększy to różnice między wyjściowymi neuronami. Następnie, gdy sprowadzisz wektor do postaci zwyczajnej, największy element, który dominuje w normie, zostanie sprowadzony do wartości zbliżonej do 1, a wszystkie pozostałe elementy zostaną podzielone przez dużą wartość i sprowadzone do wartości zbliżonej do 0. Wynikowy wektor wyraźnie wskazuje, która klasa jest zwycięska, czyli „maksymalna”, ale zachowuje pierwotny względny porządek wartości, stąd „miękki”.

Entropia krzyżowa

Teraz, gdy nasza sieć neuronowa generuje prognozy na podstawie danych wejściowych, musimy zmierzyć, jak dobre są te prognozy, czyli odległość między tym, co mówi nam sieć, a prawidłowymi odpowiedziami, które często nazywamy „etykietami”. Pamiętaj, że wszystkie obrazy w zbiorze danych mają prawidłowe etykiety.

Każda odległość byłaby odpowiednia, ale w przypadku problemów z klasyfikacją najskuteczniejsza jest tak zwana „odległość krzyżowa”. Nazywamy ją błędem lub funkcją „straty”:

Kodowanie „One-hot” oznacza, że etykietę „3) dandelion” reprezentujesz za pomocą wektora o 5 wartościach, wszystkie zera z wyjątkiem 3 wartości, która jest równa 1. Ten wektor reprezentuje 100% prawdopodobieństwo, że jest to mlecz. Nasza sieć neuronowa również generuje prognozy w postaci wektora 5 wartości prawdopodobieństwa. Można je łatwo porównać.

Efekt gradientu

„Trenowanie” sieci neuronowej oznacza w istocie korzystanie z obrazów i etykietek treningowych w celu dostosowania wag i uprzedzeń, aby zminimalizować funkcję straty entropii krzyżowej. Działa to w następujący sposób.

Entropia krzyżowa jest funkcją wag, przesunięć, pikseli obrazu treningowego i jego znanej klasy.

Jeśli obliczamy częściowe pochodne entropii krzyżowej względem wszystkich wag i wszystkich odchyleń, uzyskujemy „gradient” obliczony dla danego obrazu, etykiety oraz bieżącej wartości wag i odchylenia. Pamiętaj, że możemy mieć miliony wag i odchyleń, więc obliczenie gradientu wymaga sporo wysiłku. Na szczęście Tensorflow robi to za nas. Matematyczną właściwością gradientu jest to, że wskazuje on „do góry”. Ponieważ chcemy uzyskać wartość entropii krzyżowej zbliżoną do zera, idziemy w przeciwnym kierunku. Aktualizujemy wagi i uświadczenia o części nachylenia. Następnie powtarzamy ten sam proces wielokrotnie, używając kolejnych partii obrazów i etykiet do treningu. Mamy nadzieję, że zjawisko to zbiega się w miejsce, w którym entropia krzyżowa jest minimalna, ale nic nie gwarantuje, że te minimum jest unikalne.

„Tempo uczenia się”: nie możesz aktualizować wag i uprzedzeń o całą długość gradientu przy każdej iteracji. To tak, jakby próbować dotrzeć na dno doliny w butach siedmiomilowych. Przeskakiwanie z jednej strony doliny na drugą. Aby dotrzeć na sam dół, musisz wykonać mniejsze kroki, np. użyć tylko części gradientu, zazwyczaj z zakresu 1/1000. Ta iloraz nazywa się „stopą uczenia się”.

Krótkie partie i pęd

Możesz obliczyć gradient na podstawie tylko jednego przykładowego obrazu i natychmiast zaktualizować wagi i uświadczenia, ale wykonanie tego na przykładzie 128 obrazów daje gradient, który lepiej odzwierciedla ograniczenia narzucone przez różne przykładowe obrazy, a zatem prawdopodobnie szybciej zbliża się do rozwiązania. Wielkość minigrupy, którą można dostosować, jest parametrem.

Ta technika, czasami nazywana „stochastycznym gradientem”, ma jeszcze jedną, bardziej pragmatyczną korzyść: praca z wsadami oznacza również pracę z większymi matrycami, które zwykle można łatwiej zoptymalizować w przypadku układów GPU i TPU.

Konwergencja może być jednak nieco chaotyczna i może nawet się zatrzymać, jeśli wektor gradientu składa się wyłącznie z zer. Czy to oznacza, że znaleźliśmy minimum? Nie zawsze. Składowa gradientu może być równa 0 w przypadku wartości minimalnej lub maksymalnej. W przypadku wektora gradientu zawierającego miliony elementów, jeśli wszystkie są zerami, prawdopodobieństwo, że wszystkie zera odpowiadają minimum, a żadne z nich nie odpowiadają punktowi maksimum, jest dość małe. W wielowymiarowej przestrzeni punkty siodła są dość powszechne i nie chcemy się na nich zatrzymywać.

Ilustracja: siodło Gradient wynosi 0, ale nie jest on minimalny we wszystkich kierunkach. (źródło obrazu: Wikimedia: By Nicoguaro - Own work, CC BY 3.0)

Rozwiązaniem jest dodanie algorytmowi optymalizacji pewnej dynamiki, aby mógł on omijać punkty spoczynku bez zatrzymywania się.

Biblioteka Tensorflow udostępnia całą gamę optymalizatorów, począwszy od tf.train.GradientDescentOptimizer. Bardziej zaawansowani i popularni optymalizatorzy, którzy są już na tym etapie rozwoju, to tf.train.RMSPropOptimizer lub tf.train.AdamOptimizer.

Słownik

zbiorcze lub miniwsadowe: trenowanie jest zawsze wykonywane na grupach danych i etykiet do trenowania. Pomaga to algorytmowi w konwergencji. Wymiar „batch” jest zwykle pierwszym wymiarem tensorów danych. Na przykład tensor kształtu [100, 192, 192, 3] zawiera 100 obrazów o wymiarach 192 x 192 piksele, z 3 wartościami na piksel (RGB).

Utrata entropii krzyżowej: specjalna funkcja straty często używana w klasyfikatorach.

warstwy gęste: warstwa neuronów, w której każdy neuron jest połączony ze wszystkimi neuronami z poprzedniej warstwy.

Cechy: dane wejściowe sieci neuronowej są czasami nazywane „cechami”. Sztuka określania, które części zbioru danych (lub ich kombinacje) należy podać do sieci neuronowej, aby uzyskać dobre prognozy, nazywana jest „inżynierią cech”.

labels: inna nazwa „zajęć” lub poprawne odpowiedzi w zadaniu z klasyfikacją nadzorowaną.

tempo uczenia się: ułamek gradientu, za pomocą którego wagi i uśrednienia są aktualizowane przy każdej iteracji pętli treningowej.

Logity: wyjścia warstwy neuronów przed zastosowaniem funkcji aktywacyjnej nazywane są „logitami”. Termin pochodzi od „funkcji logistycznej”, nazywanej też „funkcją sigmoidalną”, która kiedyś była najpopularniejszą funkcją aktywacyjną. „Neuron outputs before logistic function” (Wyjścia neuronu przed funkcją logistycznej) zostało skrócone do „logitów”.

loss: funkcja błędu porównująca wyniki sieci neuronowej z poprawnymi odpowiedziami.

neuron: oblicza ważony ciąg danych wejściowych, dodaje odchylenie i przekazuje wynik przez funkcję aktywacji.

Kodowanie jednoelementowe: klasa 3 z 5 jest zakodowana jako wektor o 5 elementach, wszystkie zera z wyjątkiem 3 elementu, który ma wartość 1.

relu: skorygowana jednostka liniowa. Popularna funkcja aktywacji neuronów.

sigmoid: inna funkcja aktywacji, która była kiedyś popularna i przydaje się w szczególnych przypadkach.

softmax: specjalna funkcja aktywacji, która działa na wektorze, zwiększa różnicę między największym składnikiem a wszystkimi pozostałymi, a także normalizuje wektor, aby jego suma wynosiła 1, dzięki czemu można go interpretować jako wektor prawdopodobieństw. Jest używany jako ostatni krok w klasyfikatorach.

tensor: „tensor” jest jak macierz, ale z dowolną liczbą wymiarów. Jednowymiarowy tensor to wektor. Tensor dwuwymiarowy to macierz. Tensory mogą mieć 3, 4, 5 lub więcej wymiarów.

5. [NOWE INFORMACJE] Konwolucyjne sieci neuronowe

W skrócie

Jeśli znasz już wszystkie terminy w pogrubieniu w następnym akapicie, możesz przejść do następnego ćwiczenia. Jeśli dopiero zaczynasz korzystać z konwolucyjnych sieci neuronowych, czytaj dalej.

Ilustracja: filtrowanie obrazu za pomocą dwóch kolejnych filtrów, z których każdy składa się z 4 x 4 x 3 = 48 wagi do nauczenia

Konwolucyjne sieci neuronowe stosują do wejściowego obrazu serię filtrów uczących się. Warstwę konwolucyjną definiuje rozmiar filtra (lub jądra), zastosowana liczba filtrów oraz skok. Wejście i wyjście warstwy splotu mają 3 wymiary (szerokość, wysokość, liczba kanałów), zaczynając od obrazu wejściowego (szerokość, wysokość, kanały RGB). Podczas układania warstw splotowych szerokość i wysokość wyników można dostosować za pomocą kroku >1 lub operacji maksymalnego pulowania. Głębokość danych wyjściowych (nb kanałów) jest dostosowywana za pomocą większej lub mniejszej liczby filtrów.

Tak wygląda prosta splotowa sieć neuronowa w Keras:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

Konwolucyjne sieci neuronowe 101

W warstwie sieci splotowej jeden „neuron” dokonuje ważonej sumy pikseli znajdujących się tuż nad nią i obejmuje tylko mały obszar obrazu. Dodaje odchylenie i dostarcza sumę przez funkcję aktywacji, tak jak neuron w regularnej gęstej warstwie. Następnie operacja jest powtarzana w całym obrazie przy użyciu tych samych wag. Pamiętaj, że w gęstych warstwach każdy neuron miał własne wagi. Tutaj pojedynczy „patch” wag przesuwa się po obrazie w obu kierunkach („sprzężenie”). Dane wyjściowe mają tyle wartości, ile jest pikseli na obrazie (chociaż na krawędziach wymagane jest pewne wypełnienie). Jest to operacja filtrowania, która wykorzystuje filtr o wagach 4 x 4 x 3 = 48.

48 wag nie wystarczy. Aby dodać więcej stopni swobody, powtarzamy tę samą operację z nowym zestawem wag. Spowoduje to wygenerowanie nowego zbioru wyników filtrowania. Nazwijmy go „kanałem” wyjścia w analogii z kanałami R, G i B na obrazie wejściowym.

Dwa (lub więcej) zestawów wag można zsumować jako jeden tensor, dodając nowy wymiar. Dzięki temu otrzymujemy ogólny kształt tensora wag dla warstwy konwolucyjnej. Ponieważ liczba kanałów wejściowych i wyjściowych jest parametrami, możemy zacząć porządkować i łączyć splotowe warstwy.

Ilustracja: splotowa sieć neuronowa przekształca „sześciany” danych w inne „sześciany” danych.

Sploty rozproszone, maksymalna liczba pulsu

Wykonując sploty z krokową wielkością 2 lub 3, możemy też zmniejszyć powstały sześcian danych w kierunkach poziomych. Można to zrobić na 2 sposoby:

• Splot liniowy: filtr przesuwany jak powyżej, ale z krokiem >1
• Maksymalne łączenie w ramach: przesuwane okno z operacją MAX (zwykle przy 2 × 2 poprawkach, powtarzane co 2 piksele).

Ilustracja: przesunięcie okna obliczeniowego o 3 piksele powoduje zmniejszenie liczby wartości wyjściowych. Konwolucje skokowe lub maksymalne złączanie (maksimum w oknie 2 x 2 przesuwanym o krok 2) to sposób na zmniejszenie sześcianu danych w wymiarach poziomych.

Operacja maksymalizacji zagęszczenia pomaga nam intuicyjnie zrozumieć, jak działają sieci konwolucyjne: jeśli założymy, że podczas treningu łaty wag przekształcają się w filtry, które rozpoznają podstawowe kształty (linie poziome i pionowe, krzywe itp.), to jednym ze sposobów na wyodrębnienie przydatnych informacji jest przechowywanie na poszczególnych warstwach wyników, w których przypadku kształt został rozpoznany z maksymalnie intensywnością. W praktyce w warstwie maksymalnej wielkości neuronów dane wyjściowe neuronów są przetwarzane w grupach 2 x 2 i zachowywana jest tylko wartość maksymalna.

Klasyfikator synwolucyjny

Na koniec dołączamy blok klasyfikacji, spłaszając ostatnią kostkę danych i przesyłając ją przez gęstą warstwę aktywowaną za pomocą softmaxa. Typowy klasyfikator splotowy może wyglądać tak:

Ilustracja: klasyfikator obrazów korzystający z warstw konwolucyjnych i softmax. Używa filtrów 3 x 3 i 1 x 1. Warstwy maxpool wybierają maksymalną wartość grup 2 x 2 punktów danych. Głowica klasyfikacyjna jest implementowana za pomocą gęstej warstwy z aktywacją softmax.

W Keras

Przedstawioną wyżej warstwę konwolucyjną można zaimplementować w Keras w ten sposób:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

Parametr dopełnienia w warstwach splotowych może mieć 2 wartości:

• "same": wypełnienie ze zerami, co pozwala uzyskać dane wyjściowe o takiej samej szerokości/wysokości jak dane wejściowe
• „valid”: brak wypełnienia, używane są tylko prawdziwe piksele.

6. Twoja własna sieć konwolucyjna

Ćwiczenia praktyczne

Pomożemy Ci zbudować i wytrenować konwolucyjną sieć neuronową od podstaw. Użycie TPU pozwoli nam bardzo szybko wprowadzać poprawki. Otwórz ten notatnik, uruchom komórki (Shift-Enter) i postępuj zgodnie z instrukcjami, które pojawiają się w miejscach oznaczonych etykietą „WYMAGANE DZIAŁANIA”.

Keras_Flowers_TPU (playground).ipynb

Celem jest osiągnięcie dokładności większej niż 75%, jaką osiąga model uczenia się przenoszonego. Ten model ma tę zaletę, że został wstępnie wytrenowany na zbiorze danych składających się z milionów obrazów, podczas gdy mamy tutaj tylko 3670 obrazów. Czy możesz przynajmniej dopasować?

Informacje dodatkowe

Ile warstw i jaka jest ich rozmiar?

Wybór rozmiarów warstw to coś więcej niż sztuka. Trzeba znaleźć równowagę między zbyt małą liczbą parametrów a zbyt dużą liczbą parametrów (wag i uprzedzeń). Przy zbyt małej wadze sieć neuronowa nie jest w stanie reprezentować złożoności kształtów kwiatów. Zbyt duża ich liczba może powodować nadmierne dopasowanie, czyli brak specjalizacji w obrazach szkoleniowych i brak uogólnień. Przy dużej liczbie parametrów model będzie się też wolno trenować. W Keras funkcja model.summary() wyświetla strukturę i liczbę parametrów modelu:

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

Kilka wskazówek:

• O skuteczności „głębokich” sieci neuronowych decyduje posiadanie wielu warstw. W przypadku tego prostego problemu polegającego na rozpoznawaniu kwiatów wystarczy 5–10 warstw.
• Używaj małych filtrów. Zazwyczaj filtry 3 x 3 sprawdzają się wszędzie.
• Można też stosować tanie filtry 1 x 1. W rzeczywistości nie „filtrują” niczego poza tym, że obliczają liniowe kombinacje kanałów. Przeplataj je z prawdziwymi filtrami. (Więcej informacji o konwolucjach 1 x 1 znajdziesz w następnej sekcji).
• W przypadku takiego problemu klasyfikacji należy często stosować interpolację redukcyjną za pomocą warstw maksymalnego złączenia (lub splotów z krokiem >1). Nie interesuje Cię, gdzie znajduje się kwiat, tylko to, czy jest to róża czy stokrotka, więc utrata informacji x i y nie jest ważna, a filtrowanie mniejszych obszarów jest tańsze.
• Liczba filtrów zwykle staje się podobna do liczby klas na końcu sieci (dlaczego? Zobacz poniżej trik „średnia globalna w pulacji”). Jeśli klasyfikujesz obrazy w setki klas, stopniowo zwiększaj liczbę filtrów w kolejnych warstwach. W przypadku zbioru danych o kwiatach z 5 klasami filtrowanie za pomocą tylko 5 filtrów nie wystarczy. W większości warstw możesz użyć tej samej liczby filtrów, np. 32, a pod koniec ją zmniejszyć.
• Ostatnie gęste warstwy są kosztowne. Może on mieć więcej wag niż wszystkie warstwy konwolucyjne łącznie. Na przykład nawet przy bardzo rozsądnym wyjściu z ostatniego sześcianu danych o wymiarach 24 x 24 x 10 punktów danych gęsty warstwa z 100 neuronami będzie kosztować 24 x 24 x 10 x 100 = 576 000 wag. Staraj się być rozważny lub spróbuj globalnego średniego złączenia (patrz poniżej).

Globalny pulowanie średniej

Zamiast stosowania drogiej gęstej warstwy na końcu sieci neuronowej skoncentrowanej na konwolucjach możesz podzielić przychodzące dane na tyle części, ile masz klas, a potem z ich wartości wyliczyć średnią i przekazać je do funkcji aktywacji softmax. Ten sposób tworzenia głowicy klasyfikacji nie wymaga żadnych wag. W Keras składnia to tf.keras.layers.GlobalAveragePooling2D().

Konwolucyjne sieci neuronowe wykrywają lokalizację obiektów. Gdy filtr silnie reaguje na pewną cechę, dzieje się tak w konkretnej lokalizacji x,y. W zależności od tego, co chcesz zrobić, sieć neuronowa można wytrenować tak, aby używała lub odrzucała te dane o lokalizacji. Użycie globalnej puli średniej powoduje jawne odrzucenie wszystkich danych o lokalizacji. Może to być odpowiednie w przypadku klasyfikatora kwiatów, ale nie w przypadku innych zadań, takich jak zliczanie kwiatów na obrazie. Używaj z rozwagą.

Rozwiązanie

Oto notatnik z rozwiązaniem. Możesz z niego skorzystać, jeśli utkniesz.

Keras_Flowers_TPU (solution).ipynb

Omówione zagadnienia

• 🤔 Zabawa z warstwami konwolucyjnymi
• 🤓 Eksperymentujesz z maksymalną liczbą basenów, krokami, globalnymi wspólnymi pulami...
• 😀 powtórzono szybkie rozwiązanie na rzeczywistym modelu z TPU

Poświęć chwilę na zapoznanie się z tą listą kontrolną.

7. Gratulacje!

Udało Ci się zbudować pierwszą nowoczesną splotową sieć neuronową i wytrenować ją do ponad 80% dokładności, a dzięki TPU – już w kilka minut. Przejdź do następnego modułu, aby poznać nowoczesne architektury splotowe:

• Potoki danych o szybkości TPU: tf.data.Dataset i TFRecords
• Twój pierwszy model Keras z nauką przenoszenia
• [THIS LAB] Splotowe sieci neuronowe wykorzystujące Keras i TPU
• Nowoczesne konwnety, squeezenet, Xception z wykorzystaniem Keras i TPU

TPU w praktyce

Układy TPU i GPU są dostępne w Cloud AI Platform:

• na maszynach wirtualnych deep learning.
• W notatkach w AI Platform
• w zadaniach AI Platform Training,

Na koniec – chętnie poznamy Twoją opinię. Poinformuj nas, jeśli zauważysz w tym module coś nie tak lub jeśli uważasz, że można go ulepszyć. Opinię można przesłać, korzystając z formularza dotyczącego problemów na GitHubie [link do przesyłania opinii].

Autor: Martin Görner Twitter: @martin_gorner

www.tensorflow.org