Introduction:

Lorsqu'il s'agit d'applications d'apprentissage automatique ou d'apprentissage en profondeur, le seul langage qui nous vient à l'esprit est le python. Mais saviez-vous que ce n'est pas le seul langage avec cette capacité. Les langages de programmation autres que python qui pourraient être utilisés à cette fin sont Java, Scala, Julia, MATLAB et R. C'est juste la longue liste de modules et de bibliothèques disponibles en python pour faciliter le processus qui le rend imbattable.

Ici, dans cet article, nous allons passer par le développement de modèles en utilisant R pour la classification des chiffres écrits à la main.

Importation des bibliothèques nécessaires :

Nous commençons par importer les bibliothèques requises pour notre projet. Nous utilisons la library()fonction pour importer les bibliothèques dslabs, keraset tensorflow. Nous devons nous assurer que ces bibliothèques sont installées dans l'environnement R avant de les importer. Nous pouvons utiliser la install.packages()fonction pour installer des bibliothèques dans notre environnement de programmation R si nous ne sommes pas en mesure de les importer.

library(dslabs)
library(keras)
library(tensorflow)

Nous chargeons ensuite l'ensemble de données MNIST dans nos variables et le stockons. Nous utilisons la read_mnist()fonction de la dslabsbibliothèque pour charger le jeu de données.

mnist <- read_mnist()

i <- 5
image(1:28, 1:28, matrix(mnist$test$images[i,], nrow=28)[ , 28:1], 
    col = gray(seq(0, 1, 0.05)), xlab = "", ylab="")

      
                

                    
                    
                
            

Ensuite, nous mettons en œuvre toutes les étapes de préparation des données nécessaires pour préparer les données MNIST pour la formation et la validation, et préparons l'ensemble de données manuscrites de la classe afin qu'il soit formaté de la même manière.

Nous chargeons l'ensemble de données manuscrites de la classe à l'aide de la read.csv()fonction et le stockons dans la chdvariable.

chd <- read.csv("combined_digits_1.csv")
dim(chd)

xtest = chd[,1:784]
ytest = chd[,785]
 
xtest = as.matrix(xtest)
xtest <- array_reshape(xtest, c(nrow(xtest), 28, 28, 1))

mnist = read_mnist()  
x_train = mnist$train$images
y_train = mnist$train$labels
x_val = mnist$test$images
y_val = mnist$test$labels

x_train = array_reshape(x_train, c(nrow(x_train), 28, 28, 1))
x_val = array_reshape(x_val, c(nrow(x_val), 28, 28, 1)) 

y_train = to_categorical(y_train, 10)
y_val = to_categorical(y_val, 10)
ytest = to_categorical(ytest,10)

Maintenant, une fois nos données traitées, nous pouvons passer à la conception et à la formation de notre modèle. Pour cela nous utilisons la keras_model_sequential()fonction de la kerasbibliothèque pour créer notre modèle. Notre modèle se compose de deux couches convolutives, de deux couches de pooling max, de deux couches d'abandon, de deux couches denses et d'une fonction d'activation softmax.

#Model Building: Code Here
input_shape <- c(28, 28, 1)
batch_size <- 128
num_classes <- 10
epochs <- 10  

model <- keras_model_sequential() %>%
  layer_conv_2d(filters = 32, kernel_size = c(3,3), activation = 'relu', input_shape = input_shape) %>% 
  layer_max_pooling_2d(pool_size = c(2, 2)) %>% 
  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')  


summary(model);

Ensuite, nous compilons le modèle en spécifiant la fonction de perte, l'optimiseur et la métrique d'évaluation.

# compiling our model
model %>% compile(
  loss = loss_categorical_crossentropy,
  optimizer = optimizer_adadelta(),
  metrics = c('accuracy')
)

# fitting the model(training it)  
model_history <- model %
                  fit(x_train, y_train,
                  batch_size = batch_size,
                  epochs = epochs,
                  validation_data = list(x_val, y_val),
                  verbose = 1)

      
                

                    
                    
                
            

#Model Testing
model %>% evaluate(xtest, ytest)

      
                

                    
                    
                
            

Enfin, nous sauvegardons notre modèle afin que nous puissions l'entraîner à nouveau et le déployer également si le modèle fonctionne très bien sur les données de test.

#saveRDS(model,"<filepath>/<UNI>_model.RDS")
saveRDS(model, "digit_classifier.rds")