wake-up-neo.net

Wie funktioniert der Achsenparameter von NumPy?

Kann jemand genau erklären, was der Parameter axis in NumPy bewirkt?

Ich bin furchtbar verwirrt.

Ich versuche die Funktion myArray.sum(axis=num) zu benutzen

Zuerst dachte ich, wenn das Array selbst dreidimensional ist, gibt axis=0 drei Elemente zurück, die aus der Summe aller verschachtelten Elemente an derselben Position bestehen. Wenn jede Dimension fünf Dimensionen enthielt, erwartete ich, dass axis=1 ein Ergebnis von fünf Elementen zurückgibt, und so weiter.

Dies ist jedoch nicht der Fall, und die Dokumentation leistet keine gute Arbeit, um mir zu helfen (sie verwenden ein 3x3x3-Array, so dass es schwer zu sagen ist, was passiert)

Folgendes habe ich getan:

>>> e
array([[[1, 0],
        [0, 0]],

       [[1, 1],
        [1, 0]],

       [[1, 0],
        [0, 1]]])
>>> e.sum(axis = 0)
array([[3, 1],
       [1, 1]])
>>> e.sum(axis=1)
array([[1, 0],
       [2, 1],
       [1, 1]])
>>> e.sum(axis=2)
array([[1, 0],
       [2, 1],
       [1, 1]])
>>>

Offensichtlich ist das Ergebnis nicht intuitiv.

27
CodyBugstein

Deutlich,

e.shape == (3, 2, 2)

Summe über einer Achse ist eine Verkleinerung, sodass die angegebene Achse nicht mehr angezeigt wird. Daher,

e.sum(axis=0).shape == (2, 2)
e.sum(axis=1).shape == (3, 2)
e.sum(axis=2).shape == (3, 2)
19
Martin

Verstehen, was Achse in Anzahl bedeutet:

Betrachten Sie die dreidimensionale x-, y- und z-Koordinatenebene:

enter image description here

Der Achsenparameter ist eine Zahl, die an numpy-Arrays kommuniziert, entlang welcher Dimension Ihre Aggregatfunktion ausgeführt werden soll.

Python Numpy/Pandas Axis Mnemonik:

axis=0 means 'along the row', (x in the above image)
axis=1 means 'along the column', (y in the above image)
axis=2 means 'along the depth', (z in the above image)

enter image description here

Bildquelle: https://github.com/sentientmachine/Cheatsheets#python_numpy

Das Verständnis des Achsenparameters ist erforderlich, wenn Sie die Vektorisierung von Zahlen und insbesondere die Reihenfolge der Dimensionsoperationen für das Rundsenden verstehen möchten.

Stellen Sie sich vor, wir wollen über eine Matrix mit drei Dimensionen summieren. Eine Summe kann entlang der x-, y- oder z-Achse oder entlang aller drei Achsen arbeiten. Die Standardachse ist 0, was bedeutet, dass die äußerste Dimension diejenige ist, die von your_3d_matrix[0] Zurückgegeben wird.

Wenn Sie also entlang der Achse = 0, der Achse = 1 oder der Achse = 2 summieren, erhalten Sie eindimensionale Summenschnitte über diese Dimension.

Beispiel:

a = np.array([[1,2],[3,4]])   #define a simple 2d ndarray

>>> a[0,0]
1
>>> a[0,1]
2
>>> a[1,0]
3
>>> a[1,1]
4


>>> a.sum()                   #axis not specified means first along the col then 
10                            #along the row: (1+3) = 4 and
                              #2+4 = 6 then along the column 4+6 = 10

>>> a.sum(axis=0)             #forcing axis=0 says collapse along the row so:
array([4, 6])                 #1+3 = 4,   2+4 = 6

>>> a.sum(axis=1)             #forcing axis=1 says collapse along the col so:
array([3, 7])                 #1+2 = 3,   3+4 = 7

Sie können sogar Achse = 2 haben, was die 2. Dimension nach unten ist:

>>> b = np.array([[[1,2],[3,4]], [[5,6],[7,8]]])
>>> b
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])
>>> b.sum()         #sum along depth, col, then row:
36
>>> b.sum(axis=0)   #sum across the topmost dimension 0, the two groups of 4
array([[ 6,  8],
       [10, 12]])
>>> b.sum(axis=1)   #sum across dimension 1 the lists of two, added.
array([[ 4,  6],
       [12, 14]])
>>> b.sum(axis=2)   #sum across the dimension 2, each individual list, row wise. 
array([[ 3,  7],
       [11, 15]])

Die Ausrichtung der Achse hängt von der Struktur ab, auf die sie angewendet wird.

Die Operationsreihenfolge für den Achsenkollaps beginnt ganz außen, die Dimension von yourarray[0] Nach innen: yourarray[0][0][0].

Selbst die Entwickler, die diese Numpy-Software programmiert haben, haben Probleme damit, eine Intuition für die Matrixoperationen der linearen Algebra zu erstellen. In Youtube-Videos wird versucht, die Achsenparameter ausführlich zu erläutern:

Alexandre Chabot LeClerc NumPy Tutorial, das den Achsenparameter behandelt: https://youtu.be/gtejJ3RCddE?t=1h55m17s

Der Data School-Kanal auf YouTube bietet eine hervorragende Erklärung für die Achsenparameter: https://youtu.be/PtO3t6ynH-8?t=5m1s

36
Eric Leschinski

Um die axis intuitiv zu verstehen, beziehen Sie sich auf das folgende Bild (Quelle: Physics Dept, Cornell Uni )

 enter image description here

Das shape des (booleschen) Arrays in der obigen Abbildung ist shape=(8, 3). ndarray.shape gibt ein Tuple zurück, wobei die Einträge der Länge der jeweiligen Dimension entsprechen. In unserem Beispiel entspricht 8 der Länge von Achse 0 , während 3 der Länge von Achse 1 entspricht.

7
kmario23

Wenn jemand diese visuelle Beschreibung benötigt: 

 numpy axis

1
debaonline4u

Es gibt gute Antworten für die Visualisierung, aber es kann hilfreich sein, aus rein analytischer Perspektive zu denken. 

Sie können ein Array mit beliebigen Dimensionen mit numpy erstellen. Beispiel: Ein Array mit fünf Dimensionen:

>>> a = np.random.Rand(2, 3, 4, 5, 6)
>>> a.shape
(2, 3, 4, 5, 6)

Sie können auf jedes Element dieses Arrays zugreifen, indem Sie Indizes angeben. Hier ist zum Beispiel das erste Element dieses Arrays:

>>> a[0, 0, 0, 0, 0]
0.0038908603263844155

Wenn Sie nun eine der Dimensionen herausnehmen, erhalten Sie die Anzahl der Elemente in dieser Dimension:

>>> a[0, 0, :, 0, 0]
array([0.00389086, 0.27394775, 0.26565889, 0.62125279])

Wenn Sie eine Funktion wie sum mit dem Parameter axis anwenden, wird diese Dimension entfernt und ein Array mit weniger Dimensionen als das ursprüngliche erstellt. Für jede Zelle in einem neuen Array erhält der Operator eine Liste von Elementen und wendet die Reduktionsfunktion an, um einen Skalierer zu erhalten.

>>> np.sum(a, axis=2).shape
(2, 3, 5, 6)

Jetzt können Sie überprüfen, ob das erste Element dieses Arrays die Summe der obigen Elemente ist:

>>> np.sum(a, axis=2)[0, 0, 0, 0]
1.1647502999560164

>>> a[0, 0, :, 0, 0].sum()
1.1647502999560164

Der axis=None hat eine besondere Bedeutung, um das Array zu glätten und auf alle Zahlen eine Funktion anzuwenden.

Jetzt können Sie über komplexere Fälle nachdenken, bei denen die Achse nicht nur eine Zahl, sondern ein Tupel ist:

>>> np.sum(a, axis=(2,3)).shape
(2, 3, 6)

Beachten Sie, dass wir dieselbe Technik verwenden, um herauszufinden, wie diese Reduzierung durchgeführt wurde:

>>> np.sum(a, axis=(2,3))[0,0,0]
7.889432081931909

>>> a[0, 0, :, :, 0].sum()
7.88943208193191

Sie können dieselbe Argumentation für Hinzufügen von dimension in array verwenden, anstatt verkleinern dimension:

>>> x = np.random.Rand(3, 4)
>>> y = np.random.Rand(3, 4)

# New dimension is created on specified axis
>>> np.stack([x, y], axis=2).shape
(3, 4, 2)
>>> np.stack([x, y], axis=0).shape
(2, 3, 4)

# To retrieve item i in stack set i in that axis 

Ich hoffe, das gibt Ihnen ein generisches und umfassendes Verständnis dieses wichtigen Parameters.

0
Shital Shah