Two Dimensional Cutting Stock Problem 30 novembre 2010

Two Dimensional Cutting Stock Problem 30 novembre 2010 Sommario Studio del Cutting Stock Problem in due dimensioni secondo il modello proposto da P.C. Gilmore e R.E. Gomory in Multistage Cutting Stock Problems of Two and More Dimensions ed implementazione in C++ con l utilizzo della libreria SCIP Informazioni documento Autore Andrea Giavatto Versione 0.5 Diario delle modifiche 0.5 30/11/2010 - rivisitazione del documento sulle modifiche richieste dal docente (par. 2.2, 2.3, 2.4, 4.3) 0.4 21/11/10 - aggiunta sezione di confronto dei metodi e rivisitazione generale del documento 0.3 20/01/10 - aggiunta sezione sull implementazione dell euristica 0.2 11/01/10 - aggiunta sezione sull implementazione con SCIP 0.1 29/12/09 - stesura iniziale. 1/14

Indice 1 Introduzione 3 2 2D Cutting Stock Problem 4 2.1 1D Cutting Stock Problem...................... 4 2.2 Formulazione del problema bidimensionale generale........ 5 2.3 Problema 2-stage........................... 6 2.4 Soluzione del problema 2-stage................... 6 3 Implementazione 8 3.1 Ambiente di sviluppo......................... 8 3.2 SCIP.................................. 8 3.3 Euristica costruttiva......................... 10 4 Test 11 4.1 Invocazione dei programmi..................... 11 4.2 Risultati................................ 11 4.3 Confronto tra i metodi........................ 12 4.3.1 Qualità delle soluzioni.................... 12 4.3.2 Tempi di esecuzione..................... 12 Bibliografia14 2/14

1 Introduzione I problemi di taglio multi dimensionale sono sorprendentemente comuni nella realtà. La necessità di ottimizzare il taglio di oggetti di grandi dimensioni in parti più piccole deriva dall esigenza delle economie di scala di produrre grandi quantità di materiale per ridurre i costi. È desiderabile quindi, trovare metodi efficienti per ottenere le taglie più piccole richieste dal mercato consumer. Il taglio di lastre di vetro, metallo, grafite, pellicole fotografiche o plastica rappresenta un esempio concreto delle applicazioni pratiche del taglio multidimensionale. È proposta nei successivi paragrafi l analisi del problema di taglio bidimensionale basata sulle osservazioni contenute nell articolo [2]. 3/14

2 2D Cutting Stock Problem Il problema del taglio bidimensionale consiste nel ritagliare da rettangoli di grandi dimensioni (in seguito chiamati maxi-rettangoli ), pezzi di forma rettangolare di dimensioni inferiori rispettando una data domanda e minimizzando la quantita di maxi-rettangoli usata. 2.1 1D Cutting Stock Problem Questo problema, può essere visto come un estensione del problema in una dimensione, già trattato in [1], per il quale il modello risolutivo proposto, è il seguente: min x j (1) t.c j J N ij x j R i j J i I x j Z + j J dove I è l insieme degli oggetti da ritagliare J è l insieme dei pattern di taglio N ij è il numero di pezzi di tipo i nel pattern j R i è la richiesta complessiva di pezzi di tipo i x j è il numero di maxi-rettangoli da tagliare secondo lo schema j A causa dell elevato numero di possibili pattern non noti a priori, questo problema si risolve utilizzando un modello di tipo master-slave e una tecnica di generazione di colonne. Una soluzione ammissibile di base del problema master è progressivamente migliorata con l aggiunta di nuove colonne, ciascuna corrispondete a un pattern di taglio migliore. La scoperta dei pattern di taglio migliori avviene attraverso la soluzione di problemi slave che in questo caso sono rappresentati da problemi di zaino: max i I u i z i (2) t.c i I l i z i W dove z Z + 4/14

u è la soluzione duale in scarti complementari con la soluzione corrente del problema master z è una colonna, se esiste, corrispondente a un pattern di taglio migliore l è la lunghezza dei singoli oggetti da ritagliare W è la lunghezza totale di ogni maxi-oggetto La soluzione di questo problema di zaino fornisce, se esiste, una colonna con costo ridotto negativo che migliora la soluzione del problema di partenza. 2.2 Formulazione del problema bidimensionale generale Si consideri una scorta di maxi-rettangoli di larghezza W e altezza L da ritagliare secondo una richiesta nota. Un problema di taglio in due dimensioni consiste nel soddisfare la domanda di rettangoli da ritagliare, minimizzando la quantità di materiale usata. Inoltre, sono dati: I, un insieme di rettangoli da ritagliare i I, la larghezza w i, la lunghezza l i e la richiesta R i di ogni rettangolo la larghezza W e la lungehzza L del maxi-rettangolo da tagliare Si vuole determinare la minima quantità di maxi-rettangoli (x j ) tagliati secondo il pattern di taglio j. Un modello risolutivo per questo tipo di problema è ancora di tipo master-slave con generazione di colonne e coincide con (1). Come nel caso monodimensionale, siamo interessati a risolvere il rilassamento lineare del problema, perchè nelle applicazioni pratiche le quantità e le dimensioni dei rettangoli da tagliare permettono di arrotondare la soluzione rilassata ottenendo una buona approssimazione intera. Il problema slave, in questo caso, deve tenere conto che i maxi-rettangoli hanno due dimensioni: max u i z i (3) i I t.c z i indica in che quantità il rettangolo w i l i è presente nel pattern (z i Z + ) Per questo problema di zaino generalizzato non sono note tecniche di risoluzione efficienti. 5/14

2.3 Problema 2-stage Fortunatamente, nelle applicazioni pratiche è possibile osservare che alcuni tipi di taglio permettono di rendere il problema di zaino meno generico: è sufficiente, infatti, considerare tagli a ghigliottina 1 per poter formulare un modello efficiente pur garantendo una buona generalità nelle combinazioni dei possibili rettangoli. I tagli a ghigliottina permettono di considerare il problema in due fasi: 1. il maxi-rettangolo di dimensioni W L è inizialmente tagliato in strisce sulla larghezza W 2. ogni striscia ottenuta dalla fase precedente, è a sua volta tagliata lungo la lunghezza L secondo le richieste e pertanto trattata come un problema monodimensionale Figura 1: Rappresentazione grafica del problema 2-stage 2.4 Soluzione del problema 2-stage La soluzione proposta da Gilmore e Gomory per il problema slave (3) è la seguente: 1. per ogni larghezza w i, calcolo gli u i, soluzioni ottime dei problemi slave considerando strisce di larghezza w i e lunghezza L tagliate secondo le richieste con pezzi di larghezza w j w i 2. il valore ottimo del problema di zaino 2D si ottiene risolvendo un ulteriore problema di zaino monodimensionale: max i I u i b i (4) t.c i I w i b i W 1 un taglio a ghigliottina prevede che il maxi-rettangolo sia tagliato da un lato all altro in modo netto e senza interruzioni 6/14

dove b i rappresenta quante strisce di tipo i utilizzare per tagliare un maxirettangolo. La prima fase, considera problemi di taglio monodimensionale (striscia w i L) dove i pezzi da ritagliare sono solo quelli con w j w i. La soluzione u i di ogni slave indica la bontà del pattern di taglio per la striscia considerata. La seconda fase determina quali (e quante) strisce considerare per un pattern di taglio j da inserire nella successiva iterazione del problema master. La scelta è effettuata tenendo conto dei valori u i ottenuti dagli slave precedenti e in modo tale che la somma delle larghezze delle strisce considerate (w i ) non superi la larghezza W di un maxi-rettangolo. In sintesi, un problema di cutting stock bidimensionale, è risolvibile attraverso un modello master-slave con generazione di colonne, in cui il problema slave si risolve a partire da due problemi di zaino monodimensionale. 7/14

3 Implementazione 3.1 Ambiente di sviluppo I programmi sono stati scritti nel linguaggio C++ nel sistema operativo MacO- SX e testati su un portatile con processore Intel dual core a 2GHz e con 1GB di ram. 3.2 SCIP L implementazione è stata realizzata utilizzando la libreria SCIP 2 (ver. 1.2.0) e il solver Soplex 3 (ver. 1.4.2 e patch 1.4.2a) che forniscono un framework per la risoluzione di problemi di programmazione lineare intera (e non solo). In particolare, il codice allegato è una modifica ed estensione di un esercizio visto a lezione e realizzato in laboratorio. Il codice segue quasi fedelmente il modello proposto. Rispetto all esercizio svolto in laboratorio differisce nel file master.cpp per la scelta della base ammissibile di partenza, e nel file che contiene la funzione main. Di seguito, viene mostrato il ciclo principale: 1 do { 2 // r i s o l v o problema master per o t t e n e r e s o l u z i o n e a m m i s s i b i l e 3 master. solvelp ( ) ; 4 master. d i s p l a y ( ) ; 5 6 // v e t t o r e che c o n t e r r a i c o s t i d i ogni s t r i s c i a 7 std : : vector <double> u s t a r ( master. getwidths ( ). s i z e ( ) ) ; 8 // v e t t o r e che r i c o r d a q u a l e p a t t e r n e a s s o c i a t o a ogni s t r i s c i a 9 std : : vector <std : : vector <int> > p a t t e r n s = std : : vector <std : : vector <int> >() ; 10 11 for ( unsigned int i = 0 ; i < l a r g h e z z e. s i z e ( ) ; i ++) { 12 std : : vector <double> u ; 13 for ( unsigned int l = 0 ; l < master. getdualvalues ( ). s i z e ( ) ; l ++) { 14 u. push back ( ( master. getdualvalues ( ) ) [ l ] ) ; 15 } 16 // modifico g l i u i in modo da c o n s i d e r a r e s o l o i p e z z i con l a r g h e z z a <= w i 17 for ( unsigned int j = 0 ; j < l a r g h e z z e. s i z e ( ) ; j++) { 18 i f ( l a r g h e z z e [ j ] > l a r g h e z z e [ i ] ) { 19 u [ j ] = 0. 0 ; 20 } 21 } 22 // r i s o l v o l o s l a v e che c o n s i d e r a l a s t r i s c i a c o r r e n t e come 23 // c u t t i n g s t o c k monodimensionale 24 CSSlave s l a v e ( u, master. getlengths ( ), master. getrectlength ( ) ) ; 25 s l a v e. s o l v e ( ) ; 26 s l a v e. d i s p l a y ( ) ; 27 28 std : : vector <int> p a t t e r n S t r i s c i a I ( master. getwidths ( ). s i z e ( ) ) ; 29 // newu e i l v a l o r e d uale ottimo a s s o c i a t o a l l a s t r i s c i a i 2 http://scip.zib.de/ 3 http://soplex.zib.de/ 8/14

30 double newu = s l a v e. g e t S o l u t i o n ( p a t t e r n S t r i s c i a I ) ; 31 u s t a r [ i ] = newu ; 32 // s a l v o come ho t a g l i a t o l a s t r i s c i a i 33 p a t t e r n s. push back ( p a t t e r n S t r i s c i a I ) ; 34 } 35 36 // r i s o l v o un ultimo problema s l a v e che mi d i c e q u a l i s t r i s c e c o n s i d e r a r e 37 // per t a g l i a r e un maxi r e t t a n g o l o 38 CSSlave s l a v e ( u s t a r, master. getwidths ( ), master. getrectwidth ( ) ) ; 39 s l a v e. s o l v e ( ) ; 40 s l a v e. d i s p l a y ( ) ; 41 42 std : : vector <int> p a t t e r n S t r i s c e ( master. getwidths ( ). s i z e ( ) ) ; 43 // q u e s t o s l a v e mi d i c e q u a l i e quante s t r i s c e t a g l i a r e da un maxi r e t t a n g o l o 44 // secondo i p a t t e r n f o r n i t i d a l l e s o l u z i o n i d e g l i s l a v e p r e c e d e n t i 45 slaveobj = s l a v e. g e t S o l u t i o n ( p a t t e r n S t r i s c e ) ; 46 47 i f ( slaveobj > 1) { 48 std : : vector <int> newpattern ( master. getwidths ( ). s i z e ( ) ) ; 49 // per o t t e n e r e i l p a t t e r n da a g g i u n g e r e a l problema master, 50 // devo c o n s i d e r a r e l e s t r i s c e f o r n i t e d a l l ultimo s l a v e e c r e a r e 51 // un p a t t e r n che è l a somma d e i p a t t e r n f o r n i t i d a l l e s t r i s c e 52 // eventualmente m o l t i p l i c a t i per i l numero d i s t r i s c e i n d i c a t o 53 // n e l l ultimo s l a v e 54 for ( unsigned int k = 0 ; k < newpattern. s i z e ( ) ; k++) { 55 newpattern [ k ] = 0 ; 56 } 57 for ( unsigned int k = 0 ; k < p a t t e r n S t r i s c e. s i z e ( ) ; k++) { 58 for ( unsigned int m = 0 ; m < newpattern. s i z e ( ) ; m++) { 59 newpattern [m] = newpattern [m] + p a t t e r n S t r i s c e [ k ] p a t t e r n s [ k ] [m] ; 60 } 61 } 62 63 master. addpattern ( newpattern ) ; 64 } 65 maxiter ; 66 } while ( slaveobj > 1 && maxiter > 0) ; Da notare che per garantire che le variabili duali fornite dal problema master rispettino il vincolo che w j w i per ogni striscia i considerata, vengono settati a 0 i valori degli u j che hanno larghezza superiore alla striscia considerata (linee 17-20). Infine (linee 57-61), dopo aver risolto l ultimo slave che fornisce quante e quali strisce considerare per un maxi-rettangolo, è necessario sommario tra loro le strisce scelte con i pattern associati (linea 33) in modo da ricostruire il pattern da aggiungere al problema master. 9/14

3.3 Euristica costruttiva E stata implementata una euristica di tipo greedy per la risoluzione del problema bidimensionale; si parte da una soluzione vuota e si determinano in modo iterativo nuovi elementi da aggiungere ad una soluzione fino ad arrivare ad una soluzione completa attraverso un criterio di espansione. L idea è di ordinare i rettangoli per aree decrescenti e cominciare a ritagliare dai maxi-rettangoli i rettangoli che occupano più spazio; in questo modo è possibile inserire nello spazio rimanente una certa quantità di rettangoli più piccoli cercando di minimizzare lo spazio sprecato in ogni maxi-rettangolo (questo non sarebbe possibile se ritagliassi prima tutti i rettangoli più piccoli lasciando alla fine quelli di dimensioni maggiori). Ogni scelta non è mai messa in discussione e si procede con lo stesso criterio fino all esaurimento della domanda. Lo pseudocodice che realizza le procedure necessarie è: Algorithm 1 Solve 1: sortarea() 2: while c è richiesta do 3: F illrect(rect width, rect length, pattern) 4: AddP attern(pattern, solution) 5: num rect used num rect used + 1 6: end while Algorithm 2 FillRect(w, l, pattern) 1: for i = 1 to m do 2: current w w width[i] 3: current l l length[i] 4: demand[i] demand[i] 1 5: pattern[i] pattern[i] + 1 6: F illrect(current w, l, pattern) 7: F illrect(width[i], current l, pattern) 8: end for L algoritmo dopo aver tagliato un pezzo in alto a sinistra da un maxirettangolo, lo divide in due sotto rettangoli: la parte restante della striscia con altezza pari a quella del pezzo tagliato e larghezza L l i, e il rettangolo di altezza pari a W w i e larghezza L. Il procedimento è ripetuto ricorsivamente fin tanto che è possibile ritagliare un pezzo (di dimensione minore o uguale a quella ritagliato in precedenza) nei sotto rettangoli rimasti o finchè non è esaurita la richiesta. 10/14

4 Test 4.1 Invocazione dei programmi Sono allegati tre eseguibili, corrispondenti ai programmi richiesti dalla consegna: l implementazione in SCIP del modello scelto, un esempio di euristica, un generatore di input casuali. Tutti i programmi sono forniti di Makefile 4 e si compilano attraverso il comando make. La loro invocazione è la seguente: SCIP: compilazione: make LPS=spx ZIMPL=false READLINE=false invocazione:./bin/main./data/<file di input> euristica: compilazione: make invocazione:./euristica./data/<file di input> generatore compilazione: make invocazione:./generatore./<nome file> <numero di input> 4.2 Risultati Sono state effettuate numerose prove per ciascun programma; al codice sono allegati i file di input usati per i test seguenti in modo da poter riprodurre gli stessi risultati (a meno dei tempi di esecuzione che potrebbero variare a seconda delle performance della macchina su cui vengono eseguiti). Ogni programma è stato invocato con una serie di file di input di dimensioni variabili 5. Di seguito sono riportati i risultati ottenuti in output, privi dell elenco di pattern di taglio per motivi di spazio. E possibile avere un output completo ripetendo la computazione con ogni file di input. 10 input casuali: SCIP: In totale sono stati utilizzati: 35 maxi-rettangoli La computazione ha richiesto 4.00 secondi. Euristica: In totale sono stati utilizzati: 36 maxi-rettangoli La computazione ha richiesto 0.00 secondi. 20 input casuali: SCIP: In totale sono stati utilizzati: 65 maxi-rettangoli La computazione ha richiesto 25.00 secondi. 4è importante ricordarsi di modificare il Makefile relativo all implementazione in SCIP, cambiando il percorso relativo alle librerie in base alla propria configurazione di sistema 5 per i test i valori degli input sono stati limitati a un range ristretto 11/14

Euristica: In totale sono stati utilizzati: 70 maxi-rettangoli La computazione ha richiesto 0.00 secondi. 30 input casuali: SCIP: In totale sono stati utilizzati: 214 maxi-rettangoli La computazione ha richiesto 17.00 secondi. Euristica: In totale sono stati utilizzati: 216 maxi-rettangoli La computazione ha richiesto 0.00 secondi. 50 input casuali: SCIP: In totale sono stati utilizzati: 237 maxi-rettangoli La computazione ha richiesto 133.00 secondi. Euristica: In totale sono stati utilizzati: 261 maxi-rettangoli La computazione ha richiesto 0.00 secondi. 75 input casuali: SCIP: In totale sono stati utilizzati: 211 maxi-rettangoli La computazione ha richiesto 3554.00 secondi. Euristica: In totale sono stati utilizzati: 226 maxi-rettangoli La computazione ha richiesto 0.00 secondi. 4.3 Confronto tra i metodi 4.3.1 Qualità delle soluzioni Nella quasi totalità dei test, il metodo realizzato con SCIP si è dimostrato superiore qualitativamente rispetto alla soluzione euristica. A volte si sono verificati casi in cui le due soluzioni davano lo stesso numero di maxi-rettangoli usati, ma i pattern di taglio erano differenti. In questi casi, SCIP forniva la soluzione ottima generando meno tipologie diverse di strisce rispetto all euristica. In un paio di casi ho notato che SCIP forniva soluzioni peggiori di un unità rispetto all euristica, ma il problema in questi casi è dovuto all arrotondamento nella fase di risoluzione all interezza. 4.3.2 Tempi di esecuzione Il tempo impiegato dall euristica si è rivelato sempre inferiore a 1 secondo per qualsiasi input fornito. Per quanto riguarda l algoritmo in SCIP, risolve il problema master rilassato con un iterazione del simplesso e con più iterazioni di Branch and Bound per ogni problema slave. La soluzione finale del problema master all intero è ottenuta risolvendo un ulteriore Branch and Bound con i pattern considerati. Questo procedimento, oltre a non fornire una soluzione ottima (potrebbero esserci pattern non considerati che all intero fornirebbero una soluzione migliore), necessita di un tempo di calcolo esponenziale. 12/14

Nei vari test si può notare come per input con pochi valori, il tempo di esecuzione è accettabile e nell ordine di alcune decine di secondi, ma al crescere del numero di input il tempo richiesto per giungere alla soluzione può diventare inutile in applicazioni reali. Se ci sono forti vincoli sul tempo di esecuzione, un euristica greedy come quella fornita può essere considerata una buona approssimazione della soluzione ottima; altrimenti, può essere conveniente, prima di avviare l algoritmo che usa SCIP, fornire come soluzione ammissibile di partenza quella ottenuta dall euristica in modo da velocizzare la ricerca della soluzione ottima. 13/14

Riferimenti bibliografici [1] A Linear Programming Approach to the Cutting-Stock Problem, P. C. Gilmore and R. E. Gomory, Operations Research, Vol. 9, No. 6 (Nov. - Dec., 1961), pp. 849-859 [2] Multistage Cutting Stock Problems of Two and More Dimensions, P. C. Gilmore and R. E. Gomory, Operations Research, Vol. 13, No. 1 (Jan. - Feb., 1965), pp. 94-120 14/14