Tricks zur Verwaltung des verfügbaren Speichers in einer R-Sitzung

Question

Welche Tricks verwenden die Leute, um den verfügbaren Speicher einer interaktiven R-Sitzung zu verwalten? Ich verwende die folgenden Funktionen [basierend auf Postings von Petr Pikal und David Hinds in der r-help-Liste im Jahr 2004], um die größten Objekte aufzulisten (und/oder zu sortieren) und um gelegentlich rm() einige von ihnen. Aber die bei weitem effektivste Lösung war ... unter 64-Bit-Linux mit reichlich Speicher zu laufen.

Gibt es noch andere nette Tricks, die Sie uns mitteilen möchten? Einen pro Beitrag, bitte.

# improved list of objects
.ls.objects <- function (pos = 1, pattern, order.by,
                        decreasing=FALSE, head=FALSE, n=5) {
    napply <- function(names, fn) sapply(names, function(x)
                                         fn(get(x, pos = pos)))
    names <- ls(pos = pos, pattern = pattern)
    obj.class <- napply(names, function(x) as.character(class(x))[1])
    obj.mode <- napply(names, mode)
    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
    obj.size <- napply(names, object.size)
    obj.dim <- t(napply(names, function(x)
                        as.numeric(dim(x))[1:2]))
    vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
    obj.dim[vec, 1] <- napply(names, length)[vec]
    out <- data.frame(obj.type, obj.size, obj.dim)
    names(out) <- c("Type", "Size", "Rows", "Columns")
    if (!missing(order.by))
        out <- out[order(out[[order.by]], decreasing=decreasing), ]
    if (head)
        out <- head(out, n)
    out
}
# shorthand
lsos <- function(..., n=10) {
    .ls.objects(..., order.by="Size", decreasing=TRUE, head=TRUE, n=n)
}

Answer 1

Stellen Sie sicher, dass Sie Ihre Arbeit in einem reproduzierbaren Skript festhalten. Öffnen Sie von Zeit zu Zeit R erneut, dann source() Ihr Skript. Sie bereinigen alles, was Sie nicht mehr verwenden, und haben außerdem Ihren Code getestet.

Answer 2

Ich benutze die Daten.Tabelle Paket. Mit seinem := Betreiber können Sie :

• Spalten durch Verweis hinzufügen
• Ändern von Teilmengen vorhandener Spalten durch Verweis und durch Gruppierung durch Verweis
• Spalten per Referenz löschen

Keiner dieser Vorgänge kopiert die (potenziell großen) data.table überhaupt nicht, nicht ein einziges Mal.

• Die Aggregation ist auch deshalb besonders schnell, weil data.table verbraucht viel weniger Arbeitsspeicher.

Verwandte Links :

• Neues von data.table, Londoner R-Präsentation, 2012
• Wann sollte ich die := Operator in data.table?

Answer 3

Ich habe dies auf einem Twitter-Post gesehen und denke, es ist eine großartige Funktion von Dirk! In Anlehnung an Die Antwort von JD Long Ich würde dies für eine benutzerfreundliche Lektüre tun:

# improved list of objects
.ls.objects <- function (pos = 1, pattern, order.by,
                        decreasing=FALSE, head=FALSE, n=5) {
    napply <- function(names, fn) sapply(names, function(x)
                                         fn(get(x, pos = pos)))
    names <- ls(pos = pos, pattern = pattern)
    obj.class <- napply(names, function(x) as.character(class(x))[1])
    obj.mode <- napply(names, mode)
    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
    obj.prettysize <- napply(names, function(x) {
                           format(utils::object.size(x), units = "auto") })
    obj.size <- napply(names, object.size)
    obj.dim <- t(napply(names, function(x)
                        as.numeric(dim(x))[1:2]))
    vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
    obj.dim[vec, 1] <- napply(names, length)[vec]
    out <- data.frame(obj.type, obj.size, obj.prettysize, obj.dim)
    names(out) <- c("Type", "Size", "PrettySize", "Length/Rows", "Columns")
    if (!missing(order.by))
        out <- out[order(out[[order.by]], decreasing=decreasing), ]
    if (head)
        out <- head(out, n)
    out
}

# shorthand
lsos <- function(..., n=10) {
    .ls.objects(..., order.by="Size", decreasing=TRUE, head=TRUE, n=n)
}

lsos()

Daraus ergibt sich in etwa folgendes Bild:

                      Type   Size PrettySize Length/Rows Columns
pca.res                 PCA 790128   771.6 Kb          7      NA
DF               data.frame 271040   264.7 Kb        669      50
factor.AgeGender   factanal  12888    12.6 Kb         12      NA
dates            data.frame   9016     8.8 Kb        669       2
sd.                 numeric   3808     3.7 Kb         51      NA
napply             function   2256     2.2 Kb         NA      NA
lsos               function   1944     1.9 Kb         NA      NA
load               loadings   1768     1.7 Kb         12       2
ind.sup             integer    448  448 bytes        102      NA
x                 character     96   96 bytes          1      NA

HINWEIS: Der wichtigste Teil, den ich hinzugefügt habe, war (wiederum in Anlehnung an JDs Antwort):

obj.prettysize <- napply(names, function(x) {
                           print(object.size(x), units = "auto") })

Answer 4

Ich mache aggressiven Gebrauch von der subset Parameter mit der Auswahl nur der erforderlichen Variablen bei der Übergabe von Datenrahmen an den data= Argument der Regressionsfunktionen. Es führt zu einigen Fehlern, wenn ich vergesse, Variablen sowohl in die Formel als auch in die select= Vektor, spart aber dennoch eine Menge Zeit, da weniger Objekte kopiert werden müssen und der Speicherbedarf erheblich reduziert wird. Angenommen, ich habe 4 Millionen Datensätze mit 110 Variablen (und das habe ich.) Beispiel:

# library(rms); library(Hmisc) for the cph,and rcs functions
Mayo.PrCr.rbc.mdl <- 
cph(formula = Surv(surv.yr, death) ~ age + Sex + nsmkr + rcs(Mayo, 4) + 
                                     rcs(PrCr.rat, 3) +  rbc.cat * Sex, 
     data = subset(set1HLI,  gdlab2 & HIVfinal == "Negative", 
                           select = c("surv.yr", "death", "PrCr.rat", "Mayo", 
                                      "age", "Sex", "nsmkr", "rbc.cat")
   )            )

Um den Kontext und die Strategie zu verdeutlichen: Die gdlab2 ist ein logischer Vektor, der für Probanden in einem Datensatz konstruiert wurde, die alle normale oder fast normale Werte für eine Reihe von Labortests hatten und HIVfinal war ein Zeichenvektor, der Vor- und Bestätigungstests für HIV zusammenfasste.

Answer 5

Ich liebe Dirks Skript .ls.objects(), aber ich musste immer blinzeln, um die Zeichen in der Größenspalte zu zählen. Also habe ich ein paar hässliche Hacks gemacht, um die Größe mit einer hübschen Formatierung darzustellen:

.ls.objects <- function (pos = 1, pattern, order.by,
                        decreasing=FALSE, head=FALSE, n=5) {
    napply <- function(names, fn) sapply(names, function(x)
                                         fn(get(x, pos = pos)))
    names <- ls(pos = pos, pattern = pattern)
    obj.class <- napply(names, function(x) as.character(class(x))[1])
    obj.mode <- napply(names, mode)
    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
    obj.size <- napply(names, object.size)
    obj.prettysize <- sapply(obj.size, function(r) prettyNum(r, big.mark = ",") )
    obj.dim <- t(napply(names, function(x)
                        as.numeric(dim(x))[1:2]))
    vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
    obj.dim[vec, 1] <- napply(names, length)[vec]
    out <- data.frame(obj.type, obj.size,obj.prettysize, obj.dim)
    names(out) <- c("Type", "Size", "PrettySize", "Rows", "Columns")
    if (!missing(order.by))
        out <- out[order(out[[order.by]], decreasing=decreasing), ]
        out <- out[c("Type", "PrettySize", "Rows", "Columns")]
        names(out) <- c("Type", "Size", "Rows", "Columns")
    if (head)
        out <- head(out, n)
    out
}