import numpy
a = numpy.arange[9].reshape[3,3]
b = numpy.arange[60].reshape[20,3]
c1 = numpy.dot[b, a.T] # as in the answer of senderle
c2 = numpy.einsum['ji,ki->kj',a,b]
và kết quả C1 và C2 đều giống như những gì bạn muốn [được xác minh bằng
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Nội phân chính
- Mã nguồn: phép nhân ma trận bằng cách sử dụng vòng lặp lồng nhau
- Mã nguồn: phép nhân ma trận bằng cách sử dụng danh sách lồng nhau hiểu biết
- Làm thế nào để bạn nhân ma trận 2x2 trong Python?
- Làm thế nào để bạn nhân danh sách 2D trong Python?
- Sự nhân Matrix được thực hiện như thế nào trong Python?
- Bạn có thể nhân ma trận trong Python không?
Ưu điểm của
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Giải thích thêm về Einsum
Ví dụ: nếu bạn muốn thực hiện thao tác sau:
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Bạn có thể làm điều tương tự nhanh hơn nhiều bằng cách làm:
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
Hoặc nếu bạn không thích cách chỉ định những gì phải xảy ra, bạn cũng có thể sử dụng
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
Vì vậy, phương pháp Einsum này rất chung chung và có thể được sử dụng để tắt các vòng lặp [không chậm
Để biết thêm thông tin, hãy xem //docs.scipy.org/doc/numpy/reference/generated/numpy.tensordot.html và //docs.scipy.org/doc/numpy/reference/generated/numpy.eoinsum .html
Trong Python, chúng ta có thể triển khai một ma trận dưới dạng danh sách lồng nhau [danh sách bên trong danh sách].
Chúng ta có thể coi từng phần tử như một hàng của ma trận.
Ví dụ
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Hàng đầu tiên có thể được chọn là
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Sự nhân của hai ma trận x và y chỉ được xác định nếu số lượng cột trong x bằng số lượng hàng y.
Nếu x là ma trận
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
Mã nguồn: phép nhân ma trận bằng cách sử dụng vòng lặp lồng nhau
# Program to multiply two matrices using nested loops
# 3x3 matrix
X = [[12,7,3],
[4 ,5,6],
[7 ,8,9]]
# 3x4 matrix
Y = [[5,8,1,2],
[6,7,3,0],
[4,5,9,1]]
# result is 3x4
result = [[0,0,0,0],
[0,0,0,0],
[0,0,0,0]]
# iterate through rows of X
for i in range[len[X]]:
# iterate through columns of Y
for j in range[len[Y[0]]]:
# iterate through rows of Y
for k in range[len[Y]]:
result[i][j] += X[i][k] * Y[k][j]
for r in result:
print[r]
Đầu ra
[114, 160, 60, 27] [74, 97, 73, 14] [119, 157, 112, 23]
Trong chương trình này, chúng tôi đã sử dụng các vòng lặp
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
Kỹ thuật này đơn giản nhưng tốn kém về mặt tính toán khi chúng tôi tăng thứ tự của ma trận.
Đối với các hoạt động ma trận lớn hơn, chúng tôi khuyên bạn nên sử dụng các gói phần mềm được tối ưu hóa như Numpy, theo thứ tự [theo thứ tự 1000] lần so với mã trên.
Mã nguồn: phép nhân ma trận bằng cách sử dụng danh sách lồng nhau hiểu biết
# Program to multiply two matrices using list comprehension
# 3x3 matrix
X = [[12,7,3],
[4 ,5,6],
[7 ,8,9]]
# 3x4 matrix
Y = [[5,8,1,2],
[6,7,3,0],
[4,5,9,1]]
# result is 3x4
result = [[sum[a*b for a,b in zip[X_row,Y_col]] for Y_col in zip[*Y]] for X_row in X]
for r in result:
print[r]
Làm thế nào để bạn nhân ma trận 2x2 trong Python?
Làm thế nào để bạn nhân danh sách 2D trong Python?
Sự nhân Matrix được thực hiện như thế nào trong Python?
Bạn có thể nhân ma trận trong Python không? Multiplication of two matrices by each other of size 3×3.
Input:matrix1 = [[1, 2, 3],
[3, 4, 5],
[7, 6, 4]]
matrix2 = [[5, 2, 6],
[5, 6, 7],
[7, 6, 4]]
Output : [[36 32 32]
[70 60 66]
[93 74 100]]Ưu điểm của
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Giải thích thêm về EinsumUsing explicit for loops: This is a simple technique to multiply matrices but one of the expensive method for larger input data set.In this, we use nested for loops to iterate each row and each column.
Ví dụ: nếu bạn muốn thực hiện thao tác sau:n x m matrix and matrix2 is a m x l matrix.
Implementation:
Python3
Bạn có thể làm điều tương tự nhanh hơn nhiều bằng cách làm:
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
Hoặc nếu bạn không thích cách chỉ định những gì phải xảy ra, bạn cũng có thể sử dụng
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Vì vậy, phương pháp Einsum này rất chung chung và có thể được sử dụng để tắt các vòng lặp [không chậm
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
# Program to multiply two matrices using nested loops
# 3x3 matrix
X = [[12,7,3],
[4 ,5,6],
[7 ,8,9]]
# 3x4 matrix
Y = [[5,8,1,2],
[6,7,3,0],
[4,5,9,1]]
# result is 3x4
result = [[0,0,0,0],
[0,0,0,0],
[0,0,0,0]]
# iterate through rows of X
for i in range[len[X]]:
# iterate through columns of Y
for j in range[len[Y[0]]]:
# iterate through rows of Y
for k in range[len[Y]]:
result[i][j] += X[i][k] * Y[k][j]
for r in result:
print[r]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
d3 = numpy.tensordot[a,b, axes=[[1,0],[0,1]]]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
# Program to multiply two matrices using nested loops
# 3x3 matrix
X = [[12,7,3],
[4 ,5,6],
[7 ,8,9]]
# 3x4 matrix
Y = [[5,8,1,2],
[6,7,3,0],
[4,5,9,1]]
# result is 3x4
result = [[0,0,0,0],
[0,0,0,0],
[0,0,0,0]]
# iterate through rows of X
for i in range[len[X]]:
# iterate through columns of Y
for j in range[len[Y[0]]]:
# iterate through rows of Y
for k in range[len[Y]]:
result[i][j] += X[i][k] * Y[k][j]
for r in result:
print[r]
# Program to multiply two matrices using nested loops
# 3x3 matrix
X = [[12,7,3],
[4 ,5,6],
[7 ,8,9]]
# 3x4 matrix
Y = [[5,8,1,2],
[6,7,3,0],
[4,5,9,1]]
# result is 3x4
result = [[0,0,0,0],
[0,0,0,0],
[0,0,0,0]]
# iterate through rows of X
for i in range[len[X]]:
# iterate through columns of Y
for j in range[len[Y[0]]]:
# iterate through rows of Y
for k in range[len[Y]]:
result[i][j] += X[i][k] * Y[k][j]
for r in result:
print[r]
Để biết thêm thông tin, hãy xem //docs.scipy.org/doc/numpy/reference/generated/numpy.tensordot.html và //docs.scipy.org/doc/numpy/reference/generated/numpy.eoinsum .html
Trong Python, chúng ta có thể triển khai một ma trận dưới dạng danh sách lồng nhau [danh sách bên trong danh sách].
Chúng ta có thể coi từng phần tử như một hàng của ma trận.
Ví dụ
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Hàng đầu tiên có thể được chọn là
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Đầu ra
[[114, 160, 60], [74, 97, 73], [119, 157, 112]]
Trong chương trình này, chúng tôi đã sử dụng lồng nhau cho các vòng để tính toán kết quả sẽ lặp qua từng hàng và cột của ma trận, cuối cùng nó sẽ tích lũy tổng sản phẩm trong kết quả. & NBSP;
2. Sử dụng Numpy: Nhân bằng cách sử dụng Numpy cũng được gọi là vector hóa nhằm mục đích chính là giảm hoặc loại bỏ việc sử dụng rõ ràng cho các vòng lặp trong chương trình mà tính toán trở nên nhanh hơn. Thao tác. Đối với các hoạt động ma trận lớn hơn, chúng tôi sử dụng gói python numpy nhanh hơn 1000 lần so với phương pháp lặp. & nbsp; để biết chi tiết về numpy, vui lòng truy cập liên kếtUsing Numpy : Multiplication using Numpy also know as vectorization which main aim to reduce or remove the explicit use of for loops in the program by which computation becomes faster.
Numpy is a build in a package in python for array-processing and manipulation.For larger matrix operations we use numpy python package which is 1000 times faster than iterative one method.
For
detail about Numpy please visit the Link
Implementation:
Python3
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Các
Các
Input:matrix1 = [[1, 2, 3],
[3, 4, 5],
[7, 6, 4]]
matrix2 = [[5, 2, 6],
[5, 6, 7],
[7, 6, 4]]
Output : [[36 32 32]
[70 60 66]
[93 74 100]]5d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Output:
[[ 63 320 83] [ 77 484 102] [ 84 248 117]]
Sử dụng numpy & nbsp;numpy
Python3
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Các
Các
Input:matrix1 = [[1, 2, 3],
[3, 4, 5],
[7, 6, 4]]
matrix2 = [[5, 2, 6],
[5, 6, 7],
[7, 6, 4]]
Output : [[36 32 32]
[70 60 66]
[93 74 100]]5d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
a = numpy.arange[60.].reshape[3,4,5]
b = numpy.arange[24.].reshape[4,3,2]
d1 = numpy.zeros[[5,2]]
for i in range[5]:
for j in range[2]:
for k in range[3]:
for n in range[4]:
d1[i,j] += a[k,n,i] * b[n,k,j]
Output:
[[ 63 320 83] [ 77 484 102] [ 84 248 117]]
Sử dụng numpy & nbsp;
Input:matrix1 = [[1, 2, 3],
[3, 4, 5],
[7, 6, 4]]
matrix2 = [[5, 2, 6],
[5, 6, 7],
[7, 6, 4]]
Output : [[36 32 32]
[70 60 66]
[93 74 100]]5d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
d2 = numpy.einsum['kni,nkj->ij', a, b]
# the 'kni,nkj->ij' is what you otherwise do with the indices as in
# d1[i,j] += a[k,n,i] * b[n,k,j]
Trong ví dụ trên, chúng tôi đã sử dụng sản phẩm DOT và trong toán học, sản phẩm DOT là một hoạt động đại số có hai vectơ có kích thước bằng nhau và trả về một số duy nhất. Kết quả được tính toán bằng cách nhân các mục tương ứng và thêm các sản phẩm đó.
Bài viết này được đóng góp bởi Dheeraj Sharma. Nếu bạn thích GeekSforGeeks và muốn đóng góp, bạn cũng có thể viết một bài viết bằng Write.GeekSforGeek.org hoặc gửi bài viết của bạn. Xem bài viết của bạn xuất hiện trên trang chính của GeekSforGeek và giúp các chuyên viên máy tính khác. & NBSP;
Làm thế nào để bạn nhân ma trận 2x2 trong Python?
Bước 1: Nhập hai ma trận. Bước 2: lồng nhau cho các vòng lặp để lặp qua mỗi hàng và mỗi cột. Bước 3: Lấy một ma trận kết quả ban đầu chứa tất cả 0. Sau đó, chúng tôi nhân từng phần tử hàng của ma trận thứ nhất với mỗi phần tử của ma trận thứ hai, sau đó thêm tất cả giá trị nhân.Using the numpy. multiply[] Method. The multiply[] method of the NumPy library in Python, takes two arrays/lists as input and returns an array/list after performing element-wise multiplication.
Làm thế nào để bạn nhân danh sách 2D trong Python?
Nhân hai danh sách trong python bằng phương thức numpy.multiply []. Phương thức nhân [] của thư viện Numpy trong Python, lấy hai mảng/danh sách làm đầu vào và trả về một mảng/danh sách sau khi thực hiện phép nhân phần tử.using nested loops. Following program has two matrices x and y each with 3 rows and 3 columns. The resultant z matrix will also have 3X3 structure. Element of each row of first matrix is multiplied by corresponding element in column of second matrix.
Sự nhân Matrix được thực hiện như thế nào trong Python?
Sự nhân có thể được thực hiện bằng cách sử dụng các vòng lặp lồng nhau. Chương trình sau có hai ma trận x và y mỗi hàng có 3 hàng và 3 cột. Ma trận Z kết quả cũng sẽ có cấu trúc 3x3. Phần tử của mỗi hàng của ma trận thứ nhất được nhân với phần tử tương ứng trong cột của ma trận thứ hai.Multiplication of two matrices X and Y is defined only if the number of columns in X is equal to the number of rows Y .