Исходный код

dCode сохраняет право собственности на исходный код онлайн-инструмента «Матричный продукт». За исключением явной лицензии с открытым исходным кодом (обозначенной CC / Creative Commons / бесплатно), любой алгоритм, апплет или фрагмент «Матричного продукта» (конвертер, решатель, шифрование / дешифрование, кодирование / декодирование, шифрование / дешифрование, переводчик) или любой «Матричный продукт» ‘функция (вычислить, преобразовать, решить, расшифровать / зашифровать, расшифровать / зашифровать, декодировать / закодировать, перевести), написанная на любом информационном языке (Python, Java, PHP, C #, Javascript, Matlab и т. д.)), и никакая загрузка данных, скрипт, копирование и доступ к API для «Матричного продукта» не будут бесплатными, то же самое для автономного использования на ПК, планшете, iPhone или Android! dCode распространяется бесплатно и онлайн.

Нужна помощь?

Пожалуйста, посетите наше сообщество dCode Discord для запросов о помощи!
NB: для зашифрованных сообщений проверьте наш автоматический идентификатор шифра!

Вопросы / комментарии

Сводка

Похожие страницы

Поддержка

Форум / Справка

Ключевые слова

произведение, умножение, матрица, скаляр, число, 2×2,2×3,3×2,3×3,3×4,4×3,4×4,5×5

Ссылки

Источник: https: // www.dcode.fr/matrix-multiplication

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

a = np.array ([[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) 

Вывод:

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

Умножение трех матриц будет состоять из двух операций умножения на 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.форма))

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] и БИ 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.shape)) 

Выход:

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

Отличие между np.dot () и np.matmul () заключается в их работе с трехмерными матрицами.
В то время как ‘np.matmul ()’ работает с двумя 3D-матрицами, вычисляя матричное умножение соответствующих пар 2D-матриц (как обсуждалось в последнем разделе), 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

np.random.seed (42)

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

B = np. random.рандинт (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 = {}". format (C, C.shape)) 

Вывод:

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

Оператор «@»

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

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

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

np.random.seed (42)

А = 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.shape))

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

D = A @ B @ C # ранее np.матмул (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 и еще одна матрица 3 x 3 B. Очевидно, мы не можем умножить эти два вместе из-за несоответствия размеров.

Но что, если бы мы захотели умножить подматрицу 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 установить 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.com. Он работает системным администратором Linux с 2010 года. Он отвечает за обслуживание, защиту и устранение неполадок серверов Linux для множества клиентов по всему миру. Он любит писать сценарии оболочки и Python для автоматизации своей работы.

векторов и матриц в квантовых вычислениях — Azure Quantum

• 01.02.2021
• 6 минут для чтения

В этой статье

Некоторое знакомство с векторами и матрицами необходимо для понимания квантовых вычислений. Ниже мы приводим краткое введение, а заинтересованным читателям рекомендуется прочитать стандартный справочник по линейной алгебре, такой как Strang, G.\ dagger $.

Внутренний продукт

Мы можем умножить два вектора вместе с помощью внутреннего произведения , также известного как скалярное произведение или скалярное произведение . Как следует из названия, результатом внутреннего произведения двух векторов является скаляр. Внутренний продукт дает проекцию одного вектора на другой и неоценим для описания того, как выразить один вектор как сумму других более простых векторов. Внутреннее произведение между двумя векторами-столбцами $ u = (u_1, u_2, \ ldots, u_n) $ и $ v = (v_1, v_2, \ ldots, v_n) $, обозначенное $ \ left \ langle u, v \ right \ rangle $ определяется как

$$ \ langle u, v \ rangle = u ^ \ dagger v = \ begin {bmatrix} u_1 ^ * & \ cdots & u_n ^ * \ end {bmatrix} \ begin {bmatrix} v_1 \\ \ vdots \\ v_n \ end {bmatrix} = u_1 ^ {*} v_1 + \ cdots + u_n ^ {*} v_n.

>>> х = нп.массив ([1,5,2])
>>> y = np.array ([7,4,1])
>>> х + у
массив ([8, 9, 3])
>>> х * у
массив ([7, 20, 2])
>>> х - у
массив ([- 6, 1, 1])
>>> х / у
массив ([0, 1, 2])
>>> x% y
массив ([1, 1, 0])
 

>>> x = np.array ([3,2])
>>> y = np.array ([5,1])
>>> г = х + у
>>> г
массив ([8, 3])
>>>
 

>>> x = np.array ([1,2,3])
>>> у = нп.массив ([- 7,8,9])
>>> np.dot (x, y)
36
>>> точка = np.dot (x, y)
>>> x_modulus = np.sqrt ((x * x) .sum ())
>>> y_modulus = np.sqrt ((y * y) .sum ())
>>> cos_angle = dot / x_modulus / y_modulus # косинус угла между x и y
>>> угол = np.arccos (cos_angle)
>>> угол
0,80823378
2499
>>> angle * 360/2 / np.pi # угол в градусах
46.308384970187326
>>>
 

>>> x = np.array (((2,3), (3, 5)))
>>> y = np.array (((1,2), (5, -1)))
>>> х * у
массив ([[2, 6],
       [15, -5]])
>>> x = np.matrix (((2,3), (3, 5)))
>>> y = np.matrix (((1,2), (5, -1)))
>>> х * у
матрица ([[17, 1],
        [28, 1]])
 

>>> х = нп.массив (((2,3), (3, 5)))
>>> y = np.matrix (((1,2), (5, -1)))
>>> np.dot (x, y)
матрица ([[17, 1],
        [28, 1]])
 

>>> np.mat (x) * np.mat (y)
матрица ([[17, 1],
        [28, 1]])
 

>>> NumPersons = np.array ([[100,175,210], [90,160,150], [200,50,100], [120,0,310]])
>>> Price_per_100_g = np.array ([2.98,3.90,1.99])
>>> Price_in_Cent = np.dot (NumPersons, Price_per_100_g)
>>> Price_in_ Euro = Price_in_Cent / np.array ([100,100,100,100])
>>> Price_in_Euro
массив ([13.984, 11,907, 9,9, 9,745])
>>>
 

>>> x = np.array ([0,0,1])
>>> y = np.array ([0,1,0])

>>> np.cross (x, y)
массив ([- 1, 0, 0])

>>> np.cross (y, x)
массив ([1, 0, 0])