Rețele neuronale convoluționale

Deep Learning intermediar cu PyTorch

Michal Oleszak

Machine Learning Engineer

De ce să nu folosim straturi liniare?

Un pătrat negru reprezentând o imagine în tonuri de gri de 256x256.

Deep Learning intermediar cu PyTorch

De ce să nu folosim straturi liniare?

O imagine în tonuri de gri de 256x256 conține aproximativ 65k valori de pixeli.

Deep Learning intermediar cu PyTorch

De ce să nu folosim straturi liniare?

Un strat liniar de 1000 de neuroni procesează cele 65k valori de pixeli.

Deep Learning intermediar cu PyTorch

De ce să nu folosim straturi liniare?

Există 65 de milioane de conexiuni între imagine și strat.

Deep Learning intermediar cu PyTorch

De ce să nu folosim straturi liniare?

Cu o imagine color RGB, există 200 de milioane de conexiuni.

Deep Learning intermediar cu PyTorch

De ce să nu folosim straturi liniare?

  • Straturi liniare:
    • Antrenare lentă
    • Supraajustare
    • Nu recunosc tipare spațiale
  • O alternativă mai bună: straturi convoluționale!

Imagine cu o pisică în colț și neuronii care citesc acea zonă a imaginii

Deep Learning intermediar cu PyTorch

Stratul convoluțional

Un filtru de 3x3 glisează peste o intrare de 5x5 și produce o hartă de caracteristici de 3x3.

  • Glisați filtrul(ele) de parametri peste intrare
  • La fiecare poziție, efectuați convoluția
  • Harta de caracteristici rezultată:
    • Păstrează tipare spațiale din intrare
    • Folosește mai puțini parametri decât stratul liniar
  • Un filtru = o hartă de caracteristici
  • Aplicați activări hărților de caracteristici
  • Toate hărțile combinate formează ieșirea
  • nn.Conv2d(3, 32, kernel_size=3)
Deep Learning intermediar cu PyTorch

Convoluția

Două matrice 3x3 sunt înmulțite element cu element, iar rezultatele sunt sumate.

  1. Calculați produsul scalar al patch-ului de intrare și al filtrului
    • Câmpul stânga-sus: 2 × 1 = 2
  2. Sumați rezultatul
Deep Learning intermediar cu PyTorch

Zero-padding

O imagine 4x4 înconjurată de un cadru de pixeli cu valoarea zero.

  • Adăugați un cadru de zerouri la intrarea stratului convoluțional
nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)
  • Menține dimensiunile spațiale ale tensorilor de intrare și ieșire
  • Asigură tratarea egală a pixelilor de pe margine
Deep Learning intermediar cu PyTorch

Max Pooling

O matrice 4x4 în care fiecare sfert de 2x2 este marcat cu o culoare diferită devine o matrice 2x2 după max pooling.

  • Glisați o fereastră ne-suprapusă peste intrare
  • La fiecare poziție, păstrați doar valoarea maximă
  • Folosit după straturi convoluționale pentru a reduce dimensiunile spațiale
  • nn.MaxPool2d(kernel_size=2)
Deep Learning intermediar cu PyTorch

Rețea neuronală convoluțională

class Net(nn.Module):
    def __init__(self, num_classes):
        super().__init__()

        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
        )

        self.classifier = nn.Linear(64*16*16, num_classes)


    def forward(self, x):  
        x = self.feature_extractor(x)
        x = self.classifier(x)
        return x
  • feature_extractor: (convoluție, activare, pooling), repetat de două ori și aplatizat
  • classifier: un singur strat liniar
  • forward(): transmite imaginea de intrare prin extractor și clasificator
Deep Learning intermediar cu PyTorch

Dimensiunea ieșirii extractorului de caracteristici

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagramă schematică ce arată cum imaginile de intrare de forma 3x64x64 trec printr-un strat conv, un strat de pooling, un alt strat conv și un alt strat de pooling.

Deep Learning intermediar cu PyTorch

Dimensiunea ieșirii extractorului de caracteristici

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagramă schematică ce arată cum imaginile de intrare de forma 3x64x64 trec printr-un strat conv, un strat de pooling, un alt strat conv și un alt strat de pooling.

Deep Learning intermediar cu PyTorch

Dimensiunea ieșirii extractorului de caracteristici

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagramă schematică ce arată cum imaginile de intrare de forma 3x64x64 trec printr-un strat conv, un strat de pooling, un alt strat conv și un alt strat de pooling.

Deep Learning intermediar cu PyTorch

Dimensiunea ieșirii extractorului de caracteristici

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagramă schematică ce arată cum imaginile de intrare de forma 3x64x64 trec printr-un strat conv, un strat de pooling, un alt strat conv și un alt strat de pooling.

Deep Learning intermediar cu PyTorch

Dimensiunea ieșirii extractorului de caracteristici

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagramă schematică ce arată cum imaginile de intrare de forma 3x64x64 trec printr-un strat conv, un strat de pooling, un alt strat conv și un alt strat de pooling.

Deep Learning intermediar cu PyTorch

Să exersăm!

Deep Learning intermediar cu PyTorch

Preparing Video For Download...