Python : Différenciation entre les vecteurs de lignes et de colonnes

Question

Existe-t-il un bon moyen de différencier les vecteurs en ligne et en colonne en python ? Pour l'instant, j'utilise numpy et scipy et ce que je vois jusqu'à présent, c'est que si je donne un vecteur, disons

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

ils ne seraient pas capables de dire si je veux dire un vecteur de ligne ou de colonne. D'ailleurs :

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

Ce qui, dans le "monde réel", est tout simplement faux. Je réalise que la plupart des fonctions sur les vecteurs des modules mentionnés n'ont pas besoin de différenciation. Par exemple outer(a,b) o a.dot(b) mais j'aimerais faire la différence pour ma propre commodité.

Answer 1

Vous pouvez stocker les éléments du tableau dans une ligne ou une colonne comme suit :

>>> 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]])

Answer 2

Si je veux un tableau 1x3, ou 3x1 :

import numpy as np
row_arr = np.array([1,2,3]).reshape((1,3))
col_arr = np.array([1,2,3]).reshape((3,1)))

Vérifiez votre travail :

row_arr.shape  #returns (1,3)
col_arr.shape  #returns (3,1)

J'ai trouvé beaucoup de réponses ici qui sont utiles, mais beaucoup trop compliquées pour moi. En pratique, je reviens à shape y reshape et le code est lisible : très simple et explicite.

Answer 3

Il semble que Numpy de Python ne le distingue pas, sauf si vous l'utilisez en contexte :

" Vous pouvez avoir des vecteurs standards ou des vecteurs ligne/colonne si vous le souhaitez. "

" :) Vous pouvez traiter les tableaux de rang 1 comme des vecteurs ligne ou colonne. dot(A,v) traite v comme un vecteur colonne, tandis que dot(v,A) traite v comme un vecteur ligne. Cela peut vous éviter de devoir taper de nombreuses transpositions. "

Aussi, spécifique à votre code : "La transposition sur un tableau de rang 1 ne fait rien. " Source : http://wiki.scipy.org/NumPy_for_Matlab_Users

Answer 4

Quand j'ai essayé de calculer w^T * x en utilisant numpy, c'était super confus pour moi aussi. En fait, je n'ai pas pu l'implémenter moi-même. C'est donc l'un des rares problèmes de NumPy avec lequel nous devons nous familiariser.

En ce qui concerne Tableau 1D est concerné, il y a aucune distinction entre un vecteur ligne et un vecteur colonne . Ils sont exactement les mêmes.

Regardez les exemples suivants, où nous obtenons le même résultat dans tous les cas, ce qui n'est pas vrai dans ( le sens théorique de ) l'algèbre linéaire :

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

---

Avec cette information, essayons maintenant de calculer la longueur au carré du vecteur |w|^2 .

Pour cela, nous devons transformer w en tableau 2D.

In [51]: wt = w[:, np.newaxis]

In [52]: wt
Out[52]: 
array([[0],
       [1],
       [2],
       [3],
       [4]])

Maintenant, calculons la longueur au carré (ou la magnitude au carré) du vecteur w :

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

Notez que nous avons utilisé w , wt au lieu de wt , w (comme dans l'algèbre linéaire théorique) en raison d'un décalage de forme avec l'utilisation de np.dot(wt, w). Ainsi, nous avons la longueur au carré du vecteur comme suit [30] . Peut-être est-ce l'une des façons de distinguer (l'interprétation de numpy) les vecteurs ligne et colonne ?

Et enfin, ai-je mentionné que j'ai trouvé le moyen de mettre en œuvre w^T * x ? Oui, je l'ai fait :

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])

Ainsi, dans NumPy, l'ordre des opérandes est inversé, comme on le voit ci-dessus, contrairement à ce que nous avons étudié en algèbre linéaire théorique.

---

P.S. : problèmes potentiels dans numpy

Answer 5

Voici un autre moyen intuitif. Supposons que nous ayons :

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

Tout d'abord, nous créons un tableau 2D dont la seule ligne est celle-là :

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

Ensuite, nous pouvons le transposer :

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