PyTorch - Rede Neural Convolucional

O aprendizado profundo é uma divisão do aprendizado de máquina e é considerado um passo crucial dado pelos pesquisadores nas últimas décadas. Os exemplos de implementação de aprendizado profundo incluem aplicativos como reconhecimento de imagem e reconhecimento de voz.

Os dois tipos importantes de redes neurais profundas são fornecidos abaixo -

• Redes Neurais Convolucionais
• Redes Neurais Recorrentes.

Neste capítulo, iremos nos concentrar no primeiro tipo, ou seja, Redes Neurais Convolucionais (CNN).

Redes Neurais Convolucionais

As redes neurais convolucionais são projetadas para processar dados por meio de várias camadas de matrizes. Esse tipo de rede neural é usado em aplicativos como reconhecimento de imagem ou reconhecimento de rosto.

A principal diferença entre o CNN e qualquer outra rede neural comum é que o CNN recebe a entrada como uma matriz bidimensional e opera diretamente nas imagens, em vez de focar na extração de recursos em que outras redes neurais se concentram.

A abordagem dominante da CNN inclui solução para problemas de reconhecimento. Grandes empresas como Google e Facebook têm investido em projetos de pesquisa e desenvolvimento de projetos de reconhecimento para realizar as atividades com maior agilidade.

Cada rede neural convolucional inclui três idéias básicas -

• Respectivos campos locais
• Convolution
• Pooling

Vamos entender cada uma dessas terminologias em detalhes.

Campos Respectivos Locais

A CNN utiliza correlações espaciais que existem nos dados de entrada. Cada uma nas camadas concorrentes de redes neurais se conecta a alguns neurônios de entrada. Esta região específica é chamada de Campo Receptivo Local. Ele se concentra apenas em neurônios ocultos. O neurônio oculto processará os dados de entrada dentro do campo mencionado, sem perceber as mudanças fora do limite específico.

A representação do diagrama de geração dos respectivos campos locais é mencionada abaixo -

Convolução

Na figura acima, observamos que cada conexão aprende um peso de neurônio oculto com uma conexão associada ao movimento de uma camada para outra. Aqui, os neurônios individuais realizam uma mudança de tempos em tempos. Este processo é denominado “convolução”.

O mapeamento de conexões da camada de entrada para o mapa de feições ocultas é definido como “pesos compartilhados” e o viés incluído é chamado de “viés compartilhado”.

Pooling

As redes neurais convolucionais usam camadas de pooling que são posicionadas imediatamente após a declaração da CNN. Ele recebe a entrada do usuário como um mapa de características que sai das redes convolucionais e prepara um mapa de características condensado. O agrupamento de camadas ajuda na criação de camadas com neurônios de camadas anteriores.

Implementação de PyTorch

As etapas a seguir são usadas para criar uma rede neural convolucional usando PyTorch.

Passo 1

Importe os pacotes necessários para criar uma rede neural simples.

from torch.autograd import Variable
import torch.nn.functional as F

Passo 2

Crie uma classe com representação em lote de rede neural convolucional. Nosso formato de lote para a entrada x tem dimensão de (3, 32, 32).

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

etapa 3

Calcule a ativação das primeiras mudanças de tamanho de convolução de (3, 32, 32) a (18, 32, 32).

O tamanho da dimensão muda de (18, 32, 32) para (18, 16, 16). Remodele a dimensão dos dados da camada de entrada da rede neural devido à qual o tamanho muda de (18, 16, 16) para (1, 4608).

Lembre-se de que -1 infere essa dimensão da outra dimensão fornecida.

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)