Wyszukiwanie w witrynie

Wyściółka w konwolucyjnych sieciach neuronowych


Wypełnianie jest niezbędnym procesem w konwolucyjnych sieciach neuronowych. Chociaż nie jest to obowiązkowe, jest to proces często stosowany w wielu najnowocześniejszych architekturach CNN. W tym artykule przyjrzymy się, dlaczego i jak to się dzieje.

Mechanizm splotu

Splot w kontekście przetwarzania obrazu/wizji komputerowej to proces, podczas którego obraz jest „skanowany” przez filtr w celu przetworzenia go w jakiś sposób. Przejdźmy trochę do szczegółów technicznych.

Dla komputera obraz to po prostu tablica typów numerycznych (liczby, całkowite lub zmiennoprzecinkowe). Te typy numeryczne są trafnie nazywane pikselami. W rzeczywistości obraz HD o wymiarach 1920 na 1080 pikseli (1080p) to po prostu tabela/tablica typów numerycznych zawierająca 1080 wierszy i 1920 kolumn. Z drugiej strony filtr jest zasadniczo taki sam, ale zwykle ma mniejsze wymiary, powszechnym (3, 3) filtrem splotu jest tablica złożona z 3 wierszy i 3 kolumn.

Kiedy obraz jest splatany, na kolejne obszary obrazu nakładany jest filtr, w którym następuje mnożenie elementów pomiędzy elementami filtra a pikselami w tym obszarze, a następnie zwracana jest skumulowana suma jako nowy, własny piksel. Na przykład podczas wykonywania splotu przy użyciu filtra (3, 3) 9 pikseli jest agregowanych w celu uzyskania pojedynczego piksela. W wyniku tego procesu agregacji następuje utrata niektórych pikseli.

Filtruj skanowanie obrazu, aby wygenerować nowy obraz poprzez splot.

Zagubione piksele

Aby zrozumieć, dlaczego piksele są tracone, należy pamiętać, że jeśli filtr splotu wykracza poza zakres podczas skanowania obrazu, ten konkretny przypadek splotu jest ignorowany. Aby to zilustrować, rozważ obraz o wymiarach 6 x 6 pikseli spleciony z filtrem 3 x 3. Jak widać na poniższym obrazku, pierwsze 4 sploty mieszczą się w obrazie, tworząc 4 piksele w pierwszym rzędzie, podczas gdy piąte i szóste wystąpienie wykraczają poza zakres i dlatego są ignorowane. Podobnie, jeśli filtr zostanie przesunięty w dół o 1 piksel, ten sam wzór powtórzy się z utratą 2 pikseli również w drugim rzędzie. Po zakończeniu procesu obraz o wymiarach 6 x 6 pikseli staje się obrazem o wymiarach 4 x 4 piksele, ponieważ utraciłby 2 kolumny pikseli przy przyciemnieniu 0 (x) i 2 rzędy pikseli przy przyciemnieniu 1 (y).

Instancje splotu przy użyciu filtra 3x3.

Podobnie, jeśli używany jest filtr 5 x 5, 4 kolumny i rzędy pikseli zostaną utracone odpowiednio w przypadku przyciemnienia 0 (x) i przyciemnienia 1 (y), co daje obraz o wymiarach 2 x 2 piksele.

Instancje splotu przy użyciu filtra 5x5.

Nie wierz mi na słowo, wypróbuj poniższą funkcję, aby sprawdzić, czy rzeczywiście tak jest. Możesz dowolnie dostosowywać argumenty.

import numpy as np
import torch
import torch.nn.functional as F
import cv2
import torch.nn as nn
from tqdm import tqdm
import matplotlib.pyplot as plt

def check_convolution(filter=(3,3), image_size=(6,6)):
    """
    This function creates a pseudo image, performs
    convolution and returns the size of both the pseudo
    and convolved image
    """
    #  creating pseudo image
    original_image = torch.ones(image_size)
    #  adding channel as typical to images (1 channel = grayscale)
    original_image = original_image.view(1, 6, 6)

    #  perfoming convolution
    conv_image = nn.Conv2d(1, 1, filter)(original_image)

    print(f'original image size: {original_image.shape}')
    print(f'image size after convolution: {conv_image.shape}')
    pass

check_convolution()

Wydaje się, że istnieje pewien wzór dotyczący sposobu utraty pikseli. Wygląda na to, że za każdym razem, gdy używany jest filtr m x n, m-1 kolumn pikseli jest tracone przy przyciemnieniu 0, a n-1 rzędów pikseli przy przyciemnieniu 1. Przejdźmy trochę bardziej matematycznie…

rozmiar obrazu=(x, y) rozmiar filtra=(m, n) rozmiar obrazu po splocie=(x-(m-1), y-(n-1))=(x-m+1, y-n+1)

Ilekroć obraz o rozmiarze (x, y) jest splatany przy użyciu filtra rozmiaru (m, n), powstaje obraz o rozmiarze (x-m+1, y-n+1).

Chociaż to równanie może wydawać się nieco zawiłe (nie jest to zamierzona gra słów), logika za nim stojąca jest dość prosta do przestrzegania. Ponieważ najpopularniejsze filtry mają rozmiar kwadratowy (te same wymiary w obu osiach), wystarczy wiedzieć, że po wykonaniu splotu przy użyciu filtra (3, 3) tracone są 2 wiersze i kolumny pikseli (3-1); jeśli zostanie to zrobione przy użyciu filtra (5, 5), utracone zostaną 4 wiersze i kolumny pikseli (5-1); a jeśli zrobi się to przy użyciu filtra (9, 9), zgadłeś, 8 wierszy i kolumn pikseli zostanie straconych (9-1).

Konsekwencje utraty pikseli

Utrata 2 rzędów i kolumn pikseli może nie mieć aż tak dużego efektu, szczególnie w przypadku dużych obrazów, na przykład obraz 4K UHD (3840, 2160) wydawałby się nienaruszony utratą 2 rzędów i kolumn pikseli, gdy na który wpływa filtr (3, 3), gdy staje się (3838, 2158), co powoduje utratę około 0,1% wszystkich pikseli. Problemy zaczynają się pojawiać, gdy w grę wchodzi wiele warstw splotu, co jest typowe w najnowocześniejszych architekturach CNN. Weźmy na przykład RESNET 128. Ta architektura ma około 50 (3, 3) warstw splotu, co spowodowałoby utratę około 100 wierszy i kolumn pikseli, zmniejszając rozmiar obrazu do (3740, 2060), czyli stratę około 7,2% całkowitej liczby pikseli obrazu, a wszystko to bez uwzględnienia operacji próbkowania w dół.

Nawet w przypadku płytkiej architektury utrata pikseli może mieć ogromny wpływ. CNN z zastosowanymi zaledwie 4 warstwami splotu używanymi na obrazie w zbiorze danych MNIST o rozmiarze (28, 28) spowodowałby utratę 8 wierszy i kolumn pikseli, zmniejszając jego rozmiar do (20, 20), czyli utratę 57,1 % całkowitej liczby pikseli, co jest dość znaczne.

Ponieważ operacje splotu odbywają się od lewej do prawej i od góry do dołu, piksele są tracone przy skrajnej prawej i dolnej krawędzi. Dlatego można śmiało powiedzieć, że splot powoduje utratę pikseli krawędziowych, które mogą zawierać cechy istotne dla danego zadania widzenia komputerowego.

Wyściółka jako rozwiązanie

Ponieważ wiemy, że piksele zostaną utracone po splocie, możemy temu zapobiec, dodając je wcześniej. Na przykład, jeśli będzie używany filtr (3, 3), możemy wcześniej dodać do obrazu 2 wiersze i 2 kolumny pikseli, aby po zakończeniu splotu rozmiar obrazu był taki sam jak obraz oryginalny.

Zajmijmy się znowu trochę matematyką…

rozmiar obrazu=(x, y) rozmiar filtra=(m, n)

rozmiar obrazu po dopełnieniu=(x+2, y+2)

korzystając z równania ==> (x-m+1, y-n+1)

rozmiar obrazu po splocie (3, 3)=(x+2-3+1, y+2-3+1)=(x, y)

Wypełnienie w terminach warstw

Ponieważ mamy do czynienia z numerycznymi typami danych, sensowne jest, aby wartość dodatkowych pikseli była również numeryczna. Powszechnie przyjmowaną wartością jest zerowa wartość w pikselach, dlatego często używany jest termin „wypełnienie zerami”.

Problem z zapobiegawczym dodawaniem wierszy i kolumn pikseli do tablicy obrazów polega na tym, że należy to zrobić równomiernie po obu stronach. Na przykład, dodając 2 wiersze i 2 kolumny pikseli, należy je dodać jako jeden rząd na górze, jeden rząd na dole, jedną kolumnę po lewej stronie i jedną kolumnę po prawej stronie.

Patrząc na poniższy obrazek, dodano 2 wiersze i 2 kolumny, aby wypełnić tablicę jedynek 6 x 6 po lewej stronie, podczas gdy 4 wiersze i 4 kolumny zostały dodane po prawej stronie. Dodatkowe wiersze i kolumny zostały rozmieszczone równomiernie wzdłuż wszystkich krawędzi, jak stwierdzono w poprzednim akapicie.

Przyglądając się uważnie tablicom, po lewej stronie, wydaje się, że tablica jedynek 6 x 6 została zamknięta w pojedynczej warstwie zer, więc wypełnienie=1. Z drugiej strony tablica po prawej stronie wydaje się być ujęta w dwie warstwy zer, stąd dopełnienie=2.

Warstwy zer dodane poprzez dopełnienie.

Łącząc to wszystko razem, można śmiało powiedzieć, że jeśli ktoś chce dodać 2 wiersze i 2 kolumny pikseli w ramach przygotowań do splotu (3, 3), potrzebuje pojedynczej warstwy wyściółki. W tej samej łopatce, jeśli trzeba dodać 6 wierszy i 6 kolumn pikseli w ramach przygotowań do splotu (7, 7), potrzebne są 3 warstwy wyściółki. Mówiąc bardziej technicznie,

Biorąc pod uwagę filtr o rozmiarze (m, n), (m-1)/2 warstwy wypełnienia są wymagane, aby zachować ten sam rozmiar obrazu po splocie; pod warunkiem, że m=n i m jest liczbą nieparzystą.

Proces wypełniania

Aby zademonstrować proces dopełniania, napisałem prosty kod, aby odtworzyć proces dopełniania i splotu.

Po pierwsze, przyjrzyjmy się poniższej funkcji dopełniania. Funkcja przyjmuje obraz jako parametr z domyślną warstwą dopełniającą wynoszącą 2. Gdy parametr wyświetlania ma wartość True, funkcja generuje miniraport, wyświetlając rozmiar obu oryginalny i wyściełany obraz; zwracana jest również fabuła obu obrazów.

def pad_image(image_path, padding=2, display=True, title=''):
      """
      This function performs zero padding using the number of
      padding layers supplied as argument and return the padded
      image.
      """

      #  reading image as grayscale
      image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

      #  creating an array of zeros
      padded = arr = np.zeros((image.shape[0] + padding*2,
                               image.shape[1] + padding*2))

      #  inserting image into zero array
      padded[int(padding):-int(padding),
             int(padding):-int(padding)] = image

      if display:
        print(f'original image size: {image.shape}')
        print(f'padded image size: {padded.shape}')

        #  displaying results
        figure, axes = plt.subplots(1,2, sharey=True, dpi=120)
        plt.suptitle(title)
        axes[0].imshow(image, cmap='gray')
        axes[0].set_title('original')
        axes[1].imshow(padded, cmap='gray')
        axes[1].set_title('padded')
        axes[0].axis('off')
        axes[1].axis('off')
        plt.show()
        print('image array preview:')
      return padded

Funkcja wypełniania.

Aby przetestować funkcję dopełniania, spójrz na poniższy obrazek przedstawiający rozmiar (375, 500). Przepuszczenie tego obrazu przez funkcję dopełniającą z padding=2 powinno dać ten sam obraz z dwiema kolumnami zerowymi po lewej i prawej krawędzi oraz dwoma rzędami zer na górze i na dole, zwiększając rozmiar obrazu do (379, 504). Zobaczmy, czy tak jest…

Obraz o rozmiarze (375, 500)

pad_image('image.jpg')

wyjście: oryginalny rozmiar obrazu: (375, 500) dopełniony rozmiar obrazu: (379, 504)

Zwróć uwagę na cienką linię czarnych pikseli wzdłuż krawędzi uzupełnionego obrazu.

To działa! Możesz wypróbować tę funkcję na dowolnym obrazie, jaki znajdziesz, i dostosować parametry zgodnie z wymaganiami. Poniżej znajduje się kod waniliowy do replikacji splotu.

def convolve(image_path, padding=2, filter, title='', pad=False):
      """
      This function performs convolution over an image
      """

      #  reading image as grayscale
      image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

      if pad:
        original_image = image[:]
        image = pad_image(image, padding=padding, display=False)
      else:
        image = image

      #  defining filter size
      filter_size = filter.shape[0]

      #  creating an array to store convolutions
      convolved = np.zeros(((image.shape[0] - filter_size) + 1,
                        (image.shape[1] - filter_size) + 1))

      #  performing convolution
      for i in tqdm(range(image.shape[0])):
        for j in range(image.shape[1]):
          try:
            convolved[i,j] = (image[i:(i+filter_size), j:(j+filter_size)] * filter).sum()
          except Exception:
            pass

      #  displaying results
      if not pad:
        print(f'original image size: {image.shape}')
      else:
        print(f'original image size: {original_image.shape}')
      print(f'convolved image size: {convolved.shape}')

      figure, axes = plt.subplots(1,2, dpi=120)
      plt.suptitle(title)
      if not pad:
        axes[0].imshow(image, cmap='gray')
        axes[0].axis('off')
      else:
        axes[0].imshow(original_image, cmap='gray')
        axes[0].axis('off')
      axes[0].set_title('original')
      axes[1].imshow(convolved, cmap='gray')
      axes[1].axis('off')
      axes[1].set_title('convolved')
      pass

Funkcja splotu

W przypadku filtra wybrałem tablicę (5, 5) o wartościach 0,01. Pomysł polega na tym, że filtr zmniejsza intensywność pikseli o 99% przed zsumowaniem w celu uzyskania pojedynczego piksela. Mówiąc najprościej, filtr ten powinien powodować rozmycie obrazów.

filter_1 = np.ones((5,5))/100

filter_1
[[0.01, 0.01, 0.01, 0.01, 0.01]
 [0.01, 0.01, 0.01, 0.01, 0.01]
 [0.01, 0.01, 0.01, 0.01, 0.01]
 [0.01, 0.01, 0.01, 0.01, 0.01]
 [0.01, 0.01, 0.01, 0.01, 0.01]]

(5, 5) Filtr splotowy

Nałożenie filtra na oryginalny obraz bez dopełnienia powinno dać rozmazany obraz o rozmiarach (371, 496), utratę 4 wierszy i 4 kolumn.

convolve('image.jpg', filter=filter_1)

Wykonywanie splotu bez dopełnienia

wyjście: oryginalny rozmiar obrazu: (375, 500) rozmiar skręconego obrazu: (371, 496)

(5, 5) splot bez dopełnienia

Jednak gdy pad jest ustawiony na true, rozmiar obrazu pozostaje taki sam.

convolve('image.jpg', pad=True, padding=2, filter=filter_1)

Splot z 2 warstwami wyściółki.

wyjście: oryginalny rozmiar obrazu: (375, 500) rozmiar skręconego obrazu: (375, 500)

(5, 5) splot z dopełnieniem

Powtórzmy te same kroki, ale tym razem z filtrem (9, 9)…

filter_2 = np.ones((9,9))/100
filter_2

filter_2
[[0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
 [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01]])

(9, 9) filtr

Bez dopełniania powstały obraz zmniejsza się…

convolve('image.jpg', filter=filter_2)

wyjście: oryginalny rozmiar obrazu: (375, 500) rozmiar skręconego obrazu: (367, 492)

(9, 9) splot bez dopełnienia

Używając filtra (9, 9), aby zachować ten sam rozmiar obrazu, musimy określić warstwę dopełniającą 4 (9-1/2), ponieważ będziemy chcieli dodać 8 wierszy i 8 kolumn do oryginalnego obrazu.

convolve('image.jpg', pad=True, padding=4, filter=filter_2)

wyjście: oryginalny rozmiar obrazu: (375, 500) rozmiar skręconego obrazu: (375, 500)

(9, 9) splot z dopełnieniem

Z perspektywy PyTorcha

Dla ułatwienia ilustracji zdecydowałem się wyjaśnić procesy za pomocą kodu waniliowego w powyższej sekcji. Ten sam proces można powtórzyć w PyTorch, należy jednak pamiętać, że powstały obraz najprawdopodobniej ulegnie niewielkiej lub żadnej transformacji, ponieważ PyTorch losowo zainicjuje filtr, który nie jest przeznaczony do żadnego konkretnego celu.

Aby to zademonstrować, zmodyfikujmy funkcję check_convolution() zdefiniowaną w jednej z poprzednich sekcji powyżej…

def check_convolution(image_path, filter=(3,3), padding=0):
    """
    This function performs convolution on an image and
    returns the size of both the original and convolved image
    """

    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

    image = torch.from_numpy(image).float()

    #  adding channel as typical to images (1 channel = grayscale)
    image = image.view(1, image.shape[0], image.shape[1])

    #  perfoming convolution
    with torch.no_grad():
      conv_image = nn.Conv2d(1, 1, filter, padding=padding)(image)

    print(f'original image size: {image.shape}')
    print(f'image size after convolution: {conv_image.shape}')
    pass

Funkcja wykonuje splot przy użyciu domyślnej klasy splotu PyTorch

Zauważ, że w funkcji użyłem domyślnej klasy splotu 2D PyTorch, a parametr dopełnienia funkcji jest bezpośrednio dostarczany do klasy splotu. Wypróbujmy teraz różne filtry i zobaczmy, jakie będą rozmiary obrazu…

check_convolution('image.jpg', filter=(3, 3))

(3, 3) splot bez dopełnienia

wyjście: oryginalny rozmiar obrazu: latarka.Rozmiar(1, 375, 500) rozmiar obrazu po splocie: torch.Size(1, 373, 498)

check_convolution('image.jpg', filter=(3, 3), padding=1)

(3, 3) splot z jedną warstwą wyściółki.-

wyjście: oryginalny rozmiar obrazu: latarka.Rozmiar(1, 375, 500) rozmiar obrazu po splocie: torch.Size(1, 375, 500)

check_convolution('image.jpg', filter=(5, 5))

(5, 5) splot bez dopełnienia-

wyjście: oryginalny rozmiar obrazu: latarka.Rozmiar(1, 375, 500) rozmiar obrazu po splocie: torch.Size(1, 371, 496)

check_convolution('image.jpg', filter=(5, 5), padding=2)

(5, 5) splot z 2 warstwami wyściółki-

wyjście: oryginalny rozmiar obrazu: latarka.Rozmiar(1, 375, 500) rozmiar obrazu po splocie: torch.Size(1, 375, 500)

Jak widać w powyższych przykładach, gdy splot odbywa się bez dopełnienia, powstały obraz ma zmniejszony rozmiar. Jeśli jednak splot zostanie wykonany z odpowiednią ilością warstw wypełniających, wynikowy obraz będzie miał taki sam rozmiar jak obraz oryginalny.

Uwagi końcowe

W tym artykule udało nam się ustalić, że proces splotu w rzeczywistości powoduje utratę pikseli. Udało nam się również udowodnić, że zapobiegawcze dodanie pikseli do obrazu w procesie wywołującym dopełnianie przed splotem gwarantuje, że obraz zachowa swój pierwotny rozmiar po splocie.

Powiązane artykuły: