En aquest tema, explorarem algunes de les arquitectures més influents i utilitzades en el camp de les Xarxes Neuronals Convolucionals (CNN). Aquestes arquitectures han demostrat ser molt eficients en tasques de reconeixement d'imatges i altres aplicacions de visió per computador.
- LeNet-5
Descripció
LeNet-5 és una de les primeres arquitectures de CNN desenvolupada per Yann LeCun el 1998. Va ser dissenyada per reconèixer dígits escrits a mà en el conjunt de dades MNIST.
Estructura
LeNet-5 consta de les següents capes:
- Capa Convolucional 1: 6 filtres de 5x5, seguit d'una funció d'activació tanh.
- Capa de Pooling 1: Subsampling amb una finestra de 2x2.
- Capa Convolucional 2: 16 filtres de 5x5, seguit d'una funció d'activació tanh.
- Capa de Pooling 2: Subsampling amb una finestra de 2x2.
- Capa Convolucional 3: 120 filtres de 5x5, seguit d'una funció d'activació tanh.
- Capa Totalment Connectada 1: 84 neurones, seguit d'una funció d'activació tanh.
- Capa de Sortida: 10 neurones amb funció d'activació softmax per a la classificació de 10 classes.
Exemple de codi en PyTorch
import torch
import torch.nn as nn
import torch.nn.functional as F
class LeNet5(nn.Module):
def __init__(self):
super(LeNet5, self).__init__()
self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
self.conv3 = nn.Conv2d(16, 120, kernel_size=5)
self.fc1 = nn.Linear(120, 84)
self.fc2 = nn.Linear(84, 10)
def forward(self, x):
x = F.tanh(self.conv1(x))
x = F.avg_pool2d(x, 2)
x = F.tanh(self.conv2(x))
x = F.avg_pool2d(x, 2)
x = F.tanh(self.conv3(x))
x = x.view(-1, 120)
x = F.tanh(self.fc1(x))
x = self.fc2(x)
return F.log_softmax(x, dim=1)
# Creació del model
model = LeNet5()
- AlexNet
Descripció
AlexNet va ser desenvolupada per Alex Krizhevsky, Ilya Sutskever i Geoffrey Hinton el 2012. Va guanyar la competició ImageNet Large Scale Visual Recognition Challenge (ILSVRC) el 2012, marcant un gran avenç en el camp de la visió per computador.
Estructura
AlexNet consta de les següents capes:
- Capa Convolucional 1: 96 filtres de 11x11, stride de 4, seguit d'una funció d'activació ReLU.
- Capa de Pooling 1: Max pooling amb una finestra de 3x3 i stride de 2.
- Capa Convolucional 2: 256 filtres de 5x5, seguit d'una funció d'activació ReLU.
- Capa de Pooling 2: Max pooling amb una finestra de 3x3 i stride de 2.
- Capa Convolucional 3: 384 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 4: 384 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 5: 256 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa de Pooling 3: Max pooling amb una finestra de 3x3 i stride de 2.
- Capa Totalment Connectada 1: 4096 neurones, seguit d'una funció d'activació ReLU.
- Capa Totalment Connectada 2: 4096 neurones, seguit d'una funció d'activació ReLU.
- Capa de Sortida: 1000 neurones amb funció d'activació softmax per a la classificació de 1000 classes.
Exemple de codi en PyTorch
import torch
import torch.nn as nn
import torch.nn.functional as F
class AlexNet(nn.Module):
def __init__(self):
super(AlexNet, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(96, 256, kernel_size=5, padding=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(256, 384, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(384, 384, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(384, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
)
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(256 * 6 * 6, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, 1000),
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), 256 * 6 * 6)
x = self.classifier(x)
return x
# Creació del model
model = AlexNet()
- VGGNet
Descripció
VGGNet va ser desenvolupada per l'equip de Visual Geometry Group de la Universitat d'Oxford el 2014. Es caracteritza per l'ús de capes convolucionals amb filtres de 3x3 i una profunditat considerable.
Estructura
VGGNet té diverses variants, com VGG16 i VGG19, que es diferencien pel nombre de capes convolucionals. Aquí descriurem VGG16:
- Capa Convolucional 1: 64 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 2: 64 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa de Pooling 1: Max pooling amb una finestra de 2x2 i stride de 2.
- Capa Convolucional 3: 128 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 4: 128 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa de Pooling 2: Max pooling amb una finestra de 2x2 i stride de 2.
- Capa Convolucional 5: 256 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 6: 256 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 7: 256 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa de Pooling 3: Max pooling amb una finestra de 2x2 i stride de 2.
- Capa Convolucional 8: 512 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 9: 512 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 10: 512 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa de Pooling 4: Max pooling amb una finestra de 2x2 i stride de 2.
- Capa Convolucional 11: 512 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 12: 512 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa Convolucional 13: 512 filtres de 3x3, seguit d'una funció d'activació ReLU.
- Capa de Pooling 5: Max pooling amb una finestra de 2x2 i stride de 2.
- Capa Totalment Connectada 1: 4096 neurones, seguit d'una funció d'activació ReLU.
- Capa Totalment Connectada 2: 4096 neurones, seguit d'una funció d'activació ReLU.
- Capa de Sortida: 1000 neurones amb funció d'activació softmax per a la classificació de 1000 classes.
Exemple de codi en PyTorch
import torch
import torch.nn as nn
import torch.nn.functional as F
class VGG16(nn.Module):
def __init__(self):
super(VGG16, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 128, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(128, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(256, 512, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
)
self.classifier = nn.Sequential(
nn.Linear(512 * 7 * 7, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 1000),
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
# Creació del model
model = VGG16()
- ResNet
Descripció
ResNet (Residual Network) va ser desenvolupada per Kaiming He, Xiangyu Zhang, Shaoqing Ren i Jian Sun el 2015. Va guanyar la competició ILSVRC el 2015. La seva innovació principal és l'ús de blocs residuals, que permeten entrenar xarxes molt profundes.
Estructura
ResNet té diverses variants, com ResNet-50, ResNet-101 i ResNet-152, que es diferencien pel nombre de capes. Aquí descriurem ResNet-50:
- Blocs Residuals: Cada bloc consta de capes convolucionals amb connexions d'identitat (skip connections) que permeten el pas de gradients durant l'entrenament.
- Capa de Sortida: 1000 neurones amb funció d'activació softmax per a la classificació de 1000 classes.
Exemple de codi en PyTorch
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.shortcut = nn.Sequential()
if stride != 1 or in_planes != self.expansion*planes:
self.shortcut = nn.Sequential(
nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(self.expansion*planes)
)
def forward(self, x):
out = F.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
out += self.shortcut(x)
out = F.relu(out)
return out
class ResNet(nn.Module):
def __init__(self, block, num_blocks, num_classes=1000):
super(ResNet, self).__init__()
self.in_planes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
self.linear = nn.Linear(512*block.expansion, num_classes)
def _make_layer(self, block, planes, num_blocks, stride):
strides = [stride] + [1]*(num_blocks-1)
layers = []
for stride in strides:
layers.append(block(self.in_planes, planes, stride))
self.in_planes = planes * block.expansion
return nn.Sequential(*layers)
def forward(self, x):
out = F.relu(self.bn1(self.conv1(x)))
out = F.max_pool2d(out, kernel_size=3, stride=2, padding=1)
out = self.layer1(out)
out = self.layer2(out)
out = self.layer3(out)
out = self.layer4(out)
out = F.avg_pool2d(out, 4)
out = out.view(out.size(0), -1)
out = self.linear(out)
return out
def ResNet50():
return ResNet(BasicBlock, [3, 4, 6, 3])
# Creació del model
model = ResNet50()Conclusió
En aquesta secció, hem explorat algunes de les arquitectures més populars de CNN, incloent LeNet-5, AlexNet, VGGNet i ResNet. Cada una d'aquestes arquitectures ha contribuït significativament al desenvolupament de la visió per computador i ha demostrat ser molt efectiva en diverses tasques de reconeixement d'imatges. A mesura que avancem, aquestes arquitectures serviran com a base per a comprendre i desenvolupar models més avançats en Deep Learning.
Curs de Deep Learning
Mòdul 1: Introducció a Deep Learning
- Què és Deep Learning?
- Història i evolució del Deep Learning
- Aplicacions de Deep Learning
- Conceptes bàsics de xarxes neuronals
Mòdul 2: Fonaments de Xarxes Neuronals
- Perceptró i Perceptró Multicapa
- Funció d'activació
- Propagació cap endavant i cap enrere
- Optimització i funció de pèrdua
Mòdul 3: Xarxes Neuronals Convolucionals (CNN)
- Introducció a les CNN
- Capes convolutionals i de pooling
- Arquitectures populars de CNN
- Aplicacions de CNN en reconeixement d'imatges
Mòdul 4: Xarxes Neuronals Recurrentes (RNN)
- Introducció a les RNN
- LSTM i GRU
- Aplicacions de RNN en processament del llenguatge natural
- Seqüències i sèries temporals
Mòdul 5: Tècniques Avançades en Deep Learning
- Xarxes Generatives Adversarials (GAN)
- Autoencoders
- Transfer Learning
- Regularització i tècniques de millora
Mòdul 6: Eines i Frameworks
- Introducció a TensorFlow
- Introducció a PyTorch
- Comparació de frameworks
- Entorns de desenvolupament i recursos addicionals
Mòdul 7: Projectes Pràctics
- Classificació d'imatges amb CNN
- Generació de text amb RNN
- Detecció d'anomalies amb Autoencoders
- Creació d'una GAN per generació d'imatges