R Academy · Aula

Construindo modelos sequenciais

Empilhe camadas Dense, aplique funções de ativação e compile com uma função de perda e um otimizador.

Construindo modelos sequenciais é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 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.

O modelo sequencial

Um modelo sequencial é uma sequência linear de camadas em que cada camada tem exatamente um tensor de entrada e um tensor de saída. É o tipo mais simples de modelo do Keras e atende à maioria dos casos de uso práticos: classificadores e regressores alimentados para frente, além de CNNs e RNNs básicas.

library(keras)

# An empty sequential model
model <- keras_model_sequential()
print(model)

# Or specify the input shape upfront
model <- keras_model_sequential(input_shape = c(20))
print(model)

layer_dense() — Camada totalmente conectada

layer_dense(units, activation) adiciona uma camada totalmente conectada (densa), na qual cada neurônio de entrada se conecta a cada neurônio de saída. O argumento units define a dimensionalidade da saída. activation aplica uma não linearidade: 'relu' é padrão para camadas ocultas.

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(units = 128, activation = 'relu') |>
  layer_dense(units = 64,  activation = 'relu') |>
  layer_dense(units = 1,   activation = 'sigmoid')

# Print architecture
summary(model)

Funções de ativação da camada de saída

A função de ativação da camada final depende da tarefa:

'sigmoid': classificação binária (produz uma probabilidade entre 0 e 1)
'softmax': classificação multiclasse (produz probabilidades cuja soma é 1)
'linear' ou nenhuma ativação: regressão (produz previsões com valores reais)

# Binary classification
binary_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'sigmoid')   # P(class=1)

# Multi-class (10 classes)
multi_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64,  activation = 'relu') |>
  layer_dense(10,  activation = 'softmax')  # P per class

# Regression
reg_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'linear')   # raw value

compile() — Perda, otimizador e métricas

compile(loss, optimizer, metrics) configura o processo de aprendizado. Combinações típicas:

Binária: loss = 'binary_crossentropy', metrics = 'accuracy'
Multiclasse: loss = 'categorical_crossentropy'
Regressão: loss = 'mse', metrics = 'mae'

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

# Check configuration
model$loss
model$optimizer$get_config()

optimizer_adam()

Adam (Estimação Adaptativa de Momentos) é o otimizador padrão para a maioria das tarefas de aprendizado profundo. Ele adapta a taxa de aprendizado para cada parâmetro usando estimativas do primeiro e do segundo momento dos gradientes. A taxa de aprendizado padrão, 0,001, é um bom ponto de partida para a maioria dos problemas.

# Adam with default settings
model |> compile(
  optimizer = 'adam',
  loss = 'binary_crossentropy',
  metrics = 'accuracy'
)

# Customised Adam
model |> compile(
  optimizer = optimizer_adam(
    learning_rate = 0.0005,
    beta_1  = 0.9,
    beta_2  = 0.999,
    epsilon = 1e-7
  ),
  loss    = 'binary_crossentropy',
  metrics = 'accuracy'
)

fit() — Treinando o modelo

fit(model, x, y, epochs, batch_size, validation_split) treina o modelo. Cada época é uma passagem completa pelos dados de treinamento. O tamanho do lote determina quantas amostras são processadas antes de cada atualização dos pesos. A função retorna um objeto de histórico.

# Prepare example data
x_train <- matrix(rnorm(1000 * 20), nrow = 1000)
y_train <- sample(c(0, 1), 1000, replace = TRUE)

history <- model |> fit(
  x         = x_train,
  y         = y_train,
  epochs    = 20,
  batch_size = 32,
  validation_split = 0.2,  # reserve 20% for validation
  verbose   = 1
)

plot(history)

Regularização de camadas — Dropout

layer_dropout(rate) define aleatoriamente uma fração rate das unidades de entrada como 0 durante o treinamento. Isso impede que os neurônios se adaptem excessivamente uns aos outros, atuando como um regularizador poderoso. O dropout só fica ativo durante o treinamento, não durante a inferência.

model <- keras_model_sequential(input_shape = c(784)) |>
  layer_dense(512, activation = 'relu') |>
  layer_dropout(rate = 0.4) |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(rate = 0.3) |>
  layer_dense(10,  activation = 'softmax')

summary(model)

Regularização de pesos L1 e L2

Regularize camadas individuais usando kernel_regularizer para penalizar pesos grandes. A L2 (ridge) penaliza a soma dos pesos ao quadrado; a L1 (lasso) penaliza os valores absolutos e induz esparsidade. Ambas estão disponíveis por meio de regularizer_l2() e regularizer_l1().

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(
    units = 64,
    activation = 'relu',
    kernel_regularizer = regularizer_l2(l = 0.01)
  ) |>
  layer_dense(
    units = 32,
    activation = 'relu',
    kernel_regularizer = regularizer_l1_l2(l1 = 1e-4, l2 = 1e-3)
  ) |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

Normalização em lotes

layer_batch_normalization() normaliza as ativações da camada anterior para cada minilote. Isso estabiliza o treinamento, permite taxas de aprendizado mais altas e atua como um regularizador moderado. Coloque-a depois de layer_dense() e antes da função de ativação, ou depois da ativação — ambas as abordagens são usadas na prática.

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(256, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(128, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

avaliar() e prever()

evaluate(model, x_test, y_test) calcula a perda e as métricas nos dados de teste. predict(model, x_new) gera previsões brutas — probabilidades para classificação. Ambas aceitam matrizes numéricas e retornam valores consistentes e nativos do R.

x_test <- matrix(rnorm(200 * 20), nrow = 200)
y_test <- sample(c(0, 1), 200, replace = TRUE)

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

# Generate predictions
prob_preds <- model |> predict(x_test)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
table(class_preds, y_test)

Salvando e carregando modelos

Salve um modelo compilado e treinado com save_model_tf(model, 'path') (formato TF SavedModel, recomendado) ou save_model_hdf5(model, 'model.h5'). Recarregue-o com load_model_tf() ou load_model_hdf5(). O modelo carregado mantém as configurações de compilação e pode fazer previsões ou continuar o treinamento imediatamente.

# Save in TensorFlow SavedModel format (recommended)
save_model_tf(model, '/tmp/my_dense_model')

# Reload
loaded <- load_model_tf('/tmp/my_dense_model')

# Confirm predictions match
new_preds <- loaded |> predict(x_test)
all.equal(prob_preds, new_preds)  # TRUE

Verificação rápida

Ao criar um modelo sequencial para um problema de classificação em 5 classes, qual função de ativação e quantas unidades a camada de saída deve usar?

Recapitulação dos modelos sequenciais

Principais conclusões sobre a criação de modelos sequenciais:

keras_model_sequential() cria uma sequência linear de camadas.
layer_dense(units, activation) é a camada totalmente conectada principal.
Ativação da saída: 'sigmoid' (binária), 'softmax' (multiclasse), 'linear' (regressão).
compile(loss, optimizer, metrics) configura o processo de aprendizado.
fit(model, x, y, epochs, batch_size, validation_split) treina o modelo.
Regularização: layer_dropout(rate), regularizer_l2(), layer_batch_normalization().
Salve com save_model_tf(); carregue com load_model_tf().

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(0.4) |>
  layer_dense(64, activation = 'relu') |>
  layer_dropout(0.3) |>
  layer_dense(1, activation = 'sigmoid')

model |> compile(
  optimizer = optimizer_adam(0.001),
  loss      = 'binary_crossentropy',
  metrics   = 'accuracy'
)

history <- model |> fit(
  x_train, y_train,
  epochs = 30, batch_size = 64,
  validation_split = 0.2, verbose = 0
)
plot(history)

Perguntas Frequentes

A aula “Construindo modelos sequenciais” é grátis?

Sim — o texto completo de “Construindo modelos sequenciais” é 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 “Construindo modelos sequenciais”?

Empilhe camadas Dense, aplique funções de ativação e compile com uma função de perda e um otimizador. 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 2 de 4.

Quanto tempo leva a aula “Construindo modelos sequenciais”?

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

Configurando Keras e TensorFlow no R
Construindo modelos sequenciais
Fundamentos das redes neurais convolucionais
Treinamento, validação e prevenção do sobreajuste

← Voltar para R Academy