python numpy 에서 multiply 와*및 matul 의 차이 설명

1.행렬(matrix)에 있어
multiply 는 대응 하 는 요소 의 상승 이 고*,np.matmul()함수 와 np.dot()함 수 는 행렬 곱셈(벡터 적)에 해당 하 며 대응 하 는 열 수 와 행 수 는 곱셈 규칙 을 만족 시 켜 야 합 니 다.수량 적 으로 진행 하려 면 np.mliply 함 수 를 사용 해 야 합 니 다.다음 과 같 습 니 다.

a = np.mat([[1, 2, 3, 4, 5]])
b = np.mat([[1,2,3,4,5]])
c=np.multiply(a,b)
print(c)

결국
[[ 1 4 9 16 25]]
a = np.mat([[1, 2, 3, 4, 5]])
b = np.mat([ [1],[2],[3],[4],[5] ] )
d=a*b
print(d)\#a 는 shape(1,5),b 는 shape(5,1),결 과 는 하나의 실수
결국
[[55]]
2.배열(Array)에 있어
*multiply 와 모두 수량 적(즉 대응 요소 의 곱 하기)을 나타 내 고 np.matmul 과 np.dot 는 벡터 적(즉 행렬 곱셈)을 나타 낸다.
코드:

if __name__ == '__main__':
    w = np.array([[1,2],[3,4]])
    x = np.array([[1,3],[2,4]])
    w1 = np.array([[1,2],[3,4]])
    x1 = np.array([[1,2]])
    w_mat = np.mat([[1,2],[3,4]])
    x_mat = np.mat([[1,3],[2,4]])
    print("x1.shape:",np.shape(x1))
    w_x_start = w*x
    w_x_dot = np.dot(w,x)
    x_w_dot = np.dot(x,w)
    w_x_matmul = np.matmul(w, x)
    x_w_matmul = np.matmul(x, w)
    w_x_multiply = np.multiply(w,x)
    x_w_multiply = np.multiply(x, w)
    #w1_x1_matmul = np.matmul(w1, x1)
    x1_w1_matmul = np.matmul(x1, w1)
    w_x_mat_matmul = np.matmul(w_mat,x_mat)
    x_w_mat_matmul = np.matmul(x_mat, w_mat)
    w_x_mat_start = w_mat*x_mat
    x_w_mat_start = x_mat*w_mat
    w_x_mat_dot = np.dot(w_mat,x_mat)
    x_w_mat_dot = np.dot(x_mat,w_mat)
    w_x_mat_multiply = np.multiply(w_mat,x_mat)
    x_w_mat_multiply = np.multiply(x_mat,w_mat)
 
    print("W.shape:", np.shape(w))
    print("x.shape:", np.shape(x))
    print("w_x_start.shape:", np.shape(w_x_start))
    print("w_x_dot.shape:", np.shape(w_x_dot))
    print("x_w_dot.shape:", np.shape(x_w_dot))
    print("x1_w1_matmul.shape::", np.shape(x1_w1_matmul))
 
    print(" Array     ：", '
')
    print("w_x_start:", w_x_start)
    print("w_x_dot:", w_x_dot)
    print("x_w_dot:", x_w_dot)
    print("w_x_matmul:", w_x_matmul)
    print("x_w_matmul:", x_w_matmul)
    print("w_x_multiply:", w_x_multiply)
    print("x_w_multiply:", x_w_multiply)
    # print("w1_x1_matmul:", w1_x1_matmul)
    print("x1_w1_matmul:", x1_w1_matmul)
 
    print(" matrix     ：", '
')
    print("w_x_mat_start:", w_x_mat_start)
    print("x_w_mat_start:", x_w_mat_start)
    print("x_w_mat_dot:", x_w_mat_dot)
    print("w_x_mat_dot:", w_x_mat_dot)
    print("w_x_mat_matmul:",w_x_mat_matmul)
    print("x_w_mat_matmul:", x_w_mat_matmul)
    print("w_x_mat_multiply",w_x_mat_multiply)
    print("x_w_mat_multiply", x_w_mat_multiply)

x1.shape: (1, 2)
W.shape: (2, 2)
x.shape: (2, 2)
w_x_start.shape: (2, 2)
w_x_dot.shape: (2, 2)
x_w_dot.shape: (2, 2)
x1_w1_matmul.shape:: (1, 2)
 Array     ：
 
w_x_start: [[ 1  6]
 [ 6 16]]
w_x_dot: [[ 5 11]
 [11 25]]
x_w_dot: [[10 14]
 [14 20]]
w_x_matmul: [[ 5 11]
 [11 25]]
x_w_matmul: [[10 14]
 [14 20]]
w_x_multiply: [[ 1  6]
 [ 6 16]]
x_w_multiply: [[ 1  6]
 [ 6 16]]
x1_w1_matmul: [[ 7 10]]
 matrix     ：
 
w_x_mat_start: [[ 5 11]
 [11 25]]
x_w_mat_start: [[10 14]
 [14 20]]
x_w_mat_dot: [[10 14]
 [14 20]]
w_x_mat_dot: [[ 5 11]
 [11 25]]
w_x_mat_matmul: [[ 5 11]
 [11 25]]
x_w_mat_matmul: [[10 14]
 [14 20]]
w_x_mat_multiply [[ 1  6]
 [ 6 16]]
x_w_mat_multiply [[ 1  6]
 [ 6 16]]

python 에서 전 환 된 우선 순위 가 곱셈 연산 보다 높 습 니 다.예 를 들 어:
a = np.mat([[2, 3, 4]])
b = np.mat([[1,2,3]] )
d=a*b.T
print(d)
결국
[[20]]
그 중에서 a 는 1 행 3 열 이 고 b 도 1 행 3 열 이다.이치 에 따라 a*b 를 직접 계산 하 는 것 은 연산 할 수 없 지만 d=a*b.T 를 계산 하 는 것 은 가능 하 다.결 과 는 20 이다.연산 순 서 는 먼저 전 치 된 다음 에 a 와 b 가 전 치 된 적 을 계산 하 는 것 임 을 나타 낸다.*행렬 곱셈 으로 주의해 야 할 것 은*연산 을 수행 할 때 반드시 행렬 원칙 에 부합 해 야 한 다 는 것 이다.
numpy 에서 tile()함수 의 용법
b=tile(a,(m,n):즉 a 배열 안의 요 소 를 n 번 복사 하여 하나의 배열 c 에 넣 은 다음 에 배열 c 를 m 번 복사 하여 하나의 배열 b 에 넣 는 것 이다.쉽게 말 하면 a 줄 방향 에서 m 번 복사 하고 열 방향 에서 n 번 복사 하 는 것 이다.
python 의 sum 과 np.sum 은 다 릅 니 다.sum 만 쓰 면 배열 에 대응 하 는 차원 을 표시 합 니 다.np.sum 을 쓰 면 한 배열 의 차원 과 열 수의 수 를 모두 합 친 다 는 뜻 입 니 다.
다음 그림 에서 보 듯 이:

보충:요약:numpy 에서 세 가지 곱셈 연산 multiply,dot 와*의 차이
머리말:
본인 은 기계 학습 연습 1 을 할 때 자주 실 수 를 합 니 다.

Not aligned 가 무슨 뜻 이 죠?
두 행렬 의 상승 은 무의미 하 다 는 뜻 이다.
선형 대수 에서 mxn 과 nxp 의 행렬 이 곱 할 수 있 고 그 결 과 는 mxp 의 행렬 이다.
오류 원본 코드:

def gradientDescent(X,y,theta,alpha,iteration):
    colunms = int(theta.ravel().shape[1])
    thetai = np.matrix(np.zeros(theta.shape))
    cost = np.zeros(iteration)
                       
    for i in range(iteration):
        error = X*theta.T-y
        for j in range(colunms):
            a = np.sum(error*X[:,j])/len(X) ########## error！
            thetai[0,j] = thetai[0,j] - alpha*a
            
        theta = thetai    
        cost[i] = computeCost(X, y, theta)        
    return theta,cost

여기 error 는 nx1 의 행렬 이 고 theta.T 도 nx1 의 행렬 입 니 다.
행렬 간*연산 자 는 행렬 곱셈 을 나타 낸다.우 리 는 행렬 의 대응 요 소 를 곱 하고 싶 기 때문에 np.mliply()로 이 루어 져 야 합 니 다.
요약:
(독 자 는 간단 한 예 를 들 어 스스로 검증 할 수 있다)
1.*용법:
매트릭스 와 매트릭스:매트릭스 곱셈(matrix)
배열 과 배열:대응 하 는 위치 곱 하기(array)
2.np.dot()사용법:
행렬 곱 하기 결과
3.np.multiply()사용법:
배열,행렬 은 모두 대응 하 는 위 치 를 곱 한다.
이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.