Introduzione:

Quando si tratta di applicazioni di machine learning o deep learning, l'unico linguaggio che ci viene in mente è Python. Ma sapevi che non è l'unica lingua con questa capacità. I linguaggi di programmazione diversi da Python che potrebbero essere utilizzati allo scopo sono Java, Scala, Julia, MATLAB e R. È solo l'ampio elenco di moduli e librerie disponibili in Python per aiutare il processo che lo rende imbattibile.

Qui in questo articolo, esamineremo lo sviluppo del modello utilizzando R per la classificazione delle cifre scritte a mano.

Importazione delle librerie necessarie:

Iniziamo importando le librerie richieste per il nostro progetto. Usiamo la library()funzione per importare dslabs, kerase tensorflowlibrerie. Dobbiamo assicurarci che queste librerie siano installate nell'ambiente R prima di importarle. Possiamo utilizzare la install.packages()funzione per installare le librerie nel nostro ambiente di programmazione R se non siamo in grado di importarle.

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

Quindi carichiamo il set di dati MNIST nelle nostre variabili e lo memorizziamo. Usiamo la read_mnist()funzione dalla dslabslibreria per caricare il set di dati.

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

      
                

                    
                    
                
            

Successivamente implementiamo tutti i passaggi di preparazione dei dati necessari per preparare i dati MNIST per l'addestramento e la convalida e prepariamo il set di dati di cifre scritte a mano della classe in modo che sia formattato nello stesso modo.

Carichiamo il set di dati di cifre scritte a mano della classe utilizzando la read.csv()funzione e lo memorizziamo nella chdvariabile.

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)

Ora, una volta elaborati i dati, possiamo passare alla progettazione e all'addestramento del nostro modello. Per questo usiamo la keras_model_sequential()funzione dalla keraslibreria per creare il nostro modello. Il nostro modello è costituito da due strati convoluzionali, due strati di pooling massimo, due strati di dropout, due strati densi e una funzione di attivazione 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);

Successivamente, compiliamo il modello specificando la funzione di perdita, l'ottimizzatore e la metrica di valutazione.

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

      
                

                    
                    
                
            

Infine, salviamo il nostro modello in modo da poterlo addestrare nuovamente e distribuirlo anche se il modello funziona davvero bene sui dati di test.

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