Ottimizzazione Combinatoria

Transcript

1 Ottimizzazione Combinatoria Esercitazione AMPL A.A Esercitazione a cura di Silvia Canale contatto canale@dis.uniroma1.it Università 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 (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). Oggi vedremo altre funzionalità del linguaggio AMPL e come scrivere script in AMPL per risolvere in maniera efficiente problemi di programmazione matematica. 2

3 Materiale Oltre alle slide di questa esercitazione, è possibile trovare ulteriore materiale alla pagina relativamente a: gestione di canali di input/output in AMPL stringhe di caratteri in AMPL istruzioni iterative e if then script in AMPL 3

4 Il comando data dice all interprete che segue la definizione delle entità precedentemente dichiarate. ampl: data MCF.dat; Modalità dati // carichiamo successivamente i dati del problema Il comando data può essere anche utilizzato per porre l interprete in modalità dati e può essere utilizzato direttamente da riga di comando. ampl: model MCF.mod; ampl: data; ampl data: set NODI := A; ampl data: display NODI; set NODI := A; ampl: Per uscire dalla modalità dati occorre digitare una parola chiave diversa da quelle che identificano i dati (set, param, etc.) 4

5 Modalità dati Quando assegniamo valori dopo il comando data, l interprete verifica che ad un entità non venga assegnato più di un valore. ampl: model MCF.mod; ampl: data; ampl data: set NODI := A; ampl data: display NODI; set NODI := A; ampl: data; ampl data: set NODI := B; data for NODI already read context: set >>> NODI <<< := B; 5

6 Per aggiornare il valore assegnato ad un entità abbiamo due modi: 1) Con l istruzione reset reset data; // cancella tutte le assegnazioni reset data <lista_entità>; // cancella le assegnazioni delle entità nella lista <lista_entità> ampl: model MCF.mod; ampl: data; ampl data: set NODI := A; ampl data: display NODI; set NODI := A; Modalità dati ampl: reset data NODI; ampl: display NODI; Error executing "display" command: no data for set NODI ampl: data; ampl data: set NODI := B; ampl data: display NODI; set NODI := B; 6

7 2) Con l istruzione update update data; // aggiorna tutte le assegnazioni update data <lista_entità>; // aggiorna le assegnazioni delle entitànella lista <lista_entità> ampl: model MCF.mod; ampl: data; ampl data: set NODI := A; ampl data: display NODI; set NODI := A; ampl: update data NODI; ampl: display NODI; set NODI := A; Modalità dati ampl: data; ampl data: set NODI := B; ampl data: display NODI; set NODI := B; 7

8 Insiemi a più dimensioni Come per i parametri, anche gli insiemi (parola chiave set) possono essere a più dimensioni. In AMPL il comando dimen nella dichiarazione di un insieme specifica la dimensione dell insieme. ampl: set COPPIE dimen 2; ampl: data; ampl data: set COPPIE := (A,B) (A,C) (B,C); ampl data: display COPPIE; set COPPIE := (A,B) (A,C) (B,C); Oltre a definire insiemi e operazioni tra insiemi, il comando setof permette di creare insiemi proiezione di insiemi precedentemente dichiarati. ampl: set PROIEZIONE := setof { (i,j) in COPPIE } i; ampl: display PROIEZIONE; set PROIEZIONE := A B; 8

9 Restrizioni sulle variabili Le variabili sono le grandezze che descrivono la soluzione del problema. Le variabili vengono dichiarate nel file del.mod. L identificativo della variabile viene preceduto dalla parola chiave var e, eventualmente, viene seguito da restrizioni al suo valore. In AMPL le restrizioni sulle variabili possono essere descritte da espressioni logiche oppure dalle parole chiave integer e binary per indicare che la variabile è di tipo intero oppure binario. ampl: var x >= 0; ampl: var y binary; ampl: var z integer; 9

10 Gestione I/O Per leggere i singoli valori di una o più entità (parametri, insiemi, etc.) è disponibile l istruzione read seguita dalla lista delle entità cui assegnare un valore nell ordine in cui i valori sono forniti e la sorgente dei dati se diversa dal canale standard di input. read <lista_entità> < <reindirizzamento>; // i valori delle entità vengono letti nell ordine in cui compaiono in // <lista_entità> dalla sorgente <reindirizzamento>; // se manca la sorgente, l interprete attende i valori da assegnare // attraverso il canale standard di input In <lista_entità> le entità della lista sono separate da virgole,. Possiamo avere anche entità a più dimensioni (ad esempio parametri a una dimensione); in questo caso l entità è preceduta dall insieme degli indici tra parentesi graffe ({}). 10

11 Gestione I/O ampl: param n; ampl: param m; ampl: param c {1..n}; ampl: read n, m, {i in 1..n} c[i]; ampl? 3 ampl? 2 ampl? 1 ampl? 2 ampl? 3 ampl: display m, n, {i in 1..n} c[i]; m = 2 n = 3 L espressione 1..n, dove n è un parametro precedentemente dichiarato, indica l intervallo di valori da 1 a n. c[i] [*] := ; 11

12 Gestione I/O ampl: param M; ampl: param N; ampl: param costi {1..N,1..N}; ampl: param i; ampl: param j; ampl: read N, M, {1..M} (i,j,costi[i,j]) < dati_grafo.txt; ampl: display N, M, costi; N = 4 M = 5 50 costi := ;

13 Gestione I/O Per leggere uno o più valori dal canale standard di input (shell dell interprete AMPL) in maniera interattiva, indichiamo il trattino nel comando read : read <lista_entità> < ; // i valori delle entità vengono letti in maniera interattiva Per scrivere uno o più valori dal canale standard di output (shell dell interprete AMPL), possiamo utilizzare sia il comando display che il comando print ampl: param n; ampl: read n; ampl? 3 ampl: display n; n = 3 ampl: print n; 3 Il comando print stampa il dato non formattato, contrariamente al comando display Il comando printf stampa il dato secondo la formattazione specificata dalla stringa che segue il comando 13

14 Stringhe in AMPL In AMPL i membri di un insieme, i valori dei parametri e i nomi dei file sono trattati come stringhe di caratteri. 14

15 Stringhe in AMPL Concatenazione ampl: model MCF.mod; ampl: data MCF.dat; ampl: display NODI; set NODI := A B C D E; ampl: set ARCHI_COMPLETO := setof {i in NODI, j in NODI} i & j; ampl: display ARCHI_COMPLETO; set ARCHI_COMPLETO := AA AC AE BB BD CA CC CE DB DD EA EC EE AB AD BA BC BE CB CD DA DC DE EB ED; ampl: set NO_LOOP := setof {i in NODI, j in NODI : i!= j } i & "_" & j ; ampl: display NO_LOOP; set NO_LOOP := A_B A_D B_A B_D C_A C_D D_A D_C E_A E_C A_C A_E B_C B_E C_B C_E D_B D_E E_B E_D; 15

16 Operazioni su stringhe in AMPL In AMPL le stringhe di caratteri possono apparire tra parentesi tonde ( ) in diversi contesti: - nomi di file che sono parte di comandi AMPL come i comandi model, data e commands # supponiamo di avere due diversi file.dat # MCF_1.dat e MCF_2.dat # e di voler modellare e risolvere il primo dei due ampl: model MCF.mod; ampl: param i := 1; ampl: data ("MCF_" & i & ".dat"); ampl: display NODI; set NODI := A B C D E; 16

17 Operazioni su stringhe in AMPL - nomi di file che seguono i simboli: - < (in lettura) - > (in scrittura: apre il file con il nome indicato, se non esiste lo crea e se esiste lo sovrascrive) - >> (in scrittura: apre il file con il nome indicato, se non esiste lo crea e se esiste si posiziona alla fine del file) per specificare il re-indirizzamento di input e output # scriviamo il valore della funzione obiettivo e il valore delle variabili # del problema di flusso a costo minimo (MCF) sul file sol.txt ampl: model MCF.mod; ampl: data MCF.dat; ampl: option solver cplex; ampl: solve; CPLEX : optimal solution; objective 33 0 dual simplex iterations (0 in phase I) ampl: display Costo_Totale >> sol.txt; ampl: display x >> sol.txt; 17

18 Operazioni su stringhe in AMPL - valori da assegnare alle opzioni AMPL attraverso il comando option Abbiamo visto l uso del comando option solver per indicare all interprete AMPL quale solutore invocare per la soluzione del problema, ma esistono molte altre opzioni. # per eliminare le restrizioni di tipo integer e binary sulle variabili di un problema, usiamo il comando option per cambiare il valore dell opzione relax_integrality ampl: model MCF.mod; ampl: data MCF.dat; ampl: option relax_integrality 1; 18

19 Script in AMPL Uno script in AMPL è una sequenza di comandi AMPL da eseguire. Il comando commands legge il file.run contenente lo script da eseguire. # script_mcf_1.run script che legge i file MCF.mod e MCF.dat e # invoca il solutore CPLEX per risolvere il problema di flusso a costo # minimo stampando la soluzione primale e duale nel file MCF.sol.txt model MCF.mod; data MCF.dat; option solver cplex; solve; display x > MCF.sol.txt; display Incidenza > MCF.sol.txt; ampl: commands script_mcf_1.run; CPLEX : optimal solution; objective 33 0 dual simplex iterations (0 in phase I) 19

20 Cicli in AMPL Il comando for esegue un blocco di istruzioni AMPL per ciascun elemento di un insieme, specificato tra parentesi graffe {}. Utilizzando le stringhe in AMPL ed il comando for possiamo risolvere più problemi scrivendo un unico script AMPL. # script_mcf_2.run script che legge il file MCF.mod e successivamente # legge i file MCF.dat, CM.dat e MF.min.dat e invoca il solutore CPLEX # per risolvere i tre problemi, stampando la soluzione nei relativi file model MCF.mod; set CASI := {"MCF","CM","MF.min"}; for {j in CASI} { reset data; data ( j & ".dat"); solve; display x > ( j & ".sol.txt"); display Incidenza > (j & ".sol.txt"); } 20

21 Problema Taglio minimo in un grafo Sia G(N,A) un grafo orientato connesso. Sia dato il vettore c di capacità definito sull insieme A degli archi del grafo G(N,A) c = { 4, 2, 3, 7, 4, 5, 1 } A = {AC, BA, BC, CD, DB, DE, EB} 2 B 1 A 3 4 E 4 C 7 D 5 Vogliamo risolvere il problema di determinare il taglio di capacità minima sul grafo orientato G(N,A) rispetto al vettore c di capacità. 21

22 Algoritmo di soluzione Sappiamo risolvere il problema di determinare il taglio di capacità minima st con s e t nodi speciali in N. Aggiungiamo l arco ts (e quindi una colonna alla matrice M) di capacità infinita. c = {4, 2, 3, 7, 4, 5, 1, } A ={AC, BA, BC, CD, DB, DE, EB, EA} 2 B 1 A 3 4 E 4 C 7 D 5 IDEA Risolviamo tanti problemi di massimo flusso modificando il grafo. 22

23 Algoritmo di soluzione Facciamo variare s e t in N e risolviamo il problema di massimo flusso da s a t. Il vettore w dei costi definito sull insieme A degli archi del grafo G(N,A) non cambia w = { 0, 0, 0, 0, 0, 0, 0, 1 } A = {AB, AC, BC, BE, CD, DB, DE, ts} Il vettore d di domande definito sull insieme N dei nodi del grafo G(N,A) non cambia d = {0, 0, 0, 0, 0} N = {A, B, C, D, E} Il vettore c di capacità definito sull insieme A degli archi del grafo G(N,A) non cambia c = {4, 2, 3, 7, 4, 5, 1, } A ={AC, BA, BC, CD, DB, DE, EB, ts} 23

24 Algoritmo di soluzione La matrice M di incidenza cambia: la colonna relativa all arco ts varia in funzione di s e t colonna ts per t = E e s = A M = Occorre modificare il grafo al variare di s e t in N e risolvere di volta in volta il problema di massimo flusso da s a t. Realizziamo due script: - modifica_grafo.run che modifica l ultima colonna della matrice M - taglio_minimo.run che dichiara i parametri e definisce il problema, assegna i valori iniziali ai parametri, fa variare i parametri s e t modificando il grafo e risolvendo il problema di massimo flusso. 24

25 # file MF_modf.mod param N; param A; param domanda {1..N}; param capacita {1..A}; param costo {1..A}; param M {1..N, 1..A}; Implementazione in AMPL var x {j in 1..A} >= 0, <= capacita[j]; maximize Costo_Totale: sum {j in 1..A} costo[j] * x[j]; subject to Incidenza {i in 1..N}: sum {j in 1..A} M[i,j] * x[j] = domanda[i]; 25

26 # file MF_modf.dat data; param N := 5 ; param A := 8; Implementazione in AMPL param domanda := ; param: capacita costo := Infinity 1 ; 26

27 Implementazione in AMPL # file MF_modf.dat continua param M : := ; 27

28 Implementazione in AMPL # script taglio_minimo.run - script per determinare # il taglio di capacità minima in un grafo model MF_modf.mod; data MF_modf.dat; param ind_s default 0; param ind_t default 0; param valore_minimo default Infinity; param valore_taglio_minimo { 1..N, 1..N} default 0; param taglio_minimo {1..N, 1..N, 1..N} default 0; option solver cplex; 28

29 Implementazione in AMPL for {s in 1..N, t in 1..N} { if( s!= t ) then { commands modifica_grafo.run; solve; let valore_taglio_minimo[s,t] := Costo_Totale; for { k in 1..N } let taglio_minimo[s,t,k] := Incidenza[k]; if( Costo_Totale < valore_minimo ) then { let valore_minimo := Costo_Totale; let ind_s := s; let ind_t := t; } 29

30 Implementazione in AMPL } } display s > TCM.sol.txt; display t > TCM.sol.txt; display Costo_Totale > TCM.sol.txt; display Incidenza > TCM.sol.txt; display ind_s > TCM.sol.txt; display ind_t > TCM.sol.txt; display valore_minimo > TCM.sol.txt; 30

31 Implementazione in AMPL # script modifica_grafo.run - script per modificare # la matrice di incidenza del grafo in funzione dei # nodi s e t in N for { k in 1..N } let M[k,A] := 0; let M[s,A] := 1; let M[t,A] := -1; M = colonna ts inseriamo -1 nella riga t e 1 nella riga s A (numero degli archi) 31

32 Esecuzione e soluzione ampl: commands taglio_minimo.run; Nel file TCM.sol.txt sono riportati, al variare di s e t in N: - capacità del taglio st di capacità minima - vettore di incidenza dell insieme S di nodi separabili dal taglio st Alla fine del file, viene riportata la coppia st in corrispondenza della quale abbiamo il taglio di capacità minima e la capacità del taglio ind_s = 5 ind_t = valore_minimo =

33 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^ Riga i a i b i P x^ 33

34 Definizione del 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 a i T d b i Aggiunta del vincolo violato Metodo del Simplesso Q= x * ottima (in Q) Oracolo di Separazione x * P di P x * P a T i x>bi P= x* ottima 34

35 Algoritmo di soluzione 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. 35

36 Algoritmo di soluzione 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 Ax*< 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. 36

37 # file test.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; Implementazione in AMPL 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]]; 37

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

39 Implementazione in AMPL # script main.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; 39

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

41 Implementazione in AMPL # script oracolo.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 { let z := z + 1; let I[z] := i; let nv := 1; break; } 41

42 Esecuzione e soluzione ampl: commands main.run; Nel file sol.txt sono riportati per le diverse iterazioni: - 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 [*] := ; 42

43 Implementazione in AMPL # script main.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 test.mod; data test.dat; param nv; # se al posto di let z := 10; scriviamo: printf "\nhow many of the periods do you want to use?\n"; read z <- ; # il valore del parametro z viene letto da tastiera let {i in 1..z} I[i] := i; option solver cplex; 43