Phép nhân ma trận trong Python bằng tuple

Bạn sẽ bắt đầu bằng cách tìm hiểu điều kiện để nhân ma trận hợp lệ và viết một hàm Python tùy chỉnh để nhân ma trận. Tiếp theo, bạn sẽ thấy cách bạn có thể đạt được kết quả tương tự bằng cách sử dụng khả năng hiểu danh sách lồng nhau

Cuối cùng, bạn sẽ tiếp tục sử dụng NumPy và các hàm tích hợp của nó để thực hiện phép nhân ma trận hiệu quả hơn

Trước khi viết mã Python cho phép nhân ma trận, hãy xem lại những kiến ​​thức cơ bản về phép nhân ma trận

Ma trận Phép nhân giữa hai ma trận A và B chỉ đúng khi số cột của ma trận A bằng số hàng của ma trận B

Bạn có thể đã gặp điều kiện này đối với phép nhân ma trận trước đây. Tuy nhiên, bạn đã bao giờ tự hỏi tại sao lại như vậy chưa?

Chà, đó là do cách hoạt động của phép nhân ma trận. Hãy nhìn vào hình ảnh dưới đây

Trong ví dụ chung của chúng ta, ma trận A có m hàng và n cột. Và ma trận B có n hàng và p cột

Hình dạng của ma trận sản phẩm là gì?

Phần tử tại chỉ số (i, j) trong ma trận kết quả C là tích vô hướng của hàng i của ma trận A và cột j của ma trận B

Vì vậy, để lấy một phần tử tại một chỉ mục cụ thể trong ma trận kết quả C, bạn sẽ phải tính tích vô hướng của hàng và cột tương ứng trong ma trận A và B, tương ứng

Lặp lại quy trình trên, bạn sẽ nhận được ma trận tích C có hình dạng m x p—với m hàng và p cột, như hình bên dưới

Và tích vô hướng hay tích trong giữa hai vectơ a và b được cho bởi phương trình sau

Bây giờ hãy tóm tắt

• Rõ ràng là tích vô hướng chỉ được xác định giữa các vectơ có độ dài bằng nhau
• Vì vậy, để tích vô hướng giữa một hàng và một cột là hợp lệ—khi nhân hai ma trận—bạn cần cả hai ma trận có cùng số phần tử
• Trong ví dụ chung trên, mỗi hàng trong ma trận A có n phần tử. Và mỗi cột trong ma trận B cũng có n phần tử

Để ý kỹ hơn, n là số cột của ma trận A, đồng thời cũng là số hàng của ma trận B. Và đây chính là lý do tại sao bạn cần số cột trong ma trận A bằng số hàng trong ma trận B

Hi vọng các bạn đã hiểu điều kiện để phép nhân ma trận hợp lệ và cách lấy từng phần tử trong ma trận tích

Hãy tiến hành viết một số mã Python để nhân hai ma trận

Viết một hàm Python tùy chỉnh để nhân ma trận

Bước đầu tiên, chúng ta hãy viết một hàm tùy chỉnh để nhân các ma trận

Chức năng này nên làm như sau

• Chấp nhận hai ma trận A và B làm đầu vào
• Kiểm tra xem phép nhân ma trận giữa A và B có hợp lệ không
• Nếu hợp lệ, nhân hai ma trận A và B và trả về ma trận tích C
• Ngược lại, trả về thông báo lỗi rằng không thể nhân ma trận A và B

Bước 1. Tạo hai ma trận số nguyên bằng cách sử dụng hàm

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

1 của NumPy. Bạn cũng có thể khai báo ma trận dưới dạng danh sách Python lồng nhau

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Bước 2. Hãy tiếp tục và xác định chức năng

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

2. Hàm này lấy hai ma trận

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

3 và

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

4 làm đầu vào và trả về ma trận tích

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

5 nếu phép nhân ma trận hợp lệ

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

Phân tích định nghĩa hàm

Hãy tiến hành phân tích cú pháp định nghĩa hàm

Khai báo C như một biến toàn cục. Theo mặc định, tất cả các biến bên trong hàm Python đều có phạm vi cục bộ. Và bạn không thể truy cập chúng từ bên ngoài chức năng. Để làm cho ma trận sản phẩm C có thể truy cập được từ bên ngoài, chúng tôi sẽ phải khai báo nó dưới dạng biến toàn cục. Chỉ cần thêm từ hạn định

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

6 trước tên biến

Kiểm tra xem phép nhân ma trận có hợp lệ không. Sử dụng thuộc tính

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

7 để kiểm tra xem A và B có nhân được không. Đối với bất kỳ mảng nào

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

8,

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

9 và

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

10 lần lượt cho số lượng hàng và cột. Vì vậy,

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

11 kiểm tra xem phép nhân ma trận có hợp lệ không. Chỉ khi điều kiện này là

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

12, ma trận sản phẩm sẽ được tính toán. Ngược lại, hàm trả về thông báo lỗi

Sử dụng các vòng lặp lồng nhau để tính giá trị. Để tính toán các phần tử của ma trận kết quả, chúng ta phải lặp qua các hàng của ma trận A và vòng lặp

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

13 bên ngoài thực hiện điều này. Vòng lặp

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

13 bên trong giúp ta lặp qua cột của ma trận B. Và vòng lặp

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

13 trong cùng giúp truy xuất từng phần tử trong cột được chọn

▶️ Bây giờ chúng ta đã học cách hoạt động của hàm Python nhân ma trận, hãy gọi hàm với ma trận A và B mà chúng ta đã tạo trước đó

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

1

Khi phép nhân ma trận giữa A và B hợp lệ, hàm

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

16 trả về ma trận tích C

Sử dụng khả năng hiểu danh sách lồng nhau của Python để nhân ma trận

Trong phần trước, bạn đã viết một hàm Python để nhân các ma trận. Bây giờ, bạn sẽ thấy cách bạn có thể sử dụng khả năng hiểu danh sách lồng nhau để làm điều tương tự

Đây là cách hiểu danh sách lồng nhau để nhân ma trận

Lúc đầu, điều này có vẻ phức tạp. Nhưng chúng tôi sẽ phân tích cú pháp hiểu danh sách lồng nhau từng bước

Hãy tập trung vào một cách hiểu danh sách tại một thời điểm và xác định những gì nó làm

Chúng tôi sẽ sử dụng mẫu chung sau đây để hiểu danh sách

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

9

▶️ Hãy xem hướng dẫn của chúng tôi về Danh sách hiểu trong Python – với các ví dụ để hiểu sâu hơn

Trước khi tiếp tục, xin lưu ý rằng chúng tôi muốn xây dựng ma trận kết quả C mỗi lần một hàng

Giải thích về cách hiểu danh sách lồng nhau

Bước 1. Tính một giá trị duy nhất trong ma trận C

Cho hàng i của ma trận A và cột j của ma trận B, biểu thức dưới đây đưa ra mục tại chỉ số (i, j) trong ma trận C

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

0

Nếu

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

17, biểu thức sẽ trả về mục nhập

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

18 của ma trận C. Vì vậy, bạn có thể lấy một phần tử trong một hàng theo cách này

Bước 2. Dựng một hàng trong ma trận C

Mục tiêu tiếp theo của chúng tôi là xây dựng toàn bộ một hàng

Đối với hàng 1 trong ma trận A, bạn phải lặp qua tất cả các cột trong ma trận B để có một hàng hoàn chỉnh trong ma trận C

Quay lại mẫu hiểu danh sách

• Thay thế

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  19 bằng biểu thức từ bước 1, vì đó là điều bạn muốn làm
• Tiếp theo, thay thế

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  19 bằng

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  91—mỗi cột trong ma trận B
• Cuối cùng, thay thế

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  19 bằng

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  93—danh sách chứa tất cả các cột trong ma trận B

Và đây là cách hiểu danh sách đầu tiên

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

8

Bước 3. Xây dựng tất cả các hàng và thu được ma trận C

Tiếp theo, bạn sẽ phải điền vào ma trận sản phẩm C bằng cách tính phần còn lại của các hàng

Và để làm điều này, bạn phải lặp qua tất cả các hàng trong ma trận A

Quay lại phần hiểu danh sách một lần nữa và làm như sau

• Thay thế

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  19 bằng cách hiểu danh sách từ bước 2. Nhớ lại rằng chúng tôi đã tính toán toàn bộ hàng trong bước trước
• Bây giờ, thay thế

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  19 bằng

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  96—mỗi hàng trong ma trận A
• Và

  import numpy as np
  np.random.seed(27)
  A = np.random.randint(1,10,size = (3,3))
  B = np.random.randint(1,10,size = (3,2))
  print(f"Matrix A:\n {A}\n")
  print(f"Matrix B:\n {B}\n")
  
  # Output
  Matrix A:
   [[4 9 9]
   [9 1 6]
   [9 2 3]]
  
  Matrix B:
   [[2 2]
   [5 7]
   [4 4]]

  19 của bạn chính là ma trận A, khi bạn đang lặp qua các hàng của nó

Và đây là cách hiểu danh sách lồng nhau cuối cùng của chúng tôi. 🎊

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

3

Đã đến lúc kiểm chứng kết quả. ✔

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

4

Nếu bạn nhìn kỹ hơn, điều này tương đương với các vòng lặp for lồng nhau mà chúng ta đã có trước đó—chỉ là nó ngắn gọn hơn

Bạn cũng có thể làm điều này hiệu quả hơn bằng cách sử dụng một số hàm tích hợp. Hãy cùng tìm hiểu về chúng trong phần tiếp theo

Sử dụng NumPy matmul() để nhân ma trận trong Python

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

98 lấy hai ma trận làm đầu vào và trả về kết quả nếu phép nhân ma trận giữa các ma trận đầu vào là hợp lệ

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

6

Lưu ý cách phương pháp này đơn giản hơn hai phương pháp chúng ta đã học trước đó. Trên thực tế, thay vì

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

98, bạn có thể sử dụng toán tử @ tương đương và chúng ta sẽ thấy điều đó ngay sau đây

Cách sử dụng toán tử @ trong Python để nhân ma trận

Trong Python,

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

00 là toán tử nhị phân được sử dụng để nhân ma trận

Nó hoạt động trên hai ma trận và nói chung là các mảng NumPy N chiều và trả về ma trận tích

Ghi chú. Bạn cần có Python 3. 5 trở lên để sử dụng toán tử

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

00

Đây là cách bạn có thể sử dụng nó

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

0

Lưu ý rằng ma trận sản phẩm C giống như ma trận chúng ta đã thu được trước đó

Bạn có thể sử dụng np. dot() để nhân ma trận?

Nếu bạn đã từng gặp đoạn mã sử dụng

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

02 để nhân hai ma trận, thì đây là cách nó hoạt động

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

0

Bạn sẽ thấy rằng

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

03 cũng trả về ma trận sản phẩm dự kiến

Tuy nhiên, theo tài liệu NumPy, bạn chỉ nên sử dụng

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

02 để tính tích vô hướng của hai vectơ một chiều chứ không phải để nhân ma trận

Nhớ lại phần trước, phần tử tại chỉ số (i,j) của ma trận tích C là tích vô hướng của hàng i ma trận A và cột j của ma trận B

Vì NumPy phát hoàn toàn hoạt động sản phẩm chấm này tới tất cả các hàng và tất cả các cột, bạn sẽ có được ma trận sản phẩm kết quả. Nhưng để giữ cho mã của bạn dễ đọc và tránh sự mơ hồ, thay vào đó hãy sử dụng toán tử

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

98 hoặc

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

00

Sự kết luận

🎯 Trong hướng dẫn này, bạn đã học được những điều sau

• Điều kiện để phép nhân ma trận hợp lệ. số cột trong ma trận A = số hàng trong ma trận B
• Cách viết hàm Python tùy chỉnh để kiểm tra xem phép nhân ma trận có hợp lệ hay không và trả về ma trận sản phẩm. Phần thân của hàm sử dụng các vòng for lồng nhau
• Tiếp theo, bạn đã học cách sử dụng khả năng hiểu danh sách lồng nhau để nhân ma trận. Chúng ngắn gọn hơn các vòng lặp for nhưng dễ gặp các vấn đề về khả năng đọc
• Cuối cùng, bạn đã học cách sử dụng hàm tích hợp NumPy np. matmul() để nhân ma trận và cách này hiệu quả nhất về mặt tốc độ
• Bạn cũng đã học về toán tử @ để nhân hai ma trận trong Python

Và điều đó kết thúc phần thảo luận của chúng ta về phép nhân ma trận trong Python. Bước tiếp theo, hãy tìm hiểu cách kiểm tra xem một số có phải là số nguyên tố hay không trong Python. Hoặc giải các bài toán thú vị trên chuỗi Python

Điều gì xảy ra khi bạn nhân một bộ dữ liệu?

Tuple() trong Python là gì?