PII-401 Optimizacin I

Prof. Vctor M. Albornoz S.

Departamento de Industrias
Campus Santiago Vitacura
SEGUNDO SEMESTRE 2015

Martes 3 de Noviembre de 2015

Contenidos
1. Introduccin.
2. Programacin Lineal
3. Tcnicas de Descomposicin.
3.1 Introduccin.
3.2 Mtodo de Generacin de Columnas.
3.3 Mtodo de Dantzig & Wolfe.
3.4 Mtodo de Benders.
4. Problemas de Flujo en Redes.
5. Programacin Entera.
6. Programacin Estocstica Lineal.

3.1 Introduccin.
Existe una amplia variedad de problemas en
diversas disciplinas que dan origen a modelos de
optimizacin de gran tamao que poseen una
determinada estructura donde se combinan
restricciones simples con otras ms complejas.
Los Mtodos de Decomposition proveen una
tcnica numrica de optimization para resolverles.

En el caso de modelos de Programacin Lineal,

hay problemas cuya matriz que representa las
diferentes ecuaciones (Ax=b) resulta ser una
matriz poco densa con un claro patrn de sus
elementos no-nulos.
Por ejemplo, A podra ser una matriz bloque
angular:

tener una estructura dual bloque angular:

o bien ser una matriz con forma de escalera:

Un modelo lineal de Programacin Estocstica

con recurso de dos-etapas (en el caso finito)
corresponde por ejemplo a:
Min
s.a.

cx + p1q1y1 + p2q2y2 + + pSqSyS

Ax
=b
1
1
T x + Wy
= h1
T2x
+ Wy2
= h2

TSx
+ WyS = hS
x0, y10, y20, , yS0.

En Albornoz et al. (2004) se abord un problema

de expansin de capacidad de un sistema de
potencia elctrica trmico que ante incertidumbre
en la disponibilidad de las unidades de
generacin existentes se resolvi mediante el
Mtodo de Descomposicin de Benders.

En Albornoz and Canales (2006), usamos un

Mtodo de Descomposicin Lagrangeana para
resolver un modelo de programacin estocstica
con recurso de dos-etapas que provee una cuota
total de captura de un recurso pesquero
particular regulado por el Estado.

En Albornoz and anco (2014) se abord un

problema de particin en zonas homogneas de
un terreno agrcola basado en informacin georeferenciada de propiedades del suelo mediante
un Mtodo de Generacin de Columnas.

En Palomo-Martnez et al. (2015) se est

abordando un problema de ruteo vehicular
conocido en la literatura como Orienteering
Problem (OP), que incluye adicionalmente la
visita a nodos obligatorios y nodos en conflicto
para el diseo de las rutas, que considera el
Mtodo de Branch-and-Price para su resolucin.

Existen numerosos problemas de gran tamao

altamente estructurados que contribuyen a la toma
de buenas decisiones y cuya resolucin plantea
desafos algortmicos por su complejidad.
La presencia de tal estructura puede y (debe) ser
empleada en mtodos eficientes para la
resolucin de tales tipos de problema (ante
instancias de gran tamao).

En un contexto ms amplio, los primeros trabajos

que hacen uso de Mtodos de Descomposicin
se remontan a ms de cinco dcadas con la
aparicin de los mtodos de Descomposicin de
Dantzig y Wolfe (1960) y el mtodo de
Descomposicin de Benders (1962).

A ello se agrega una primera aplicacin de un

Mtodo de Generacin de Columnas en el trabajo
de Gilmore y Gomory (1961,1963) quienes lo
aplicaron al problema de corte de piezas.
Con posterioridad son numerosos los problemas
que han sido abordados con este mtodo, ver por
ejemplo Desaulniers et al. (2005).

Otras referencias de inters:

VRPTW, Desrosiers et al. (1984).
Two-stage stochastic linear program, Birge (1985).
Column Generation in IP, Vanderveck and Wolsey (1996).
Branch-and-price, Barnhart et al. (1998).
Two-Stage Column Generation, Salani and Vacca (2008).
Primal-dual column generation method, Gondzio et al.
(2013).
Bi-objective column generation algorithm, Moradi et al.
(2015)

Para abordar computacionalmente un problema

complejo mediante el uso de un Mtodo de
Descomposicin la idea bsica consiste en:
descomponer o simplificar la resolucin del
problema original resolviendo separadamente
un Problema Maestro (reducido) y un
Subproblem, este timo usualmente con un
subjunto de las restricciones originales que
poseen una estructura especial.

Para llevar a cabo esta idea en un contexto

algortmico, la estrategia consiste en enviar
informacin tales como precios sombra y
soluciones factibles entre el Problema Maestro
Reducido y el Subproblema hasta alcanzar la
solucin ptima o una aproximacin a la misma
en un nmero finito de iteraciones.

En Albornoz et al. (2004) se considera el Mtodo

de Descomposicin de Benders donde:
Problema Maestro: plan de inversiones sobre todo
el horizonte de planificacin de largo plazo.
Subproblema(s): operacin ptima del sistema en
cada mes y escenario de disponibilidad de
unidades.

En Albornoz and Canales (2006), se considera el

Mtodo de Descomposicin Lagrangeana donde:
Problema
Maestro:
coordinacin
restricciones de no-anticipatividad.

de

las

Subproblema(s): problema de cuota de captura

anual para cada escenario de comportamiento de
dinmica poblacional (ecosistema marino).

En Albornoz and anco (2014) se considera el

Mtodo de Generacin de Columnas donde:
Problema Maestro: Particin ptima del terreno
para un conjunto dado de potenciales zonas.
Subproblema(s): determinacin de una potencial
zona rectangular para el terreno.

En Palomo-Martnez et al. (2015) se considera el

Mtodo de Branch-and-Price donde:
Problema Maestro: Seleccin de una ruta que
verifica cumplimiento de visita a nodos obligatorios
y elimina conflictos de entre un conjunto dado de
potenciales rutas.
Subproblema(s): Problema de ruteo vehicular
capacitado.

10

Contenidos
1. Introduccin.
2. Programacin Lineal
3. Tcnicas de Descomposicin.
3.1 Introduccin.
3.2 Mtodo de Generacin de Columnas.
3.3 Mtodo de Dantzig & Wolfe.
3.4 Mtodo de Benders.
4. Problemas de Flujo en Redes.
5. Programacin Entera.
6. Programacin Estocstica Lineal.

3.2 Mtodo de Generacin de Columnas.

Como ya se seal, una primera aplicacin de un
Mtodo de Descomposicin corresponde al uso
del mtodo de Generacin de Columnas para el
problema de corte de piezas, ver NEOS

11

Notacin.
W = ancho de las piezas a cortar
wi = ancho del trozo demandado i=1,,m
bi = demanda de trozos de ancho wi con i=1,,m
aij = nmero de veces que aparece el trozo de tamao wi
en el patrn de corte j, con i=1,,m j=1,,n
A=(aij)i=1,,m j=1,,n matriz que rene todos los patrones de
corte.
aj = j-sima columna de A, correspondiente al patrn de
corte j=1,,n.

Un patrn de corte j es factible en la medida que

verifique: a1jw1 + a2jw2 + + amjwm W
Si xj representa el nmero de veces que se emplea
el patrn de corte j, un modelo que minimiza el
nmero total de piezas a cortar corresponde a:
Min x1 + x2+ ... + xn
s.a. ai1x1 + ai2x2 + ... + ainxn = bi
i=1,,m
x10, x20, , xn0, enteros,

12

Al emplear el Mtodo de Generacin de Columnas

los patrones se van generando iteracin tras
iteracin al aplicar el mtodo Simplex Revisado a
la relajacin continua del modelo anterior.
El mtodo parte de una solucin bsica factible
que en general es fcil de conseguir. En el ejemplo
se puede partir de m patrones iniciales cada uno
de los cuales contiene nicamente W/wi trozos
del tamao wi, es decir para i=1,,m se define:
aij= W/wi si i=j y 0 sino para j=1,,m

Siendo B la respectiva matriz de base asociada a

esta solucin bsica factible, es posible saber si
es ptima mediante el clculo de los costos
reducidos para cada variable no-bsica xj,
verificando si se cumple:
1 - cBTB-1aj = 1- Taj 0

para cada patrn j, lo cual equivale a:

minj=1,,n {1- Taj} 0

13

Para verificar esto ltimo no es necesario

conocer todos los patrones sino simplemente
verificar si le cumple aquel patrn que minimiza
el siguiente Suproblema:
Min
s.a.

1 - Ta
a1w1 + a2w2 + + amwm W
a 0, entero.

si a=ak es el patrn donde se alcanza la solucin

ptima y verifica: 1 - Tak 0, entonces todos los
otros patrones le verifican y hemos alcanzado la
solucin ptima. Sino se sigue con el M.Simplex.

Implementacin en AMPL
www.ampl.com

14

cut1.mod

# ---------------------------------------# CUTTING STOCK USING PATTERNS

# ---------------------------------------param roll_width > 0;

# width of raw rolls

set WIDTHS;
param orders {WIDTHS} > 0;

# set of widths to be cut

# number of each width to be cut

param nPAT integer >= 0;

set PATTERNS := 1..nPAT;

# number of patterns
# set of patterns

param nbr {WIDTHS,PATTERNS} integer >= 0;

check {j in PATTERNS}:
sum {i in WIDTHS} i * nbr[i,j] <= roll_width;
# defn of patterns: nbr[i,j] = number
# of rolls of width i in pattern j
var Cut {PATTERNS} integer >= 0;

# rolls cut using each pattern

minimize Number:
sum {j in PATTERNS} Cut[j];

# minimize total raw rolls cut

subj to Fill {i in WIDTHS}:

sum {j in PATTERNS} nbr[i,j] * Cut[j] >= orders[i];
# for each width, total
# rolls cut meets total orders
# ---------------------------------------# KNAPSACK SUBPROBLEM FOR CUTTING STOCK
# ---------------------------------------param price {WIDTHS} default 0.0;
var Use {WIDTHS} integer >= 0;
minimize Reduced_Cost:
1 - sum {i in WIDTHS} price[i] * Use[i];
subj to Width_Limit:
sum {i in WIDTHS} i * Use[i] <= roll_width;

cut.dat
# ---------------------------------------# CUTTING STOCK
# ----------------------------------------

data;
param roll_width := 110 ;
param: WIDTHS: orders :=
20 48
45 35
50 24
55 10
75 8 ;

15

cut1.run

#
#
#
#

---------------------------------------GILMORE-GOMORY METHOD FOR

CUTTING STOCK PROBLEM
----------------------------------------

option solver lpsolve;

option solution_round 6;
model cut1.mod;
data cut1.dat;
problem Cutting_Opt: Cut, Number, Fill;
option relax_integrality 1;
option presolve 0;
problem Pattern_Gen: Use, Reduced_Cost, Width_Limit;
option relax_integrality 0;
option presolve 1;
let nPAT := 0;
for {i
let
let
let
};

in WIDTHS} {
nPAT := nPAT + 1;
nbr[i,nPAT] := floor (roll_width/i);
{i2 in WIDTHS: i2 <> i} nbr[i2,nPAT] := 0;

repeat {
solve Cutting_Opt;
let {i in WIDTHS} price[i] := Fill[i].dual;
solve Pattern_Gen;
if Reduced_Cost < -0.00001 then {
let nPAT := nPAT + 1;
let {i in WIDTHS} nbr[i,nPAT] := Use[i];
}
else break;
};
display nbr;
display Cut;
option Cutting_Opt.relax_integrality 0;
option Cutting_Opt.presolve 10;
solve Cutting_Opt;
display Cut;

16