Punto producto de un vector en SciPy/NumPy (obteniendo ValueError: los objetos no están alineados)

Question

Acabo de empezar a aprender SciPy y estoy luchando con las características más básicas.

Considérese el siguiente vector estándar:

In [6]: W=array([[1],[2]]) 

In [7]: print W 
[[1] 
[2]] 

Si he entendido bien, esto debe ser la representación SciPy de un 2x1 del vector matemática estándar, así:

producto

(1)  
(2) 

El punto de este vector debería simplemente ser 1*1+2*2=5. Sin embargo, esto no funciona en SciPy:

In [16]: dot(W, W) 
--------------------------------------------------------------------------- 
ValueError        Traceback (most recent call last) 
/home/ingo/<ipython-input-16-961b62a82495> in <module>() 
----> 1 dot(W, W) 

ValueError: objects are not aligned 

Tenga en cuenta que lo siguiente funciona. Esto debería ser un vector del formulario (1 2) si no me equivoco.

In [9]: V=array([1,2]) 

In [10]: print V 
[1 2] 

In [11]: dot(V, V) 
Out[11]: 5 

¿Cuál es mi error? ¿Qué estoy haciendo mal?

Answer 1

La clave aquí es que numpy/scipy respeta la forma de las matrices al calcular los productos de puntos. En cuanto a su primer ejemplo, W es una matriz 2x1:

In [7]: W=array([[1],[2]]) 

In [8]: print W.shape 
------> print(W.shape) 
(2, 1) 

es, por lo tanto, necesario utilizar el operador de transposición para calcular el producto escalar (interior) de W con ella misma:

In [9]: print dot(W.T,W) 
------> print(dot(W.T,W)) 
[[5]] 

In [10]: print np.asscalar(dot(W.T,W)) 
-------> print(np.asscalar(dot(W.T,W))) 
5 

Answer 2

Esa es una matriz de dos matrices, no una matriz de dos valores. El primero podría considerarse como una matriz: dos filas con una columna cada una.

El segundo es correcto; también te da el producto correcto de punto correcto. Cree en tus ojos; usa el segundo.

Answer 3

En el primer ejemplo, W es una matriz de 2 dimensiones, mientras que en la última (la que funciona), tiene solo 1 dim.

Yon puede estar seguro de que la 2 ª manera es la forma correcta de hacerlo.

Answer 4

En su primer caso numpy está generando el vector como una matriz bidimensional, básicamente una matriz de 2 por 1. En ese caso, el producto escalar no se puede tomar porque la matriz m-by-n se puede puntear solo con una matriz n-by-k. La solución es usar:

dot(W.T,W) 

Esto es lo mismo que la forma en que x.x a veces se escribe x^T x.

En el segundo caso, para mayor comodidad numpy está generando una matriz unidimensional en lugar de una matriz, por lo que el producto escalar tiene una definición simple. Si se va a generar una matriz de 1 por 2 usando

W = np.array([[1,2]]) 

entonces se obtendría el mismo comportamiento que en el primer caso.

Answer 5

se equivoca acerca de la forma de la matriz se pasa en:

>>> W = np.array([[1], [2]]) 
>>> W.shape 
(2, 1) 
>>> W = np.array([1, 2]) 
>>> W.shape 
(2,) 

Como se ha observado, utilizando np.dot en la segunda definición de W funciona como se espera.Poner los puntos sobre una matriz 2-D con ella misma, cuando no es cuadrada, debe transponer:

>>> W = np.array([[1], [2]]) 
>>> np.dot(W, W.transpose()) 
array([[1, 2], 
     [2, 4]]) 

un acceso directo para transpose es W.T

Tenga en cuenta que la forma de la salida varía en función de si se empezar con la transposición o el original, como era de esperar:

>>> np.dot(W.T, W) 
array([[5]]) 
>>> np.dot(W.T, W).shape 
(1, 1) 

Consulte los documentos numpy por más.

Answer 6

Debe usar vdot: "Devuelve el producto punto de dos vectores". Esta función aplana los argumentos de entrada y da los resultados que espera. Para su ejemplo:

>>> W = np.array([[1], [2]]) 
>>> np.vdot(W, W) 
5 
>>>