Chƣơng 1 BÀI TỐN TỐI ƢU TỔNG QUÁT
2.2 Bài tốn điều khiển tối ƣu suy biến
2.2.1 Khái niệm
Trở lại bài tốn (2.1), với giả thiết ( ( ), ( ), )L x t u t t và [ ( ), x tf tf]là những hàm trơn, hàm Hamilton cho bài tốn này là:
( , , , ) ( , , ) T ( , , )
H x u t L x u t f x u t (2.2) Theo nguyên lý Pontryagin, các điều kiện cần của bài tốn tối ưu phải thỏa mãn với quỹ đạo tối ưu là:
( , , , ) x H x u t (2.3) ( )tf x[ ( ), ]x tf tf Tx (2.4) ( )f t[ ( ), ]f f tT H t x t t (2.5) trong đĩ: arg min ( , , , ) u u H x u t (2.6)
Với x u, lần lượt là nghiệm tiềm năng của các biến trạng thái và biến điều khiển, là vector hàm nhân tử Lagrange theo thời gian, là các vector nhân tử Lagrange liên hợp với .
Một cực trị của bài tốn điều khiển tối ưu được coi là suy biến nếu det(Huu)=0 tại mọi điểm trên quỹ đạo của nĩ, trong đĩ Huu là ma trận cấp (mm). Trong trường hợp ngược lại là trường hợp khơng suy biến. Trường hợp đặc biệt, khi hàm Hamilton là hàm tuyến tính với một hay nhiều biến điều khiển u(t) thì cực trị sẽ là cực trị suy biến [9].
2.2.2 Các đặc điểm
Định nghĩa 1.1: Gọi uk là phần tử tối ưu suy biến của vector biến điều khiển u
trong khoảng thời gian [t1, t2] mà giá trị của nĩ là tuyến tính trong hàm Hamilton. Gọi đạo hàm bậc 2q của Huklà đạo hàm tồn phần bậc thấp nhất mà trong đĩ uk
xuất hiện tường minh với một hệ số khác khơng trên đoạn [t1, t2]. Khi đĩ q được gọi là bậc của cung suy biến. Biến điều khiển u được gọi là biến điều khiển suy biến.
Lựa chọn phương pháp giải và các cơng cụ 43
Định nghĩa 1.2: Giả sử tất cả các phần tử u1, u2, ..., um của vector biến điều khiển u đồng thời suy biến, thì u được gọi là hàm điều khiển suy biến tồn phần khi:
( , , ) 0
u
H x t (2.6)
với mọi t[ , ]t t0 f .
Định nghĩa 1.3: Một hàm điều khiển được gọi là hàm điều khiển suy biến từng
phần khi biểu thức (2.6) đúng với các khoảng thời gian k cĩ độ dài Ti , i=1, 2, ..., k
và 0 1 k i f i T t t .
Lời giải của rất nhiều bài tốn điều khiển tối ưu khơng thể tìm được theo cách giải tích, đặc biệt với bài tốn điều khiển suy biến. Vì khi đĩ Gradient (2.6) của hàm Hamilton khơng cung cấp bất kỳ một thơng tin nào liên quan đến biến điều khiển khi nĩ bằng 0.
Trong khi đĩ, các phương pháp trực tiếp tìm nghiệm dạng số đã được giới thiệu trong chương 1 lại cĩ thể giải quyết được những bài tốn này bởi nĩ khơng sử dụng đến hàm Hamilton. Mặt khác, những hệ thống điều khiển hiện đại thường là những hệ thống điều khiển số nên việc tìm lời giải dạng số cho bài tốn điều khiển tối ưu động là phổ biến hiện nay. Do đĩ trong luận văn này, tác giả thực hiện việc tìm lời giải số cho bài tốn điều khiển tối ưu động, đặc biệt là với bài tốn điều khiển suy biến.
2.3 Lựa chọn phƣơng pháp giải và các cơng cụ 2.3.1 Lựa chọn phƣơng án IP-SQP
Như đã phân tích trong phần 1.3.3, bài tốn NLP được hình thành bằng cách sử dụng phương pháp QS-SQA cĩ những đặc điểm như sau:
1. Số lượng biến của bài tốn NLP, là các biến điều khiển đã được rời rạc hĩa dạng từng đoạn hằng số, thường nhỏ hơn số lượng biến trạng thái.
2. Số lượng các ràng buộc bất phương trình, mà chính là những ràng buộc đối với biến trạng thái, là khá lớn.
3. Số lượng các ràng buộc dạng phương trình là rất ít nhờ việc sử dụng lớp bài tốn mơ phỏng hệ thống giải hệ phương trình đại số phi tuyến sau collocation.
Trên thực tế khơng tồn tại một phương pháp giải dùng chung cho tất cả các bài tốn tối ưu phi tuyến tĩnh. Do đĩ tùy thuộc vào tính chất, đặc điểm của các bài tốn
Lựa chọn phương pháp giải và các cơng cụ 44 mà người ta chọn phương pháp giải phù hợp. Tuy nhiên ta cần lưu ý một số đặc điểm sau:
Phương pháp IP-SQP thường cho nghiệm nhanh hơn phương pháp AS-SQP nhưng phương pháp AS-SQP lại ổn định hơn phương pháp IP; phương pháp IP cĩ thể khơng giải được bài tốn khi tập hợp nghiệm khả thi là trống;
Phương pháp IP-SQP thích hợp với bài tốn cĩ số lượng biến lớn và bài tốn chứa nhiều ràng buộc bất phương trình tích cực.
Từ những phân tích trên, phương án giải được lựa chọn là phương án IP-SQP. Vấn đề cịn lại là lựa chọn phần mềm thực thi bài tốn. Trên thực tế theo [13] tồn tại khá nhiều phần mềm sử dụng phương pháp giải IP như: LOQO, IPOPT, KNITRO, BARNLP và MOSEK (cho bài tốn tối ưu lồi). Phần dưới đây trình bày một số đặc điểm của hai phần mềm phổ biến IPOPT và KNITRO.
Phần mềm IPOPT:
IPOPT [6] là một phần mềm dạng mã nguồn mở (open source) được viết bằng các ngơn ngữ Fortran, C và C++, sử dụng cho bài tốn tối ưu phi tuyến cỡ lớn. Nĩ sử dụng phương pháp IP đối ngẫu. Hướng tìm nghiệm dk được tính tốn trong khơng gian đầy đủ bằng cách giải hệ tuyến tính cỡ lớn (1.18). Nghiệm tối ưu tồn cục được đảm bảo bằng phương pháp tìm kiếm đường thẳng cĩ lọc (filter line search method).
IPOPT cĩ một số đặc điểm cần lưu ý sau:
Khác với những phần mềm khác như SNOPT và CFSQP, ta phải viết tất cả các chương trình con cung cấp hàm mục tiêu (objective function), các ràng buộc (constraints), các Gradient của hàm mục tiêu đối với các biến và Jacobians của các ràng buộc đối với các biến; cịn thơng tin về Hessian cĩ thể được chương trình tự tính gần đúng bằng phương pháp L-BFGS.
IPOPT khơng phân biệt các ràng buộc tuyến tính hay phi tuyến.
IPOPT cĩ thể được nhúng trong các mơi trường tính tốn khác như GAMS, MATLAB, AMPL và AIMMS.
Phần mềm KNITRO:
KNITRO [15] là một phần mềm được viết bằng Fortran77 dùng để giải các bài tốn tối ưu cỡ lớn. Nĩ kết hợp cả hai phương pháp tính IP và AS-SQP nhằm cung cấp những lựa chọn phong phú khi giải bài tốn tối ưu. Với đặc điểm này, KNITRO
Lựa chọn phương pháp giải và các cơng cụ 45 cĩ thể tự động thay đổi phương pháp tính nhằm tìm ra một kết quả tốt nhất cho bài tốn tối ưu.
KNITRO cĩ một số đặc điểm cần lưu ý sau:
Sử dụng cả hai phương pháp IP và AS-SQP;
Rất hiệu quả và ổn định với các bài tốn cỡ nhỏ cũng như cỡ lớn;
Cĩ thể lựa chọn khơng cần cung cấp đạo hàm, hoặc cung cấp đạo hàm bậc một và cấp hai;
Cĩ thể sử dụng nhiều giá trị khởi tạo khác nhau nhằm tìm ra nghiệm tối ưu nhất;
Cĩ thể viết mã nguồn trong C/C++, Fortran, Java và cả Microsoft Excel;
Được nhúng trong các mơi trường tính tốn khác như AMPL, GAMS, MATLAB, Mathematica.
KNITRO là một phần mềm thương mại, nhưng nĩ cũng được cung cấp dưới dạng phiên bản dùng thử với giới hạn về thời gian và kích thước bài tốn cĩ ít hơn 600 biến và 600 ràng buộc.
Qua những phân tích trên, trong luận văn này, tác giả lựa chọn phần mềm IPOPT do những ưu thế của nĩ, đặc biệt là phần mềm mã nguồn mở, cho những ví dụ minh họa trong phần tiếp theo.
2.3.2 Phần mềm IPOPT (Interior Point OPTimizer)
IPOPT (Interior Point OPTimizer- đọc là I-P-Opt) là một phần mềm mã nguồn mở sử dụng phương pháp tối ưu điểm trong IP, được phát triển bởi nhĩm nghiên cứu dưới sự chỉ đạo của Giáo sư Lorenz Biegler tại Đại học Carnegie Mellon (CMU), Hoa Kỳ. Nĩ được dùng để giải bài tốn tối ưu tổng
quát cĩ dạng sau: min ( ) (2.7a) sao cho ( ) (2.7b) , (2.7c) n x R L U L U f x g g x g x x x trong đĩ: n
xR là các biến tối ưu của bài tốn, mà cĩ thể cĩ các giới hạn dưới ( { })
L n
Lựa chọn phương pháp giải và các cơng cụ 46 tiêu, và g R: n Rmlà các ràng buộc phi tuyến tổng quát. Các hàm f(x) và g(x)
cĩ thể là hàm tuyến tính hay phi tuyến, nhưng nên cĩ đạo hàm đến cấp 2. Các ràng buộc g(x) cĩ thể cĩ các giới hạn dưới gL(R { })m và các giới hạn trên gU(R { })m. Nếu gi(x) là các ràng buộc phương trình ( )g xi gi thì ta đặt L U
i i i
g g g .
IPOPT được trình bày dưới dạng mã nguồn mở viết bằng C/C++ nằm trong sự án COIN-OR tại địa chỉ Internet https://projects.coin-or.org/Ipopt. IPOPT cĩ thể
được biên dịch trên các mơi trường hệ điều hành LINUX, UNIX hoặc WINDOWS. Trong luận văn này, tác giả sử dụng IPOPT chạy trên WINDOWS với trình dịch VISUAL STUDIO của Microsoft.
Về mặt cấu trúc, IPOPT được chia thành các chương trình con nằm trong một Solution lớn mang tên IPOPT, trong đĩ là các Project nhỏ hơn. Người sử dụng giao tiếp với IPOPT thơng qua 09 chương trình con được mơ tả trong phần tiếp theo.
2.3.2.1 Method get_nlp_info:
cĩ dạng thức như sau:
virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
Index& nnz_h_lag, IndexStyleEnum& index_style) Hàm cung cấp cho IPOPT những thơng tin về kích thước bài tốn:
n: (ra), số lượng biến x của bài tốn tối ưu.
m: (ra), số lượng hàm ràng buộc g(x).
nnz_jac_g: (ra), số phần tử khác 0 của Jacobian.
nnz_h_lag: (ra), số phần tử khác 0 của Hessian.
index_style: (ra), kiểu đánh chỉ số cho hàng và cột của ma trận (C
STYLE: bắt đầu từ 0, FORTRAN STYLE: bắt đầu từ 1). //*********************************************
bool HS071_NLP::get_nlp_info( Index& n, Index& m, Index& nnz_jac_g,
Index& nnz_h_lag, IndexStyleEnum& index_style) { // số lượng các biến, x[0],…, x[n-1] n = ...; // số lượng các ràng buộc m = ...; nnz_jac_g = ...;
// chỉ dùng phần thấp bên dưới trái (ma trận đối xứng) nnz_h_lag = ...;
Lựa chọn phương pháp giải và các cơng cụ 47 // sử dụng kiểu phần tử ma trận trong C (0-based)
index_style = TNLP::C_STYLE; return true; } // ***************************************************** 2.3.2.2 Method get_bounds_info: cĩ dạng thức như sau:
virtual bool get_bounds_info( Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u)
Hàm cung cấp cho IPOPT những thơng tin về giá trị các giới hạn của các biến và các ràng buộc của bài tốn:
n: (vào), số lượng biến x của bài tốn tối ưu.
x_l: (ra) giá trị giới hạn dưới xL của biến x. x_u: (ra) giá trị giới hạn trên xU của biến x. m: (vào), số lượng hàm ràng buộc g(x).
g_l: (ra) giá trị giới hạn dưới gL của g(x). g_u: (ra) giá trị giới hạn trên gU của g(x).
// ***************************************************** bool HS071_NLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u)
{
assert(n == ...); assert(m == ...);
// Giá trị giới hạn dưới của các biến for (Index i=0; i<n; i++) {
x_l[i] = ...; }
// Giá trị giới hạn trên của các biến for (Index i=0; i<n; i++) {
x_u[i] = ...; }
// Giá trị giới hạn dưới của các ràng buộc g_l[i] = ...;
// nếu các ràng buộc khơng cĩ giới hạn trên thì đặt bằng 2e19.
g_u[...] = 2e19;
// nếu các ràng buộc là phuowng trình thì đặt giới hạn dưới bằng giới // hạn trên.
Lựa chọn phương pháp giải và các cơng cụ 48 return true; } // ***************************************************** 2.3.2.3 Method get_starting_point: cĩ dạng thức:
virtual bool get_starting_point(Index n, bool init_x, Number* x,
bool init_z, Number* z_L, Number* z_U, Index m, bool init_lambda, Number* lambda) Hàm trả về các giá trị khởi tạo của bài tốn trước khi lặp.
n: (vào), số lượng biến của bài tốn x.
init_x: (vào), đặt là true thì hàm phải đặt giá trị khởi tạo cho x. x: (ra), giá trị khởi tạo của biến x.
init_z: (vào), đặt là true thì hàm phải đặt giá trị khởi tạo cho các nhân
tử ràng buộc zL
và zU.
z_L: (ra), giá trị khởi tạo của biến zL. z_U: (ra), giá trị khởi tạo của biến zU. m: (in), số lượng các ràng buộc g(x).
init_lambda: (vào), đặt là true thì hàm phải đặt giá trị khởi tạo cho các
nhân tử ràng buộc .
lambda: (ra), giá trị khởi tạo của biến .
// ***************************************************** bool HS071_NLP::get_starting_point( Index n, bool init_x, Number* x,
bool init_z, Number* z_L, Number* z_U, Index m, bool init_lambda,
Number* lambda) {
// Here, we assume we only have starting values for x, if you code // your own NLP, you can provide starting values for the dual variables // if you wish to use a warmstart option
assert(init_x == true); assert(init_z == false); assert(init_lambda == false);
// initialize to the given starting point x[0] = ...;
x[1] = ...;
Lựa chọn phương pháp giải và các cơng cụ 49 x[n-1] = ...; return true; } // ***************************************************** 2.3.2.4 Method eval_f: cĩ dạng thức:
virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value) Hàm trả về giá trị hàm mục tiêu tại x.
n: (vào), số lượng biến x.
x: (vào), giá trị của biến x dùng để tính f(x).
new x: (vào), là false nếu x đã được dùng để tính trước đĩ, true trong
trường hợp ngược lại.
obj value: (ra) giá trị hàm mục tiêu f(x).
// ***************************************************** bool HS071_NLP::eval_f(Index n, const Number* x, bool new_x, Number&
obj_value) { assert(n == ...); obj_value = ...; return true; } // ***************************************************** 2.3.2.5 Method eval_grad_f: cĩ dạng thức:
virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f)
Hàm trả về gradient của hàm muc tiêu tại x. n: (vào), số lượng biến x.
x: (vào), giá trị x dùng để tính f x( ).
new_x: (vào), là false nếu x đã được dùng để tính trước đĩ, true trong
Lựa chọn phương pháp giải và các cơng cụ 50 grad_f: (ra), giá trị của mảng f x( ).
// *****************************************************
bool HS071_NLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f) { assert(n == ...); grad_f[0] = ...; grad_f[1] = ...; ...................... grad_f[n-2] = ...; grad_f[n-1] = ...; return true; } // ***************************************************** 2.3.2.6 Method eval_g: cĩ dạng thức:
virtual bool eval_g(Index n, const Number* x,
bool new_x, Index m, Number* g) Hàm trả về giá trị của các ràng buộc tại x.
n: (vào), số lượng biến x.
x: (vào), giá trị x dùng để tính các ràng buộc g(x).
new_x: (vào), là false nếu x đã được dùng để tính trước đĩ, true trong
trường hợp ngược lại.
m: (vào), số lượng các ràng buộc g(x).
g: (ra) giá trị các ràng buộc g(x).
// ***************************************************** bool HS071_NLP::eval_g(Index n, const Number* x, bool new_x, Index m,
Number* g) { assert(n == ...); assert(m == ...); g[...] = ...; ... ... ... ... ... ... ... ... ... ... g[...] = ...; return true;
Lựa chọn phương pháp giải và các cơng cụ 51 }
// *****************************************************
2.3.2.7 Method eval_jac_g:
cĩ dạng thức:
virtual bool eval_jac_g(Index n, const Number* x, bool new_x, Index m, Index nele_jac, Index* iRow, Index *jCol, Number* values)
Hàm trả về cấu trúc của Jacobian của các ràng buộc, hoặc trả về giá trị các phần tử của Jacobian của các ràng buộc tại x.
n: (vào), số lượng biến x.
x: (vào), giá trị biến x dùng để tính Jacobian g x( )T.
new_x: (vào), là false nếu x đã được dùng để tính trước đĩ, true trong
trường hợp ngược lại.
m: (vào), số lượng các ràng buộc g(x).
n_ele_jac: (vào), số lượng phần tử khác 0 trong Jacobian (kích thước
của iRow, jCol, và values).
iRow: (ra), giá trị chỉ số hàng của Jacobian của ràng buộc.
jCol: (ra), giá trị chỉ số cột của Jacobian của ràng buộc.
values: (ra), giá trị của các phần tử trong Jacobian của các ràng buộc.
// ***************************************************** bool HS071_NLP::eval_jac_g(Index n, const Number* x, bool new_x,
Index m, Index nele_jac, Index* iRow, Index *jCol, Number* values)
{
if (values == NULL) {
// trả về cấu trúc của Jacobian iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; iRow[...] = ...; jCol[...] = ...; } else {
Lựa chọn phương pháp giải và các cơng cụ 52 // trả về giá trị của Jacobian của các ràng buộc
values[0] = ...; // 0,0 .................................. values[...] = ...; // 0,1 values[...] = ...; // 0,2 values[...] = ...; // 0,3 } return true; } // ***************************************************** 2.3.2.8 Method eval_h: cĩ dạng thức:
virtual bool eval_h( Index n, const Number* x, bool new_x,
Number obj_factor, Index m, const Number* lambda, bool new_lambda, Index nele_hess, Index* iRow, Index* jCol, Number* values)
Hàm trả về cấu trúc của Hessian của hàm Lagrange, hoặc trả về giá của Hessian của hàm Lagrange với các giá trị đã cho của x, f , và .
n: (vào), số lượng các biến của bài tốn x.
x: (vào), giá trị của biến x, dùng để tính giá trị của Hessian.
new_x: (vào), là false nếu x đã được dùng để tính trước đĩ, true trong
trường hợp ngược lại.
obj_factor: (vào), hệ số nhân đứng trước phần hàm mục tiêu trong