numpy
numpy.dot

통사론

• numpy.dot (a, b, out = 없음)

매개 변수

비고

행렬 곱셈

행렬 곱셈은 점 함수를 사용하여 두 가지 방법으로 수행 할 수 있습니다. 한 가지 방법은 numpy.ndarray의 도트 멤버 함수를 사용하는 것입니다.

>>> import numpy as np
>>> A = np.ones((4,4))
>>> A
array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]])
>>> B = np.ones((4,2))
>>> B
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])
>>> A.dot(B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

행렬 곱셈을 수행하는 두 번째 방법은 numpy 라이브러리 함수를 사용하는 것입니다.

>>> np.dot(A,B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

벡터 도트 제품

도트 함수는 두 개의 1 차원 numpy 배열 사이에서 벡터 도트 곱을 계산하는 데 사용될 수도 있습니다.

>>> v = np.array([1,2])
>>> w = np.array([1,2])
>>> v.dot(w)
5
>>> np.dot(w,v)
5
>>> np.dot(v,w)
5

out 매개 변수

numpy 점 함수에는 선택적 매개 변수 out = None이 있습니다. 이 매개 변수를 사용하면 결과를 기록 할 배열을 지정할 수 있습니다. 이 배열은 반환 된 배열과 모양 및 유형이 동일해야합니다. 그렇지 않으면 예외가 발생합니다.

>>> I = np.eye(2)
>>> I
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result = np.zeros((2,2))
>>> result
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> np.dot(I, I, out=result)
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result
array([[ 1.,  0.],
       [ 0.,  1.]])

결과의 dtype을 int로 변경해 봅시다.

>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

그리고 다른 기본 메모리 순서 인 Fortran 스타일 (행 대신 행이 연속적이기 때문에)을 사용하면 오류도 발생합니다.

>>> result = np.zeros((2,2), order='F')
>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

벡터 배열에 대한 행렬 연산

numpy.dot는 벡터 목록에 행렬을 곱하는 데 사용할 수 있지만 벡터의 방향은 8 개의 두 구성 요소 벡터 목록이 두 개의 8 구성 요소 벡터처럼 표시되도록 수직이어야합니다.

>>> a
array([[ 1.,  2.],
       [ 3.,  1.]])
>>> b
array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.],
       [  9.,  10.,  11.,  12.,  13.,  14.,  15.,  16.]])
>>> np.dot(a, b)
array([[ 19.,  22.,  25.,  28.,  31.,  34.,  37.,  40.],
       [ 12.,  16.,  20.,  24.,  28.,  32.,  36.,  40.]])

벡터 목록이 축을 반올림하여 배열 된 경우 (일반적으로 그렇습니다) 배열을 다음과 같이 점 작업 전후에 배치해야합니다.

>>> b
array([[  1.,   9.],
       [  2.,  10.],
       [  3.,  11.],
       [  4.,  12.],
       [  5.,  13.],
       [  6.,  14.],
       [  7.,  15.],
       [  8.,  16.]])
>>> np.dot(a, b.T).T
array([[ 19.,  12.],
       [ 22.,  16.],
       [ 25.,  20.],
       [ 28.,  24.],
       [ 31.,  28.],
       [ 34.,  32.],
       [ 37.,  36.],
       [ 40.,  40.]])

도트 기능이 매우 빠르지 만 때로는 einsum을 사용하는 것이 좋습니다. 위와 같은 결과는 다음과 같습니다.

>>> np.einsum('...ij,...j', a, b)

조금 느리지 만 정점 목록에 해당 행렬 목록이 곱해질 수 있습니다. 이것은 점을 사용하는 매우 복잡한 프로세스입니다.

>>> 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]],
       [[24, 25],
        [26, 27]],
       [[28, 29],
        [30, 31]]])
>>> np.einsum('...ij,...j', a, b)
array([[   9.,   29.],
       [  58.,   82.],
       [ 123.,  151.],
       [ 204.,  236.],
       [ 301.,  337.],
       [ 414.,  454.],
       [ 543.,  587.],
       [ 688.,  736.]])

numpy.dot를 사용하여 목록의 각 벡터의 내적을 다른 목록의 해당 벡터와 함께 찾을 수 있습니다. 이는 요소 별 현행 곱셈 및 마지막 축을 따라 합산하는 것과 비교할 때 상당히 복잡하고 느립니다. 이와 같은 것 (계산하기에는 더 큰 배열이 필요하지만 대부분 무시됩니다)

>>> np.diag(np.dot(b,b.T))
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

엘리먼트 - 와이즈 곱셈과 합산을 이용한 도트 곱

>>> (b * b).sum(axis=-1)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

einsum 사용은

>>> np.einsum('...j,...j', b, b)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])