Różnica między numpy.kształt tablicy (R, 1) i (R,)

1. Znaczenie kształtów w NumPy

Najlepszym sposobem myślenia o tablicach NumPy jest to, że składają się one z dwóch części, bufora danych, który jest tylko blokiem nieprzetworzonych elementów, oraz widoku, który opisuje jak interpretować bufor danych.

Na przykład, jeśli utworzymy tablicę 12 liczby całkowite:

>>> a = numpy.arange(12)
>>> a
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

Następnie a składa się z bufora danych, ułożonego mniej więcej tak:

┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

I widok, który opisuje, jak interpretować dane:

>>> a.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False
>>> a.dtype
dtype('int64')
>>> a.itemsize
8
>>> a.strides
(8,)
>>> a.shape
(12,)

Tutaj kształt (12,) oznacza, że tablica jest indeksowana pojedynczym indeksem, który biegnie od 0 do 11. W przypadku, gdy indeks i zostanie oznaczony, tablica a wygląda następująco:

i= 0    1    2    3    4    5    6    7    8    9   10   11
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

Jeśli przekształcimy tablicę, nie zmieni to bufora danych. Zamiast tego tworzy nowy widok, który opisuje inny sposób interpretacji danych. Więc po:

>>> b = a.reshape((3, 4))

Tablica b mA ten sam bufor danych co a, ale teraz jest indeksowana przez dwa indeksy , które działają odpowiednio od 0 do 2 i 0 do 3. Jeśli oznaczymy dwa indeksy i i j, tablica b wygląda następująco:

i= 0    0    0    0    1    1    1    1    2    2    2    2
j= 0    1    2    3    0    1    2    3    0    1    2    3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

Co oznacza, że:

>>> b[2,1]
9

Widać, że drugi indeks zmienia się szybko, a pierwszy indeks zmienia się powoli. Jeśli wolisz to być w przeciwnym razie możesz podać parametr order:

>>> c = a.reshape((3, 4), order='F')

Co daje tablicę indeksowaną w ten sposób:

i= 0    1    2    0    1    2    0    1    2    0    1    2
j= 0    0    0    1    1    1    2    2    2    3    3    3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

Co oznacza, że:

>>> c[2,1]
5

Powinno być teraz jasne, co to znaczy, że tablica ma kształt o jednym lub więcej wymiarach o rozmiarze 1. Po:

>>> d = a.reshape((12, 1))

Tablica d jest indeksowana przez dwa indeksy, z których pierwszy biegnie od 0 do 11, a drugi indeks jest zawsze 0:

i= 0    1    2    3    4    5    6    7    8    9   10   11
j= 0    0    0    0    0    0    0    0    0    0    0    0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

I tak:

>>> d[10,0]
10

Wymiar długość 1 jest "wolna" (w pewnym sensie), więc nic nie stoi na przeszkodzie, aby iść do miasta: {]}

>>> e = a.reshape((1, 2, 1, 6, 1))

Dając tablicę indeksowaną w ten sposób:

i= 0    0    0    0    0    0    0    0    0    0    0    0
j= 0    0    0    0    0    0    1    1    1    1    1    1
k= 0    0    0    0    0    0    0    0    0    0    0    0
l= 0    1    2    3    4    5    0    1    2    3    4    5
m= 0    0    0    0    0    0    0    0    0    0    0    0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

I tak:

>>> e[0,1,0,0,0]
6

Zobacz NumPy wewnętrzne dokumentacja aby uzyskać więcej szczegółów na temat implementacji tablic.

2. Co robić?

Od numpy.reshape po prostu tworzy nowy widok, nie powinieneś się bać korzystania z niego w razie potrzeby. Jest to odpowiednie narzędzie do użycia, gdy chcesz indeksować array w inny sposób.

Jednakże, w długich obliczeniach zazwyczaj możliwe jest skonstruowanie tablic o "właściwym" kształcie w pierwszej kolejności, a więc zminimalizowanie liczby przekształceń i transponowań. Ale nie widząc rzeczywistego kontekstu, który doprowadził do potrzeby zmiany kształtu, trudno powiedzieć, co należy zmienić.

Przykład w twoim pytaniu brzmi:

numpy.dot(M[:,0], numpy.ones((1, R)))

M[:,0].sum()

Oblicza wynik prościej. Po drugie, czy naprawdę jest coś specjalnego w kolumnie 0? Być może to, czego naprawdę potrzebujesz, to:

M.sum(axis=0)