Python: diferenciación entre vectores de fila y columna

¿Hay una buena manera de diferenciar entre los vectores de fila y columna en python? Hasta ahora estoy usando entumecimiento y scipy y lo que veo hasta ahora es que si tuviera que dar un vector, diga

from numpy import * Vector = array([1,2,3]) 

no podrían decir clima me refiero a una fila o un vector de columna. Además:

 array([1,2,3]) == array([1,2,3]).transpose() True 

Lo que en el “mundo real” es simplemente falso. Me doy cuenta de que la mayoría de las funciones en los vectores de los módulos mencionados no necesitan la diferenciación. Por ejemplo outer(a,b) a.dot(b) outer(a,b) o a.dot(b) pero me gustaría diferenciar para mi propia conveniencia.

Related of "Python: diferenciación entre vectores de fila y columna"

Puede hacer que la distinción sea explícita agregando otra dimensión a la matriz.

 >>> a = np.array([1, 2, 3]) >>> a array([1, 2, 3]) >>> a.transpose() array([1, 2, 3]) >>> a.dot(a.transpose()) 14 

Ahora obliga a que sea un vector de columna:

 >>> a.shape = (3,1) >>> a array([[1], [2], [3]]) >>> a.transpose() array([[1, 2, 3]]) >>> a.dot(a.transpose()) array([[1, 2, 3], [2, 4, 6], [3, 6, 9]]) 

Otra opción es usar np.newaxis cuando desee hacer la distinción:

 >>> a = np.array([1, 2, 3]) >>> a array([1, 2, 3]) >>> a[:, np.newaxis] array([[1], [2], [3]]) >>> a[np.newaxis, :] array([[1, 2, 3]]) 

Usa el doble [] al escribir tus vectores.

Entonces, si quieres un vector fila:

 row_vector = array([[1, 2, 3]]) # shape (1, 3) 

O si quieres un vector de columna:

 col_vector = array([[1, 2, 3]]).T # shape (3, 1) 

Creo que puedes usar la opción ndmin de numpy.array. Manteniéndolo en 2 dice que será un (4,1) y que la transposición será (1,4).

 >>> a = np.array([12, 3, 4, 5], ndmin=2) >>> print a.shape >>> (1,4) >>> print aTshape >>> (4,1) 

Si desea una distinción para este caso, le recomendaría que utilice una matrix , en la que:

 matrix([1,2,3]) == matrix([1,2,3]).transpose() 

da:

 matrix([[ True, False, False], [False, True, False], [False, False, True]], dtype=bool) 

También puede usar un ndarray agregando explícitamente una segunda dimensión:

 array([1,2,3])[None,:] #array([[1, 2, 3]]) 

y:

 array([1,2,3])[:,None] #array([[1], # [2], # [3]]) 

El vector que está creando no es ni fila ni columna . En realidad solo tiene 1 dimensión. Puedes verificar que por

  • comprobando el número de dimensiones myvector.ndim que es 1
  • revisando el myvector.shape , que es (3,) (una tupla con un solo elemento). Para un vector de fila debe ser (1, 3) , y para una columna (3, 1)

Dos formas de manejar esto

  • crear un vector de fila o columna real
  • reshape su actual

Puedes crear explícitamente una fila o columna

 row = np.array([ # one row with 3 elements [1, 2, 3] ] column = np.array([ # 3 rows, with 1 element each [1], [2], [3] ]) 

o, con un atajo

 row = np.r_['r', [1,2,3]] # shape: (1, 3) column = np.r_['c', [1,2,3]] # shape: (3,1) 

Alternativamente, puede cambiarlo a (1, n) para la fila, o (n, 1) para la columna

 row = my_vector.reshape(1, -1) column = my_vector.reshape(-1, 1) 

donde el -1 encuentra automáticamente el valor de n .

Parece que Python’s Numpy no lo distingue a menos que lo uses en contexto:

“Si lo desea, puede tener vectores estándar o vectores de fila / columna”.

“:) Puede tratar las matrices de rango 1 como vectores de fila o de columna. El punto (A, v) trata v como un vector de columna, mientras que el punto (v, A) trata v como un vector de fila. Esto puede ahorrarle la necesidad de escribe muchos transposiciones “.

Además, específico para su código: “Transponer en una matriz de rango 1 no hace nada”. Fuente: http://wiki.scipy.org/NumPy_for_Matlab_Users

Puede almacenar los elementos de la matriz en una fila o columna de la siguiente manera:

 >>> a = np.array([1, 2, 3])[:, None] # stores in rows >>> a array([[1], [2], [3]]) >>> b = np.array([1, 2, 3])[None, :] # stores in columns >>> b array([[1, 2, 3]]) 

La excelente biblioteca de Pandas agrega funciones al número que hacen que este tipo de operaciones sean IMO más intuitivas. Por ejemplo:

 import numpy as np import pandas as pd # column df = pd.DataFrame([1,2,3]) # row df2 = pd.DataFrame([[1,2,3]]) 

Incluso puede definir un DataFrame y hacer una tabla dinámica similar a una hoja de cálculo .

Cuando intenté calcular w^T * x usando numpy, también fue muy confuso para mí. De hecho, no pude implementarlo yo mismo. Entonces, este es uno de los pocos errores en NumPy con los que debemos familiarizarnos.

En lo que respecta a la matriz 1D , no hay distinción entre un vector de fila y un vector de columna . Son exactamente lo mismo.

Mire los siguientes ejemplos, donde obtenemos el mismo resultado en todos los casos, lo cual no es cierto en ( el sentido teórico de ) el álgebra lineal:

 In [37]: w Out[37]: array([0, 1, 2, 3, 4]) In [38]: x Out[38]: array([1, 2, 3, 4, 5]) In [39]: np.dot(w, x) Out[39]: 40 In [40]: np.dot(w.transpose(), x) Out[40]: 40 In [41]: np.dot(w.transpose(), x.transpose()) Out[41]: 40 In [42]: np.dot(w, x.transpose()) Out[42]: 40 

Con esa información, ahora tratemos de calcular la longitud al cuadrado del vector |w|^2 .

Para esto, necesitamos transformar w a array 2D.

 In [51]: wt = w[:, np.newaxis] In [52]: wt Out[52]: array([[0], [1], [2], [3], [4]]) 

Ahora, vamos a calcular la longitud al cuadrado (o magnitud al cuadrado) del vector w :

 In [53]: np.dot(w, wt) Out[53]: array([30]) 

Tenga en cuenta que usamos w , wt lugar de wt , w (como en el álgebra lineal teórica) debido a la falta de coincidencia de formas con el uso de np.dot (wt, w). Por lo tanto, tenemos la longitud al cuadrado del vector como [30] . ¿Quizás esta es una de las maneras de distinguir (la interpretación de numpy de) el vector de fila y columna?

Y finalmente, ¿mencioné que descubrí la manera de implementar w^T * x ? Sí, lo hice :

 In [58]: wt Out[58]: array([[0], [1], [2], [3], [4]]) In [59]: x Out[59]: array([1, 2, 3, 4, 5]) In [60]: np.dot(x, wt) Out[60]: array([40]) 

Entonces, en NumPy, el orden de los operandos se invierte, como se evidencia arriba, contrariamente a lo que estudiamos en álgebra lineal teórica.


PD : potenciales trampas en cantidad.

Aquí hay otra forma intuitiva. Supongamos que tenemos:

 >>> a = np.array([1, 3, 4]) >>> a array([1, 3, 4]) 

Primero hacemos una matriz 2D con eso como la única fila:

 >>> a = np.array([a]) >>> a array([[1, 3, 4]]) 

Entonces podemos transponerlo:

 >>> aT array([[1], [3], [4]])