Как я могу улучшить эффективность умножения матриц в Python?

Question

Я написал код для умножения матриц в разных диапазонах, но для выполнения кода требуется много времени,

код:

Программа для умножения двух матриц с использованием вложенных циклов

import time

print("Enter the size of matrix A")
m = int(input())
n = int(input())
print("Enter the size of matrix A")
p = int(input())
q = int(input())
if(n==p):
     print('enter matrix A')
else:
    print("invalid entry")
    exit()
our_list1 = []
A = []
i = 0
int(i)

for i in range(m):
    for i in range(n):
            number = int(input('Please enter a element '))
            our_list1.append(number)
    A.append(our_list1)
    our_list1= []
print(A)
print('enter matrix B')
our_list1 = []
B = []

for i in range(p):
    for i in range(q):
            number = int(input('Please enter a element '))
            our_list1.append(number)
    B.append(our_list1)
    our_list1= []
print(B)
start_time = time.time()

#
our_list1 = []
R = []

for i in range(m):
    for i in range(q):
            number = 0
            our_list1.append(number)
    R.append(our_list1)
    our_list1= []
print(R)
for i in range(len(A)):

    # iterating by coloum by B
    for j in range(len(B[0])):

        # iterating by rows of B
        for k in range(len(B)):
            R[i][j] += A[i][k] * B[k][j]
print(R)
print("--- %s seconds ---" % (time.time() - start_time))

Требуется больше времени для выполнения этого метода умножения матриц, как я могу выбрать эффективный способ умножения матриц огромного диапазона измерений? Таким образом, массив с более высокой размерностью может быть выполнен плавно и быстро. Пример вывода:

Matrix A[[3, 3, 3], [3, 3, 3], [3, 3, 3]]
Matrix B[[3, 3, 3], [3, 3, 3], [3, 3, 3]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[27, 27, 27], [27, 27, 27], [27, 27, 27]]
--- 0.00014400482177734375 seconds ---

Это займет 0,00014400482177734375 секунд. Могу ли я улучшить эту синхронизацию, когда я делаю это для умножения в более высоком измерении?

Answer 1

Эти моменты в ваших комментариях имеют ряд существенных недостатков:

1. print() сравнительно дорог и не имеет ничего общего с расчетом.Включение его в тайминги может занять большую часть общего времени.
2. Использование wallclock (time.time()) не является хорошим способом получения стабильных таймингов;вы получаете один прогон, и все может происходить в вашей системе.

Это должно дать лучший тест для сравнения:

import numpy as np

def python_lists():
    A = [[3, 3, 3], [3, 3, 3], [3, 3, 3]]
    B = [[3, 3, 3], [3, 3, 3], [3, 3, 3]]
    our_list1 = []
    R = []

    for i in range(3):
        for i in range(3):
                number = 0
                our_list1.append(number)
        R.append(our_list1)
        our_list1= []

    for i in range(len(A)):

        # iterating by coloum by B
        for j in range(len(B[0])):

            # iterating by rows of B
            for k in range(len(B)):
                R[i][j] += A[i][k] * B[k][j]


def numpy_array():
    A = np.full((3, 3), 3)
    B = np.full((3, 3), 3)
    result = np.dot(A, B)

И время:

%timeit python_lists()
15 µs ± 45.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit numpy_array()
5.57 µs ± 44.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Итак, NumPy для этого примера в 3 раза быстрее.Но это было бы более важно, если бы у вас были большие массивы.

РЕДАКТИРОВАТЬ: И на самом деле, вы можете утверждать, что создание A и B внутри функции не полезно для синхронизации фактического умножения матриц, так что еслиВместо этого я сначала создаю списки / массивы и передаю их, новые значения времени:

%timeit python_lists(A, B)
14.4 µs ± 98.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit numpy_array(A, B)
1.2 µs ± 13.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

И, для полноты, для массива с формой (200, 200):

%timeit python_lists()
6.99 s ± 128 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit numpy_array()
5.77 ms ± 43.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)