परिचय:

जब मशीन लर्निंग या डीप लर्निंग एप्लिकेशन की बात आती है, तो हमारे दिमाग में आने वाली भाषा केवल अजगर है। लेकिन, क्या आप जानते हैं कि यह क्षमता वाली एकमात्र भाषा नहीं है। अजगर के अलावा अन्य प्रोग्रामिंग भाषाएँ जिनका उपयोग इस उद्देश्य के लिए किया जा सकता है, वे हैं जावा, स्काला, जूलिया, MATLAB और R। यह केवल मॉड्यूल और पुस्तकालयों की विस्तृत सूची है जो अजगर में उपलब्ध हैं जो प्रक्रिया को अपराजेय बनाती हैं।

यहाँ इस लेख में, हम हस्तलिखित अंकों के वर्गीकरण के लिए R का उपयोग करके मॉडल विकास के बारे में जानेंगे।

आवश्यक पुस्तकालयों का आयात करना:

हम अपनी परियोजना के लिए आवश्यक पुस्तकालयों को आयात करके शुरू करते हैं। हम , , और लाइब्रेरी library()आयात करने के लिए फ़ंक्शन का उपयोग करते हैं। हमें यह सुनिश्चित करना होगा कि इन पुस्तकालयों को आयात करने से पहले आर पर्यावरण में स्थापित किया गया हो। यदि हम उन्हें आयात करने में सक्षम नहीं हैं, तो हम अपने आर प्रोग्रामिंग वातावरण में पुस्तकालयों को स्थापित करने के लिए फ़ंक्शन का उपयोग कर सकते हैं ।dslabskerastensorflowinstall.packages()

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

फिर हम MNIST डेटासेट को अपने वेरिएबल्स में लोड करते हैं और इसे स्टोर करते हैं। हम डेटासेट को लोड करने के लिए लाइब्रेरी read_mnist()से फ़ंक्शन का उपयोग करते हैं।dslabs

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

      
                

                    
                    
                
            

आगे हम प्रशिक्षण और सत्यापन के लिए MNIST डेटा तैयार करने के लिए आवश्यक किसी भी डेटा तैयारी चरण को लागू करते हैं, और कक्षा का हस्तलिखित अंक डेटा सेट तैयार करते हैं ताकि इसे उसी तरह से स्वरूपित किया जा सके।

हम फ़ंक्शन का उपयोग करके वर्ग के हस्तलिखित अंक डेटा सेट को लोड करते हैं read.csv()और इसे chdचर में संग्रहीत करते हैं।

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)

अब, एक बार हमारे डेटा संसाधित हो जाने के बाद, हम अपने मॉडल के डिजाइन और प्रशिक्षण के लिए आगे बढ़ सकते हैं। उसके लिए हम अपना मॉडल बनाने के लिए लाइब्रेरी keras_model_sequential()से फ़ंक्शन का उपयोग करते हैं। kerasहमारे मॉडल में दो संकेंद्रित परतें, दो अधिकतम पूलिंग परतें, दो ड्रॉपआउट परतें, दो घनी परतें और एक सॉफ्टमैक्स सक्रियण फ़ंक्शन शामिल हैं।

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

अगला, हम नुकसान फ़ंक्शन, ऑप्टिमाइज़र और मूल्यांकन मीट्रिक निर्दिष्ट करके मॉडल को संकलित करते हैं।

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

      
                

                    
                    
                
            

अंत में, हम अपने मॉडल को सहेजते हैं ताकि हम इसे फिर से प्रशिक्षित कर सकें और इसे तैनात कर सकें यदि मॉडल परीक्षण डेटा पर वास्तव में अच्छा काम करता है।

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