Скалярное произведение векторов python: Вычисляем скалярное произведение векторов при помощи numpy.dot()

alexxlab / / Разное

dot | NumPy

numpy.dot(a, b, out=None)

Функция dot() вычисляет скалярное произведение двух массивов.

Перед использованием данной функции необходимо учитывать следующие нюансы:

  • Если a или b является числом, то np.dot(a, b) становится эквивалентна функции np.multiply(a, b) или команде a*b, которые являются более предпочтительными;
  • Если a или b являются одномерными массивами, т.е. векторами, то выполняется внутреннее (по сути скалярное) произведение векторов и np.dot(a, b) становится эквивалентна функции np.inner(a, b), но без поддержки комплексных чисел.
  • Если a — это N-мерный массив,
    b     — это одномерный массив, то сумма произведений элементов a и b вычисляется по последней оси a.
  • Если a и b являются двумерными массивами, т.е. матрицами, то выполняется матричное умножение и np.dot(a, b) становится эквивалентна функции np.matmul(a, b) или команде a@b, которые являются более предпочтительными;
  • Если a — это N-мерный массив, а b — это M-мерный массив (при условии, что M >= 2), то вычисляется сумма произведений элементов последней оси a и элементов со второй по последнюю осей b, т.е. эквивалентно команде: dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
Параметры:
a, b — числа, массивы NumPy или подобные массивам объекты.
Входные данные.
out — массив NumPy, необязательный параметр.
Массив в который можно поместить результат функции. Данный массив должен соответствовать форме и типу данных результирующего массива функции, а так же обязательно быть C-смежным, т.е. хранить данные в строчном С стиле. Указание данного параметра, позволяет избежать лишней операции присваивания тем самым немного ускоряя работу вашего кода. Полезный параметр если вы очень часто обращаетесь к функции в цикле.
Возвращает:
результат — массив NumPy или число
Скалярное произведение a и b. Если это числа или одномерные массивы, то возвращается число, в противном случае возвращается массив.

Замечание

Длина последней оси массива a, а так же длина всех осей массива b кроме первой должны совпадать, иначе возникнет исключение ValueError.

Смотрите так же:
vdot, linalg.multi_dot, matmul

Примеры

Умножение числа на число или числа на массив:

>>> import numpy as np
>>> 
>>> np.dot(2, 2)
4
>>> 
>>> np.dot(2, [2, 3, 4])
array([4, 6, 8])    #  Лучше использовать np.multiply() или a*b

Умножение одномерных массивов (векторов):

>>> a = np.array([2, 3, 4])
>>> b = np.array([5, 6, 7])
>>> 
>>> np.dot(a, b)
56
>>> #  Эквивалентно:
... np.inner(a, b)    #  предпочтительнее
56
>>> 
>>> #  Эквивалентно:
... np.sum(a*b)
56

Умножение двумерных массивов (матриц):

>>> a = np.arange(1, 7).reshape(2, 3)
>>> a
array([[1, 2, 3],
       [4, 5, 6]])
>>> 
>>> b = np. arange(1, 7).reshape(3, 2)
>>> b
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> 
>>> np.dot(a, b)
array([[22, 28],
       [49, 64]])
>>> 
>>> np.dot(b, a)
array([[ 9, 12, 15],
       [19, 26, 33],
       [29, 40, 51]])
>>> 
>>> #  Эквивалентно:
...np.matmul(a, b)        #  предпочтительнее
array([[22, 28],
       [49, 64]])

Умножение одномерного массива на двумерные и многомерные:

>>> a = np.array([2, 3])
>>> b = np.array([[1, 2], [3, 4]])
>>> 
>>> np.dot(a, b)
array([11, 16])
>>> 
>>> c = np.arange(1, 7).reshape(2, 3)
>>> c
array([[1, 2, 3],
       [4, 5, 6]])
>>> 
>>> np.dot(a, c)
array([14, 19, 24])
>>>
>>> np.dot(c, a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shapes (2,3) and (2,) not aligned: 3 (dim 1) != 2 (dim 0)
>>>
>>> #  Длина последней оси 'c' должна совпадать с длиной 'a':
>>> c = c.
  reshape(3, 2)
>>> c
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> 
>>> np.dot(c, a)
array([ 8, 18, 28])
>>> a
array([2, 3])
>>>
>>>
>>> d = np.arange(1, 13).reshape(3, 2, 2)
>>> d
array([[[ 1,  2],
        [ 3,  4]],
       [[ 5,  6],
        [ 7,  8]],
       [[ 9, 10],
        [11, 12]]])
>>> 
>>> np.dot(a, d)
array([[11, 16],
       [31, 36],
       [51, 56]])
>>> np.dot(d, a)
array([[ 8, 18],
       [28, 38],
       [48, 58]])
>>> 
>>>
>>> d = np.arange(1, 13).reshape(2, 3, 2)
>>> d
array([[[ 1,  2],
        [ 3,  4],
        [ 5,  6]],
       [[ 7,  8],
        [ 9, 10],
        [11, 12]]])
>>> 
>>> np.dot(a, d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shapes (2,) and (2,3,2) not aligned: 2 (dim 0) != 3 (dim 1)
>>> np.dot(d, a)
array([[ 8, 18, 28],
       [38, 48, 58]])
>>>
>>>
>>> d = np.

  

  
 arange(1, 13).reshape(2, 2, 3)
>>> d
array([[[ 1,  2,  3],
        [ 4,  5,  6]],
       [[ 7,  8,  9],
        [10, 11, 12]]])
>>> 
>>> np.dot(a, d)
array([[14, 19, 24],
       [44, 49, 54]])
>>> np.dot(d, a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shapes (2,2,3) and (2,) not aligned: 3 (dim 2) != 2 (dim 0)

Скалярное произведение многомерных массивов:

>>> a = np.arange(3*2*4).reshape(3, 2, 4)
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],
       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]],
       [[16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> 
>>> b = np.arange(2*4*4).reshape(2, 4, 4)
>>> b
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15]],
       [[16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27],
        [28, 29, 30, 31]]])
>>> 
>>> np.
  dot(a, b)
array([[[[  56,   62,   68,   74],
         [ 152,  158,  164,  170]],
        [[ 152,  174,  196,  218],
         [ 504,  526,  548,  570]]],
       [[[ 248,  286,  324,  362],
         [ 856,  894,  932,  970]],
        [[ 344,  398,  452,  506],
         [1208, 1262, 1316, 1370]]],
       [[[ 440,  510,  580,  650],
         [1560, 1630, 1700, 1770]],
        [[ 536,  622,  708,  794],
         [1912, 1998, 2084, 2170]]]])

примеры вычисления скалярного произведения массивов

Автор В. Дронов

/

02.04.2021

/

Библиотеки Python / Статьи по теме: Numpy

Чтобы вычислить скалярное произведение массивов numpy nd, вы можете использовать функцию numpy.dot() в Python. Она принимает в качестве аргументов два массива numpy, вычисляет их скалярное произведение и возвращает результат.

Синтаксис

Синтаксис метода numpy.dot():

numpy.dot(a, b, out=None)
ПараметрОписание
a[обязательный] Первый аргумент для операции скалярного произведения.
b[обязательный] Второй аргумент для операции скалярного произведения.
out[необязательно] Этот аргумент используется для оценки производительности. Это должен быть C-смежный массив, а dtype должен быть тем dtype, который будет возвращен для точки (a, b).

На основе размеров входного массива

В следующей таблице указывается тип выполняемой операции на основе размеров входных массивов: a и b.

Размерности «a» и «b»Выход
Нулевое измерение (скалярное)Умножение двух скаляров a и b.
Одномерные массивы (вектор)Внутреннее произведение векторов.
Двумерные массивы (матрица)Умножение матриц.
a: N-мерный массив, b: 1-мерный массивСуммируйте произведение по последней оси a и b.
a: N-мерный массив, b: M-мерный массив (M> = 2)Суммируйте произведение по последней оси a и предпоследней оси b.

Пример 1: произведение скаляров с несколькими точками

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

import numpy as np

a = 3 
b = 4
output = np.dot(a,b)
print(output)

Вывод:

12

Объяснение:

output = a * b
       = 3 * 4
       = 12

Пример 2: произведение числовых точек одномерных массивов

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

import numpy as np

#initialize arrays
A = np.array([2, 1, 5, 4])
B = np.array([3, 4, 7, 8])

#dot product
output = np.dot(A, B)

print(output)

Вывод:

77

Скалярное произведение:

output = [2, 1, 5, 4].[3, 4, 7, 8]
       = 2*3 + 1*4 + 5*7 + 4*8
       = 77

Пример 3: произведение числовых точек двумерных массивов

В этом примере мы берем два двумерных массива numpy и вычисляем их скалярное произведение. Точечное произведение двух двумерных массивов возвращает матричное умножение двух входных массивов.

import numpy as np

#initialize arrays
A = np.array([[2, 1], [5, 4]])
B = np. array([[3, 4], [7, 8]])

#dot product
output = np.dot(A, B)

print(output)

Вывод:

[[13 16]
 [43 52]]

Скалярное произведение:

output = [[2, 1], [5, 4]].[[3, 4], [7, 8]]
       = [[2*3+1*7, 2*4+1*8], [5*3+4*7, 5*4+4*8]]
       = [[13, 16], [43, 52]]

В этом руководстве на примерах Python мы узнали, как вычислить скалярное произведение массивов numpy с помощью примеров программ.

This div height required for enabling the sticky sidebar

numpy.dot — NumPy v1.24 Руководство

numpy.dot( a , b , out=None )

Скалярное произведение двух массивов. В частности,

  • Если оба числа a и b являются одномерными массивами, то это внутреннее произведение векторов (без комплексного сопряжения).

  • Если оба a и b являются двумерными массивами, это матричное умножение, но используя matmul или a@b является предпочтительным.

  • Если либо a , либо b являются 0-D (скалярными), это эквивалентно умножить и использовать numpy.multiply(a, b) или a * b предпочтительно.

  • Если a представляет собой массив N-D, а b представляет собой массив 1-D, это произведение суммы по последняя ось a и b .

  • Если , то — массив N-D, а b — массив M-D (где M>=2 ), это сумма произведений по последней оси a и предпоследней оси б :

     точка (a, b) [i, j, k, m] = сумма (a [i, j,:] * b [k,:, m])

По возможности использует оптимизированную библиотеку BLAS (см. numpy.linalg ).

Параметры:
a array_like

Первый аргумент.

b array_like

Второй аргумент.

out ndarray, необязательный

Выходной аргумент. Это должно иметь точный вид, который будет возвращен если он не использовался. В частности, он должен иметь правильный тип, должен быть C-непрерывный, и его dtype должен быть возвращенным dtype для точка(а,б) . Это особенность производительности. Следовательно, если эти условия не выполняются, вместо попытки быть гибким.

Возвращает:
output ndarray

Возвращает скалярное произведение a и b . Если a и b оба скаляры или оба одномерных массива, то возвращается скаляр; в противном случае возвращается массив. Если дано из , то возвращается.

Поднимает:
ValueError

Если последнее измерение или не совпадает с размером предпоследнее измерение б .

См. также

vdot

Комплексно-сопряженное скалярное произведение.

тензордот

Сумма произведений по произвольным осям.

einsum

Соглашение Эйнштейна о суммировании.

matmul

Оператор @ как метод без параметра.

linalg.multi_dot

Скалярное произведение.

Примеры

 >>> np.dot(3, 4)
12

Ни один из аргументов не является комплексно сопряженным:

 >>> np.dot([2j, 3j], [2j, 3j])
(-13+0j)

Для двумерных массивов это матричное произведение:

 >>> а = [[1, 0], [0, 1]]
>>> b = [[4, 1], [2, 2]]
>>> нп.точка (а, б)
массив([[4, 1],
       [2, 2]])
 
 >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
>>> np.dot(a, b)[2,3,2,1,2,2]
499128
>>> сумма(а[2,3,2,:] * б[1,2,:,2])
499128

numpy.linalg.multi_dot — Руководство NumPy v1.

24
linalg.multi_dot( массива , * , out=None )[источник]

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

multi_dot цепочки numpy.dot и использует оптимальные скобки матриц [1] [2]. В зависимости от формы матриц, это может значительно ускорить умножение.

Если первый аргумент одномерный, он обрабатывается как вектор-строка. Если последним аргументом является 1-D, он рассматривается как вектор-столбец. Другие аргументы должны быть двумерными.

Думайте о multi_dot как:

 def multi_dot (массивы): return functools.reduce (np.dot, массивы)
Параметры:
массивы последовательность array_like

Если первый аргумент одномерный, он обрабатывается как вектор-строка. Если последним аргументом является 1-D, он рассматривается как вектор-столбец. Другие аргументы должны быть двумерными.

out ndarray, необязательный

Выходной аргумент. Это должно иметь точный вид, который будет возвращен если он не использовался. В частности, он должен иметь правильный тип, должен быть C-непрерывный, и его dtype должен быть возвращенным dtype для точка(а, б) . Это особенность производительности. Следовательно, если эти условия не выполняются, вместо попытки быть гибким.

Новое в версии 1.19.0.

Возвращает:
вывод ndarray

Возвращает скалярное произведение предоставленных массивов.

См. также

numpy.dot

умножение на точку с двумя аргументами.

Примечания

Стоимость матричного умножения можно рассчитать с помощью следующая функция:

 по умолчанию стоимость (A, B):
    вернуть A. shape[0] * A.shape[1] * B.shape[1]

Предположим, у нас есть три матрицы \(A_{10×100}, B_{100×5}, C_{5×50}\).

Стоимость двух разных скобок следующая:

 стоимость((AB)C) = 10*100*5 + 10*5*50 = 5000 + 2500 = 7500
стоимость (A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000

Ссылки

[1]

Кормен, «Введение в алгоритмы», глава 15.2, с. 370-378

[2]

https://en.wikipedia.org/wiki/Matrix_chain_multiplication

Примеры

multi_dot позволяет писать:

 >>> из numpy.linalg импортировать multi_dot
>>> # Подготовить некоторые данные
>>> A = np.random.random((10000, 100))
>>> B = np.random.random((100, 1000))
>>> C = np.random.random((1000, 5))
>>> D = np.random.random((5, 333))
>>> # фактическое умножение точек
>>> _ = multi_dot([A, B, C, D])

вместо:

 >>> _ = np.dot (np.dot (np.dot (A, B), C), D)
>>> # или
>>> _ = A.
No related posts.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *