PricingLoginStart free
R Academy · Pelajaran

Membina Model Berjujukan

Susun lapisan Dense, gunakan pengaktifan dan susun model dengan fungsi kehilangan serta pengoptimum.

Pelajaran 2 daripada 413 langkah

Membina Model Berjujukan ialah pelajaran R Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran R Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Model Berjujukan

Model berjujukan ialah susunan linear lapisan yang setiap lapisannya mempunyai tepat satu tensor masukan dan satu tensor keluaran. Ini ialah jenis model Keras yang paling mudah dan merangkumi kebanyakan kes penggunaan praktikal: pengelas suapan hadapan, model regresi dan CNN/RNN asas.

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() — Lapisan Bersambung Penuh

layer_dense(units, activation) menambah lapisan bersambung penuh (padat), iaitu setiap neuron masukan bersambung kepada setiap neuron keluaran. Argumen units menetapkan dimensi keluaran. activation menggunakan bukan lineariti: 'relu' ialah pilihan standard untuk lapisan tersembunyi.

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)

Pengaktifan Lapisan Keluaran

Pengaktifan lapisan akhir bergantung pada tugas:

  • 'sigmoid': pengelasan binari (menghasilkan kebarangkalian 0–1)
  • 'softmax': pengelasan berbilang kelas (menghasilkan kebarangkalian yang jumlahnya 1)
  • 'linear' atau tiada pengaktifan: regresi (menghasilkan ramalan bernilai nyata)
# 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() — Kehilangan, Pengoptimum, Metrik

compile(loss, optimizer, metrics) mengkonfigurasi proses pembelajaran. Gabungan yang biasa:

  • Binari: loss = 'binary_crossentropy', metrics = 'accuracy'
  • Berbilang kelas: loss = 'categorical_crossentropy'
  • Regresi: 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 (Anggaran Momen Adaptif) ialah pengoptimum lalai untuk kebanyakan tugas pembelajaran mendalam. Ia menyesuaikan kadar pembelajaran bagi setiap parameter menggunakan anggaran momen pertama dan kedua kecerunan. Kadar pembelajaran lalai 0.001 ialah titik permulaan yang baik untuk kebanyakan masalah.

# 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() — Melatih Model

fit(model, x, y, epochs, batch_size, validation_split) melatih model. Setiap epok ialah satu laluan lengkap melalui data latihan. Saiz kelompok menentukan bilangan sampel yang diproses sebelum setiap kemas kini pemberat. Fungsi ini mengembalikan objek sejarah.

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

Pelarasan Lapisan — Dropout

layer_dropout(rate) menetapkan sebahagian unit masukan, secara rawak, kepada 0 semasa latihan. Ini menghalang neuron daripada menyesuaikan diri bersama secara terlalu rapat, sekali gus bertindak sebagai pengatur kuat. Dropout hanya aktif semasa latihan, bukan semasa inferens.

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)

Pelarasan Pemberat L1 dan L2

Laraskan lapisan individu menggunakan kernel_regularizer untuk mengenakan penalti terhadap pemberat yang besar. L2 (ridge) mengenakan penalti terhadap jumlah kuasa dua pemberat; L1 (lasso) mengenakan penalti terhadap nilai mutlak dan menghasilkan kekosongan. Kedua-duanya tersedia melalui regularizer_l2() dan 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)

Penormalan Kelompok

layer_batch_normalization() menormalkan pengaktifan lapisan sebelumnya bagi setiap kelompok kecil. Ini menstabilkan latihan, membolehkan kadar pembelajaran yang lebih tinggi dan bertindak sebagai pengatur sederhana. Letakkannya selepas layer_dense() dan sebelum fungsi pengaktifan, atau selepas pengaktifan — kedua-dua susunan digunakan dalam amalan.

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() dan predict()

evaluate(model, x_test, y_test) mengira kehilangan dan metrik pada data ujian. predict(model, x_new) menjana ramalan mentah — kebarangkalian untuk pengelasan. Kedua-duanya menerima matriks berangka dan mengembalikan nilai yang konsisten serta asli kepada 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)

Menyimpan dan Memuatkan Model

Simpan model yang telah dikompil dan dilatih dengan save_model_tf(model, 'path') (format TF SavedModel, disyorkan) atau save_model_hdf5(model, 'model.h5'). Muatkan semula dengan load_model_tf() atau load_model_hdf5(). Model yang dimuatkan mengekalkan tetapan kompilasi dan boleh terus membuat ramalan atau meneruskan latihan.

# 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

Semakan Pantas

Apabila membina model berjujukan untuk masalah pengelasan 5 kelas, apakah fungsi pengaktifan dan bilangan unit yang harus digunakan oleh lapisan output?

Jawab dalam pelajaran interaktif

Imbas Kembali Model Berjujukan

Perkara penting daripada Membina Model Berjujukan:

  • keras_model_sequential() mencipta susunan lapisan linear.
  • layer_dense(units, activation) ialah lapisan teras yang bersambung sepenuhnya.
  • Pengaktifan output: 'sigmoid' (binari), 'softmax' (berbilang kelas), 'linear' (regresi).
  • compile(loss, optimizer, metrics) mengkonfigurasi proses pembelajaran.
  • fit(model, x, y, epochs, batch_size, validation_split) melatih model.
  • Pelarasan regularisasi: layer_dropout(rate), regularizer_l2(), layer_batch_normalization().
  • Simpan dengan save_model_tf(); muatkan dengan 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)
Percuma untuk bermula

Pelajari R dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
43
Pelajaran
159
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membina Model Berjujukan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran R Academy, termasuk “Membina Model Berjujukan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membina Model Berjujukan”?

Susun lapisan Dense, gunakan pengaktifan dan susun model dengan fungsi kehilangan serta pengoptimum. Anda berlatih R Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan R Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran R Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Membina Model Berjujukan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Menyediakan Keras dan TensorFlow dalam R
  2. Membina Model Berjujukan
  3. Asas Rangkaian Neural Konvolusi
  4. Latihan, Pengesahan dan Pencegahan Terlebih Suai
← Kembali ke R Academy