LEZIONE ICO 12-10-2009
Argomento: introduzione alla piattaforma Matlab. Risoluzione numerica di problemi di minimo liberi e vincolati.
Lucia Marucci
[email protected]
http://www.mathworks.com/access/helpdesk/help/toolbo
x/optim/optim.shtml
Definizione funzione obiettivo in Matlab
Definizione della funzione obiettivo :
creazione di una MATLAB function:
• Input
• Output
• Modi di scrivere la funzione obiettivo:
1. Creare una funzione anonima nella riga di comando
2. Scrivere un M-file
3. Utilizzo del comando “Inline”
1.Creare una funzione anonima
nella riga di comando
esempio
>>f = @(x) 2*x^2-3*x+4;
>>f(3)
ans = 13
>>f = @(x,y) 2*x*y;
>>f(2,2)
ans = 8
Si utilizza quando la f è semplice o
quando non si userà in una
successiva sessione di MATLAB
2.
Usando il comando inline
• Utilizzando il comando inline:
– Crea una funzione nella linea di comando:
Sintassi: f = inline(‘expr’,’n’) con
>f = inline('2*x^2-3*x+4','x');
>>f(3)
ans = 13
>> f = inline('2*x*y', 'x', 'y');
>> f(2,2)
ans = 8
3.
Scrivere un M-file
Bisogna aprire un file di Matlab editor
function [out1, out2, ...] = funname(in1,in2, ...)
esempio: nell’editor square.m
function f = square(x)
f = x.^2;
Nella command window si richiama la funzione
@ square per creare una funzione handle per
square. Si può usare questo metodo quando la f(x)
è complicata o se si intende riutilizzare la funzione.
NOTA BENE attenzione ai path!
MINIMIZZAZIONE NON VINCOLATA:
fminunc
• Scopo: trovare il minimo di una funzione
multivariabile non vincolata:
– x è un vettore ed f(x) è una funzione che ritorna uno
scalare
• Sintassi:
[x,fval,exitflag,output,grad,hessian] =
fminunc(fun,x0,options)
INPUT
• x0 è punto iniziale di ricerca, scalare, vettore o matrice
• fun è la funzione obiettivo
• options: crea attraverso il comando optmiset parametri di
ottimizzazione (numero di iterazioni, tolleranza
dell’algoritmo,ecc..)
OUTPUT
• fval valore della funzione obiettivo nel punto di minimo
• Exitflag: descrive le condizioni di uscita
• Output: genera una struttura di uscita che riporta informazioni
circa l’operazione di ottimizzazione
• grad: ritorna il valore del gradiente di fun alla soluzione x
• hessian: ritorna il valore dell’hessiano di fun alla soluzione x
Input
>>x = fminunc (myfun,x0)
x0=scelta iniziale;
myfun è una Matlab function, ovvero:
x = fminunc(@myfun,x0)
function f = myfun(x)
f = ...
Input
>>x = fminunc (myfun,x0,options)
Options:
Sintassi:
options=optimset('param1',value1,'param2',value2,...)
Algoritmi utilizzati da fminunc
• Per default fminunc utilizza algoritmi :
– Quasi Newton method con BFGS, steepest
discendent
medium scale: se poniamo nell’opzione LargeScale ‘off’ nel
comando optimset
– Trust region method, Newton method e gradiente
coniugato
large scale: se l’opzione GradObj è ‘on’ nel comando
optimset
Output
• x: valore ottimo (soluzione del problema)
• fval: valore della funzione nel punto ottimo
• exitflag: descrive le condizioni di uscita:
» se>0 la funzione converge ad una soluzione x
» se=0 l’algoritmo non è in grado di ottenere una
soluzione nel numero di iterazioni stabilite
» se <0 la funzione non converge alla soluzione x
• output: informazioni circa il processo di ottimizzazione
»
»
»
»
»
Iterations: numero di iterazione dell’algoritmo
funcCount : numero di valutazioni della funzione
Algorithm: algoritmo usato
Step-size
Firstorderopt: norma del gradiente nella soluzione
Esempio 1: Unconstrained Minimization
• Problema di minimizzazione della
funzione:
• Passi da effettuare:
– Generare un M-file che ritorni il valore della
funzione
– Invocare la routine di risoluzione fminunc
Step 1: scrittura dell’M-file myfun.m
Step 2: nella command window chiamo
fminunc
>>x0=[1 1];
>>[x,fval] = fminunc(@myfun,x0)
Quasi_Newton
• Minimizziamo con un altro algoritmo:
•
Modifichiamo l’M-file:myfun.m fornendo gradiente
• Creazione di una struttura options
trust-region Newton
Limiti dell’ fminunc
• La funzione da minimizzare deve essere
continua
• Potrebbe determinare soluzioni locali
• Ottimizzazione di funzioni di variabili reali: x
deve essere una variabile reale
MINIMIZZAZIONE NON VINCOLATA
fminsearch
• Trova il minimo di una funzione obiettivo multivariabile in
assenza di vincoli SENZA CALCOLARE GRADIENTE
ALGORITMO: Nelder-Mead simplex direct search
• Sintassi:
– x= fminsearch (fun,x0), partendo da un punto di
ricerca iniziale tenta di trovare il minimo di fun
– fun è una funzione descritta nella linea di
comando, dal comando inline o da un M.file
– x= fminsearch (fun,x0,options), tenta la
minimizzazione usando il parametro options.
Usare optimset per stabilire le opzioni
dell’algoritmo
• [x,fval]=fminsearch(…) , riporta in fval il valore il
valore della funzione obiettivo fun nel valore x
• [x,fval,exitflag]=fminsearch(…), riporta un valore
exitflag che descrive le condizioni di uscita di
fminsearch
• [x,fval,exitflag,output]=fminsearch(…), riporta in
output le informazioni inerenti il processo di
ottimizzazione.
• [x,fval,exitflag,output]=fminsearch(…P1,P2…),
dove P1… Pn sono parametri della funzione
obiettivo
Input arguments
• fun: funzione da minimizzare
– fun può essere:
• M.file:
con myfun Matlab function
• Funzione anonima nella linea di comando
• Options: valgono le stesse considerazioni
per fminunc….. ma i più usati sono:
Options
Output Arguments
Esempio 1
Minimizzazione della funzione di Rosenbrock:
x0=[-1.2, 1]
Presenta minimo (1,1) ed fval=0
-Scriviamo l’M.file:
function f= myfun(x)
f= 100*(x(2)-x(1)^2)^2+(1-x(1))^2;
-Passiamo dall’M.file alla routine di ottimizzazione:
[x,fval] = fminsearch (f , [-1.2, 1] )
OPPURE
La definiamo nella command window
Esempio 2
• Se la funzione obiettivo è parametrica:
>>f= inline('100*(x(2)-x(1)^2)^2+(a-x(1))^2','x','a')
>>a=2;
>>options= optimset ('Display','iter','TolX',1e-8);
>>[x,fval]= fminsearch (f,[1 2],options,a)
Vantaggi e limiti
• Vantaggi:
– se f(x) è discontinua, fminsearch è un
comando robusto
• Svantaggi:
– è in genere meno efficiente di fminunc per
problemi di ottimizzazione di ordine maggiore
di 2
– Ottimizzazione di funzioni di variabili reali: x
deve essere una variabile reale
MINIMIZZAZIONE VINCOLATA
fmincon
dove x; b; beq; lb; ub sono vettori, A; Aeq sono matrici; c(x) e
ceq(x) sono funzioni vettoriali (cioe’ ad ogni vettore x associano un
vettore) e f e’ una funzione scalare (cioe’ ad ogni vettore x associa
un numero reale). Le funzioni f(x), c(x) e ceq(x) possono essere
non lineari.
min F(x) vincoli: A*x <= b, Aeq*x= beq
C(x) <= 0, Ceq(x) = 0
LB <= x<= UB
sintassi input
x=fmincon(fun,x0,A,b)
partendo da x0 cerca il minimo x della funzione fun
sotto i vincoli lineari A*x <= b .
x0 può essere uno scalare, un vettore o una matrice.
x=fmincon(fun,x0,A,b,Aeq,beq)
vincoli lineari Aeq*x = beq e anche A*x <= b.
(A=[ ] and B=[ ] se non ci sono disuguaglianze)
min F(x) vincoli: A*x <= b, Aeq*x= beq
C(x) <= 0, Ceq(x) = 0
LB <= x<= UB
x=fmincon(fun,x0,A,b,Aeq,beq,LB,UB)
Definisce un set di lower e upper per la variabile x,
di modo che la soluzione sia trovata nel range
LB <= x <= UB.
Porre LB(i) = -Inf se x(i) é illimitata inferiormente;
porre UB(i) = Inf se x(i) é illimitata superiormente.
x = fmincon(fun,x0,A,b,Aeq,beq,LB,Ub,nonlcon,options)
se ci sono anche dei vincoli non lineari definiti in
nonlcon e delle opzioni specificate con optimset.
sintassi output
[x,fval] = fmincon(...) ritorna il valore della funzione
Obiettivo raggiunto
[x,fval,exitflag] = fmincon(...)
[x,fval,exitflag,output] = fmincon(...)
[x,fval,exitflag,output,lambda] = fmincon(...)
Ritorna una struttura lambda i cui campi contengono
I moltiplicatori di Lagrange alla soluzione x
[x,fval,exitflag,output,lambda,grad,hessian]
=fmincon(...)
ALGORITMI
-active-set (DEFAULT)
-interior-point
-trust-region-reflective SE SPECIFICATO
MA BISOGNA DARE IL JACOBIANO
Esempio 1
Minimizzare f(x)=-x1x2x3
x0 = [10; 10; 10]
Vincolo: 0 ≤ x1 + 2 x 2 + 2 x 3 ≤ 72
1. Scrivo m file myfun_vin.m
function f = myfun_vin(x)
f = -x(1) * x(2) * x(3);
2. Riscrivo il vincolo riportandolo a due
minorazioni
0 ≤ x1 + 2x2 + 2x3 ≤ 72
− x1 − 2x2 − 2x3 ≤ 0
x1 + 2x2 + 2x3 ≤ 72
In questo modo posso formulare i due vincoli,
entrambi lineari, come
A*X <= b
A=[-1 -2 -2; 1 2 2];
b=[0;72];
min F(x) vincoli: A*x <= b, Aeq*x= beq
C(x) <= 0, Ceq(x) = 0
LB <= x<= UB
3 . Chiamo routine fmincon dalla command window
>> A=[-1 -2 -2;1 2 2];
>> b=[0;72];
>> x0 = [10; 10; 10]; % Starting guess at the solution
>> [x,fval] = fmincon(@myfun_vin,x0,A,b)
Esempio 2
C=10; V=6; X0=[1 1 1];
Mfile nlcon.m per il vincolo non lineare
function [C,Ceq]=nlcon(x)
C=[ ];
Ceq=[x(1)*x(2)*x(3)-6];
min F(x) vincoli: A*x <= b, Aeq*x= beq
C(x) <= 0, Ceq(x) = 0
LB <= x<= UB
>>[x,fval,exitflag,output,lambda,grad,hessian]=
fmincon(inline('2*10*(x(1)*x(2)+x(1)*x(3)+x(2)*x(3))‘,’x’),[
1;1;1],[ ],[ ],[ ],[ ],[-Inf;-Inf;-Inf],[Inf;Inf;Inf],@nlcon)
Esempio 3
M-files:
Command
window
Risoluzione di sistemi di equazioni
• fsolve e fzero:
fsolve : risoluzione di sistemi non lineari di
equazioni:
con x vettore e F(X) che
ritorna un valore vettoriale (determinazione delle
radici (zero) di un sistema non lineare di
equazioni)
Sintassi
Input Argument
• fun: sistema di equazioni non lineari da risolvere:
accetta un vettore x e ritorna un vettore F, equazioni
non lineari valutate in x. fun può essere richiamata
da :
• M.file:
• funzione anonima:
• Jacobiano:
– in tal modo la funzione fun richiama in un secondo output il valore
della matrice J in x.
Output Arguments
• exitflag:
Caratteristiche
dell’algoritmo
utilizzato
• Output:
Informazioni circa
il processo di
ottimizzazione
Algoritmo
• Per default viene utilizzato Trust-region dogleg.
• Alternativamente, si puo’ scegliere Levenberg-Marquardt
oppure Gauss-Newton.
Esempio 1
• Sistema di equazioni in 2 incognite:
x0=[-5,-5]
• Risolviamo in x:
– Scriviamo un M.file:
– Routine di ottimizzazione:
Esempio 2
• Trovare una matrice X tale che:
con x0=[1,1;1,1] (matrice)
• Scrittura dell’M.file:
• Invochiamo la routine di ottimizzazione:
x=
exitflag=1
fval=
Limiti
• Le funzioni del sistema devono essere
continue
• Le variabili devono essere reali
• Fsolve potrebbe convergere ad un punto
che non e’ uno stazionario; in tal caso
converrebbe variare le condizioni iniziali.
fzero
• Soluzioni di una funzione continua di una
variabile
• Sintassi:
• Descrizione:
– x=fzero(fun,xo), determina lo zero di fun vicino ad xo,
se xo è uno scalare. fun è una funzione descritta da
M.file o da una funzione anonima. Il valore x
determinato da fzero è vicino al punto per cui la
funzione fun cambia segno, o NaN se la ricerca non
ammette risultato.
Input arguments
• fun: funzione da risolvere
– M.file richiamata nella routine dal comando @
con
– Attraverso una funzione anonima:
– Options: cambiando i valori attraverso il
comando optimiset…. Ovvero:
Options
Output arguments
Esempi
• Calcolare il valore di π determinando lo zero
della funzione seno vicino al punto 3
• Trovare lo zero della funzione coseno
nell’intervallo [1 2]
Trovare lo zero della funzione:
• Scriviamo un M.file:
• Per calcolare lo zero vicino a 2 :
• Dal momento che questa è una funzione
polinomiale, è possibile usare il comando roots ([1 0
-2 5]), che determina lo stesso zero reale e coppie di
zero coniugate
Limiti
• Il comando è in grado di trovare un punto dove la
funzione cambia segno.
• Se la funzione è continua, tale punto è anche un punto
per cui la funzione si avvicina al suo zero
• Se la funzione non è continua, il comando trova punti di
discontinuità invece cha la soluzione.
• Inoltre, la funzione determina lo zero come punto di
intersezione di fun con l’asse x. Punti per cui la funzione
tocca l’asse, ma non lo intercetta non sono considerati
zero. Esempio la funzione x^2 è una parabola che tocca
l’asse x nello zero. Non attraversando l’asse x, il punto
non viene visto come soluzione.
