Hướng dẫn gradient descent with momentum python - dốc xuống với con trăn động lượng

Cập nhật lần cuối vào ngày 12 tháng 10 năm 2021

Nội dung chính Show

Tổng quan hướng dẫn
Xuống dốc
Bạn muốn bắt đầu với các thuật toán tối ưu hóa?
Quán tính
Độ dốc hạ xuống với động lượng
Vấn đề kiểm tra một chiều
# Hiển thị cốt truyện
Trực quan hóa tối ưu hóa giảm dần độ dốc
Tối ưu hóa giảm dần độ dốc với động lượng
Trực quan hóa tối ưu hóa giảm độ dốc với động lượng
Đọc thêm
Bài viết
Bản tóm tắt
Nhận một xử lý các thuật toán tối ưu hóa hiện đại!
Độ dốc giảm dần với động lượng là gì?
Làm thế nào để bạn mã hóa một độ dốc giảm dần trong Python?
Tại sao chúng ta cần động lực ở độ dốc giảm dần?
RMSProp có sử dụng động lượng không?

Độ dốc gốc là một thuật toán tối ưu hóa theo độ dốc âm của hàm mục tiêu để xác định vị trí tối thiểu của hàm. is an optimization algorithm that follows the negative gradient of an objective function in order to locate the minimum of the function.

Một vấn đề với độ dốc giảm dần là nó có thể nảy xung quanh không gian tìm kiếm về các vấn đề tối ưu hóa có một lượng lớn độ cong hoặc độ dốc ồn, và nó có thể bị mắc kẹt trong các điểm phẳng trong không gian tìm kiếm không có độ dốc.

Động lượng là một phần mở rộng cho thuật toán tối ưu hóa giảm độ dốc cho phép tìm kiếm xây dựng quán tính theo hướng trong không gian tìm kiếm và khắc phục các dao động của độ dốc ồn ào và bờ biển trên các điểm phẳng của không gian tìm kiếm. is an extension to the gradient descent optimization algorithm that allows the search to build inertia in a direction in the search space and overcome the oscillations of noisy gradients and coast across flat spots of the search space.

Trong hướng dẫn này, bạn sẽ khám phá ra độ dốc giảm dần với thuật toán động lượng.

Sau khi hoàn thành hướng dẫn này, bạn sẽ biết:

Độ dốc gốc là một thuật toán tối ưu hóa sử dụng gradient của hàm mục tiêu để điều hướng không gian tìm kiếm.
Độ dốc độ dốc có thể được tăng tốc bằng cách sử dụng động lượng từ các bản cập nhật trong quá khứ đến vị trí tìm kiếm.
Làm thế nào để thực hiện tối ưu hóa giảm độ dốc với động lượng và phát triển trực giác cho hành vi của nó.

Kick bắt đầu dự án của bạn với Tối ưu hóa cuốn sách mới của tôi để học máy, bao gồm các hướng dẫn từng bước và các tệp mã nguồn Python cho tất cả các ví dụ. with my new book Optimization for Machine Learning, including step-by-step tutorials and the Python source code files for all examples.

Bắt đầu nào.

Độ dốc hạ xuống với động lực từ Scratchphoto của Chris Barnes, một số quyền được bảo lưu.
Photo by Chris Barnes, some rights reserved.

Tổng quan hướng dẫn

Hướng dẫn này được chia thành ba phần; họ đang:

Xuống dốc
Quán tính
Độ dốc hạ xuống với động lượng
1. Vấn đề kiểm tra một chiều
2. Tối ưu hóa giảm dần độ dốc
3. Trực quan hóa tối ưu hóa giảm dần độ dốc
4. Tối ưu hóa giảm dần độ dốc với động lượng
5. Trực quan hóa tối ưu hóa giảm độ dốc với động lượng

Xuống dốc

Quán tính

Độ dốc hạ xuống với động lượng

Vấn đề kiểm tra một chiều

Tối ưu hóa giảm dần độ dốc

Trực quan hóa tối ưu hóa giảm dần độ dốc

Tối ưu hóa giảm dần độ dốc với động lượng

Trực quan hóa tối ưu hóa giảm độ dốc với động lượng: First-order derivative for a multivariate objective function.

Độ dốc gốc là một thuật toán tối ưu hóa.

Về mặt kỹ thuật, nó được gọi là thuật toán tối ưu hóa bậc một vì nó sử dụng rõ ràng đạo hàm bậc nhất của hàm mục tiêu đích.

Các phương pháp đặt hàng đầu tiên dựa vào thông tin gradient để giúp chỉ đạo tìm kiếm tối thiểu

- Trang 69, Thuật toán để tối ưu hóa, 2019.

Đạo hàm bậc nhất, hoặc đơn giản là đạo hàm của người Viking, là tốc độ thay đổi hoặc độ dốc của hàm đích tại một điểm cụ thể, ví dụ: cho một đầu vào cụ thể.

Nếu hàm đích có nhiều biến đầu vào, nó được gọi là hàm đa biến và các biến đầu vào có thể được coi là một vectơ. Đổi lại, đạo hàm của hàm mục tiêu đa biến cũng có thể được coi là một vectơ và được gọi chung là gradient.

Độ dốc: Đạo hàm bậc nhất cho hàm mục tiêu đa biến.

Đạo hàm hoặc các điểm gradient theo hướng đi lên dốc nhất của hàm mục tiêu cho một đầu vào cụ thể.

Độ dốc độ dốc đề cập đến một thuật toán tối ưu hóa tối thiểu hóa theo tiêu cực của độ dốc độ dốc của hàm mục tiêu để xác định mức tối thiểu của hàm. (alpha): Hyperparameter that controls how far to move in the search space against the gradient each iteration of the algorithm, also called the learning rate.

Thuật toán gốc độ dốc yêu cầu một hàm đích đang được tối ưu hóa và hàm phái sinh cho hàm mục tiêu. Hàm mục tiêu f () trả về điểm cho một tập hợp các đầu vào nhất định và hàm dẫn xuất f '() đưa ra đạo hàm của hàm đích cho một tập hợp đầu vào nhất định.

Thuật toán gốc gradient yêu cầu điểm bắt đầu (x) trong vấn đề, chẳng hạn như một điểm được chọn ngẫu nhiên trong không gian đầu vào.

Bạn muốn bắt đầu với các thuật toán tối ưu hóa?

Tham gia khóa học gặp sự cố email 7 ngày miễn phí của tôi ngay bây giờ (với mã mẫu).

Nhấp để đăng ký và cũng nhận được phiên bản Ebook PDF miễn phí của khóa học.

Quán tính

Động lượng là một phần mở rộng cho thuật toán tối ưu hóa độ dốc độ dốc, thường được gọi là độ dốc độ dốc với động lượng.gradient descent with momentum.

Nó được thiết kế để tăng tốc quá trình tối ưu hóa, ví dụ: Giảm số lượng đánh giá chức năng cần thiết để đạt đến tối ưu hoặc để cải thiện khả năng của thuật toán tối ưu hóa, ví dụ: dẫn đến một kết quả cuối cùng tốt hơn.

Một vấn đề với thuật toán giảm độ dốc là sự tiến triển của tìm kiếm có thể nảy xung quanh không gian tìm kiếm dựa trên độ dốc. Ví dụ, tìm kiếm có thể tiến xuống dốc về phía cực tiểu, nhưng trong quá trình tiến triển này, nó có thể di chuyển theo một hướng khác, thậm chí lên dốc, tùy thuộc vào độ dốc của các điểm cụ thể (bộ tham số) gặp phải trong quá trình tìm kiếm.

Điều này có thể làm chậm tiến trình của tìm kiếm, đặc biệt là đối với những vấn đề tối ưu hóa trong đó xu hướng hoặc hình dạng rộng hơn của không gian tìm kiếm hữu ích hơn so với độ dốc cụ thể trên đường đi.

Một cách tiếp cận cho vấn đề này là thêm lịch sử vào phương trình cập nhật tham số dựa trên độ dốc gặp trong các bản cập nhật trước đó.

Thay đổi này dựa trên phép ẩn dụ của động lượng từ vật lý nơi gia tốc theo hướng có thể được tích lũy từ các bản cập nhật trong quá khứ.

Động lượng tên bắt nguồn từ một sự tương tự vật lý, trong đó độ dốc âm là một lực di chuyển một hạt thông qua không gian tham số, theo định luật chuyển động của Newton.

- Trang 296, Học sâu, 2016.

Động lượng liên quan đến việc thêm một siêu nhân bổ sung kiểm soát lượng lịch sử (động lượng) để đưa vào phương trình cập nhật, tức là bước đến một điểm mới trong không gian tìm kiếm. Giá trị của siêu đồng tính được xác định trong phạm vi 0,0 đến 1,0 và thường có giá trị gần 1,0, chẳng hạn như 0,8, 0,9 hoặc 0,99. Một động lượng là 0,0 giống như giảm độ dốc mà không có động lượng.

Đầu tiên, hãy để phá vỡ phương trình cập nhật giảm độ dốc xuống thành hai phần: tính toán thay đổi vị trí và cập nhật vị trí cũ lên vị trí mới.

Sự thay đổi trong các tham số được tính là độ dốc cho điểm được chia tỷ lệ theo kích thước bước.

Change_x = Step_Size * f '(x)

Vị trí mới được tính bằng cách trừ đi sự thay đổi từ điểm hiện tại

x = x - thay đổi_x

Động lượng liên quan đến việc duy trì sự thay đổi trong vị trí và sử dụng nó trong tính toán tiếp theo về sự thay đổi vị trí.

Nếu chúng ta nghĩ về các bản cập nhật theo thời gian, thì bản cập nhật tại lần lặp hiện tại hoặc thời gian (t) sẽ thêm thay đổi được sử dụng vào thời điểm trước (T-1) được tính theo tính năng

Change_x (t) = Step_Size * F '(x (t-1)) + Momentum * Change_x (T-1)

Bản cập nhật cho vị trí sau đó được thực hiện như trước.

x (t) = x (t-1)-thay đổi_x (t)

Sự thay đổi trong vị trí tích lũy cường độ và hướng thay đổi đối với các lần lặp của tìm kiếm, tỷ lệ với kích thước của siêu đồng tính động lượng.

Ví dụ: một động lượng lớn (ví dụ: 0,9) sẽ có nghĩa là bản cập nhật bị ảnh hưởng mạnh mẽ bởi bản cập nhật trước đó, trong khi động lượng khiêm tốn (0,2) sẽ có nghĩa là rất ít ảnh hưởng.

Thuật toán động lượng tích lũy trung bình di chuyển phân rã theo cấp số nhân của độ dốc trong quá khứ và tiếp tục di chuyển theo hướng của chúng.

- Trang 296, Học sâu, 2016.

Đầu tiên, hãy để phá vỡ phương trình cập nhật giảm độ dốc xuống thành hai phần: tính toán thay đổi vị trí và cập nhật vị trí cũ lên vị trí mới.

Sự thay đổi trong các tham số được tính là độ dốc cho điểm được chia tỷ lệ theo kích thước bước.

Change_x = Step_Size * f '(x)

Vị trí mới được tính bằng cách trừ đi sự thay đổi từ điểm hiện tại

- Trang 296, Học sâu, 2016.

Đầu tiên, hãy để phá vỡ phương trình cập nhật giảm độ dốc xuống thành hai phần: tính toán thay đổi vị trí và cập nhật vị trí cũ lên vị trí mới.

Bây giờ chúng ta đã quen thuộc với động lực là gì, hãy để Lôi nhìn vào một ví dụ hoạt động.

Độ dốc hạ xuống với động lượng

Trong phần này, trước tiên chúng tôi sẽ thực hiện thuật toán tối ưu hóa độ dốc độ dốc, sau đó cập nhật nó để sử dụng động lượng và so sánh kết quả.

Vấn đề kiểm tra một chiều

Đầu tiên, hãy để xác định một chức năng tối ưu hóa.

Chúng tôi sẽ sử dụng hàm một chiều đơn giản, bình phương đầu vào và xác định phạm vi đầu vào hợp lệ từ -1.0 đến 1.0.

Hàm mục tiêu () bên dưới thực hiện hàm này.

# hàm mục tiêu

mục tiêu def (x):objective(x):

returnx**2.0x**2.0

Sau đó, chúng ta có thể lấy mẫu tất cả các đầu vào trong phạm vi và tính toán giá trị hàm mục tiêu cho mỗi.

.....

# Xác định phạm vi cho đầu vào

r_min,r_max=-1.0,1.0,r_max=-1.0,1.0

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

inputs=arange(r_min,r_max+0.1,0.1)=arange(r_min, r_max+0.1,0.1)

# Tính toán mục tiêu

results=objective(inputs)=objective(inputs)

Cuối cùng, chúng ta có thể tạo một biểu đồ dòng của các đầu vào (trục x) so với các giá trị hàm mục tiêu (trục y) để có trực giác cho hình dạng của hàm mục tiêu mà chúng ta sẽ tìm kiếm.

.....

# Xác định phạm vi cho đầu vào

pyplot.plot(inputs,results).plot(inputs,results)

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

pyplot.show().show()

# Tính toán mục tiêu

# Tạo một biểu đồ dòng đầu vào so với kết quảnumpy import arange

# Hiển thị cốt truyệnmatplotlib import pyplot

# hàm mục tiêu

mục tiêu def (x):objective(x):

returnx**2.0x**2.0

# Xác định phạm vi cho đầu vào

r_min,r_max=-1.0,1.0,r_max=-1.0,1.0

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

inputs=arange(r_min,r_max+0.1,0.1)=arange(r_min,r_max+0.1, 0.1)

# Tính toán mục tiêu

results=objective(inputs)=objective(inputs)

# Xác định phạm vi cho đầu vào

pyplot.plot(inputs,results).plot(inputs,results)

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

pyplot.show().show()

# Tính toán mục tiêu

Hướng dẫn gradient descent with momentum python - dốc xuống với con trăn động lượng

# Tạo một biểu đồ dòng đầu vào so với kết quả

# Hiển thị cốt truyện

Ví dụ dưới đây gắn kết điều này lại với nhau và cung cấp một ví dụ về việc vẽ hàm thử nghiệm một chiều.

# lô chức năng đơn giản

từ nhập khẩu Numpy Arange

từ pyplot nhập khẩu matplotlib

Chạy ví dụ tạo ra một biểu đồ dòng của các đầu vào cho hàm (trục x) và đầu ra được tính toán của hàm (trục y).derivative(x):

Chúng ta có thể thấy hình chữ U quen thuộc được gọi là parabola.x *2.0

Biểu đồ dòng của hàm một chiều đơn giản

Tối ưu hóa giảm dần độ dốc

Tiếp theo, chúng ta có thể áp dụng thuật toán gốc gradient cho vấn đề.

Đầu tiên, chúng ta cần một hàm tính toán đạo hàm cho hàm mục tiêu.

Đạo hàm của x^2 là x * 2 và hàm đạo hàm () thực hiện điều này dưới đây.gradient_descent(objective,derivative,bounds,n_iter,step_size):

# đạo hàm của hàm mục tiêu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])= bounds[:,0]+rand(len(bounds))*(bounds[:,1]- bounds[:,0])

DEF DERIVATION (X):

foriinrange(n_iter):iinrange(n_iter):

returnX *2.0

gradient=derivative(solution)= derivative(solution)

Chúng ta có thể xác định một hàm thực hiện thuật toán tối ưu hóa độ dốc.

Quy trình liên quan đến việc bắt đầu với một điểm được chọn ngẫu nhiên trong không gian tìm kiếm, sau đó tính toán độ dốc, cập nhật vị trí trong không gian tìm kiếm, đánh giá vị trí mới và báo cáo tiến trình. Quá trình này sau đó được lặp lại cho một số lần lặp cố định. Điểm cuối cùng và đánh giá của nó sau đó được trả lại từ chức năng.=solution-step_size *gradient

Hàm gradient_descent () bên dưới thực hiện điều này và lấy tên của các hàm khách quan và độ dốc cũng như giới hạn trên các đầu vào cho hàm mục tiêu, số lần lặp và kích thước bước, sau đó trả về giải pháp và đánh giá của nó ở cuối Tìm kiếm.

solution_eval=objective(solution)= objective(solution)

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size):('>%d f(%s) = %.5f'%(i,solution,solution_eval))

return[solution,solution_eval] [solution,solution_eval]

# Tạo điểm ban đầu

# Chạy độ dốc độ dốc

# Tính độ dốc

.....

# Xác định phạm vi cho đầu vào

seed(4)(4)

# Xác định phạm vi cho đầu vào

bounds=asarray([[-1.0,1.0]])=asarray([[-1.0,1.0]])

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

n_iter=30=30

# Tính toán mục tiêu

step_size=0.1=0.1

best,score=gradient_descent(objective,derivative,bounds,n_iter,step_size),score=gradient_descent(objective, derivative,bounds,n_iter,step_size)

# Tạo một biểu đồ dòng đầu vào so với kết quả

# Hiển thị cốt truyện

Ví dụ dưới đây gắn kết điều này lại với nhau và cung cấp một ví dụ về việc vẽ hàm thử nghiệm một chiều.numpy import asarray

# lô chức năng đơn giảnnumpy.random import rand

từ nhập khẩu Numpy Arangenumpy.random import seed

# hàm mục tiêu

mục tiêu def (x):objective(x):

returnx**2.0x**2.0

# đạo hàm của hàm mục tiêu

DEF DERIVATION (X):derivative(x):

returnX *2.0x *2.0

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size):gradient_descent(objective,derivative,bounds,n_iter,step_size):

# Tạo điểm ban đầu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])=bounds[:, 0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])

# Chạy độ dốc độ dốc

foriinrange(n_iter):iinrange(n_iter):

# Tính độ dốc

gradient=derivative(solution)=derivative(solution)

# Hãy thực hiện một bước

Giải pháp = giải pháp-step_size *gradient=solution-step_size *gradient

# Đánh giá điểm ứng cử viên

solution_eval=objective(solution)=objective(solution)

# Báo cáo tiến độ

in ('>%d f (%s) =%.5f'%(i, giải pháp, giải pháp_eval)))('>%d f(%s) = %.5f'%(i,solution,solution_eval))

return[solution,solution_eval][solution,solution_eval]

# Hạt trình tạo số ngẫu nhiên giả giả

seed(4)(4)

# Xác định phạm vi cho đầu vào

bounds=asarray([[-1.0,1.0]])=asarray([[-1.0,1.0]])

# Xác định tổng số lần lặp

n_iter=30=30

# Xác định kích thước bước

step_size=0.1 =0.1

# Thực hiện tìm kiếm giảm độ dốc

best,score=gradient_descent(objective,derivative,bounds,n_iter,step_size),score=gradient_descent(objective,derivative,bounds,n_iter,step_size)

print('Done!')('Done!')

in ('f (%s) =%f'%(tốt nhất, điểm))('f(%s) = %f'%(best,score))

Chạy ví dụ bắt đầu với một điểm ngẫu nhiên trong không gian tìm kiếm, sau đó áp dụng thuật toán giảm độ dốc, báo cáo hiệu suất trên đường đi.

Lưu ý: Kết quả của bạn có thể khác nhau với tính chất ngẫu nhiên của thuật toán hoặc quy trình đánh giá, hoặc sự khác biệt về độ chính xác số. Xem xét chạy ví dụ một vài lần và so sánh kết quả trung bình.: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

Trong trường hợp này, chúng ta có thể thấy rằng thuật toán tìm thấy một giải pháp tốt sau khoảng 27 lần lặp, với đánh giá hàm khoảng 0,0.

Lưu ý tối ưu cho hàm này là F (0,0) = 0,0.

Chúng tôi hy vọng rằng độ dốc độ dốc với động lượng sẽ tăng tốc quy trình tối ưu hóa và tìm một giải pháp được đánh giá tương tự trong ít lần lặp hơn.

> 0 F ([0.74724774]) = 0,55838

> 1 F ([0.59779819]) = 0,35736

> 2 F ([0.47823856]) = 0.22871

> 3 F ([0.38259084]) = 0.14638

> 4 F ([0.30607268]) = 0,09368

> 5 F ([0.24485814]) = 0,05996

> 6 F ([0.19588651]) = 0,03837

> 7 F ([0.15670921]) = 0,02456

> 8 F ([0.12536737]) = 0,01572

> 9 F ([0.10029389]) = 0,01006

> 10 F ([0,08023512]) = 0,00644

> 11 F ([0,06418809]) = 0,00412

> 12 F ([0,05135047]) = 0,00264

> 13 F ([0,04108038]) = 0,00169

> 14 F ([0,0328643]) = 0,00108

> 15 F ([0,02629144]) = 0,00069

> 16 F ([0,02103315]) = 0,00044

> 17 F ([0.01682652]) = 0,00028

> 18 F ([0,01346122]) = 0,00018

> 19 F ([0.01076897]) = 0,00012

> 20 F ([0,00861518]) = 0,00007

> 21 F ([0,00689214]) = 0,00005

> 22 F ([0,00551372]) = 0,00003

> 23 F ([0,00441097]) = 0,00002

> 24 F ([0,00352878]) = 0,00001

> 25 F ([0,00282302]) = 0,00001

> 26 F ([0,00225842]) = 0,00001

> 27 F ([0,00180673]) = 0,00000

> 28 F ([0,00144539]) = 0,00000

> 29 F ([0,00115631]) = 0,00000

Done!

F ([0,00115631]) = 0,000001

Trực quan hóa tối ưu hóa giảm dần độ dốc

Tiếp theo, chúng ta có thể hình dung tiến trình tìm kiếm trên một biểu đồ của hàm đích.

Đầu tiên, chúng ta có thể cập nhật hàm gradient_descent () để lưu trữ tất cả các giải pháp và điểm số của chúng được tìm thấy trong quá trình tối ưu hóa dưới dạng danh sách và trả lại chúng ở cuối tìm kiếm thay vì giải pháp tốt nhất được tìm thấy.

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size):gradient_descent(objective,derivative,bounds,n_iter,step_size):

# Theo dõi tất cả các giải pháp

solutions,scores=list(),list(), scores=list(),list()

# Tạo điểm ban đầu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])=bounds[:,0]+ rand(len(bounds))*(bounds[:,1]-bounds[:,0])

# Chạy độ dốc độ dốc

foriinrange(n_iter):iinrange(n_iter):

# Tính độ dốc

gradient=derivative(solution)=derivative(solution)

# Hãy thực hiện một bước

Giải pháp = giải pháp-step_size *gradient= solution-step_size *gradient

# Đánh giá điểm ứng cử viên

solution_eval=objective(solution)=objective(solution)

# Báo cáo tiến độ

solutions.append(solution).append(solution)

scores.append(solution_eval).append(solution_eval)

# Báo cáo tiến độ

in ('>%d f (%s) =%.5f'%(i, giải pháp, giải pháp_eval)))('>%d f(%s) = %.5f'%(i, solution,solution_eval))

return[solutions,scores][solutions,scores]

# Hạt trình tạo số ngẫu nhiên giả giả

# Xác định phạm vi cho đầu vào..

# Thực hiện tìm kiếm giảm độ dốc

solutions,scores=gradient_descent(objective,derivative,bounds,n_iter,step_size),scores=gradient_descent(objective,derivative,bounds,n_iter, step_size)

in ('f (%s) =%f'%(tốt nhất, điểm))

# Xác định phạm vi cho đầu vào..

# Xác định tổng số lần lặp

inputs=arange(bounds[0,0],bounds[0,1]+0.1,0.1)=arange(bounds[0,0],bounds[0,1]+0.1, 0.1)

# Xác định kích thước bước

results=objective(inputs)=objective(inputs)

# Thực hiện tìm kiếm giảm độ dốc

pyplot.plot(inputs,results).plot(inputs,results)

in ('f (%s) =%f'%(tốt nhất, điểm))

# Xác định phạm vi cho đầu vào..

# Xác định tổng số lần lặp

pyplot.plot(solutions,scores,'.-',color='red').plot(solutions,scores,'.-',color='red')

# Xác định kích thước bước

# Thực hiện tìm kiếm giảm độ dốc

từ nhập khẩu numpy asarraynumpy import asarray

từ nhập khẩu Numpy Arangenumpy import arange

từ numpy.random nhập khẩu randnumpy.random import rand

từ Numpy.Random Hạt nhập nhập khẩunumpy.random import seed

từ pyplot nhập khẩu matplotlibmatplotlib import pyplot

# hàm mục tiêu

mục tiêu def (x):objective(x):

returnx**2.0x**2.0

# đạo hàm của hàm mục tiêu

DEF DERIVATION (X):derivative(x):

returnX *2.0x *2.0

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size):gradient_descent(objective,derivative,bounds,n_iter, step_size):

# Theo dõi tất cả các giải pháp

solutions,scores=list(),list(),scores=list(),list()

# Tạo điểm ban đầu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])= bounds[:,0]+rand(len(bounds))*(bounds[:,1]- bounds[:,0])

# Chạy độ dốc độ dốc

foriinrange(n_iter):iinrange(n_iter):

# Tính độ dốc

gradient=derivative(solution)= derivative(solution)

# Hãy thực hiện một bước

Giải pháp = giải pháp-step_size *gradient=solution-step_size *gradient

# Đánh giá điểm ứng cử viên

solution_eval=objective(solution)= objective(solution)

# Lưu trữ giải pháp

solutions.append(solution).append(solution)

scores.append(solution_eval).append(solution_eval)

# Báo cáo tiến độ

in ('>%d f (%s) =%.5f'%(i, giải pháp, giải pháp_eval)))('>%d f(%s) = %.5f'%(i,solution,solution_eval))

return[solutions,scores][solutions,scores]

# Hạt trình tạo số ngẫu nhiên giả giả

seed(4)(4)

# Xác định phạm vi cho đầu vào

bounds=asarray([[-1.0,1.0]])=asarray([[-1.0,1.0]])

# Xác định tổng số lần lặp

n_iter=30=30

# Xác định kích thước bước

step_size=0.1 =0.1

# Thực hiện tìm kiếm giảm độ dốc

solutions,scores=gradient_descent(objective,derivative,bounds,n_iter,step_size),scores=gradient_descent(objective,derivative,bounds,n_iter,step_size)

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

inputs=arange(bounds[0,0],bounds[0,1]+0.1,0.1)=arange(bounds[0,0],bounds[0,1]+0.1,0.1)

# Tính toán mục tiêu

results=objective(inputs) =objective(inputs)

# Tạo một biểu đồ dòng đầu vào so với kết quả

pyplot.plot(inputs,results).plot(inputs,results)

# Vẽ các giải pháp được tìm thấy

pyplot.plot(solutions,scores,'.-',color='red').plot(solutions, scores,'.-',color='red')

# Hiển thị cốt truyện

pyplot.show().show()

Chạy ví dụ thực hiện tìm kiếm giảm độ dốc trên hàm mục tiêu như trước đây, ngoại trừ trong trường hợp này, mỗi điểm được tìm thấy trong quá trình tìm kiếm được vẽ.

Trong trường hợp này, chúng ta có thể thấy rằng việc tìm kiếm bắt đầu hơn một nửa phần bên phải của chức năng và bước xuống dốc xuống đáy lưu vực.

Chúng ta có thể thấy rằng trong các phần của hàm mục tiêu với đường cong lớn hơn, đạo hàm (gradient) lớn hơn và lần lượt, các bước lớn hơn được thực hiện. Tương tự, độ dốc nhỏ hơn khi chúng ta tiến gần hơn với Optima, và đến lượt nó, các bước nhỏ hơn được thực hiện.

Điều này nhấn mạnh rằng kích thước bước được sử dụng làm yếu tố tỷ lệ trên độ lớn của độ dốc (độ cong) của hàm mục tiêu.

Biểu đồ về tiến trình giảm độ dốc trên hàm mục tiêu một chiều

Tối ưu hóa giảm dần độ dốc với động lượng

Tiếp theo, chúng ta có thể cập nhật thuật toán tối ưu hóa độ dốc độ dốc để sử dụng động lượng.

Điều này có thể đạt được bằng cách cập nhật hàm gradient_descent () để lấy một đối số động lượng trên mạng xác định lượng động lượng được sử dụng trong quá trình tìm kiếm.

Sự thay đổi được thực hiện đối với giải pháp phải được ghi nhớ từ lần lặp trước của vòng lặp, với giá trị ban đầu là 0,0.

.....

# Theo dõi sự thay đổi

change=0.0=0.0

Sau đó, chúng ta có thể chia thủ tục cập nhật vào đầu tiên tính toán độ dốc, sau đó tính toán thay đổi thành giải pháp, tính toán vị trí của giải pháp mới, sau đó lưu thay đổi cho lần lặp tiếp theo.

.....

# Tính độ dốc

gradient=derivative(solution)=derivative(solution)

# Hãy thực hiện một bước

Giải pháp = giải pháp-step_size *gradient=step_size *gradient+momentum *change

# Hãy thực hiện một bước

solution=solution-new_change=solution-new_change

Giải pháp = giải pháp-step_size *gradient

change=new_change=new_change

# Đánh giá điểm ứng cử viên

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size):gradient_descent(objective,derivative,bounds,n_iter,step_size,momentum):

# Tạo điểm ban đầu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])=bounds[:,0]+rand(len(bounds))*(bounds[:,1] -bounds[:,0])

# Theo dõi sự thay đổi

change=0.0=0.0

# Chạy độ dốc độ dốc

foriinrange(n_iter):iin range(n_iter):

# Tính độ dốc

gradient=derivative(solution)=derivative(solution)

# Hãy thực hiện một bước

Giải pháp = giải pháp-step_size *gradient=step_size *gradient +momentum *change

# Hãy thực hiện một bước

solution=solution-new_change=solution-new_change

Giải pháp = giải pháp-step_size *gradient

change=new_change=new_change

# Đánh giá điểm ứng cử viên

solution_eval=objective(solution)=objective(solution)

# Báo cáo tiến độ

in ('>%d f (%s) =%.5f'%(i, giải pháp, giải pháp_eval)))('>%d f(%s) = %.5f'%(i,solution, solution_eval))

return[solution,solution_eval][solution,solution_eval]

# Hạt trình tạo số ngẫu nhiên giả giả

# Xác định phạm vi cho đầu vào

.....

# Theo dõi sự thay đổi

momentum=0.3=0.3

best,score=gradient_descent(objective,derivative,bounds,n_iter,step_size,momentum),score=gradient_descent(objective,derivative, bounds,n_iter,step_size,momentum)

# Tính cập nhật

# Ví dụ về độ dốc độ dốc với động lượng cho hàm một chiều

từ nhập khẩu numpy asarraynumpy import asarray

từ numpy.random nhập khẩu randnumpy.random import rand

từ Numpy.Random Hạt nhập nhập khẩunumpy.random import seed

# hàm mục tiêu

mục tiêu def (x):objective(x):

returnx**2.0x**2.0

# đạo hàm của hàm mục tiêu

DEF DERIVATION (X):derivative(x):

returnX *2.0x *2.0

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size, động lượng):gradient_descent(objective,derivative,bounds,n_iter,step_size,momentum):

# Tạo điểm ban đầu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])= bounds[:,0]+rand(len(bounds))*(bounds[:,1]- bounds[:,0])

# Theo dõi sự thay đổi

change=0.0=0.0

# Chạy độ dốc độ dốc

foriinrange(n_iter):iin range(n_iter):

# Tính độ dốc

gradient=derivative(solution)=derivative(solution)

# Tính cập nhật

new_change = step_size *gradient+động lượng *thay đổi=step_size *gradient +momentum *change

# Hãy thực hiện một bước

solution=solution-new_change=solution-new_change

# Lưu thay đổi

change=new_change=new_change

# Đánh giá điểm ứng cử viên

solution_eval=objective(solution)=objective(solution)

# Báo cáo tiến độ

in ('>%d f (%s) =%.5f'%(i, giải pháp, giải pháp_eval)))('>%d f(%s) = %.5f'%(i,solution, solution_eval))

return[solution,solution_eval][solution,solution_eval]

# Hạt trình tạo số ngẫu nhiên giả giả

seed(4)(4)

# Xác định phạm vi cho đầu vào

bounds=asarray([[-1.0,1.0]])= asarray([[-1.0,1.0]])

# Xác định tổng số lần lặp

n_iter=30=30

# Xác định kích thước bước

step_size=0.1=0.1

# Xác định động lượng

momentum=0.3 =0.3

# Thực hiện tìm kiếm giảm độ dốc với động lượng

best,score=gradient_descent(objective,derivative,bounds,n_iter,step_size,momentum),score=gradient_descent(objective,derivative,bounds,n_iter, step_size,momentum)

print('Done!')('Done!')

in ('f (%s) =%f'%(tốt nhất, điểm))('f(%s) = %f'%(best,score))

Chạy ví dụ bắt đầu với một điểm ngẫu nhiên trong không gian tìm kiếm, sau đó áp dụng thuật toán giảm độ dốc với động lượng, báo cáo hiệu suất trên đường đi.

Trong trường hợp này, chúng ta có thể thấy rằng thuật toán tìm thấy một giải pháp tốt sau khoảng 13 lần lặp, với đánh giá hàm khoảng 0,0.

Đúng như dự đoán, điều này nhanh hơn (ít lặp hơn) so với độ dốc độ dốc mà không có động lực, sử dụng cùng một điểm bắt đầu và kích thước bước mất 27 lần lặp.

> 0 F ([0.74724774]) = 0,55838

> 1 F ([0.54175461]) = 0.29350

> 2 F ([0.37175575]) = 0.13820

> 3 F ([0.24640494]) = 0,06072

> 4 F ([0.15951871]) = 0,02545

> 5 F ([0.1015491]) = 0,01031

> 6 F ([0,0638484]) = 0,00408

> 7 F ([0,03976851]) = 0,00158

> 8 F ([0,02459084]) = 0,00060

> 9 F ([0.01511937]) = 0,00023

> 10 F ([0,00925406]) = 0,00009

> 11 F ([0,00564365]) = 0,00003

> 12 F ([0,0034318]) = 0,00001

> 13 F ([0,00208188]) = 0,00000

> 14 F ([0,00126053]) = 0,00000

> 15 F ([0,00076202]) = 0,00000

> 16 F ([0,00046006]) = 0,00000

> 17 F ([0,00027746]) = 0,00000

> 18 F ([0,00016719]) = 0,00000

> 19 F ([0,00010067]) = 0,00000

> 20 F ([6.05804744E-05]) = 0,00000

> 21 F ([3.64373635E-05]) = 0,00000

> 22 F ([2.19069576E-05]) = 0,00000

> 23 f ([1.31664443e-05]) = 0,00000

> 24 F ([7.91100141E-06]) = 0,00000

> 25 F ([4.75216828E-06]) = 0,00000

> 26 F ([2.85408468E-06]) = 0,00000

> 27 F ([1.71384267E-06]) = 0,00000

> 28 F ([1.02900153E-06]) = 0,00000

> 29 F ([6.17748881E-07]) = 0,00000

Done!

F ([6.17748881E-07]) = 0,000000

Trực quan hóa tối ưu hóa giảm độ dốc với động lượng

Cuối cùng, chúng ta có thể hình dung tiến trình của thuật toán tối ưu hóa giảm độ dốc với động lượng.

Ví dụ hoàn chỉnh được liệt kê dưới đây.

# Ví dụ về âm mưu giảm độ dốc với động lượng cho hàm một chiều

từ nhập khẩu numpy asarraynumpy import asarray

từ nhập khẩu Numpy Arangenumpy import arange

từ numpy.random nhập khẩu randnumpy.random import rand

từ Numpy.Random Hạt nhập nhập khẩunumpy.random import seed

từ pyplot nhập khẩu matplotlibmatplotlib import pyplot

# hàm mục tiêu

mục tiêu def (x):objective(x):

returnx**2.0x**2.0

# đạo hàm của hàm mục tiêu

DEF DERIVATION (X):derivative(x):

returnX *2.0x *2.0

# Thuật toán gốc gradient

def gradient_descent (mục tiêu, phái sinh, giới hạn, n_iter, step_size, động lượng):gradient_descent(objective,derivative,bounds,n_iter, step_size,momentum):

# Tạo điểm ban đầu

solutions,scores=list(),list(),scores=list(),list()

# Tạo điểm ban đầu

solution=bounds[:,0]+rand(len(bounds))*(bounds[:,1]-bounds[:,0])=bounds[:,0]+rand(len(bounds))*(bounds[:,1] -bounds[:,0])

# Theo dõi sự thay đổi

change=0.0=0.0

# Chạy độ dốc độ dốc

foriinrange(n_iter):iin range(n_iter):

# Tính độ dốc

gradient=derivative(solution)=derivative(solution)

# Tính cập nhật

new_change = step_size *gradient+động lượng *thay đổi=step_size *gradient +momentum *change

# Hãy thực hiện một bước

solution=solution-new_change=solution-new_change

# Lưu thay đổi

change=new_change=new_change

# Đánh giá điểm ứng cử viên

solution_eval=objective(solution)=objective(solution)

# Báo cáo tiến độ

solutions.append(solution).append(solution)

scores.append(solution_eval).append(solution_eval)

# Báo cáo tiến độ

in ('>%d f (%s) =%.5f'%(i, giải pháp, giải pháp_eval)))('>%d f(%s) = %.5f'%(i,solution,solution_eval))

return[solutions,scores] [solutions,scores]

# Hạt trình tạo số ngẫu nhiên giả giả

seed(4)(4)

# Xác định phạm vi cho đầu vào

bounds=asarray([[-1.0,1.0]])=asarray([[-1.0, 1.0]])

# Xác định tổng số lần lặp

n_iter=30=30

# Xác định kích thước bước

step_size=0.1=0.1

# Xác định động lượng

momentum=0.3=0.3

# Thực hiện tìm kiếm giảm độ dốc với động lượng

solutions,scores=gradient_descent(objective,derivative,bounds,n_iter,step_size,momentum),scores=gradient_descent(objective,derivative,bounds,n_iter,step_size,momentum)

# Phạm vi đầu vào mẫu thống nhất ở mức tăng 0,1

inputs=arange(bounds[0,0],bounds[0,1]+0.1,0.1)=arange(bounds[0,0],bounds[0,1]+0.1,0.1)

# Tính toán mục tiêu

results=objective(inputs) =objective(inputs)

# Tạo một biểu đồ dòng đầu vào so với kết quả

pyplot.plot(inputs,results).plot(inputs,results)

# Vẽ các giải pháp được tìm thấy

pyplot.plot(solutions,scores,'.-',color='red').plot(solutions, scores,'.-',color='red')

# Hiển thị cốt truyện

pyplot.show().show()

Chạy ví dụ thực hiện tìm kiếm giảm độ dốc với động lượng trên hàm mục tiêu như trước đây, ngoại trừ trong trường hợp này, mỗi điểm được tìm thấy trong quá trình tìm kiếm được vẽ.

Trong trường hợp này, nếu chúng ta so sánh cốt truyện với cốt truyện được tạo trước đây cho hiệu suất của độ dốc độ dốc (không có động lượng), chúng ta có thể thấy rằng tìm kiếm thực sự đạt đến tối ưu trong ít bước hơn, được ghi nhận với ít chấm đỏ khác biệt trên đường dẫn đến đường dẫn đến đáy của lưu vực.

Biểu đồ tiến trình của độ dốc giảm dần với động lượng trên hàm mục tiêu một chiều

Là một phần mở rộng, hãy thử các giá trị khác nhau cho động lượng, chẳng hạn như 0,8 và xem lại biểu đồ kết quả. Hãy cho tôi biết những gì bạn khám phá trong các ý kiến dưới đây.
Let me know what you discover in the comments below.

Đọc thêm

Phần này cung cấp nhiều tài nguyên hơn về chủ đề nếu bạn đang muốn đi sâu hơn.

Sách

Thuật toán để tối ưu hóa, 2019.
Học sâu, 2016.
Neural Smithing: Học tập có giám sát trong mạng lưới thần kinh nhân tạo, 1999.
Mạng lưới thần kinh để nhận dạng mẫu, 1996.
Mạng lưới thần kinh: Thủ thuật thương mại, 2012.

API

numpy.random.rand API.
Numpy.asarray API.
API Matplotlib.

Bài viết

Độ dốc gốc, Wikipedia.
Độ dốc ngẫu nhiên, Wikipedia.
Gradient, wikipedia.
Phái sinh, wikipedia.
Chức năng khác biệt, Wikipedia.

Bản tóm tắt

Trong hướng dẫn này, bạn đã phát hiện ra độ dốc gốc với thuật toán động lượng.

Cụ thể, bạn đã học được:

Độ dốc gốc là một thuật toán tối ưu hóa sử dụng gradient của hàm mục tiêu để điều hướng không gian tìm kiếm.
Độ dốc độ dốc có thể được tăng tốc bằng cách sử dụng động lượng từ các bản cập nhật trong quá khứ đến vị trí tìm kiếm.
Làm thế nào để thực hiện tối ưu hóa giảm độ dốc với động lượng và phát triển trực giác cho hành vi của nó.

Bạn có câu hỏi nào không? Đặt câu hỏi của bạn trong các ý kiến dưới đây và tôi sẽ cố gắng hết sức để trả lời.
Ask your questions in the comments below and I will do my best to answer.

Nhận một xử lý các thuật toán tối ưu hóa hiện đại!

Phát triển sự hiểu biết của bạn về tối ưu hóa

... Chỉ với một vài dòng mã Python

Khám phá cách trong ebook mới của tôi: Tối ưu hóa cho việc học máy
Optimization for Machine Learning

Nó cung cấp các hướng dẫn tự học với mã làm việc đầy đủ trên: giảm độ dốc, thuật toán di truyền, leo đồi, phù hợp với đường cong, RMSProp, Adam, và nhiều hơn nữa ...self-study tutorials with full working code on:
Gradient Descent, Genetic Algorithms, Hill Climbing, Curve Fitting, RMSProp, Adam, and much more...

Mang các thuật toán tối ưu hóa hiện đại cho các dự án học máy của bạn
Your Machine Learning Projects

Xem những gì bên trong

Độ dốc giảm dần với động lượng là gì?

Có một thuật toán được gọi là động lượng, hoặc độ dốc giảm dần với động lượng hầu như luôn hoạt động nhanh hơn thuật toán gốc gradient tiêu chuẩn. Trong một câu, ý tưởng cơ bản là tính trung bình có trọng số theo cấp số nhân của độ dốc của bạn, và sau đó sử dụng gradient đó để cập nhật trọng lượng của bạn thay thế.compute an exponentially weighted average of your gradients, and then use that gradient to update your weights instead.

Làm thế nào để bạn mã hóa một độ dốc giảm dần trong Python?

Để thực hiện một thuật toán giảm dần độ dốc, chúng ta cần làm theo 4 bước:..

Khởi tạo ngẫu nhiên sự thiên vị và trọng lượng theta ..

Tính giá trị dự đoán của y là y cho độ lệch và trọng lượng ..

Tính hàm chi phí từ các giá trị dự đoán và thực tế của y ..

Tính toán gradient và trọng số ..

Tại sao chúng ta cần động lực ở độ dốc giảm dần?

Động lượng là một phần mở rộng cho thuật toán tối ưu hóa giảm độ dốc cho phép tìm kiếm xây dựng quán tính theo hướng trong không gian tìm kiếm và khắc phục các dao động của độ dốc ồn ào và bờ biển trên các điểm phẳng của không gian tìm kiếm.allows the search to build inertia in a direction in the search space and overcome the oscillations of noisy gradients and coast across flat spots of the search space.

RMSProp có sử dụng động lượng không?

Việc triển khai RMSPROP này sử dụng động lượng đơn giản, không phải là động lượng của Nesterov.Phiên bản trung tâm cũng duy trì mức trung bình di chuyển của độ dốc và sử dụng mức trung bình đó để ước tính phương sai.uses plain momentum, not Nesterov momentum. The centered version additionally maintains a moving average of the gradients, and uses that average to estimate the variance.

Hướng dẫn gradient descent with momentum python - dốc xuống với con trăn động lượng

Tổng quan hướng dẫn

Xuống dốc

Bạn muốn bắt đầu với các thuật toán tối ưu hóa?

Quán tính

Độ dốc hạ xuống với động lượng

Vấn đề kiểm tra một chiều

# Hiển thị cốt truyện

Trực quan hóa tối ưu hóa giảm dần độ dốc

Tối ưu hóa giảm dần độ dốc với động lượng

Trực quan hóa tối ưu hóa giảm độ dốc với động lượng

Đọc thêm

Sách

API

Bài viết

Bản tóm tắt

Nhận một xử lý các thuật toán tối ưu hóa hiện đại!

Phát triển sự hiểu biết của bạn về tối ưu hóa

Mang các thuật toán tối ưu hóa hiện đại cho các dự án học máy của bạnYour Machine Learning Projects

Độ dốc giảm dần với động lượng là gì?

Làm thế nào để bạn mã hóa một độ dốc giảm dần trong Python?

Tại sao chúng ta cần động lực ở độ dốc giảm dần?

RMSProp có sử dụng động lượng không?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Mang các thuật toán tối ưu hóa hiện đại cho các dự án học máy của bạn
Your Machine Learning Projects