Progetto e ottimizzazione di reti 2

Transcript

1 Progetto e ottimizzazione di reti 2 Esercitazione AMPL A.A Esercitazione a cura di Silvia Canale contatto canale@dis.uniroma1.it Università i di Roma La Sapienza Dipartimento di Informatica e Sistemistica Corso di Laurea in Ingegneria Gestionale 1

2 Riassumendo AMPL è un linguaggio di modellazione algebrico che ci permette di modellare problemi di programmazione matematica di diversa natura. Abbiamo visto come dichiarare (file.mod) e definire i (file.dat) le entità: - Insiemi (parola chiave set); - Parametri semplici o a più dimensioni (parola chiave param); - Variabili (parola chiave var); - Funzione obiettivo (parola chiave minimize o maximize); - Vincoli (parola chiave subject to). Abbiamo visto come far interpretare i file.mod e.dat all interprete AMPL. Abbiamo visto come far risolvere il problema modellato all interprete AMPL invocando un opportuno solutore di programmazione matematica (CPLEX). Abbiamo visto altre funzionalità del linguaggio AMPL e come scrivere script in AMPL per risolvere in maniera efficiente problemi di programmazione matematica. 2

3 Check parametri AMPL permette di dichiarare delle restrizioni sui parametri. Il modo è lo stesso visto per le restrizioni sulle variabili. Esempio: Se nel problema MCF vogliamo dichiarare i vettori costo e capacita dip parametri metinonneg negativi iet tali che heil costo todi ciascun arco sia non superiore alla metà della sua capacità, si dichiara nel file MCF_chk.mod: param capacita {ARCHI} >= 0; param costo {j in ARCHI} >= 0, <= 0.5 * capacita[j]; Successivamente definiamo i parametri nel file MCF_chk_1.dat i valori dei parametri: param: capacita costo := AB 6 2 AC 4 2 BC 2 1 BE CD 8 1 DB 4 2 DE ; 3

4 Check parametri Successivamente definiamo i parametri nel file MCF_chk_2.dat i valori dei parametri: param: costo capacita := AB 6 2 AC 4 3 BC 2 1 BE 7 5 CD 8 1 DB 4 2 DE 5 4 ; Il solutore nel primo caso risolverà correttamente il problema. Nel secondo, restituirà un errore (un insieme di errori: uno per ogni vincolo violato dai valori dei parametri). 4

5 Parametri simbolici Un parametro in AMPL può assumere sia valori numerici che valori simbolici riferiti ad un insieme base. Attraverso la parola chiave symbolic possiamo dichiarare un parametro che assume valori definiti nell insieme in cui viene dichiarato simbolico Esempio: Se dichiariamo un insieme base S e vogliamo dichiarare un parametri che ampl: set S; ampl: param a symbolic in S; Una volta definito l insieme S, possiamo assegnare al parametro a un qualsiasi elemento presente nell insieme S: ampl: data; ampl data: set S := A B C; ampl data: param a := 'A'; ampl data: display S, a; set S := A B C; a = A 5

6 Parametri simbolici Un caso in cui l uso di parametri simbolici può essere utile è il caso in cui il valore di un parametro del problema non è noto prima di eseguire il blocco di istruzioni per risolvere il problema Esempio: Modello sym.mod set NODI; set ARCHI; param domanda {NODI}; param capacita {ARCHI}; param costo {ARCHI}; param M {NODI, ARCHI}; var x {j in ARCHI} >= 0; minimize Costo_Totale: sum {j in ARCHI} costo[j] * x[j]; subject to Incidenza {i in NODI}: sum {j in ARCHI} M[i,j] * x[j] = domanda[i]; subject to Capacita {j in ARCHI}: x[j] <= capacita[j]; 6

7 Parametri simbolici Esempio: Dati sym.dat data; set NODI := A B C D E ; set ARCHI := AB AC BC BE CD DB DE; param: domanda := A -1 B 0 C 0 D 0 E 0 ; param: capacita costo := AB 4 1 AC 2 1 BC 3 1 BE 7 1 CD 4 1 DB 5 1 DE 1 1 ; 7

8 Parametri simbolici Esempio: Dati sym.dat (segue) param M : AB AC BC BE CD DB DE := A B C D E ; 8

9 Parametri simbolici Esempio: Script sym.run model sym.mod; data sym.dat; param p symbolic in NODI; printf "\nqual e' il nodo destinazione?\n"; read p < - ; let domanda[p] := - domanda['a']; display p; display domanda; option solver cplex; solve; display Costo_Totale; display x; reset; 9

10 Più funzioni obiettivo AMPL permette di dichiarare (e definire) più di una funzione obiettivo e di scegliere di volta in volta la funzione rispetto alla quale ottimizzare un problema. Esempio: Se nel modello MCF.mod vogliamo dichiarare oltre alla funzione obiettivo Costo_Totale una funzione obiettivo che restituisca il numero di unità di bene che transitano complessivamente su ciascun arco della rete, dichiariamo un la funzione obiettivo Utilizzo_Totale nel file MCF_fo.mod minimize Utilizzo_Totale: sum {j in ARCHI} x[j]; Dopo aver letto il file MCF.dat, le due funzioni obiettivo sono completamente specificate. Per indicare rispetto a quale delle due funzioni obiettivo vogliamo risolvere il problema, usiamo la parola chiave solve seguita dal nome della funzione obiettivo da ottimizzare. solve Utilizzo_Totale ; solve Costo_Totale ; 10

11 Più funzioni obiettivo Esempio: Script MCF_fo.run model MCF_ fo.mod; data MCF.dat; option solver cplex; solve Costo_Totale; display Costo_Totale; solve Utilizzo_Totale; display Utilizzo_Totale; reset; 11

12 Metodo del Simplesso Dinamico Descrizione implicita di: P ={x R n : Ax<b, x > 0 n } ^ x R n Oracolo di Separazione di P ^x P ^x P a i ^ x > b i vincolo violato A x^ < b x^ a i Riga i b i x^ P 12

13 Metodo del Simplesso Dinamico Risolve un problema di Programmazione Lineare: min c T x: x P = {x R n : Ax b, 1 n x 0 n } Due ingredienti: ^ x R n min c T x Ax b, 1 n x 0 n Oracolo di Separazione di P Metodo del Simplesso ^x P ^x P ^ a i x > b i x * soluzione ottima problema illimitato nessuna soluzione (P= ) 13

14 Dfiii Definizione del dl problema core A D 0 d 0 b D=D 0 ; d=d 0 min c T x x Q= Dx<d, (P Q) 1 n > x > 0 n Nuova D e nuovo d D d a T i b i Aggiunta del vincolo violato Metodo del Simplesso x * ottima (in Q) Q= P= Oracolo di Separazione x* P di P x * P x* ottima a T i x>bi 14

15 Algoritmo di soluzione (I) Per implementare il metodo del Simplesso Dinamico in AMPL dobbiamo prevedere una struttura dati che ci consenta di definire, iterazione per iterazione, quali vincoli del sistema Ax<b si trovano nel sottoproblema corrente. Dichiariamo nel file.mod - un parametro M che indichi il numero di vincoli - un parametro z che indichi il numero di vincoli presenti nel sottoproblema corrente - un vettore di parametri I che indichi gli indici dei vincoli presenti nel sottoproblema corrente Nel file.dat definiamo i coefficienti e i termini noti di tutti i vincoli. Modificando opportunamente i parametri z e I definiamo di volta in volta il sottoproblema definendo solamente i vincoli con indici in I. 15

16 Algoritmo di soluzione (I) Per risolvere un generico problema di PL con poliedro P ={x R n : Ax<b, x> 0 n } l oracolo di separazione più semplice che possiamo immaginare è quello che verifica che la soluzione x * ottima (in Q) in input verifichi tutti i vincoli del sistema Ax<b (separazione per look-up). x* R n Realizziamo due script: Oracolo di Separazione di P verifica A x*< b x* P x* P a i x > b i - oracolo.run che trova, se esiste, un vincolo violato, aggiungendolo a I - main.run che dichiara i parametri e definisce il problema, assegna i valori iniziali ai parametri, risolve il sottoproblema corrente e invoca l oracolo. 16

17 Implementazione in AMPL # file test1.mod param N; param M; param z; param I {1..M}; param c {1..N}; param d {1..M}; param D {1..M, 1..N}; var x {j in 1..N} >= 0; minimize Funzione_Obiettivo: sum {j in 1..N} c[j] * x[j]; subject to Insieme_Vincoli {i in 1..z}: sum {j in 1..N} D[I[i],j] * x[j] >= d[i[i]]; 17

18 Implementazione in AMPL # file test1.dat data; param N := 10; param M := 100; param c := ; // segue definizione dei vettori di parametri D e d 18

19 Implementazione in AMPL # script main1.run - script per risolvere un problema # di PL con il metodo del Simplesso Dinamico model test.mod; data test.dat; param nv; let z := 10; let {i in 1..z} I[i] := i; option solver cplex; 19

20 Implementazione in AMPL repeat { solve; commands oracolo1.run; display Funzione_Obiettivo > sol.txt; display x > sol.txt; display I > sol.txt; } until nv = 0; display Funzione_Obiettivo; display x; 20

21 Implementazione in AMPL # script oracolo1.run - script per l'oracolo di # separazione per look-up let nv := 0; for {i in 1..M} { if( sum {j in 1..N} D[i,j] * x[j] >= d[i] ) then continue; else { lt let z := z +1; let I[z] := i; let nv := 1; break; } } 21

22 Esecuzione e soluzione ampl: commands main1.run; Nel file sol.txt t sono riportati ti per le diverse iterazioni: i i - il valore della soluzione -la soluzione - il vettore di indici dei vincoli nel sottoproblema corrente A monitor viene stampata la soluzione ottima: ottenuta risolvendo un problema di PL con 10 variabili e 15 vincoli (anzichè 100): Funzione_Obiettivo = 10 x [*] := ; 22

23 Implementazione in AMPL # script main1.run - script per risolvere un problema # di PL con il metodo del Simplesso Dinamico # variante con lettura del valore del parametro z da tastiera model test1.mod; data test1.dat; param nv; # se al posto di let z := 10; scriviamo: printf "\nquanti vincoli iniziali?\n"; read z <- ; #il valore del parametro z viene letto da tastiera ti let {i in 1..z} I[i] := i; option solver cplex; 23

24 Più problemi di ottimizzazione AMPL permette di risolvere più problemi di ottimizzazione dichiarati e definiti simultaneamente aventi parametri, variabili,, distinti. Esempio: Supponiamo di dichiarare il seguente prob_a.mod set A; param ca {A}; param da {A}; param DA {A, A}; var x {j in A} >= 0, <= 1; minimize Costo_A: sum {j in A} ca[j] * x[j]; subject to Vincoli_A {i in A}: sum {j in A} DA[i,j] * x[j] = da[i]; 24

25 Più problemi di ottimizzazione Esempio: Subito dopo dichiariamo un secondo problema prob_b.mod set B; param cb {B}; param db {B}; param DB {B, B}; var y {j in B} >= 10, <= 20; maximize Costo_B: sum {j in B} cb[j] * y[j]; subject to Vincoli_B {i in B}: sum {j in B} DB[i,j] * y[j] >= db[i]; 25

26 Più problemi di ottimizzazione Esempio: I due problemi non hanno dichiarazioni comuni, quindi possiamo dichiararli entrambi e decidere poi quale dei due risolvere per primo ampl: model prob_a.mod; ampl: data prob_a.dat; ampl: model prob_b.mod; ampl: data prob_ B.dat; ampl: option solver cplex; ampl: solve Costo_A; Solution determined by presolve; objective Costo_A = 8. ampl: display x; x [*] := z1 1 z2 1 ; 26

27 Più problemi di ottimizzazione Esempio (continua): ampl: solve Costo_B; CPLEX : optimal solution; objective dual simplex iterations (0 in phase I) ampl: display y; y [*] := a 20 b 20 c 20 ; 27

28 Algoritmo di soluzione (II) Riprendiamo l esempio del metodo del Simplesso Dinamico. Per la sua implementazione in AMPL dobbiamo sempre prevedere una struttura dati che ci consenta di definire, iterazione per iterazione, quali vincoli del sistema Ax<b si trovano nel sottoproblema corrente. Supponiamo di non conoscere esplicitamente it t tutti tti i vincoli del sistema Ax<b. Dichiariamo i nel file.mod - un parametro M che indichi il numero di vincoli - un parametro z che indichi il numero di vincoli presenti nel sottoproblema corrente Nel file.dat definiamo i coefficienti e i termini noti dei vincoli presenti nel sottoproblema corrente. Modificando opportunamente i parametri z e M definiamo di volta in volta il sottoproblema definendo solamente i vincoli presenti nel sottoproblema corrente. 28

29 Algoritmo di soluzione (II) Vogliamo risolvere un generico problema di PL con poliedro P ={x R n : Ax<b, x> 0 n } avendo a disposizione un oracolo di separazione che richiede di risolvere un altro problema di ottimizzazione P ={y R n : A y<b, y > 0 n } x* R n Realizziamo due script: Oracolo di Separazione di P risolve min c T y y P ={y R n : A y<b, y > 0 n } - oracolo.run che trova, se esiste, un vincolo violato, risolvendo il problema di separazione x* P x* P a i x > b i - main.run che dichiara i parametri e definisce il problema, assegna i valori iniziali ai parametri, risolve il sottoproblema corrente e invoca l oracolo. 29

30 Consideriamo il poliedro Algoritmo di soluzione (II) P ={x R n : Ax > b, x > 0 n } in cui tutti i vincoli a i x > b i sono del tipo: e T a i = 4 0 < a ij <1 i=1 1..m, j=1 1,..,n b i = 2 x* R n Oracolo di Separazione di P risolve min a T x* : a P dove P ={a R n : e T a= 4, 0 n < a < 1 n } i = 1..m x* P x* P T a i x* < bi Dato il vettore x* vogliamo determinare un vettore a tale che se esista un vettore a tale che e T a = 4 0 n < a < 1 n e che a T x* < 2 i i 30

31 Algoritmo di soluzione (II) Oracolo di x* R n Separazione di P x* P a T x* > 2 Realizziamo due script: min a T x* a T x* < 2 e T a= 4, x* P 0 n < a < 1 n - oracolo.run che trova, se esiste, un vincolo violato, risolvendo il problema di separazione: min a T x* e T a =4 4, 0 n < a < 1 n - main.run che dichiara i parametri e definisce il problema, assegna i valori iniziali ai parametri, risolve il sottoproblema corrente e invoca l oracolo. 31

32 Implementazione in AMPL # file test2.mod param N; param M; param z; param c {1..N}; param d {1..M}; param D {1..M, 1..N}; var x {j in 1..N} >= 0; minimize Funzione_Obiettivo: sum {j in 1..N} c[j] * x[j]; subject to Insieme_Vincoli {i in 1..z}: sum {j in 1..N} D[i,j] * x[j] >= d[i]; 32

33 Implementazione in AMPL # file test2.dat data; param N := 10; param M := 1000; param z := 3; param c := ; param d := ; param D : := ; 33

34 Implementazione in AMPL # file separazione.mod param X {1..N} default 0; param g default 0; param f {1..N} default 0; var a {j in 1..N} >= 0, <= 1; minimize Violazione: sum {j in 1..N} X[j] * a[j]; subject to Vincolo: sum {j in 1..N} f[j] * a[j] = g; 34

35 Implementazione in AMPL # file separazione.dat data; param f := ; param g := 4; 35

36 Implementazione in AMPL # script main2.run - script per risolvere un problema # di PL con il metodo del Simplesso Dinamico model test2.mod; data test2.dat; model separazione.mod; data separazione.dat; option solver cplex; 36

37 Implementazione in AMPL repeat { solve Funzione_ Obiettivo; display Funzione_Obiettivo > sol.txt; display x > sol.txt; commands oracolo2.run; if( Violazione < 2 ) then { display z, {j in 1..N} D[z,j], d[z]; } } until Violazione >= 2; 37

38 Implementazione in AMPL display Funzione_Obiettivo; display x; close sol.txt; reset; 38

39 Implementazione in AMPL # script oracolo2.run - script per l'oracolo di # separazione che risolve il problema di ottimizzazione separazione.mod let {j in 1..N} X[j] := x[j]; solve Violazione; if( Violazione < 2 ) then { let z := z + 1; let {j in 1..N} D[z,j] := a[j]; let d[z] := 2; } display Violazione > sol.txt; 39

40 Esecuzione e soluzione ampl: commands main2.run; Nel file sol.txt t sono riportati ti per le diverse iterazioni: i i - il valore della soluzione corrente - la soluzione corrente - il valore della violazione A monitor viene stampata la soluzione ottima: ottenuta risolvendo un problema di PL con 10 variabili e 16 vincoli: Funzione_Obiettivo = x [*] := ; 40