Матричното умножение е основна операция в линейната алгебра.
Обикновено го използваме в множество приложения като обработка на изображения, машинно обучение и много други. NumPy е забележителен пакет на Python за научни изчисления.
В тази публикация обаче ще разгледаме различни методи за извършване на умножение на матрици в Python без използване на NumPy.
Ние ще използваме вложени цикли, вградената функция map() и разбиране на списък.
Освен това ще разгледаме предимствата и недостатъците на всяка стратегия, както и кога да приложим всяка от тях. Ако сте нов в линейната алгебра и искате да научите повече за умножението на матрици; продължавай да четеш.
Къде използваме матрично умножение?
Матричното умножение се използва в компютърна графика за промяна на 2D и 3D визуализации. Например, можете да завъртате, мащабирате и премествате обекти на екрана. Матриците се използват при обработката на изображения, за да представят изображения като масиви от пиксели. Освен това матриците могат да се използват за извършване на операции като филтриране на изображения.
Ние също така използваме матрици в машинно обучение. Те могат да ни помогнат да представим данните и параметрите на модела. Можем да извършваме множество операции, като изчисляване на точкови продукти и матрично-векторни продукти.
Със сигурност тази операция е много полезна и в научните операции. Можем да го използваме във физиката и инженерството, за да опишем физически величини. Следователно можем да оперираме с вектори и тензори.
Защо може да не изберем да използваме NumPy?
Докато NumPy е a Библиотека на Python, не винаги е идеалният вариант за матрично умножение. Може да не изберем да използваме NumPy поради причини като размер и зависимост, обучение и наследени системи.
Използването на вградените функции на Python или разработването на персонализиран код може да бъде по-ефективно в някои случаи. Важно е обаче да се отбележи, че NumPy е силна библиотека. Освен това можете да го използвате и за умножение на матрици.
Сега нека да разгледаме как можем да постигнем умножение на матрици без NumPy.
Метод на вложени цикли
Техниката на вложените цикли използва вложени цикли за изпълнение на умножение на матрици в Python. Функцията итерира всеки матричен елемент. И ги умножава с помощта на поредица от вложени цикли. Функцията връща резултата, който се съхранява в нова матрица.
Този подход е лесен за разбиране. Въпреки това, той може да не е толкова ефективен, колкото други начини, особено за по-големи матрици. И все пак това е прекрасен избор за вас, ако сте нов в линейната алгебра.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Задайте матрицата на резултатите на нули.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
Нека да дадем пример как да направите това. Можете просто да добавите тези редове код по-долу, за да тествате този пример.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
Ползи:
- Лесен за разбиране.
- Чудесно за начинаещи или за тези, които търсят по-задълбочено разбиране на матричното умножение.
Недостатъци:
- Не е толкова ефективен като алтернативните техники, особено за по-големи матрици.
- Не е толкова четим като алтернативните подходи.
метод на функцията map().
Функционалният метод map() предоставя алтернативен подход за извършване на умножение на матрици в Python. При този подход използваме вградената функция map(). Следователно ние използваме инструмент за функционално програмиране, който прилага предоставена функция към всеки итерируем елемент (списък, кортеж и т.н.). Освен това функцията map() приема два параметъра, функция и итерируем. И връща итератор, който прилага функцията към всеки итерируем елемент.
При този подход преминаваме през всеки член на матрицата и извършваме умножението с помощта на вложената функция map().
Функцията zip() се използва за итерация през всеки елемент от матриците паралелно.
И накрая, функцията sum() се използва за събиране на резултатите.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
Сега отново можем да тестваме нашия код с пример.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
Предимства
- По-ефективен от подхода на подредените цикли
- Той използва функционално програмиране, за да направи кода по-прост.
Недостатъци
- Някои хора, които не са запознати с функционалното програмиране, може да го намерят за по-малко четливо.
- Това е по-малко разбираемо от техниката на вложените цикли.
Метод за разбиране на списък
Разбирането на списъци ви позволява да генерирате нов списък в един ред код. Следователно, това е чрез прилагане на израз към всеки член на съществуващ списък.
При този подход умножението се извършва чрез многократно повторение през всеки член на матрицата. Ние използваме разбиране на слоест списък.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
Ползи
- В сравнение с метода на функцията map(), по-кратък и по-четлив.
Недостатъци
- Може да е по-малко ефективно от използването на функцията map(), особено за големи матрици.
- По-трудно е от подхода на вложените цикли.
Заключение
В тази публикация разгледахме алтернативи на използването на NumPy при умножаване на матрици в Python. Извършихме умножение на матрици във вложени цикли, вградената функция map() и разбиране на списък.
Най-добрата стратегия ще разчита на конкретните нужди на вашия проект.
Всяка от стратегиите има своите плюсове и минуси. За да сте сигурни, че функцията работи правилно, добра идея е да добавите няколко тестови случая с различни размери и стойности на матрицата.
Трябва също да включите някои тестове за ефективност, за да сравните колко добре се изпълняват тези методи.
Оставете коментар