In R, mean()e median()sono funzioni standard che fanno ciò che ti aspetteresti. mode()indica la modalità di archiviazione interna dell'oggetto, non il valore più frequente nel suo argomento. Ma esiste una funzione di libreria standard che implementa la modalità statistica per un vettore (o elenco)?

Un'altra soluzione, che funziona sia con dati numerici sia con dati carattere / fattore:

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

Sulla mia piccola macchina viziosa, che può generare e trovare la modalità di un vettore intero 10M in circa mezzo secondo.

Se il tuo set di dati potrebbe avere più modalità, la soluzione precedente utilizza lo stesso approccio which.maxe restituisce il valore che appare per primo della serie di modalità. Per restituire tutte le modalità, utilizzare questa variante (da @digEmAll nei commenti):

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

Esiste un pacchetto modeestche fornisce stimatori della modalità di dati univodati unimodali (e talvolta multimodali) e valori delle modalità delle consuete distribuzioni di probabilità.

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")

Per maggiori informazioni vedi questa pagina

trovato questo sulla mailing list r, spero che sia utile. È anche quello che stavo pensando comunque. Ti consigliamo di tabella () i dati, ordinare e quindi scegliere il nome. È hacker ma dovrebbe funzionare.

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

Ho trovato il post di Ken Williams qui sopra eccezionale, ho aggiunto alcune righe per tenere conto dei valori di NA e l'ho reso una funzione per facilità.

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)))])
}

Un modo rapido e sporco di stimare la modalità di un vettore di numeri che ritieni provenga da una continua distribuzione univariata (ad esempio una distribuzione normale) sta definendo e usando la seguente funzione:

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

Quindi per ottenere la stima della modalità:

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

La seguente funzione è disponibile in tre forme:

method = "mode" [default]: calcola la modalità per un vettore unimodale, altrimenti restituisce un NA
method = "nmodes": calcola il numero di modalità nel vettore
method = "modes": elenca tutte le modalità per un unimodale o polimodale vettore

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()
}

Ecco un'altra soluzione:

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

Non posso ancora votare, ma la risposta di Rasmus Bååth è ciò che stavo cercando. Tuttavia, lo modificherei un po 'permettendo di contravvenire alla distribuzione, ad esempio per valori solo tra 0 e 1.

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

Siamo consapevoli del fatto che potresti non voler limitare la tua distribuzione, quindi impostare da = - "BIG NUMBER", a = "BIG NUMBER"

Una piccola modifica alla risposta di Ken Williams, aggiungendo parametri opzionali na.rme return_multiple.

A differenza delle risposte invocate names(), questa risposta mantiene il tipo di dati xnei valori restituiti.

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])
}

Per dimostrarlo funziona con i parametri opzionali e mantiene il tipo di dati:

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"

Grazie a @Frank per la semplificazione.

Ho scritto il seguente codice per generare la modalità.

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)))
}

Proviamolo:

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

Basato sulla funzione di @ Chris per calcolare la modalità o le relative metriche, tuttavia utilizzando il metodo di Ken Williams per calcolare le frequenze. Questo fornisce una correzione per il caso di nessuna modalità (tutti gli elementi ugualmente frequenti) e alcuni methodnomi più leggibili .

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'")
}

Poiché utilizza il metodo di Ken per calcolare le frequenze, anche le prestazioni sono ottimizzate, utilizzando il post di AkselA ho confrontato alcune delle risposte precedenti per mostrare come la mia funzione è vicina a quella di Ken, con i condizionali per le varie opzioni di uscita che causano solo lievi spese generali:

Questo hack dovrebbe funzionare bene. Ti dà il valore e il conteggio della modalità:

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

R ha così tanti pacchetti aggiuntivi che alcuni di essi potrebbero fornire la modalità [statistica] di un elenco numerico / serie / vettore.

Tuttavia, la libreria standard di R in sé non sembra avere un metodo così integrato! Un modo per aggirare questo è usare un costrutto come il seguente (e trasformarlo in una funzione se usi spesso ...):

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

Per un elenco di campioni più grande, si dovrebbe considerare l'utilizzo di una variabile temporanea per il valore max (tabSmpl) (non so che R lo ottimizzerebbe automaticamente)

Riferimento: vedi "Che ne dici di mediana e modalità?" in questa lezione di KickStarting R
Questo sembra confermare che (almeno dalla stesura di questa lezione) non c'è una funzione mode in R (beh ... mode () come hai scoperto è usata per affermare il tipo di variabili ).

Funziona abbastanza bene

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

Ecco una funzione per trovare la modalità:

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)
}

Di seguito è riportato il codice che può essere utilizzato per trovare la modalità di una variabile vettoriale in R.

a <- table([vector])

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

Sono disponibili più soluzioni per questo. Ho controllato il primo e dopo ho scritto il mio. Pubblicandolo qui se aiuta qualcuno:

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

Proviamo con alcuni esempi. Sto prendendo il irisset di dati. Consente di testare con dati numerici

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

che puoi verificare sia corretto.

Ora l'unico campo non numerico nel set di dati dell'iride (specie) non ha una modalità. Proviamo con il nostro esempio

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

MODIFICARE

Come menzionato nei commenti, l'utente potrebbe voler preservare il tipo di input. Nel qual caso la funzione mode può essere modificata in:

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

L'ultima riga della funzione costringe semplicemente il valore della modalità finale al tipo di input originale.

Vorrei usare la funzione densità () per identificare un massimo livellato di una distribuzione (possibilmente continua):

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

dove x è la raccolta dei dati. Prestare attenzione al paremetro di regolazione della funzione di densità che regola il livellamento.

Mentre mi piace la semplice funzione di Ken Williams, vorrei recuperare le diverse modalità se esistono. Tenendo presente ciò, utilizzo la seguente funzione che restituisce un elenco delle modalità, se multiple o singole.

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)) )]
} 

Stavo esaminando tutte queste opzioni e ho iniziato a chiedermi quali fossero le loro caratteristiche e prestazioni, quindi ho fatto alcuni test. Nel caso in cui qualcun altro fosse curioso della stessa cosa, sto condividendo i miei risultati qui.

Non volendo preoccuparmi di tutte le funzioni pubblicate qui, ho scelto di concentrarmi su un campione basato su alcuni criteri: la funzione dovrebbe funzionare su caratteri, fattori, vettori logici e numerici, dovrebbe occuparsi in modo appropriato di NA e altri valori problematici, e l'output dovrebbe essere "sensato", cioè nessun valore numerico come carattere o altra stupidità simile.

Ho anche aggiunto una mia funzione, che si basa sulla stessa rleidea di Chrispy, tranne adattata per un uso più generale:

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

Ho finito per eseguire cinque funzioni, su due set di dati di test, attraverso microbenchmark. I nomi delle funzioni si riferiscono ai rispettivi autori:

La funzione di Chris è stata impostata su method="modes"e na.rm=TRUEper impostazione predefinita per renderla più comparabile, ma a parte questo sono state utilizzate le funzioni presentate qui dai loro autori.

Per quanto riguarda la velocità, solo la versione di Kens vince facilmente, ma è anche l'unica di queste che segnalerà solo una modalità, non importa quante ce ne siano davvero. Come spesso accade, c'è un compromesso tra velocità e versatilità. In method="mode", la versione di Chris restituirà un valore se esiste una modalità, altrimenti NA. Penso che sia un bel tocco. Penso anche che sia interessante come alcune funzioni siano influenzate da un numero crescente di valori univoci, mentre altre non sono altrettanto. Non ho studiato il codice in dettaglio per capire perché, oltre a eliminare logico / numerico come causa.

La modalità non può essere utile in tutte le situazioni. Quindi la funzione dovrebbe affrontare questa situazione. Prova la seguente funzione.

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)
}

Produzione,

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."

Questo si basa sulla risposta di jprockbelly, aggiungendo una velocità per vettori molto brevi. Ciò è utile quando si applica la modalità a un data.frame o un datatable con molti piccoli gruppi:

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)))]
}

Un'altra semplice opzione che fornisce tutti i valori ordinati per frequenza è usare rle:

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

Un'altra possibile soluzione:

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

Uso:

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

Produzione:

   user  system elapsed 
   0.32    0.00    0.31 

Suppongo che le tue osservazioni siano classi da numeri reali e ti aspetti che la modalità sia 2.5 quando le tue osservazioni sono 2, 2, 3 e 3, quindi potresti stimare la modalità con mode = l1 + i * (f1-f0) / (2f1 - f0 - f2)cui l1 .. limite inferiore della classe più frequente, f1 . .frequency di classe più frequente, f0 ..frequency delle classi prima classe più frequente, f2 ..frequency delle classi dopo classe più frequente ed i ..Class intervallo come indicato ad esempio in 1 , 2 , 3 :

#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

Se desideri il livello più frequente e hai più di un livello più frequente, puoi ottenerli tutti ad es. Con:

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

Aggiunta di un possibile approccio 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)}]

Ecco alcuni modi in cui puoi farlo nel tempo di esecuzione di Theta (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))

Potrebbe provare la seguente funzione:

1. trasforma valori numerici in fattore
2. usa il sommario () per ottenere la tabella delle frequenze
3. modalità di ritorno l'indice la cui frequenza è la più grande
4. Trasforma il fattore in numerico anche se ci sono più di 1 modalità, questa funzione funziona bene!

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

La modalità di calcolo è principalmente in caso di variabile fattore, quindi possiamo usare

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

HouseVotes84 è un set di dati disponibile nel pacchetto 'mlbench'.

darà il valore massimo dell'etichetta. è più facile da usare dalle funzioni integrate senza scrivere la funzione.

Mi sembra che se una collezione ha una modalità, i suoi elementi possono essere mappati uno a uno con i numeri naturali. Pertanto, il problema di trovare la modalità si riduce alla produzione di tale mappatura, alla ricerca della modalità dei valori mappati, quindi alla mappatura su alcuni degli elementi della raccolta. (Trattare conNA verifica in fase di mappatura).

Ho una histogramfunzione che opera su un principio simile. (Le funzioni e gli operatori speciali utilizzati nel codice qui presentato devono essere definiti in Shapiro e / o neatOveRse . Le parti di Shapiro e neatOveRse duplicate nel presente documento sono così duplicate con l'autorizzazione; i frammenti duplicati possono essere utilizzati in base ai termini di questo sito. ) R pseudocodice per histogramis

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

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

(Gli speciali operatori binari eseguono piping , curry e composizione ) Ho anche una maxlocfunzione, che è simile a which.max, ma restituisce tutti i massimi assoluti di un vettore. R pseudocodice per maxlocis

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

Poi

imode <- histogram %O% maxloc

e

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

calcolerà la modalità di qualsiasi raccolta, a condizione che siano definite le funzioni map-ping e unmap-ping appropriate .