Rではmean()、median()期待どおりの動作をする標準関数です。 mode()オブジェクトの内部ストレージモードであり、引数で最も多く発生する値ではありません。しかし、ベクトル（またはリスト）の統計モードを実装する標準ライブラリ関数はありますか？

数値と文字/因子データの両方で機能するもう1つのソリューション：

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

私のちっぽけな小さなマシンでは、それは10M整数ベクトルのモードを約0.5秒で生成して見つけることができます。

データセットに複数のモードがある場合、上記のソリューションはと同じアプローチを取り、モードセットの最初に現れる値をwhich.max返します。すべてのモードを返すには、次のバリアントを使用します（コメントの@digEmAllから）：

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

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

詳細については、このページを参照してください

これはrメーリングリストで見つかりました。役立つことを願っています。それはとにかく私が考えていたものでもあります。データをtable（）で並べ替え、最初の名前を選択します。ハックですが、うまくいくはずです。

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

上記のケンウィリアムズの投稿はすばらしいと思いました。NAの値を説明するために数行追加し、簡単に使えるようにしました。

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

連続する一変量分布（たとえば、正規分布）から得られると考えられる数値のベクトルのモードをすばやく簡単に推定するには、次の関数を定義して使用します。

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

次の関数には3つの形式があります。

method = "mode" [default]：単峰ベクトルのモードを計算し、それ以外の場合はNAを返します
method = "nmodes"：ベクトルのモード数を計算します
method = "modes"：単峰または多峰のすべてのモードをリストしますベクター

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

ここでは、別の解決策：

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

まだ投票はできませんが、RasmusBååthの答えが私が探していたものです。ただし、少し変更して、たとえば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)]
}

ディストリビューションをまったく制限したくない場合があることを認識し、from =-"BIG NUMBER"、to = "BIG NUMBER"を設定します

ケンウィリアムズの回答に小さな変更を加え、オプションのパラメーター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"

簡略化してくれた@Frankに感謝します。

モードを生成するために次のコードを書きました。

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)

@Chrisのモードまたは関連するメトリックを計算する関数に基づいていますが、Ken Williamsの方法を使用して頻度を計算します。これは、モードがまったくない場合（すべての要素が同じ頻度である場合）の修正と、より読みやすい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'")
}

周波数の計算にケンの方法を使用しているため、パフォーマンスも最適化されています。アクセルAの投稿を使用して、以前の回答のいくつかをベンチマークし、関数がパフォーマンスでケンの方法にどのように近いかを示しました。

このハックはうまくいくはずです。値とモードの数を示します。

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

Rには非常に多くのアドオンパッケージがあり、それらの一部は数値リスト/シリーズ/ベクトルの[統計]モードを提供する可能性があります。

しかし、R自体の標準ライブラリには、そのような組み込みメソッドがないようです！これを回避する1つの方法は、次のような構造体を使用することです（頻繁に使用する場合は、これを関数に変換します...）。

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

より大きなサンプルリストの場合、max（tabSmpl）値に一時変数を使用することを検討する必要があります（Rがこれを自動的に最適化することはわかりません）

参照：「中央値とモードはどうですか？」を参照してください。これで KickStarting Rレッスンでは、
これは（少なくともこのレッスンの執筆時点では）Rにモード関数がないことを確認しているようです（そうですね ... mode（）は変数の型のアサートに使用されています。 ）。

これはかなりうまくいきます

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

モードを見つける関数は次のとおりです。

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

以下は、Rのベクトル変数のモードを見つけるために使用できるコードです。

a <- table([vector])

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

これには複数のソリューションが用意されています。私は最初のものをチェックし、その後自分で書いた。誰かに役立つ場合は、ここに投稿してください

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

いくつかの例を使ってテストしてみましょう。irisデータセットを取得しています。数値データでテストしましょう

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

あなたが確認できるものは正しいです。

現在、irisデータセット（Species）の唯一の非数値フィールドにはモードがありません。独自の例でテストしてみましょう

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

関数の最後の行は、最終的なモード値を元の入力の型に強制変換するだけです。

私は密度（）関数を使用して、（おそらく連続的な）分布の平滑化された最大値を識別します：

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

ここで、xはデータ収集です。平滑化を調整する密度関数の調整パラメーターに注意してください。

私はケンウィリアムズの単純な関数が好きですが、複数のモードが存在する場合はそれらを取得したいと思います。そのことを念頭に置いて、次の関数を使用して、複数の場合または単一の場合にモードのリストを返します。

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

私はこれらすべてのオプションを調べていて、それらの相対的な機能とパフォーマンスについて疑問に思い始めたので、いくつかのテストを行いました。他の誰かが同じことについて気になった場合のために、私はここで私の結果を共有しています。

ここに掲載されているすべての関数を気にしたくないので、いくつかの基準に基づいてサンプルに焦点を当てることを選択しました。関数は、文字、因子、論理ベクトル、数値ベクトルの両方で機能し、NAおよびその他の問題のある値を適切に処理する必要があります。そして、出力は「賢明」でなければなりません。すなわち、文字としての数値やその他のそのようなばかげたことはありません。

私はまたrle、chrispy と同じアイデアに基づいた、より一般的な用途に適応することを除いて、独自の関数を追加しました。

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

2つのテストデータセットで、から5つの関数を実行しましたmicrobenchmark。関数名はそれぞれの作者を参照します：

クリスの機能はmethod="modes"、na.rm=TRUEデフォルトでより比較可能になっていますが、それ以外の点では、作成者がここで示したように関数が使用されました。

速度だけの問題では、Kensバージョンは手軽に勝ちますが、実際にいくつあっても、1つのモードのみを報告するのはこれらの唯一のバージョンです。よくあることですが、速度と汎用性の間にはトレードオフがあります。ではmethod="mode"、Chrisのバージョンは、モードが1つの場合に限り値を返し、そうでない場合はNAを返します。いい感じだと思います。また、ユニークな値の数の増加によって一部の関数がどのように影響を受けるか、他の関数はほとんど影響を受けないことも興味深いと思います。原因として論理/数値を排除することを除いて、その理由を理解するためにコードを詳細に調査していません。

モードは、すべての状況で役立つとは限りません。したがって、関数はこの状況に対処する必要があります。次の関数を試してください。

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

これは、非常に短いベクトルの速度を上げることにより、jprockbellyの答えに基づいています。これは、多数の小さなグループを持つdata.frameまたはdatatableにモードを適用するときに役立ちます。

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

頻度順に並べられたすべての値を提供する別の簡単なオプションは、使用することrleです：

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

別の可能な解決策：

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 

私はあなたの観測がされた場合、クラスから実数とあなたがいることを期待するモードがあなたの観測は、あなたがしてモードを見積もることができ2、2、3、および3のとき2.5であることをL1最も頻繁クラスの..lower制限、F1。最も頻繁クラスの.frequency F0最も頻繁クラス前のクラスの..frequency、F2最も頻繁にクラスの後にクラスの..frequencyと私はで与えられた例として..Class区間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"

可能な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)}]

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

次の関数を試すことができます：

1. 数値を因子に変換する
2. summary（）を使用して頻度表を取得する
3. 戻りモード頻度が最大のインデックス
4. 複数のモードがある場合でも、変換係数を数値に戻すと、この関数はうまく機能します！

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

計算モードは主に因子変数の場合であり、次に使用できます

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

HouseVotes84は 'mlbench'パッケージで利用可能なデータセットです。

最大ラベル値を提供します。関数を記述せずに組み込み関数自体を使用する方が簡単です。

コレクションにモードがある場合、その要素は自然数と1対1でマッピングできるように思えます。したがって、モードを見つけるという問題は、そのようなマッピングを作成し、マップされた値のモードを見つけて、コレクション内の一部のアイテムにマッピングし直すことになります。（NAマッピングフェーズでの取引が発生します）。

histogram同様の原理で動作する関数があります。（ここに示されているコードで使用されている特別な関数と演算子は、Shapiroおよび/またはneatOveRseで定義する必要があります。ここに複製されているShapiroとneatOveRseの部分は、許可を得て複製されています。複製されたスニペットは、このサイトの条件に基づいて使用される場合があります。 ）Rの擬似コードのためのhistogramIS

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

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

（特別な2項演算子は、パイピング、カリー化、および合成を実行します）またmaxloc、と同様の関数which.maxがありますが、ベクトルのすべての絶対最大値を返します。Rの擬似コードのための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

その後

imode <- histogram %O% maxloc

そして

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

適切なmap-pingおよびunmap-ping関数が定義されていれば、コレクションのモードを計算します。