डेटामाइनिंग के लिए कारक स्तरों के संयोजन के लिए आर पैकेज?

Question

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

अपडेट करें:

इन महान सुझावों के लिए धन्यवाद, मैंने एक फ़ंक्शन बहुत आसानी से लिखा। मुझे एहसास हुआ कि अनुपात के साथ स्तरों को गिराना संभव था <न्यूनतम और अभी भी है कि पुनरावर्ती स्तर <न्यूनतम है, अनुपात के साथ निम्नतम स्तर के जोड़ की आवश्यकता है> न्यूनतम। संभवतः अधिक कुशल हो सकता है लेकिन यह काम करने के लिए प्रकट होता है। अगली एन्हांसमेंट यह पता लगाने की होगी कि नए डेटा (एक सत्यापन सेट या अन्य डेटा) में पतन तर्क को लागू करने के लिए "नियमों" पर कैसे कब्जा किया जाए।

collapseFactors<- function(tableName,minPercent=5,fillIn ="RECODED" )
{
    for (i in 1:ncol(tableName))
        {   

            if(is.factor(tableName[,i]) == TRUE) #process just factors
            {


                sortedTable<-sort(prop.table(table(tableName[,i])))
                numberToCollapse<-length(sortedTable[sortedTable<(minPercent/100)])

                if (sum(sortedTable[1:numberToCollapse])<(minPercent/100))
                    {
                        numberToCollapse=numberToCollapse+1 #add next level if < minPercent
                    }

                if(numberToCollapse>1) #if not >1 then nothing to collapse
                {
                    lf <- names(sortedTable[1:numberToCollapse])
                    levels(tableName[,i])[levels(tableName[,i]) %in% lf] <- fillIn
                }
            }#end if a factor


        }#end for loop

    return(tableName)

}#end function

Comments

दूसरे दृष्टिकोण के लिए: आंकड़े.stackexchange.com/questions/227125/…

— kjetil b halvorsen

Answer 1

ऐसा लगता है कि यह कारक को "रीलेवल करने" की बात है; आंशिक रकम की गणना करने या मूल वेक्टर की एक प्रति बनाने की कोई आवश्यकता नहीं है। उदाहरण के लिए,

set.seed(101)
a <- factor(LETTERS[sample(5, 150, replace=TRUE, 
                           prob=c(.1, .15, rep(.75/3,3)))])
p <- 1/5
lf <- names(which(prop.table(table(a)) < p))
levels(a)[levels(a) %in% lf] <- "Other"

यहां, मूल कारक स्तरों को निम्नानुसार वितरित किया गया है:

 A  B  C  D  E 
18 23 35 36 38 

और फिर यह बन जाता है

Other     C     D     E 
   41    35    36    38 

यह आसानी से एक समारोह में लपेटा जा सकता है। रिशेप पैकेज combine_factor()में एक फ़ंक्शन है , इसलिए मुझे लगता है कि यह उपयोगी भी हो सकता है।

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

Comments

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

— B_Miner

@chl +1, अच्छा है। मैंने अपना कार्य पूरी तरह से लिखा था क्योंकि कोड [a (स्तर)%% में] <- "अन्य" काम नहीं करता है, इसलिए मैंने माना कि कारक स्तर परिवर्तन जटिल मामला है। हमेशा की तरह यह पता चला कि R जटिल नहीं है, मैं :)

— mpiktas

@mpiktas Thx तुम्हें पता है, जैसे के साथ वेक्टर स्तर पर काम कर सकते हैं a[as.character(a) %in% lf] <- lf[1]; a <- factor(droplevels(a), labels=c("Other",LETTERS[3:5]))।

— chl

+1। [[स्तर (ए)% में% lf] <- "अन्य" निश्चित रूप से एक टन कोड लाइनों को बचाता है। चतुर और कुशल!

— क्रिस्टोफर एडन

लेकिन ध्यान दें कि एक [a == "a"] <- "अन्य" काम नहीं करेगा, जो मेरे लिए यह मानने के लिए काफी स्वाभाविक है कि यह होना चाहिए। खासकर जब से [a == "a"] पूरी तरह से मान्य है।

— mpiktas

Answer 2

क्रिस्टोफर जवाब के साथ एकमात्र समस्या यह है कि यह कारक के मूल क्रम को मिलाएगा। यहाँ मेरा फिक्स है:

 Merge.factors <- function(x, p) {
     t <- table(x)
     levt <- cbind(names(t), names(t)) 
     levt[t/sum(t)<p, 2] <- "Other"
     change.levels(x, levt)
 }

change.levelsनिम्नलिखित कार्य कहां है मैंने इसे कुछ समय पहले लिखा था, इसलिए मुझे संदेह है कि इसे प्राप्त करने के बेहतर तरीके हो सकते हैं।

 change.levels <- function(f, levt) {
     ##Change the the names of the factor f levels from
     ##substitution table levt.
     ## In the first column there are the original levels, in
     ## the second column -- the substitutes
     lv <- levels(f)
     if(sum(sort(lv) != sort(levt[, 1]))>0)
     stop ("The names from substitution table does not match given level names")
     res <- rep(NA, length(f))

     for(i in lv) {
          res[f==i] <- as.character(levt[levt[, 1]==i, 2])
     }
     factor(res)
}

Answer 3

मैंने एक त्वरित कार्य लिखा है जो इस लक्ष्य को पूरा करेगा। मैं एक नौसिखिया आर उपयोगकर्ता हूं, इसलिए यह बड़ी तालिकाओं के साथ धीमा हो सकता है।

Merge.factors <- function(x, p) { 
    #Combines factor levels in x that are less than a specified proportion, p.
    t <- table(x)
    y <- subset(t, prop.table(t) < p)
    z <- subset(t, prop.table(t) >= p)
    other <- rep("Other", sum(y))
    new.table <- c(z, table(other))
    new.x <- as.factor(rep(names(new.table), new.table))
    return(new.x)
}

कार्रवाई में इसका एक उदाहरण के रूप में:

> a <- rep("a", 100)
> b <- rep("b", 1000)
> c <- rep("c", 1000)
> d <- rep("d", 1000)
> e <- rep("e", 400)
> f <- rep("f", 100)
> x <- factor(c(a, b, c, d, e, f))
> summary(x)
   a    b    c    d    e    f 
 100 1000 1000 1000  400  100 
> prop.table(table(x))
x
         a          b          c          d          e          f 
0.02777778 0.27777778 0.27777778 0.27777778 0.11111111 0.02777778 
> 
> w <- Merge.factors(x, .05)
> summary(w)
    b     c     d     e Other 
 1000  1000  1000   400   200 
> class(w)
[1] "factor"

Comments

अवलोकन के लिए धन्यवाद, जॉन। मैंने इसे एक कारक बनाने के लिए इसे थोड़ा बदल दिया है। मैंने किया था, हालांकि मूल वेक्टर को तालिका से रीमेक किया गया था, इसलिए यदि उस चरण को छोड़ने का कोई तरीका है, तो यह तेज हो जाएगा।

— क्रिस्टोफर एडन

प्रतिक्रिया देने वाले सभी लोगों का शुक्रिया। मेरा आर कमजोर है, लेकिन कोड की कुछ पंक्तियों के साथ ऐसा करने की क्षमता वसीयतनामा है कि यह कितना शक्तिशाली है और मुझे सीखना चाहता है।

— B_Miner