## The user asked ChatGPT on 3/3/26: show R code based on Keras for a simple convolution-based autoencoder for 2-d images.
## ChatGPT responded: Here is a simple convolutional autoencoder in R using Keras for 2D grayscale images (e.g., MNIST 28×28). I’ll keep it minimal but fully working.

# 1. Load Libraries
library(keras)
library(tensorflow)
#If not installed:
#install.packages("keras")
#keras::install_keras()

# 2. Load and Prepare Data (MNIST)
mnist <- dataset_mnist()

x_train <- mnist$train$x
x_test  <- mnist$test$x

# Normalize to [0,1]
x_train <- x_train / 255
x_test  <- x_test / 255

# Reshape to 4D tensors: (samples, height, width, channels)
x_train <- array_reshape(x_train, c(nrow(x_train), 28, 28, 1))
x_test  <- array_reshape(x_test, c(nrow(x_test), 28, 28, 1))

#Autoencoders use input = output:
y_train <- x_train
y_test  <- x_test

# 3. Build Convolutional Autoencoder
# Define model:
input_img <- layer_input(shape = c(28, 28, 1))

# ----- Encoder -----
encoded <- input_img %>%
  layer_conv_2d(filters = 16, kernel_size = 3,
                activation = "relu", padding = "same") %>%
  layer_max_pooling_2d(pool_size = 2, padding = "same") %>%
  layer_conv_2d(filters = 8, kernel_size = 3,
                activation = "relu", padding = "same") %>%
  layer_max_pooling_2d(pool_size = 2, padding = "same")

# Shape now: 7x7x8

# ----- Decoder -----
decoded <- encoded %>%
  layer_conv_2d_transpose(filters = 8, kernel_size = 3,
                          activation = "relu", padding = "same") %>%
  layer_upsampling_2d(size = 2) %>%
  layer_conv_2d_transpose(filters = 16, kernel_size = 3,
                          activation = "relu", padding = "same") %>%
  layer_upsampling_2d(size = 2) %>%
  layer_conv_2d(filters = 1, kernel_size = 3,
                activation = "sigmoid", padding = "same")

# Create model:
autoencoder <- keras_model(input_img, decoded)

# 4. Compile Model
autoencoder %>% compile(
  optimizer = "adam",
  loss = "binary_crossentropy"
)

# 5. Train model:
history <- autoencoder %>% fit(
  x_train, y_train,
  epochs = 10,
  batch_size = 128,
  validation_data = list(x_test, y_test)
)

# 6. Reconstruct Images
decoded_imgs <- autoencoder %>% predict(x_test)

# 7. Visualize Results
par(mfrow = c(2, 10), mar = c(1,1,1,1))

for (i in 1:10) {
  image(x_test[i,,,1], col = gray.colors(256), axes = FALSE)
}

for (i in 1:10) {
  image(decoded_imgs[i,,,1], col = gray.colors(256), axes = FALSE)
}

## Why using the BCE as the loss? You can use the MSE (and change "sigmoid" to "linear") as ChatGPT did...

## User: the output images seem rotated; would you rotate them back?
## ChatGPT: In R: image() flips the y-axis (origin at bottom-left); MNIST arrays are stored with origin at top-left

rotate_image <- function(img_matrix) {
  t(apply(img_matrix, 2, rev))
}

par(mfrow = c(2, 10), mar = c(1,1,1,1))

for (i in 1:10) {
  image(rotate_image(x_test[i,,,1]),
        col = gray.colors(256),
        axes = FALSE)
}

for (i in 1:10) {
  image(rotate_image(decoded_imgs[i,,,1]),
        col = gray.colors(256),
        axes = FALSE)
}


####################################
## User: generate R code for a similar autoencoder for MNIST but use MLPs for both the encoder and decoder.
## ChatGPT: Great — here is a fully working MLP-based autoencoder in R using Keras for MNIST.

#mnist <- dataset_mnist()

x_train <- mnist$train$x / 255
x_test  <- mnist$test$x  / 255

# Flatten 28x28 -> 784
x_train <- array_reshape(x_train, c(nrow(x_train), 784))
x_test  <- array_reshape(x_test,  c(nrow(x_test),  784))

# Autoencoder target = input
y_train <- x_train
y_test  <- x_test

input_img <- layer_input(shape = 784)

# ----- Encoder -----
encoded <- input_img %>%
  layer_dense(256, activation = "relu") %>%
  layer_dense(64, activation = "relu")

# ----- Decoder -----
decoded <- encoded %>%
  layer_dense(256, activation = "relu") %>%
  layer_dense(784, activation = "linear")

autoencoder <- keras_model(input_img, decoded)

autoencoder %>% compile(
  optimizer = "adam",
  loss = "mse"
)

history <- autoencoder %>% fit(
  x_train, y_train,
  epochs = 20,
  batch_size = 128,
  validation_data = list(x_test, y_test)
)

decoded_imgs <- autoencoder %>% predict(x_test)

par(mfrow = c(2, 10), mar = c(1,1,1,1))

for (i in 1:10) {
  image(matrix(x_test[i, ], 28, 28)[,28:1],
        col = gray.colors(256),
        axes = FALSE)
}

for (i in 1:10) {
  image(matrix(decoded_imgs[i, ], 28, 28)[,28:1],
        col = gray.colors(256),
        axes = FALSE)
}


## You could: Add dropout; Add batch normalization; Use sigmoid output + BCE
## Extract encoder separately:
encoder <- keras_model(input_img, encoded)

##########################################
## ChatGPT: For visualization, it’s easiest if the latent dimension is 2 or 3. I’ll show you how to modify the autoencoder for 2D latent space and then plot it colored by MNIST digit labels.

input_img <- layer_input(shape = 784)

# ----- Encoder -----
encoded <- input_img %>%
  layer_dense(256, activation = "relu") %>%
  layer_dense(2, activation = "linear")   # latent_dim = 2

# ----- Decoder -----
decoded <- encoded %>%
  layer_dense(256, activation = "relu") %>%
  layer_dense(784, activation = "linear")

autoencoder <- keras_model(input_img, decoded)

autoencoder %>% compile(
  optimizer = "adam",
  loss = "mse"
)

history <- autoencoder %>% fit(
  x_train, y_train,
  epochs = 20,
  batch_size = 128,
  validation_data = list(x_test, y_test)
)

encoder <- keras_model(input_img, encoded)

latent_test <- encoder %>% predict(x_test)

library(ggplot2)

latent_df <- data.frame(
  x = latent_test[,1],
  y = latent_test[,2],
  label = as.factor(mnist$test$y)
)

ggplot(latent_df, aes(x = x, y = y, color = label)) +
  geom_point(alpha = 0.6, size = 1) +
  theme_minimal() +
  labs(title = "2D Latent Space of MLP Autoencoder")