Tôi học tốt nhất bằng cách làm và giảng dạy. Và trong khi Python có một số gói tuyệt vời có sẵn cho hồi quy tuyến tính (như StatSmodels hoặc Scikit-learn), tôi muốn hiểu trực giác đằng sau hồi quy tuyến tính bình phương tối thiểu (OLS). Làm thế nào là phù hợp tốt nhất được tìm thấy? Làm thế nào để bạn thực sự thực hiện giảm độ dốc hàng loạt? Có rất nhiều lời giải thích tuyệt vời về dòng dõi độ dốc ở đây, ở đây và ở đây, vì vậy mục tiêu của tôi ở đây là cung cấp một số hiểu biết sâu sắc khi tôi thực hiện nó với Python.
Hướng dẫn này chủ yếu được mô hình hóa sau khóa học học máy tuyệt vời của Andrew Ng, có sẵn trực tuyến miễn phí. Các bài tập lập trình ở đó là thẳng thắn và trực quan, nhưng nó chủ yếu trong MATLAB/OCTAVE. Tôi muốn thực hiện điều tương tự trong Python với các mảng Numpy.
Bạn cũng có thể tìm thấy phiên bản Notebook Ipython của hướng dẫn này có sẵn trên GitHub của tôi hoặc ở định dạng HTML tại đây
Contents:
- Tải dữ liệu
- Vẽ đồ thị dữ liệu
- Chức năng ước lượng
- Xuống dốc
- Thực hiện Python
- Diễn dịch
- Sự dự đoán
Packages:
- Pandas cho các khung dữ liệu và dễ đọc các tệp CSV
- Numpy cho các chức năng toán học mảng và ma trận
- Matplotlib cho âm mưu
Tải dữ liệu
Hãy bắt đầu bằng cách thực hiện hồi quy tuyến tính với một biến để dự đoán lợi nhuận cho một chiếc xe tải thực phẩm. Dữ liệu chứa 2 cột, dân số của một thành phố (trong 10.000) và lợi nhuận của xe tải thực phẩm (trong 10.000s).
data = pd.read_csv('ex1data1.txt', names = ['population', 'profit']) print data.head()
# population profit 0 6.1101 17.5920 1 5.5277 9.1302 2 8.5186 13.6620 3 7.0032 11.8540 4 5.8598 6.8233
Vẽ đồ thị dữ liệu
Vì vậy, đây là những điểm dữ liệu của chúng tôi trông như thế nào khi được vẽ ra.
Ý tưởng về hồi quy tuyến tính là tìm ra mối quan hệ giữa mục tiêu hoặc biến phụ thuộc của chúng tôi (y) và một tập hợp các biến giải thích (\ (x_1, x_2, \)). Mối quan hệ này sau đó có thể được sử dụng để dự đoán các giá trị khác.
Trong trường hợp của chúng tôi với một biến, mối quan hệ này là một dòng được xác định bởi các tham số \ (\ beta \) và hình thức sau: \ (y = \ beta_0 + \ beta_1x \), trong đó \ (\ beta_0 \) là đánh chặn của chúng tôi. (Tôi đã chọn sử dụng \ (\ beta \) nhưng nhiều tài liệu sử dụng \ (theta \), vì vậy hãy ghi nhớ điều đó)
Điều này có thể được mở rộng sang hồi quy đa biến bằng cách mở rộng phương trình ở dạng vectơ: \ (y = x \ beta \)
Vậy làm cách nào để làm cho dòng tốt nhất? Trong hình này, có nhiều dòng có thể. Cái nào là tốt nhất?
Chức năng ước lượng
Hóa ra để tạo dòng tốt nhất để mô hình hóa dữ liệu, chúng tôi muốn chọn tham số \ (\ beta \) cho phép giá trị dự đoán của chúng tôi càng gần với giá trị thực tế càng tốt. Nói cách khác, chúng tôi muốn khoảng cách hoặc dư giữa giả thuyết của chúng tôi \ (h (x) \) và y được giảm thiểu.
Vì vậy, chúng tôi chính thức xác định một hàm chi phí bằng cách sử dụng bình phương tối thiểu thông thường chỉ đơn giản là tổng của khoảng cách bình phương. Để tìm dòng hồi quy lớp lót, chúng tôi điều chỉnh các tham số beta của mình để giảm thiểu:
Một lần nữa, giả thuyết mà chúng tôi đang cố gắng tìm thấy được đưa ra bởi mô hình tuyến tính:
Và chúng ta có thể sử dụng dòng dõi độ dốc hàng loạt nơi mỗi lần lặp thực hiện cập nhật
Whoa, những gì độ dốc giảm dần? Và tại sao chúng ta lại cập nhật điều đó?
Độ dốc giảm dần đơn giản là một thuật toán thực hiện các bước nhỏ dọc theo một hàm để tìm mức tối thiểu cục bộ. Chúng ta có thể nhìn vào một phương trình bậc hai đơn giản như thế này:
Chúng tôi đang cố gắng tìm mức tối thiểu cục bộ trên chức năng này. Nếu chúng ta bắt đầu ở chấm đỏ đầu tiên tại x = 2, chúng ta sẽ tìm thấy độ dốc và chúng ta di chuyển chống lại nó. Trong trường hợp này, độ dốc là độ dốc. Và vì độ dốc là tiêu cực, nỗ lực tiếp theo của chúng tôi ở bên phải. Do đó đưa chúng ta đến gần hơn với mức tối thiểu.
Nếu chúng ta bắt đầu ở chấm màu xanh bên phải ở x = 8, độ dốc hoặc độ dốc của chúng ta là dương, vì vậy chúng ta di chuyển ra khỏi đó bằng cách nhân nó với một -1. Và cuối cùng nó làm cho các bản cập nhật nhỏ hơn và nhỏ hơn (khi độ dốc tiếp cận 0 ở mức tối thiểu) cho đến khi tham số hội tụ ở mức tối thiểu mà chúng tôi đang tìm kiếm.
Thật vậy, chúng tôi tiếp tục cập nhật beta tham số của chúng tôi để ngày càng gần hơn với mức tối thiểu.
Trong đó \ (\ alpha \) là tỷ lệ học tập của chúng tôi và chúng tôi tìm thấy sự khác biệt một phần của chức năng chi phí của chúng tôi đối với beta. Tôi đã giành được sự khác biệt một phần ngày hôm nay, nhưng nó dẫn đến công thức ngay trước đó.
Bằng cách điều chỉnh Alpha, chúng ta có thể thay đổi mức độ nhanh chóng của chúng ta đến mức tối thiểu (có nguy cơ vượt quá nó hoàn toàn và không hội tụ ở mức tối thiểu cục bộ của chúng ta)
Đó là một không gian 2 chiều. Trong một không gian 3D, nó sẽ giống như lăn một quả bóng xuống một ngọn đồi để tìm điểm thấp nhất. Tôi có thể hình dung bất cứ điều gì trên 3 chiều, nhưng đó là ý tưởng.
Phương pháp này được gọi là độ dốc độ dốc của Batch Batch vì chúng tôi sử dụng toàn bộ lô điểm X để tính toán từng độ dốc, trái ngược với độ dốc ngẫu nhiên. trong đó sử dụng một điểm tại một thời điểm. Tôi sẽ thực hiện giảm dần độ dốc ngẫu nhiên trong một hướng dẫn trong tương lai.“batch” gradient descent because we use the entire batch of points X to calculate each gradient, as opposed to stochastic gradient descent. which uses one point at a time. I’ll implement stochastic gradient descent in a future tutorial.
Thực hiện Python
Ok, hãy để cố gắng thực hiện điều này trong Python. Đầu tiên tôi khai báo một số tham số. Alpha là tỷ lệ học tập của tôi và các lần lặp lại xác định số lần tôi muốn thực hiện cập nhật.
Sau đó, tôi chuyển đổi khung dữ liệu giữ dữ liệu của tôi thành một mảng cho toán học ma trận đơn giản hơn. Và sau đó viết một hàm để tính hàm chi phí như được định nghĩa ở trên. Tôi sử dụng np.dot cho phép nhân ma trận bên trong. Ở đây, nó trông như thế nào:
iterations = 1500 alpha = 0.01 ## Add a columns of 1s as intercept to X. This becomes the 2nd column X_df['intercept'] = 1 ## Transform to Numpy arrays for easier matrix math ## and start beta at 0, 0 X = np.array(X_df) y = np.array(y_df).flatten() beta = np.array([0, 0]) def cost_function(X, y, beta): """ cost_function(X, y, beta) computes the cost of using beta as the parameter for linear regression to fit the data points in X and y """ ## number of training examples m = len(y) ## Calculate the cost with the given parameters J = np.sum((X.dot(beta)-y)**2)/2/m return J cost_function(X, y, beta) >>> 32.07
Bây giờ, hãy để thực hiện giảm độ dốc. Hãy nhớ rằng phương trình dài ở trên?
Tôi sẽ chia chúng thành các phần riêng biệt để tôi có thể thấy những gì đang diễn ra. Thêm vào đó, tôi thích kiểm tra kích thước ma trận của mình để đảm bảo rằng tôi đã thực hiện toán học theo đúng thứ tự. Ồ và vì bây giờ tôi đang thực hiện các ma trận toán học, tôi có thể loại trừ việc tổng kết các thuật ngữ của tôi.
- Tính toán giả thuyết \ (h_ \ beta (x) \):hypothesis \(h_\beta(x)\):
- Giả thuyết [97x1] = x [97x2] * beta [2x1]
- Tính toán lỗ \ ((h_ \ beta (x) -y) \):loss \((h_\beta(x)-y)\):
- Mất mát [97x1] với phép trừ yếu tố khôn ngoan
- Tính toán gradient \ ((h_ \ beta (x) -y) x_ {j} \):gradient \((h_\beta(x)-y)x_{j}\):
- gradient [2x1] = X triệt [2x97] * Mất [97x1]
- Cập nhật tham số Beta:beta:
- [2x1] Sau khi trừ phần tử khôn ngoan nhân với vô hướng
- Và tìm chi phí bằng cách sử dụng cost_function()cost by using cost_function()
def gradient_descent(X, y, beta, alpha, iterations): """ gradient_descent() performs gradient descent to learn beta by taking num_iters gradient steps with learning rate alpha """ cost_history = [0] * iterations for iteration in range(iterations): hypothesis = X.dot(beta) loss = hypothesis-y gradient = X.T.dot(loss)/m beta = beta - alpha*gradient cost = cost_function(X, y, beta) cost_history[iteration] = cost ## If you really want to merge everything in one line: # beta = beta - alpha * (X.T.dot(X.dot(beta)-y)/m) # cost = cost_function(X, y, beta) # cost_history[iteration] = cost return beta, cost_history (b, c) = gradient_descent(X, y, beta, alpha, iterations) print b >>> [ 1.16636235 -3.63029144]
Diễn dịch
Làm thế nào chúng ta có thể giải thích các tham số beta? Vâng \ (\ beta_0 \) là đánh chặn của dòng trong 2d. Trong trường hợp của chúng tôi, vì chúng tôi đã thêm cột chặn 1S sau đó, nó thực sự là cột thứ hai của ma trận X. Vì vậy, bản beta tương ứng là điểm thứ hai. Đánh chặn của chúng tôi là -3,6. Thật vậy, chúng ta có thể thấy trên biểu đồ với dòng phù hợp nhất mà điều này là đúng. \ (\ beta_0 \) sau đó là độ dốc của dòng.
Với mọi thứ được đặt cùng nhau:
Sự dự đoán
Bây giờ chúng tôi có thể sử dụng mô hình hồi quy tuyến tính được đào tạo của chúng tôi để dự đoán lợi nhuận ở các thành phố có quy mô nhất định. Hãy thử thử 2 thành phố, với dân số 35.000 và 70.000. Vì tôi có các tham số của mình được xác định, tôi có thể cắm chúng vào mô hình hồi quy tuyến tính:
hoặc biến chúng thành Matrix X và nhiều chúng bằng Beta
print np.array([3.5, 1]).dot(b) print np.array([7, 1]).dot(b) >>> 0.45197678677 >>> 4.53424501294
Lợi nhuận lần lượt là khoảng $ 4,519 và $ 45,342.
Hãy xem, Gradient Descent là khó hiểu nữa. Tất nhiên, tôi đã đưa ra một số cân nhắc quan trọng (chẳng hạn như tỷ lệ học tập và số lần lặp cho đến khi hội tụ trên một minumum), và chúng có thể là chủ đề cho một ngày khác, nhưng đây là khái niệm chung.
Tiếp theo, chúng tôi sẽ xem xét chính quy hóa và hồi quy đa biến, trước khi khám phá hồi quy logistic và các thuật toán học tập được giám sát khác.
Hãy cho tôi biết nếu điều này hữu ích hoặc nếu bạn phát hiện ra bất kỳ lỗi nào.
->