Умножение матриц является фундаментальной операцией в линейной алгебре.
Обычно мы используем его во многих приложениях, таких как обработка изображений, машинное обучение и многие другие. NumPy — известный пакет Python для научных вычислений.
Однако в этом посте мы рассмотрим различные методы умножения матриц в Python без использования NumPy.
мы будем использовать вложенные циклы, встроенная функция map() и понимание списка.
Кроме того, мы рассмотрим преимущества и недостатки каждой стратегии, а также когда применять каждую из них. Если вы новичок в линейной алгебре и хотите узнать больше об умножении матриц; продолжайте читать.
Где мы используем умножение матриц?
Умножение матриц используется в компьютерная графика изменять 2D и 3D изображения. Например, вы можете вращать, масштабировать и перемещать объекты на экране. Матрицы используются при обработке изображений для представления изображений в виде массивов пикселей. Кроме того, матрицы могут использоваться для проведения таких операций, как фильтрация изображений.
Мы также используем матрицы в обучение с помощью машины. Они могут помочь нам представить данные и параметры модели. Мы можем выполнять множество операций, таких как вычисление скалярных произведений и матрично-векторных произведений.
Несомненно, эта операция очень выгодна и в научных операциях. Мы можем использовать его в физике и технике для описания физических величин. Следовательно, мы можем оперировать векторами и тензорами.
Почему мы не можем использовать NumPy?
В то время как NumPy является Библиотека 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() и анализе списка.
Лучшая стратегия будет зависеть от конкретных потребностей вашего проекта.
Каждая из стратегий имеет свои плюсы и минусы. Чтобы убедиться, что функция работает правильно, рекомендуется добавить несколько тестовых случаев с различными размерами и значениями матрицы.
Вы также должны включить некоторые тесты производительности, чтобы сравнить, насколько хорошо эти методы работают.
Оставьте комментарий