arrays - squeeze - Convierta una matriz en una matriz de 1 dimensión

squeeze matlab

Question

Tengo una matriz (32X48).

¿Cómo puedo convertir la matriz en una única matriz dimensional?

Answer 1

Desde ?matrix : "Una matriz es el caso especial de una ''matriz'' bidimensional". Simplemente puede cambiar las dimensiones de la matriz / matriz.

Elts_int <- as.matrix(tmp_int) # read.table returns a data.frame as Brandon noted
dim(Elts_int) <- (maxrow_int*maxcol_int,1)

Answer 2

O léelo con ''escanear'', o simplemente hazlo como .vector () en la matriz. Es posible que desee transponer la matriz primero si lo desea por filas o columnas.

> m=matrix(1:12,3,4)
> m
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> as.vector(m)
[1] 1 2 3 4 5 6 7 8 9 10 11 12
> as.vector(t(m))
[1] 1 4 7 10 2 5 8 11 3 6 9 12

Answer 3

Puede que sea tan tarde, de todos modos, esta es mi manera de convertir Matrix en vector:

library(gdata)
vector_data<- unmatrix(yourdata,byrow=T))

espero que ayude

Answer 4

Puede usar la solución de Joshua, pero creo que necesita Elts_int <- as.matrix(tmp_int)

O para bucles:

z <- 1 ## Initialize
counter <- 1 ## Initialize
for(y in 1:48) { ## Assuming 48 columns otherwise, swap 48 and 32
for (x in 1:32) {
z[counter] <- tmp_int[x,y]
counter <- 1 + counter
}
}

z es un vector 1d.

Answer 5

Si en cambio tiene un data.frame (df) que tiene varias columnas y desea vectorizar, puede hacer

as.matrix (df, ncol = 1)

Answer 6

Si estamos hablando de data.frame, entonces debería preguntarse ¿son las variables del mismo tipo? Si ese es el caso, puedes usar "rapply", o "unlist", ya que data.frames son listas, en el fondo de sus almas ...

 data(mtcars)
unlist(mtcars)
rapply(mtcars, c) # completely stupid and pointless, and slower

Answer 7

Simple y rápido ya que una matriz de 1d es esencialmente un vector

vector <- array[1:length(array)]

Answer 8

prueba c()

x = matrix(1:9, ncol = 3)
x
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
c(x)
[1] 1 2 3 4 5 6 7 8 9

Answer 9

puedes usar as.vector() . Parece que es el método más rápido de acuerdo con mi pequeño punto de referencia, de la siguiente manera:

library(microbenchmark)
x=matrix(runif(1e4),100,100) # generate a 100x100 matrix
microbenchmark(y<-as.vector(x),y<-x[1:length(x)],y<-array(x),y<-c(x),times=1e4)

La primera solución usa as.vector() , la segunda usa el hecho de que una matriz se almacena como una matriz contigua en la memoria y la length(m) da la cantidad de elementos en una matriz m . El tercero instancia una array de x , y la cuarta usa la función de concatenación c() . También probé unmatrix de gdata , pero es demasiado lento para mencionarlo aquí.

Estos son algunos de los resultados numéricos que obtuve:

> microbenchmark(
y<-as.vector(x),
y<-x[1:length(x)],
y<-array(x),
y<-c(x),
times=1e4)
Unit: microseconds
expr min lq mean median uq max neval
y <- as.vector(x) 8.251 13.1640 29.02656 14.4865 15.7900 69933.707 10000
y <- x[1:length(x)] 59.709 70.8865 97.45981 73.5775 77.0910 75042.933 10000
y <- array(x) 9.940 15.8895 26.24500 17.2330 18.4705 2106.090 10000
y <- c(x) 22.406 33.8815 47.74805 40.7300 45.5955 1622.115 10000

El aplanamiento de una matriz es una operación común en Machine Learning, donde una matriz puede representar los parámetros a aprender, pero uno usa un algoritmo de optimización de una biblioteca genérica que espera un vector de parámetros. Por lo tanto, es común transformar la matriz (o matrices) en dicho vector. Es el caso con la función R estándar optim() .

Answer 10

array(A) o array(t(A)) le dará una matriz de 1-d.