Различия функций транспонирования в python

я генерирую большую матрицу (100x100, назовем ее X) со случайными числами, с numpy.matrix() так что у меня есть numpy.ndarray.

мне было интересно, есть ли разница между двумя операциями:

  1. и NumPy.транспонировать (X)
  2. Х. Т

я измерил время каждой операции в цикле с дальностью 1000 и кажется, что Х. Т значительно быстрее чем и NumPy.транспонировать (X)

Добавлено Ориентиры:

для матрицы 100x100 я получил следующие результаты с Х. Т и и NumPy.tranpose (X)

в цикле диапазона 10.000:

  • 7421/10.000: Х. Т быстрый
  • 1256/10.000: и NumPy.транспонировать (X) быстрый
  • 1323/10.000: то же время вычисления или разница слишком мала, чтобы определить

добавлен код ниже

    import numpy as np
    import time

    np_transpose_count = 0
    T_transpose_count = 0
    equal_count = 0

    for i in range(10000):
       Se = np.random.rand(100,100)

       tic1 =time.clock()
       ST_T = Se.T
       toc1=time.clock()

       tic2 =time.clock()
       ST_np = np.transpose(Se)
       toc2=time.clock()

       if (toc1-tic1) < (toc2-tic2):
           T_transpose_count+=1
       elif (toc1-tic1) > (toc2-tic2):
           np_transpose_count+=1
       else:
           equal_count+=1

    print(T_transpose_count, np_transpose_count, equal_count)

С наилучшими пожеланиями Шум

7
numpy python transpose

1 ответов

Используя Оболочкой IPython %timeit магия я получаю:

In [218]: X=np.ones((100,100))

In [219]: timeit X.T
1000000 loops, best of 3: 379 ns per loop

In [220]: timeit X.transpose()
1000000 loops, best of 3: 470 ns per loop

In [221]: timeit np.transpose(X)
1000000 loops, best of 3: 993 ns per loop

In [222]: timeit X+1
10000 loops, best of 3: 21.6 µs per loop

да, .T быстрый и медленный. Но сравните эти времена со временем для простого сложения

или копия или срез

In [223]: timeit X.copy()
100000 loops, best of 3: 10.8 µs per loop

In [224]: timeit X[:]
1000000 loops, best of 3: 465 ns per loop

Transpose во всех своих формах возвращает новый объект массива с new shape и strides, но с общим буфером данных (посмотрите на .__array_interface__ словарь, чтобы увидеть, что). Таким образом, это занимает примерно столько же времени, сколько и другие действия, которые возвращают view. Но ни одна из функций транспонирования не делает копию данных или не выполняет итерацию через нее. Таким образом, разница во времени-это просто результат вызова через голову.

снова ipython магия

np.transpose??
def transpose(a, axes=None):
    try:
        transpose = a.transpose
    except AttributeError:
        return _wrapit(a, 'transpose', axes)
    return transpose(axes)

так np.function(X) заканчивает вызов X.transpose().

я бы посмотрел на код numpy, но я помню, что .T реализуется как attribute (не совсем то же самое как property). Я подозреваю, что это быстрее, потому что он не использует

5