wake-up-neo.com

Python: Unterscheidung zwischen Zeilen- und Spaltenvektoren

Gibt es eine gute Möglichkeit, Zeilen- und Spaltenvektoren in Python zu unterscheiden? Bis jetzt benutze ich Numpy und Scipy und was ich bisher sehe ist, dass ich einem einen Vektor geben würde

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

sie würden nicht sagen können, wann ich meine, eine Zeile oder einen Spaltenvektor. Außerdem:

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

Was in der "realen Welt" einfach nicht wahr ist ... Ich weiß, dass die meisten Funktionen auf Vektoren aus den genannten Modulen nicht die Differenzierung benötigen. Zum Beispiel outer(a,b) oder a.dot(b), aber ich möchte für meine Bequemlichkeit unterscheiden.

47

Sie können die Unterscheidung explizit machen, indem Sie dem Array eine weitere Dimension hinzufügen.

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

Erzwinge es jetzt als Spaltenvektor:

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

Eine andere Option ist die Verwendung von np.newaxis, wenn Sie die Unterscheidung treffen wollen:

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

Verwenden Sie doppelt [], wenn Sie Ihre Vektoren schreiben.

Dann, wenn Sie einen Zeilenvektor wünschen:

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

Oder wenn Sie einen Spaltenvektor wünschen:

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

Ich denke, Sie können die Option ndmin von numpy.array verwenden. Wenn Sie den Wert 2 beibehalten, bedeutet dies, dass es sich um eine (4,1) handelt. 

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

Wenn Sie eine Abgrenzung für diesen Fall wünschen, würde ich empfehlen, stattdessen eine matrix zu verwenden, wobei:

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

gibt:

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

Sie können auch eine ndarray verwenden, um explizit eine zweite Dimension hinzuzufügen:

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

und: 

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

Der Vektor, den Sie erstellen, ist weder Zeile noch Spalte . Es hat eigentlich nur 1 Dimension. Sie können das durch überprüfen

  • Überprüfung der Anzahl der Dimensionen myvector.ndim, dh 1
  • Überprüfung von myvector.shape, dh (3,) (ein Tuple mit nur einem Element). Für einen Zeilenvektor sollte (1, 3) und für eine Spalte (3, 1)

Zwei Möglichkeiten, damit umzugehen

  • erstellen Sie einen actual -Zeilen- oder -Spaltenvektor
  • reshape Ihr aktuelles

Sie können explizit eine Zeile oder Spalte erstellen

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

oder mit einer Verknüpfung

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

Alternativ können Sie es in (1, n) für die Zeile oder (n, 1) für die Spalte umformen

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

wo -1 automatisch den Wert von n findet.

3
blue_note

Es sieht so aus, als würde Python's Numpy es nicht unterscheiden, wenn Sie es nicht im Kontext verwenden:

"Sie können Standardvektoren oder Zeilen-/Spaltenvektoren haben, wenn Sie möchten."

":) Sie können Rang-1-Arrays entweder als Zeilen- oder Spaltenvektoren behandeln. Punkt (A, v) behandelt v als Spaltenvektor, während Punkt (v, A) v als Zeilenvektor behandelt. Dies kann Sie ersparen tippe viele transponiert. "

Auch spezifisch für Ihren Code: "Transponieren auf einem Rang 1-Array bewirkt nichts." Quelle: http://wiki.scipy.org/NumPy_for_Matlab_Users

2
so13eit

Wenn ich ein 1x3-Array oder ein 3x1-Array haben möchte:

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

Überprüfe deine Arbeit:

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

Ich fand viele Antworten hier hilfreich, aber viel zu kompliziert für mich. In der Praxis komme ich auf shape und reshape zurück und der Code ist lesbar: sehr einfach und explizit.

2
neuronet

Sie können die Elemente des Arrays wie folgt in einer Zeile oder Spalte speichern:

>>> 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]])
1
Mehran Yarah

Hier ist ein anderer intuitiver Weg. Angenommen, wir haben:

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

Zuerst erstellen wir ein 2D-Array mit der einzigen Zeile:

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

Dann können wir es umsetzen:

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

Als ich versuchte, w^T * x Mit numpy zu berechnen, war das auch für mich sehr verwirrend. Tatsächlich konnte ich es nicht selbst implementieren. Dies ist einer der wenigen Fallstricke in NumPy, mit denen wir uns vertraut machen müssen.

Für 1D array gibt es keine Unterscheidung zwischen einem Zeilenvektor und einem Spaltenvektor . Sie sind genau das gleiche.

Schauen Sie sich die folgenden Beispiele an, in denen wir in allen Fällen das gleiche Ergebnis erhalten, was in ( der theoretischen Bedeutung von) linearer Algebra nicht zutrifft:

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

Versuchen wir nun, mit diesen Informationen die quadratische Länge des Vektors |w|^2 Zu berechnen.

Dazu müssen wir w in ein 2D-Array transformieren.

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

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

Nun berechnen wir die quadratische Länge (oder die quadratische Größe) des Vektors w:

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

Beachten Sie, dass wir w, wt anstelle von wt, w (wie in der theoretischen linearen Algebra) verwendet haben, da die Form nicht mit der Verwendung von np.dot übereinstimmt (wt, w). Wir haben also die quadratische Länge des Vektors als [30]. Vielleicht ist dies eine der Möglichkeiten, den Zeilen- und den Spaltenvektor zu unterscheiden (numpysche Interpretation)?

Und schließlich habe ich erwähnt, dass ich herausgefunden habe, wie w^T * x Implementiert werden kann? Ja, habe ich :

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

In NumPy ist die Reihenfolge der Operanden umgekehrt, wie oben gezeigt, im Gegensatz zu dem, was wir in der theoretischen linearen Algebra studiert haben.


P.S. : mögliche Fallstricke

0
kmario23

Die exzellente Pandas - Bibliothek fügt numpy weitere Funktionen hinzu, die diese Art von Operationen intuitiver machen. Zum Beispiel:

import numpy as np
import pandas as pd

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

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

Sie können sogar einen DataFrame definieren und eine tabellarische Pivot-Tabelle erstellen .

0
cms_mgr