Hướng dẫn intercept trong python - intercept in python

Mục lục bài viết:

• Hồi quy
  • Hồi quy là gì?
  • Khi nào bạn cần hồi quy?
• Hồi quy tuyến tính
  • Công thức
  • Hiệu suất hồi quy
  • Đơn hồi quy tuyến tính
  • Đa hồi quy tuyến tính
  • Hồi quy đa thức
  • Underfitting và Overfitting
• Triển khai hồi quy tuyến tính bằng Python
  • Các gói Python cho hồi quy tuyến tính
  • Đơn hồi quy tuyến tính với scikit-learning
  • Đa hồi quy tuyến tính với scikit-learning
  • Hồi quy đa thức với scikit-learning
  • Hồi quy tuyến tính nâng cao với statsmodels
• Vượt ra ngoài hồi quy tuyến tính
• Phần kết luận

Chúng ta đang sống trong thời đại của một lượng lớn dữ liệu, máy tính mạnh mẽ và trí tuệ nhân tạo. Điều này chỉ là khởi đầu. Khoa học dữ liệu và máy học đang thúc đẩy nhận dạng hình ảnh, phát triển phương tiện tự hành, các quyết định trong lĩnh vực tài chính và năng lượng, tiến bộ trong y học, sự nổi lên của mạng xã hội, v.v. Hồi quy tuyến tính là một phần quan trọng của điều này.

Hồi quy tuyến tính là một trong những kỹ thuật thống kê và học máy cơ bản. Cho dù bạn muốn thống kê, học máy hay khoa học máy tính, thì rất có thể bạn sẽ cần nó. Bạn nên tìm hiểu nó trước và sau đó tiến hành các phương pháp phức tạp hơn.

Đến cuối bài viết này, bạn sẽ học được:

• Hồi quy tuyến tính là gì
• Hồi quy tuyến tính được sử dụng để làm gì
• Cách hoạt động của hồi quy tuyến tính
• Cách triển khai hồi quy tuyến tính trong Python, từng bước

Hồi quy

Hồi quy là gì?

Hồi quy là gì?

Khi nào bạn cần hồi quy?

Hồi quy tuyến tính

Công thức

Hiệu suất hồi quy

Đơn hồi quy tuyến tính

Đa hồi quy tuyến tính

Hồi quy đa thức

Underfitting và Overfitting

Triển khai hồi quy tuyến tính bằng Python

Các gói Python cho hồi quy tuyến tính

Khi nào bạn cần hồi quy?

Hồi quy tuyến tính

Công thức

Hiệu suất hồi quy

Hồi quy tuyến tính

Công thức

Công thức

Hiệu suất hồi quy

Hồi quy tuyến tính tính toán các ước (estimator) của các hệ số hồi quy hoặc đơn giản là trọng số dự đoán, được ký hiệu bằng 𝑏₀, 𝑏₁,…, 𝑏ᵣ. Chúng định nghĩa hàm hồi quy ước lượng 𝑓(𝐱) = 𝑏₀ + 𝑏₁𝑥₁ + ⋯ + 𝑏ᵣ𝑥ᵣ. Hàm này phải nắm bắt đầy đủ các mối quan hệ phụ thuộc giữa các đầu vào và đầu ra.

Ước hoặc phản hồi được dự đoán, 𝑓(𝐱ᵢ), với 𝑖 = 1, ..., 𝑛, cần phải càng gần càng tốt để tương ứng với câu trả lời thực tế 𝑦ᵢ. Hiệu 𝑦ᵢ - 𝑓 (𝐱ᵢ) với 𝑖 = 1,…, 𝑛, được gọi là phần dư. Hồi quy là xác định các trọng số được dự đoán tốt nhất, đó là các trọng số tương ứng với các phần dư nhỏ nhất.

Để có được trọng số tốt nhất, bạn thường tối thiểu hóa tổng các phần dư bình phương (SSR) với 𝑖 = 1,…, 𝑛: SSR = Σᵢ (𝑦ᵢ - 𝑓 (𝐱ᵢ)) ². Cách tiếp cận này được gọi là phương pháp bình phương nhỏ nhất thông thường.

Hiệu suất hồi quy

Sự thay đổi của các phản hồi thực tế 𝑦ᵢ, 𝑖 = 1,…, 𝑛, xảy ra một phần do sự phụ thuộc vào các yếu tố dự đoán 𝐱ᵢ. Tuy nhiên, cũng có một phương sai cố hữu bổ sung của đầu ra.

Các hệ số xác định, ký hiệu là 𝑅², cho bạn biết số lượng biến thể trong 𝑦 có thể được giải thích bởi sự phụ thuộc vào 𝐱 sử dụng mô hình hồi quy cụ thể. 𝑅² lớn hơn cho thấy sự phù hợp hơn và có nghĩa là mô hình có thể giải thích tốt hơn sự biến đổi của đầu ra với các đầu vào khác nhau.

Giá trị 𝑅² = 1 tương ứng với SSR = 0, nghĩa là hoàn toàn phù hợp vì giá trị của câu trả lời được dự đoán và thực tế hoàn toàn khớp với nhau.

Đơn hồi quy tuyến tính

Đơn hồi quy tuyến tính hoặc đơn biến thiên là trường hợp đơn giản nhất của hồi quy tuyến tính với một biến độc lập duy nhất, 𝐱 = 𝑥.

Hình sau minh họa đơn hồi quy tuyến tính:

Ví dụ về hồi quy tuyến tính đơn giản

Khi thực hiện hồi quy tuyến tính đơn giản, bạn thường bắt đầu với một tập hợp các cặp đầu vào-đầu ra (𝑥-𝑦) nhất định (vòng tròn màu xanh lá cây). Những cặp này là quan sát của bạn. Ví dụ, quan sát ngoài cùng bên trái (vòng tròn màu xanh lá cây) có đầu vào 𝑥 = 5 và đầu ra thực tế (phản hồi) 𝑦 = 5. Quan sát tiếp theo có 𝑥 = 15 và 𝑦 = 20, v.v.

Hàm hồi quy ước lượng (đường đen) có phương trình 𝑓(𝑥) = 𝑏₀ + 𝑏₁𝑥. Mục tiêu của bạn là tính toán các giá trị tối ưu của trọng số dự đoán 𝑏₀ và 𝑏₁ để giảm thiểu SSR và xác định hàm hồi quy ước tính. Giá trị của 𝑏₀, còn gọi là đánh chặn, cho thấy điểm mà đường hồi quy ước đi qua trục 𝑦. Nó là giá trị của phản hồi ước lượng 𝑓(𝑥) cho 𝑥 = 0. Giá trị của 𝑏₁ xác định độ dốc của đường hồi quy ước tính.

Các phản hồi dự đoán (ô vuông màu đỏ) là các điểm trên đường hồi quy tương ứng với các giá trị đầu vào. Ví dụ: đối với đầu vào 𝑥 = 5, phản hồi dự đoán là 𝑓(5) = 8,33 (được biểu thị bằng hình vuông màu đỏ ngoài cùng bên trái).

Phần dư (các đường màu xám gạch ngang dọc) có thể được tính là 𝑦ᵢ - 𝑓(𝐱ᵢ) = 𝑦ᵢ - 𝑏₀ - 𝑏₁𝑥ᵢ cho 𝑖 = 1,…, 𝑛. Chúng là khoảng cách giữa các hình tròn màu xanh lá cây và hình vuông màu đỏ. Khi bạn thực hiện hồi quy tuyến tính, bạn thực sự đang cố gắng giảm thiểu những khoảng cách này và làm cho các hình vuông màu đỏ càng gần với các hình tròn màu xanh lá cây được xác định trước càng tốt.

Đa hồi quy tuyến tính

Hồi quy tuyến tính nhiều biến hoặc đa biến là trường hợp hồi quy tuyến tính với hai hoặc nhiều biến độc lập.

Nếu chỉ có hai biến độc lập, thì hàm hồi quy ước lượng là 𝑓(𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂. Nó biểu diễn một mặt phẳng hồi quy trong không gian ba chiều. Mục tiêu của hồi quy là xác định giá trị của các trọng số 𝑏₀, 𝑏₁ và 𝑏₂ sao cho mặt phẳng này càng gần với các phản hồi thực tế càng tốt và mang lại SSR tối thiểu.

Trường hợp có nhiều hơn hai biến độc lập cũng tương tự, nhưng tổng quát hơn. Hàm hồi quy ước tính là 𝑓(𝑥₁,…, 𝑥ᵣ) = 𝑏₀ + 𝑏₁𝑥₁ + ⋯ + 𝑏ᵣ𝑥ᵣ, và có 𝑟 + 1 trọng số được xác định khi số lượng đầu vào là 𝑟.

Hồi quy đa thức

Bạn có thể coi hồi quy đa thức như một trường hợp tổng quát của hồi quy tuyến tính. Bạn giả định sự phụ thuộc đa thức giữa đầu ra và đầu vào và do đó, hàm hồi quy ước lượng đa thức.

Nói cách khác, ngoài các thuật ngữ tuyến tính như 𝑏₁𝑥₁, hàm hồi quy 𝑓 của bạn có thể bao gồm các thuật ngữ phi tuyến tính như 𝑏₂𝑥₁², 𝑏₃𝑥₁³ hoặc thậm chí 𝑏₄𝑥₁𝑥₂, 𝑏₅𝑥₁²𝑥₂, v.v.

Ví dụ đơn giản nhất về hồi quy đa thức có một biến độc lập duy nhất và hàm hồi quy ước lượng là đa thức bậc 2: 𝑓(𝑥) = 𝑏₀ + 𝑏₁𝑥 + 𝑏₂𝑥².

Bây giờ, hãy nhớ rằng bạn muốn tính toán 𝑏₀, 𝑏₁ và 𝑏₂ để giảm thiểu SSR. Đây là những ẩn số của bạn!

Hãy ghi nhớ điều này, hãy so sánh hàm hồi quy trước đó với hàm 𝑓(𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ được sử dụng cho hồi quy tuyến tính. Chúng trông rất giống nhau và đều là hàm tuyến tính của các ẩn số 𝑏₀, 𝑏₁ và 𝑏₂. Đây là lý do tại sao bạn có thể giải quyết vấn đề hồi quy đa thức như một bài toán tuyến tính với thuật ngữ 𝑥² được coi là một biến đầu vào.

Trong trường hợp hai biến và đa thức bậc 2, hàm hồi quy có dạng: 𝑓(𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ + 𝑏₃𝑥₁² + 𝑏₄𝑥₁𝑥₂ + 𝑏₅𝑥₂². Quy trình giải quyết vấn đề giống với trường hợp trước. Bạn áp dụng hồi quy tuyến tính cho năm đầu vào: 𝑥₁, 𝑥₂, 𝑥₁², 𝑥₁𝑥₂ và 𝑥₂². Những gì bạn nhận được là kết quả của hồi quy là giá trị của sáu trọng số tối thiểu hóa SSR: 𝑏₀, 𝑏₁, 𝑏₂, 𝑏₃, 𝑏₄ và 𝑏₅.

Tất nhiên, có nhiều vấn đề tổng quát hơn, nhưng điều này đủ để minh họa cho điểm.

Underfitting và Overfitting

Một câu hỏi rất quan trọng có thể nảy sinh khi bạn thực hiện hồi quy đa thức có liên quan đến việc lựa chọn mức độ tối ưu của hàm hồi quy đa thức.

Không có quy tắc đơn giản để làm điều này. Nó phụ thuộc vào từng trường hợp. Tuy nhiên, bạn nên lưu ý hai vấn đề có thể xảy ra theo sự lựa chọn của mức độ: trang bị thiếu và trang bị thừa.

Trang bị thiếu xảy ra khi một mô hình không thể nắm bắt chính xác các yếu tố phụ thuộc giữa các dữ liệu, thường là do sự đơn giản của chính nó. Nó thường mang lại 𝑅² thấp với dữ liệu đã biết và khả năng tổng quát hóa kém khi áp dụng với dữ liệu mới.

Trang bị thừa xảy ra khi một mô hình lại học cả sự phụ thuộc giữa dữ liệu và các biến động ngẫu nhiên. Nói cách khác, mô hình được học với dữ liệu hiện có là quá tốt. Các mô hình phức tạp, có nhiều tính năng hoặc thuật ngữ, thường dễ bị trang bị quá mức. Khi áp dụng cho dữ liệu đã biết, các mô hình như vậy thường mang lại 𝑅² cao. Tuy nhiên, chúng thường không khái quát hóa tốt và có 𝑅² thấp hơn đáng kể khi được sử dụng với dữ liệu mới.

Hình tiếp theo minh họa các mô hình thiếu trang bị, trang bị tốt và trang bị thừa:

Ví dụ về các mẫu không được trang bị tốt, được trang bị tốt và được trang bị thừa

Biểu đồ trên cùng bên trái hiển thị một đường hồi quy tuyến tính có 𝑅² thấp. Điều quan trọng nữa là một đường thẳng không thể tính đến thực tế là phản ứng thực tế tăng lên khi 𝑥 di chuyển từ 25 về 0. Đây có thể là một ví dụ về trang bị thiếu.

Biểu đồ trên cùng bên phải minh họa hồi quy đa thức với mức độ bằng 2. Trong trường hợp này, đây có thể là mức độ tối ưu để mô hình hóa dữ liệu này. Mô hình có giá trị 𝑅² phù hợp trong nhiều trường hợp và hiển thị xu hướng một cách độc đáo.

Biểu đồ dưới cùng bên trái trình bày hồi quy đa thức với bậc bằng 3. Giá trị của 𝑅² cao hơn trong các trường hợp trước. Mô hình này hoạt động tốt hơn với dữ liệu đã biết so với các mô hình trước đó. Tuy nhiên, nó cho thấy một số dấu hiệu của việc trang bị thừa, đặc biệt là đối với các giá trị đầu vào gần 60 khi dòng bắt đầu giảm, mặc dù dữ liệu thực tế không cho thấy điều đó.

Cuối cùng, ở biểu đồ dưới cùng bên phải, bạn có thể thấy sự phù hợp hoàn hảo: sáu điểm và đường đa thức bậc 5 (hoặc cao hơn) cho kết quả 𝑅² = 1. Mỗi phản hồi thực tế bằng với dự đoán tương ứng của nó.

Trong một số tình huống, đây có thể là chính xác những gì bạn đang tìm kiếm. Tuy nhiên, trong nhiều trường hợp, đây là một mô hình được trang bị thừa. Nó có khả năng có hành vi kém với dữ liệu không nhìn thấy, đặc biệt là với các đầu vào lớn hơn 50.

Ví dụ, nó giả định, mà không có bất kỳ bằng chứng nào, rằng có sự sụt giảm đáng kể trong các phản hồi cho 𝑥> 50 và 𝑦 bằng 0 cho 𝑥 gần 60. Hành vi như vậy là hậu quả của nỗ lực quá mức để tìm hiểu và điều chỉnh dữ liệu hiện có.

Có rất nhiều nguồn mà bạn có thể tìm thêm thông tin về hồi quy nói chung và hồi quy tuyến tính nói riêng. Các trang phân tích hồi quy trên Wikipedia, bài báo hồi quy tuyến tính của Wikipedia, cũng như bài viết hồi quy tuyến tính của Học viện Khan là điểm khởi đầu tốt.

Triển khai hồi quy tuyến tính bằng Python

Đã đến lúc bắt đầu triển khai hồi quy tuyến tính bằng Python. Về cơ bản, tất cả những gì bạn nên làm là áp dụng các gói thích hợp và các hàm và lớp của chúng.

Các gói Python cho hồi quy tuyến tính

Gói NumPy là một gói khoa học Python cơ bản cho phép nhiều hoạt động hiệu suất cao trên các mảng đơn và đa chiều. Nó cũng cung cấp nhiều thói quen toán học. Tất nhiên, nó cũng là mã nguồn mở.

Nếu bạn không quen với NumPy, bạn có thể sử dụng Hướng dẫn sử dụng NumPy chính thức và đọc Look Ma, No For-Loops: Array Programming With NumPy. Ngoài ra, So sánh hiệu suất Pure Python vs NumPy vs TensorFlow có thể cung cấp cho bạn một ý tưởng khá tốt về hiệu suất mà bạn có thể đạt được khi áp dụng NumPy.

Gói scikit-learning là một thư viện Python được sử dụng rộng rãi để học máy, được xây dựng dựa trên NumPy và một số gói khác. Nó cung cấp các phương tiện để xử lý trước dữ liệu, giảm kích thước, thực hiện hồi quy, phân loại, phân cụm và hơn thế nữa. Giống như NumPy, scikit-learning cũng là mã nguồn mở.

Bạn có thể xem trang Mô hình tuyến tính tổng quát trên trang web scikit-learning để tìm hiểu thêm về mô hình tuyến tính và hiểu sâu hơn về cách hoạt động của gói này.

Nếu bạn muốn triển khai hồi quy tuyến tính và cần chức năng vượt ra ngoài phạm vi của scikit-learning, bạn nên cân nhắc 

model.fit(x, y)

Bạn có thể tìm thêm thông tin về 

model.fit(x, y)

Đơn hồi quy tuyến tính với scikit-learning

Hãy bắt đầu với trường hợp đơn giản nhất, đó là hồi quy tuyến tính đơn giản.

Có năm bước cơ bản khi bạn triển khai hồi quy tuyến tính:

1. Import các gói và lớp bạn cần.
2. Cung cấp dữ liệu để làm việc và cuối cùng thực hiện các chuyển đổi thích hợp.
3. Tạo mô hình hồi quy và phù hợp với dữ liệu hiện có.
4. Kiểm tra kết quả mô hình để biết mô hình có đạt yêu cầu hay không.
5. Áp dụng mô hình cho các dự đoán.

Các bước này ít nhiều chung chung cho hầu hết các cách tiếp cận và triển khai hồi quy.

Bước 1: Import các gói và lớp

Bước đầu tiên là import gói 

model.fit(x, y)

model.fit(x, y)

model.fit(x, y)

model = LinearRegression().fit(x, y)

import numpy as np
from sklearn.linear_model import LinearRegression

Bây giờ, bạn có tất cả các chức năng cần thiết để thực hiện hồi quy tuyến tính.

Kiểu dữ liệu cơ bản của NumPy là kiểu mảng được gọi 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

Lớp 

model = LinearRegression().fit(x, y)

Bước 2: Cung cấp dữ liệu

Bước thứ hai là xác định dữ liệu để làm việc. Các đầu vào (bộ hồi quy, 𝑥) và đầu ra (bộ dự đoán, 𝑦) phải là mảng (các đối tượng của của lớp 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bây giờ, bạn có hai mảng: đầu vào 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.715875613747954

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Như bạn có thể thấy, 

model = LinearRegression().fit(x, y)

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.715875613747954

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.715875613747954

model = LinearRegression().fit(x, y)

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.715875613747954

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

Bước 3: Tạo một mô hình và phù hợp với nó

Bước tiếp theo là tạo mô hình hồi quy tuyến tính và điều chỉnh nó bằng cách sử dụng dữ liệu hiện có.

Hãy tạo một thể hiện của lớp 

model.fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression()

Câu lệnh trên tạo biến 

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

model.fit(x, y)

model.fit(x, y)

• >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  6 là một Boolean (mặc định là 

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) quyết định xem có tính toán chặn 𝑏₀ (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) hay coi nó bằng không (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9).

• >>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
  >>> print('intercept:', new_model.intercept_)
  intercept: [5.63333333]
  >>> print('slope:', new_model.coef_)
  slope: [[0.54]]

  0 là một Boolean (mặc định là 

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9) quyết định có chuẩn hóa các biến đầu vào (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) hay không (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9).

• >>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
  >>> print('intercept:', new_model.intercept_)
  intercept: [5.63333333]
  >>> print('slope:', new_model.coef_)
  slope: [[0.54]]

  4 là một Boolean (mặc định là 

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) quyết định việc sao chép (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) hoặc ghi đè các biến đầu vào (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9).

• >>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
  >>> print('intercept:', new_model.intercept_)
  intercept: [5.63333333]
  >>> print('slope:', new_model.coef_)
  slope: [[0.54]]

  8 là một số nguyên hoặc 

  >>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
  >>> print('intercept:', new_model.intercept_)
  intercept: [5.63333333]
  >>> print('slope:', new_model.coef_)
  slope: [[0.54]]

  9 (mặc định) và đại diện cho số lượng công việc được sử dụng trong tính toán song song. 

  >>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
  >>> print('intercept:', new_model.intercept_)
  intercept: [5.63333333]
  >>> print('slope:', new_model.coef_)
  slope: [[0.54]]

  9 thường có nghĩa là một công việc và 

  >>> y_pred = model.predict(x)
  >>> print('predicted response:', y_pred, sep='\n')
  predicted response:
  [ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

  1 sử dụng tất cả các bộ xử lý.

Ví dụ trên sử dụng các giá trị mặc định của tất cả các tham số.

Đã đến lúc bắt đầu sử dụng mô hình. Trước tiên, bạn cần phải gọi 

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

model = LinearRegression().fit(x, y)

model.fit(x, y)

Với 

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

Câu lệnh này thực hiện tương tự như hai câu trước. Nó chỉ ngắn hơn.

Bước 4: Nhận kết quả

Khi bạn đã phù hợp với mô hình của mình, bạn có thể nhận được kết quả để kiểm tra xem mô hình có hoạt động tốt hay không và giải thích nó.

Bạn có thể nhận được hệ số xác định (𝑅²) với lệnh 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

model = LinearRegression().fit(x, y)

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.715875613747954

Khi bạn đang áp dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

Các thuộc tính của 

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

Đoạn mã trên minh họa cách lấy 𝑏₀ và 𝑏₁. Bạn có thể nhận thấy rằng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Giá trị 𝑏₀ = 5,63 (gần đúng) minh họa rằng mô hình của bạn dự đoán phản ứng 5,63 khi 𝑥 bằng 0. Giá trị 𝑏₁ = 0,54 có nghĩa là phản ứng dự đoán tăng 0,54 khi 𝑥 tăng thêm một.

Bạn nên lưu ý rằng bạn cũng có thể cung cấp 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

>>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
>>> print('intercept:', new_model.intercept_)
intercept: [5.63333333]
>>> print('slope:', new_model.coef_)
slope: [[0.54]]

Như bạn có thể thấy, ví dụ này rất giống với ví dụ trước, nhưng trong trường hợp này, 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bước 5: Dự đoán phản hồi

Khi có một mô hình ưng ý, bạn có thể sử dụng nó để dự đoán với dữ liệu hiện có hoặc dữ liệu mới.

Để nhận được phản hồi dự đoán, hãy sử dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

Khi áp dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Đây là một cách gần giống nhau để dự đoán phản ứng:

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Trong trường hợp này, bạn nhân từng phần tử của 

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Kết quả đầu ra ở đây chỉ khác với ví dụ trước đó về kích thước. Phản hồi được dự đoán bây giờ là một mảng hai chiều, trong khi trong trường hợp trước, nó có một chiều.

Nếu bạn giảm số chiều của 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Trong thực tế, các mô hình hồi quy thường được áp dụng cho các dự báo. Điều này có nghĩa là bạn có thể sử dụng các mô hình được trang bị để tính toán kết quả đầu ra dựa trên một số đầu vào mới khác:

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Ở đây, 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model.fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bạn có thể tìm thêm thông tin về 

model.fit(x, y)

Đa hồi quy tuyến tính với scikit-learning

Bạn có thể thực hiện đa hồi quy đa tuyến tính theo các bước tương tự như bạn làm đối với đơn hồi quy tuyến tính.

Bước 1 và 2: Import gói và lớp và cung cấp dữ liệu

Trước tiên, bạn import 

model.fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Đó là một cách đơn giản để xác định đầu vào 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Trong đa hồi quy tuyến tính, 

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

Bước 3: Tạo một mô hình và phù hợp với nó

Bước tiếp theo là tạo mô hình hồi quy như một đối tượng của 

model.fit(x, y)

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

Kết quả của câu lệnh này là biến 

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

model.fit(x, y)

Bước 4: Nhận kết quả

Bạn có thể có được các thuộc tính của mô hình theo cách tương tự như trong trường hợp đơn hồi quy tuyến tính:

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bạn nhận được giá trị của 𝑅² bằng cách sử dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Trong ví dụ này, giới hạn xấp xỉ 5,52 và đây là giá trị của phản hồi được dự đoán khi 𝑥₁ = 𝑥₂ = 0. Việc tăng 𝑥₁ thêm 1 dẫn đến sự gia tăng của phản hồi dự đoán thêm 0,45. Tương tự, khi 𝑥₂ tăng thêm 1, thì phản ứng tăng 0,26.

Bước 5: Dự đoán phản hồi

Các dự đoán cũng hoạt động theo cách tương tự như trong trường hợp đơn hồi quy tuyến tính:

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Phản ứng dự đoán nhận được với 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bạn có thể dự đoán các giá trị đầu ra bằng cách nhân từng cột của đầu vào với trọng số thích hợp, tính tổng các kết quả và thêm số chặn vào tổng.

Bạn cũng có thể áp dụng mô hình này cho dữ liệu mới:

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Đó là dự đoán sử dụng mô hình hồi quy tuyến tính.

Hồi quy đa thức với scikit-learning

Thực hiện hồi quy đa thức với scikit-learning rất giống với hồi quy tuyến tính. Chỉ có một bước bổ sung: bạn cần biến đổi mảng đầu vào để bao gồm các số hạng phi tuyến tính như 𝑥².

Bước 1: Import các gói và lớp

Ngoài 

model.fit(x, y)

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Quá trình import hiện đã hoàn tất và bạn có mọi thứ cần thiết để làm việc.

Bước 2a: Cung cấp dữ liệu

Bước này xác định đầu vào và đầu ra và giống như trong trường hợp hồi quy tuyến tính:

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Bây giờ bạn có đầu vào và đầu ra ở định dạng phù hợp. Hãy nhớ rằng bạn cần đầu vào là một mảng hai chiều. Đó là lý do tại sao 

model = LinearRegression().fit(x, y)

Bước 2b: Chuyển đổi dữ liệu đầu vào

Đây là bước mới bạn cần thực hiện cho hồi quy đa thức!

Như bạn đã thấy trước đó, bạn cần bao gồm 𝑥² (và có thể là các thuật ngữ khác) làm các tính năng bổ sung khi triển khai hồi quy đa thức. Vì lý do đó, bạn nên biến đổi mảng đầu vào 

model = LinearRegression().fit(x, y)

Có thể biến đổi mảng đầu vào theo một số cách (như sử dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model.fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Biến 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

Bạn có thể cung cấp một số tham số tùy chọn cho 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

• x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
  y = np.array([5, 20, 14, 32, 22, 38])

  84 là một số nguyên (mặc định là 

  x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
  y = np.array([5, 20, 14, 32, 22, 38])

  38) đại diện cho mức độ của hàm hồi quy đa thức.

• x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
  y = np.array([5, 20, 14, 32, 22, 38])

  86 là Boolean (mặc định là 

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9) quyết định chỉ bao gồm các tính năng tương tác (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) hay tất cả các tính năng (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9).

• x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
  y = np.array([5, 20, 14, 32, 22, 38])

  90 là một Boolean (mặc định là 

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) quyết định có bao gồm cột thiên vị (chặn) của chúng (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  7) hay không (

  >>> print('intercept:', model.intercept_)
  intercept: 5.633333333333329
  >>> print('slope:', model.coef_)
  slope: [0.54]

  9).

Ví dụ này sử dụng các giá trị mặc định của tất cả các tham số, nhưng đôi khi bạn sẽ muốn thử nghiệm với mức độ của hàm và dù sao cũng có thể có lợi nếu cung cấp đối số này.

Trước khi áp dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Sau khi 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Đó là sự biến đổi của mảng đầu vào với 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bạn cũng có thể sử dụng 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Điều đó phù hợp và biến đổi mảng đầu vào trong một câu lệnh với 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Mảng đầu vào đã sửa đổi chứa hai cột: một cột chứa các đầu vào ban đầu và cột kia chứa các ô vuông của chúng.

Bạn có thể tìm thêm thông tin 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bước 3: Tạo một mô hình và phù hợp với nó

Bước này cũng giống như trong trường hợp hồi quy tuyến tính. Bạn tạo và phù hợp với mô hình:

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Mô hình hồi quy hiện đã được tạo và điều chỉnh. Nó đã sẵn sàng để áp dụng.

Bạn nên nhớ rằng đối số đầu tiên của 

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

Bước 4: Nhận kết quả

Bạn có thể có được các thuộc tính của mô hình theo cách tương tự như trong trường hợp hồi quy tuyến tính:

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Một lần nữa, 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bạn có thể nhận được một kết quả rất giống nhau với các đối số biến đổi và hồi quy khác nhau:

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Nếu bạn gọi 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Cột đầu tiên của 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

Phần đánh chặn đã được bao gồm trong cột ngoài cùng bên trái của những cái đó và bạn không cần phải bao gồm lại nó khi tạo phiên bản của 

model.fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model = LinearRegression()

Biến 

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

Cách tiếp cận này mang lại các kết quả sau, tương tự như trường hợp trước:

model = LinearRegression().fit(x, y)

model = LinearRegression()

Bạn thấy rằng bây giờ 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Bước 5: Dự đoán phản hồi

Nếu bạn muốn nhận được phản hồi dự đoán, chỉ cần sử dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression()

Như bạn có thể thấy, dự đoán hoạt động gần giống như trong trường hợp hồi quy tuyến tính. Nó chỉ yêu cầu đầu vào được sửa đổi thay vì đầu vào ban đầu.

Bạn có thể áp dụng quy trình tương tự nếu bạn có nhiều biến đầu vào. Bạn sẽ có một mảng đầu vào với nhiều hơn một cột, nhưng mọi thứ khác đều giống nhau. Đây là một ví dụ:

model = LinearRegression().fit(x, y)

model = LinearRegression()

Ví dụ hồi quy trên mang lại các kết quả và dự đoán sau:

model = LinearRegression().fit(x, y)

model = LinearRegression()

Trong trường hợp này, có sáu hệ số hồi quy (bao gồm cả hệ số chặn), như được thể hiện trong hàm hồi quy ước tính 𝑓 (𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ + 𝑏₃𝑥₁² + 𝑏₄𝑥₁𝑥₂ + 𝑏₅𝑥₂².

Bạn cũng có thể nhận thấy rằng hồi quy đa thức mang lại hệ số xác định cao hơn đa hồi quy tuyến tính cho cùng một vấn đề. Ban đầu, bạn có thể nghĩ rằng có được một 𝑅² lớn như vậy là một kết quả tuyệt vời. Có thể là.

Tuy nhiên, trong các tình huống thực tế, có một mô hình phức tạp và 𝑅² rất gần với 1 cũng có thể là dấu hiệu của việc trang bị thừa. Để kiểm tra hiệu suất của một mô hình, bạn nên kiểm tra nó với dữ liệu mới, tức là với các quan sát không được sử dụng để điều chỉnh (huấn luyện) mô hình. Để tìm hiểu cách tách tập dữ liệu của bạn thành các tập con huấn luyện và kiểm tra, hãy xem Tách tập dữ liệu của bạn với train_test_split() của scikit-learning.

Hồi quy tuyến tính nâng cao với model.fit(x, y)5

Bạn cũng có thể triển khai hồi quy tuyến tính trong Python một cách tương đối dễ dàng bằng cách sử dụng gói 

model.fit(x, y)

Quy trình tương tự như của scikit-learning.

Bước 1: Import các gói

Đầu tiên bạn cần thực hiện một số thao tác import. Ngoài 

model.fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model = LinearRegression()

Bây giờ bạn có các gói bạn cần.

Bước 2: Cung cấp dữ liệu và chuyển đổi đầu vào

Bạn có thể cung cấp các đầu vào và đầu ra giống như cách bạn đã làm khi sử dụng scikit-learning:

model = LinearRegression().fit(x, y)

model = LinearRegression()

Các mảng đầu vào và đầu ra được tạo, nhưng công việc vẫn chưa được thực hiện.

Bạn cần thêm cột của chúng vào các đầu vào nếu bạn muốn 

model.fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression()

Đó là cách bạn thêm cột của chúng vào 

model = LinearRegression().fit(x, y)

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression().fit(x, y)

model = LinearRegression()

Bạn có thể thấy rằng 

model = LinearRegression().fit(x, y)

Bước 3: Tạo một mô hình và phù hợp với nó

Mô hình hồi quy dựa trên bình phương nhỏ nhất thông thường là một thể hiện của lớp 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model = LinearRegression()

Bạn nên cẩn thận ở đây! Xin lưu ý rằng đối số đầu tiên là đầu ra, tiếp theo là đầu vào. Có một số tham số tùy chọn khác.

Để tìm thêm thông tin về lớp này, vui lòng truy cập trang tài liệu chính thức.

Sau khi mô hình của bạn được tạo, bạn có thể áp dụng 

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

model = LinearRegression().fit(x, y)

model.fit(x, y)

Bằng cách gọi 

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Bước 4: Nhận kết quả

Biến 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Bạn có thể gọi 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model = LinearRegression().fit(x, y)

model.fit(x, y)

Bảng này rất toàn diện. Bạn có thể tìm thấy nhiều giá trị thống kê được kết hợp với hồi quy tuyến tính bao gồm 𝑅², 𝑏₀, 𝑏₁ và 𝑏₂.

Trong trường hợp cụ thể này, bạn có thể nhận được cảnh báo liên quan đến 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

model.fit(x, y)

Bạn có thể trích xuất bất kỳ giá trị nào từ bảng trên. Đây là một ví dụ:

model = LinearRegression().fit(x, y)

Đây là cách bạn thu được một số kết quả của hồi quy tuyến tính:

1. >>> print(x)
   [[ 5]
    [15]
    [25]
    [35]
    [45]
    [55]]
   >>> print(y)
   [ 5 20 14 32 22 38]

   71 giữ 𝑅².

2. >>> print(x)
   [[ 5]
    [15]
    [25]
    [35]
    [45]
    [55]]
   >>> print(y)
   [ 5 20 14 32 22 38]

   72 đại diện cho 𝑅² đã điều chỉnh (𝑅² được sửa theo số lượng các đối tượng địa lý đầu vào).

3. >>> print(x)
   [[ 5]
    [15]
    [25]
    [35]
    [45]
    [55]]
   >>> print(y)
   [ 5 20 14 32 22 38]

   73 tham chiếu đến mảng với 𝑏₀, 𝑏₁ và 𝑏₂ tương ứng.

Bạn cũng có thể nhận thấy rằng những kết quả này giống hệt với những kết quả thu được với scikit-learning cho cùng một vấn đề.

Để tìm thêm thông tin về kết quả của hồi quy tuyến tính, vui lòng truy cập trang tài liệu chính thức.

Bước 5: Dự đoán phản hồi

Bạn có thể nhận được phản hồi dự đoán về các giá trị đầu vào được sử dụng để tạo mô hình bằng cách sử dụng 

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

model.fit(x, y)

Đây là phản ứng dự đoán cho các đầu vào đã biết. Nếu bạn muốn dự đoán với các bộ hồi quy mới, bạn cũng có thể áp dụng 

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

model = LinearRegression().fit(x, y)

model.fit(x, y)

Bạn có thể nhận thấy rằng kết quả dự đoán cũng giống như kết quả nhận được với scikit-learning cho cùng một vấn đề.

Vượt ra ngoài hồi quy tuyến tính

Hồi quy tuyến tính đôi khi không thích hợp, đặc biệt đối với các mô hình phi tuyến tính có độ phức tạp cao.

May mắn thay, có những kỹ thuật hồi quy khác phù hợp với những trường hợp mà hồi quy tuyến tính không hoạt động tốt. Một số trong số đó là máy vectơ hỗ trợ, cây quyết định, rừng ngẫu nhiên và mạng nơ-ron.

Có rất nhiều thư viện Python để hồi quy bằng cách sử dụng các kỹ thuật này. Hầu hết chúng đều miễn phí và mã nguồn mở. Đó là một trong những lý do tại sao Python là một trong những ngôn ngữ lập trình chính cho học máy.

Gói scikit-learning cung cấp các phương tiện để sử dụng các kỹ thuật hồi quy khác theo cách rất giống với những gì bạn đã thấy. Nó chứa các lớp cho máy vectơ hỗ trợ, cây quyết định, rừng ngẫu nhiên , v.v. cùng với các phương thức 

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Phần kết luận

Bây giờ bạn đã biết hồi quy tuyến tính là gì và cách bạn có thể triển khai nó với Python và ba gói mã nguồn mở: NumPy, scikit-learning và 

model.fit(x, y)

Bạn sử dụng NumPy để xử lý mảng.

Hồi quy tuyến tính được thực hiện như sau:

• scikit-learning nếu bạn không cần kết quả chi tiết và muốn sử dụng phương pháp phù hợp với các kỹ thuật hồi quy khác
• statsmodels nếu bạn cần các thông số thống kê tiên tiến của một mô hình

Cả hai cách tiếp cận đều đáng để học cách sử dụng và khám phá thêm. Các liên kết trong bài viết này có thể rất hữu ích cho việc đó.

Khi thực hiện hồi quy tuyến tính trong Python, bạn có thể làm theo các bước sau:

1. Import gói và lớp bạn cần
2. Cung cấp dữ liệu để làm việc và cuối cùng thực hiện các chuyển đổi thích hợp
3. Tạo mô hình hồi quy và phù hợp với dữ liệu hiện có
4. Kiểm tra kết quả lắp mô hình để biết mô hình có đạt yêu cầu hay không
5. Áp dụng mô hình cho các dự đoán.