0Pricing
R Academy · 课时

构建序列模型

堆叠 Dense 层，应用激活函数，并使用损失函数和优化器进行编译

构建序列模型 是 CoddyKit 上的免费 R Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 R Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 R Academy 课程共包含 4 节课。

顺序模型

顺序模型是由多个层按线性顺序堆叠而成的模型，其中每一层恰好有一个输入张量和一个输出张量。它是最简单的 Keras 模型类型，适用于大多数实际场景：前馈分类器、回归器以及基础 CNN/RNN。

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() — 全连接层

layer_dense(units, activation) 会添加一个全连接（稠密）层，其中每个输入神经元都连接到每个输出神经元。units 参数设置输出维度。activation 应用非线性变换：'relu' 是隐藏层的标准选择。

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)

输出层激活函数

最终层的激活函数取决于任务类型：

  • 'sigmoid'：二分类（输出 0 到 1 之间的概率）
  • 'softmax'：多分类（输出总和为 1 的概率）
  • 'linear' 或不使用激活函数：回归（输出实数预测值）
# 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() — 损失函数、优化器和指标

compile(loss, optimizer, metrics) 用于配置学习过程。常见组合如下：

  • 二分类：loss = 'binary_crossentropy'，metrics = 'accuracy'
  • 多分类：loss = 'categorical_crossentropy'
  • 回归：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（自适应矩估计）是大多数深度学习任务的默认优化器。它利用梯度一阶矩和二阶矩的估计值，为每个参数调整学习率。默认学习率 0.001 是大多数问题的良好起点。

# 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() — 训练模型

fit(model, x, y, epochs, batch_size, validation_split) 用于训练模型。每个训练轮次（epoch）表示完整遍历一次训练数据。批次大小决定每次更新权重前要处理的样本数量。该函数会返回一个历史记录对象。

# 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)

层正则化 — Dropout

layer_dropout(rate) 会在训练期间随机将输入单元的一部分（比例为 rate）设置为 0。这样可以防止神经元过度协同适应，从而起到强大的正则化作用。Dropout 仅在训练期间启用，在推理期间不会启用。

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)

L1 和 L2 权重正则化

使用 kernel_regularizer 对各个层进行正则化，以惩罚较大的权重。L2（岭）正则化惩罚权重平方和；L1（套索）正则化惩罚权重绝对值，并促使权重变得稀疏。两者分别可通过 regularizer_l2() 和 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)

批归一化

layer_batch_normalization() 会针对每个小批次，对前一层的激活值进行归一化。这样可以稳定训练过程、允许使用更高的学习率，并起到轻度正则化的作用。请将它放在 layer_dense() 之后、激活函数之前，或者放在激活函数之后——这两种方式在实践中都会使用。

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)

evaluate() 与 predict()

evaluate(model, x_test, y_test) 用测试数据计算损失和指标。predict(model, x_new) 生成原始预测结果——分类问题中即为概率。两者都接受数值矩阵，并返回一致的 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)

保存和加载模型

使用 save_model_tf(model, 'path')（TF SavedModel 格式，推荐）或 save_model_hdf5(model, 'model.h5') 保存已编译和训练好的模型。使用 load_model_tf() 或 load_model_hdf5() 重新加载。加载后的模型会保留编译设置，并且可以立即进行预测或继续训练。

# 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

快速检查

为 5 类分类问题构建 sequential 模型时，输出层应使用什么激活函数和多少个单元？

Sequential 模型回顾

构建 Sequential 模型的要点：

  • keras_model_sequential() 创建由多个层线性堆叠而成的模型。
  • layer_dense(units, activation) 是核心的全连接层。
  • 输出激活函数：'sigmoid'（二分类）、'softmax'（多分类）、'linear'（回归）。
  • compile(loss, optimizer, metrics) 配置学习过程。
  • fit(model, x, y, epochs, batch_size, validation_split) 训练模型。
  • 正则化：layer_dropout(rate)、regularizer_l2()、layer_batch_normalization()。
  • 使用 save_model_tf() 保存；使用 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)

常见问题解答

「构建序列模型」课时是免费的吗？

是的 — 「构建序列模型」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 R Academy 课程的其余内容，请升级到 CoddyKit PRO。 R Academy 课程共包含 4 节课。

「构建序列模型」这节课中我会学到什么？

堆叠 Dense 层，应用激活函数，并使用损失函数和优化器进行编译 你通过在浏览器中直接运行的动手代码来练习 R Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 R Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 R Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。

「构建序列模型」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 R Academy 课中编写并运行代码吗？

能。每节 R Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 在 R 中设置 Keras 和 TensorFlow
  2. 构建序列模型
  3. 卷积神经网络基础
  4. 训练、验证与防止过拟合
← 返回 R Academy