Đại số tuyến tính là một chủ đề quan trọng trong nhiều môn học. Nó cho phép bạn giải các bài toán liên quan đến vectơ, ma trận và phương trình tuyến tính. Trong Python, hầu hết các thủ tục liên quan đến chủ đề này được triển khai trong
In [6]: linalg.det[A]
Out[6]:
45102.0
Đặc biệt, các mô hình tuyến tính đóng một vai trò quan trọng trong nhiều vấn đề trong thế giới thực và
In [6]: linalg.det[A]
Out[6]:
45102.0
Trong hướng dẫn này, bạn sẽ học cách
- Nghiên cứu các hệ thống tuyến tính bằng cách sử dụng các định thức và giải quyết các vấn đề bằng cách sử dụng nghịch đảo ma trận
- Nội suy các đa thức để phù hợp với một tập hợp các điểm bằng cách sử dụng các hệ thống tuyến tính
- Sử dụng Python để giải các bài toán hồi quy tuyến tính
- Sử dụng hồi quy tuyến tính để dự đoán giá dựa trên dữ liệu lịch sử
Đây là phần thứ hai của loạt bài hướng dẫn về đại số tuyến tính bằng cách sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Mã nguồn miễn phí. Nhấp vào đây để tải xuống mã và tập dữ liệu miễn phí mà bạn sẽ sử dụng để làm việc với các hệ thống tuyến tính và đại số bằng Python với
In [6]: linalg.det[A]
Out[6]:
45102.0
Bây giờ bạn đã sẵn sàng để bắt đầu
Bắt đầu với Đại số tuyến tính trong Python
Đại số tuyến tính là một nhánh của toán học giải quyết các phương trình tuyến tính và biểu diễn của chúng bằng cách sử dụng vectơ và ma trận. Đây là một chủ đề cơ bản trong một số lĩnh vực kỹ thuật và là điều kiện tiên quyết để hiểu sâu hơn về học máy
Để làm việc với đại số tuyến tính trong Python, bạn có thể tin tưởng vào SciPy, đây là một thư viện mã nguồn mở Python được sử dụng cho tính toán khoa học, bao gồm một số mô-đun cho các nhiệm vụ phổ biến trong khoa học và kỹ thuật
Tất nhiên, SciPy bao gồm các mô-đun cho đại số tuyến tính, nhưng đó không phải là tất cả. Nó cũng cung cấp khả năng tối ưu hóa, tích hợp, nội suy và xử lý tín hiệu. Nó là một phần của ngăn xếp SciPy, bao gồm một số gói khác dành cho máy tính khoa học, chẳng hạn như NumPy, Matplotlib, SymPy, IPython và pandas
In [6]: linalg.det[A]
Out[6]:
45102.0
Trong hướng dẫn trước của loạt bài này, bạn đã học cách làm việc với ma trận và vectơ trong Python để mô hình hóa các vấn đề thực tế bằng các hệ thống tuyến tính. Bạn đã giải quyết những vấn đề này bằng cách sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Trong hướng dẫn này, bạn sẽ tiến thêm một bước, sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Để sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
Ghi chú. Sử dụng Jupyter Notebook để chạy mã là không bắt buộc, nhưng nó tạo điều kiện làm việc với các ứng dụng số và khoa học
Để xem lại cách làm việc với Jupyter Notebooks, hãy xem Jupyter Notebook. Một lời giới thiệu
Tiếp theo, bạn sẽ tìm hiểu một số khái niệm cơ bản về đại số tuyến tính và khám phá cách sử dụng Python để làm việc với các khái niệm này
Loại bỏ các quảng cáoHiểu về vectơ, ma trận và vai trò của đại số tuyến tính
Vectơ là một thực thể toán học dùng để biểu diễn các đại lượng vật lý có cả độ lớn và hướng. Nó là một công cụ cơ bản để giải quyết các vấn đề kỹ thuật và máy học. Ma trận cũng vậy, được sử dụng để biểu diễn các phép biến đổi vectơ, trong số các ứng dụng khác
Ghi chú. Trong Python, NumPy là để làm việc với ma trận và vectơ. Nó sử dụng một loại đặc biệt có tên là
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
Với NumPy, bạn có thể sử dụng
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
>>>
In [1]: import numpy as np
In [2]: np.array[[[1, 2], [3, 4], [5, 6]]]
Out[2]:
array[[[1, 2],
[3, 4],
[5, 6]]]
NumPy cung cấp một số chức năng để tạo điều kiện làm việc với các phép tính vectơ và ma trận. Bạn có thể tìm thêm thông tin về cách sử dụng NumPy để biểu diễn vectơ và ma trận và thực hiện các thao tác với chúng trong
Một hệ thống tuyến tính hay chính xác hơn là một hệ phương trình tuyến tính, là một tập hợp các phương trình liên quan tuyến tính với một tập hợp các biến. Đây là một ví dụ về một hệ thống tuyến tính liên quan đến các biến x₁ và x₂
Ở đây bạn có hai phương trình liên quan đến hai biến. Để có một hệ thống tuyến tính, các giá trị nhân các biến x₁ và x₂ phải là các hằng số, giống như các giá trị trong ví dụ này. Người ta thường viết các hệ tuyến tính sử dụng ma trận và vectơ. Ví dụ: bạn có thể viết hệ thống trước dưới dạng tích ma trận sau
So sánh dạng tích ma trận với hệ thống ban đầu, có thể nhận thấy các phần tử của ma trận A tương ứng với các hệ số nhân x₁ và x₂. Bên cạnh đó, các giá trị ở vế phải của phương trình ban đầu giờ đây tạo nên vectơ b
Đại số tuyến tính là một môn toán học liên quan đến vectơ, ma trận và không gian vectơ và các phép biến đổi tuyến tính nói chung hơn. Bằng cách sử dụng các khái niệm đại số tuyến tính, có thể xây dựng các thuật toán để thực hiện tính toán cho một số ứng dụng, bao gồm giải các hệ phương trình tuyến tính
Khi chỉ có hai hoặc ba phương trình và biến, có thể thực hiện các phép tính theo cách thủ công, kết hợp các phương trình và tìm giá trị cho các biến
Tuy nhiên, trong các ứng dụng thực tế, số lượng phương trình có thể rất lớn, khiến việc tính toán thủ công là không khả thi. Đó chính là lúc các khái niệm và thuật toán đại số tuyến tính trở nên tiện dụng, chẳng hạn như cho phép bạn phát triển các ứng dụng có thể sử dụng được cho kỹ thuật và máy học
Trong , bạn đã thấy cách giải các hệ tuyến tính bằng cách sử dụng
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
Giải bài toán sử dụng ma trận nghịch đảo và định thức
Nghịch đảo ma trận và định thức là những công cụ cho phép bạn lấy một số thông tin về hệ thống tuyến tính và cũng để giải quyết nó. Trước khi xem chi tiết cách tính nghịch đảo ma trận và định thức bằng cách sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Sử dụng yếu tố quyết định để nghiên cứu hệ thống tuyến tính
Như bạn có thể nhớ lại từ các lớp học toán của mình, không phải mọi hệ phương trình tuyến tính đều có thể giải được. Bạn có thể có một sự kết hợp của các phương trình không nhất quán và không có giải pháp. Ví dụ: một hệ có hai phương trình x₁ + x₂ = 2 và x₁ + x₂ = 3 không nhất quán và không có nghiệm. Điều này xảy ra vì không có hai số x₁ và x₂ nào cộng được cả 2 và 3 cùng một lúc
Ngoài ra, một số hệ phương trình giải được nhưng có nhiều hơn một nghiệm. Ví dụ: nếu bạn có một hệ gồm hai phương trình tương đương, chẳng hạn như x₁ + x₂ = 2 và 2x₁ + 2x₂ = 4, thì bạn có thể tìm thấy vô số nghiệm, chẳng hạn như [x₁=1, x₂=1], [
Định thức là một số, được tính toán bằng cách sử dụng ma trận hệ số, cho bạn biết liệu có giải pháp cho hệ thống hay không. Vì bạn sẽ sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
- Nếu định thức của ma trận hệ số của một hệ tuyến tính khác 0, thì bạn có thể nói hệ có nghiệm duy nhất
- Nếu định thức của ma trận hệ số của một hệ tuyến tính bằng 0, thì hệ có thể có nghiệm bằng 0 hoặc vô số nghiệm
Bây giờ bạn đã ghi nhớ điều này, bạn sẽ học cách giải hệ phương trình tuyến tính bằng cách sử dụng ma trận
Loại bỏ các quảng cáoSử dụng nghịch đảo ma trận để giải quyết các hệ thống tuyến tính
Để hiểu ý tưởng đằng sau nghịch đảo của ma trận, hãy bắt đầu bằng cách nhớ lại khái niệm về nghịch đảo nhân của một số. Khi bạn nhân một số với nghịch đảo của nó, bạn nhận được kết quả là 1. Lấy 3 làm ví dụ. Nghịch đảo của 3 là 1/3 và khi bạn nhân các số này với nhau, bạn sẽ nhận được 3 × 1/3 = 1
Với ma trận vuông, bạn có thể nghĩ ra ý tưởng tương tự. Tuy nhiên, thay vì 1, kết quả là bạn sẽ nhận được một ma trận nhận dạng. Một ma trận đơn vị có các số 1 trong đường chéo của nó và các số 0 trong các phần tử bên ngoài đường chéo, như các ví dụ sau
Ma trận đồng nhất có một thuộc tính thú vị. khi nhân với ma trận A khác cùng kích thước thì được kết quả là A. Nhớ lại rằng điều này cũng đúng với số 1, khi bạn xét phép nhân các số
Điều này cho phép bạn giải một hệ phương trình tuyến tính bằng cách làm theo các bước tương tự được sử dụng để giải một phương trình. Ví dụ, xét hệ tuyến tính sau, được viết dưới dạng tích ma trận
Bằng cách gọi A⁻¹ là nghịch đảo của ma trận A, bạn có thể nhân cả hai vế của phương trình với A⁻¹, kết quả này sẽ cho bạn kết quả như sau
Bằng cách này, bằng cách sử dụng phép nghịch đảo, A⁻¹, bạn có thể thu được nghiệm x cho hệ bằng cách tính A⁻¹b
Điều đáng chú ý là trong khi các số khác 0 luôn có nghịch đảo, không phải tất cả các ma trận đều có nghịch đảo. Khi hệ vô nghiệm hoặc có nhiều nghiệm thì định thức của A sẽ bằng 0 và định thức A⁻¹ sẽ không tồn tại
Bây giờ bạn sẽ thấy cách sử dụng Python với
In [6]: linalg.det[A]
Out[6]:
45102.0
Tính nghịch đảo và định thức với In [6]: linalg.det[A]
Out[6]:
45102.0
5
In [6]: linalg.det[A]
Out[6]:
45102.0
Bạn có thể tính nghịch đảo ma trận và định thức bằng cách sử dụng
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
Ví dụ, hãy xem xét vấn đề kế hoạch bữa ăn mà bạn đã giải quyết trong. Nhớ lại rằng hệ thống tuyến tính cho vấn đề này có thể được viết dưới dạng tích ma trận
Trước đó, bạn đã sử dụng
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Đây là một sự cố về những gì đang xảy ra
Dòng 1 và 2 nhập NumPy dưới dạng
2, cùng vớiIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
3 từIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
4. Những lần nhập này cho phép bạn sử dụngIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
5In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]Dòng 4 đến 12 tạo ma trận hệ số dưới dạng mảng NumPy có tên là
6In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]Dòng 14 tạo vectơ thuật ngữ độc lập dưới dạng mảng NumPy có tên là
7. Để biến nó thành một vectơ cột có năm phần tử, bạn sử dụngIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
8In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]Dòng 16 sử dụng
5 để lấy nghịch đảo của ma trậnIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
6In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]Dòng 18 và 19 sử dụng toán tử
1 để thực hiện tích ma trận nhằm giải hệ phương trình tuyến tính được đặc trưng bởiIn [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]] ...: linalg.det[A] Out[6]: 0.0
6 vàIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
7. Bạn lưu trữ kết quả trongIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
4, được in raIn [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]] ...: linalg.det[A] Out[6]: 0.0
Bạn nhận được chính xác giải pháp tương tự như giải pháp được cung cấp bởi
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
In [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
...: linalg.det[A]
Out[6]:
0.0
In [6]: linalg.det[A]
Out[6]:
45102.0
>>>
In [6]: linalg.det[A]
Out[6]:
45102.0
Như mong đợi, yếu tố quyết định không phải là số không. Điều này chỉ ra rằng tồn tại nghịch đảo của A, ký hiệu là A⁻¹ và được tính bằng
In [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
...: linalg.det[A]
Out[6]:
0.0
>>>
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
Bây giờ bạn đã biết kiến thức cơ bản về cách sử dụng ma trận nghịch đảo và định thức, bạn sẽ biết cách sử dụng những công cụ này để tìm hệ số của đa thức
Loại bỏ các quảng cáoNội suy đa thức với hệ thống tuyến tính
Bạn có thể sử dụng các hệ thống tuyến tính để tính toán các hệ số đa thức để các đa thức này bao gồm một số điểm cụ thể
Ví dụ, xét đa thức bậc hai y = P[x] = a₀ + a₁x + a₂x². Nhớ lại rằng khi bạn vẽ một đa thức bậc hai, bạn sẽ nhận được một hình parabol, hình parabol này sẽ khác nhau tùy thuộc vào các hệ số a₀, a₁ và a₂
Bây giờ, giả sử bạn muốn tìm một đa thức bậc hai cụ thể bao gồm các điểm [x, y] [1, 5], [2, 13] và [3, 25]. Làm cách nào bạn có thể tính a₀, a₁ và a₂ sao cho P[x] bao gồm các điểm này trong parabol của nó?
Đối với mỗi điểm mà bạn muốn đưa vào parabol, bạn có thể sử dụng biểu thức tổng quát của đa thức để có phương trình tuyến tính. Ví dụ: lấy điểm thứ hai, [x=2, y=13] và xét rằng y = a₀ + a₁x + a₂x², bạn có thể viết phương trình sau
Bằng cách này, với mỗi điểm [x, y], bạn sẽ nhận được một phương trình liên quan đến a₀, a₁ và a₂. Bởi vì bạn đang xem xét ba điểm khác nhau, nên cuối cùng bạn sẽ có một hệ gồm ba phương trình
Để kiểm tra xem hệ này có nghiệm duy nhất hay không, bạn có thể tính định thức của ma trận hệ số và kiểm tra xem nó có khác 0 không. Bạn có thể làm điều đó với đoạn mã sau
>>>
In [1]: import numpy as np
...: from scipy import linalg
In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 3, 9]]]
In [3]: linalg.det[A]
Out[3]:
1.9999999999999996
Cần lưu ý rằng sự tồn tại của giải pháp chỉ phụ thuộc vào
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
>>>
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
Kết quả này cho bạn biết rằng a₀ = 1, a₁ = 2 và a₂ = 2 là nghiệm của hệ. Nói cách khác, đa thức bao gồm các điểm [1, 5], [2, 13] và [3, 25] được cho bởi y = P[x] = 1 + 2x + 2x². Bạn có thể kiểm tra giải pháp cho từng điểm bằng cách nhập x và xác minh rằng P[x] bằng y
Lấy ví dụ về một hệ thống không có bất kỳ giải pháp nào, giả sử bạn đang cố gắng nội suy một parabol với các điểm [x, y] được cho bởi [1, 5], [2, 13] và [2, 25]. Nếu bạn xem kỹ những con số này, bạn sẽ nhận thấy rằng điểm thứ hai và thứ ba xem xét x = 2 và các giá trị khác nhau của y, điều này khiến bạn không thể tìm thấy một hàm bao gồm cả hai điểm
Thực hiện theo các bước tương tự như trước đây, bạn sẽ đến các phương trình cho hệ thống này, đó là các phương trình sau
Để xác nhận rằng hệ thống này không đưa ra một giải pháp duy nhất, bạn có thể tính toán yếu tố quyết định của ma trận hệ số bằng đoạn mã sau
>>>
In [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
...: linalg.det[A]
Out[6]:
0.0
Bạn có thể nhận thấy rằng giá trị của định thức bằng 0, điều đó có nghĩa là hệ thống không có nghiệm duy nhất. Điều này cũng có nghĩa là không tồn tại ma trận nghịch đảo của ma trận hệ số. Nói cách khác, ma trận hệ số là số ít
Tùy thuộc vào cấu trúc máy tính của bạn, bạn có thể nhận được một số rất nhỏ thay vì số không. Điều này xảy ra do các thuật toán số mà
In [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
...: linalg.det[A]
Out[6]:
0.0
Nói chung, bất cứ khi nào bạn gặp một số nhỏ, bạn có thể kết luận rằng hệ thống không có nghiệm duy nhất
Bạn có thể thử giải hệ phương trình tuyến tính bằng phương pháp nghịch đảo ma trận với đoạn mã sau
>>>
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
Bởi vì hệ thống không có giải pháp, bạn nhận được một ngoại lệ cho bạn biết rằng ma trận hệ số là số ít
Khi hệ thống có nhiều hơn một giải pháp, bạn sẽ gặp một kết quả tương tự. Giá trị của định thức của ma trận hệ số sẽ bằng 0 hoặc rất nhỏ, cho biết rằng ma trận hệ số một lần nữa là số ít
Để làm ví dụ về một hệ thống có nhiều hơn một nghiệm, bạn có thể thử nội suy một parabol khi xét các điểm [x, y] cho bởi [1, 5], [2, 13] và [2, 13]. Như bạn có thể nhận thấy, ở đây bạn đang xem xét hai điểm ở cùng một vị trí, điều này cho phép vô số nghiệm cho a₀, a₁ và a₂
Bây giờ bạn đã tìm hiểu cách làm việc với phép nội suy đa thức bằng các hệ thống tuyến tính, bạn sẽ thấy một kỹ thuật khác giúp nỗ lực tìm các hệ số cho bất kỳ tập hợp điểm nào
Loại bỏ các quảng cáoGiảm thiểu lỗi với bình phương tối thiểu
Bạn đã thấy rằng đôi khi bạn không thể tìm thấy một đa thức thỏa mãn chính xác một tập hợp các điểm. Tuy nhiên, thông thường khi bạn đang cố gắng nội suy một đa thức, bạn không quan tâm đến sự phù hợp chính xác. Bạn chỉ đang tìm kiếm một giải pháp xấp xỉ số điểm, cung cấp sai số tối thiểu có thể
Đây thường là trường hợp khi bạn đang làm việc với dữ liệu trong thế giới thực. Thông thường, nó bao gồm một số tiếng ồn do lỗi xảy ra trong quá trình thu thập, chẳng hạn như cảm biến không chính xác hoặc trục trặc và lỗi chính tả khi người dùng nhập dữ liệu theo cách thủ công
Sử dụng phương pháp bình phương nhỏ nhất, bạn có thể tìm ra nghiệm cho phép nội suy của đa thức, ngay cả khi ma trận hệ số là số ít. Bằng cách sử dụng phương pháp này, bạn sẽ tìm kiếm các hệ số của đa thức cung cấp sai số bình phương nhỏ nhất khi so sánh đường cong đa thức với các điểm dữ liệu của bạn
Trên thực tế, phương pháp bình phương nhỏ nhất thường được sử dụng để khớp đa thức với tập hợp lớn các điểm dữ liệu. Ý tưởng là cố gắng thiết kế một mô hình đại diện cho một số hành vi được quan sát
Ghi chú. Nếu một hệ phương trình tuyến tính có nghiệm duy nhất thì nghiệm bình phương nhỏ nhất sẽ bằng nghiệm duy nhất đó
Ví dụ: bạn có thể thiết kế một mô hình để cố gắng dự đoán giá ô tô. Để làm được điều đó, bạn có thể thu thập một số dữ liệu trong thế giới thực, bao gồm giá ô tô và một số tính năng khác như quãng đường đã đi, năm và loại ô tô. Với dữ liệu này, bạn có thể thiết kế một đa thức mô hình giá như một hàm của các tính năng khác và sử dụng bình phương nhỏ nhất để tìm các hệ số tối ưu của mô hình này
Chẳng bao lâu nữa, bạn sẽ làm việc trên một mô hình để giải quyết vấn đề này. Nhưng trước tiên, bạn sẽ xem cách sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Xây dựng các mô hình bình phương nhỏ nhất bằng cách sử dụng In [6]: linalg.det[A]
Out[6]:
45102.0
5
In [6]: linalg.det[A]
Out[6]:
45102.0
Để giải các bài toán bình phương nhỏ nhất,
In [6]: linalg.det[A]
Out[6]:
45102.0
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
Giống như bạn đã làm trước đây, sử dụng mô hình y = a₀ + a₁x + a₂x², bạn đến hệ thống tuyến tính sau
Sử dụng phương pháp bình phương nhỏ nhất, bạn có thể tìm ra giải pháp cho các hệ số a₀, a₁ và a₂ cung cấp một hình parabol giúp giảm thiểu chênh lệch bình phương giữa đường cong và các điểm dữ liệu. Đối với điều đó, bạn có thể sử dụng đoạn mã sau
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
5 ...: b = np.array[[5, 13, 25]].reshape[[3, 1]]
6
7In [3]: p, *_ = linalg.lstsq[A, b]
8 ...: p
9Out[3]:
10array[[[-0.42857143],
11 [ 1.14285714],
12 [ 4.28571429]]]
Trong chương trình này, bạn đã thiết lập như sau
Dòng 1 đến 2. Bạn nhập
5 dưới dạngIn [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [8]: x = linalg.inv[A] @ b --------------------------------------------------------------------------- LinAlgError Traceback [most recent call last] in ----> 1 x = linalg.inv[A] @ b LinAlgError: singular matrix
2 vàIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
3 từIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
4 để sử dụngIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
9In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [8]: x = linalg.inv[A] @ b --------------------------------------------------------------------------- LinAlgError Traceback [most recent call last] in ----> 1 x = linalg.inv[A] @ b LinAlgError: singular matrixDòng 4 đến 5. Bạn tạo ma trận hệ số A bằng cách sử dụng mảng NumPy có tên là
6 và vectơ có các số hạng độc lập b bằng cách sử dụng mảng NumPy có tên làIn [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]
7In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [5]: a = linalg.inv[A] @ b ...: a Out[5]: array[[[1.], [2.], [2.]]]dòng 7. Bạn tính nghiệm bình phương nhỏ nhất cho bài toán bằng cách sử dụng
9, lấy ma trận hệ số và vectơ có các số hạng độc lập làm đầu vàoIn [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]] In [8]: x = linalg.inv[A] @ b --------------------------------------------------------------------------- LinAlgError Traceback [most recent call last] in ----> 1 x = linalg.inv[A] @ b LinAlgError: singular matrix
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
5 ...: b = np.array[[5, 13, 25]].reshape[[3, 1]]
6
7In [3]: p, *_ = linalg.lstsq[A, b]
8 ...: p
9Out[3]:
10array[[[-0.42857143],
11 [ 1.14285714],
12 [ 4.28571429]]]
Như bạn có thể thấy, ngay cả khi xem xét một hệ thống tuyến tính không có giải pháp chính xác,
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
>>>
1In [4]: import matplotlib.pyplot as plt
2
3In [5]: x = np.linspace[0, 3, 1000]
4 ...: y = p[0] + p[1] * x + p[2] * x ** 2
5
6In [6]: plt.plot[x, y]
7 ...: plt.plot[1, 5, "ro"]
8 ...: plt.plot[2, 13, "ro"]
9 ...: plt.plot[2, 25, "ro"]
Chương trình này sử dụng
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
5 ...: b = np.array[[5, 13, 25]].reshape[[3, 1]]
6
7In [3]: p, *_ = linalg.lstsq[A, b]
8 ...: p
9Out[3]:
10array[[[-0.42857143],
11 [ 1.14285714],
12 [ 4.28571429]]]
Dòng 1. Bạn nhập
7 dưới dạng1In [1]: import numpy as np 2 ...: from scipy import linalg 3 4In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]] 5 ...: b = np.array[[5, 13, 25]].reshape[[3, 1]] 6 7In [3]: p, *_ = linalg.lstsq[A, b] 8 ...: p 9Out[3]: 10array[[[-0.42857143], 11 [ 1.14285714], 12 [ 4.28571429]]]
8, điển hình là1In [1]: import numpy as np 2 ...: from scipy import linalg 3 4In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]] 5 ...: b = np.array[[5, 13, 25]].reshape[[3, 1]] 6 7In [3]: p, *_ = linalg.lstsq[A, b] 8 ...: p 9Out[3]: 10array[[[-0.42857143], 11 [ 1.14285714], 12 [ 4.28571429]]]Dòng 3 đến 4. Bạn tạo một mảng NumPy có tên là
4, với các giá trị nằm trong khoảng từIn [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]] ...: linalg.det[A] Out[6]: 0.0
0 đến1In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]
1, chứa1In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]
2 điểm. Bạn cũng tạo một mảng NumPy có tên là1In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]
3 với các giá trị tương ứng của mô hình1In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]dòng 6. Bạn vẽ đường cong cho parabol thu được với mô hình cho bởi các điểm trong mảng
4 vàIn [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]] ...: linalg.det[A] Out[6]: 0.0
31In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]Dòng 7 đến 9. Màu đỏ [
6], bạn vẽ ba điểm được sử dụng để xây dựng mô hình1In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]
Đầu ra phải là hình sau
Lưu ý cách đường cong do mô hình cung cấp cố gắng ước lượng các điểm tốt nhất có thể
Ngoài
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
Có được các giải pháp bình phương nhỏ nhất bằng cách sử dụng một Pseudoinverse
Một cách khác để tính nghiệm bình phương nhỏ nhất là sử dụng nghịch đảo giả Moore-Penrose của ma trận
Bạn có thể nghĩ về nghịch đảo giả như một dạng tổng quát của nghịch đảo ma trận, vì nó bằng nghịch đảo ma trận thông thường khi ma trận không phải là số ít
Tuy nhiên, khi ma trận là số ít, đó là trường hợp trong các hệ thống tuyến tính thiếu nghiệm duy nhất, thì nghịch đảo giả tính toán ma trận cung cấp sự phù hợp tốt nhất, dẫn đến nghiệm bình phương nhỏ nhất
Sử dụng nghịch đảo giả, bạn có thể tìm thấy các hệ số cho parabol được sử dụng trong ví dụ trước
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Mã này rất giống với mã từ phần trước, ngoại trừ các dòng được đánh dấu
dòng 7. Bạn tính nghịch đảo giả của ma trận hệ số và lưu trữ nó trong
81In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]Dòng 9. Theo cùng một cách tiếp cận được sử dụng để giải các hệ thống tuyến tính với ma trận nghịch đảo, bạn tính các hệ số của phương trình parabola bằng cách sử dụng nghịch đảo giả và lưu trữ chúng trong vectơ
91In [4]: import matplotlib.pyplot as plt 2 3In [5]: x = np.linspace[0, 3, 1000] 4 ...: y = p[0] + p[1] * x + p[2] * x ** 2 5 6In [6]: plt.plot[x, y] 7 ...: plt.plot[1, 5, "ro"] 8 ...: plt.plot[2, 13, "ro"] 9 ...: plt.plot[2, 25, "ro"]
Như bạn mong đợi, giải pháp bình phương nhỏ nhất giống như giải pháp
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Tuy nhiên, điều đáng chú ý là bạn cũng có thể tính toán
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Thí dụ. Dự đoán giá xe ô tô với bình phương nhỏ nhất
Trong ví dụ này, bạn sẽ xây dựng một mô hình sử dụng bình phương tối thiểu để dự đoán giá ô tô đã qua sử dụng bằng cách sử dụng dữ liệu từ Bộ dữ liệu ô tô đã qua sử dụng. Tập dữ liệu này là một bộ sưu tập khổng lồ với 957 MB danh sách xe từ craigslist. org, bao gồm các loại phương tiện rất khác nhau
Khi làm việc với dữ liệu thực, thường phải thực hiện một số bước lọc và làm sạch để sử dụng dữ liệu để xây dựng mô hình. Trong trường hợp này, cần phải thu hẹp các loại phương tiện mà bạn sẽ đưa vào để có được kết quả tốt hơn với mô hình của mình
Vì trọng tâm chính của bạn ở đây là sử dụng bình phương nhỏ nhất để xây dựng mô hình, nên bạn sẽ bắt đầu với một tập dữ liệu đã được làm sạch, đây là một tập hợp con nhỏ từ tập hợp ban đầu. Trước khi bạn bắt đầu viết mã, hãy lấy tệp CSV dữ liệu đã được làm sạch bằng cách nhấp vào liên kết bên dưới và điều hướng đến
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Mã nguồn miễn phí. Nhấp vào đây để tải xuống mã và tập dữ liệu miễn phí mà bạn sẽ sử dụng để làm việc với các hệ thống tuyến tính và đại số bằng Python với
In [6]: linalg.det[A]
Out[6]:
45102.0
Trong các tài liệu có thể tải xuống, bạn cũng có thể xem Jupyter Notebook để tìm hiểu thêm về cách chuẩn bị dữ liệu
Chuẩn bị dữ liệu
Để tải tệp CSV và xử lý dữ liệu, bạn sẽ sử dụng pandas. Vì vậy, hãy đảm bảo cài đặt nó trong môi trường
In [7]: A_inv
Out[7]:
array[[[-0.01077558, 0.10655847, -0.03565252, -0.0058534 , -0.00372489],
[ 0.11287748, -0.00512172, -0.04010909, -0.00658507, -0.0041905 ],
[ 0.0052991 , -0.01536517, 0.21300608, -0.01975522, -0.0125715 ],
[-0.0064077 , -0.01070906, -0.02325839, -0.01376879, 0.08214713],
[-0.00931223, -0.01902355, -0.00611946, 0.1183983 , -0.01556472]]]
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Sau khi tải xuống dữ liệu và thiết lập gấu trúc, bạn có thể khởi động Máy tính xách tay Jupyter mới và tải dữ liệu bằng cách chạy khối mã sau
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Thao tác này sẽ tạo một Khung dữ liệu gấu trúc có tên là
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Một đối tượng
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Bạn có thể xem một trong các dòng của DataFrame bằng cách sử dụng
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Như bạn có thể thấy, tập dữ liệu này bao gồm chín cột, với dữ liệu sau
Tên cột Mô tả
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Để sử dụng dữ liệu này nhằm xây dựng một mô hình bình phương nhỏ nhất, bạn sẽ cần biểu diễn dữ liệu phân loại theo cách số. Trong hầu hết các trường hợp, dữ liệu phân loại được chuyển đổi thành một tập hợp các biến giả, là các biến có thể nhận giá trị
1In [4]: import matplotlib.pyplot as plt
2
3In [5]: x = np.linspace[0, 3, 1000]
4 ...: y = p[0] + p[1] * x + p[2] * x ** 2
5
6In [6]: plt.plot[x, y]
7 ...: plt.plot[1, 5, "ro"]
8 ...: plt.plot[2, 13, "ro"]
9 ...: plt.plot[2, 25, "ro"]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Để làm ví dụ về sự chuyển đổi này, hãy xem xét cột
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [4]: import matplotlib.pyplot as plt
2
3In [5]: x = np.linspace[0, 3, 1000]
4 ...: y = p[0] + p[1] * x + p[2] * x ** 2
5
6In [6]: plt.plot[x, y]
7 ...: plt.plot[1, 5, "ro"]
8 ...: plt.plot[2, 13, "ro"]
9 ...: plt.plot[2, 25, "ro"]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Lưu ý rằng bạn sẽ chỉ cần một cột giả để biểu thị một cột phân loại có thể nhận hai giá trị khác nhau. Tương tự, đối với một cột phân loại có thể nhận N giá trị, bạn sẽ cần N-1 cột giả, vì một trong các giá trị sẽ được coi là mặc định
Trong gấu trúc, bạn có thể chuyển đổi các cột phân loại này thành các cột giả với
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Tại đây, bạn đang tạo một DataFrame mới có tên là
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Bây giờ bạn đã chuyển đổi các biến phân loại thành tập hợp các biến giả, bạn có thể sử dụng thông tin này để xây dựng mô hình của mình. Về cơ bản, mô hình sẽ bao gồm một hệ số cho mỗi cột này—ngoại trừ
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Tuy nhiên, theo thông lệ, việc xem xét một hệ số bổ sung đại diện cho một giá trị không đổi được thêm vào tổ hợp trọng số của các biến khác. Hệ số này được gọi là hệ số chặn và bạn có thể đưa nó vào mô hình của mình bằng cách thêm một cột bổ sung vào dữ liệu, với tất cả các hàng bằng
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Bây giờ bạn đã sắp xếp tất cả dữ liệu, bạn có thể tạo các mảng NumPy để xây dựng mô hình của mình bằng cách sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Xây dựng mô hình
Để tạo các mảng NumPy để nhập vào
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Ma trận hệ số
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
In [4]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [5]: a = linalg.inv[A] @ b
...: a
Out[5]:
array[[[1.],
[2.],
[2.]]]
In [7]: b = np.array[[5, 13, 25]].reshape[[3, 1]]
In [8]: x = linalg.inv[A] @ b
---------------------------------------------------------------------------
LinAlgError Traceback [most recent call last]
in
----> 1 x = linalg.inv[A] @ b
LinAlgError: singular matrix
>>>
In [6]: linalg.det[A]
Out[6]:
45102.0
Đây là các hệ số mà bạn nên sử dụng để lập mô hình
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
>>>
In [6]: linalg.det[A]
Out[6]:
45102.0
Một trong những đặc điểm hay của mô hình hồi quy tuyến tính là nó khá dễ hiểu. Trong trường hợp này, bạn có thể kết luận từ các hệ số rằng giá trị của chiếc xe tăng khoảng $847 khi
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
Bây giờ bạn đã có được mô hình, bạn sẽ sử dụng nó để dự đoán giá của một chiếc ô tô
dự đoán giá
Sử dụng mô hình được đưa ra bởi giải pháp bình phương nhỏ nhất, bạn có thể dự đoán giá của một chiếc ô tô được biểu thị bằng một vectơ với các giá trị cho từng biến được sử dụng trong mô hình
>>>
In [6]: linalg.det[A]
Out[6]:
45102.0
Vì vậy, một chiếc hatchback 4 xi-lanh đời 2010, với hộp số tự động, nhiên liệu xăng và đã đi 50.000 dặm, trong tình trạng tốt, có thể được biểu diễn bằng vectơ sau
>>>
In [6]: linalg.det[A]
Out[6]:
45102.0
Bạn có thể có được dự đoán về giá bằng cách tính tích vô hướng giữa vectơ
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[
5 ...: [
6 ...: [1, 9, 2, 1, 1],
7 ...: [10, 1, 2, 1, 1],
8 ...: [1, 0, 5, 1, 1],
9 ...: [2, 1, 1, 2, 9],
10 ...: [2, 1, 2, 13, 2],
11 ...: ]
12 ...: ]
13
14In [3]: b = np.array[[170, 180, 140, 180, 350]].reshape[[5, 1]]
15
16In [4]: A_inv = linalg.inv[A]
17
18In [5]: x = A_inv @ b
19 ...: x
20Out[5]:
21array[[[10.],
22 [10.],
23 [20.],
24 [20.],
25 [10.]]]
1In [1]: import numpy as np
2 ...: from scipy import linalg
3
4In [2]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
5 ...: b = np.array[[5, 13, 25]].reshape[[3, 1]]
6
7In [3]: p, *_ = linalg.lstsq[A, b]
8 ...: p
9Out[3]:
10array[[[-0.42857143],
11 [ 1.14285714],
12 [ 4.28571429]]]
In [6]: A = np.array[[[1, 1, 1], [1, 2, 4], [1, 2, 4]]]
...: linalg.det[A]
Out[6]:
0.0
>>>
In [6]: linalg.det[A]
Out[6]:
45102.0
Trong ví dụ này, giá dự đoán cho chiếc hatchback là khoảng $6.160. Cần lưu ý rằng các hệ số của mô hình bao gồm một số yếu tố không chắc chắn vì dữ liệu được sử dụng để lấy mô hình có thể bị sai lệch đối với một loại ô tô cụ thể, chẳng hạn
Bên cạnh đó, việc lựa chọn mô hình đóng vai trò lớn đến chất lượng ước lượng. Bình phương nhỏ nhất là một trong những kỹ thuật được sử dụng nhiều nhất để xây dựng mô hình vì nó đơn giản và mang lại các mô hình có thể giải thích được. Trong ví dụ này, bạn đã thấy cách sử dụng
In [6]: linalg.det[A]
Out[6]:
45102.0
Phần kết luận
Chúc mừng. Bạn đã học cách sử dụng một số khái niệm đại số tuyến tính với Python để giải các bài toán liên quan đến mô hình tuyến tính. Bạn đã phát hiện ra rằng các vectơ và ma trận rất hữu ích để biểu diễn dữ liệu và bằng cách sử dụng các hệ thống tuyến tính, bạn có thể mô hình hóa các vấn đề thực tế và giải quyết chúng một cách hiệu quả
Trong hướng dẫn này, bạn đã học cách
- Nghiên cứu các hệ thống tuyến tính bằng cách sử dụng các định thức và giải quyết các vấn đề bằng cách sử dụng nghịch đảo ma trận
- Nội suy các đa thức để phù hợp với một tập hợp các điểm bằng cách sử dụng các hệ thống tuyến tính
- Sử dụng Python để giải các bài toán hồi quy tuyến tính
- Sử dụng hồi quy tuyến tính để dự đoán giá dựa trên dữ liệu lịch sử
Đại số tuyến tính là một chủ đề rất rộng. Để biết thêm thông tin về một số ứng dụng đại số tuyến tính khác, hãy xem các tài nguyên sau
- Làm việc với các hệ thống tuyến tính trong Python với
5In [6]: linalg.det[A] Out[6]: 45102.0 - Trăn khoa học. Sử dụng SciPy để tối ưu hóa
- Lập trình tuyến tính thực hành. Tối ưu hóa với Python
- NumPy, SciPy và gấu trúc. Mối tương quan với Python
Hãy tiếp tục học tập và đừng ngại để lại bất kỳ câu hỏi hoặc nhận xét nào bên dưới
Mã nguồn miễn phí. Nhấp vào đây để tải xuống mã và tập dữ liệu miễn phí mà bạn sẽ sử dụng để làm việc với các hệ thống tuyến tính và đại số bằng Python với
In [6]: linalg.det[A]
Out[6]:
45102.0
Đánh dấu là đã hoàn thành
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về Candido Renato
Nhà nghiên cứu về xử lý tín hiệu số, viễn thông và máy học. người đam mê {miễn phí, tự do, nguồn mở} {phần mềm, phần cứng, văn hóa, khoa học}
» Thông tin thêm về RenatoMỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Aldren
David
Geir Arne
kate
Sadie
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Chuyên gia Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ EmailBài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi