0Pricing
R Academy · Aula

Fundamentos das redes neurais convolucionais

Adicione camadas Conv2D e MaxPooling para tarefas de classificação de imagens.

Fundamentos das redes neurais convolucionais é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Por que CNNs são usadas para imagens?

Uma rede densa trata os pixels de forma independente, perdendo as relações espaciais. Uma rede neural convolucional (CNN) aplica filtros treináveis que deslizam pela entrada, detectando padrões locais, como bordas, texturas e formas, independentemente da posição. Essa invariância à translação e o compartilhamento de parâmetros fazem das CNNs o padrão de excelência para dados de imagem.

library(keras)

# Images are 3D tensors: (height, width, channels)
# MNIST: (28, 28, 1) — grayscale
# CIFAR-10: (32, 32, 3) — RGB

# Reshape flat vectors into image tensors
mnist <- dataset_mnist()
x_train <- array_reshape(mnist$train$x / 255, c(-1, 28, 28, 1))
y_train <- to_categorical(mnist$train$y, 10)

cat('Input shape:', dim(x_train))

layer_conv_2d() — A camada principal

layer_conv_2d(filters, kernel_size, activation) aplica filters núcleos 2D treináveis de tamanho kernel_size à entrada. Cada filtro aprende a detectar um tipo de padrão espacial. A saída tem o formato (height, width, filters).

library(keras)

# First conv layer: 32 filters of 3x3
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(
    filters     = 32,
    kernel_size = c(3, 3),
    activation  = 'relu',
    padding     = 'same'  # keep spatial dimensions
  )

summary(model)  # output: (None, 28, 28, 32)

layer_max_pooling_2d()

layer_max_pooling_2d(pool_size) reduz as dimensões espaciais selecionando o valor máximo em cada janela de agrupamento. Isso alcança dois objetivos: reduz o número de parâmetros nas camadas seguintes e introduz um certo grau de invariância à translação (pequenos deslocamentos não alteram drasticamente a saída).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, kernel_size = c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(pool_size = c(2, 2))

summary(model)
# After pooling: (None, 13, 13, 32)
# Spatial dims halved, channel count preserved

Empilhando camadas convolucionais

CNNs mais profundas empilham vários blocos de convolução e agrupamento. As camadas iniciais detectam características de baixo nível (bordas, gradientes); as camadas mais profundas combinam essas características em elementos de alto nível (formas, objetos). Cada camada convolucional aumenta o número de filtros para compensar a redução das dimensões espaciais.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 16x16
  layer_conv_2d(64, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 8x8
  layer_conv_2d(128, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2))      # 4x4

summary(model)

layer_flatten()

layer_flatten() converte a saída 3D do último bloco convolucional (height, width, filters) em um vetor 1D. Essa é a ponte entre a base de extração de características (camadas convolucionais) e o classificador (camadas densas).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>     # 3D -> 1D vector
  layer_dense(128, activation = 'relu') |>
  layer_dense(10, activation = 'softmax')

summary(model)

layer_dropout() em CNNs

Em CNNs, o dropout normalmente é aplicado depois da camada de achatamento e das camadas densas, não dentro dos blocos convolucionais (onde o dropout espacial layer_spatial_dropout_2d() é preferível). Uma taxa de 0.25 a 0.5 depois da primeira camada densa é comum.

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(rate = 0.5) |>    # regularise the classifier head
  layer_dense(10, activation = 'softmax')

summary(model)

Compilando e treinando uma CNN

Compile e treine uma CNN da mesma forma que uma rede densa. Para classificação multiclasse com rótulos one-hot, use 'categorical_crossentropy'; para rótulos inteiros, use 'sparse_categorical_crossentropy'. As CNNs geralmente se beneficiam de uma taxa de aprendizado um pouco menor que a das redes densas.

model |> compile(
  optimizer = optimizer_adam(learning_rate = 0.0005),
  loss      = 'categorical_crossentropy',
  metrics   = c('accuracy')
)

history <- model |> fit(
  x = x_train,
  y = y_train,
  epochs     = 10,
  batch_size = 64,
  validation_split = 0.1,
  verbose = 1
)

plot(history)

Aumento de dados

Treinar CNNs com conjuntos de dados pequenos geralmente causa sobreajuste. O aumento de dados amplia artificialmente o conjunto de treinamento aplicando transformações aleatórias (inversões, rotações e ampliações) durante o treinamento. No keras3, use layer_random_flip() e layer_random_rotation() como camadas de pré-processamento dentro do modelo.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  # Data augmentation layers (only active during training)
  layer_random_flip('horizontal') |>
  layer_random_rotation(factor = 0.1) |>
  layer_random_zoom(height_factor = 0.1) |>
  # CNN backbone
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')

summary(model)

Avaliando a CNN

evaluate(model, x_test, y_test) retorna a perda e a acurácia nos dados de teste. Para uma análise mais aprofundada, use predict() para obter as probabilidades das classes e, em seguida, crie uma matriz de confusão ou calcule as pontuações F1 por classe para entender em quais situações o modelo tem dificuldades.

# Evaluate on test set
test_scores <- model |> evaluate(x_test, y_test, verbose = 0)
cat('Test accuracy:', test_scores['accuracy'])

# Get predicted classes
prob_matrix <- model |> predict(x_test)
pred_classes <- max.col(prob_matrix) - 1  # 0-indexed
true_classes <- mnist$test$y

# Confusion matrix
table(Predicted = pred_classes, True = true_classes)

Conceito de aprendizado por transferência

Treinar uma CNN do zero exige grandes conjuntos de dados. O aprendizado por transferência reutiliza camadas de extração de características pré-treinadas no ImageNet (por exemplo, VGG, ResNet e MobileNet) e treina apenas um classificador personalizado. No keras, carregue uma base pré-treinada com application_mobilenet_v2() e congele suas camadas.

# Load MobileNetV2 pretrained on ImageNet
base_model <- application_mobilenet_v2(
  weights      = 'imagenet',
  include_top  = FALSE,          # remove original classifier head
  input_shape  = c(224, 224, 3)
)

# Freeze pretrained weights
base_model$trainable <- FALSE

# Add custom classifier head
model <- keras_model(
  inputs  = base_model$input,
  outputs = base_model$output |>
    layer_global_average_pooling_2d() |>
    layer_dense(128, activation = 'relu') |>
    layer_dense(5, activation = 'softmax')
)

Preenchimento e passos do Conv2D

Dois argumentos importantes de layer_conv_2d: padding = 'same' adiciona zeros ao redor da entrada para que a saída tenha o mesmo tamanho espacial da entrada; padding = 'valid' (padrão) reduz as dimensões em kernel_size - 1. strides = c(2,2) substitui o agrupamento máximo fazendo o filtro deslizar em passos de 2.

# 'same' padding: output = input size
conv_same <- layer_conv_2d(filters = 32, kernel_size = c(3, 3),
                           padding = 'same')

# Strided convolution instead of pooling
conv_strided <- layer_conv_2d(filters = 64, kernel_size = c(3, 3),
                              strides = c(2, 2),  # halves spatial dims
                              padding = 'same')

# Model using strides instead of max pooling
model2 <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_conv_2d(64, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')
summary(model2)

Verificação rápida

Qual é o objetivo principal de layer_max_pooling_2d(pool_size = c(2, 2)) em uma CNN?

Recapitulação das CNNs

Principais conclusões sobre os fundamentos das redes neurais convolucionais:

  • As CNNs usam campos receptivos locais e compartilhamento de parâmetros para processar imagens com eficiência.
  • layer_conv_2d(filters, kernel_size, activation) extrai características espaciais.
  • layer_max_pooling_2d(pool_size) reduz a resolução e fornece invariância à translação.
  • layer_flatten() conecta a base convolucional à camada classificadora densa.
  • layer_dropout(rate) regulariza o classificador.
  • Camadas de aumento de dados (layer_random_flip(), entre outras) reduzem o sobreajuste.
  • O aprendizado por transferência com bases pré-treinadas é a abordagem prática para conjuntos de dados pequenos.
# Standard CNN architecture for image classification
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(64,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(128, c(3,3), activation = 'relu', padding = 'same') |>
  layer_flatten() |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(0.5) |>
  layer_dense(num_classes, activation = 'softmax')

model |> compile('adam', 'categorical_crossentropy', 'accuracy')
summary(model)

Perguntas Frequentes

A aula “Fundamentos das redes neurais convolucionais” é grátis?

Sim — o texto completo de “Fundamentos das redes neurais convolucionais” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Fundamentos das redes neurais convolucionais”?

Adicione camadas Conv2D e MaxPooling para tarefas de classificação de imagens. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Fundamentos das redes neurais convolucionais”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Configurando Keras e TensorFlow no R
  2. Construindo modelos sequenciais
  3. Fundamentos das redes neurais convolucionais
  4. Treinamento, validação e prevenção do sobreajuste
← Voltar para R Academy