Zeilen entfernen, die mit allen oder einigen NAs (fehlende Werte) in den Daten.Rahmen

Möchte ich entfernen Sie die Zeilen in diesem data-frame:

a) enthalten NAs über alle Spalten. Unten ist meine Beispiel-Daten-frame.

             gene hsap mmul mmus rnor cfam
1 ENSG00000208234    0   NA   NA   NA   NA
2 ENSG00000199674    0   2    2    2    2
3 ENSG00000221622    0   NA   NA   NA   NA
4 ENSG00000207604    0   NA   NA   1    2
5 ENSG00000207431    0   NA   NA   NA   NA
6 ENSG00000221312    0   1    2    3    2

Grundsätzlich, würde ich mag, um einen Daten-frame, wie die folgenden.

             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
6 ENSG00000221312    0   1    2    3    2

b) enthalten NAs nur in einigen Spalten, also kann ich auch bekommen dieses Ergebnis:

             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
4 ENSG00000207604    0   NA   NA   1    2
6 ENSG00000221312    0   1    2    3    2

InformationsquelleAutor Benoit B. | 2011-02-01

967

Überprüfen Sie auch abgeschlossen.Fällen :
```
> final[complete.cases(final), ]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
6 ENSG00000221312    0    1    2    3    2
```
na.omit ist schöner, nur entfernen Sie alle NA's. complete.cases teilweise erlaubt die Auswahl, indem nur bestimmte Spalten der dataframe:
```
> final[complete.cases(final[ , 5:6]),]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
4 ENSG00000207604    0   NA   NA    1    2
6 ENSG00000221312    0    1    2    3    2
```
Deine Lösung nicht funktionieren kann. Wenn Sie darauf bestehen, mit is.na, dann haben Sie etwas zu tun wie:
```
> final[rowSums(is.na(final[ , 5:6])) == 0, ]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
4 ENSG00000207604    0   NA   NA    1    2
6 ENSG00000221312    0    1    2    3    2
```
aber mit complete.cases ist sehr viel klarer und schneller.
- Welche Bedeutung hat das nachgestellte Komma in final[complete.cases(final),]?
- Sie müssen wählen Sie die Zeilen, nicht Spalten. Wie sonst würden Sie das tun?
- Gibt es eine einfache negation von complete.cases? Wenn ich wollte zu halten, die Zeilen mit NAs, anstatt zu verwerfen? final[ ! complete.cases(final),] kooperieren nicht...
- Ich kann bestätigen, dass die komplette.Fällen() ist etwa drei mal schneller als na.auslassen(), aber beide sind ehrlich gesagt sehr langsam.
- mit dplyr, wird es wohl mit dem filter, wie in df %>% filter(ist.na(a)) etc.
- Es ist durchaus üblich zu wollen, nur diejenigen auszuwählen, die Spalten, für die haben wir sichergestellt komplett Fällen, wodurch der Zweck der nachgestellte Komma mehr auf der Hand: für das zweite Beispiel, vergleichen final[complete.cases(final[ , 5:6]), 5:6] oder vielleicht sinnvoller final[complete.cases(final[ , 5:6]), c(1,5:6)]; man kann auch auswählen, indem Sie den Namen zB selected.names <- c("gene", "rnor", "cfam"); final[complete.cases(final[ , selected.names]), selected.names] (Wahrscheinlich nicht nützlich für Sie, nicht mehr, aber vielleicht für die vielen Anfänger die dies Lesen Q)
- final ist dataframe variable?
- in der Tat, es ist.
- Gibt es eine Möglichkeit, mit diesen Methoden nicht beibehalten der Zeilennummern? Im Grunde, wenn es 5 Zeilen und Zeile 3 löscht, dann werden alle diese Methoden erzeugen einer Tabelle mit Zeilennummern: 1, 2, 4, 5 anstelle von 1 -4 .
- Ich lief einfach final[ !complete.cases(final), ] auf version 3.5.1 und es funktioniert: halten Sie alle Zeilen, die eine oder mehrere NAs.
InformationsquelleAutor Joris Meys
234

Versuchen na.omit(your.data.frame). Zur zweiten Frage, posten Sie es als eine andere Frage (für Klarheit).
- na.weglassen fällt die Zeilen, sondern behält die Zeilen-Nummern. Wie würden Sie dieses Problem beheben, so dass es richtig nummeriert?
- wenn Sie nicht über Zeilennummern, nur rownames(x) <- NULL.
- bitte beachten Sie, dass na.omit() Tropfen Zeilen NA in jeder Spalte
InformationsquelleAutor Roman Luštrik
88

tidyr hat eine neue Funktion drop_na:
```
library(tidyr)
df %>% drop_na()
#              gene hsap mmul mmus rnor cfam
# 2 ENSG00000199674    0    2    2    2    2
# 6 ENSG00000221312    0    1    2    3    2
df %>% drop_na(rnor, cfam)
#              gene hsap mmul mmus rnor cfam
# 2 ENSG00000199674    0    2    2    2    2
# 4 ENSG00000207604    0   NA   NA    1    2
# 6 ENSG00000221312    0    1    2    3    2
```
- Es gibt keine wirkliche Verbindung zwischen Rohren und drop_na. Zum Beispiel df %>% drop_na(), df %>% na.omit() und drop_na(df) sind im Grunde alle gleichwertig.
- Ich bin nicht einverstanden. na.omit fügt zusätzliche Infos wie die Indizes weggelassen Fällen und - noch wichtiger - wird nicht zulassen, Sie Spalten auswählen - dies ist, wo drop_na scheint.
- Sicher, mein Punkt ist, dass nicht der dass hat nichts zu tun mit Rohren. Sie können na.omit mit oder ohne Rohre, nur so können Sie drop_na mit oder ohne Rohre.
- True, nichts zu tun mit Rohren an alle. drop_na() ist nur eine Funktion wie jede andere, und als solche, die direkt aufgerufen werden können, oder mit einem Rohr. Leider drop_na(), im Gegensatz zu den anderen genannten Methoden, können Sie auf zoo-oder xts-Objekt-Typen. Dies könnte ein problem für einige.
- Rechts, also bearbeitete ich die Antwort so, dass es nicht erwähnen Rohre.
InformationsquelleAutor lukeA
86

Ich bevorzuge folgenden Weg, um zu überprüfen, ob die Zeilen enthalten alle NAs:
```
row.has.na <- apply(final, 1, function(x){any(is.na(x))})
```
Zurück logischer Vektor mit Werten, die angibt, ob es eine NA in einer Reihe. Sie können es verwenden, um zu sehen, wie viele Zeilen müssen Sie drop:
```
sum(row.has.na)
```
und schließlich fallen Sie
```
final.filtered <- final[!row.has.na,]
```
Für das filtern von Zeilen mit bestimmten Teil des NAs wird es ein wenig schwieriger (zum Beispiel, können Sie füttern 'final[,5:6]' zu 'gelten').
In der Regel, Joris Meys' Lösung zu sein scheint mehr elegant.
- Das ist extrem langsam. Viel langsamer als zB die oben genannten abgeschlossen.Fälle () - Lösung. Zumindest in meinem Fall, auf xts Daten.
- rowSum(!is.na(final)) scheint besser geeignet als apply()
InformationsquelleAutor donshikin

Weitere option, wenn Sie möchten mehr Kontrolle darüber, wie die Zeilen werden als ungültig ist

final <- final[!(is.na(final$rnor)) | !(is.na(rawdata$cfam)),]

Unter Verwendung der oben, diese:

             gene hsap mmul mmus rnor cfam
1 ENSG00000208234    0   NA   NA   NA   2
2 ENSG00000199674    0   2    2    2    2
3 ENSG00000221622    0   NA   NA   2   NA
4 ENSG00000207604    0   NA   NA   1    2
5 ENSG00000207431    0   NA   NA   NA   NA
6 ENSG00000221312    0   1    2    3    2

Wird:

             gene hsap mmul mmus rnor cfam
1 ENSG00000208234    0   NA   NA   NA   2
2 ENSG00000199674    0   2    2    2    2
3 ENSG00000221622    0   NA   NA   2   NA
4 ENSG00000207604    0   NA   NA   1    2
6 ENSG00000221312    0   1    2    3    2

...wo nur Zeile 5 entfernt wird, denn es ist die einzige Zeile, in der NAs für beide rnor UND cfam. Die Boolesche Logik kann dann geändert werden, um fit spezifischen Anforderungen.

aber wie können Sie diese wenn Sie überprüfen möchten, viele Spalten, ohne die Eingabe jedes, können Sie verwenden eine Reihe final[,4:100]?

InformationsquelleAutor getting-there

Wenn Sie wollen Kontrolle darüber, wie viele NAs sind gültig für jede Zeile, versuchen Sie diese Funktion. Für viele Umfrage-Daten-sets, zu viele leere Frage Antworten kann ruinieren die Ergebnisse. Damit Sie gelöscht werden, nachdem eine bestimmte Schwelle überschreitet. Diese Funktion ermöglicht Ihnen, zu entscheiden, wie viele NAs die Zeile haben kann, bevor es gelöscht:

delete.na <- function(DF, n=0) {
  DF[rowSums(is.na(DF)) <= n,]
}

Standardmäßig, wird es zu beseitigen alle NAs:

delete.na(final)
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
6 ENSG00000221312    0    1    2    3    2

Oder geben Sie die maximale Anzahl von NAs erlaubt:

delete.na(final, 2)
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
4 ENSG00000207604    0   NA   NA    1    2
6 ENSG00000221312    0    1    2    3    2

InformationsquelleAutor Pierre Lafortune

Wenn die Leistung eine Priorität ist, verwenden Sie `data.table` und `na.omit()` mit optionaler param `cols=`.

na.weglassen.Daten.table ist der Schnellste auf meinem benchmark (siehe unten), ob alle Spalten oder Spalten auswählen (OP-Frage Teil 2).

Wenn Sie nicht möchten, zu verwenden `data.table` verwenden `complete.cases()`.

Auf einem Vanille data.frame, abgeschlossen.Fällen ist schneller als na.weglassen() oder dplyr::drop_na(). Beachten Sie, dass na.omit.data.frame nicht unterstützen cols=.

Benchmark-Ergebnis

Hier ist ein Vergleich der Basis (blau), dplyr (rosa), und data.table (gelb) Methoden zum löschen, entweder alle oder wählen Sie fehlen Beobachtungen, die auf fiktive Datensatz mit 1 million Beobachtungen von 20 numerische Variablen mit unabhängigen 5% Wahrscheinlichkeit des seins fehlt, und die eine Teilmenge von 4 Variablen, die für Teil 2.

Ihre Ergebnisse können variieren je nach Länge, Breite und sparsity von Ihr bestimmten Datensatz.

Hinweis-log-Skala der y-Achse.

Zeilen entfernen, die mit allen oder einigen NAs (fehlende Werte) in den Daten.Rahmen

Benchmark-Skript

#-------  Adjust these assumptions for your own use case  ------------
row_size   <- 1e6L 
col_size   <- 20    # not including ID column
p_missing  <- 0.05   # likelihood of missing observation (except ID col)
col_subset <- 18:21  # second part of question: filter on select columns

#-------  System info for benchmark  ----------------------------------
R.version # R version 3.4.3 (2017-11-30), platform = x86_64-w64-mingw32
library(data.table); packageVersion('data.table') # 1.10.4.3
library(dplyr);      packageVersion('dplyr')      # 0.7.4
library(tidyr);      packageVersion('tidyr')      # 0.8.0
library(microbenchmark)

#-------  Example dataset using above assumptions  --------------------
fakeData <- function(m, n, p){
  set.seed(123)
  m <-  matrix(runif(m*n), nrow=m, ncol=n)
  m[m<p] <- NA
  return(m)
}
df <- cbind( data.frame(id = paste0('ID',seq(row_size)), 
                        stringsAsFactors = FALSE),
             data.frame(fakeData(row_size, col_size, p_missing) )
             )
dt <- data.table(df)

par(las=3, mfcol=c(1,2), mar=c(22,4,1,1)+0.1)
boxplot(
  microbenchmark(
    df[complete.cases(df), ],
    na.omit(df),
    df %>% drop_na,
    dt[complete.cases(dt), ],
    na.omit(dt)
  ), xlab='', 
  main = 'Performance: Drop any NA observation',
  col=c(rep('lightblue',2),'salmon',rep('beige',2))
)
boxplot(
  microbenchmark(
    df[complete.cases(df[,col_subset]), ],
    #na.omit(df), # col subset not supported in na.omit.data.frame
    df %>% drop_na(col_subset),
    dt[complete.cases(dt[,col_subset,with=FALSE]), ],
    na.omit(dt, cols=col_subset) # see ?na.omit.data.table
  ), xlab='', 
  main = 'Performance: Drop NA obs. in select cols',
  col=c('lightblue','salmon',rep('beige',2))
)

InformationsquelleAutor C8H10N4O2

19

Mit dplyr-package können wir filter NA, wie folgt:
```
dplyr::filter(df,  !is.na(columnname))
```
InformationsquelleAutor Raminsu
17

Das liefert die Zeilen, die mindestens EIN nicht NA-Wert.
```
final[rowSums(is.na(final))<length(final),]
```
Das liefert die Zeilen, die mindestens ZWEI nicht-NA-Wert.
```
final[rowSums(is.na(final))<(length(final)-1),]
```
InformationsquelleAutor Leo
15

Für Ihre erste Frage, ich habe einen code, die ich bin bequem mit, um loszuwerden, alle NAs. Danke, @Gregor um es einfacher zu machen.
```
final[!(rowSums(is.na(final))),]
```
Für die zweite Frage, der code ist nur ein Wechsel von der bisherigen Lösung.
```
final[as.logical((rowSums(is.na(final))-5)),]
```
Beachten Sie die -5 ist die Anzahl der Spalten in Ihren Daten. Dadurch wird verhindert, dass Zeilen mit allen NAs, da die rowSums fügt bis zu 5 und Sie werden Nullen nach der Subtraktion. Dieses mal, da.logisch notwendig ist.
- final[als.logische((rowSums(ist.na(final))-ncol(final))),] für eine Universelle Antwort
InformationsquelleAutor LegitMe
14

Können wir auch die subset-Funktion für diese.
```
finalData<-subset(data,!(is.na(data["mmul"]) | is.na(data["rnor"])))
```
Diese geben nur die Zeilen, die nicht mit NA in beiden mmul und rnor

InformationsquelleAutor Ramya Ural

Ich bin ein synthesizer -:). Hier kombinierte ich die Antworten in einer Funktion:

#' keep rows that have a certain number (range) of NAs anywhere/somewhere and delete others
#' @param df a data frame
#' @param col restrict to the columns where you would like to search for NA; eg, 3, c(3), 2:5, "place", c("place","age")
#' \cr default is NULL, search for all columns
#' @param n integer or vector, 0, c(3,5), number/range of NAs allowed.
#' \cr If a number, the exact number of NAs kept
#' \cr Range includes both ends 3<=n<=5
#' \cr Range could be -Inf, Inf
#' @return returns a new df with rows that have NA(s) removed
#' @export
ez.na.keep = function(df, col=NULL, n=0){
    if (!is.null(col)) {
        # R converts a single row/col to a vector if the parameter col has only one col
        # see https://radfordneal.wordpress.com/2008/08/20/design-flaws-in-r-2-%E2%80%94-dropped-dimensions/#comments
        df.temp = df[,col,drop=FALSE]
    } else {
        df.temp = df
    }

    if (length(n)==1){
        if (n==0) {
            # simply call complete.cases which might be faster
            result = df[complete.cases(df.temp),]
        } else {
            # credit: http://stackoverflow.com/a/30461945/2292993
            log <- apply(df.temp, 2, is.na)
            logindex <- apply(log, 1, function(x) sum(x) == n)
            result = df[logindex, ]
        }
    }

    if (length(n)==2){
        min = n[1]; max = n[2]
        log <- apply(df.temp, 2, is.na)
        logindex <- apply(log, 1, function(x) {sum(x) >= min && sum(x) <= max})
        result = df[logindex, ]
    }

    return(result)
}

InformationsquelleAutor Jerry T

Vorausgesetzt dat als Ihre dataframe, die erwartete Leistung erreicht werden kann, mit

1.rowSums

> dat[!rowSums((is.na(dat))),]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
6 ENSG00000221312    0   1    2    3    2

2.lapply

> dat[!Reduce('|',lapply(dat,is.na)),]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
6 ENSG00000221312    0   1    2    3    2

InformationsquelleAutor Prradep

4
```
delete.dirt <- function(DF, dart=c('NA')) {
  dirty_rows <- apply(DF, 1, function(r) !any(r %in% dart))
  DF <- DF[dirty_rows, ]
}

mydata <- delete.dirt(mydata)
```
Oben genannten Funktion löscht alle Zeilen aus der Daten-frame, der hat 'NA' in jeder Spalte und gibt die resultierenden Daten. Wenn Sie wollen, überprüfen Sie, ob mehrere Werte wie NA und ? ändern dart=c('NA') in der Funktion param zu dart=c('NA', '?')

InformationsquelleAutor sapy

Meine Vermutung ist, dass dies eher elegant gelöst

  m <- matrix(1:25, ncol = 5)
  m[c(1, 6, 13, 25)] <- NA
  df <- data.frame(m)
  library(dplyr) 
  df %>%
  filter_all(any_vars(is.na(.)))
  #>   X1 X2 X3 X4 X5
  #> 1 NA NA 11 16 21
  #> 2  3  8 NA 18 23
  #> 3  5 10 15 20 NA

dieser behält Zeilen mit NA. Ich glaube, was der OP will, ist: df %>% filter_all(all_vars(!is.na(.)))

InformationsquelleAutor Joni Hoppen

Einen Ansatz, der sowohl die Allgemeinen und die Erträge sind relativ lesbaren code zu verwenden, der filter - Funktion und Ihre Varianten im dplyr-package (filter_all, filter_at, filter_if):

library(dplyr)

vars_to_check <- c("rnor", "cfam")

# Filter a specific list of columns to keep only non-missing entries
df %>% 
  filter_at(.vars = vars(one_of(vars_to_check)),
            ~ !is.na(.))

# Filter all the columns to exclude NA
df %>% 
  filter_all(~ !is.na(.))

# Filter only numeric columns
df %>%
  filter_if(is.numeric,
            ~ !is.na(.))

InformationsquelleAutor bschneidr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Wenn die Leistung eine Priorität ist, verwenden Sie data.table und na.omit() mit optionaler param cols=.

Wenn Sie nicht möchten, zu verwenden data.table verwenden complete.cases().

Benchmark-Ergebnis

Benchmark-Skript

Wenn die Leistung eine Priorität ist, verwenden Sie `data.table` und `na.omit()` mit optionaler param `cols=`.

Wenn Sie nicht möchten, zu verwenden `data.table` verwenden `complete.cases()`.