mnist_cnn

    Trains a simple convnet on the MNIST dataset.

    Gets to 99.25% test accuracy after 12 epochs Note: There is still a large margin for parameter tuning

    16 seconds per epoch on a GRID K520 GPU.

    library(keras)
    
    # Data Preparation -----------------------------------------------------
    
    batch_size <- 128
    num_classes <- 10
    epochs <- 12
    
    # Input image dimensions
    img_rows <- 28
    img_cols <- 28
    
    # The data, shuffled and split between train and test sets
    mnist <- dataset_mnist()
    x_train <- mnist$train$x
    y_train <- mnist$train$y
    x_test <- mnist$test$x
    y_test <- mnist$test$y
    
    # Redefine  dimension of train/test inputs
    x_train <- array_reshape(x_train, c(nrow(x_train), img_rows, img_cols, 1))
    x_test <- array_reshape(x_test, c(nrow(x_test), img_rows, img_cols, 1))
    input_shape <- c(img_rows, img_cols, 1)
    
    # Transform RGB values into [0,1] range
    x_train <- x_train / 255
    x_test <- x_test / 255
    
    cat('x_train_shape:', dim(x_train), '\n')
    cat(nrow(x_train), 'train samples\n')
    cat(nrow(x_test), 'test samples\n')
    
    # Convert class vectors to binary class matrices
    y_train <- to_categorical(y_train, num_classes)
    y_test <- to_categorical(y_test, num_classes)
    
    # Define Model -----------------------------------------------------------
    
    # Define model
    model <- keras_model_sequential() %>%
      layer_conv_2d(filters = 32, kernel_size = c(3,3), activation = 'relu',
                    input_shape = input_shape) %>% 
      layer_conv_2d(filters = 64, kernel_size = c(3,3), activation = 'relu') %>% 
      layer_max_pooling_2d(pool_size = c(2, 2)) %>% 
      layer_dropout(rate = 0.25) %>% 
      layer_flatten() %>% 
      layer_dense(units = 128, activation = 'relu') %>% 
      layer_dropout(rate = 0.5) %>% 
      layer_dense(units = num_classes, activation = 'softmax')
    
    # Compile model
    model %>% compile(
      loss = loss_categorical_crossentropy,
      optimizer = optimizer_adadelta(),
      metrics = c('accuracy')
    )
    
    # Train model
    model %>% fit(
      x_train, y_train,
      batch_size = batch_size,
      epochs = epochs,
      validation_split = 0.2
    )
    
    
    
    
    scores <- model %>% evaluate(
      x_test, y_test, verbose = 0
    )
    
    # Output metrics
    cat('Test loss:', scores[[1]], '\n')
    cat('Test accuracy:', scores[[2]], '\n')