Membangun Model Sekuensial
Susun lapisan Dense, terapkan fungsi aktivasi, lalu kompilasikan dengan fungsi kerugian dan pengoptimal.
Membangun Model Sekuensial adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.
Model Sequential
Model sequential adalah susunan linear lapisan, dengan setiap lapisan memiliki tepat satu tensor masukan dan satu tensor keluaran. Ini adalah jenis model Keras yang paling sederhana dan mencakup sebagian besar kasus penggunaan praktis: pengklasifikasi feedforward, model regresi, serta CNN/RNN dasar.
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 Terhubung Penuh
layer_dense(units, activation) menambahkan lapisan terhubung penuh (dense), dengan setiap neuron masukan terhubung ke setiap neuron keluaran. Argumen units menetapkan dimensi keluaran. activation menerapkan non-linearitas: 'relu' merupakan pilihan standar 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)Aktivasi Lapisan Keluaran
Aktivasi lapisan terakhir bergantung pada tugasnya:
'sigmoid': klasifikasi biner (menghasilkan probabilitas 0–1)'softmax': klasifikasi multikelas (menghasilkan probabilitas yang jumlahnya 1)'linear'atau tanpa aktivasi: regresi (menghasilkan prediksi bernilai riil)
# 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 valuecompile() — Kerugian, Pengoptimal, Metrik
compile(loss, optimizer, metrics) mengonfigurasi proses pembelajaran. Kombinasi yang umum:
- Biner:
loss = 'binary_crossentropy',metrics = 'accuracy' - Multikelas:
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 (Adaptive Moment Estimation) adalah pengoptimal bawaan untuk sebagian besar tugas pembelajaran mendalam. Adam menyesuaikan laju pembelajaran untuk setiap parameter menggunakan perkiraan momen pertama dan kedua dari gradien. Laju pembelajaran bawaan sebesar 0,001 merupakan titik awal yang baik untuk sebagian besar 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 epoch adalah satu kali proses lengkap melalui data pelatihan. Ukuran batch menentukan jumlah sampel yang diproses sebelum setiap pembaruan bobot. Fungsi ini mengembalikan objek riwayat.
# 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)Regularisasi Lapisan — Dropout
layer_dropout(rate) secara acak menetapkan sebagian unit masukan sebesar rate menjadi 0 selama pelatihan. Hal ini mencegah neuron beradaptasi bersama secara terlalu erat dan berfungsi sebagai regularisasi yang kuat. Dropout hanya aktif selama pelatihan, bukan saat inferensi.
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)Regularisasi Bobot L1 dan L2
Regularisasikan lapisan individual menggunakan kernel_regularizer untuk memberikan penalti pada bobot yang besar. L2 (ridge) memberikan penalti pada jumlah kuadrat bobot; L1 (lasso) memberikan penalti pada nilai absolut dan menghasilkan sparsitas. Keduanya 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)Normalisasi Batch
layer_batch_normalization() menormalisasi aktivasi lapisan sebelumnya untuk setiap batch mini. Hal ini menstabilkan pelatihan, memungkinkan laju pembelajaran yang lebih tinggi, dan berfungsi sebagai regularisasi ringan. Letakkan fungsi ini setelah layer_dense() dan sebelum fungsi aktivasi, atau setelah aktivasi — keduanya digunakan dalam praktik.
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) menghitung nilai kerugian dan metrik pada data pengujian. predict(model, x_new) menghasilkan prediksi mentah—probabilitas untuk klasifikasi. Keduanya menerima matriks numerik dan mengembalikan nilai yang konsisten dalam format asli 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 Memuat Model
Simpan model yang telah dikompilasi dan dilatih dengan save_model_tf(model, 'path') (format TF SavedModel, direkomendasikan) atau save_model_hdf5(model, 'model.h5'). Muat ulang dengan load_model_tf() atau load_model_hdf5(). Model yang dimuat mempertahankan pengaturan kompilasi dan dapat langsung digunakan untuk melakukan prediksi atau melanjutkan pelatihan.
# 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) # TRUEPemeriksaan Singkat
Saat membangun model berurutan untuk masalah klasifikasi dengan 5 kelas, fungsi aktivasi dan jumlah unit apa yang harus digunakan oleh lapisan keluaran?
Ringkasan Model Berurutan
Hal-hal penting dari Membangun Model Berurutan:
keras_model_sequential()membuat susunan lapisan secara linear.layer_dense(units, activation)adalah lapisan inti yang terhubung penuh.- Aktivasi keluaran:
'sigmoid'(biner),'softmax'(multikelas),'linear'(regresi). compile(loss, optimizer, metrics)mengonfigurasi proses pembelajaran.fit(model, x, y, epochs, batch_size, validation_split)melatih model.- Regularisasi:
layer_dropout(rate),regularizer_l2(),layer_batch_normalization(). - Simpan dengan
save_model_tf(); muat denganload_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)
Belajar R dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 43
- Pelajaran
- 159
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Membangun Model Sekuensial” gratis?
Ya — teks lengkap “Membangun Model Sekuensial” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Membangun Model Sekuensial”?
Susun lapisan Dense, terapkan fungsi aktivasi, lalu kompilasikan dengan fungsi kerugian dan pengoptimal. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai R Academy?
Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Membangun Model Sekuensial” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?
Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Menyiapkan Keras dan TensorFlow di R
- Membangun Model Sekuensial
- Dasar-Dasar Jaringan Saraf Konvolusional
- Pelatihan, Validasi, dan Pencegahan Overfitting