🤶🏾 🔞 🥐 एक भोला बेयस क्लासिफायर (आर के लिए कोड) का उपयोग करके एसएमएस स्पैम को फ़िल्टर करना 🔏 👩🏻‍🌾 🐈

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

नैवे बेस क्लासिफायर

कुछ वस्तुओं के सेट पर विचार करें D = {dq, d2, ..., dm} , जिनमें से प्रत्येक में सभी संकेतों F = {f1, f2, ..., fq} के साथ-साथ लेबल के सेट से एक निश्चित चिह्न है। C = {c1, c2, ..., cr} । हमारा कार्य इसकी विशेषताओं Fd = {fd1, fd2, ..., fdn} के सेट के आधार पर, आने वाली वस्तु d की सबसे अधिक संभावना वर्ग / लेबल की गणना करना है। दूसरे शब्दों में, हमें यादृच्छिक चर C के मूल्य की गणना करने की आवश्यकता है , जिस पर एक पोस्टीरियर अधिकतम ( अधिकतम पोस्टीरियर प्रायिकता , एमएपी) प्राप्त की जाती है।

२.१ - वास्तव में, यह हमारा लक्ष्य है
2.2 - बेयस प्रमेय द्वारा विघटित
2.3 - यह विचार करते हुए कि हम एक तर्क की तलाश कर रहे हैं, संभावना फ़ंक्शन को अधिकतम करता है, और यह कि भाजक इस तर्क से स्वतंत्र है और इस मामले में स्थिर है, हम सुरक्षित रूप से कुल संभाव्यता पी (डी) के मूल्य को पार कर सकते हैं
2.4 - चूँकि लघुगणक किसी x> 0 के लिए एकरूपता बढ़ाता है, तो किसी भी फ़ंक्शन f (x) का अधिकतम ln (f (x)) के समान होगा; यह आवश्यक है ताकि भविष्य में प्रोग्रामिंग के दौरान शून्य के करीब संख्याओं के साथ काम न किया जाए

भोला बेयर्स क्लासिफायर मॉडल दो मान्यताओं को स्वीकार करता है, जो इसे इतना भोला बनाता है:

वस्तु के संकेतों का क्रम मायने नहीं रखता;
इस वर्ग में संकेतों की संभावनाएं एक दूसरे पर निर्भर नहीं होती हैं: ।

उपरोक्त मान्यताओं को देखते हुए, हम सूत्रों की व्युत्पत्ति जारी रखते हैं।

2.6-2.7 - यह सिर्फ मान्यताओं के अनुप्रयोग का परिणाम है
२. the - यहाँ, बस, लघुगणक की उल्लेखनीय संपत्ति को लागू किया जाता है, जो बहुत ही उत्कृष्ट मूल्यों के साथ संचालन करते समय सटीकता की हानि से बचने की अनुमति देता है।

हम एक भोले बेयस क्लासिफायर के एक ग्राफिक मॉडल को निम्नानुसार चित्रित कर सकते हैं:

स्पैम क्लासीफायर

अब सामान्य वर्गीकरण कार्य से हम स्पैम को वर्गीकृत करने के विशिष्ट कार्य में लगेंगे। तो, सेट डी में एसएमएस संदेश होते हैं। प्रत्येक संदेश सेट C = {हैम, स्पैम} से टैग किया गया है । संकेतों की अवधारणा तैयार करने के लिए, हम शब्द प्रतिनिधित्व मॉडल के बैग का उपयोग करेंगे, हम एक उदाहरण के साथ इसका उदाहरण देते हैं। मान लीजिए कि हमारे पास डेटाबेस में केवल दो हैम एसएमएस संदेश हैं

hi how are you
how old are you

तब हम एक टेबल बना सकते हैं

शब्द	आवृत्ति
हाय	1
कैसे	2
कर रहे हैं	2
आप	2
पुराना	1

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

पी (फाई = "कैसे" | सी = हैम) = 2/8 = 1/4

या हम इस विधि को सामान्य रूप में लिख सकते हैं:

, जहां क्यू शब्दकोष में अद्वितीय शब्दों की कुल संख्या है।

लाप्लास ब्लर

इस बिंदु पर, यह निम्न समस्या पर ध्यान देने का समय है। दो हैम संदेशों के हमारे डेटाबेस को याद करें, और मान लें कि वर्गीकरण के लिए एक संदेश हमारे पास आया: " हाय भाई ", और, मान लीजिए, गैर-स्पैम पी (हैम) = 1/2 की एक प्राथमिक संभावना। हम शब्दों की संभावनाओं की गणना करते हैं:

पी ("हाय" | हैम) = 1/8
पी ("ब्रो" | हैम) = 0/8 = 0

सूत्र 2.8 को याद करें और c = हैम के साथ argmax के अंतर्गत अभिव्यक्ति की गणना करें:

जाहिर है, हम या तो एक त्रुटि या नकारात्मक अनंतता प्राप्त करते हैं, क्योंकि शून्य पर लघुगणक मौजूद नहीं है। यदि हम लघुगणक का उपयोग नहीं करते हैं, तो हम बस 0 प्राप्त करेंगे, अर्थात। इस संदेश की संभावना शून्य होगी, जो सिद्धांत रूप में हमारे लिए बहुत लाभकारी है।

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

, जहां z> = 0 धब्बा गुणांक है, और q उन मानों की संख्या है जो एक यादृच्छिक चर ले सकते हैं, हमारे मामले में यह कक्षा में शब्दों की संख्या है; और q शब्दों की कुल संख्या है जो मॉडल को पढ़ाने में उपयोग की गई थी।

उदाहरण के लिए, हैम और स्पैम संदेशों को पढ़ते समय, हमें 10 अद्वितीय शब्द मिले, फिर P ("hi" | हैम) = (1 + 1) / (8 + 1 * 10) = 2/18 = 1/9 एक धुंधला गुणांक z के साथ = 1. और शून्य संभावना ऐसी होती है: P ("ब्रो" | हैम) = (0 + 1) / (8 + 1 * 10) = 1/18 ।

बायेसियन दृष्टिकोण से, यह विधि पूर्ववर्ती वितरण के रूप में पैरामीटर z के द्वारा डिरिचलेट डिस्ट्रीब्यूटेड डिस्ट्रिब्यूटर्स का उपयोग करके, पीछे के वितरण की गणितीय अपेक्षा से मेल खाती है।

प्रयोग और कोड

मैं कैम्पिनास विश्वविद्यालय की वेबसाइट से डाउनलोड किए गए डेटाबेस का उपयोग करता हूं, जिसमें 4827 सामान्य एसएमएस संदेश (हैम) और 747 स्पैम संदेश हैं।

मैंने कोई गंभीर पाठ पूर्व-प्रक्रिया नहीं किया, जैसे कि स्टेमिंग , बस कुछ सरल ऑपरेशन:

पाठ को कम करने के लिए
सभी विराम चिह्नों को हटा दिया गया
एक के साथ सभी संख्यात्मक अनुक्रमों को बदल दिया

प्रीप्रोसेसिंग कोड

 PreprocessSentence <- function(s) { # Cut and make some preprocessing with input sentence words <- strsplit(gsub(pattern="[[:digit:]]+", replacement="1", x=tolower(s)), '[[:punct:][:blank:]]+') return(words) } LoadData <- function(fileName = "./Data/Spam/SMSSpamCollection") { # Read data from text file and makes simple preprocessing: # to lower case -> replace all digit strings with 1 -> split with punctuation and blank characters con <- file(fileName,"rt") lines <- readLines(con) close(con) df <- data.frame(lab = rep(NA, length(lines)), data = rep(NA, length(lines))) for(i in 1:length(lines)) { tmp <- unlist(strsplit(lines[i], '\t', fixed = T)) df$lab[i] <- tmp[1] df$data[i] <- PreprocessSentence(tmp[2]) } return(df) }

निम्न फ़ंक्शन उपयुक्त अनुपात में डेटा सरणी का एक विभाजन बनाता है, जिससे प्रशिक्षण, सत्यापन और परीक्षण डेटा सेट के सूचकांक उत्पन्न होते हैं:

पृथक्करण तिथि

 CreateDataSet <- function(dataSet, proportions = c(0.6, 0.2, 0.2)) { # Creates a list with indices of train, validation and test sets proportions <- proportions/sum(proportions) hamIdx <- which(df$lab == "ham") nham <- length(hamIdx) spamIdx <- which(df$lab == "spam") nspam <- length(spamIdx) hamTrainIdx <- sample(hamIdx, floor(proportions[1]*nham)) hamIdx <- setdiff(hamIdx, hamTrainIdx) spamTrainIdx <- sample(spamIdx, floor(proportions[1]*nspam)) spamIdx <- setdiff(spamIdx, spamTrainIdx) hamValidationIdx <- sample(hamIdx, floor(proportions[2]*nham)) hamIdx <- setdiff(hamIdx, hamValidationIdx) spamValidationIdx <- sample(spamIdx, floor(proportions[2]*nspam)) spamIdx <- setdiff(spamIdx, spamValidationIdx) ds <- list( train = sample(union(hamTrainIdx, spamTrainIdx)), validation = sample(union(hamValidationIdx, spamValidationIdx)), test = sample(union(hamIdx, spamIdx)) ) return(ds) }

तब इनपुट डेटा ऐरे के आधार पर एक मॉडल बनाया जाता है:

मॉडल निर्माण

 CreateModel <- function(data, laplaceFactor = 0) { # creates naive bayes spam classifier based on data m <- list(laplaceFactor = laplaceFactor) m[["total"]] <- length(data$lab) m[["ham"]] <- list() m[["spam"]] <- list() m[["hamLabelCount"]] <- sum(data$lab == "ham") m[["spamLabelCount"]] <- sum(data$lab == "spam") m[["hamWordCount"]] <- 0 m[["spamWordCount"]] <- 0 uniqueWordSet <- c() for(i in 1:length(data$lab)) { sentence <- unlist(data$data[i]) uniqueWordSet <- union(uniqueWordSet, sentence) for(j in 1:length(sentence)) { if(data$lab[i] == "ham") { if(is.null(m$ham[[sentence[j]]])) { m$ham[[sentence[j]]] <- 1 } else { m$ham[[sentence[j]]] <- m$ham[[sentence[j]]] + 1 } m[["hamWordCount"]] <- m[["hamWordCount"]] + 1 } else if(data$lab[i] == "spam") { if(is.null(m$spam[[sentence[j]]])) { m$spam[[sentence[j]]] <- 1 } else { m$spam[[sentence[j]]] <- m$spam[[sentence[j]]] + 1 } m[["spamWordCount"]] <- m[["spamWordCount"]] + 1 } } } m[["uniqueWordCount"]] <- length(uniqueWordSet) return(m) }

मॉडल के संबंध में अंतिम फ़ंक्शन प्रशिक्षित मॉडल का उपयोग करके आने वाले संदेश को वर्गीकृत करता है:

वर्गीकरण के बाद

 ClassifySentense <- function(s, model, preprocess = T) { # calculate class of the input sentence based on the model GetCount <- function(w, ls) { if(is.null(ls[[w]])) { return(0) } return(ls[[w]]) } words <- unlist(s) if(preprocess) { words <- unlist(PreprocessSentence(s)) } ham <- log(model$hamLabelCount/(model$hamLabelCount + model$spamLabelCount)) spam <- log(model$spamLabelCount/(model$hamLabelCount + model$spamLabelCount)) for(i in 1:length(words)) { ham <- ham + log((GetCount(words[i], model$ham) + model$laplaceFactor) /(model$hamWordCount + model$laplaceFactor*model$uniqueWordCount)) spam <- spam + log((GetCount(words[i], model$spam) + model$laplaceFactor) /(model$spamWordCount + model$laplaceFactor*model$uniqueWordCount)) } if(ham >= spam) { return("ham") } return("spam") }

सेट पर मॉडल का परीक्षण करने के लिए, निम्नलिखित फ़ंक्शन का उपयोग किया जाता है:

मॉडल परीक्षण

 TestModel <- function(data, model) { # calculate percentage of errors errors <- 0 for(i in 1:length(data$lab)) { predictedLabel <- ClassifySentense(data$data[i], model, preprocess = F) if(predictedLabel != data$lab[i]) { errors <- errors + 1 } } return(errors/length(data$lab)) }

इष्टतम धुंधला गुणांक की खोज करने के लिए, इसी सेट पर क्रॉस-सत्यापन का उपयोग किया जाता है:

क्रॉस सत्यापन मॉडल

 CrossValidation <- function(trainData, validationData, laplaceFactorValues, showLog = F) { cvErrors <- rep(NA, length(laplaceFactorValues)) for(i in 1:length(laplaceFactorValues)) { model <- CreateModel(trainData, laplaceFactorValues[i]) cvErrors[i] <- TestModel(validationData, model) if(showLog) { print(paste(laplaceFactorValues[i], ": error is ", cvErrors[i], sep="")) } } return(cvErrors) }

निम्न कोड डेटा को पढ़ता है, 0 से 10 तक ब्लर पैरामीटर के मूल्यों के लिए मॉडल बनाता है, सबसे अच्छा परिणाम का चयन करता है, पहले अप्रयुक्त परीक्षण सेट पर मॉडल का परीक्षण करता है और फिर ब्लर पैरामीटर से क्रॉस-सत्यापन सेट पर त्रुटि परिवर्तन का एक ग्राफ बनाता है और परीक्षण सेट पर अंतिम त्रुटि स्तर:

 rm(list = ls()) source("./Spam/spam.R") set.seed(14880) fileName <- "./Data/Spam/SMSSpamCollection" df <- LoadData() ds <- CreateDataSet(df, proportions = c(0.7, 0.2, 0.1)) laplaceFactorValues <- 1:10 cvErrors <- CrossValidation(df[ds$train, ], df[ds$validation, ], 0:10, showLog = T) bestLaplaceFactor <- laplaceFactorValues[which(cvErrors == min(cvErrors))] model <- CreateModel(data=df[ds$train, ], laplaceFactor=bestLaplaceFactor) testResult <- TestModel(df[ds$test, ], model) plot(cvErrors, type="l", col="blue", xlab="Laplace Factor", ylab="Error Value", ylim=c(0, max(cvErrors))) title("Cross validation and test error value") abline(h=testResult, col="red") legend(bestLaplaceFactor, max(cvErrors), c("cross validation values", "test value level"), cex=0.8, col=c("blue", "red"), lty=1)

सभी कोड github से डाउनलोड किए जा सकते हैं।

निष्कर्ष

जैसा कि आप देख सकते हैं, यह विधि सरल प्रीप्रोसेसिंग के साथ भी बहुत प्रभावी है, परीक्षण सेट पर त्रुटि सूचक (संदेशों की कुल संख्या में गलत तरीके से वर्गीकृत संदेशों का अनुपात) केवल 2.32% है । आप इस विधि का उपयोग कहां कर सकते हैं? उदाहरण के लिए, आपकी साइट पर कई टिप्पणियां हैं, आपने हाल ही में 1 से 5 तक टिप्पणियों की रेटिंग दर्ज की है, और आपके पास केवल एक छोटा सा हिस्सा है जिसे लोगों ने वास्तव में रेट किया है; फिर आप शेष टिप्पणियों के लिए स्वचालित रूप से अधिक या कम प्रासंगिक रेटिंग रैंक कर सकते हैं।

एक भोला बेयस क्लासिफायर (आर के लिए कोड) का उपयोग करके एसएमएस स्पैम को फ़िल्टर करना

नैवे बेस क्लासिफायर

स्पैम क्लासीफायर

लाप्लास ब्लर

प्रयोग और कोड

निष्कर्ष

More articles: