Numpy: транспонировать результат расширенного индексирования

Я хотел бы суммировать его по измерению 0, но в реальном мире матрица огромна, и я бы предпочел суммировать ее по измерению -1, что быстрее из-за расположения памяти.

Я не совсем уверен, что вы имеете в виду под этим. Если базовый массив является основным по строкам (по умолчанию, т. е. X.flags.c_contiguous == True), то его суммирование по 0-му измерению может быть немного быстрее. Простое перемещение массива с помощью .T или np.transpose() само по себе не меняет способ расположения массива в памяти.

Например:

# X is row-major
print(X.flags.c_contiguous)
# True

# Y is just a transposed view of X
Y = X.T

# the indices of the elements in Y are transposed, but their layout in memory
# is the same as in X, therefore Y is column-major rather than row-major
print(Y.flags.c_contiguous)
# False

Вы можете преобразовать из упорядочения по строкам в упорядочение по столбцам, например, с помощью np.asfortranarray(X), но невозможно выполнить это преобразование без создания полной копии X в памяти. Если вы не собираетесь выполнять множество операций над столбцами X, тогда почти наверняка не стоит выполнять преобразование.

Если вы хотите сохранить результат суммирования в массиве столбцов, вы можете использовать out= kwarg для X.sum(), например:

result = np.empty((3, 3), order='F') # Fortran-order, i.e. column-major
X.sum(0, out=result)

В вашем случае разница между суммированием строк и столбцов, вероятно, будет очень минимальной, поскольку вы уже собираетесь индексировать несмежные элементы в X, вы уже потеряете преимущество < href="http://en.wikipedia.org/wiki/Locality_of_reference#Spatial_and_temporal_locality_usage" rel="nofollow">пространственное расположение ссылки, которое обычно несколько ускоряет суммирование по строкам.

Например:

X = np.random.randn(100, 100, 100)

# summing over whole rows is slightly faster than summing over whole columns
%timeit X.sum(0)
# 1000 loops, best of 3: 438 µs per loop
%timeit X.T.sum(0)
# 1000 loops, best of 3: 486 µs per loop

# however, the locality advantage disappears when you are addressing
# non-adjacent elements using fancy indexing
%timeit X[[0, 0, 1], [0, 1, 1], :].sum()
# 100000 loops, best of 3: 4.72 µs per loop
%timeit X.T[[0, 0, 1], [0, 1, 1], :].sum()
# 100000 loops, best of 3: 4.63 µs per loop

Обновлять

@senderle упомянул в комментариях, что при использовании numpy v1.6.2 он видит обратный порядок времени, то есть X.sum(-1) быстрее, чем X.sum(0) для массива строк. Кажется, это связано с версией numpy, которую он использует - используя v1.6.2, я могу воспроизвести порядок, который он наблюдает, но используя две более новые версии (v1.8.2 и 1.10.0.dev-8bcb756), я наблюдаю обратное ( то есть X.sum(0) быстрее, чем X.sum(-1) с небольшим отрывом). В любом случае, я не думаю, что изменение порядка памяти в массиве может сильно помочь в случае OP.