พื้นฐานโครงข่ายประสาทเทียมแบบคอนโวลูชัน

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

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)

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 preserved

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)

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)

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)

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)

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)

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

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

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

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