R Academy · Урок

Создание последовательных моделей

Объединяйте полносвязные слои Dense, применяйте функции активации и компилируйте модель с функцией потерь и оптимизатором

«Создание последовательных моделей» — бесплатный урок R Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения 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) обучает модель. Каждая эпоха — это один полный проход по обучающим данным. Размер пакета определяет, сколько образцов обрабатывается перед каждым обновлением весов. Функция возвращает объект с историей обучения.

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

Регуляризация слоя — прореживание

layer_dropout(rate) во время обучения случайным образом устанавливает долю входных единиц, равную rate, в 0. Это не позволяет нейронам слишком тесно подстраиваться друг под друга и служит эффективным способом регуляризации. Прореживание активно только во время обучения, но не при применении модели.

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 классов какую функцию активации и сколько единиц должна использовать выходная слой?

Повторение: последовательные модели

Главные выводы из темы «Создание последовательных моделей»:

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)

Часто задаваемые вопросы

Урок «Создание последовательных моделей» бесплатный?

Да — полный текст урока «Создание последовательных моделей» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс R Academy, подпишись на CoddyKit PRO. Курс R Academy содержит 4 уроков всего.

Чему я научусь в уроке «Создание последовательных моделей»?

Объединяйте полносвязные слои Dense, применяйте функции активации и компилируйте модель с функцией потерь и оптимизатором Ты практикуешь R Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать R Academy?

Предыдущий опыт не требуется. R Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Создание последовательных моделей»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке R Academy?

Да. Каждый урок R Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

Настройка Keras и TensorFlow в R
Создание последовательных моделей
Основы свёрточных нейронных сетей
Обучение, проверка и предотвращение переобучения

← Назад к R Academy