Python: Rozróżnianie wektorów wiersza i kolumny

Question

Czy istnieje dobry sposób na rozróżnianie wektorów wiersza i kolumny w python? Do tej pory używam numpy i scipy i co widzę tak daleko, że jeśli miałem dać jeden wektor, powiedzmy

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

nie byłby w stanie powiedzieć pogoda Znaczy wiersza lub kolumny wektor. Ponadto:

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

Co w "prawdziwym świecie" jest po prostu nieprawdą. Zdaję sobie sprawę, że większość funkcji na wektorach z wymienionych modułów nie wymaga rozróżnienia. Na przykład outer(a,b) lub a.dot(b), ale chciałbym wyróżnić dla własnej wygody.

Answer 1

Rozróżnienie można wyrazić, dodając kolejny wymiar do tablicy.

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

teraz zmusić go do być wektorem kolumna:

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

Inną opcją jest użycie np.newaxis gdy chcesz wprowadzić rozróżnienie:

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

Answer 2

Wygląda Python Numpy nie odróżnia go chyba go użyć w kontekście: „Można mieć standardowych wektorów lub wektory wiersz/kolumna jeśli lubisz”

":) Można traktuj tablice 1-sza jako wektory wierszowe lub kolumnowe, kropka (A, v) traktuje v jako wektor kolumnowy, a kropka (v, A) traktuje v jako wektor wierszy, co może zaoszczędzić na konieczności wpisania wielu transpozycji . "

Co więcej, specyficzny dla Twojego kodu:" Transpozycja na macierzy rank-1 nic nie robi. " Źródło: http://wiki.scipy.org/NumPy_for_Matlab_Users

Answer 3

Jeśli chcesz w tej sprawie zalecam użycie zamiast tego matrix, gdzie:

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

daje:

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

Można również użyć ndarray wyraźnie dodając drugi wymiar:

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

oraz:

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

Answer 4

Doskonała Pandas biblioteka dodaje funkcje do numpy, które sprawiają, tego rodzaju operacje są bardziej intuicyjne IMO. Na przykład:

import numpy as np 
import pandas as pd 

# column 
df = pd.DataFrame([1,2,3]) 

# row 
df2 = pd.DataFrame([[1,2,3]]) 

Możesz nawet define a DataFrame and make a spreadsheet-like pivot table.

Answer 5

Myślę, że możesz użyć opcji ndmin z numpy.array. Utrzymanie go na poziomie 2 oznacza, że ​​będzie to (4,1), a transpozycja będzie wynosić (1,4).

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

Answer 6

Kiedy próbowałem obliczyć w^T * x użyciu numpy, było również bardzo mylące dla mnie. W rzeczywistości nie mogłem sam tego wdrożyć. Jest to jeden z niewielu gier w NumPy, z którymi musimy się zapoznać.

ile 1D Tablica się, to nie ma żadnej różnicy pomiędzy wektora wierszy i kolumn wektora. Są dokładnie takie same.

Spójrz na poniższe przykłady, w których możemy uzyskać ten sam rezultat w każdym przypadku, co nie jest prawdą w (teoretyczne poczucie) algebry liniowej:

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 

---

Dzięki tej informacji, teraz spróbujmy obliczyć kwadratową długość wektora |w|^2.

W tym celu musimy przekształcić w na tablicę 2D.

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

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

Teraz Obliczmy długość kwadratu (lub kwadratu wielkości) wektora w:

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

Zauważ, że użyliśmy w, wt zamiast wt, w (jak w teoretycznym algebry liniowej) z powodu niedopasowania kształtu za pomocą np.dot (wt, w). Mamy więc kwadratową długość wektora jako [30]. Może to jeden ze sposobów odróżnienia (numpy's interpretacja) wektora wiersza i kolumny?

I wreszcie, czy wspomniałem, że wymyśliłem sposób na wdrożenie w^T * x? Tak, zrobiłem:

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

Więc w NumPy kolejność argumentów jest odwracany, co widać powyżej, wbrew temu, co badaliśmy w teoretycznym algebry liniowej.

---

P.S.: potential gotchas in numpy

Answer 7

Oto kolejny intuicyjny sposób. Załóżmy, że mamy:

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

Najpierw tworzymy tablicę 2D z tym jako jedyny rząd:

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

Wtedy możemy go transpozycji:

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

Answer 8

używać podwójnego [] podczas pisania wektory.

Następnie, jeśli chcesz wektor rzędu:

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

Albo jeśli chcesz wektor kolumna:

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