Dasar-Dasar Jaringan Saraf Konvolusional
Tambahkan lapisan Conv2D dan MaxPooling untuk tugas klasifikasi gambar.
Dasar-Dasar Jaringan Saraf Konvolusional adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.
Mengapa CNN untuk Citra?
Jaringan padat memperlakukan piksel secara terpisah sehingga kehilangan hubungan spasial. Jaringan saraf konvolusional (CNN) menerapkan filter yang dapat dipelajari dan digeser melintasi masukan untuk mendeteksi pola lokal seperti tepi, tekstur, dan bentuk, terlepas dari posisinya. Invariansi terhadap translasi dan penggunaan parameter bersama ini menjadikan CNN pilihan standar untuk data citra.
library(keras)
# Images are 3D tensors: (height, width, channels)
# MNIST: (28, 28, 1) — grayscale
# CIFAR-10: (32, 32, 3) — RGB
# Reshape flat vectors into image tensors
mnist <- dataset_mnist()
x_train <- array_reshape(mnist$train$x / 255, c(-1, 28, 28, 1))
y_train <- to_categorical(mnist$train$y, 10)
cat('Input shape:', dim(x_train))layer_conv_2d() — Lapisan Inti
layer_conv_2d(filters, kernel_size, activation) menerapkan filters kernel 2D yang dapat dipelajari, berukuran kernel_size, pada masukan. Setiap filter belajar mendeteksi satu jenis pola spasial. Keluaran memiliki bentuk (height, width, filters).
library(keras)
# First conv layer: 32 filters of 3x3
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
layer_conv_2d(
filters = 32,
kernel_size = c(3, 3),
activation = 'relu',
padding = 'same' # keep spatial dimensions
)
summary(model) # output: (None, 28, 28, 32)layer_max_pooling_2d()
layer_max_pooling_2d(pool_size) mengurangi dimensi spasial dengan mengambil nilai maksimum pada setiap jendela pooling. Hal ini memberikan dua manfaat: mengurangi jumlah parameter pada lapisan berikutnya dan memperkenalkan tingkat invariansi terhadap translasi (pergeseran kecil tidak mengubah keluaran secara drastis).
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
layer_conv_2d(32, kernel_size = c(3, 3), activation = 'relu') |>
layer_max_pooling_2d(pool_size = c(2, 2))
summary(model)
# After pooling: (None, 13, 13, 32)
# Spatial dims halved, channel count preservedMenumpuk Lapisan Konvolusi
CNN yang lebih dalam menumpuk beberapa blok Conv+Pool. Lapisan awal mendeteksi fitur tingkat rendah (tepi, gradien), sedangkan lapisan yang lebih dalam menggabungkannya menjadi fitur tingkat tinggi (bentuk, objek). Setiap lapisan Conv menambah jumlah filter untuk mengimbangi penyusutan dimensi spasial.
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
layer_max_pooling_2d(c(2, 2)) |> # 16x16
layer_conv_2d(64, c(3, 3), activation = 'relu', padding = 'same') |>
layer_max_pooling_2d(c(2, 2)) |> # 8x8
layer_conv_2d(128, c(3, 3), activation = 'relu', padding = 'same') |>
layer_max_pooling_2d(c(2, 2)) # 4x4
summary(model)layer_flatten()
layer_flatten() mengubah keluaran 3D dari blok konvolusi terakhir (height, width, filters) menjadi vektor 1D. Lapisan ini menjadi penghubung antara bagian utama ekstraksi fitur (lapisan konvolusional) dan bagian klasifikasi (lapisan padat).
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
layer_conv_2d(32, c(3, 3), activation = 'relu') |>
layer_max_pooling_2d(c(2, 2)) |>
layer_conv_2d(64, c(3, 3), activation = 'relu') |>
layer_max_pooling_2d(c(2, 2)) |>
layer_flatten() |> # 3D -> 1D vector
layer_dense(128, activation = 'relu') |>
layer_dense(10, activation = 'softmax')
summary(model)layer_dropout() dalam CNN
Dalam CNN, dropout biasanya diterapkan setelah lapisan perataan dan lapisan padat, bukan di dalam blok konvolusional (di sana spatial dropout layer_spatial_dropout_2d() lebih disarankan). Nilai rate 0,25–0,5 setelah lapisan padat pertama merupakan pilihan yang umum.
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
layer_conv_2d(32, c(3, 3), activation = 'relu') |>
layer_max_pooling_2d(c(2, 2)) |>
layer_conv_2d(64, c(3, 3), activation = 'relu') |>
layer_max_pooling_2d(c(2, 2)) |>
layer_flatten() |>
layer_dense(128, activation = 'relu') |>
layer_dropout(rate = 0.5) |> # regularise the classifier head
layer_dense(10, activation = 'softmax')
summary(model)Mengompilasi dan Melatih CNN
Kompilasi dan latih CNN dengan cara yang sama seperti jaringan padat. Untuk klasifikasi multikelas dengan label one-hot, gunakan 'categorical_crossentropy'; untuk label bilangan bulat, gunakan 'sparse_categorical_crossentropy'. CNN sering memberikan hasil lebih baik dengan laju pembelajaran yang sedikit lebih rendah daripada jaringan padat.
model |> compile(
optimizer = optimizer_adam(learning_rate = 0.0005),
loss = 'categorical_crossentropy',
metrics = c('accuracy')
)
history <- model |> fit(
x = x_train,
y = y_train,
epochs = 10,
batch_size = 64,
validation_split = 0.1,
verbose = 1
)
plot(history)Augmentasi Data
Melatih CNN pada kumpulan data kecil sering menyebabkan overfitting. Augmentasi data memperluas kumpulan data pelatihan secara artifisial dengan menerapkan transformasi acak (pembalikan, rotasi, pembesaran) selama pelatihan. Dalam keras3, gunakan layer_random_flip() dan layer_random_rotation() sebagai lapisan prapemrosesan di dalam model.
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
# Data augmentation layers (only active during training)
layer_random_flip('horizontal') |>
layer_random_rotation(factor = 0.1) |>
layer_random_zoom(height_factor = 0.1) |>
# CNN backbone
layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
layer_max_pooling_2d(c(2, 2)) |>
layer_flatten() |>
layer_dense(10, activation = 'softmax')
summary(model)Mengevaluasi CNN
evaluate(model, x_test, y_test) mengembalikan nilai kerugian dan akurasi pengujian. Untuk analisis yang lebih mendalam, gunakan predict() untuk memperoleh probabilitas kelas, lalu buat matriks kebingungan atau hitung skor F1 per kelas untuk memahami bagian yang masih sulit diprediksi oleh model.
# Evaluate on test set
test_scores <- model |> evaluate(x_test, y_test, verbose = 0)
cat('Test accuracy:', test_scores['accuracy'])
# Get predicted classes
prob_matrix <- model |> predict(x_test)
pred_classes <- max.col(prob_matrix) - 1 # 0-indexed
true_classes <- mnist$test$y
# Confusion matrix
table(Predicted = pred_classes, True = true_classes)Konsep Pembelajaran Transfer
Melatih CNN dari awal memerlukan kumpulan data yang besar. Pembelajaran transfer menggunakan kembali lapisan ekstraksi fitur yang telah dilatih sebelumnya pada ImageNet (misalnya VGG, ResNet, MobileNet), lalu hanya melatih bagian klasifikasi khusus. Dalam keras, muat bagian dasar yang telah dilatih dengan application_mobilenet_v2() dan bekukan lapisannya.
# Load MobileNetV2 pretrained on ImageNet
base_model <- application_mobilenet_v2(
weights = 'imagenet',
include_top = FALSE, # remove original classifier head
input_shape = c(224, 224, 3)
)
# Freeze pretrained weights
base_model$trainable <- FALSE
# Add custom classifier head
model <- keras_model(
inputs = base_model$input,
outputs = base_model$output |>
layer_global_average_pooling_2d() |>
layer_dense(128, activation = 'relu') |>
layer_dense(5, activation = 'softmax')
)Padding dan Stride Conv2D
Dua argumen penting untuk layer_conv_2d: padding = 'same' menambahkan nol di sekeliling masukan sehingga keluaran memiliki ukuran spasial yang sama dengan masukan; padding = 'valid' (bawaan) mengurangi dimensi sebesar kernel_size - 1. strides = c(2,2) menggantikan max pooling dengan menggeser filter dalam langkah berukuran 2.
# 'same' padding: output = input size
conv_same <- layer_conv_2d(filters = 32, kernel_size = c(3, 3),
padding = 'same')
# Strided convolution instead of pooling
conv_strided <- layer_conv_2d(filters = 64, kernel_size = c(3, 3),
strides = c(2, 2), # halves spatial dims
padding = 'same')
# Model using strides instead of max pooling
model2 <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
layer_conv_2d(32, c(3,3), strides = c(2,2), activation = 'relu',
padding = 'same') |>
layer_conv_2d(64, c(3,3), strides = c(2,2), activation = 'relu',
padding = 'same') |>
layer_flatten() |>
layer_dense(10, activation = 'softmax')
summary(model2)Pemeriksaan Singkat
Apa tujuan utama layer_max_pooling_2d(pool_size = c(2, 2)) dalam CNN?
Ringkasan CNN
Hal-hal penting dari Dasar-Dasar Jaringan Saraf Konvolusional:
- CNN menggunakan bidang penerimaan lokal dan penggunaan parameter bersama untuk memproses citra secara efisien.
layer_conv_2d(filters, kernel_size, activation)mengekstraksi fitur spasial.layer_max_pooling_2d(pool_size)memperkecil ukuran dan memberikan invariansi terhadap translasi.layer_flatten()menghubungkan bagian utama konvolusi dengan bagian klasifikasi padat.layer_dropout(rate)melakukan regularisasi pada bagian klasifikasi.- Lapisan augmentasi data (
layer_random_flip(), dan lainnya) mengurangi overfitting. - Pembelajaran transfer dengan bagian utama yang telah dilatih sebelumnya merupakan pendekatan praktis untuk kumpulan data kecil.
# Standard CNN architecture for image classification
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
layer_conv_2d(32, c(3,3), activation = 'relu', padding = 'same') |>
layer_max_pooling_2d(c(2,2)) |>
layer_conv_2d(64, c(3,3), activation = 'relu', padding = 'same') |>
layer_max_pooling_2d(c(2,2)) |>
layer_conv_2d(128, c(3,3), activation = 'relu', padding = 'same') |>
layer_flatten() |>
layer_dense(256, activation = 'relu') |>
layer_dropout(0.5) |>
layer_dense(num_classes, activation = 'softmax')
model |> compile('adam', 'categorical_crossentropy', 'accuracy')
summary(model)Pertanyaan yang Sering Diajukan
Apakah pelajaran “Dasar-Dasar Jaringan Saraf Konvolusional” gratis?
Ya — teks lengkap “Dasar-Dasar Jaringan Saraf Konvolusional” 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 “Dasar-Dasar Jaringan Saraf Konvolusional”?
Tambahkan lapisan Conv2D dan MaxPooling untuk tugas klasifikasi gambar. 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 3 dari 4.
Berapa lama pelajaran “Dasar-Dasar Jaringan Saraf Konvolusional” 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