rpy2: Conversione di un data.frame ad una matrice NumPy

Question

Ho un data.frame in R. Esso contiene un sacco di dati: livelli di espressione genica da molti (125) array. Mi piacerebbe i dati in Python, dovuto soprattutto alla mia incompetenza in R e il fatto che questo doveva essere un lavoro di 30 minuti.

Vorrei il seguente codice al lavoro. Per capire questo codice, sappiate che il path variabile contiene il percorso completo per il mio set di dati che, una volta caricato, mi dà una variabile chiamata immgen. Sa che immgen è un oggetto (un oggetto ExpressionSet Bioconductor) e che restituisce exprs(immgen) un frame di dati con 125 colonne (esperimenti) e decine di migliaia di righe (geni denominati). (Solo nel caso non si capisce bene, questo è il codice Python, utilizzando robjects.r alla chiamata codice R)

import numpy as np
import rpy2.robjects as robjects
# ... some code to build path
robjects.r("load('%s')"%path) # loads immgen
e = robjects.r['data.frame']("exprs(immgen)")
expression_data = np.array(e)

Questa esegue il codice, ma è semplicemente expression_data array([[1]]).

Sono abbastanza sicuro che e non rappresenta il frame di dati generato da exprs() a causa di cose come:

In [40]: e._get_ncol()
Out[40]: 1

In [41]: e._get_nrow()
Out[41]: 1

Ma poi chi lo sa? Anche se ha fatto e rappresentare il mio data.frame, che non converte direttamente a una matrice sarebbe abbastanza giusto - un frame di dati ha più al suo interno di un array (rownames e colnames) e quindi forse la vita non deve essere così facile . Tuttavia non riesco ancora a capire come eseguire la conversione. La documentazione è un po 'troppo conciso per me, anche se la mia comprensione limitata delle voci nei documenti implica che questo dovrebbe essere possibile.

Chiunque ogni pensiero?

Answer 1

Perché passare attraverso un data.frame quando 'exprs (immgen)' restituisce un / matrice / e il vostro obiettivo finale è quello di avere i dati in una matrice?

Passando la matrice di NumPy è semplice (e può anche essere realizzato senza una copia): http: //rpy.sourceforge. / rpy2 net / doc-2.1 / html / numpy.html # da-rpy2-to-NumPy

Ciò dovrebbe battere sia semplice ed efficiente il suggerimento di passare attraverso rappresentazione testuale dei dati numerici in file flat come un modo per scambiare dati.

Sembra che tu stia lavorando con le classi Bioconductor, e potrebbe essere interessato al seguente: http://pypi.python.org/pypi/rpy2-bioconductor-extensions/

Answer 2

Questo è il modo più semplice e affidabile che ho trovato per trasferire un frame di dati da R a Python.

Per cominciare, penso che lo scambio di dati attraverso le associazioni R è una complicazione inutile. R fornisce un metodo semplice per esportare i dati, allo stesso modo, NumPy ha metodi decenti per l'importazione dei dati. Il formato del file è l'interfaccia unica comune richiesto qui.

data(iris)
iris$Species = unclass(iris$Species)

write.table(iris, file="/path/to/my/file/np_iris.txt", row.names=F, sep=",")

# now start a python session
import numpy as NP

fpath = "/path/to/my/file/np_iris.txt"

A = NP.loadtxt(fpath, comments="#", delimiter=",", skiprows=1)

# print(type(A))
# returns: <type 'numpy.ndarray'>

print(A.shape)
# returns: (150, 5)

print(A[1:5,])
# returns: 
 [[ 4.9  3.   1.4  0.2  1. ]
  [ 4.7  3.2  1.3  0.2  1. ]
  [ 4.6  3.1  1.5  0.2  1. ]
  [ 5.   3.6  1.4  0.2  1. ]]

In base alla documentazione (e la mia esperienza per quello che vale) loadtxt è il metodo preferito per l'importazione di dati convenzionali.

Si può anche passare per loadtxt una tupla di tipi di dati (l'argomento è dtypes ), un elemento nella tupla per ogni colonna. 'skiprows = 1' notice scavalcare la colonna (per loadtxt righe sono indicizzate da 1, colonne da 0).

Infine, i convertito il fattore dataframe per intero (che è in realtà il tipo di dati sottostante per factor) prima di esportare - 'unclass' è probabilmente il modo più semplice per farlo

.

Se si dispone di dati grandi (ad esempio, non si vuole caricare l'intero file di dati in memoria, ma ancora bisogno di accedervi) struttura di dati mappato in memoria di NumPy ( 'memmap') è un buona scelta:

from tempfile import mkdtemp
import os.path as path

filename = path.join(mkdtemp(), 'tempfile.dat')

# now create a memory-mapped file with shape and data type 
# based on original R data frame:
A = NP.memmap(fpath, dtype="float32", mode="w+", shape=(150, 5))

# methods are ' flush' (writes to disk any changes you make to the array), and 'close'
# to write data to the memmap array (acdtually an array-like memory-map to 
# the data stored on disk)
A[:] = somedata[:]