Quali sono i modi per pulire un ambiente R dagli oggetti?

Question

So che posso usare ls() e rm() per vedere e rimuovere gli oggetti che esistono nel mio ambiente.

Tuttavia, quando si ha a che fare con il "vecchio" file .RData, è necessario scegliere a volte un ambiente, una parte per trovare cosa conservare e cosa lasciare fuori.

Quello che mi piacerebbe fare è avere un'interfaccia simile a quella della GUI per permettermi di vedere gli oggetti, ordinarli (ad esempio, di lì dimensione), e rimuovere quelli che non mi servono (per esempio, tramite un'interfaccia check-box). Dal momento che immagino che un tale sistema non sia attualmente implementato in R, quali sono le vie? Cosa usi per pulire vecchi file .RData?

Grazie,

Tal

Answer 1

È possibile controllare il pacchetto RGtk2. È possibile creare facilmente un'interfaccia con Glade Interface Designer e quindi allegare qualsiasi comando R desiderato.

Se si desidera un buon punto di partenza in cui "rubare" idee su come utilizzare RGtk2, installare il pacchetto rattle ed eseguire rattle();. Poi guarda il codice sorgente e inizia a creare la tua interfaccia :)

Potrei provarci e vedere se riesco a uscire con qualcosa di semplice.

MODIFICA: questo è un pezzo di codice veloce e sporco con cui puoi giocare. Il grosso problema è che per qualsiasi motivo l'istruzione rm non viene eseguita, ma non sono sicuro del perché ... So che è l'istruzione centrale, ma almeno l'interfaccia funziona! : D

TODO:

• Fai rm lavoro
• ho messo tutte le variabili nell'ambiente remObjEnv. Non dovrebbe essere elencato nella variabile corrente e dovrebbe essere rimosso quando la finestra viene chiusa
• L'elenco mostrerà solo oggetti nell'ambiente globale, qualsiasi cosa all'interno di altro ambiente non verrà mostrata, ma è abbastanza facile implementare
• probabilmente c'è qualche altro bug che non ho pensato: D

Godetevi

# Our environment 
remObjEnv <<- new.env() 

# Various required libraries 
require("RGtk2") 

remObjEnv$createModel <- function() 
    { 
    # create the array of data and fill it in 
    remObjEnv$objList <- NULL 
    objs <- objects(globalenv()) 

    for (o in objs) 
     remObjEnv$objList[[length(remObjEnv$objList)+1]] <- list(object = o, 
      type = typeof(get(o)), 
      size = object.size(get(o))) 

    # create list store 
    model <- gtkListStoreNew("gchararray", "gchararray", "gint") 

    # add items 
    for (i in 1:length(remObjEnv$objList)) 
     { 
     iter <- model$append()$iter 

     model$set(iter, 
       0, remObjEnv$objList[[i]]$object, 
       1, remObjEnv$objList[[i]]$type, 
       2, remObjEnv$objList[[i]]$size) 
     } 

    return(model) 
    } 

remObjEnv$addColumns <- function(treeview) 
    { 
    colNames <- c("Name", "Type", "Size (bytes)") 

    model <- treeview$getModel() 

    for (n in 1:length(colNames)) 
     { 
     renderer <- gtkCellRendererTextNew() 
     renderer$setData("column", n-1) 
     treeview$insertColumnWithAttributes(-1, colNames[n], renderer, text=n-1) 
     } 
    } 

# Builds the list. 
# I seem to have some problems in correctly build treeviews from glade files 
# so we'll just do it by hand :) 
remObjEnv$buildTreeView <- function() 
    { 
    # create model 
    model <- remObjEnv$createModel() 
    # create tree view 
    remObjEnv$treeview <- gtkTreeViewNewWithModel(model) 

    remObjEnv$treeview$setRulesHint(TRUE) 
    remObjEnv$treeview$getSelection()$setMode("single") 

    remObjEnv$addColumns(remObjEnv$treeview) 
    remObjEnv$vbox$packStart(remObjEnv$treeview, TRUE, TRUE, 0) 
    } 

remObjEnv$delObj <- function(widget, treeview) 
    { 
    model <- treeview$getModel() 
    selection <- treeview$getSelection() 
    selected <- selection$getSelected() 
    if (selected[[1]]) 
     { 
     iter <- selected$iter 
     path <- model$getPath(iter) 
      i <- path$getIndices()[[1]] 
      model$remove(iter) 
     } 

    obj <- as.character(remObjEnv$objList[[i+1]]$object) 
    rm(obj) 
    } 

# The list of the current objects 
remObjEnv$objList <- NULL 

# Create the GUI. 
remObjEnv$window <- gtkWindowNew("toplevel", show = FALSE) 
gtkWindowSetTitle(remObjEnv$window, "R Object Remover") 
gtkWindowSetDefaultSize(remObjEnv$window, 500, 300) 
remObjEnv$vbox <- gtkVBoxNew(FALSE, 5) 
remObjEnv$window$add(remObjEnv$vbox) 

# Build the treeview 
remObjEnv$buildTreeView() 

remObjEnv$button <- gtkButtonNewWithLabel("Delete selected object") 
gSignalConnect(remObjEnv$button, "clicked", remObjEnv$delObj, remObjEnv$treeview) 
remObjEnv$vbox$packStart(remObjEnv$button, TRUE, TRUE, 0) 

remObjEnv$window$showAll() 

Answer 2

The X gui sistema operativo ha una cosa del genere, si chiama Browser Workspace. Abbastanza utile.

Ho anche desiderato un'interfaccia che mostri la dipendenza della sessione tra gli oggetti, cioè se parto da una trama() e lavoro all'indietro per trovare tutti gli oggetti che sono stati utilizzati per crearlo. Ciò richiederebbe l'analisi della cronologia.

Answer 3

Non creo mai file .RData. Se stai praticando una ricerca riproducibile (e dovresti esserlo!) Dovresti essere in grado di cercare nei file R di passare da file di dati di input a tutte le uscite.

Quando si verificano operazioni che richiedono molto tempo, è consigliabile memorizzarle nella cache. Se spesso utilizzano un costrutto come:

if (file.exists("cache.rdata")) { 
    load("cache.rdata") 
} else { 
    # do stuff ... 
    save(..., file = "cache.rdata") 
} 

Questo ti permette di lavorare in modo rapido dai file memorizzati nella cache, e quando è necessario ricalcolare da zero si può semplicemente eliminare tutti i file RDATA nella directory di lavoro.

Answer 4

La soluzione di base è caricare i dati, rimuovere ciò che non si desidera e salvare come nuovi, pulire i dati.

---

Un altro modo per gestire questa situazione è quello di controllare RDATA caricato caricandolo al proprio ambiente

sandbox <- new.env() 
load("some_old.RData", sandbox) 

Ora è possibile vedere ciò che è dentro

ls(sandbox) 
sapply(ls(sandbox), function(x) object.size(get(x,sandbox))) 

sono disponibili diverse posibilities :

• scrivere cosa si vuole nuova RDATA: save(A, B, file="clean.RData", envir=sandbox)
• rimuovere ciò che non vuoi dall'ambiente rm(x, z, u, envir=sandbox)
• make copia di variabili che si desidera in spazio di lavoro globale e rimuovere sandbox

faccio di solito qualcosa di simile alla terza opzione. Carica i miei dati, esegui controlli, trasformazioni, copia i dati finali nello spazio di lavoro globale e rimuovi gli ambienti.

---

È sempre possibile implementare ciò che si desidera.Così

1. caricare i dati
   vars <- load("some_old.RData")
2. Get dimensioni
   vars_size <- sapply(vars, function(x) object.size(get(x)))
3. Order loro
   vars <- vars[order(vars_size, decreasing=TRUE)]
vars_size <- vars_size [order(vars_size, decreasing=TRUE)]
4. Fai la finestra di dialogo (dipende dal sistema operativo, ecco Windows)
   vars_with_size <- paste(vars,vars_size)
vars_to_save <- select.list(vars_with_size, multiple=TRUE)
5. Rimuovi quello che non si vuole
   rm(vars[!vars_with_size%in%vars_to_save])

a Nizza sotto forma di dimensioni dell'oggetto che uso soluzione basata su getAnywhere(print.object_size)

pretty_size <- function(x) { 
    ifelse(x >= 1024^3, paste(round(x/1024^3, 1L), "Gb"), 
    ifelse(x >= 1024^2, paste(round(x/1024^2, 1L), "Mb"), 
    ifelse(x >= 1024 , paste(round(x/1024, 1L), "Kb"), 
         paste(x, "bytes") 
    ))) 
} 

Poi nel 4. si può usare paste(vars, pretty_size(vars_size))

Answer 5

non deve caselle di controllo per eliminare con, piuttosto si seleziona il file (s) quindi scegliere elimina .Tuttavia, la soluzione qui di seguito è abbastanza facile da implementare:

library(gWidgets) 
options(guiToolkit="RGtk2") 

## make data frame with files 
out <- lapply((x <- list.files()), file.info) 
out <- do.call("rbind", out) 
out <- data.frame(name=x, size=as.integer(out$size), ## more attributes? 
        stringsAsFactors=FALSE) 
## set up GUI 
w <- gwindow("Browse directory") 
g <- ggroup(cont=w, horizontal=FALSE) 
tbl <- gtable(out, cont=g, multiple=TRUE) 
size(tbl) <- c(400,400) 
deleteThem <- gbutton("delete", cont=g) 
enabled(deleteThem) <- FALSE 
## add handlers 
addHandlerClicked(tbl, handler=function(h,...) { 
    enabled(deleteThem) <- (length(svalue(h$obj, index=TRUE)) > 0) 
}) 

addHandlerClicked(deleteThem, handler=function(h,...) { 
    inds <- svalue(tbl, index=TRUE) 
    files <- tbl[inds,1] 
    print(files)       # replace with rm? 
}) 

Answer 6

Una volta che hai capito ciò che si desidera conservare, è possibile utilizzare la funzione di -keep- dal pacchetto GData fa quello che suggerisce il suo nome.

a <- 1 
b <- 2 
library(gdata) 
keep(a, all = TRUE, sure = TRUE) 

Vedere la guida (tenere) per i dettagli sulle opzioni -all- e -sure-.

all: whether hidden objects (beginning with a .) should be removed, unless explicitly kept. 
sure: whether to perform the removal, otherwise return names of objects that would have been removed. 

Questa funzione è così utile che sono sorpreso che non faccia parte della R stessa.