Globalne łączenie w konwolucyjnych sieciach neuronowych
Wstęp
Od pewnego czasu operacje łączenia są podstawą splotowych sieci neuronowych. Podczas gdy procesy takie jak maksymalne łączenie i średnie łączenie często zajmują centralne miejsce, ich mniej znani kuzyni, globalne łączenie maksymalnych i średnich globalnych, stały się równie ważne. W tym artykule będziemy badać, na czym polegają globalne warianty dwóch powszechnych technik łączenia zasobów i jak można je porównać ze sobą.
# article dependencies
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import torchvision.datasets as Datasets
from torch.utils.data import Dataset, DataLoader
import numpy as np
import matplotlib.pyplot as plt
import cv2
from tqdm.notebook import tqdm
import seaborn as sns
from torchvision.utils import make_grid
if torch.cuda.is_available():
device = torch.device('cuda:0')
print('Running on the GPU')
else:
device = torch.device('cpu')
print('Running on the CPU')
Warunki wstępne
- Podstawowe zrozumienie sieci CNN: znajomość architektury sieci CNN, w tym warstw takich jak warstwy splotowe, pulowe i w pełni połączone.
- Koncepcje łączenia danych: znajomość typowych technik łączenia danych (np. łączenia maksymalnego, łączenia średniego) stosowanych w celu zmniejszenia wymiarów przestrzennych w sieciach CNN.
- Algebra liniowa i operacje na tensorach: Zrozumienie operacji na macierzach i manipulacji tensorami, ponieważ globalne łączenie obejmuje redukcję wielowymiarowego tensora do niższego wymiaru.
- Funkcje aktywacji: podstawowa wiedza o tym, jak funkcje aktywacji (np. ReLU, sigmoid) wpływają na cechy wyodrębniane przez warstwy CNN.
- Umiejętność korzystania z frameworka: doświadczenie w zakresie frameworków do głębokiego uczenia się, takich jak TensorFlow lub PyTorch, szczególnie we wdrażaniu niestandardowych warstw łączenia zasobów.
Klasyczna splotowa sieć neuronowa
Wielu początkujących w dziedzinie widzenia komputerowego często zapoznaje się ze splotowymi sieciami neuronowymi jako idealną siecią neuronową dla danych obrazu, ponieważ zachowuje ona strukturę przestrzenną obrazu wejściowego podczas uczenia się/wydobywania z nich funkcji. W ten sposób jest w stanie nauczyć się zależności między sąsiednimi pikselami a położeniem obiektów na obrazie, dzięki czemu jest to bardzo wydajna sieć neuronowa.
Perceptron wielowarstwowy działałby również w kontekście klasyfikacji obrazu, ale jego wydajność ulegnie znacznemu pogorszeniu w porównaniu z jego odpowiednikiem w sieci po prostu dlatego, że natychmiast niszczy strukturę przestrzenną obrazu poprzez jego spłaszczenie/wektoryzację, usuwając w ten sposób większość relacji między sąsiednimi pikseli.
Kombinacja ekstraktora funkcji i klasyfikatora
Wiele klasycznych splotowych sieci neuronowych jest w rzeczywistości kombinacją sieci konwolucyjnych i MLP. Patrząc na przykład na architektury LeNet i AlexNet, wyraźnie widać, że ich architektury to tylko kilka warstw splotu z dołączonymi na końcu warstwami liniowymi.
Ta konfiguracja ma wiele sensu, pozwoliła warstwom splotu robić to, co potrafią najlepiej, czyli wyodrębniać cechy z danych o dwóch wymiarach przestrzennych. Następnie wyodrębnione cechy są przekazywane na warstwy liniowe, dzięki czemu mogą one również robić to, w czym są świetne, czyli znajdować relacje między wektorami cech i celami.
Błąd w projekcie
Problem z tym projektem polega na tym, że warstwy liniowe mają bardzo dużą skłonność do nadmiernego dopasowania do danych. Aby złagodzić ten problem, wprowadzono regularyzację przerywania nauki, ale mimo to pozostał on problemem. Co więcej, w przypadku sieci neuronowej, która szczyci się tym, że nie niszczy struktur przestrzennych, klasyczna sieć i tak to zrobiła, choć głębiej w sieć i w mniejszym stopniu.
Nowoczesne rozwiązania klasycznego problemu
Aby zapobiec problemowi nadmiernego dopasowania w sieciach konwekcyjnych, logicznym następnym krokiem po próbie regularyzacji porzucania było całkowite pozbycie się wszystkich warstw liniowych. Jeśli warstwy liniowe mają zostać wykluczone, należy poszukiwać zupełnie nowego sposobu próbkowania map obiektów w dół i tworzenia reprezentacji wektorowej o rozmiarze równym liczbie rozpatrywanych klas. Właśnie w tym miejscu pojawia się globalne łączenie zasobów.
Rozważmy zadanie klasyfikacji składające się z 4 klas, podczas gdy warstwy splotu 1 x 1 pomogą w próbkowaniu map obiektów w dół, aż będzie ich 4, globalne łączenie pomoże stworzyć reprezentację wektorową o długości 4 elementów, która może być następnie wykorzystana przez funkcję straty w obliczanie gradientów.
Globalne średnie łączenie
Wciąż pracując nad tym samym zadaniem klasyfikacji opisanym powyżej, wyobraźmy sobie scenariusz, w którym naszym zdaniem nasze warstwy splotu znajdują się na odpowiedniej głębokości, ale mamy 8 map obiektów o rozmiarze (3, 3). Możemy wykorzystać warstwę splotu 1 x 1, aby zmniejszyć próbkowanie 8 map obiektów do 4. Teraz mamy 4 macierze o rozmiarze (3, 3), podczas gdy tak naprawdę potrzebujemy wektora 4 elementy.
Jednym ze sposobów uzyskania 4-elementowego wektora z tych map obiektów jest obliczenie średniej wszystkich pikseli na każdej mapie obiektów i zwrócenie jej jako pojedynczego elementu. Zasadniczo na tym polega globalne łączenie średnich zasobów.
Globalne maksymalne łączenie
Podobnie jak w powyższym scenariuszu, w którym chcielibyśmy utworzyć 4-elementowy wektor z 4 macierzy, w tym przypadku zamiast przyjmować średnią wartość wszystkich pikseli na każdej mapie obiektów, bierzemy maksymalną wartość i zwracamy ją jako indywidualny element w wektorowa reprezentacja zainteresowań.
Porównanie metod globalnego łączenia zasobów
Celem analizy porównawczej jest porównanie obu technik globalnego łączenia danych w oparciu o ich wydajność podczas generowania reprezentacji wektorów klasyfikacji. Zbiór danych, który należy wykorzystać do celów porównawczych, to zbiór danych FashionMNIST, który zawiera obrazy popularnych artykułów modowych o wymiarach 28 na 28 pikseli.
# loading training data
training_set = Datasets.FashionMNIST(root='./', download=True,
transform=transforms.ToTensor())
loading validation data
validation_set = Datasets.FashionMNIST(root='./', download=True, train=False,
transform=transforms.ToTensor())
Etykieta
Opis
Koszulka
1
Spodnie
2
Pulower
3
Sukienka
4
Płaszcz
5
Sandał
6
Koszula
7
Trampki
8
Torba
9
But do kostki
Convnet z globalnym łączeniem średnich
Sieć zdefiniowana poniżej wykorzystuje warstwę splotu 1 x 1 w połączeniu z globalną pulą średnią zamiast warstw liniowych w celu utworzenia 10-elementowej reprezentacji wektorowej bez regularyzacji. Jeśli chodzi o implementację globalnego średniego łączenia w PyTorch, wszystko, co należy zrobić, to wykorzystać zwykłą klasę średniego łączenia, ale użyć jądra/filtra o rozmiarze równym rozmiarowi każdej indywidualnej mapy funkcji. Aby to zilustrować, mapy obiektów wychodzące z warstwy 6 mają rozmiar (3, 3), więc aby wykonać globalne średnie łączenie, używane jest jądro o rozmiarze 3. Uwaga: samo wzięcie średniej wartości każdej mapy obiektów da ten sam wynik.
class ConvNet_1(nn.Module):
def __init__(self):
super().__init__()
self.network = nn.Sequential(
# layer 1
nn.Conv2d(1, 8, 3, padding=1),
nn.ReLU(), # feature map size = (28, 28)
# layer 2
nn.Conv2d(8, 8, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2), # feature map size = (14, 14)
# layer 3
nn.Conv2d(8, 16, 3, padding=1),
nn.ReLU(), # feature map size = (14, 14)
# layer 4
nn.Conv2d(16, 16, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2), # feature map size = (7, 7)
# layer 5
nn.Conv2d(16, 32, 3, padding=1),
nn.ReLU(), # feature map size = (7, 7)
# layer 6
nn.Conv2d(32, 32, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2), # feature map size = (3, 3)
# output layer
nn.Conv2d(32, 10, 1),
nn.AvgPool2d(3)
)
def forward(self, x):
x = x.view(-1, 1, 28, 28)
output = self.network(x)
output = output.view(-1, 10)
return torch.sigmoid(output)
Convnet z Global Max Pooling
Z drugiej strony ConvNet_2 poniżej zastępuje warstwy liniowe warstwą splotu 1 x 1 działającą w tandemie z globalnym maksymalnym łączeniem w celu wytworzenia 10-elementowego wektora bez regularyzacji. Podobnie jak w przypadku globalnego średniego łączenia, aby zaimplementować globalne maksymalne łączenie w PyTorch, należy użyć zwykłej klasy maksymalnego łączenia w pulę z rozmiarem jądra równym rozmiarowi mapy funkcji w tym momencie. Uwaga: samo wyznaczenie maksymalnej wartości pikseli na każdej mapie obiektów dałoby takie same wyniki.
class ConvNet_2(nn.Module):
def __init__(self):
super().__init__()
self.network = nn.Sequential(
# layer 1
nn.Conv2d(1, 8, 3, padding=1),
nn.ReLU(), # feature map size = (28, 28)
# layer 2
nn.Conv2d(8, 8, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2), # feature map size = (14, 14)
# layer 3
nn.Conv2d(8, 16, 3, padding=1),
nn.ReLU(), # feature map size = (14, 14)
# layer 4
nn.Conv2d(16, 16, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2), # feature map size = (7, 7)
# layer 5
nn.Conv2d(16, 32, 3, padding=1),
nn.ReLU(), # feature map size = (7, 7)
# layer 6
nn.Conv2d(32, 32, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2), # feature map size = (3, 3)
# output layer
nn.Conv2d(32, 10, 1),
nn.MaxPool2d(3)
)
def forward(self, x):
x = x.view(-1, 1, 28, 28)
output = self.network(x)
output = output.view(-1, 10)
return torch.sigmoid(output)
Klasa konwolucyjnej sieci neuronowej
Zdefiniowana poniżej klasa zawiera funkcje szkoleniowe i klasyfikacyjne, które można wykorzystać do szkolenia i wykorzystania sieci komunikacyjnych.
class ConvolutionalNeuralNet():
def __init__(self, network):
self.network = network.to(device)
self.optimizer = torch.optim.Adam(self.network.parameters(), lr=3e-4)
def train(self, loss_function, epochs, batch_size,
training_set, validation_set):
# creating log
log_dict = {
'training_loss_per_batch': [],
'validation_loss_per_batch': [],
'training_accuracy_per_epoch': [],
'validation_accuracy_per_epoch': []
}
# defining weight initialization function
def init_weights(module):
if isinstance(module, nn.Conv2d):
torch.nn.init.xavier_uniform_(module.weight)
module.bias.data.fill_(0.01)
# defining accuracy function
def accuracy(network, dataloader):
total_correct = 0
total_instances = 0
for images, labels in tqdm(dataloader):
images, labels = images.to(device), labels.to(device)
predictions = torch.argmax(network(images), dim=1)
correct_predictions = sum(predictions==labels).item()
total_correct+=correct_predictions
total_instances+=len(images)
return round(total_correct/total_instances, 3)
# initializing network weights
self.network.apply(init_weights)
# creating dataloaders
train_loader = DataLoader(training_set, batch_size)
val_loader = DataLoader(validation_set, batch_size)
for epoch in range(epochs):
print(f'Epoch {epoch+1}/{epochs}')
train_losses = []
# training
print('training...')
for images, labels in tqdm(train_loader):
# sending data to device
images, labels = images.to(device), labels.to(device)
# resetting gradients
self.optimizer.zero_grad()
# making predictions
predictions = self.network(images)
# computing loss
loss = loss_function(predictions, labels)
log_dict['training_loss_per_batch'].append(loss.item())
train_losses.append(loss.item())
# computing gradients
loss.backward()
# updating weights
self.optimizer.step()
with torch.no_grad():
print('deriving training accuracy...')
# computing training accuracy
train_accuracy = accuracy(self.network, train_loader)
log_dict['training_accuracy_per_epoch'].append(train_accuracy)
# validation
print('validating...')
val_losses = []
with torch.no_grad():
for images, labels in tqdm(val_loader):
# sending data to device
images, labels = images.to(device), labels.to(device)
# making predictions
predictions = self.network(images)
# computing loss
val_loss = loss_function(predictions, labels)
log_dict['validation_loss_per_batch'].append(val_loss.item())
val_losses.append(val_loss.item())
# computing accuracy
print('deriving validation accuracy...')
val_accuracy = accuracy(self.network, val_loader)
log_dict['validation_accuracy_per_epoch'].append(val_accuracy)
train_losses = np.array(train_losses).mean()
val_losses = np.array(val_losses).mean()
print(f'training_loss: {round(train_losses, 4)} training_accuracy: '+
f'{train_accuracy} validation_loss: {round(val_losses, 4)} '+
f'validation_accuracy: {val_accuracy}\n')
return log_dict
def predict(self, x):
return self.network(x)
ConvNet_1 (średnia globalna pula)
ConvNet_1 wykorzystuje globalną średnią pulę przy tworzeniu wektora klasyfikacji. Ustawianie interesujących parametrów i uczenia dla 60 epok tworzy dziennik metryczny, jak analizowano poniżej.
model_1 = ConvolutionalNeuralNet(ConvNet_1())
log_dict_1 = model_1.train(nn.CrossEntropyLoss(), epochs=60, batch_size=64,
training_set=training_set, validation_set=validation_set)
Z uzyskanego dziennika wynika, że zarówno dokładność uczenia, jak i walidacji wzrosła w trakcie uczenia modelu. Dokładność walidacji zaczyna się od około 66%, po czym stale rośnie do wartości nieco poniżej 80% w 28. epoce. Następnie w 31. epoce obserwuje się gwałtowny wzrost do wartości poniżej 85%, a następnie w 60. epoce osiąga się kulminację na poziomie około 87%.
sns.lineplot(y=log_dict_1['training_accuracy_per_epoch'], x=range(len(log_dict_1['training_accuracy_per_epoch'])), label='training')
sns.lineplot(y=log_dict_1['validation_accuracy_per_epoch'], x=range(len(log_dict_1['validation_accuracy_per_epoch'])), label='validation')
plt.xlabel('epoch')
plt.ylabel('accuracy')
ConvNet_2 (maksymalna globalna pula)
ConvNet_2 wykorzystuje globalne maksymalne łączenie zamiast globalnego łączenia średniego przy tworzeniu 10-elementowego wektora klasyfikacji. Utrzymanie wszystkich parametrów bez zmian i uczenie przez 60 epok daje poniższy log metryki.
model_2 = ConvolutionalNeuralNet(ConvNet_2())
log_dict_2 = model_2.train(nn.CrossEntropyLoss(), epochs=60, batch_size=64,
training_set=training_set, validation_set=validation_set)
Ogólnie rzecz biorąc, zarówno dokładność uczenia, jak i walidacji wzrosła w ciągu 60 epok. Dokładność walidacji zaczyna się od nieco poniżej 70%, po czym ulega wahaniom i stale rośnie do wartości nieco poniżej 85% w 60. epoce.
sns.lineplot(y=log_dict_2['training_accuracy_per_epoch'], x=range(len(log_dict_2['training_accuracy_per_epoch'])), label='training')
sns.lineplot(y=log_dict_2['validation_accuracy_per_epoch'], x=range(len(log_dict_2['validation_accuracy_per_epoch'])), label='validation')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.savefig('maxpool_benchmark.png', dpi=1000)
Porównanie wydajności
Porównując wydajność obu technik globalnego łączenia danych, można łatwo wywnioskować, że globalne średnie łączenie danych działa lepiej, przynajmniej w przypadku zbioru danych, którego zdecydowaliśmy się użyć (FashionMNIST). Wydaje się to naprawdę logiczne, ponieważ globalne łączenie średnich daje pojedynczą wartość, która jest reprezentatywna dla ogólnego charakteru wszystkich pikseli na każdej mapie obiektów, w przeciwieństwie do globalnego łączenia maksymalnych wartości, które tworzy pojedynczą wartość w izolacji, bez względu na inne piksele obecne w mapa funkcji. Aby jednak uzyskać bardziej rozstrzygający werdykt, należy przeprowadzić analizę porównawczą kilku zbiorów danych.
Globalne łączenie pod maską
Aby wyrobić sobie intuicję wyjaśniającą, dlaczego globalne pule faktycznie działają, musimy napisać funkcję, która umożliwi nam wizualizację wyników warstwy pośredniej w splotowej sieci neuronowej. Często uważa się, że sieci neuronowe to modele czarnych skrzynek, ale istnieją pewne sposoby, aby przynajmniej spróbować podważyć czarną skrzynkę i zrozumieć, co dzieje się w środku. Poniższa funkcja właśnie to robi.
def visualize_layer(model, dataset, image_idx: int, layer_idx: int):
"""
This function visulizes intermediate layers in a convolutional neural
network defined using the PyTorch sequential class
"""
# creating a dataloader
dataloader = DataLoader(dataset, 250)
# deriving a single batch from dataloader
for images, labels in dataloader:
images, labels = images.to(device), labels.to(device)
break
# deriving output from layer of interest
output = model.network.network[:layer_idx].forward(images[image_idx])
# deriving output shape
out_shape = output.shape
# classifying image
predicted_class = model.predict(images[image_idx])
print(f'actual class: {labels[image_idx]}\npredicted class: {torch.argmax(predicted_class)}')
# visualising layer
plt.figure(dpi=150)
plt.title(f'visualising output')
plt.imshow(np.transpose(make_grid(output.cpu().view(out_shape[0], 1,
out_shape[1],
out_shape[2]),
padding=2, normalize=True), (1,2,0)))
plt.axis('off')
Aby skorzystać z funkcji należy dobrze zrozumieć parametry. Model odnosi się do splotowej sieci neuronowej utworzonej w taki sam sposób, jak zrobiliśmy to w tym artykule. Inne typy nie będą działać z tą funkcją. Zbiór danych w tym przypadku może być dowolnym zbiorem danych, ale najlepiej zbiorem walidacyjnym. Image_idx to indeks obrazu w pierwszej partii dostarczonego zbioru danych, funkcja definiuje partię jako 250 obrazów, więc image_idx może mieć wartość z zakresu 0–249. Z drugiej strony Layer_idx nie odnosi się dokładnie do warstw splotu, odnosi się do warstw zgodnie z definicją w klasie sekwencyjnej PyTorch, jak pokazano poniżej.
model_1.network
output
>>>> ConvNet_1(
(network): Sequential(
(0): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(8, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(5): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(6): ReLU()
(7): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(8): ReLU()
(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(10): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(11): ReLU()
(12): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(13): ReLU()
(14): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(15): Conv2d(32, 10, kernel_size=(1, 1), stride=(1, 1))
(16): AvgPool2d(kernel_size=3, stride=3, padding=0)
)
)
Dlaczego globalne średnie łączenie działa
Aby zrozumieć, dlaczego działa globalna średnia pula, musimy wizualizować dane wyjściowe warstwy wyjściowej tuż przed wykonaniem globalnej średniej puli, co odpowiada warstwie 15, więc musimy pobrać/indeksować warstwy aż do warstwy 15, co oznacza, że Layer_idx= 16. Korzystając z modelu_1 (ConvNet_1), tworzymy poniższe wyniki.
visualize_layer(model=model_1, dataset=validation_set, image_idx=2, layer_idx=16)
output
>>>> actual class: 1
>>>> predicted class: 1
Kiedy wizualizujemy wynik obrazu 3 (indeks 2) tuż przed zbiorczym średnim globalnym, możemy zobaczyć, że model poprawnie przewidział swoją klasę jako klasę 1 (spodnie), jak pokazano powyżej. Patrząc na wizualizację, widzimy, że mapa obiektów o indeksie 1 ma średnio najjaśniejsze piksele w porównaniu z innymi mapami obiektów. Innymi słowy, sieć internetowa nauczyła się klasyfikować obrazy poprzez „włączanie” większej liczby pikseli na interesującej mapie obiektów tuż przed zbiorem średniej globalnej. Kiedy zostanie wykonane globalne średnie łączenie, element o najwyższej wartości zostanie umieszczony w indeksie 1, dlatego też zostanie wybrany jako właściwa klasa.
Globalny średni wynik łączenia.
Dlaczego globalne maksymalne łączenie zasobów działa
Zachowując te same parametry, ale w tym przypadku używając modelu_2 (ConvNet_2), otrzymujemy poniższe wyniki. Ponownie convnet poprawnie klasyfikuje ten obraz jako należący do klasy 1. Patrząc na wygenerowaną wizualizację, możemy zobaczyć, że mapa obiektów o indeksie 1 zawiera najjaśniejszy piksel.
W tym przypadku sieć komunikacyjna nauczyła się klasyfikować obrazy poprzez „włączanie” najjaśniejszych pikseli na interesującej mapie obiektów tuż przed globalnym łączeniem maksymalnych wartości.
visualize_layer(model=model_2, dataset=validation_set, image_idx=2, layer_idx=16)
output
>>>> actual class: 1
>>>> predicted class: 1
Globalna maksymalna moc wyjściowa łączenia.
Uwagi końcowe
W tym artykule sprawdziliśmy, na czym polega globalne średnie i maksymalne łączenie zasobów. Omówiliśmy, dlaczego zaczęto ich używać i jak wypadają względem siebie. Rozwinęliśmy także intuicję wyjaśniającą, dlaczego one działają, wykonując biopsję naszych połączeń i wizualizując warstwy pośrednie.








