Hướng dẫn non linear least squares python - python bình phương nhỏ nhất phi tuyến tính

Giải quyết vấn đề bình phương nhỏ nhất phi tuyến với giới hạn trên các biến.

Với phần dư f (x) (hàm thực m-d của các biến thực n) và hàm mất Rho (s) (hàm vô hướng),

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

minimize F(x) = 0.5 * sum(rho(f_i(x)**2), i = 0, ..., m - 1)
subject to lb <= x <= ub

Mục đích của chức năng mất Rho (s) là để giảm ảnh hưởng của các ngoại lệ đến giải pháp.

Chức năng tính toán vectơ của phần dư, với chữ ký

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

Dự đoán ban đầu trên các biến độc lập. Nếu nổi, nó sẽ được coi là mảng 1-D với một phần tử.

Phương pháp tính toán ma trận Jacobian (ma trận M-by-N, trong đó phần tử (i, j) là đạo hàm một phần của f [i] đối với x [j]). Các từ khóa chọn sơ đồ khác biệt hữu hạn để ước tính số. Sơ đồ ‘3 điểm, chính xác hơn, nhưng yêu cầu gấp đôi số hoạt động so với‘ 2 điểm (mặc định). Sơ đồ ‘CS, sử dụng các bước phức tạp, và trong khi có khả năng chính xác nhất, nhưng nó chỉ áp dụng khi FUN xử lý chính xác các đầu vào phức tạp và có thể được tiếp tục phân tích đến mặt phẳng phức tạp. Phương pháp ‘LM, luôn luôn sử dụng sơ đồ‘ 2 điểm. Nếu có thể gọi được, nó được sử dụng là

>>> from scipy.optimize import least_squares
>>> x0_rosenbrock = np.array([2, 2])
>>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
>>> res_1.x
array([ 1.,  1.])
>>> res_1.cost
9.8669242910846867e-30
>>> res_1.optimality
8.8928864934219529e-14

>>> from scipy.optimize import least_squares
>>> x0_rosenbrock = np.array([2, 2])
>>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
>>> res_1.x
array([ 1.,  1.])
>>> res_1.cost
9.8669242910846867e-30
>>> res_1.optimality
8.8928864934219529e-14

Giới hạn dưới và trên trên các biến độc lập. Mặc định không có giới hạn. Mỗi mảng phải khớp với kích thước của x0 hoặc là vô hướng, trong trường hợp sau, một ràng buộc sẽ giống nhau cho tất cả các biến. Sử dụng

>>> from scipy.optimize import least_squares
>>> x0_rosenbrock = np.array([2, 2])
>>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
>>> res_1.x
array([ 1.,  1.])
>>> res_1.cost
9.8669242910846867e-30
>>> res_1.optimality
8.8928864934219529e-14

Thuật toán để thực hiện giảm thiểu.

• ‘TRF,: Thuật toán phản ánh vùng tin cậy, đặc biệt phù hợp với các vấn đề thưa thớt lớn với giới hạn. Nói chung là phương pháp mạnh mẽ.

• Dogbox, thuật toán Dogleg với các vùng tin cậy hình chữ nhật, trường hợp sử dụng điển hình là những vấn đề nhỏ với giới hạn. Không được khuyến nghị cho các vấn đề với Jacobian thiếu thứ hạng.

• ‘LM,: Thuật toán Levenberg-Marquardt như được thực hiện trong Minpack. Không xử lý giới hạn và người Jacobian thưa thớt. Thông thường phương pháp hiệu quả nhất cho các vấn đề nhỏ không bị ràng buộc.

Mặc định là ‘TRF. Xem ghi chú để biết thêm thông tin.

Dung sai để chấm dứt bằng cách thay đổi hàm chi phí. Mặc định là 1e-8. Quá trình tối ưu hóa được dừng lại khi

>>> from scipy.optimize import least_squares
>>> x0_rosenbrock = np.array([2, 2])
>>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
>>> res_1.x
array([ 1.,  1.])
>>> res_1.cost
9.8669242910846867e-30
>>> res_1.optimality
8.8928864934219529e-14

Nếu không có và ‘phương thức, không phải là‘ LM, thì việc chấm dứt theo điều kiện này sẽ bị vô hiệu hóa. Nếu ‘phương pháp là‘ LM, thì dung sai này phải cao hơn epsilon máy.

Dung sai để chấm dứt bằng cách thay đổi các biến độc lập. Mặc định là 1e-8. Điều kiện chính xác phụ thuộc vào phương pháp được sử dụng:

• Đối với ‘TRF, và‘ Dogbox,

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  4.

• Đối với ‘LM,:

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  5, trong đó

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  6 là bán kính vùng tin cậy và

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  7 là giá trị của

  >>> def fun_rosenbrock(x):
  ...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])
  

  7 được chia tỷ lệ theo tham số X_Scale (xem bên dưới).

Nếu không có và ‘phương thức, không phải là‘ LM, thì việc chấm dứt theo điều kiện này sẽ bị vô hiệu hóa. Nếu ‘phương pháp là‘ LM, thì dung sai này phải cao hơn epsilon máy.

Dung sai để chấm dứt bằng cách thay đổi các biến độc lập. Mặc định là 1e-8. Điều kiện chính xác phụ thuộc vào phương pháp được sử dụng:

• Đối với ‘TRF, và‘ Dogbox,

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  4.

• Đối với ‘LM,:

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  5, trong đó

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  6 là bán kính vùng tin cậy và

  >>> from scipy.optimize import least_squares
  >>> x0_rosenbrock = np.array([2, 2])
  >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
  >>> res_1.x
  array([ 1.,  1.])
  >>> res_1.cost
  9.8669242910846867e-30
  >>> res_1.optimality
  8.8928864934219529e-14
  

  7 là giá trị của

  >>> def fun_rosenbrock(x):
  ...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])
  

  7 được chia tỷ lệ theo tham số X_Scale (xem bên dưới).

• gtolfloat hoặc không, tùy chọn

Nếu không có và ‘phương thức, không phải là‘ LM, thì việc chấm dứt theo điều kiện này sẽ bị vô hiệu hóa. Nếu ‘phương pháp là‘ LM, thì dung sai này phải cao hơn epsilon máy.

Quy mô đặc trưng của từng biến. Cài đặt X_Scale tương đương với việc cải tổ vấn đề trong các biến được chia tỷ lệ

>>> def jac_rosenbrock(x):
...     return np.array([
...         [-20 * x[0], 10],
...         [-1, 0]])

>>> def jac_rosenbrock(x):
...     return np.array([
...         [-20 * x[0], 10],
...         [-1, 0]])

Xác định chức năng mất. Các giá trị từ khóa sau được cho phép:

• ‘Tuyến tính (mặc định):

  >>> def jac_rosenbrock(x):
  ...     return np.array([
  ...         [-20 * x[0], 10],
  ...         [-1, 0]])
  
  

  5. Đưa ra một vấn đề bình phương nhỏ nhất tiêu chuẩn.

• Soft_L1,:

  >>> def jac_rosenbrock(x):
  ...     return np.array([
  ...         [-20 * x[0], 10],
  ...         [-1, 0]])
  
  

  6. Sự xấp xỉ trơn tru của tổn thất L1 (giá trị tuyệt đối). Thường là một lựa chọn tốt cho bình phương tối thiểu mạnh mẽ.

• Huber Huber:

  >>> def jac_rosenbrock(x):
  ...     return np.array([
  ...         [-20 * x[0], 10],
  ...         [-1, 0]])
  
  

  7. Hoạt động tương tự như ‘soft_l1.

• ‘Cauchy,

  >>> def jac_rosenbrock(x):
  ...     return np.array([
  ...         [-20 * x[0], 10],
  ...         [-1, 0]])
  
  

  8. Làm suy yếu nghiêm trọng ảnh hưởng của ngoại lệ, nhưng có thể gây khó khăn trong quá trình tối ưu hóa.

• ‘Arctan,

  >>> def jac_rosenbrock(x):
  ...     return np.array([
  ...         [-20 * x[0], 10],
  ...         [-1, 0]])
  
  

  9. Giới hạn tổn thất tối đa trên một phần dư duy nhất, có các thuộc tính tương tự như ‘Cauchy.

Nếu có thể gọi được, phải mất 1-D nDarray

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

Giá trị của lề mềm giữa phần dư inlier và Outier, mặc định là 1.0. Hàm mất được đánh giá như sau

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

Số lượng đánh giá chức năng tối đa trước khi chấm dứt. Nếu không có (mặc định), giá trị được chọn tự động:

• Cho ‘TRF, và‘ Dogbox, 100 * n.

• Đối với ‘LM, 100 * n nếu JAC có thể gọi được và 100 * n * (n + 1) nếu không (vì‘ LM, tính toán chức năng gọi theo ước tính của Jacobian).

Xác định kích thước bước tương đối cho xấp xỉ chênh lệch hữu hạn của Jacobian. Bước thực tế được tính toán là

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

Phương pháp giải quyết các vấn đề phụ thuộc vùng tin cậy, chỉ có liên quan đến các phương pháp ‘TRF và‘ Dogbox.

• Chính xác là phù hợp cho các vấn đề không lớn với ma trận Jacobian dày đặc. Độ phức tạp tính toán trên mỗi lần lặp có thể so sánh với sự phân hủy giá trị số ít của ma trận Jacobian.

• LSMR, phù hợp cho các vấn đề với ma trận Jacobian thưa thớt và lớn. Nó sử dụng quy trình lặp

  >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
  ...                       bounds=([-np.inf, 1.5], np.inf))
  >>> res_2.x
  array([ 1.22437075,  1.5       ])
  >>> res_2.cost
  0.025213093946805685
  >>> res_2.optimality
  1.5885401433157753e-07
  

  6 để tìm giải pháp cho vấn đề bình phương nhỏ nhất tuyến tính và chỉ yêu cầu đánh giá sản phẩm ma trận-vector.

Nếu không có (mặc định), bộ giải được chọn dựa trên loại Jacobian được trả về trong lần lặp đầu tiên.

Tùy chọn từ khóa được chuyển cho người giải phân vùng tin cậy.

• >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
  ...                       bounds=([-np.inf, 1.5], np.inf))
  >>> res_2.x
  array([ 1.22437075,  1.5       ])
  >>> res_2.cost
  0.025213093946805685
  >>> res_2.optimality
  1.5885401433157753e-07
  

  7: TR_Options bị bỏ qua.

• >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
  ...                       bounds=([-np.inf, 1.5], np.inf))
  >>> res_2.x
  array([ 1.22437075,  1.5       ])
  >>> res_2.cost
  0.025213093946805685
  >>> res_2.optimality
  1.5885401433157753e-07
  

  8: Tùy chọn cho

  >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
  ...                       bounds=([-np.inf, 1.5], np.inf))
  >>> res_2.x
  array([ 1.22437075,  1.5       ])
  >>> res_2.cost
  0.025213093946805685
  >>> res_2.optimality
  1.5885401433157753e-07
  

  6. Ngoài ra,

  >>> def fun_broyden(x):
  ...     f = (3 - x) * x + 1
  ...     f[1:] -= x[:-1]
  ...     f[:-1] -= 2 * x[1:]
  ...     return f
  

  0 hỗ trợ tùy chọn chính quy hóa (BOOL, mặc định là đúng), điều này bổ sung một thuật ngữ chính quy vào phương trình bình thường, giúp cải thiện sự hội tụ nếu Jacobian thiếu thứ hạng [BYRD] (Phương trình 3.4).

Xác định cấu trúc thưa thớt của ma trận Jacobian để ước tính chênh lệch hữu hạn, hình dạng của nó phải là (m, n). Nếu Jacobian chỉ có một vài phần tử khác không trong mỗi hàng, việc cung cấp cấu trúc thưa thớt sẽ tăng tốc đáng kể các tính toán [Curtis]. Một mục không có nghĩa là một phần tử tương ứng trong Jacobian bằng không. Nếu được cung cấp, buộc phải sử dụng ‘LSMR, Trust-Bolvers. Nếu không có (mặc định), thì sự khác biệt dày đặc sẽ được sử dụng. Không có tác dụng cho phương pháp ‘LM.

Mức độ của thuật toán từ verbosity:

• 0 (mặc định): Làm việc âm thầm.

• 1: Hiển thị báo cáo chấm dứt.

• 2: Hiển thị tiến trình trong quá trình lặp (không được hỗ trợ bởi phương thức ‘LM).

Các cuộc tranh luận bổ sung được truyền lại cho niềm vui và JAC. Cả hai trống theo mặc định. Chữ ký gọi là

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

xndarray, hình dạng (n,)ndarray, shape (n,)

Giải pháp tìm thấy.

chi phífloat

Giá trị của hàm chi phí tại giải pháp.

Funndarray, Shape (M,)ndarray, shape (m,)

Vector của phần dư tại dung dịch.

Jacndarray, ma trận thưa thớt hoặc trình điều khiển tuyến tính, hình dạng (m, n)ndarray, sparse matrix or LinearOperator, shape (m, n)

Ma trận Jacobian đã sửa đổi tại giải pháp, theo nghĩa là J^t j là một xấp xỉ Gauss-Newton của Hessian của hàm chi phí. Loại giống như loại được sử dụng bởi thuật toán.

Gradndarray, Shape (M,)ndarray, shape (m,)

Độ dốc của chức năng chi phí tại giải pháp.

Tối ưufloat

Biện pháp tối ưu thứ nhất. Trong các vấn đề không bị ràng buộc, nó luôn luôn là chuẩn mực thống nhất của độ dốc. Trong các vấn đề bị ràng buộc, đó là số lượng được so sánh với GTOL trong quá trình lặp lại.

Active_maskndarray của int, hình dạng (n,)ndarray of int, shape (n,)

Mỗi thành phần cho thấy liệu một ràng buộc tương ứng có hoạt động hay không (nghĩa là, liệu một biến có ở mức bị ràng buộc):

• 0: Một ràng buộc không hoạt động.

• -1: Một giới hạn dưới đang hoạt động.

• 1: Một giới hạn trên đang hoạt động.

Có thể hơi tùy tiện cho phương pháp ‘TRF, vì nó tạo ra một chuỗi các lần lặp hoàn toàn khả thi và Active_mask được xác định trong ngưỡng dung sai.

nfevintint

Số lượng đánh giá chức năng được thực hiện. Các phương pháp ‘TRF, và‘ Dogbox, không đếm các chức năng gọi cho xấp xỉ bằng số Jacobian, trái ngược với phương thức ‘LM.

njevint hoặc không cóint or None

Số lượng đánh giá Jacobian được thực hiện. Nếu xấp xỉ bằng số Jacobian được sử dụng trong phương thức ‘LM, thì nó sẽ được đặt thành không.

địa vịint

Lý do chấm dứt thuật toán:

• -1: Trạng thái tham số đầu vào không đúng được trả về từ MinPack.

• 0: Số lượng đánh giá chức năng tối đa bị vượt quá.

• 1: Điều kiện chấm dứt GTOL được thỏa mãn.

• 2: Điều kiện chấm dứt FTOL được thỏa mãn.

• 3: Điều kiện chấm dứt XTOL được thỏa mãn.

• 4: Cả hai điều kiện chấm dứt FTOL và XTOL đều được thỏa mãn.

Messagestrstr

Mô tả bằng lời nói về lý do chấm dứt.

Thành côngbool

Đúng nếu một trong các tiêu chí hội tụ được thỏa mãn (trạng thái> 0).

Xem thêm

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

Một trình bao bọc kế thừa cho việc triển khai Minpack của thuật toán Levenberg-Marquadt.

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

Tối thiểu hóa bình phương nhỏ nhất áp dụng cho một vấn đề phù hợp với đường cong.

Ghi chú

Phương thức ‘LM, (Levenberg-Marquest) gọi một trình bao bọc qua các thuật toán bình phương nhỏ nhất được triển khai trong Minpack (LMDER, LMDIF). Nó chạy thuật toán Levenberg-Marquest được xây dựng như một thuật toán loại ủy thác. Việc thực hiện dựa trên giấy [JJMore], nó rất mạnh mẽ và hiệu quả với rất nhiều thủ thuật thông minh. Nó nên là lựa chọn đầu tiên của bạn cho các vấn đề không bị ràng buộc. Lưu ý rằng nó không hỗ trợ giới hạn. Ngoài ra, nó không hoạt động khi m

Phương pháp ‘TRF, (phản xạ vùng tin cậy) được thúc đẩy bởi quá trình giải một hệ phương trình, tạo thành điều kiện tối ưu thứ nhất cho vấn đề giảm thiểu bị hạn chế bị ràng buộc như được xây dựng trong [Stir]. Thuật toán giải quyết các vấn đề tiểu vùng tin cậy được tăng cường bởi một thuật ngữ bậc hai đường chéo đặc biệt và với hình dạng khu vực tin cậy được xác định bởi khoảng cách từ giới hạn và hướng của độ dốc. Các cải tiến này giúp tránh thực hiện các bước trực tiếp vào giới hạn và khám phá hiệu quả toàn bộ không gian của các biến. Để cải thiện hơn nữa sự hội tụ, thuật toán xem xét các hướng tìm kiếm được phản ánh từ các giới hạn. Để tuân thủ các yêu cầu lý thuyết, thuật toán giữ cho lặp đi lặp lại hoàn toàn khả thi. Với các tiểu cầu của Jacobians Trust-Puion được giải quyết bằng một phương pháp chính xác rất giống với phương pháp được mô tả trong [JJMore] (và được thực hiện trong Minpack). Sự khác biệt so với việc triển khai MinPack là sự phân hủy giá trị số ít của ma trận Jacobian được thực hiện một lần mỗi lần lặp, thay vì phân tách QR và loạt loại bỏ xoay vòng. Đối với người Jacobian lớn thưa thớt, cách tiếp cận không gian con 2-D để giải quyết các tiểu cầu đáng tin cậy được sử dụng [Stir], [Byrd]. Không gian con được kéo dài bởi một gradient tỷ lệ và một giải pháp Gauss-Newton gần đúng được cung cấp bởi

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

Phương pháp ‘Dogbox, hoạt động trong khuôn khổ vùng tin cậy, nhưng xem xét các vùng tin cậy hình chữ nhật trái ngược với các elipsoids thông thường [voglis]. Giao điểm của một vùng ủy thác hiện tại và giới hạn ban đầu một lần nữa là hình chữ nhật, do đó, trên mỗi lần lặp, một vấn đề giảm thiểu bậc hai phải chịu các ràng buộc bị ràng buộc được giải quyết bằng phương pháp Dogleg của Powell [Numopt]. Bước Gauss-Newton cần thiết có thể được tính toán chính xác cho người Jacobs dày đặc hoặc xấp xỉ bằng

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

Các hàm mất mạnh được thực hiện như được mô tả trong [BA]. Ý tưởng là sửa đổi một vectơ còn lại và ma trận Jacobian trên mỗi lần lặp sao cho độ dốc tính toán và xấp xỉ Gauss-Newton Hessian phù hợp với độ dốc thực sự và xấp xỉ Hessian của hàm chi phí. Sau đó, thuật toán tiến hành theo cách bình thường, tức là, các hàm mất mạnh được thực hiện như một trình bao bọc đơn giản so với các thuật toán bình phương nhỏ nhất tiêu chuẩn.

Mới trong phiên bản 0.17.0.

Người giới thiệu

M. A. Branch, T. F. Coleman và Y. Li, Một không gian con, nội thất và phương pháp gradient liên hợp cho các vấn đề giảm thiểu ràng buộc quy mô lớn, Tạp chí SIAM về máy tính khoa học, tập. 21, số 1, trang 1-23, 1999.

William H. Báo chí et. Al., Công thức nấu ăn số. Nghệ thuật điện toán khoa học. Ấn bản thứ 3, giây. 5.7.

R. H. Byrd, R. B. Schnabel và G. A. Shultz, Giải pháp gần đúng của vấn đề khu vực ủy thác bằng cách giảm thiểu trong các không gian con hai chiều, Math. Lập trình, 40, trang 247-263, 1988.

A. Curtis, M. J. D. Powell, và J. Reid, Hồi về ước tính của ma trận Jacobian thưa thớt, Tạp chí của Viện Toán học và các ứng dụng của nó, 13, trang 117-120, 1974.

J. J. Thêm, Hồi Các thuật toán Levenberg-Marquest: Thực hiện và lý thuyết, Phân tích số, ed. G. A. Watson, Bài giảng ghi chú trong Toán học 630, Springer Verlag, trang 105-116, 1977.

C. Voglis và I. E. Lagaris, Hồi Một phương pháp tiếp cận chó ủy thác hình chữ nhật cho tối ưu hóa phi tuyến bị ràng buộc và ràng buộc, Hội nghị quốc tế WSEAS về toán học ứng dụng, Corfu, Hy Lạp, 2004.

J. Nocedal và S. J. Wright, Tối ưu hóa số, Phiên bản thứ 2, Chương 4.

B. Triggs et. Al., Điều chỉnh bó - Một tổng hợp hiện đại, Kỷ yếu của Hội thảo quốc tế về các thuật toán tầm nhìn: Lý thuyết và thực hành, trang 298-372, 1999.

Ví dụ

Trong ví dụ này, chúng tôi tìm thấy tối thiểu chức năng Rosenbrock mà không giới hạn trên các biến độc lập.

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

Lưu ý rằng chúng tôi chỉ cung cấp vectơ của phần dư. Thuật toán xây dựng hàm chi phí như một tổng hình vuông của phần dư, mang lại chức năng Rosenbrock. Tối thiểu chính xác là tại

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

>>> from scipy.optimize import least_squares
>>> x0_rosenbrock = np.array([2, 2])
>>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
>>> res_1.x
array([ 1.,  1.])
>>> res_1.cost
9.8669242910846867e-30
>>> res_1.optimality
8.8928864934219529e-14

Bây giờ chúng tôi hạn chế các biến, theo cách mà giải pháp trước đó trở nên không khả thi. Cụ thể, chúng tôi yêu cầu

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

>>> from scipy.sparse import lil_matrix
>>> def sparsity_broyden(n):
...     sparsity = lil_matrix((n, n), dtype=int)
...     i = np.arange(n)
...     sparsity[i, i] = 1
...     i = np.arange(1, n)
...     sparsity[i, i - 1] = 1
...     i = np.arange(n - 1)
...     sparsity[i, i + 1] = 1
...     return sparsity
...
>>> n = 100000
>>> x0_broyden = -np.ones(n)
...
>>> res_3 = least_squares(fun_broyden, x0_broyden,
...                       jac_sparsity=sparsity_broyden(n))
>>> res_3.cost
4.5687069299604613e-23
>>> res_3.optimality
1.1650454296851518e-11

Chúng tôi cũng cung cấp Jacobian phân tích:

>>> def jac_rosenbrock(x):
...     return np.array([
...         [-20 * x[0], 10],
...         [-1, 0]])

Đặt tất cả những điều này lại với nhau, chúng ta thấy rằng giải pháp mới nằm ở ràng buộc:

>>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
...                       bounds=([-np.inf, 1.5], np.inf))
>>> res_2.x
array([ 1.22437075,  1.5       ])
>>> res_2.cost
0.025213093946805685
>>> res_2.optimality
1.5885401433157753e-07

Bây giờ chúng tôi giải quyết một hệ phương trình (nghĩa là, hàm chi phí phải bằng 0 ở mức tối thiểu) cho hàm giá trị vectơ chéo của Broyden của 100000 biến:

>>> def fun_broyden(x):
...     f = (3 - x) * x + 1
...     f[1:] -= x[:-1]
...     f[:-1] -= 2 * x[1:]
...     return f

Ma trận Jacobian tương ứng là thưa thớt. Chúng tôi nói với thuật toán ước tính nó bằng sự khác biệt hữu hạn và cung cấp cấu trúc thưa thớt của Jacobian để tăng tốc đáng kể quá trình này.

>>> from scipy.sparse import lil_matrix
>>> def sparsity_broyden(n):
...     sparsity = lil_matrix((n, n), dtype=int)
...     i = np.arange(n)
...     sparsity[i, i] = 1
...     i = np.arange(1, n)
...     sparsity[i, i - 1] = 1
...     i = np.arange(n - 1)
...     sparsity[i, i + 1] = 1
...     return sparsity
...
>>> n = 100000
>>> x0_broyden = -np.ones(n)
...
>>> res_3 = least_squares(fun_broyden, x0_broyden,
...                       jac_sparsity=sparsity_broyden(n))
>>> res_3.cost
4.5687069299604613e-23
>>> res_3.optimality
1.1650454296851518e-11

Hãy cùng giải quyết vấn đề phù hợp với đường cong bằng cách sử dụng chức năng mất mạnh để chăm sóc các ngoại lệ trong dữ liệu. Xác định hàm mô hình là

>>> from scipy.sparse import lil_matrix
>>> def sparsity_broyden(n):
...     sparsity = lil_matrix((n, n), dtype=int)
...     i = np.arange(n)
...     sparsity[i, i] = 1
...     i = np.arange(1, n)
...     sparsity[i, i - 1] = 1
...     i = np.arange(n - 1)
...     sparsity[i, i + 1] = 1
...     return sparsity
...
>>> n = 100000
>>> x0_broyden = -np.ones(n)
...
>>> res_3 = least_squares(fun_broyden, x0_broyden,
...                       jac_sparsity=sparsity_broyden(n))
>>> res_3.cost
4.5687069299604613e-23
>>> res_3.optimality
1.1650454296851518e-11

Đầu tiên, xác định chức năng tạo dữ liệu với nhiễu và ngoại lệ, xác định các tham số mô hình và tạo dữ liệu:

>>> from numpy.random import default_rng
>>> rng = default_rng()
>>> def gen_data(t, a, b, c, noise=0., n_outliers=0, seed=None):
...     rng = default_rng(seed)
...
...     y = a + b * np.exp(t * c)
...
...     error = noise * rng.standard_normal(t.size)
...     outliers = rng.integers(0, t.size, n_outliers)
...     error[outliers] *= 10
...
...     return y + error
...
>>> a = 0.5
>>> b = 2.0
>>> c = -1
>>> t_min = 0
>>> t_max = 10
>>> n_points = 15
...
>>> t_train = np.linspace(t_min, t_max, n_points)
>>> y_train = gen_data(t_train, a, b, c, noise=0.1, n_outliers=3)

Xác định chức năng để tính toán dư và ước tính ban đầu của các tham số.

>>> def fun(x, t, y):
...     return x[0] + x[1] * np.exp(x[2] * t) - y
...
>>> x0 = np.array([1.0, 1.0, 0.0])

Tính toán giải pháp bình phương nhỏ nhất tiêu chuẩn:

>>> res_lsq = least_squares(fun, x0, args=(t_train, y_train))

Bây giờ tính toán hai giải pháp với hai hàm mất mạnh khác nhau. Tham số F_Scale được đặt thành 0,1, có nghĩa là phần dư inliter không được vượt quá đáng kể 0,1 (mức độ nhiễu được sử dụng).

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

Và cuối cùng, vẽ tất cả các đường cong. Chúng tôi thấy rằng bằng cách chọn một tổn thất thích hợp, chúng tôi có thể nhận được các ước tính gần với tối ưu ngay cả khi có sự hiện diện của các ngoại lệ mạnh mẽ. Nhưng hãy nhớ rằng nói chung, người ta nên thử ‘Soft_L1, hoặc‘ Huber, trước hết (nếu cần thiết) vì hai tùy chọn khác có thể gây khó khăn trong quá trình tối ưu hóa.

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

Trong ví dụ tiếp theo, chúng tôi cho thấy các hàm còn lại có giá trị phức tạp của các biến phức tạp có thể được tối ưu hóa như thế nào với

>>> from scipy.sparse import lil_matrix
>>> def sparsity_broyden(n):
...     sparsity = lil_matrix((n, n), dtype=int)
...     i = np.arange(n)
...     sparsity[i, i] = 1
...     i = np.arange(1, n)
...     sparsity[i, i - 1] = 1
...     i = np.arange(n - 1)
...     sparsity[i, i + 1] = 1
...     return sparsity
...
>>> n = 100000
>>> x0_broyden = -np.ones(n)
...
>>> res_3 = least_squares(fun_broyden, x0_broyden,
...                       jac_sparsity=sparsity_broyden(n))
>>> res_3.cost
4.5687069299604613e-23
>>> res_3.optimality
1.1650454296851518e-11

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

Chúng tôi bọc nó thành một hàm của các biến thực trả về phần dư thực bằng cách xử lý các phần thực và tưởng tượng như các biến độc lập:

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])

Do đó, thay vì hàm phức hợp m-d ban đầu của các biến phức N, chúng tôi tối ưu hóa hàm thực 2m-D của các biến thực 2N:

>>> def fun_rosenbrock(x):
...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])