Wstęp:

Jeśli chodzi o aplikacje do uczenia maszynowego lub głębokiego uczenia, jedynym językiem, który przychodzi nam do głowy, jest python. Ale czy wiesz, że nie jest to jedyny język z taką możliwością. Języki programowania inne niż python, których można by użyć do tego celu, to Java, Scala, Julia, MATLAB i R. To tylko szeroka lista modułów i bibliotek dostępnych w pythonie, aby wspomóc proces, który czyni go nie do pobicia.

W tym artykule omówimy tworzenie modelu przy użyciu R dla klasyfikacji cyfr pisanych odręcznie.

Importowanie niezbędnych bibliotek:

Zaczynamy od zaimportowania wymaganych bibliotek dla naszego projektu. Używamy tej library()funkcji do importowania dslabs, keras, i tensorflowbibliotek. Musimy upewnić się, że te biblioteki są zainstalowane w środowisku R przed ich zaimportowaniem. Możemy użyć tej install.packages()funkcji do zainstalowania bibliotek w naszym środowisku programistycznym R, jeśli nie jesteśmy w stanie ich zaimportować.

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

Następnie ładujemy zestaw danych MNIST do naszych zmiennych i przechowujemy go. Używamy read_mnist()funkcji z dslabsbiblioteki, aby załadować zestaw danych.

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

      
                

                    
                    
                
            

Następnie wdrażamy wszelkie kroki przygotowania danych potrzebne do przygotowania danych MNIST do szkolenia i walidacji oraz przygotowujemy zestaw danych odręcznych cyfr klasy, aby był sformatowany w ten sam sposób.

Za pomocą funkcji ładujemy zestaw danych odręcznych cyfr klasy read.csv()i zapisujemy go w chdzmiennej.

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)

Teraz, gdy mamy już przetworzone dane, możemy przejść do projektowania i trenowania naszego modelu. W tym celu używamy keras_model_sequential()funkcji z kerasbiblioteki do stworzenia naszego modelu. Nasz model składa się z dwóch warstw konwolucyjnych, dwóch warstw max poolingu, dwóch warstw dropout, dwóch gęstych warstw i funkcji aktywacji 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);

Następnie kompilujemy model, określając funkcję straty, optymalizator i metrykę oceny.

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

      
                

                    
                    
                
            

Na koniec zapisujemy nasz model, abyśmy mogli go ponownie wyszkolić i wdrożyć, jeśli model działa naprawdę dobrze na danych testowych.

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