Як множити матриці: Знаходження добутку матриць

Покажите, что XYeqYXXY eq YXXYeqYX, если

Сначала мы вычисляем левую часть уравнения. Вычисление XYXYXY дает нам:

Теперь вычисляя правую часть уравнения, мы имеем:

Как видите,

Потому что у нас

Эти две матрицы совершенно разные.

Теперь есть еще несколько свойств умножения матриц. Однако эти свойства имеют дело с нулевой и единичной матрицами.

Умножение матрицы на нулевую матрицу

Свойство умножения матриц для нулевой матрицы утверждает следующее:

, где ООО – нулевая матрица.

Это означает, что если вы умножите нулевую матрицу на другую ненулевую матрицу, то вы получите нулевую матрицу. Давайте проверим, так ли это на примере.

Вопрос 9 : Покажите, что уравнение OX = OOX = OOX = O и XO = OXO = OXO = O выполняется, если:

Давайте сначала посмотрим на уравнение

Обратите внимание, что вычисление OXOXOX дает нам:

Мы видим, что OX = OOX = OOX = O, поэтому уравнение выполняется. Аналогично, если мы посчитаем XOXOXO, мы получим:

Мы видим, что уравнение XO = OXO = OXO = O выполняется, так что мы закончили.

Умножение матриц для идентификационной матрицы

А как насчет свойства умножения матриц для единичных матриц? Что ж, в собственности указано следующее:

, где InI_ {n} In – единичная матрица размера n × nn \ умноженная на nn × n.Опять же, мы можем видеть, что следующие уравнения действительно выполняются на примере.

Вопрос 10 : Покажите, что уравнения XI2 = XX I_ {2} = XXI2 = X и I2X = XI_ {2} X = XI2 X = X выполняются со следующими матрицами

Итак, для уравнения XI2 = XX I_ {2} = XXI2 = X, мы имеем:

Итак, уравнение верно. Аналогично уравнению I2X = XI_ {2} X = XI2 X = X, имеем:

Опять же, уравнение верно. Итак, мы закончили с вопросом, и оба уравнения верны. На этом завершаются все свойства умножения матриц. Теперь, если вы хотите взглянуть на реальное применение умножения матриц, я рекомендую вам взглянуть на эту статью.

https://www.mathsisfun.com/algebra/matrix-multiplying.html

20+ примеров умножения матриц NumPy

В этом руководстве мы рассмотрим различные способы выполнения умножения матриц с использованием массивов NumPy.Мы научимся перемножать матрицы разного размера вместе.

Кроме того, мы узнаем, как ускорить процесс умножения с помощью графического процессора и других актуальных тем, так что приступим!

Прежде чем двигаться дальше, лучше рассмотреть некоторые основные термины матричной алгебры.

Основные термины

Вектор: С алгебраической точки зрения вектор – это набор координат точки в пространстве.
Таким образом, вектор с двумя значениями представляет точку в 2-мерном пространстве.В информатике вектор – это расположение чисел в одном измерении. Он также широко известен как массив, список или кортеж.
Например. [1,2,3,4]

Матрица: Матрица (множественные матрицы) – это двумерное расположение чисел или набор векторов.
Пример:

 [[1,2,3],
[4,5,6],
[7,8,9]] 

Точечное произведение: Скалярное произведение – это математическая операция между двумя векторами равной длины .
Он равен сумме произведений соответствующих элементов векторов.

С ясным пониманием этой терминологии, мы готовы к работе.

Умножение матрицы на вектор

Начнем с простой формы умножения матриц – между матрицей и вектором.

Прежде чем продолжить, давайте сначала разберемся, как создать матрицу с помощью NumPy.

Метод NumPy array () используется для представления векторов, матриц и многомерных тензоров. Давайте определим 5-мерный вектор и матрицу 3 × 3 с помощью NumPy.

 импортировать numpy как np

a = np.array ([1, 3, 5, 7, 9])

b = np.array ([[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]])

print ("Вектор a: \ n", a)

Распечатать()

print ("Матрица b: \ n", b) 

Выход:

Давайте теперь посмотрим, как происходит умножение матрицы и вектора.

При умножении матрицы на вектор следует учитывать следующие моменты:

1. Результатом умножения матрицы на вектор является вектор.
2. Каждый элемент этого вектора получается путем скалярного произведения между каждой строкой матрицы и умножаемым вектором.
3. Количество столбцов в матрице должно быть равно количеству элементов в векторе.

Мы будем использовать метод NumPy matmul () для большинства операций умножения матриц.
Давайте определим матрицу 3 × 3 и умножим ее на вектор длины 3.

 импортировать numpy как np

а = нп.массив ([[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]])
b = np.array ([10, 20, 30])

print ("A =", a)

print ("b =", b)

print ("Ab =", np.matmul (a, b)) 

Вывод:

Обратите внимание, что результатом является вектор длины, равной строкам матрицы умножителя.

Умножение на другую матрицу

Теперь мы поняли умножение матрицы на вектор; было бы легко вычислить умножение двух матриц.
Но перед этим давайте рассмотрим самые важные правила умножения матриц:

1. Количество столбцов в первой матрице должно быть равно количеству строк во второй матрице.
2. Если мы умножаем матрицу размеров m x n на другую матрицу размеров n x p, то полученный продукт будет матрицей размеров m x p.

Давайте рассмотрим умножение матрицы A размера m x n на матрицу B размера n x p:
Произведение двух матриц C = AB будет иметь m строк и p столбцов.
Каждый элемент в матрице произведения C является результатом скалярного произведения между вектором-строкой в ​​A и вектором-столбцом в B.

Давайте теперь выполним матричное умножение двух матриц в Python, используя NumPy.
Мы случайным образом сгенерируем две матрицы размеров 3 x 2 и 2 x 4.
Мы будем использовать метод np.random.randint () для генерации чисел.

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 15, размер = (3,2))

B = np.random.randint (0, 15, размер = (2,4))

print ("Матрица A: \ n", A)

print ("shape of A =", A.shape)

Распечатать()

print ("Матрица B: \ n", B)

print ("shape of B =", B.shape) 

Вывод:

Примечание: мы устанавливаем случайное начальное число с помощью np.random.seed (), чтобы сделать генератор случайных чисел детерминированным.
При каждом запуске этого фрагмента кода будут генерироваться одни и те же случайные числа. Этот шаг важен, если вы хотите воспроизвести результат позже.

Вы можете установить любое другое целое число в качестве начального числа, но я предлагаю установить его на 42 для этого руководства, чтобы ваш вывод соответствовал показанным на снимках экрана вывода.

Теперь перемножим две матрицы с помощью метода np.matmul () . Полученная матрица должна иметь форму 3 x 4.

 C = np.matmul (A, B)

print ("произведение A и B: \ n", C)

print ("shape of product =", C.shape) 

Выход:

Умножение трех матриц

Умножение трех матриц будет состоять из двух операций 2-матричного умножения, и каждая из этих двух операций будет следовать тем же правилам, что обсуждались в предыдущем разделе.

Допустим, мы перемножаем три матрицы A, B и C, и получаем произведение D = ABC.
Здесь количество столбцов в A должно быть равно количеству строк в B, а количество строк в C должно быть равно количеству столбцов в B.

Результирующая матрица будет иметь строки, равные количеству строк в A, и столбцы, равные количеству столбцов в C.

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

Например, в нашем примере умножения трех матриц D = ABC не имеет значения, выполняем ли мы сначала AB или сначала BC.

Оба заказа дадут одинаковый результат. Давайте сделаем пример на Python.

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 10, размер = (2,2))

B = np.random.randint (0, 10, размер = (2,3))

C = np.random.randint (0, 10, размер = (3,3))

print ("Матрица A: \ n {}, shape = {} \ n" .format (A, A.shape))

print ("Матрица B: \ n {}, shape = {} \ n" .format (B, B.shape))

print ("Матрица C: \ n {}, shape = {} \ n" .format (C, C.shape)) 

Вывод:

На основе правил, которые мы обсуждали выше, умножение этих трех матриц должно дать результирующую матрицу формы (2, 3).
Обратите внимание, что метод np.matmul () принимает только две матрицы в качестве входных данных для умножения, поэтому мы вызовем метод дважды в том порядке, в котором мы хотим умножить, и передадим результат первого вызова в качестве параметра методу второй.
(Мы найдем лучший способ решения этой проблемы в следующем разделе, когда введем оператор «@»)

Давайте произведем умножение в обоих порядках и проверим свойство ассоциативности.

 D = np.matmul (np.matmul (A, B), C)

print ("Результат умножения в порядке (AB) C: \ n \ n {}, shape = {} \ n" .format (D, D.shape))

D = np.matmul (A, np.matmul (B, C))

print ("Результат умножения в порядке A (BC): \ n \ n {}, shape = {}". format (D, D.shape)) 

Вывод:

Как мы видим, результат умножения трех матриц остается неизменным независимо от того, умножаем ли мы сначала A и B или сначала B и C.
Таким образом, свойство ассоциативности подтверждается.
Кроме того, форма результирующего массива (2, 3) находится на ожидаемых строках.

Умножение 3D-матриц NumPy

3D-матрица – это не что иное, как набор (или стек) множества 2D-матриц, точно так же, как 2D-матрица представляет собой набор / стек многих одномерных векторов.

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

Давайте рассмотрим пример матрицы A формы (3,3,2), умноженной на другую трехмерную матрицу B формы (3,2,4).

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 10, размер = (3,3,2))

B = np.random.randint (0, 10, размер = (3,2,4))

print ("A: \ n {}, shape = {} \ nB: \ n {}, shape = {}". format (A, A.shape, B, B.shape)) 

Вывод:

Первая матрица представляет собой стопку из трех 2D-матриц, каждая из которых имеет форму (3,2), а вторая матрица представляет собой стопку из 3 2D-матриц, каждая из которых имеет форму (2,4).

Умножение матриц между этими двумя будет включать три умножения между соответствующими двумерными матрицами A и B, имеющими формы (3,2) и (2,4) соответственно.

В частности, первое умножение будет между A [0] и B [0], второе умножение будет между A [1] и B [1], и, наконец, третье умножение будет между A [2] и B. [2].

Результат каждого отдельного умножения 2D-матриц будет иметь форму (3,4). Следовательно, конечный продукт двух 3D-матриц будет матрицей формы (3,3,4).

Давайте реализуем это с помощью кода.

 C = np.matmul (A, B)

print ("Продукт C: \ n {}, shape = {}". format (C, C.shape)) 

Выход:

Альтернативы np.matmul ()

Помимо «np.matmul ()», есть два других способа выполнения матричного умножения – метод np.dot () и оператор «@» , каждый из которых предлагает некоторые различия / гибкость в операциях умножения матриц.

Метод «np.dot ()»

Вы можете использовать этот метод для нахождения скалярного произведения векторов, но если мы передадим две двумерные матрицы, то он будет вести себя аналогично «np.matmul () ’и вернет результат матричного умножения двух матриц.

Давайте посмотрим на пример:

 импортировать numpy как np

# матрица 3x2
A = np.array ([[8, 2, 2],
             [1, 0, 3]])

# матрица 2x3
B = np.array ([[1, 3],
             [5, 0],
             [9, 6]])

# точечный продукт должен возвращать продукт 2x2
C = np.dot (A, B)

print ("произведение A и B: \ n {} shape = {}". format (C, C.форма)) 

Выход:

Здесь мы определили матрицу 3 × 2, а матрицу 2 × 3 и их скалярное произведение дает результат 2 × 2, который представляет собой матричное умножение двух матриц,
то же самое, что и what ‘np .matmul () ‘вернулся бы.

разница между np.dot () и np.matmul () заключается в их работе с трехмерными матрицами.
В то время как «np.matmul ()» работает с двумя трехмерными матрицами путем вычисления матричного умножения соответствующих пар двумерных матриц (как обсуждалось в последнем разделе), np.dot (), с другой стороны, вычисляет скалярные произведения различных пар векторов-строк и векторов-столбцов из первой и второй матрицы соответственно.

np.dot () на двух 3D-матрицах A и B возвращает произведение суммы по последней оси A и предпоследней оси B.
Это неинтуитивно и непросто для понимания.

Итак, если A имеет форму (a, b, c), а B имеет форму (d, c, e), то результат np.dot (A, B) будет иметь форму (a, d, b , e) чей индивидуальный элемент в позиции (i, j, k, m) определяется как:

 точка (A, B) [i, j, k, m] = sum (A [i, j ,:] * B [k,:, m]) 

Давайте проверим пример:

 импортировать numpy как np

нп.random.seed (42)

A = np.random.randint (0, 10, размер = (2,3,2))

B = np.random.randint (0, 10, размер = (3,2,4))

print ("A: \ n {}, shape = {} \ nB: \ n {}, shape = {}". format (A, A.shape, B, B.shape)) 

Вывод:

Если мы теперь передадим эти матрицы методу np.dot (), он вернет матрицу формы (2,3,3,4), отдельные элементы которой вычисляются с использованием формулы, приведенной выше. .

 C = np.dot (A, B)

print ("np.dot (A, B) = \ n {}, shape = {}".формат (C, C.shape)) 

Вывод:

Еще одно важное различие между np.matmul () и np.dot () состоит в том, что np.matmul () не позволяет умножать на скаляр (мы обсудим это в следующем section), а np.dot () – позволяет.

Оператор «@»

Оператор @, представленный в Python 3.5, выполняет ту же операцию, что и «np.matmul ()».

Давайте рассмотрим предыдущий пример ‘np.matmul ()’ с использованием оператора @ и увидим тот же результат, что и возвращенный ранее:

 импортировать numpy как np

нп.random.seed (42)

A = np.random.randint (0, 15, размер = (3,2))

B = np.random.randint (0, 15, размер = (2,4))

print ("Матрица A: \ n {}, shape = {}". format (A, A.shape))

print ("Матрица B: \ n {}, shape = {}". format (B, B.shape))

С = А @ В

print ("произведение A и B: \ n {}, shape = {}". format (C, C.shape)) 

Вывод:

Оператор ‘@’ становится удобным, когда мы выполняем матричное умножение более двух матриц.

Раньше нам приходилось звонить np.matmul () ’несколько раз и передать их результаты в качестве параметра следующему вызову.
Теперь мы можем выполнить ту же операцию более простым (и более интуитивным) способом:

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 10, размер = (2,2))

B = np.random.randint (0, 10, размер = (2,3))

C = np.random.randint (0, 10, размер = (3,3))

print ("Матрица A: \ n {}, shape = {} \ n" .format (A, A.shape))

print ("Матрица B: \ n {}, shape = {} \ n" .format (B, B.форма))

print ("Матрица C: \ n {}, shape = {} \ n" .format (C, C.shape))

D = A @ B @ C # ранее np.matmul (np.matmul (A, B), C)

print ("Продукт ABC: \ n \ n {}, shape = {} \ n" .format (D, D.shape)) 

Выход:

Умножение на скаляр (одно значение)

Итак, мы выполнили умножение матрицы на вектор или другую матрицу. Но что происходит, когда мы выполняем матричное умножение на скалярное или одно числовое значение?

Результат такой операции получается умножением каждого элемента в матрице на скалярное значение.Таким образом, выходная матрица имеет тот же размер, что и входная матрица.

Обратите внимание, что «np.matmul ()» не позволяет умножать матрицу на скаляр. Этого можно добиться, используя метод np.dot () или оператор ‘*’.

Давайте посмотрим на это на примере кода.

 импортировать numpy как np

A = np.array ([[1,2,3],
             [4,5, 6],
             [7, 8, 9]])

В = А * 10

print ("Матрица A: \ n {}, shape = {} \ n".формат (A, A.shape))

print ("Умножение A на 10: \ n {}, shape = {}". format (B, B.shape)) 

Выход:

Поэлементное умножение матриц

Иногда мы хотим произвести перемножение соответствующих элементов двух матриц одинаковой формы.

Эта операция также называется произведением Адамара . Он принимает две матрицы одинаковых размеров и создает третью матрицу того же размера.

Вы можете добиться этого, вызвав функцию multiply () в NumPy или используя оператор ‘*’ .

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 10, размер = (3,3))

B = np.random.randint (0, 10, размер = (3,3))

print ("Матрица A: \ n {} \ n" .format (A))

print ("Матрица B: \ n {} \ n" .format (B))

C = np.multiply (A, B) # или A * B

print ("Поэлементное умножение A и B: \ n {}". format (C)) 

Вывод:

Единственное правило, которое вам нужно помнить для поэлементного умножения, состоит в том, что две матрицы должны иметь одинаковую форму .
Однако, если одно измерение матрицы отсутствует, NumPy будет транслировать его, чтобы соответствовать форме другой матрицы.

Фактически, матричное умножение на скаляр также включает в себя широковещательную передачу скалярного значения в матрицу формы, равной операнду матрицы при умножении.

Это означает, что когда мы умножаем матрицу формы (3,3) на скалярное значение 10, NumPy создаст другую матрицу формы (3,3) с постоянными значениями десять во всех позициях в матрице и выполнит поэлементное умножение. между двумя матрицами.

Давайте разберемся с этим на примере:

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 10, размер = (3,4))

B = np.array ([[1,2,3,4]])

print ("Матрица A: \ n {}, shape = {} \ n" .format (A, A.shape))

print ("Матрица B: \ n {}, shape = {} \ n" .format (B, B.shape))

С = А * В

print ("Поэлементное умножение A и B: \ n {}". format (C)) 

Вывод:

Обратите внимание, как вторая матрица, имеющая форму (1,4), была преобразована в матрицу (3,4) посредством широковещательной рассылки, и произошло поэлементное умножение между двумя матрицами.

Матрица в степени (матрица возведения в степень)

Точно так же, как мы можем возвести скалярное значение в экспоненту, мы можем проделать ту же операцию с матрицами.
Подобно тому, как увеличение скалярного значения (основания) до степени n равносильно многократному умножению n оснований, такая же закономерность наблюдается при возведении матрицы в степень, которое включает в себя многократные умножения матриц.

Например, если мы возведем матрицу A в степень n, она будет равна умножению матриц n матриц, каждая из которых будет матрицей A.

Обратите внимание, что для того, чтобы эта операция была возможна, базовая матрица должна быть квадратной .
Это необходимо для обеспечения того, чтобы количество столбцов в предыдущей матрице = количеству строк в следующей матрице.

Эта операция предоставляется в Python с помощью метода NumPy linalg.matrix_power () , который принимает в качестве параметров базовую матрицу и целочисленную степень.

Давайте посмотрим на пример на Python:

 импортировать numpy как np

np.random.seed (10)

А = np.random.randint (0, 10, размер = (3,3))

A_to_power_3 = np.linalg.matrix_power (A, 3)

print ("Матрица A: \ n {}, shape = {} \ n" .format (A, A.shape))

print ("A в степени 3: \ n {}, shape = {}". format (A_to_power_3, A_to_power_3.shape)) 

Вывод:

Мы можем проверить этот результат, выполнив обычное матричное умножение с тремя операндами (все они A), используя оператор «@»:

 В = А @ А @ А

print ("B = A @ A @ A: \ n {}, shape = {}". format (B, B.форма)) 

Вывод:

Как видите, результаты обеих операций совпадают.

Важный вопрос, который возникает в результате этой операции: Что происходит, когда мощность равна 0?
Чтобы ответить на этот вопрос, давайте рассмотрим, что происходит, когда мы возводим скалярное основание в степень 0.
Мы получаем значение 1, верно? Итак, что эквивалентно 1 в матричной алгебре? Вы угадали!

Это единичная матрица.

Итак, возведение матрицы размера n x n в степень 0 приводит к единичной матрице I формы n x n.

Давайте быстро проверим это на Python, используя нашу предыдущую матрицу A.

 C = np.linalg.matrix_power (A, 0)

print ("A в степени 0: \ n {}, shape = {}". format (C, C.shape)) 

Выход:

Поэлементное возведение в степень

Точно так же, как мы можем выполнять поэлементное умножение матриц, мы также можем выполнять поэлементное возведение в степень, то есть возводить каждый отдельный элемент матрицы в некоторую степень.

Это может быть достигнуто в Python с помощью стандартного оператора экспоненты « ** » – пример перегрузки оператора на .мощности: \ n {}, shape = {} \ n “.format (C, C.shape))

Выход:

Умножение на определенный индекс

Предположим, у нас есть матрица A 5 x 6 и еще одна матрица B 3 x 3. Очевидно, мы не можем перемножить эти две матрицы из-за несоответствия размеров.

Но что, если бы мы захотели умножить подматрицу 3 × 3 в матрице A на матрицу B, оставив при этом другие элементы в A неизменными?
Для лучшего понимания см. Следующее изображение:

Эту операцию можно выполнить в Python, используя нарезку матрицы для извлечения подматрицы из A, выполняя умножение на B, а затем записывая результат по соответствующему индексу в A.

Давайте посмотрим на это в действии.

 импортировать numpy как np

np.random.seed (42)

A = np.random.randint (0, 10, размер = (5,6))

B = np.random.randint (0, 10, размер = (3,3))

print ("Матрица A: \ n {}, shape = {} \ n" .format (A, A.shape))

print ("Матрица B: \ n {}, shape = {} \ n" .format (B, B.shape))

C = A [1: 4,2: 5] @ B

A [1: 4,2: 5] = C

print ("Матрица A после умножения подматрицы: \ n {}, shape = {} \ n" .format (A, A.shape)) 

Вывод:

Как видите, только элементы с индексами строк с 1 по 3 и с индексами столбцов со 2 по 4 были умножены на B, и то же самое было записано обратно в A, в то время как остальные элементы A остались. без изменений.

Кроме того, нет необходимости перезаписывать исходную матрицу. Мы также можем записать результат в новую матрицу, сначала скопировав исходную матрицу в новую матрицу, а затем записав произведение в позиции подматрицы.

Умножение матриц с использованием графического процессора

Мы знаем, что NumPy ускоряет матричные операции за счет распараллеливания большого количества вычислений и использования возможностей параллельных вычислений нашего процессора.

Однако современным приложениям нужно нечто большее.ЦП предлагают ограниченные вычислительные возможности, и этого недостаточно для большого количества необходимых нам вычислений, обычно в таких приложениях, как глубокое обучение.

Вот где на сцену выходят графические процессоры. Они предлагают большие вычислительные возможности и отличную инфраструктуру параллельных вычислений, которая помогает нам значительно экономить время, выполняя сотни тысяч операций за доли секунды.

В этом разделе мы рассмотрим, как можно выполнять умножение матриц на графическом процессоре, а не на процессоре, и при этом сэкономить много времени.

NumPy не предлагает функции для матричного умножения на GPU. Поэтому мы должны установить некоторые дополнительные библиотеки, которые помогут нам достичь нашей цели.

Сначала мы установим библиотеки « scikit-cuda » и « PyCUDA » с помощью pip install. Эти библиотеки помогают нам выполнять вычисления на графических процессорах на базе CUDA. Чтобы установить эти библиотеки с вашего терминала, если на вашем компьютере установлен графический процессор.

 pip install pycuda

pip install scikit-cuda 

Если у вас нет графического процессора на вашем компьютере, вы можете попробовать ноутбуки Google Colab и включить доступ к графическому процессору; это бесплатно для использования.Теперь мы напишем код для генерации двух матриц 1000 × 1000 и выполнения матричного умножения между ними двумя способами:

1. Использование метода NumPy « matmul () » на ЦП
2. Использование метода scikit-cuda ‘ linalg.mdot () ‘ на GPU

Во втором методе мы будем генерировать матрицы на CPU; затем мы сохраним их на графическом процессоре (используя метод PyCUDA « gpuarray.to_gpu () ») перед выполнением умножения между ними.Мы будем использовать модуль «, время » для вычисления времени вычисления в обоих случаях.

Использование ЦП

 импортировать numpy как np

время импорта

# создание матриц размером 1000 x 1000
np.random.seed (42)

x = np.random.randint (0,256, размер = (1000,1000)). astype ("float64")

y = np.random.randint (0,256, размер = (1000,1000)). astype ("float64")


# вычисление времени умножения на CPU
tic = time.time ()

г = нп.матмул (х, у)

toc = время.время()

time_taken = toc - tic # время в с

print ("Время, затраченное на CPU (в мс) = {}". format (time_taken * 1000))

 

Выход:

На некоторых старых аппаратных системах вы можете получить ошибку памяти, но если вам повезет, она будет работать долгое время (зависит от вашей системы).

Теперь давайте выполним то же умножение на графическом процессоре и посмотрим, как время вычисления различается между ними.

Использование графического процессора

 # вычисление времени умножения на GPU
linalg.в этом()

# сохранение массивов на GPU
x_gpu = gpuarray.to_gpu (x)

y_gpu = gpuarray.to_gpu (у)

tic = time.time ()

# выполнение умножения
z_gpu = linalg.mdot (x_gpu, y_gpu)

toc = time.time ()

time_taken = toc - tic # время в с

print ("Время, затраченное на GPU (в мс) = {}". format (time_taken * 1000)) 

Вывод:

Как мы видим, выполнение одной и той же операции на графическом процессоре дает нам ускорение в 70 раз по сравнению с процессором.
Это все еще было небольшое вычисление. Для крупномасштабных вычислений графические процессоры дают нам ускорение на несколько порядков.

Заключение

В этом руководстве мы рассмотрели, как происходит умножение двух матриц, правила, управляющие им, и как их реализовать в Python.
Мы также рассмотрели различные варианты стандартного умножения матриц (и их реализацию в NumPy), такие как умножение более двух матриц, умножение только по определенному индексу или степень матрицы.

Мы также рассмотрели поэлементные вычисления в матрицах, такие как поэлементное умножение матриц или поэлементное возведение в степень.

Наконец, мы рассмотрели, как можно ускорить процесс умножения матриц, выполняя его на графическом процессоре.

Основатель LikeGeeks. Я работаю системным администратором Linux с 2010 года. Я отвечаю за обслуживание, защиту и устранение неполадок серверов Linux для множества клиентов по всему миру. Я люблю писать сценарии оболочки и Python для автоматизации моей работы.

Скалярное и матричное умножение

Это замечательно, поскольку количество столбцов матрицы E равняется количеству строк матрицы F. Это означает, что произведение EF определено, поэтому мы можем продолжить и выполнить умножение матриц. См. Ниже анимированное пошаговое решение умножения матриц.

Пример 3 : Рассчитайте, если возможно, произведение F и E.

В нашем предыдущем примере мы успешно получили продукт EF.На этот раз мы хотим выяснить, сможем ли мы найти произведение E [латекс] и [латекс] F в указанном порядке.

Напоминаем, что действительные числа коммутативны при операции умножения, что означает, что порядок умножения не влияет на конечный результат. Например …

Таким образом, возникает большой вопрос, работает ли это также при матричном умножении?

Проверим, равно ли количество столбцов матрицы F количеству строк матрицы E.

количество столбцов = 2

количество строк = 3

Очевидно, что количество столбцов матрицы F не равно количеству строк матрицы E.Подразумевается, что произведение FE не может быть вычислено, поэтому не определено!

В общем случае умножение матриц не коммутативно.

Пример 4 : Рассчитайте, если возможно, произведение AE.

Стандартный способ описать размер или размерность матрицы – это …

(указать количество строк) x (указать количество столбцов)

… читается как «количество строк по количеству столбцов».

3 x 3 (матрица три на три)

3 x 2 (матрица три на два)

Поскольку количество столбцов в матрице A , равное , равно количеству строк в матрице E , равному , мы заключаем, что произведение AE определено.

Давайте разберемся. См. Анимированное решение ниже.

Пример 5 : Рассчитайте, если возможно, произведение E и A.

3 x 2 (матрица три на два)

3 x 3 (матрица три на три)

Очевидно, что количество столбцов матрицы E не равно количеству столбцов матрицы A. Следовательно, произведение EA не может быть вычислено или не определено.

Пример 6 : Вычислить, если возможно, произведение D и F.2}. Другими словами, мы возводим в квадрат матрицу C.

Здесь нужно проявлять осторожность. Обратите внимание, что возвести в квадрат можно только квадратную матрицу. Напомним, квадратная матрица – это матрица, в которой номер строки равен номеру столбца.

Я предоставлю вам возможность проверить правильность приведенного ниже решения. Такие математические задачи, как эта, хотя и утомительны, я всегда рекомендую решать их вручную, используя карандаш и бумагу.