简介

但在现实中，这个简单的事实很容易被掩盖，因为实际用于模型拟合的数据可能与您传入的数据有很大不同。当您的数据中包含NA、您对数据进行了子集化、因子具有未使用的水平、或者你已经转换了你的变量并在某处得到了NaN。You are rarely in this ideal situation where a single-level factor can be spotted from str(your_data_frame) directly. StackOverflow上关于这个错误的许多问题是不可重现的，因此人们的建议可能会起作用，也可能不起作用。虽然现在已经有118 posts针对这个问题，但是用户还是找不到一个适应性的解决方案，以至于这个问题被一次又一次的提出，这个答案就是我的尝试，想一劳永逸的解决这个问题，或者至少提供一个合理的指导。
这个答案信息量很大，我先做一个快速总结。
我为您定义了3个辅助函数：一米三米一，一米四米一，一米五米一。
我建议你用下面的方法来使用它们。
1.运行NA_preproc以获得更完整的用例;
1.运行你的模型，如果你得到一个"对比错误"，使用debug_contr_error2进行调试。
大部分的答案都会一步一步地告诉你这些函数是如何定义的以及为什么定义的。跳过这些开发过程可能没有坏处，但是不要跳过"可复制的案例研究和讨论"中的章节。

修改答案

original answer在OP上运行得很好，并且已经成功地帮助了一些其他人。但是它在其他地方失败了，因为缺乏适应性。看看问题中str(ad.train)的输出。OP的变量是数字或因子;没有字符。最初的答案是针对这种情况的。如果你有字符变量，尽管它们在lm和glm拟合过程中会被强制为因子，但代码不会报告它们，因为它们没有作为因子提供，所以is.factor会错过它们。在本扩展中，我将使最初的答案更具适应性。
假设dat是传递给lm或glm的数据集，如果你没有这样一个数据框，也就是说，你所有的变量都分散在全局环境中，你需要将它们聚集到一个数据框中，下面的方法可能不是最好的，但它是有效的。

## `form` is your model formula, here is an example
y <- x1 <- x2 <- x3 <- 1:4
x4 <- matrix(1:8, 4)
form <- y ~ bs(x1) + poly(x2) + I(1 / x3) + x4

## to gather variables `model.frame.default(form)` is the easiest way 
## but it does too much: it drops `NA` and transforms variables
## we want something more primitive

## first get variable names
vn <- all.vars(form)
#[1] "y"  "x1" "x2" "x3" "x4"

## `get_all_vars(form)` gets you a data frame
## but it is buggy for matrix variables so don't use it
## instead, first use `mget` to gather variables into a list
lst <- mget(vn)

## don't do `data.frame(lst)`; it is buggy with matrix variables
## need to first protect matrix variables by `I()` then do `data.frame`
lst_protect <- lapply(lst, function (x) if (is.matrix(x)) I(x) else x)
dat <- data.frame(lst_protect)
str(dat)
#'data.frame':  4 obs. of  5 variables:
# $ y : int  1 2 3 4
# $ x1: int  1 2 3 4
# $ x2: int  1 2 3 4
# $ x3: int  1 2 3 4
# $ x4: 'AsIs' int [1:4, 1:2] 1 2 3 4 5 6 7 8

## note the 'AsIs' for matrix variable `x4`
## in comparison, try the following buggy ones yourself
str(get_all_vars(form))
str(data.frame(lst))

• • 步骤0：显式子集化**

如果你已经使用了lm或glm的subset参数，那么从一个显式的子集开始：

## `subset_vec` is what you pass to `lm` via `subset` argument
## it can either be a logical vector of length `nrow(dat)`
## or a shorter positive integer vector giving position index
## note however, `base::subset` expects logical vector for `subset` argument
## so a rigorous check is necessary here
if (mode(subset_vec) == "logical") {
  if (length(subset_vec) != nrow(dat)) {
    stop("'logical' `subset_vec` provided but length does not match `nrow(dat)`")
    }
  subset_log_vec <- subset_vec
  } else if (mode(subset_vec) == "numeric") {
  ## check range
  ran <- range(subset_vec)
  if (ran[1] < 1 || ran[2] > nrow(dat)) {
    stop("'numeric' `subset_vec` provided but values are out of bound")
    } else {
    subset_log_vec <- logical(nrow(dat))
    subset_log_vec[as.integer(subset_vec)] <- TRUE
    } 
  } else {
  stop("`subset_vec` must be either 'logical' or 'numeric'")
  }
dat <- base::subset(dat, subset = subset_log_vec)

• • 步骤1：删除不完整的案例**

dat <- na.omit(dat)

如果您从subset automatically removes incomplete cases开始已经执行了步骤0，则可以跳过此步骤。

• • 第二步：模式检查和转换**

数据框列通常是一个原子向量，其 * mode * 如下所示："逻辑"、"数字"、"复杂"、"字符"、"原始"。对于回归，不同模式的变量被不同地处理。

"logical",   it depends
"numeric",   nothing to do
"complex",   not allowed by `model.matrix`, though allowed by `model.frame`
"character", converted to "numeric" with "factor" class by `model.matrix`
"raw",       not allowed by `model.matrix`, though allowed by `model.frame`

一个逻辑变量是很棘手的，它可以被当作一个伪变量（1对应TRUE; 0 for FALSE），因此是一个"数值"，或者可以强制为两级因子。这完全取决于model.matrix是否认为从模型公式的规范中必须强制为"至因子"。为简单起见，我们可以这样理解：它总是被强制为因子，但是应用对比的结果可能以相同的模型矩阵结束，就好像它被直接作为哑元处理一样。
有些人可能想知道为什么不包括"integer"。因为整数向量，如1:4，有一个"numeric"模式（尝试mode(1:4)）。
数据框列也可以是具有"AsIs"类的矩阵，但此类矩阵必须具有"numeric"模式。
我们的检查是在以下情况下产生错误

• 找到"复合"或"原始";
• 找到"逻辑"或"字符"矩阵变量;

并继续将"逻辑"和"字符"转换为"因子"类的"数字"。

## get mode of all vars
var_mode <- sapply(dat, mode)

## produce error if complex or raw is found
if (any(var_mode %in% c("complex", "raw"))) stop("complex or raw not allowed!")

## get class of all vars
var_class <- sapply(dat, class)

## produce error if an "AsIs" object has "logical" or "character" mode
if (any(var_mode[var_class == "AsIs"] %in% c("logical", "character"))) {
  stop("matrix variables with 'AsIs' class must be 'numeric'")
  }

## identify columns that needs be coerced to factors
ind1 <- which(var_mode %in% c("logical", "character"))

## coerce logical / character to factor with `as.factor`
dat[ind1] <- lapply(dat[ind1], as.factor)

请注意，如果数据框列已经是因子变量，则它不会包含在ind1中，因为因子变量具有"数值"模式（尝试mode(factor(letters[1:4]))）。

• • 步骤3：删除未使用的因子水平**

对于从第2步转换而来的因子变量，即那些由ind1索引的因子变量，我们不会有未使用的因子水平。然而，随dat而来的因子变量可能有未使用的水平（通常是第0步和第1步的结果），我们需要删除其中任何可能未使用的水平。

## index of factor columns
fctr <- which(sapply(dat, is.factor))

## factor variables that have skipped explicit conversion in step 2
## don't simply do `ind2 <- fctr[-ind1]`; buggy if `ind1` is `integer(0)`
ind2 <- if (length(ind1) > 0L) fctr[-ind1] else fctr

## drop unused levels
dat[ind2] <- lapply(dat[ind2], droplevels)

• • 步骤4：汇总因子变量**

现在，我们可以看到lm或glm实际使用了哪些因子水平以及使用了多少因子水平：

## export factor levels actually used by `lm` and `glm`
lev <- lapply(dat[fctr], levels)

## count number of levels
nl <- lengths(lev)

为了简化您的工作，我将这些步骤封装到一个函数debug_contr_error中。

• • 输入：**
• dat是通过data参数传递给lm或glm的 Dataframe ;
• subset_vec是通过subset参数传递给lm或glm的索引向量。
• • 输出：**一个列表
• nlevels（列表）给出所有因子变量的因子水平数;
• levels（向量）给出所有因子变量的水平。

如果没有完整的案例或没有因子变量要汇总，该函数将生成警告。

debug_contr_error <- function (dat, subset_vec = NULL) {
  if (!is.null(subset_vec)) {
    ## step 0
    if (mode(subset_vec) == "logical") {
      if (length(subset_vec) != nrow(dat)) {
        stop("'logical' `subset_vec` provided but length does not match `nrow(dat)`")
        }
      subset_log_vec <- subset_vec
      } else if (mode(subset_vec) == "numeric") {
      ## check range
      ran <- range(subset_vec)
      if (ran[1] < 1 || ran[2] > nrow(dat)) {
        stop("'numeric' `subset_vec` provided but values are out of bound")
        } else {
        subset_log_vec <- logical(nrow(dat))
        subset_log_vec[as.integer(subset_vec)] <- TRUE
        } 
      } else {
      stop("`subset_vec` must be either 'logical' or 'numeric'")
      }
    dat <- base::subset(dat, subset = subset_log_vec)
    } else {
    ## step 1
    dat <- stats::na.omit(dat)
    }
  if (nrow(dat) == 0L) warning("no complete cases")
  ## step 2
  var_mode <- sapply(dat, mode)
  if (any(var_mode %in% c("complex", "raw"))) stop("complex or raw not allowed!")
  var_class <- sapply(dat, class)
  if (any(var_mode[var_class == "AsIs"] %in% c("logical", "character"))) {
    stop("matrix variables with 'AsIs' class must be 'numeric'")
    }
  ind1 <- which(var_mode %in% c("logical", "character"))
  dat[ind1] <- lapply(dat[ind1], as.factor)
  ## step 3
  fctr <- which(sapply(dat, is.factor))
  if (length(fctr) == 0L) warning("no factor variables to summary")
  ind2 <- if (length(ind1) > 0L) fctr[-ind1] else fctr
  dat[ind2] <- lapply(dat[ind2], base::droplevels.factor)
  ## step 4
  lev <- lapply(dat[fctr], base::levels.default)
  nl <- lengths(lev)
  ## return
  list(nlevels = nl, levels = lev)
  }

这是一个构造好的小例子。

dat <- data.frame(y = 1:4,
                  x = c(1:3, NA),
                  f1 = gl(2, 2, labels = letters[1:2]),
                  f2 = c("A", "A", "A", "B"),
                  stringsAsFactors = FALSE)

#  y  x f1 f2
#1 1  1  a  A
#2 2  2  a  A
#3 3  3  b  A
#4 4 NA  b  B

str(dat)
#'data.frame':  4 obs. of  4 variables:
# $ y : int  1 2 3 4
# $ x : int  1 2 3 NA
# $ f1: Factor w/ 2 levels "a","b": 1 1 2 2
# $ f2: chr  "A" "A" "A" "B"

lm(y ~ x + f1 + f2, dat)
#Error in `contrasts<-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) : 
#  contrasts can be applied only to factors with 2 or more levels

很好，我们看到了一个错误。现在我的debug_contr_error暴露了f2最终只有一个级别。

debug_contr_error(dat)
#$nlevels
#f1 f2 
# 2  1 
#
#$levels
#$levels$f1
#[1] "a" "b"
#
#$levels$f2
#[1] "A"

注意，原始的简短答案在这里是没有希望的，因为f2是作为字符变量而不是因子变量提供的。

## old answer
tmp <- na.omit(dat)
fctr <- lapply(tmp[sapply(tmp, is.factor)], droplevels)
sapply(fctr, nlevels)
#f1 
# 2 
rm(tmp, fctr)

现在我们来看一个矩阵变量为x的示例。

dat <- data.frame(X = I(rbind(matrix(1:6, 3), NA)),
                  f = c("a", "a", "a", "b"),
                  y = 1:4)

dat
#  X.1 X.2 f y
#1   1   4 a 1
#2   2   5 a 2
#3   3   6 a 3
#4  NA  NA b 4

str(dat)
#'data.frame':  4 obs. of  3 variables:
# $ X: 'AsIs' int [1:4, 1:2] 1 2 3 NA 4 5 6 NA
# $ f: Factor w/ 2 levels "a","b": 1 1 1 2
# $ y: int  1 2 3 4

lm(y ~ X + f, data = dat)
#Error in `contrasts<-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) : 
#  contrasts can be applied only to factors with 2 or more levels

debug_contr_error(dat)$nlevels
#f 
#1

请注意，没有水平的因子变量也会导致"对比错误"。您可能会想知道0水平因子是怎么可能的。nlevels(factor(character(0)))。如果您没有完整的案例，则在这里您将以0级因子结束。

dat <- data.frame(y = 1:4,
                  x = rep(NA_real_, 4),
                  f1 = gl(2, 2, labels = letters[1:2]),
                  f2 = c("A", "A", "A", "B"),
                  stringsAsFactors = FALSE)

lm(y ~ x + f1 + f2, dat)
#Error in `contrasts<-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) : 
#  contrasts can be applied only to factors with 2 or more levels

debug_contr_error(dat)$nlevels
#f1 f2 
# 0  0    ## all values are 0
#Warning message:
#In debug_contr_error(dat) : no complete cases

最后让我们看看f2是逻辑变量的情况。

dat <- data.frame(y = 1:4,
                  x = c(1:3, NA),
                  f1 = gl(2, 2, labels = letters[1:2]),
                  f2 = c(TRUE, TRUE, TRUE, FALSE))

dat
#  y  x f1    f2
#1 1  1  a  TRUE
#2 2  2  a  TRUE
#3 3  3  b  TRUE
#4 4 NA  b FALSE

str(dat)
#'data.frame':  4 obs. of  4 variables:
# $ y : int  1 2 3 4
# $ x : int  1 2 3 NA
# $ f1: Factor w/ 2 levels "a","b": 1 1 2 2
# $ f2: logi  TRUE TRUE TRUE FALSE

我们的调试器会预测一个"对比度错误"，但它真的会发生吗？

debug_contr_error(dat)$nlevels
#f1 f2 
# 2  1

否，至少此操作未失败（the NA coefficient is due to the rank-deficiency of the model; don't worry）：

lm(y ~ x + f1 + f2, data = dat)
#Coefficients:
#(Intercept)            x          f1b       f2TRUE  
#          0            1            0           NA

我很难举出一个错误的例子，但也没有必要，实际上我们不用调试器来预测;当我们真的遇到错误时我们就用它在这种情况下，调试器可以定位出错的因子变量。
也许有些人会说逻辑变量和虚拟变量没有什么不同，但请尝试下面这个简单的例子：这取决于你的公式。

u <- c(TRUE, TRUE, FALSE, FALSE)
v <- c(1, 1, 0, 0)  ## "numeric" dummy of `u`

model.matrix(~ u)
#  (Intercept) uTRUE
#1           1     1
#2           1     1
#3           1     0
#4           1     0

model.matrix(~ v)
#  (Intercept) v
#1           1 1
#2           1 1
#3           1 0
#4           1 0

model.matrix(~ u - 1)
#  uFALSE uTRUE
#1      0     1
#2      0     1
#3      1     0
#4      1     0

model.matrix(~ v - 1)
#  v
#1 1
#2 1
#3 0
#4 0

使用lm的"model.frame"方法实现更灵活

我们还建议您浏览一下R: how to debug "factor has new levels" error for linear model and prediction，它解释了lm和glm在数据集上的作用。您会明白上面列出的步骤0到4只是试图模拟这样的内部过程。请记住，实际用于模型拟合的数据可能与您传递的数据有很大不同。
我们的步骤与这种内部处理并不完全一致。为了进行比较，您可以通过在lm和glm中使用method = "model.frame"来检索内部处理的结果。在前面构造的小型示例dat中尝试此操作，其中f2是字符变量。

dat_internal <- lm(y ~ x + f1 + f2, dat, method = "model.frame")

dat_internal
#  y x f1 f2
#1 1 1  a  A
#2 2 2  a  A
#3 3 3  b  A

str(dat_internal)
#'data.frame':  3 obs. of  4 variables:
# $ y : int  1 2 3
# $ x : int  1 2 3
# $ f1: Factor w/ 2 levels "a","b": 1 1 2
# $ f2: chr  "A" "A" "A"
## [.."terms" attribute is truncated..]

实际上，model.frame只会执行步骤0和步骤1。它还会删除数据集中提供的变量，但不会删除模型公式中的变量。因此，模型框架中的行和列可能比您提供给lm和glm的少。在我们的步骤2中执行的类型强制是由后面的model.matrix执行的，可能会产生"对比错误"。
首先获取这个内部模型帧，然后将其传递给debug_contr_error（这样它实质上只执行步骤2到4）有几个优点。

• • 优点一：模型公式中未使用的变量将被忽略**

## no variable `f1` in formula
dat_internal <- lm(y ~ x + f2, dat, method = "model.frame")

## compare the following
debug_contr_error(dat)$nlevels
#f1 f2 
# 2  1 

debug_contr_error(dat_internal)$nlevels
#f2 
# 1

• • 优点二：能够处理转换变量**

模型公式中的变量可以进行变换，model.frame记录的是变换后的变量而不是原来的变量，注意即使原来的变量没有NA，变换后的变量也可以有。

dat <- data.frame(y = 1:4, x = c(1:3, -1), f = rep(letters[1:2], c(3, 1)))
#  y  x f
#1 1  1 a
#2 2  2 a
#3 3  3 a
#4 4 -1 b

lm(y ~ log(x) + f, data = dat)
#Error in `contrasts<-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) : 
#  contrasts can be applied only to factors with 2 or more levels
#In addition: Warning message:
#In log(x) : NaNs produced

# directly using `debug_contr_error` is hopeless here
debug_contr_error(dat)$nlevels
#f 
#2 

## this works
dat_internal <- lm(y ~ log(x) + f, data = dat, method = "model.frame")
#  y    log(x) f
#1 1 0.0000000 a
#2 2 0.6931472 a
#3 3 1.0986123 a

debug_contr_error(dat_internal)$nlevels
#f 
#1

考虑到这些好处，我编写了另一个函数来 Package model.frame和debug_contr_error。

• • 输入**：
• form是您的模型公式;
• dat是通过data参数传递给lm或glm的数据集;
• subset_vec是通过subset参数传递给lm或glm的索引向量。
• • 输出：**一个列表
• mf（ Dataframe ）给出模型帧（删除"terms"属性）;
• nlevels（列表）给出了所有因子变量的因子水平数;
• levels（向量）给出所有因子变量的水平。

## note: this function relies on `debug_contr_error`
debug_contr_error2 <- function (form, dat, subset_vec = NULL) {
  ## step 0
  if (!is.null(subset_vec)) {
    if (mode(subset_vec) == "logical") {
      if (length(subset_vec) != nrow(dat)) {
        stop("'logical' `subset_vec` provided but length does not match `nrow(dat)`")
        }
      subset_log_vec <- subset_vec
      } else if (mode(subset_vec) == "numeric") {
      ## check range
      ran <- range(subset_vec)
      if (ran[1] < 1 || ran[2] > nrow(dat)) {
        stop("'numeric' `subset_vec` provided but values are out of bound")
        } else {
        subset_log_vec <- logical(nrow(dat))
        subset_log_vec[as.integer(subset_vec)] <- TRUE
        } 
      } else {
      stop("`subset_vec` must be either 'logical' or 'numeric'")
      }
    dat <- base::subset(dat, subset = subset_log_vec)
    }
  ## step 0 and 1
  dat_internal <- stats::lm(form, data = dat, method = "model.frame")
  attr(dat_internal, "terms") <- NULL
  ## rely on `debug_contr_error` for steps 2 to 4
  c(list(mf = dat_internal), debug_contr_error(dat_internal, NULL))
  }

尝试前面的log转换示例。

debug_contr_error2(y ~ log(x) + f, dat)
#$mf
#  y    log(x) f
#1 1 0.0000000 a
#2 2 0.6931472 a
#3 3 1.0986123 a
#
#$nlevels
#f 
#1 
#
#$levels
#$levels$f
#[1] "a"
#
#
#Warning message:
#In log(x) : NaNs produced

也可以尝试subset_vec。

## or: debug_contr_error2(y ~ log(x) + f, dat, c(T, F, T, T))
debug_contr_error2(y ~ log(x) + f, dat, c(1,3,4))
#$mf
#  y   log(x) f
#1 1 0.000000 a
#3 3 1.098612 a
#
#$nlevels
#f 
#1 
#
#$levels
#$levels$f
#[1] "a"
#
#
#Warning message:
#In log(x) : NaNs produced

每组的模型拟合和NA作为因子水平

您需要
1.通过分组变量分割 Dataframe （参见?split.data.frame）;
1.应用debug_contr_error2逐个处理这些 Dataframe （lapply函数有助于完成此循环）。
Some also told me that they can not use na.omit on their data, because it will end up too few rows to do anything sensible.这个可以放宽，实际上是NA_integer_和NA_real_需要省略，但是NA_character_可以保留：只需添加NA作为因子水平。要实现这一点，您需要循环数据框中的变量：

• 如果变量x已经是因子**，并且anyNA(x)是TRUE**，则执行x <- addNA(x)。"and"很重要。如果x没有NA，则addNA(x)将添加未使用的<NA>水平。
• 如果变量x是字符，执行x <- factor(x, exclude = NULL)将其强制为因子。exclude = NULL将保留<NA>作为级别。
• 如果x是"逻辑的"、"数字的"、"原始的"或"复杂的"，则不应改变任何东西。NA仅仅是NA。

droplevels或na.omit不会删除<NA>因子水平，并且对于构建模型矩阵有效，请检查以下示例。

## x is a factor with NA

x <- factor(c(letters[1:4], NA))  ## default: `exclude = NA`
#[1] a    b    c    d    <NA>     ## there is an NA value
#Levels: a b c d                  ## but NA is not a level

na.omit(x)  ## NA is gone
#[1] a b c d
#[.. attributes truncated..]
#Levels: a b c d

x <- addNA(x)  ## now add NA into a valid level
#[1] a    b    c    d    <NA>
#Levels: a b c d <NA>  ## it appears here

droplevels(x)    ## it can not be dropped
#[1] a    b    c    d    <NA>
#Levels: a b c d <NA>

na.omit(x)  ## it is not omitted
#[1] a    b    c    d    <NA>
#Levels: a b c d <NA>

model.matrix(~ x)   ## and it is valid to be in a design matrix
#  (Intercept) xb xc xd xNA
#1           1  0  0  0   0
#2           1  1  0  0   0
#3           1  0  1  0   0
#4           1  0  0  1   0
#5           1  0  0  0   1

## x is a character with NA

x <- c(letters[1:4], NA)
#[1] "a" "b" "c" "d" NA 

as.factor(x)  ## this calls `factor(x)` with default `exclude = NA`
#[1] a    b    c    d    <NA>     ## there is an NA value
#Levels: a b c d                  ## but NA is not a level

factor(x, exclude = NULL)      ## we want `exclude = NULL`
#[1] a    b    c    d    <NA>
#Levels: a b c d <NA>          ## now NA is a level

将NA作为水平添加到因子/字符中后，您的数据集可能会突然拥有更多完整的事例。然后您可以运行模型。如果仍然出现"对比错误"，请使用debug_contr_error2查看发生了什么。
为了方便起见，我为这个NA预处理编写了一个函数。

• • 输入**：
• dat是您的完整数据集。
• • 输出：**
• Dataframe ，添加NA作为因子/字符的级别。

NA_preproc <- function (dat) {
  for (j in 1:ncol(dat)) {
    x <- dat[[j]]
    if (is.factor(x) && anyNA(x)) dat[[j]] <- base::addNA(x)
    if (is.character(x)) dat[[j]] <- factor(x, exclude = NULL)
    }
  dat
  }

可重现的案例研究和讨论

下面是专门为可重现的案例研究而选择的，因为我刚刚用这里创建的三个帮助函数回答了这些问题。

• How to do a GLM when "contrasts can be applied only to factors with 2 or more levels"?
• R: Error in contrasts when fitting linear models with lm

还有一些其他StackOverflow用户解决的高质量线程：

• Factors not being recognised in a lm using map()（这是关于按组进行模型拟合）
• How to drop NA observation of factors conditionally when doing linear regression in R?（这与前面列表中的情况1类似）
• Factor/level error in mixed model（另一篇关于按组拟合模型的帖子）

此答案旨在调试模型拟合过程中的“对比错误”。但是，使用predict进行预测时也会出现此错误。predict.lm或predict.glm不会出现此行为，但某些包中的预测方法会出现此行为。以下是StackOverflow上的一些相关线程。

• Prediction in R - GLMM
• Error in `contrasts' Error
• SVM predict on dataframe with different factor levels
• Using predict with svyglm
• must a dataset contain all factors in SVM in R
• Probability predictions with cumulative link mixed models
• must a dataset contain all factors in SVM in R

还要注意，这个答案的原理是基于lm和glm . These two functions are a coding standard for many model fitting routines的原理，但可能不是所有的模型拟合例程都有类似的行为。例如，下面的帮助函数是否真的有用，我看起来并不清楚。

• Error with svychisq - 'contrast can be applied to factors with 2 or more levels'
• R packages effects & plm : "error in contrasts" when trying to plot marginal effects
• Contrasts can be applied only to factor
• R: lawstat::levene.test fails while Fligner Killeen works, as well as car::leveneTest
• R - geeglm Error: contrasts can be applied only to factors with 2 or more levels

虽然有点离题，但知道有时“对比错误”仅仅来自编写错误的代码片段仍然是有用的。在下面的示例中，OP将其变量的名称而不是其值传递给lm。由于名称是单值字符，因此稍后将其强制为单级别因子并导致错误。

• Error in contrasts<-(*tmp*, value = contr.funs[1 + isOF[nn]]) : contrasts can be applied only to factors with 2 or more levels
• Loop through a character vector to use in a function

调试后如何解决此错误？

在实践中，人们想知道如何解决这个问题，无论是在统计层面还是在编程层面。
如果您在完整的数据集上拟合模型，那么可能没有统计解决方案，除非您可以插补缺失值或收集更多数据。因此，您可以简单地转向编码解决方案来删除有问题的变量。debug_contr_error2返回nlevels，这有助于您轻松地定位它们。用向量1替换它们（如在How to do a GLM when "contrasts can be applied only to factors with 2 or more levels"?中所解释的），并且让lm或glm处理所得到的秩亏。
如果您在子集上拟合模型，则可能存在统计解决方案。
按组拟合模型不一定需要按组拆分数据集并拟合独立模型。以下内容可能会让您有一个大致的概念：

• R regression analysis: analyzing data for a certain ethnicity
• Finding the slope for multiple points in selected columns
• R: build separate models for each category

如果您确实显式拆分数据，则很容易出现“对比错误”，因此必须按组调整模型公式（即，您需要动态生成模型公式）。更简单的解决方案是跳过为此组构建模型。
也可以将数据集随机划分为训练子集和测试子集，这样就可以进行交叉验证，R: how to debug "factor has new levels" error for linear model and prediction简要提到了这一点，最好进行分层抽样，以确保训练部分的模型估计和测试部分的预测都成功。

也许作为一个非常快的步骤，一个是验证你确实至少有两个因素。我发现的快速方法是：

df %>% dplyr::mutate_all(as.factor) %>% str

根据我十分钟前的经验，这种情况可能发生在有多个类别但有很多NA的情况下，以Kaggle Houseprice Dataset为例，如果加载数据并运行简单的回归，

train.df = read.csv('train.csv')
lm1 = lm(SalePrice ~ ., data = train.df)

你会得到同样的错误。我也试过测试每个因素的水平数，但没有一个说它少于2个水平。

cols = colnames(train.df)
for (col in cols){
  if(is.factor(train.df[[col]])){
    cat(col, ' has ', length(levels(train.df[[col]])), '\n')
  }
}

所以过了很长一段时间，我使用summary(train.df)查看每个列的细节，并删除了一些，它终于工作：

train.df = subset(train.df, select=-c(Id, PoolQC,Fence, MiscFeature, Alley, Utilities))
lm1 = lm(SalePrice ~ ., data = train.df)

并删除其中任何一个，回归无法再次运行相同的错误（我已经自己测试过）。
另一种调试大量NA错误的方法是，用列的最常见属性替换每个NA。注意下面的方法cannotdebug，其中NA是列的模式，我建议手动删除这些列或替换这些列，而不是像这样应用一个函数来处理整个数据集：

fill.na.with.mode = function(df){
    cols = colnames(df)
    for (col in cols){
        if(class(df[[col]])=='factor'){
            x = summary(df[[col]])
            mode = names(x[which.max(x)])
            df[[col]][is.na(df[[col]])]=mode
        }
        else{
            df[[col]][is.na(df[[col]])]=0
        }
    }
    return (df)
}

而上述属性通常有1400+个NA和10个有用的值，所以你可能想删除这些垃圾属性，即使它们有3或4个级别。我想一个计算每列中有多少个NA的函数会有所帮助。