R में सपोर्ट वेक्टर मशीनें

मशीन लर्निंग में, सपोर्ट वेक्टर मशीनें (SVM) सुपरवाइज्ड लर्निंग मॉडल होती हैं जिनके साथ जुड़े एल्गोरिदम वर्गीकरण और प्रतिगमन विश्लेषण के लिए प्रयुक्त डेटा का विश्लेषण करते हैं। हालांकि, इनका उपयोग मुख्यतः वर्गीकरण समस्याओं में होता है। इस ट्यूटोरियल में, हम समझेंगे कि SVM कैसे काम करते हैं और फिर उन्हें R में लागू करेंगे। मैं औपचारिक कठोरता की बजाय अंतर्ज्ञान पर ध्यान दूंगा। इसका अर्थ यह है कि हम गणित को यथासंभव छोड़ते हुए कार्य सिद्धांत का मजबूत अंतर्ज्ञान विकसित करेंगे।

सपोर्ट वेक्टर मशीन एल्गोरिदम

रैखिक डेटा

SVM की मूल बातें और उनका काम करना एक साधारण उदाहरण से सबसे बेहतर समझा जा सकता है। मान लीजिए हमारे पास दो टैग हैं: red और blue, और हमारे डेटा में दो विशेषताएँ हैं: x और y। हमें ऐसा क्लासिफायर चाहिए जो (x,y) निर्देशांकों की जोड़ी के आधार पर बताए कि वह red है या blue। हम अपने पहले से लेबल किए गए प्रशिक्षण डेटा को एक तल पर प्लॉट करते हैं:

एक सपोर्ट वेक्टर मशीन इन बिंदुओं को लेती है और वह हाइपरप्लेन निकालती है (दो आयामों में यह बस एक रेखा होती है) जो टैग्स को सबसे बेहतर ढंग से अलग करे। यह रेखा डिसीजन बाउंडरी है: इसकी एक ओर आने वाली किसी भी चीज़ को हम blue के रूप में, और दूसरी ओर आने वाली को red के रूप में वर्गीकृत करेंगे।

लेकिन, सबसे अच्छा हाइपरप्लेन वास्तव में क्या है? SVM के लिए, वह हाइपरप्लेन है जो दोनों टैग्स से मार्जिन को अधिकतम करता है। दूसरे शब्दों में: वह हाइपरप्लेन (यहाँ याद रखें कि यह एक रेखा है) जिसकी दूरी प्रत्येक टैग के निकटतम तत्व से सबसे अधिक हो।

गैर-रैखिक डेटा

ऊपर का उदाहरण आसान था क्योंकि डेटा स्पष्ट रूप से रैखिक रूप से पृथक था — हम red और blue को अलग करने के लिए सीधी रेखा खींच सकते थे। दुर्भाग्यवश, अक्सर चीज़ें इतनी सरल नहीं होतीं। इस केस को देखें:

यह स्पष्ट है कि यहाँ कोई रैखिक डिसीजन बाउंडरी नहीं है (एक सीधी रेखा जो दोनों टैग्स को अलग करे)। फिर भी, वेक्टर साफ़-साफ़ अलग-अलग समूहों में हैं, और लगता है कि इन्हें अलग करना आसान होना चाहिए।

तो हम यह करेंगे: एक तीसरा आयाम जोड़ेंगे। अभी तक हमारे पास दो आयाम थे: $x$ और $y$। हम एक नया z आयाम बनाते हैं, और यह नियम तय करते हैं कि इसे हमारे अनुकूल तरीके से गणना किया जाए: $z = x² + y²$ (आप ध्यान देंगे कि यह एक वृत्त का समीकरण है)।

इससे हमें त्रि-आयामी स्थान मिलेगा। उस स्थान का एक स्लाइस लेने पर, यह कुछ ऐसा दिखता है:

SVM इसके साथ क्या कर सकता है? आइए देखें:

यह बढ़िया है! ध्यान दें कि अब हम तीन आयामों में हैं, इसलिए हाइपरप्लेन एक ऐसा समतल है जो किसी निश्चित $z$ पर $x$ अक्ष के समानांतर है (मान लें $z = 1$)।

अब बचा है इसे वापस दो आयामों में मैप करना:

और लीजिए! हमारी डिसीजन बाउंडरी त्रिज्या 1 वाली परिधि है, जो SVM का उपयोग करके दोनों टैग्स को अलग करती है।

कर्नेल ट्रिक

ऊपर के उदाहरण में, हमने अपने स्पेस को ऊँचे आयाम में चालाकी से मैप करके गैर-रैखिक डेटा को वर्गीकृत करने का तरीका ढूँढ लिया। परन्तु, यह परिवर्तन निकालना कम्प्यूटेशन के लिहाज़ से काफी महंगा पड़ सकता है: कई नए आयाम हो सकते हैं, जिनमें से हर एक में जटिल गणना शामिल हो सकती है। यह काम डेटासेट के हर वेक्टर के लिए करना भारी हो सकता है, इसलिए कोई सस्ता उपाय मिल जाए तो अच्छा होगा।

यहाँ एक तरकीब है: SVM को अपना जादू चलाने के लिए असल वेक्टरों की ज़रूरत नहीं पड़ती, वह केवल उनके बीच के डॉट प्रोडक्ट्स से काम चला सकता है। इसका मतलब है कि हम नए आयामों की महंगी गणनाओं से बच सकते हैं! इसकी जगह हम यह करते हैं:

• जिस नए स्पेस की हमें ज़रूरत है, उसकी कल्पना करें:

• उस स्पेस में डॉट प्रोडक्ट कैसा दिखेगा, यह निकालें:

• SVM को वही काम नए डॉट प्रोडक्ट के साथ करने दें — इसे हम कर्नेल फ़ंक्शन कहते हैं।

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

फायदे और नुकसान

अब हम SVM के कुछ फायदे और नुकसान पर नज़र डालते हैं:

फायदे

• उच्च आयामिकता: SVM उच्च-आयामी स्पेसेज़ में प्रभावी उपकरण है, जो दस्तावेज़ वर्गीकरण और सेंटिमेंट विश्लेषण में विशेष रूप से लागू होता है, जहाँ आयामिकता अत्यधिक बड़ी हो सकती है।

• मेमोरी दक्षता: चूँकि नए सदस्यों को असाइन करने की वास्तविक निर्णय प्रक्रिया में प्रशिक्षण बिंदुओं का केवल एक उपसमुच्चय उपयोग होता है, इसलिए निर्णय लेते समय केवल इन्हीं बिंदुओं को मेमोरी में संग्रहीत (और गणना) करना होता है।

• बहुमुखी प्रतिभा: कक्षा पृथक्करण अक्सर अत्यधिक गैर-रैखिक होता है। नए कर्नेल लागू करने की क्षमता डिसीजन बाउंडरीज़ के लिए पर्याप्त लचीलेपन की अनुमति देती है, जिससे वर्गीकरण प्रदर्शन बेहतर होता है।

नुकसान

• कर्नेल पैरामीटर का चयन: SVM कर्नेल पैरामीटर की पसंद के प्रति बहुत संवेदनशील होते हैं। ऐसी स्थितियों में जहाँ प्रत्येक ऑब्जेक्ट के फीचर्स की संख्या प्रशिक्षण सैम्पलों की संख्या से अधिक होती है, SVM का प्रदर्शन कमज़ोर हो सकता है। सहज रूप से इसे ऐसे समझा जा सकता है कि यदि उच्च-आयामी फीचर स्पेस नमूनों की तुलना में बहुत बड़ा है, तो इष्टतम रैखिक हाइपरप्लेन को सहारा देने के लिए कम प्रभावी सपोर्ट वेक्टर होंगे, जिससे जैसे-जैसे नए अनदेखे नमूने जुड़ते हैं, वर्गीकरण प्रदर्शन घट सकता है।

• अप्रायिक: चूँकि क्लासिफायर वस्तुओं को एक वर्गीकृत हाइपरप्लेन के ऊपर और नीचे रखकर काम करता है, समूह सदस्यता के लिए कोई प्रत्यक्ष प्रायिकतामूलक व्याख्या नहीं होती। हालांकि, वर्गीकरण की "प्रभावशीलता" को मापने का एक संभावित माप यह है कि नया बिंदु डिसीजन बाउंडरी से कितनी दूरी पर है।

R में सपोर्ट वेक्टर मशीनें

रैखिक SVM क्लासिफायर

पहले हम 2 आयामों में कुछ डेटा बनाते हैं, और उन्हें थोड़ा अलग-अलग करते हैं। रैंडम सीड सेट करने के बाद, आप एक मैट्रिक्स x बनाते हैं, जो 2 चर पर 2 कक्षाओं के 20 ऑब्ज़र्वेशन्स के साथ सामान्य वितरण से आता है। फिर आप एक y वैरिएबल बनाते हैं, जो -1 या 1 होगा, प्रत्येक कक्षा में 10। y = 1 के लिए, आप प्रत्येक निर्देशांक में माध्य को 0 से 1 तक खिसकाते हैं। अंत में, आप डेटा प्लॉट कर सकते हैं और उनके प्रत्युत्तर के अनुसार बिंदुओं को रंग कोड कर सकते हैं। प्लॉटिंग कैरेक्टर 19 आपको बड़े स्पष्ट डॉट्स देता है जो 1 या -1 होने पर क्रमशः नीले या लाल रंग में कोडेड होते हैं।

set.seed(10111)
x = matrix(rnorm(40), 20, 2)
y = rep(c(-1, 1), c(10, 10))
x[y == 1,] = x[y == 1,] + 1
plot(x, col = y + 3, pch = 19)संचालित द्वारा

अब आप e1071 पैकेज लोड करते हैं जिसमें svm फ़ंक्शन होता है (यदि आपने अभी तक पैकेज इंस्टॉल नहीं किया है तो याद से इंस्टॉल करें)।

library(e1071)संचालित द्वारा

अब आप डेटा का डेटा फ्रेम बनाते हैं, और y को एक फैक्टर वैरिएबल में बदलते हैं। इसके बाद, आप इस डेटा फ्रेम पर svm कॉल करते हैं, जहाँ y प्रतिक्रिया वैरिएबल है और अन्य वैरिएबल्स प्रीडिक्टर्स हैं। डेटा फ्रेम मैट्रिक्स x को खोलकर 2 कॉलम बनाएगा जिन्हें x1 और x2 नाम दिए जाएंगे। आप SVM को बताते हैं कि कर्नेल लीनियर है, ट्यूनिंग पैरामीटर cost 10 है, और scale false है। इस उदाहरण में, आप इसे वैरिएबल्स को स्टैंडर्डाइज़ न करने के लिए कहते हैं।

dat = data.frame(x, y = as.factor(y))
svmfit = svm(y ~ ., data = dat, kernel = "linear", cost = 10, scale = FALSE)
print(svmfit)संचालित द्वारा

svmfit को प्रिंट करने पर इसका सारांश मिलता है। आप देख सकते हैं कि सपोर्ट वेक्टरों की संख्या 6 है — ये वे बिंदु हैं जो सीमा के पास हैं या सीमा के गलत तरफ़ हैं।

SVM के लिए एक प्लॉट फ़ंक्शन भी है जो डिसीजन बाउंडरी दिखाता है, जैसा कि नीचे दिख रहा है। रंगों पर अधिक नियंत्रण नहीं दिखता। यह परंपरा से हटकर है क्योंकि यह x2 को क्षैतिज अक्ष पर और x1 को ऊर्ध्वाधर अक्ष पर रखता है।

plot(svmfit, dat)संचालित द्वारा

आइए अपना खुद का प्लॉट बनाने की कोशिश करते हैं। सबसे पहले x1 और x2 के लिए मानों का एक ग्रिड या जाल (lattice) बनाना है जो पूरे डोमेन को पर्याप्त घने lattice पर कवर करे। इसके लिए आप make.grid नामक फ़ंक्शन बनाते हैं। यह आपके डेटा मैट्रिक्स x को लेता है, साथ ही n आर्गुमेंट जो प्रत्येक दिशा में बिंदुओं की संख्या है। यहाँ आप 75 x 75 ग्रिड माँगेंगे।

इस फ़ंक्शन के भीतर, आप apply फ़ंक्शन का उपयोग करके x के प्रत्येक वैरिएबल की रेंज लेते हैं। फिर x1 और x2 दोनों के लिए, आप seq फ़ंक्शन से निम्नतम मान से उच्चतम मान तक n लंबाई का ग्रिड बनाते हैं। अब आपके पास x1 और x2 हैं, प्रत्येक में 75 समानांतर दूरी पर मान हैं। अंत में, आप expand.grid फ़ंक्शन का उपयोग करते हैं, जो x1 और x2 को लेकर lattice बनाता है।

make.grid = function(x, n = 75) {
  grange = apply(x, 2, range)
  x1 = seq(from = grange[1,1], to = grange[2,1], length = n)
  x2 = seq(from = grange[1,2], to = grange[2,2], length = n)
  expand.grid(X1 = x1, X2 = x2)
}संचालित द्वारा

अब आप x पर make.grid फ़ंक्शन लागू कर सकते हैं। आइए 1 से 10 तक lattice के शुरुआती कुछ मान देखते हैं।

xgrid = make.grid(x)
xgrid[1:10,]संचालित द्वारा

जैसा कि आप देख सकते हैं, ग्रिड पहले प्रथम निर्देशांक में चलता है, जबकि दूसरे निर्देशांक को स्थिर रखता है।

लैटिस बन जाने के बाद, आप लैटिस के प्रत्येक बिंदु पर प्रेडिक्शन करेंगे। नए डेटा xgrid के साथ, आप predict का उपयोग करते हैं और प्रतिक्रिया को ygrid कहते हैं। फिर आप प्लॉट करते हैं और वर्गीकरण के अनुसार बिंदुओं को रंग-कोड करते हैं ताकि डिसीजन बाउंडरी स्पष्ट हो। आइए इस प्लॉट पर मूल बिंदुओं को भी points फ़ंक्शन से रखें।

svmfit में index नाम का एक घटक होता है जो बताता है कि सपोर्ट पॉइंट कौन से हैं। आप उन्हें फिर से points फ़ंक्शन का उपयोग करके प्लॉट में शामिल करते हैं।

ygrid = predict(svmfit, xgrid)
plot(xgrid, col = c("red","blue")[as.numeric(ygrid)], pch = 20, cex = .2)
points(x, col = y + 3, pch = 19)
points(x[svmfit$index,], pch = 5, cex = 2)संचालित द्वारा

जैसा कि आप प्लॉट में देख सकते हैं, बक्सों में घिरे बिंदु डिसीजन बाउंडरी के पास हैं और उस सीमा को निर्धारित करने में महत्वपूर्ण हैं।

दुर्भाग्य से, svm फ़ंक्शन बहुत अनुकूल नहीं है, क्योंकि रैखिक गुणांक वापस पाने के लिए आपको कुछ काम करना पड़ता है। शायद कारण यह है कि यह केवल लीनियर कर्नेल्स के लिए ही मायने रखता है, और फ़ंक्शन अधिक सामान्य है। तो आइए गुणांक अधिक कुशलता से निकालने के लिए एक सूत्र का उपयोग करते हैं। आप beta और beta0 निकालते हैं, जो रैखिक गुणांक हैं।

beta = drop(t(svmfit$coefs)%*%x[svmfit$index,])
beta0 = svmfit$rhoसंचालित द्वारा

अब आप ग्रिड पर बिंदुओं को फिर से प्लॉट कर सकते हैं, फिर बिंदुओं (सपोर्ट वेक्टर बिंदुओं सहित) को वापस डाल सकते हैं। इसके बाद, आप एक सरल समीकरण के रूप में गुणांकों का उपयोग करके डिसीजन बाउंडरी खींच सकते हैं:

उस समीकरण से, आपको डिसीजन बाउंडरी के लिए ढाल और अवरोध (इंटरसेप्ट) निकालने होंगे। फिर आप abline फ़ंक्शन का उन 2 आर्गुमेंट्स के साथ उपयोग कर सकते हैं। अगली 2 abline कॉल क्रमशः डिसीजन बाउंडरी के ऊपरी मार्जिन और निचले मार्जिन का प्रतिनिधित्व करती हैं।

plot(xgrid, col = c("red", "blue")[as.numeric(ygrid)], pch = 20, cex = .2)
points(x, col = y + 3, pch = 19)
points(x[svmfit$index,], pch = 5, cex = 2)
abline(beta0 / beta[2], -beta[1] / beta[2])
abline((beta0 - 1) / beta[2], -beta[1] / beta[2], lty = 2)
abline((beta0 + 1) / beta[2], -beta[1] / beta[2], lty = 2)संचालित द्वारा

आप साफ़ देख सकते हैं कि कुछ सपोर्ट पॉइंट ठीक मार्जिन पर हैं, जबकि कुछ मार्जिन के अंदर हैं।

गैर-रैखिक SVM क्लासिफायर

पिछले अनुभाग में यह रैखिक SVM था। अब हम SVM के गैर-रैखिक संस्करण पर चलते हैं। आप पाठ्यपुस्तक Elements of Statistical Learning के एक उदाहरण पर नज़र डालेंगे, जिसमें 2 आयामों में एक मानक उदाहरण है जहाँ डिसीजन बाउंडरी गैर-रैखिक है। आप उस सीमा को सीखने के लिए कर्नेल सपोर्ट वेक्टर मशीन का उपयोग करेंगे।

सबसे पहले, आप उस उदाहरण का डेटा सीधे इस URL से डाउनलोड करके प्राप्त करते हैं, जहाँ डेटा मौजूद है। डेटा मिश्रित और सिम्यूलेटेड है। फिर आप इसके कॉलम नाम देख सकते हैं।

load(file = "ESL.mixture.rda")
names(ESL.mixture)संचालित द्वारा

फिलहाल, प्रशिक्षण डेटा x और y हैं। आपने पिछले उदाहरण के लिए पहले ही x और y बनाए थे। अतः, आइए उन्हें हटा दें ताकि आप इस नए डेटा को अटैच कर सकें।

rm(x, y)
attach(ESL.mixture)संचालित द्वारा

डेटा भी 2-आयामी है। बेहतर नज़र के लिए इसे प्लॉट करते हैं।

plot(x, col = y + 1)संचालित द्वारा

डेटा काफी हद तक ओवरलैप दिखता है, लेकिन इसकी संरचना में कुछ खास बात दिख रही है। अब, हम प्रतिक्रिया y के साथ एक डेटा फ्रेम बनाते हैं, और उसे फैक्टर में बदलते हैं। उसके बाद, आप रेडियल कर्नेल और cost = 5 के साथ एक SVM फिट कर सकते हैं।

dat = data.frame(y = factor(y), x)
fit = svm(factor(y) ~ ., data = dat, scale = FALSE, kernel = "radial", cost = 5)संचालित द्वारा

अब ग्रिड बनाना और प्रेडिक्शन करना का समय है। यह डेटा वास्तव में ग्रिड पॉइंट्स के साथ आया था। यदि आप सूची में दिए गए नामों के सारांश को देखें, तो वहाँ 2 वैरिएबल्स px1 और px2 हैं, जो प्रत्येक वैरिएबल के लिए मानों का ग्रिड हैं। आप expand.grid का उपयोग करके मानों का ग्रिड बना सकते हैं। फिर आप ग्रिड के प्रत्येक मान पर वर्गीकरण की भविष्यवाणी करते हैं।

xgrid = expand.grid(X1 = px1, X2 = px2)
ygrid = predict(fit, xgrid)संचालित द्वारा

अंत में, आप बिंदुओं को प्लॉट करते हैं और उन्हें डिसीजन बाउंडरी के अनुसार रंगते हैं। आप देख सकते हैं कि डिसीजन बाउंडरी गैर-रैखिक है। आप यह देखने के लिए डेटा बिंदुओं को भी प्लॉट में रख सकते हैं कि वे कहाँ आते हैं।

plot(xgrid, col = as.numeric(ygrid), pch = 20, cex = .2)
points(x, col = y + 1, pch = 19)संचालित द्वारा

डिसीजन बाउंडरी बड़े पैमाने पर वहीं चलती है जहाँ डेटा है, लेकिन बहुत गैर-रैखिक ढंग से।

देखते हैं क्या आप इस प्लॉट को थोड़ा और सुधार सकते हैं और प्रेडिक्ट फ़ंक्शन से हमारे हर ग्रिड पॉइंट पर वास्तविक फ़ंक्शन के अनुमानों का उत्पादन करा सकते हैं। खास तौर पर, आप contour फ़ंक्शन का उपयोग करते हुए एक कर्व डालना चाहेंगे जो डिसीजन बाउंडरी दे। डेटा फ्रेम पर prob नाम का एक वैरिएबल भी है, जो इन डेटा के लिए ग्रिड पॉइंट्स पर क्लास 1 की वास्तविक प्रायिकता है। यदि आप इसका 0.5 कंटूर प्लॉट करें, तो वह बेयज़ डिसीजन बाउंडरी देगा, जो सबसे अच्छा संभव है।

पहले, आप ग्रिड पर अपने फिट की भविष्यवाणी करते हैं। आप decision values को TRUE सेट करते हैं क्योंकि आपको केवल वर्गीकरण नहीं, वास्तविक फ़ंक्शन चाहिए। यह वास्तविक वर्गीकृत मानों का एक एट्रीब्यूट लौटाता है, इसलिए आपको उस एट्रीब्यूट को निकालना होगा। फिर आप decision नाम वाले को एक्सेस करते हैं।

इसके बाद, आप ऊपर जैसे ही कदमों का पालन करके ग्रिड बनाते हैं, प्रेडिक्शन करते हैं, और बिंदुओं को प्लॉट करते हैं।

फिर, contour फ़ंक्शन का उपयोग करने का समय है। इसे 2 ग्रिड अनुक्रम, एक फ़ंक्शन, और 2 आर्गुमेंट्स level और add चाहिए। आपको फ़ंक्शन एक मैट्रिक्स के रूप में चाहिए, जिसके आयाम px1 और px2 (क्रमशः 69 और 99) के हों। आप level को 0 सेट करते हैं और इसे प्लॉट में जोड़ते हैं। परिणामस्वरूप, आप देख सकते हैं कि कंटूर डिसीजन बाउंडरी का पीछा करता है — 2 आयामों में गैर-रैखिक डिसीजन बाउंडरी को प्लॉट करने का एक सुविधाजनक तरीका।

अंत में, आप सच्चाई शामिल करते हैं, जो प्रायिकताओं का कंटूर है। यह 0.5 कंटूर है, जो प्रायिकताओं के लिहाज़ से डिसीजन बाउंडरी होगी (जिसे बेयज़ डिसीजन बाउंडरी भी कहते हैं)।

func = predict(fit, xgrid, decision.values = TRUE)
func = attributes(func)$decision

xgrid = expand.grid(X1 = px1, X2 = px2)
ygrid = predict(fit, xgrid)
plot(xgrid, col = as.numeric(ygrid), pch = 20, cex = .2)
points(x, col = y + 1, pch = 19)

contour(px1, px2, matrix(func, 69, 99), level = 0, add = TRUE)
contour(px1, px2, matrix(func, 69, 99), level = 0.5, add = TRUE, col = "blue", lwd = 2)संचालित द्वारा

नतीजतन, आप देख सकते हैं कि आपका गैर-रैखिक SVM बेयज़ डिसीजन बाउंडरी के काफी करीब पहुँच गया है।

निष्कर्ष

संक्षेप में, सपोर्ट वेक्टर मशीनें सुपरवाइज्ड क्लासिफायर्स का एक उपवर्ग हैं जो फीचर स्पेस को दो या अधिक समूहों में विभाजित करने का प्रयास करती हैं। वे यह काम ज्ञात क्लास लेबल्स के आधार पर ऐसे समूहों को अलग करने का इष्टतम तरीका ढूँढकर करती हैं:

• सरल मामलों में पृथक्करण की "सीमा" रैखिक होती है, जिसके परिणामस्वरूप उच्च-आयामी स्पेस में समूह रेखाओं (या समतलों) से विभाजित होते हैं।
• जटिल मामलों में (जहाँ समूह रेखाओं या समतलों से अच्छी तरह पृथक नहीं होते), SVM गैर-रैखिक विभाजन करने में सक्षम होते हैं। यह एक कर्नेल फ़ंक्शन के माध्यम से प्राप्त होता है।
• अंततः, यह उन्हें बहुत परिष्कृत और सक्षम क्लासिफायर बनाता है, लेकिन सामान्य कीमत पर कि वे ओवरफिटिंग के प्रति संवेदनशील हो सकते हैं।

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

यदि आप R के बारे में और सीखना चाहते हैं, तो DataCamp का Machine Learning Toolbox कोर्स करें।

हमारा Scikit-learn के साथ सपोर्ट वेक्टर मशीनें ट्यूटोरियल देखें।