क्या मोड खोजने के लिए एक अंतर्निहित फ़ंक्शन है?

Question

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

Comments

आपको यह स्पष्ट करना होगा कि क्या आपका डेटा पूर्णांक, संख्यात्मक, कारक है ...? अंकशास्त्र के लिए मोड का अनुमान अलग होगा, और अंतराल का उपयोग करता है। देखें modeest

— एसएमसीआई

आर में मोड के लिए एक अंतर्निहित फ़ंक्शन क्यों नहीं है? R mode, फ़ंक्शन के समान क्यों माना जाता है class?

— कोरी लेविंसन

Answer 1

एक और समाधान, जो संख्यात्मक और चरित्र / कारक डेटा दोनों के लिए काम करता है:

Mode <- function(x) {
  ux <- unique(x)
  ux[which.max(tabulate(match(x, ux)))]
}

मेरी डिंकी छोटी मशीन पर, जो लगभग 10 सेकंड में 10M-पूर्णांक वेक्टर के मोड को उत्पन्न और खोज सकता है।

यदि आपके डेटा सेट में कई मोड हो सकते हैं, तो उपरोक्त समाधान के रूप में एक ही दृष्टिकोण लेता है which.max, और मोड के सेट का पहला-दिखने वाला मान लौटाता है । सभी मोड लौटाने के लिए , इस संस्करण का उपयोग करें (टिप्पणियों में @digEmAll से):

Modes <- function(x) {
  ux <- unique(x)
  tab <- tabulate(match(x, ux))
  ux[tab == max(tab)]
}

Comments

तार्किकों के लिए भी काम करता है! सभी प्रकार के वैक्टर के लिए डेटा प्रकार को सुरक्षित रखता है (अन्य उत्तरों में कुछ कार्यान्वयन के विपरीत)।

— 19

यह मल्टी-मोडल डेटासेट (जैसे c(1,1,2,2)) के मामले में सभी मोड वापस नहीं करता है । आपको अपनी अंतिम पंक्ति को इस प्रकार बदलना चाहिए:tab <- tabulate(match(x, ux)); ux[tab == max(tab)]

— digEmAll

@verybadatthis उसके लिए, आप ux[which.max(tabulate(match(x, ux)))]बस के साथ बदल देंगे max(tabulate(match(x, ux)))।

— केन विलियम्स

आप ध्यान दें कि Mode(1:3)देता है 1और Mode(3:1)देता है 3, इसलिए मोड सबसे लगातार तत्व या पहला रिटर्न देता है यदि वे सभी अद्वितीय हैं।

— एनरिक पेरीज़ हेरेरो

जैसा कि एनरिक ने कहा: यह तब विफल होता है जब कोई मोड नहीं होता है, और इसके बजाय आपको यह धारणा देता है कि पहला मान मोड है। अगर यह वापस आ जाता 0या NAउन मामलों में बेहतर होता।

— not2qubit

Answer 2

वहाँ पैकेज है modeestजो यूनीवेट अनिमॉडल (और कभी-कभी मल्टीमॉडल) डेटा के मोड के अनुमानक प्रदान करता है और सामान्य संभावना वितरण के मोड के मान।

mySamples <- c(19, 4, 5, 7, 29, 19, 29, 13, 25, 19)

library(modeest)
mlv(mySamples, method = "mfv")

Mode (most likely value): 19 
Bickel's modal skewness: -0.1 
Call: mlv.default(x = mySamples, method = "mfv")

अधिक जानकारी के लिए यह पृष्ठ देखें

Comments

तो बस, मोड मूल्य प्राप्त करने के mfv(mySamples)[1]। 1महत्वपूर्ण होने के रूप में यह वास्तव में देता है सबसे लगातार मूल्य रों ।

— एटॉमिक्यूलस

यह इस उदाहरण में काम नहीं करता है: पुस्तकालय (मामूली) एक <- rnorm (50, 30, 2) b <- rnorm (100, 35, 2) c <- rnorm (20, 37, 2) तापमान < c (a, b, c) hist (temperature )C) # माइन एबलाइन (v = माध्य (temperatureºC), col = "red", lwd = 2) #median abline (v = माध्यिका (temperatureºC), col = "black") lwd = 2) #mode abline (v = mlv (तापमान ,C, विधि = "mfv") [1], col = "नारंगी", lwd = 2)

— Agus camacho

@atomicules: [1] के साथ आपको केवल पहला मोड मिलता है। बिमोडल या सामान्य एन-मोडल वितरण के लिए आपको बस जरूरत होगीmfv(mySamples)

— पेटीज

आर संस्करण 3.6.0 के लिए, यह कहता है कि फ़ंक्शन 'फ़ंक्शन "एमएलवी" नहीं खोज सका और वही त्रुटि जब मैंने एमएफवी (मायसम) की कोशिश की। क्या यह मूल्यह्रास है?

— डॉ। निशा अरोड़ा

@DrNishaArora: क्या आपने 'मोडेस्ट' पैकेज डाउनलोड किया है?

— petzi

Answer 3

आर मेलिंग सूची में यह पाया, आशा है कि यह उपयोगी है। यह भी है कि मैं वैसे भी क्या सोच रहा था। आप डेटा को क्रमबद्ध करना चाहते हैं और फिर पहला नाम चुनें। यह हैकिश है लेकिन काम करना चाहिए।

names(sort(-table(x)))[1]

Comments

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

— 19

मैंने 1e6 तत्वों के कारक के साथ चलने का समय मापा और यह समाधान लगभग कारक 3 द्वारा स्वीकृत उत्तर की तुलना में तेज़ था!

— vonjd

मैंने अभी इसे as.numeric () का उपयोग करके नंबर में परिवर्तित किया है। पूरी तरह से ठीक काम करता है। धन्यवाद!

— अभिषेक सिंह

Answer 4

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

Mode <- function(x, na.rm = FALSE) {
  if(na.rm){
    x = x[!is.na(x)]
  }

  ux <- unique(x)
  return(ux[which.max(tabulate(match(x, ux)))])
}

Comments

मैंने इसके लिए कुछ गति प्राप्त की है, नीचे उत्तर देखें।

— डैन ह्यूटन

Answer 5

आपके द्वारा निरंतर संख्याहीन वितरण (जैसे सामान्य वितरण) से आने वाले संख्याओं के वेक्टर के मोड का अनुमान लगाने का एक त्वरित और गंदा तरीका निम्नलिखित फ़ंक्शन को परिभाषित और उपयोग कर रहा है:

estimate_mode <- function(x) {
  d <- density(x)
  d$x[which.max(d$y)]
}

फिर मोड अनुमान प्राप्त करने के लिए:

x <- c(5.8, 5.6, 6.2, 4.1, 4.9, 2.4, 3.9, 1.8, 5.7, 3.2)
estimate_mode(x)
## 5.439788

Comments

बस इस पर एक नोट: आप इस तरह से निरंतर संख्याओं के किसी भी समूह का "मोड" प्राप्त कर सकते हैं। डेटा को काम करने के लिए एक सामान्य वितरण से आने की आवश्यकता नहीं है। यहां एक समान वितरण से संख्या लेने का एक उदाहरण है। set.seed(1); a<-runif(100); mode<-density(a)$x[which.max(density(a)$y)]; abline(v=mode)

— जोता

error in density.default(x, from = from, to = to) : need at least 2 points to select a bandwidth automatically

— सर्जियो

@xhie वह त्रुटि संदेश आपको वह सब कुछ बताता है जो आपको जानना आवश्यक है। यदि आपके पास बस एक बिंदु है तो आपको कॉल करते समय मैन्युअल रूप से बैंडविड्थ सेट करने की आवश्यकता है density। हालाँकि, यदि आपके पास सिर्फ एक डाटापॉइंट है, तो उस डाटापॉइंट का मूल्य शायद वैसे भी मोड के लिए आपका सबसे अच्छा अनुमान होगा ...

— रासमस बैथ

आप सही हैं, लेकिन मैंने सिर्फ एक ट्विक जोड़ा: estimate_mode <- function(x) { if (length(x)>1){ d <- density(x) d$x[which.max(d$y)] }else{ x } } मैं सर्कुलर पैकेज के साथ वैक्टरियल औसत का उपयोग करने की दिशा के बजाय, मुख्य दिशा हवा का अनुमान लगाने की विधि का परीक्षण कर रहा हूं। मैं ', एक बहुभुज ग्रेड पर अंक के साथ काम कर रहा हूं, इसलिए, कभी-कभी दिशा के साथ केवल एक बिंदु होता है। धन्यवाद!

— सर्जियो

@xhie उचित लगता है :)

— रासमस बैथ

Answer 6

निम्नलिखित फ़ंक्शन तीन रूपों में आता है:

विधि = "मोड" [डिफ़ॉल्ट]: एक अनिमॉडल वेक्टर के लिए मोड की गणना करता है, अन्यथा एक NA
पद्धति = "nmodes" लौटाता है: वेक्टर
विधि में मोड की संख्या की गणना करता है = "मोड": एक यूनिमॉडल या पॉलीमोडल के लिए सभी मोड को सूचीबद्ध करता है। वेक्टर

modeav <- function (x, method = "mode", na.rm = FALSE)
{
  x <- unlist(x)
  if (na.rm)
    x <- x[!is.na(x)]
  u <- unique(x)
  n <- length(u)
  #get frequencies of each of the unique values in the vector
  frequencies <- rep(0, n)
  for (i in seq_len(n)) {
    if (is.na(u[i])) {
      frequencies[i] <- sum(is.na(x))
    }
    else {
      frequencies[i] <- sum(x == u[i], na.rm = TRUE)
    }
  }
  #mode if a unimodal vector, else NA
  if (method == "mode" | is.na(method) | method == "")
  {return(ifelse(length(frequencies[frequencies==max(frequencies)])>1,NA,u[which.max(frequencies)]))}
  #number of modes
  if(method == "nmode" | method == "nmodes")
  {return(length(frequencies[frequencies==max(frequencies)]))}
  #list of all modes
  if (method == "modes" | method == "modevalues")
  {return(u[which(frequencies==max(frequencies), arr.ind = FALSE, useNames = FALSE)])}  
  #error trap the method
  warning("Warning: method not recognised.  Valid methods are 'mode' [default], 'nmodes' and 'modes'")
  return()
}

Comments

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

— ग्रेज़गोरेज़ एडम कोवाल्स्की

टिप्पणी के लिए बहुत धन्यवाद। "nmode" और "मोड" को अब अपेक्षित रूप से व्यवहार करना चाहिए।

— क्रिस

आपका फ़ंक्शन लगभग काम करता है, सिवाय इसके कि जब प्रत्येक मूल्य समान रूप से अक्सर उपयोग होता है method = 'modes'। फिर फ़ंक्शन सभी अद्वितीय मान लौटाता है, हालांकि वास्तव में कोई मोड नहीं है, इसलिए इसके NAबजाय वापस लौटना चाहिए। मैं आपके फ़ंक्शन के थोड़ा अनुकूलित संस्करण युक्त एक और उत्तर जोड़ूंगा, प्रेरणा के लिए धन्यवाद!

— ह्यूगोबर्ग

केवल एक गैर-खाली संख्यात्मक वेक्टर को सामान्य रूप से इस फ़ंक्शन के साथ एक NA उत्पन्न करना चाहिए जब एक पॉलीमोडल वेक्टर पर डिफ़ॉल्ट विधि का उपयोग किया जाता है। संख्याओं के सरल अनुक्रम जैसे 1,2,3,4 वास्तव में अनुक्रम में उन सभी संख्याओं के हैं, इसलिए समान अनुक्रम "मोड" के लिए अपेक्षा के अनुरूप व्यवहार किया जाता है। जैसे modeave (c (1,2,3,4), तरीका = "मोड") रिटर्न [1] 1 2 3 4 इसके बावजूद, मैं फंक्शन को ऑप्टिमाइज़ करके देखने में बहुत दिलचस्पी लूंगा क्योंकि यह काफी रिसोर्स इंटेंसिव है। वर्तमान स्थिति

— क्रिस

इस फ़ंक्शन के अधिक कुशल संस्करण के लिए, @ hugovdberg की पोस्ट ऊपर देखें :)

— क्रिस

Answer 7

यहाँ, एक और समाधान:

freq <- tapply(mySamples,mySamples,length)
#or freq <- table(mySamples)
as.numeric(names(freq)[which.max(freq)])

Comments

आप तालिका के साथ पहली पंक्ति को बदल सकते हैं।

— जोनाथन चांग

मैं सोच रहा था कि 'टेबल' की तुलना में 'टैपली' अधिक कुशल है, लेकिन वे दोनों लूप के लिए उपयोग करते हैं। मुझे लगता है कि तालिका के साथ समाधान बराबर है। मैं जवाब को अपडेट करता हूं।

— तश्तरी

Answer 8

मैं अभी तक वोट नहीं दे सकता लेकिन रासमस बैथ का जवाब वही है जो मैं खोज रहा था। हालाँकि, मैं इसे थोड़ा संशोधित करके केवल 0 और 1 के बीच उदाहरण के लिए मानों के वितरण के लिए अनुमति दूंगा।

estimate_mode <- function(x,from=min(x), to=max(x)) {
  d <- density(x, from=from, to=to)
  d$x[which.max(d$y)]
}

हम जानते हैं कि आप अपने सभी वितरण में बाधा नहीं डालना चाह सकते हैं, फिर = - "BIG NUMBER" से = "=" बड़े पैमाने पर सेट करें।

Comments

error in density.default(x, from = from, to = to) : need at least 2 points to select a bandwidth automatically

— सर्जियो

x एक वेक्टर होना चाहिए

— अलेउरिटे

Answer 9

वैकल्पिक विलोम को जोड़ते हुए केन विलियम्स के उत्तर में एक छोटा संशोधन na.rmऔरreturn_multiple ।

names()इस पर निर्भर उत्तर के विपरीत , यह उत्तर xदिए गए मान में डेटा प्रकार को बनाए रखता है ।

stat_mode <- function(x, return_multiple = TRUE, na.rm = FALSE) {
  if(na.rm){
    x <- na.omit(x)
  }
  ux <- unique(x)
  freq <- tabulate(match(x, ux))
  mode_loc <- if(return_multiple) which(freq==max(freq)) else which.max(freq)
  return(ux[mode_loc])
}

यह दिखाने के लिए कि यह वैकल्पिक परम के साथ काम करता है और डेटा प्रकार बनाए रखता है:

foo <- c(2L, 2L, 3L, 4L, 4L, 5L, NA, NA)
bar <- c('mouse','mouse','dog','cat','cat','bird',NA,NA)

str(stat_mode(foo)) # int [1:3] 2 4 NA
str(stat_mode(bar)) # chr [1:3] "mouse" "cat" NA
str(stat_mode(bar, na.rm=T)) # chr [1:2] "mouse" "cat"
str(stat_mode(bar, return_mult=F, na.rm=T)) # chr "mouse"

@ सरलीकरण के लिए धन्यवाद @ धन्यवाद।

Answer 10

मैंने मोड उत्पन्न करने के लिए निम्न कोड लिखा है।

MODE <- function(dataframe){
    DF <- as.data.frame(dataframe)

    MODE2 <- function(x){      
        if (is.numeric(x) == FALSE){
            df <- as.data.frame(table(x))  
            df <- df[order(df$Freq), ]         
            m <- max(df$Freq)        
            MODE1 <- as.vector(as.character(subset(df, Freq == m)[, 1]))

            if (sum(df$Freq)/length(df$Freq)==1){
                warning("No Mode: Frequency of all values is 1", call. = FALSE)
            }else{
                return(MODE1)
            }

        }else{ 
            df <- as.data.frame(table(x))  
            df <- df[order(df$Freq), ]         
            m <- max(df$Freq)        
            MODE1 <- as.vector(as.numeric(as.character(subset(df, Freq == m)[, 1])))

            if (sum(df$Freq)/length(df$Freq)==1){
                warning("No Mode: Frequency of all values is 1", call. = FALSE)
            }else{
                return(MODE1)
            }
        }
    }

    return(as.vector(lapply(DF, MODE2)))
}

चलो यह कोशिश करते हैं:

MODE(mtcars)
MODE(CO2)
MODE(ToothGrowth)
MODE(InsectSprays)

Answer 11

मोड या संबंधित मैट्रिक्स की गणना करने के लिए @ क्रिस के कार्य के आधार पर, हालांकि आवृत्तियों की गणना करने के लिए केन विलियम्स की विधि का उपयोग करना। यह एक बिना किसी मोड के मामले के लिए एक फिक्स प्रदान करता है (सभी तत्व समान रूप से लगातार), और कुछ और पठनीय methodनाम।

Mode <- function(x, method = "one", na.rm = FALSE) {
  x <- unlist(x)
  if (na.rm) {
    x <- x[!is.na(x)]
  }

  # Get unique values
  ux <- unique(x)
  n <- length(ux)

  # Get frequencies of all unique values
  frequencies <- tabulate(match(x, ux))
  modes <- frequencies == max(frequencies)

  # Determine number of modes
  nmodes <- sum(modes)
  nmodes <- ifelse(nmodes==n, 0L, nmodes)

  if (method %in% c("one", "mode", "") | is.na(method)) {
    # Return NA if not exactly one mode, else return the mode
    if (nmodes != 1) {
      return(NA)
    } else {
      return(ux[which(modes)])
    }
  } else if (method %in% c("n", "nmodes")) {
    # Return the number of modes
    return(nmodes)
  } else if (method %in% c("all", "modes")) {
    # Return NA if no modes exist, else return all modes
    if (nmodes > 0) {
      return(ux[which(modes)])
    } else {
      return(NA)
    }
  }
  warning("Warning: method not recognised.  Valid methods are 'one'/'mode' [default], 'n'/'nmodes' and 'all'/'modes'")
}

चूँकि यह आवृत्तियों की गणना करने के लिए केन की विधि का उपयोग करता है, इसलिए प्रदर्शन को भी अनुकूलित किया गया है, मैंने पिछले जवाबों में से कुछ का उपयोग करते हुए बताया कि मेरा कार्य केन के प्रदर्शन के करीब है, विभिन्न ouput के लिए सशर्त कारण केवल मामूली ओवरहेड के कारण:

Comments

आपके द्वारा प्रस्तुत कोड पैकेज Modeमें पाए जाने वाले फ़ंक्शन की अधिक या कम सीधी प्रतिलिपि प्रतीत होता है pracma। समझाने की परवाह?

— 19el में AkselA

वास्तव में? जाहिरा तौर पर मैं यह सोचने वाला एकमात्र व्यक्ति नहीं हूँ कि यह मोड की गणना करने का एक अच्छा तरीका है, लेकिन मैं ईमानदारी से यह नहीं जानता था कि (अभी से पहले उस पैकेज को कभी नहीं जानता था)। मैंने क्रिस के कार्य को साफ किया और केन के संस्करण का लाभ उठाकर उस पर सुधार किया, और अगर यह किसी और के कोड जैसा दिखता है जो पूरी तरह से संयोग है।

— हगोवडबर्ग

मैंने अभी इसमें देखा, लेकिन pracmaआप पैकेज के किस संस्करण का उल्लेख करते हैं? संस्करण 1.9.3 में एक पूरी तरह से अलग कार्यान्वयन है जहां तक ​​मैं देख सकता हूं।

— हुगोव्डबर्ग

समारोह में अच्छा संशोधन। कुछ और पढ़ने के बाद, मैं इस निष्कर्ष पर पहुंचा हूं कि इस बात पर कोई सहमति नहीं है कि क्या समान या एकरूपता के वितरण में नोड्स हैं, कुछ सूत्रों का कहना है कि मोड की सूची स्वयं वितरण हैं, अन्य हैं कि कोई नोड नहीं है। एकमात्र समझौता यह है कि इस तरह के वितरण के लिए मोड की एक सूची तैयार करना न तो बहुत जानकारीपूर्ण है और न ही विशेष रूप से सार्थक है। यदि आप उपरोक्त कार्य की इच्छा रखते हैं, तो ऐसे मामलों का निर्माण करें, फिर लाइन हटाएं: nmodes <- ifelse (nmodes == n, 0L, nmodes)

— क्रिस

@greendiod क्षमा करें, मैं आपकी टिप्पणी से चूक गया। यह इस gist के माध्यम से उपलब्ध है: gist.github.com/Hugovdberg/0f00444d46efd99ed27bbe227bdc4d37

— hugovdberg

Answer 12

यह हैक ठीक काम करना चाहिए। आपको मान के साथ-साथ मोड की गणना भी देता है:

Mode <- function(x){
a = table(x) # x is a vector
return(a[which.max(a)])
}

Answer 13

R के पास कई ऐड-ऑन पैकेज हैं जिनमें से कुछ एक संख्यात्मक सूची / श्रृंखला / वेक्टर के [सांख्यिकीय] मोड को अच्छी तरह से प्रदान कर सकते हैं।

हालाँकि R का मानक पुस्तकालय अपने आप में ऐसी बिल्ट-इन विधि नहीं है! इसके चारों ओर काम करने का एक तरीका कुछ निर्माणों का उपयोग करना है जैसे कि निम्नलिखित (और यदि आप अक्सर उपयोग करते हैं तो इसे फ़ंक्शन में बदलना है ...):

mySamples <- c(19, 4, 5, 7, 29, 19, 29, 13, 25, 19)
tabSmpl<-tabulate(mySamples)
SmplMode<-which(tabSmpl== max(tabSmpl))
if(sum(tabSmpl == max(tabSmpl))>1) SmplMode<-NA
> SmplMode
[1] 19

बड़ी नमूना सूची के लिए, किसी को अधिकतम (tabSmpl) मान के लिए एक अस्थायी चर का उपयोग करने पर विचार करना चाहिए (मुझे नहीं पता है कि R अपने आप को अनुकूलित करेगा)

संदर्भ: देखें "माध्यिका और विधा के बारे में कैसे?" इस किकस्टार्टिंग आर पाठ में
यह पुष्टि करता है कि (कम से कम इस पाठ के लेखन के रूप में) आर में एक मोड फ़ंक्शन नहीं है (अच्छी तरह से ... मोड) जैसा कि आपको पता चला है कि इसका उपयोग चर के प्रकार को दर्शाने के लिए किया जाता है। )।

Answer 14

यह बहुत अच्छा काम करता है

> a<-c(1,1,2,2,3,3,4,4,5)
> names(table(a))[table(a)==max(table(a))]

Answer 15

यहाँ मोड खोजने के लिए एक समारोह है:

mode <- function(x) {
  unique_val <- unique(x)
  counts <- vector()
  for (i in 1:length(unique_val)) {
    counts[i] <- length(which(x==unique_val[i]))
  }
  position <- c(which(counts==max(counts)))
  if (mean(counts)==max(counts)) 
    mode_x <- 'Mode does not exist'
  else 
    mode_x <- unique_val[position]
  return(mode_x)
}

Answer 16

नीचे वह कोड है जिसका उपयोग आर में एक वेक्टर चर के मोड को खोजने के लिए किया जा सकता है।

a <- table([vector])

names(a[a==max(a)])

Answer 17

इसके लिए कई समाधान दिए गए हैं। मैंने पहले चेक किया और उसके बाद अपना लिखा। यहाँ पोस्टिंग अगर यह किसी को भी मदद करता है:

Mode <- function(x){
  y <- data.frame(table(x))
  y[y$Freq == max(y$Freq),1]
}

कुछ उदाहरणों के साथ इसकी जांच करते हैं। मैं irisडेटा सेट ले रहा हूं । संख्यात्मक डेटा के साथ परीक्षा देता है

> Mode(iris$Sepal.Length)
[1] 5

जिसे आप सत्यापित कर सकते हैं कि सही है।

अब iris डाटासेट (प्रजाति) में केवल गैर संख्यात्मक क्षेत्र में एक मोड नहीं है। आइए अपने स्वयं के उदाहरण के साथ परीक्षण करें

> test <- c("red","red","green","blue","red")
> Mode(test)
[1] red

संपादित करें

जैसा कि टिप्पणियों में बताया गया है, उपयोगकर्ता इनपुट प्रकार को संरक्षित करना चाह सकता है। जिस स्थिति में मोड फ़ंक्शन को संशोधित किया जा सकता है:

Mode <- function(x){
  y <- data.frame(table(x))
  z <- y[y$Freq == max(y$Freq),1]
  as(as.character(z),class(x))
}

फ़ंक्शन की अंतिम पंक्ति बस मूल मोड के प्रकार के लिए अंतिम मोड मान को जोड़ती है।

Comments

यह एक कारक है, जबकि उपयोगकर्ता संभवतः इनपुट के प्रकार को संरक्षित करना चाहता है। शायद एक मध्य कदम जोड़ेंy[,1] <- sort(unique(x))

— फ्रैंक

Answer 18

मैं (संभवतः निरंतर) वितरण के एक स्मूथेड अधिकतम की पहचान करने के लिए घनत्व () फ़ंक्शन का उपयोग करेगा:

function(x) density(x, 2)$x[density(x, 2)$y == max(density(x, 2)$y)]

जहाँ x डेटा संग्रह है। घनत्व फ़ंक्शन के समायोजन paremeter पर ध्यान दें जो चौरसाई को नियंत्रित करता है।

Answer 19

जबकि मुझे केन विलियम्स का सरल कार्य पसंद है, मैं मौजूद कई मोड को फिर से प्राप्त करना चाहूंगा। इसे ध्यान में रखते हुए, मैं निम्नलिखित फ़ंक्शन का उपयोग करता हूं जो कई या एकल होने पर मोड की एक सूची देता है।

rmode <- function(x) {
  x <- sort(x)  
  u <- unique(x)
  y <- lapply(u, function(y) length(x[x==y]))
  u[which( unlist(y) == max(unlist(y)) )]
} 

Comments

यह प्रोग्रामिक उपयोग के लिए अधिक सुसंगत होगा यदि यह हमेशा एक सूची

— लौटाता

यह एक मान्य बिंदु @ एंटोनी-सैक है। इस समाधान के बारे में मुझे जो पसंद है, वह वेक्टर है जिसे लौटाया गया जवाब आसानी से पता योग्य छोड़ देता है। बस समारोह के आउटपुट को संबोधित करें: r <- मोड (c (2, 2, 3, 3)) r [1] और r [2] पर उपलब्ध मोड के साथ। फिर भी, आप एक अच्छी बात करते हैं !!

— RandallShanePhD

ठीक है, यह वह जगह है जहाँ आपका समाधान कम हो जाता है। यदि modeकई मानों के साथ कोई सूची देता है, तो r [1] पहला मूल्य नहीं है; यह इसके बजाय पहले मान वाले लंबाई 1 की सूची है और आपको संख्यात्मक के रूप में पहला मोड प्राप्त करने के लिए r [[1]] करना होगा और सूची नहीं। अब जब कोई एकल मोड है, तो आपका r एक सूची नहीं है r [1] काम करता है, यही वजह है कि मुझे लगा कि यह असंगत है। लेकिन जब से r [[1]] भी काम करता है जब r एक साधारण वेक्टर होता है, तो वास्तव में एक स्थिरता है जिसका मुझे एहसास नहीं था कि आप हमेशा [[तत्वों का उपयोग कर सकते हैं।

— जलकुंभी

Answer 20

मैं इन सभी विकल्पों को देख रहा था और उनकी सापेक्ष विशेषताओं और प्रदर्शन के बारे में आश्चर्य करने लगा, इसलिए मैंने कुछ परीक्षण किए। यदि किसी और के बारे में उत्सुक हैं, तो मैं यहां अपना परिणाम साझा कर रहा हूं।

यहां पोस्ट किए गए सभी कार्यों के बारे में परेशान नहीं करना चाहते हैं, मैंने कुछ मानदंडों के आधार पर एक नमूने पर ध्यान केंद्रित करने का विकल्प चुना: फ़ंक्शन को चरित्र, कारक, तार्किक और संख्यात्मक वैक्टर दोनों पर काम करना चाहिए, इसे NA और अन्य समस्याग्रस्त मूल्यों के साथ उचित रूप से निपटना चाहिए, और आउटपुट 'समझदार' होना चाहिए, यानी चरित्र या अन्य ऐसी नीरसता के रूप में कोई अंक नहीं।

मैंने अपना स्वयं का एक फ़ंक्शन भी जोड़ा, जो कि rleअधिक सामान्य उपयोग के लिए अनुकूलित को छोड़कर क्रिस्पी के समान विचार पर आधारित है :

library(magrittr)

Aksel <- function(x, freq=FALSE) {
    z <- 2
    if (freq) z <- 1:2
    run <- x %>% as.vector %>% sort %>% rle %>% unclass %>% data.frame
    colnames(run) <- c("freq", "value")
    run[which(run$freq==max(run$freq)), z] %>% as.vector   
}

set.seed(2)

F <- sample(c("yes", "no", "maybe", NA), 10, replace=TRUE) %>% factor
Aksel(F)

# [1] maybe yes  

C <- sample(c("Steve", "Jane", "Jonas", "Petra"), 20, replace=TRUE)
Aksel(C, freq=TRUE)

# freq value
#    7 Steve

मैंने परीक्षण डेटा के दो सेटों पर, के माध्यम से पांच कार्यों को चलाने का अंत किया microbenchmark। समारोह के नाम उनके संबंधित लेखकों को संदर्भित करते हैं:

क्रिस के समारोह के लिए method="modes"और सेट किया गया थाna.rm=TRUE डिफ़ॉल्ट रूप से इसे और अधिक तुलनीय है, लेकिन अन्य की तुलना में है कि कार्यों के रूप में उनके लेखकों द्वारा यहां प्रस्तुत इस्तेमाल किया गया बनाने के लिए।

अकेले गति के मामले में केन्स संस्करण हाथ से जीतता है, लेकिन यह इनमें से केवल एक ही है जो केवल एक मोड की रिपोर्ट करेगा, कोई फर्क नहीं पड़ता कि वास्तव में कितने हैं। जैसा कि अक्सर होता है, गति और चंचलता के बीच व्यापार बंद हो जाता है। में method="mode", क्रिस का संस्करण एक मान लौटाएगा अगर वहाँ एक मोड है, और एनए। मुझे लगता है कि यह एक अच्छा स्पर्श है। मुझे यह भी लगता है कि यह दिलचस्प है कि कुछ फ़ंक्शंस अद्वितीय मूल्यों की बढ़ी हुई संख्या से कैसे प्रभावित होते हैं, जबकि अन्य लगभग नहीं हैं। मैंने कारण के रूप में तार्किक / संख्यात्मक को समाप्त करने के अलावा, यह पता लगाने के लिए कोड का विस्तार से अध्ययन नहीं किया है।

Answer 21

मोड हर स्थिति में उपयोगी नहीं हो सकता। तो फ़ंक्शन को इस स्थिति को संबोधित करना चाहिए। निम्न फ़ंक्शन का प्रयास करें।

Mode <- function(v) {
  # checking unique numbers in the input
  uniqv <- unique(v)
  # frquency of most occured value in the input data
  m1 <- max(tabulate(match(v, uniqv)))
  n <- length(tabulate(match(v, uniqv)))
  # if all elements are same
  same_val_check <- all(diff(v) == 0)
  if(same_val_check == F){
    # frquency of second most occured value in the input data
    m2 <- sort(tabulate(match(v, uniqv)),partial=n-1)[n-1]
    if (m1 != m2) {
      # Returning the most repeated value
      mode <- uniqv[which.max(tabulate(match(v, uniqv)))]
    } else{
      mode <- "Two or more values have same frequency. So mode can't be calculated."
    }
  } else {
    # if all elements are same
    mode <- unique(v)
  }
  return(mode)
}

आउटपुट,

x1 <- c(1,2,3,3,3,4,5)
Mode(x1)
# [1] 3

x2 <- c(1,2,3,4,5)
Mode(x2)
# [1] "Two or more varibles have same frequency. So mode can't be calculated."

x3 <- c(1,1,2,3,3,4,5)
Mode(x3)
# [1] "Two or more values have same frequency. So mode can't be calculated."

Comments

क्षमा करें, मैं अभी यह नहीं देखता कि यह कैसे पहले से पोस्ट की गई नई चीज़ों को जोड़ता है। इसके अलावा, आपका आउटपुट आपके फ़ंक्शन के ऊपर असंगत लगता है।

— not2qubit

Answer 22

यह बहुत कम वैक्टर के लिए एक गति को जोड़कर, जर्कबेली के जवाब पर बनाता है। यह उपयोगी है जब कई छोटे समूहों के साथ डेटा.फ्रेम या डेटाटेबल पर मोड लागू किया जाता है:

Mode <- function(x) {
   if ( length(x) <= 2 ) return(x[1])
   if ( anyNA(x) ) x = x[!is.na(x)]
   ux <- unique(x)
   ux[which.max(tabulate(match(x, ux)))]
}

Answer 23

एक और सरल विकल्प जो आवृत्ति द्वारा आदेशित सभी मूल्यों का उपयोग करता है rle:

df = as.data.frame(unclass(rle(sort(mySamples))))
df = df[order(-df$lengths),]
head(df)

Answer 24

एक अन्य संभावित समाधान:

Mode <- function(x) {
    if (is.numeric(x)) {
        x_table <- table(x)
        return(as.numeric(names(x_table)[which.max(x_table)]))
    }
}

उपयोग:

set.seed(100)
v <- sample(x = 1:100, size = 1000000, replace = TRUE)
system.time(Mode(v))

आउटपुट:

   user  system elapsed 
   0.32    0.00    0.31 

Answer 25

मुझे लगता है कि आपकी टिप्पणियां वास्तविक संख्याओं से वर्ग हैं और आप उम्मीद करते हैं कि मोड 2.5 हो जब आपकी टिप्पणियां 2, 2, 3 और 3 हों, तब आप उस मोड का अनुमान लगा सकते हैं जहां l1 .. सबसे लगातार वर्ग की सीमित सीमा, f1 है । सबसे अक्सर वर्ग की ffquency , f0 .. सबसे लगातार वर्ग से पहले कक्षाओं की संख्या, f2 .. सबसे अधिक बार वर्ग के बाद वर्गों की योग्यता और मैं .. 1 , 2 , 3 में दिए गए अनुसार अंतराल अंतराल :mode = l1 + i * (f1-f0) / (2f1 - f0 - f2)

#Small Example
x <- c(2,2,3,3) #Observations
i <- 1          #Class interval

z <- hist(x, breaks = seq(min(x)-1.5*i, max(x)+1.5*i, i), plot=F) #Calculate frequency of classes
mf <- which.max(z$counts)   #index of most frequent class
zc <- z$counts
z$breaks[mf] + i * (zc[mf] - zc[mf-1]) / (2*zc[mf] - zc[mf-1] - zc[mf+1])  #gives you the mode of 2.5


#Larger Example
set.seed(0)
i <- 5          #Class interval
x <- round(rnorm(100,mean=100,sd=10)/i)*i #Observations

z <- hist(x, breaks = seq(min(x)-1.5*i, max(x)+1.5*i, i), plot=F)
mf <- which.max(z$counts)
zc <- z$counts
z$breaks[mf] + i * (zc[mf] - zc[mf-1]) / (2*zc[mf] - zc[mf-1] - zc[mf+1])  #gives you the mode of 99.5

मामले में आप सबसे लगातार स्तर चाहते हैं और आपके पास है एक से अधिक लगातार स्तर हैं तो आप उन सभी को प्राप्त कर सकते हैं जैसे कि:

x <- c(2,2,3,5,5)
names(which(max(table(x))==table(x)))
#"2" "5"

Answer 26

एक संभावित data.table दृष्टिकोण जोड़ना

library(data.table)
#for single mode
dtmode <- function(x) x[which.max(data.table::rowid(x))]

#for multiple modes
dtmodes <- function(x) x[{r <- rowid(x); r==max(r)}]

Answer 27

यहाँ कई तरीके हैं जो आप इसे थेटा (N) रनिंग टाइम में कर सकते हैं

from collections import defaultdict

def mode1(L):
    counts = defaultdict(int)
    for v in L:
        counts[v] += 1
    return max(counts,key=lambda x:counts[x])

def mode2(L):
    vals = set(L)
    return max(vals,key=lambda x: L.count(x))

def mode3(L):
    return max(set(L), key=lambda x: L.count(x))

Answer 28

निम्नलिखित समारोह की कोशिश कर सकते हैं:

1. कारक में संख्यात्मक मान को बदलना
2. आवृत्ति तालिका हासिल करने के लिए सारांश () का उपयोग करें
3. रिटर्न मोड इंडेक्स जिसकी आवृत्ति सबसे बड़ी है
4. परिवर्तन कारक को वापस संख्यात्मक में बदलना यहां तक ​​कि 1 से अधिक मोड हैं, यह फ़ंक्शन अच्छी तरह से काम करता है!

mode <- function(x){
  y <- as.factor(x)
  freq <- summary(y)
  mode <- names(freq)[freq[names(freq)] == max(freq)]
  as.numeric(mode)
}

Answer 29

गणना मोड ज्यादातर कारक चर के मामले में है तो हम उपयोग कर सकते हैं

labels(table(HouseVotes84$V1)[as.numeric(labels(max(table(HouseVotes84$V1))))])

HouseVotes84 'mlbench' पैकेज में उपलब्ध डेटासेट है।

यह अधिकतम लेबल मान देगा। फ़ंक्शन लिखने के बिना इनबिल्ट फ़ंक्शंस द्वारा उपयोग करना आसान है।

Answer 30

यह मुझे लगता है कि अगर किसी संग्रह में एक मोड है, तो उसके तत्वों को प्राकृतिक संख्याओं के साथ एक-से-एक मैप किया जा सकता है। तो, मोड खोजने की समस्या कम हो जाती है जैसे कि मैपिंग का उत्पादन, मैप किए गए मानों का मोड ढूंढना, फिर संग्रह में कुछ वस्तुओं पर मैपिंग करना। ( NAमानचित्रण चरण में होता है)।

मेरे पास एक histogramफ़ंक्शन है जो एक समान प्रिंसिपल पर काम करता है। (यहां प्रस्तुत कोड में उपयोग किए गए विशेष कार्यों और संचालकों को शापिरो और / या नीटओवररसे में परिभाषित किया जाना चाहिए । शापिरो और नीटओवेर्स के डुप्लिकेट किए गए भागों को अनुमति के साथ दोहराया गया है; इस साइट की शर्तों के तहत डुप्लिकेट स्निपेट का उपयोग किया जा सकता है। ) R pseudocode के लिए histogramहै

.histogram <- function (i)
        if (i %|% is.empty) integer() else
        vapply2(i %|% max %|% seqN, `==` %<=% i %O% sum)

histogram <- function(i) i %|% rmna %|% .histogram

(विशेष द्विआधारी ऑपरेटरों को पूरा पाइपिंग , currying , और रचना ) मैं भी एक है maxlocसमारोह है, जो करने के लिए इसी तरह की है which.max, लेकिन रिटर्न सब एक सदिश का पूर्ण मॅक्सिमा। आर स्यूडोकोड के लिए maxlocहै

FUNloc <- function (FUN, x, na.rm=F)
        which(x == list(identity, rmna)[[na.rm %|% index.b]](x) %|% FUN)

maxloc <- FUNloc %<=% max

minloc <- FUNloc %<=% min # I'M THROWING IN minloc TO EXPLAIN WHY I MADE FUNloc

फिर

imode <- histogram %O% maxloc

तथा

x %|% map %|% imode %|% unmap

किसी भी संग्रह के मोड की गणना करेगा, बशर्ते कि उपयुक्त map-और unmap-कार्य को परिभाषित किया गया हो।