एल्गोरिदम सीखने के बीच कैसे चुनें

Question

मुझे एक कार्यक्रम लागू करने की आवश्यकता है जो कुछ प्रशिक्षण डेटा के आधार पर रिकॉर्ड को 2 श्रेणियों (सच्चा / गलत) में वर्गीकृत करेगा, और मैं सोच रहा था कि मुझे किस एल्गोरिदम / कार्यप्रणाली को देखना चाहिए। उनमें से चुनने के लिए बहुत कुछ प्रतीत होता है - आर्टिफिशियल न्यूरल नेटवर्क, जेनेटिक एल्गोरिथम, मशीन लर्निंग, बायेसियन ऑप्टिमाइज़ेशन आदि आदि, और मुझे यकीन नहीं था कि कहां से शुरू किया जाए। तो, मेरे प्रश्न हैं: मुझे अपनी समस्या के लिए सीखने के एल्गोरिथ्म का चयन कैसे करना चाहिए?

यदि यह मदद करता है, तो यहां समस्या है जिसे मुझे हल करने की आवश्यकता है।

---

प्रशिक्षण डेटा:
प्रशिक्षण डेटा में इस तरह कई पंक्तियाँ होती हैं:

Precursor1, Precursor2, Boolean (true/false)

रन
मैं अग्रदूतों का एक समूह दिया जाएगा।
फिर,

1. मैं अलग-अलग एल्गोरिदम से एक एल्गोरिथ्म चुनता हूं (या डायनामिक रूप से एक एल्गोरिथ्म उत्पन्न करता हूं), और इसे इन अग्रदूतों के हर संभव संयोजन पर लागू करता हूं और उत्सर्जित "रिकॉर्ड" इकट्ठा करता हूं। "रिकॉर्ड" में कई कुंजी-मूल्य जोड़े शामिल हैं *।

2. मैं कुछ भयानक एल्गोरिथ्म लागू करता हूं और इन रिकॉर्ड्स को 2 श्रेणियों (सच्चा / गलत) में वर्गीकृत करता हूं।

3. मैं एक तालिका उत्पन्न करूँगा जिसमें ट्रेन डेटा के समान प्रारूप है:
   Precursor1, Precursor2, Boolean

और पूरा कार्यक्रम इस आधार पर बनाया गया है कि मैं कितना सही / गलत हूं।

*: "रिकॉर्ड" इस तरह दिखेगा (आशा है कि यह समझ में आता है)

Record         [1...*] Score
-Precursor1             -Key
-Precursor2             -Value

संभव कुंजी की केवल एक सीमित संख्या है। अभिलेखों में इन कुंजियों के अलग-अलग उपसमूह होते हैं (कुछ अभिलेखों में की 1, की 2, की 3 ... अन्य अभिलेखों में की 3, की 4 ... आदि हैं)।

मुझे वास्तव में 2 सीखने की आवश्यकता है। एक चरण 1 के लिए है। मेरे पास एक ऐसा मॉड्यूल होना चाहिए जो कि प्रीस्कॉरर जोड़े आदि को देखता है और यह निर्णय लेता है कि तुलना के लिए रिकॉर्ड का उत्सर्जन करने के लिए कौन सा एल्गोरिदम लागू करना है। एक और चरण 2 के लिए है। मुझे एक मॉड्यूल की आवश्यकता है जो अभिलेखों के संग्रह का विश्लेषण करता है और उन्हें 2 श्रेणियों (सही / गलत) में वर्गीकृत करता है।

आपका अग्रिम में ही बहुत धन्यवाद!

Answer 1

" आर " के लिए " कैरेट " नामक एक पैकेज है , जो "वर्गीकरण और प्रतिगमन परीक्षण" के लिए खड़ा है। मुझे लगता है कि यह आपके लिए शुरू करने के लिए एक अच्छी जगह होगी, क्योंकि यह आसानी से आपको अपने डेटा में एक दर्जन या इतने अलग-अलग लर्निंग एल्गोरिदम लागू करने की अनुमति देगा, और फिर उन्हें यह अनुमान लगाने के लिए क्रॉस-वेरीफाई करेगा कि वे प्रत्येक कितने सही हैं।

यहाँ एक उदाहरण है जिसे आप अपने स्वयं के डेटा / अन्य तरीकों से संशोधित कर सकते हैं:

install.packages('caret',dependencies = c('Depends','Suggests'))
library(caret)

set.seed(999)
Precursor1 <- runif(25)
Precursor2 <- runif(25)
Target <- sample(c('T','F'),25,replace=TRUE)
MyData <- data.frame(Precursor1,Precursor2,Target)
str(MyData)

#Try Logistic regression
model_Logistic <- train(Target~Precursor1+Precursor2,data=MyData,method='glm')

#Try Neural Network
model_NN <- train(Target~Precursor1+Precursor2,data=MyData,method='nnet',trace=FALSE)

#Try Naive Bayes
model_NB <- train(Target~Precursor1+Precursor2,data=MyData,method='nb')

#Try Random Forest
model_RF <- train(Target~Precursor1+Precursor2,data=MyData,method='rf')

#Try Support Vector Machine
model_SVM<- train(Target~Precursor1+Precursor2,data=MyData,method='svmLinear')

#Try Nearest Neighbors
model_KNN<- train(Target~Precursor1+Precursor2,data=MyData,method='knn')

#Compare the accuracy of each model
cat('Logistic:',max(model_Logistic$results$Accuracy))
cat('Neural:',max(model_NN$results$Accuracy))
cat('Bayes:',max(model_NB$results$Accuracy))
cat('Random Forest:',max(model_RF$results$Accuracy))
cat('Support Vector Machine:',max(model_SVM$results$Accuracy))
cat('Nearest Neighbors:',max(model_KNN$results$Accuracy))

#Look at other available methods
?train

एक अन्य विचार आपके डेटा को एक प्रशिक्षण सेट और एक परीक्षण सेट में तोड़ना होगा, और फिर तुलना करें कि प्रत्येक मॉडल परीक्षण सेट पर कैसा प्रदर्शन करता है। यदि आप चाहें, तो मैं आपको दिखा सकता हूं कि यह कैसे करना है।

Answer 2

$T$$X$$Y$$I$

$Y$

$$P(Y|T,X,I)$$

अब हम संभाव्यता सिद्धांत के किसी भी नियम का उपयोग उन चीजों में हेरफेर करने के लिए कर सकते हैं जिन्हें हम जानते हैं कि गणना कैसे करें। तो बेयस प्रमेय का उपयोग करते हुए, आपको मिलता है:

$$P(Y|T,X,I)=\frac{P(Y|T,I)P(X|Y,T,I)}{P(X|T,I)}$$

$P(Y|T,I)$$Y$$Y$

$P(X|Y,T,I)$$P(X|T,I)$$Y$$\overline{Y}$$Y$

$$O(Y|T,X,I)=\frac{P(Y|T,X,I)}{P(\overline{Y}|T,X,I)}=\frac{P(Y|T,I)}{P(\overline{Y}|T,I)}\frac{P(X|Y,T,I)}{P(X|\overline{Y},T,I)}$$

$Y$

$P(X|Y,T,I)$$\theta_{Y}$

$$P(X|Y,T,I)=\int P(X,\theta_{Y}|Y,T,I) d\theta = \int P(X|\theta_{Y},Y,T,I)P(\theta_{Y}|Y,T,I) d\theta_{Y}$$

$P(X|\theta_{Y},Y,T,I)=P(X|\theta_{Y},Y,I)$$T$$P(\theta_{Y}|Y,T,I)$मॉडल में मापदंडों के लिए पीछे वितरण है - यह वह हिस्सा है जिसे प्रशिक्षण डेटा निर्धारित करेगा। और यह संभवतः वह जगह है जहां अधिकांश काम चलेगा।

$\theta_{Y}$$M_i$$\theta^{(i)}_{Y}$

$$P(X|Y,T,I)= \sum_{i}P(M_{i}|Y,T,I)\int P(X|\theta_{Y}^{(i)},M_{i},Y,T,I)P(\theta_{Y}^{(i)}|M_{i},Y,T,I) d\theta_{Y}^{(i)}$$ $$P(M_{i}|Y,T,I)=P(M_{i}|Y,I)\int P(\theta_{Y}^{(i)}|M_{i},Y,I)P(T|\theta_{Y}^{(i)},M_{i},Y,I) d\theta_{Y}^{(i)}$$

$M_i$

अब, इस बिंदु तक, सभी परिणाम सटीक और इष्टतम हैं (यह विकल्प 2 है - डेटा के लिए कुछ भयानक एल्गोरिदम लागू करें)। लेकिन यह एक कठिन काम है। वास्तविक दुनिया में, आवश्यक गणित व्यवहार में करने के लिए संभव नहीं है - इसलिए आपको समझौता करना होगा। आपको हमेशा सटीक समीकरण करने में "एक जाना" चाहिए, किसी भी गणित के लिए जिसे आप सरल कर सकते हैं वह आपको पीसी में समय बचाएगा। हालांकि, यह पहला कदम महत्वपूर्ण है, क्योंकि यह "लक्ष्य" सेट करता है, और यह स्पष्ट करता है कि क्या किया जाना है। अन्यथा आप संभावित विकल्पों की एक पूरी मेजबानी के साथ छोड़ दिए जाते हैं (जैसा कि आप प्रतीत होते हैं) कि उनके बीच चयन करने के लिए कुछ भी नहीं है।

अब इस स्तर पर, हम अभी भी "प्रतीकात्मक तर्क" दुनिया में हैं, जहां वास्तव में कुछ भी समझ में नहीं आता है। इसलिए आपको इन्हें अपनी विशिष्ट समस्या से जोड़ना होगा:

1. $P(M_{i}|Y,I)$
2. $P(\theta_{Y}^{(i)}|M_{i},Y,I)$
3. $P(T|\theta_{Y}^{(i)},M_{i},Y,I)$
4. $P(\theta_{Y}^{(i)}|T,M_{i},Y,I)$
5. $P(M_{i}|Y,T,I)$

लिए समीकरणों का एक और सेट होगा$\overline{Y}$

$P(M_{j}|Y,T,I)\approx 1$

$$P(X|Y,T,I)\approx P(X|\theta_{Y}^{(j)},M_{j},Y,T,I)_{\theta_{Y}^{(j)}=\hat{\theta}_{Y}^{(j)}}$$

जो इस तरह की समस्या के लिए "मानक" दृष्टिकोण है।