Capítulos 1-2 2023-2

Pontificia Universidad Católica de Chile
Escuela de Ingenierı́a
ICS2121 – Métodos de Optimización
Apuntes de
Métodos de Optimización
Por Francisco Garcı́a Aubert y Jorge Vera Andreo
Material en desarrollo. No compartir fuera del curso
Índice general
1. Introducción: problemas y algoritmos 5

1.1. El problema general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2. Soluciones aproximadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3. Algoritmos y oráculos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2. Métodos del Gradiente, Newton y extensiones 9

2.1. La idea del Algoritmo de Descenso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2. Método del Gradiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3. Método de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4. Midiendo la eficiencia de un algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4.1. Convergencia del Método del Gradiente . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.2. Cambios de variable para mejorar el condicionamiento . . . . . . . . . . . . . . . . . . 21
2.4.3. Velocidad de convergencia para el Método de Newton . . . . . . . . . . . . . . . . . . 22
2.4.4. Costo por iteración del Método del Gradiente y Newton . . . . . . . . . . . . . . . . . 22
2.5. Linesearch: Selección del paso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.1. Métodos de búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5.2. Condición de Wolfe-Armijo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6. Métodos Quasi-Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.6.1. Métodos Quasi-Newton: BFGS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.6.2. Eficiencia de BFGS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.7. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.7.1. Aplicación en IA: Optimización de Redes Neuronales . . . . . . . . . . . . . . . . . . . 30
2.7.2. Aplicación: Optimización en doblamiento de proteinas . . . . . . . . . . . . . . . . . . 33
2.7.3. Centro Analı́tico de un Poliedro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.7.4. Localización espacial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3. Métodos de Primer Orden 40

3.1. Problemas diferenciables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.1. Gradiente sin Linesearch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.2. Convergencia Método Simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.1.3. Propiedad fuerte de convexidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.1.4. Método acelerado de Nesterov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2. Problemas no diferenciables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.2.1. LASSO: Least Absolute Shrinkage and Selection Operator . . . . . . . . . . . . . . . . 48
3.2.2. El Método del Subgradiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.3. FISTA: Fast Iterative Shrinkage and Thresholding Algorithm . . . . . . . . . . . . . . 54
3.2.4. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3. Métodos de Primer Orden con Restricciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.4. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.4.1. Función no diferenciable restringida . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.4.2. Subgradiente de la función “Max” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.4.3. Subgradiente y esfuerzo computacional . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4. Programación Dinámica 66
4.1. Ejemplo introductorio: Desarrollo de problemas recursivos . . . . . . . . . . . . . . . . . . . . 67
4.1.1. Ejemplo del Problema de la Mochila . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.2. La lógica de la Programación Dinámica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
2
Francisco Garcı́a y Jorge Vera Índice general 3
4.2.1. Algoritmo Backwards DP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

4.3. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3.1. Reemplazo de equipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3.2. Compra de acciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.3.3. El Problema de la ruta más corta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.3.4. El problema del Vendedor Viajero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.3.5. Trabajo general sobre rutas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.3.6. Loteo dinámico no capacitado (ULS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.3.7. Programación de una cadena de hornos industriales . . . . . . . . . . . . . . . . . . . 80
4.4. Procesos de decisión Markoviana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.5. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.5.1. Selección dinámica de candidatos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.5.2. Ruteo dinámico con demanda estocástica . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.6. Procesos de decisión Markoviana con horizonte infinito . . . . . . . . . . . . . . . . . . . . . . 85
4.6.1. Value iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.6.2. Policy Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5. Geometrı́a de la Programación Lineal y Extensiones 93

5.1. Conceptos básicos de Geometrı́a de Programación Lineal . . . . . . . . . . . . . . . . . . . . . 93
5.1.1. Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
5.1.2. Conceptos básicos aplicados a Programación Lineal . . . . . . . . . . . . . . . . . . . . 101
5.2. Algoritmo SIMPLEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
5.3. Dualidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.3.1. Problema primal y dual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.3.2. Algunos ejemplos de formulaciones lineales y sus duales . . . . . . . . . . . . . . . . . 105
5.3.3. Ejemplo: el dual aplicado al problema de planifiación de proyectos . . . . . . . . . . . 107
5.3.4. Condiciones alternativas y Lema de Farkas . . . . . . . . . . . . . . . . . . . . . . . . 108
5.3.5. Ejemplos de aplicación del Lema de Farkas . . . . . . . . . . . . . . . . . . . . . . . . 109
5.3.6. SIMPLEX Dual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6. Optimización de gran tamaño 112

6.1. Generación de columnas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
6.1.1. El algoritmo general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
6.1.2. Multiple Pricing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.1.3. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.2. Descomposición de Dantzig-Wolfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
6.2.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
6.3. Identificando Estructuras Complicantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
6.4. Descomposición de Benders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
6.4.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
6.5. Relación entre el método de Dantzig-Wolfe y Benders . . . . . . . . . . . . . . . . . . . . . . 138
7. El Enfoque Dual para Problemas de Gran Tamaño 141

7.1. Dualidad Lagrangeana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
7.1.1. El Primal y el Dual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
7.1.2. Teorema débil y fuerte de dualidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
7.1.3. Múltiples duales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
7.2. Relajación Lagrangeana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
7.2.1. Ejemplos de Relajaciones Lagrangeanas . . . . . . . . . . . . . . . . . . . . . . . . . . 146
7.3. Resolviendo el Problema Dual: Método del Supgradiente . . . . . . . . . . . . . . . . . . . . . 149
7.4. Visión alternativa del dual y el algoritmo de planos cortantes . . . . . . . . . . . . . . . . . . 151
7.4.1. El Método de Planos Cortantes para el dual . . . . . . . . . . . . . . . . . . . . . . . . 152
7.4.2. Diferencias en las relajaciones (material avanzado) . . . . . . . . . . . . . . . . . . . . 153
7.5. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
8. Heurı́sticas 162
8.1. Heurı́sticas Generales: Metaheurı́sticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
8.2. Simulated Annealing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
8.2.1. Ejemplo: localización de centros de distribución y asignación de clientes . . . . . . . . 164
8.3. Tabu Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
4 Índice general
8.4. Algoritmos Genéticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

8.4.1. Ejemplo: problema de localización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
8.5. Comentarios Finales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
9. Complejidad Computacional 168

9.1. Cómo se mide la eficiencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
9.2. Problemas Fáciles y Difı́ciles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
9.3. Clases de Complejidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
9.4. Los problemas NP-Completos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
9.5. La complejidad de Programación Lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
10.Algoritmos de Punto Interior 171

10.1. El algoritmo de Barrera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
10.2. Convergencia del algoritmo y complejidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
10.3. Los métodos interiores prácticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
10.4. Algoritmos interiores: el caso general no lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
10.5. Convergencia del algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
10.6. Elementos básicos de Optimización Cónica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
10.7. Ejemplos de problemas cónicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
10.7.1. Ejemplo 1: proyección de un punto en un poliedro . . . . . . . . . . . . . . . . . . . . 177
10.7.2. Ejemplo 2: Support Vector Machine (SVM) . . . . . . . . . . . . . . . . . . . . . . . . 178
10.7.3. Ejemplo 3: Cono de matrices semidefinidas positivas . . . . . . . . . . . . . . . . . . . 181
10.7.4. Ejemplo 4: Restricciones cuadráticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
10.7.5. Ejemplo 5: Distancias con nomas “no euclideanas” . . . . . . . . . . . . . . . . . . . . 183
10.7.6. Ejemplo 6: Desigualdades lineales de matrices (Linear Matrix Inequalities) . . . . . . . 184
11.Optimización Bajo Incertidumbre 185

11.1. La necesidad de considerar la incertidumbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
11.1.1. Análisis de Sensibilidad para entender incertidumbre . . . . . . . . . . . . . . . . . . . 186
11.2. Simulando la incertidumbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
11.3. Optimización con Restricciones Probabilı́sticas . . . . . . . . . . . . . . . . . . . . . . . . . . 188
11.3.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
11.4. Modelando la Dinámica de la Incertidumbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
11.4.1. Ejemplo introductorio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
11.4.2. Modelo Estocástico de 2 epatas: formulación general . . . . . . . . . . . . . . . . . . . 194
11.5. Cómo resolver el problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
11.5.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
11.5.2. Decisiones en etapas: comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Capı́tulo 1
Introducción: problemas y algoritmos
En este capı́tulo pretendemos dar una introducción y motivación muy general a la necesidad de desarrollar
métodos computacionales para abordar problemas de optimización. Las personas que estudian cálculo y
temas básicos de optimización pueden quedarse con la idea de que para resolver un problema basta “derivar e
igualar a cero”. Como veremos a lo largo de este curso, eso es una falacia: prácticamente ningún problema real
se puede abordar de esa forma. La complejidad de los problemas requerirá el desarrollo de métodos iterativos
como única forma de llegar, no a una solución del problema, si que a una aproximación suficientemente buena.
1.1. El problema general

El problema de optimización general se denota tı́picamente como:
P) mı́n f (x)
x∈S
Donde x es un vector que está en Rn , f : Rn → R y el conjunto S ⊂ Rn corresponde al dominio. Este

conjunto S se puede explicitar:
P) mı́n f (x)
s.a. gi (x) ≤ bi , i = 1, ..., m
Donde f : Rn → R, gi : Rn → R y S ⊂ Rn . Si bien, en la mayorı́a de los casos haremos explı́citas las

“restricciones”, a veces el conjunto S no es describible a través de fórmulas, pero sı́ matemáticamente, tal
como las restricciones de naturaleza de las variables, ej: xi ∈ {0, 1} y otros más complejos.
1.2. Soluciones aproximadas

Supongamos, de momento, que S = Rn , es decir, no hay restricciones, y que la función f puede ser derivada
sin complicaciones. En ese caso, la solución x∗ que se busca corresponde al mı́nimo global, valor que se obtiene
donde ∇f (x∗ ) = 0. El problema de esto es que en muchos problemas existen múltiples mı́nimos locales donde
el gradiente de la función también se anula, también el hecho que pueden existir ciertas restricciones (y la
condición nos e cumple) y que muchas funciones son de miles o millones de variables. De acá la insuficiencia
de simplemente derivar una función e igualar a cero. Más aún, muchas veces en muchas funciones, al derivar
e igualar a cero no se llega a ninguna parte útil, tal como en el siguiente caso:
f (x) = x2 + e−x
Derivando e igualando a cero:
1 −x
f 0 (x) = 2x − e−x = 0 −→ x = e
2
5
6 Capı́tulo 1. Introducción: problemas y algoritmos
En esta última ecuación no se puede despejar x por medio de fórmulas simple algebraicas (los matemáticos
llaman a esto una ecuación trascendente) y se debe optar por otro método para encontrar el mı́nimo. Se
puede resolver llegando a una solución aproximada, lo que se puede hacer con algún algoritmo iterativo, como
lo es el de punto fijo, donde en cada iteración se aproxima más a la solución óptima. El algoritmo consiste
0
en partir de una solución arbitraria para x, llamémosla x0 . Con esta se obtiene x1 resolviendo x1 = 1/2e−x ,
1
luego se resuelve x2 = 1/2e−x y ası́ recursivamente:
1 −xk
xk+1 = e
2
A medida que se itera se va alcanzando una situación de convergencia, por lo que se repite hasta alcanzar un
valor que este cercano al óptimo x∗ . La moraleja es que derivar e igualar a cero generalmente es totalmente
inútil, sino que se debe optar por un enfoque iterativo aproximado.
Formalicemos los objetivos que buscamos. Se dice que x̄ ∈ S es una solución -óptima de P) si para un
≥ 0 su valor objetivo se diferencia en menos de del valor óptimo:
kf (x̄) − f (x∗ )k ≤
Por otro lado, se dice que una solución x̄ es -aproximada si la distancia o norma de esta solución con la
solución óptima es menor a :
kx̄ − x∗ k ≤
Con una solución -óptima estamos focalizándonos en que el objetivo sea lo más cercano posible a su valor
mı́nimo. Por otro lado, la solución -aproximada se focaliza en como “producir” el vector x de modo que sea
lo más parecido posible a la combinación de valores de variables que dan el óptimo. Ambos conceptos no
son equivalentes pero están relacionados:
Figura 1.1: Solución épsilon óptima y épsilon aproximada
En el ejemplo de la imagen se puede ver que si el gráfico de la función en el óptimo es muy plano, no se
requiere una solución -aproximada muy precisa para obtener una buena solución -óptima.
1.3. Algoritmos y oráculos

La idea general consiste principalmente iterar por medio de algoritmos de optimización, para ası́ ir generando
una sucesión de puntos x0 , x1 , x2 , . . .. Para generar los nuevos puntos se utilizan las iteraciones anteriores y
una subrutina o “oráculo” que entrega información de la función f :
Oráculo/información Valores Derivadas Segundas derivadas

Orden cero X
Primer orden X X
Segundo orden X X X
Francisco Garcı́a y Jorge Vera 1.3. Algoritmos y oráculos 7
Al momento de utilizar estos oráculos, se debe tener en cuenta que acceder a más información es más costoso
en tiempo de computo, por lo que no necesariamente un oráculo de segundo orden es más conveniente que
uno de primer orden, ni este más conveniente que uno de orden cero. Es acá donde surge el problema de la
eficiencia del algoritmo de optimización: Dado un error aceptable > 0 ¿cuánto tiempo necesitamos en la
iteración de un algoritmo para obtener este error?
En el caso del Oráculo de orden cero, que solo entrega valores de la función f , se pueden evaluar puntos de f
para ver en dónde se encuentran valores objetivos buenos. El problema es que no necesariamente el óptimo
se encuentra aledaño a los mejores puntos encontrados, tal como en el problema mı́nx∈S f (x) de la Figura
1.2.
Figura 1.2: Puntos encontrados por un oráculo de orden cero
El problema acá es que la función puede oscilar mucho y el óptimo no necesariamente se puede captar.
Este problema se puede solucionar si se sabe que la función f satisface una condición de Lipschitz con
constante L:
|f (x) − f (y)| ≤ L|x − y|, ∀x, y
Esta condición dice que para dos puntos x e y, la diferencia de sus valores objetivos se encuentra acotada en
forma proporcional a la distancia entre x e y. Más aún, todo valor objetivo de una solución que se encuentre
entre x e y está acotado. Esto se debe a que la derivada (y por tanto la pendiente) de la función entre
cualquier par de puntos está acotada por L, para ver esto, se divide la expresión anterior por |x − y| y se
toma el lı́mite cuando x está muy cercano a y:
|f (x) − f (y)|
lı́m ≤ L, ∀x
y→x |x − y|
f 0 (x) ≤ L, ∀x
Lo que se puede hacer con esto, es elegir puntos x e y cuya diferencia sea tal que L|x − y| esté acotada por
un dado, de modo que exista garantı́a de que los valores de la función estén incluidos dentro de ciertos
rangos de variación. En este caso, se tendrá que |f (x) − f (y)| ≤ . De este modo, si dividimos el intervalo
[a, b] en una cantidad de puntos a = x0 , x1 , . . . , xp = b tales que |xi − xi+1 | ≤ /L, tendremos que, en el
intervalo [xi , xi+1 ] se tiene que |f (x) − f (xi )| ≤ .
En la Figura 1.3, por ejemplo, la función se ve acotada por las curvas verdes, cuya pendiente L o −L tiene
un valor absoluto superior a cualquier pendiente de la curva roja (mayor que cualquier derivada), lo que
asegura que f nunca se saldrá de los márgenes, de modo que se puede tener certeza que el óptimo no se
encuentra en partes más lejanas, de hecho, no se encuentra fuera del intervalo [c, d].
De este modo, vamos encontrando “cajas” que “contienen” a f (al gráfico de f y esto permite definir un
punto que tienen un error acotado con respecto al óptimo. Si hacemos la división del intervalo más fina,
podremos tener una mucho mejor aproximación, de hecho. Esto ilustra cómo una propiedad adicional permite
encontrar una solución aproximada tan precisa como se quiera. En efecto, dado que la solución estará en
alguno de los intervalos, si queremos una solución -aproximada necesitamos que el ancho de los intervalos
sea ≤ /L. Esto se logra dividiendo [a, b] en p puntos equidistantes, con p = L/.
Para encontrar la solución -aproximada tenemos que evaluar la función en todos los p puntos creados.
En Optimización y en Computación se habla de la “complejidad” de un algoritmo. Esto es el número de
8 Capı́tulo 1. Introducción: problemas y algoritmos
Figura 1.3: Uso de Lipschitz para descartar parte del dominio cuando se tiene un oráculo de orden cero
“iteraciones” (evaluaciones en este caso) necesarias para llegar a la meta (que es la aproximación, no la
solución exacta). En este caso, esa complejidad es proporcional a L/. Esto refleja que si queremos más
precisión, tenemos que trabajar más. Pero también indica que si la función no es muy “decente”, si L es muy
grande, también tendremos que trabajar más.
Ahora bien, si tenemos una función de n variables, podemos extender esta idea. Lo que se debe hacer es dividir
cada una de las coordenadas en intervalos de modo de forma una “grilla” en la que se debe evaluar la función.
Es fácil darse cuenta que si usamos, digamos, p divisiones, entonces tendremos que hacer pn evaluaciones
de la función. La estimación de p es igual que en el caso de una dimensión, ası́ que la complejidad, en este
caso, es proporcional a (L/)n .
Podemos ver, entonces, que sólo evaluando valores de la función nuestra búsqueda de una aproximación
al mı́nimo puede ser muy ineficiente. Acá surge, entonces, la necesidad de acceder a más información de
f para construir algoritmos más inteligentes, por lo que deberemos acceder a oráculos de mayor orden.
Adicionalmente se deben pedir ciertas estructuras en f más fuertes, por ejemplo, convexidad.
Capı́tulo 2
Métodos del Gradiente, Newton y

extensiones
En este capı́tulo abordaremos el problema más simple de optimización: aproximar el mı́nimo de una función
razonablemente “decente”, sin considerar restricciones de ningún tipo. Esto nos llevará a estudiar dos de los
métodos clásicos más famosos, como son los métodos de Gradiente y Newton. Estudiaremos la forma cómo
funcionan y también su comportamiento y convergencia. Estudiaremos también los métodos Quasi-Newton,
que son extensiones que buscan ser más eficientes. Si bien todos estos métodos son antiguos, aún siguen
siendo la piedra central para abordar muchos tipos de problemas.
2.1. La idea del Algoritmo de Descenso

El problema a estudiar para este caso es de la forma:
P) mı́nn f (x)
x∈R
Donde f es, al menos, continuamente diferenciable. La idea consiste en partir de un punto x0 e ir moviéndose
iterativamente a puntos donde el valor de la función objetivo disminuya progresivamente. Con esto en mente,
se define:
Definición 2.1.1: Dirección de Descenso

d 6= 0 se dice dirección de descenso de f si existe r > 0 tal que:
f (x + λd) < f (x), ∀λ ≥ 0, λ ≤ r
Un ejemplo de esto se puede ver en la Figura 2.1, donde en el punto azul que está sobre la curva roja hay
una dirección de descenso en +y.
Alternativamente, d es dirección de descenso si la derivada direccional en la dirección d (el producto punto

de la dirección por el gradiente) es negativo:
dT ∇f (x) < 0
La idea general que surge de aquı́ es desarrollar un algoritmo que se mueva por direcciones de descenso. Esto
es equivalente a lo que un excursionista harı́a bajando un cerro. Podrı́amos ir por un camino que valla hacia
abajo, pero podrı́a pasar que en algún momento dejemos de descender por ese camino especı́fico. Entonces,
es necesario cambiar de dirección. El algoritmo que se muestra a continuación hace eso: se mueve por una
dirección de descenso lo más que se pueda, y después de eso pide una nueva dirección de descenso distinta
a la actual.
9
10 Capı́tulo 2. Métodos del Gradiente, Newton y extensiones
Figura 2.1: Dirección de descenso
Algoritmo del Método básico de Descenso
0. Sea x0 ∈ Rn , k = 0.
1. Sea dk una dirección de descenso en xk .
2. Verificar criterio parada: STOP si se cumple.
3. Sea λk solución óptima de:
mı́n f xk + λk dk ,

(linesearch)
λ≥0
4. Sea xk+1 = xk + λk dk , k ← k + 1. Go to 1.
Normalmente un criterio de parada puede ser una cierta cantidad de iteraciones, un cierto tiempo de computo
o, considerando que en el óptimo ∇f (x∗ ) = 0 y que ∇f (xk )k→∞ −→ 0, un punto donde k∇f (x)k < , para
un predeterminado. A su vez, el linesearch corresponde al paso de avance: cuánto avanzo en la dirección
dk , valor que se obtiene de un problema de optimización que naturalmente es más simple que el problema
original dado que es de solo una variable. Por otro lado, el oráculo es el que da la dirección de descenso d
dado el punto xk en que se esté. Cabe mencionar que esté tipo de algoritmo no garantiza que se encuentre
el mı́nimo global, sino solo uno local. Para tener garantı́a de mı́nimo global, debe existir ciertas propiedades
de convexidad.
Existen diversos métodos que usan este algoritmo básico, utilizando distintos oráculos y distintos enfoques.
Algunos de estos son el Método del Gradiente con dirección de descenso dk = −∇f xk , el de Newton con
−1
dk = − ∇2 f xk ∇f xk y el de Quasi-Newton que tiene otro dk .

2.2. Método del Gradiente
El Método del Gradiente o Método de Cauchy, utiliza un oráculo

de primer orden (necesita las derivadas /
gradientes de f ), pues define la dirección como dk = −∇f xk . Esta dirección corresponde a la de máximo
descenso desde un punto xk .
Francisco Garcı́a y Jorge Vera 2.2. Método del Gradiente 11
Algoritmo del Método del Gradiente
0. Sea x0 ∈ Rn , k = 0 y > 0
1. Dirección de descenso: dk = −∇f xk .

2. Si k∇f (x)k < : STOP.

3. Sea λk solución de:
mı́n f xk + λk dk

λ≥0
T
con λk solución óptima de ∇f xk + λk dk dk = 0
La forma en que los puntos x0 , x1 , x2 , ... van evolucionando es tal que se va avanzando en direcciones
T k+1
ortogonales: ∇xk+1 ⊥ ∇xk , ∀k. El que las direcciones de descenso sean ortogonales implica que dk d =
0 y que por tanto se mueva en “zigzag”, tal como se ve en la Figura 2.2 para dos iteraciones.
Figura 2.2: Dos iteraciones del Método del Gradiente
La prueba de que ∇xk+1 ⊥ ∇xk con ∇xk+1 = xk+1 − xk = λk dk se presenta a continuación. En el paso 3
del Método del Gradiente se encuentra el valor del λ mı́nimo resolviendo el problema:
mı́n f (x + λd)
λ≥0
Cuya solución se encuentra derivando respecto a λ e igualando a cero:
∂f (x + λd)
=0
∂λ
∇f (x + λd)T d = 0
Si λk−1 es la solución del problema de lineasearch correspondiente, entonces como
dk = −∇f xk = −∇f xk−1 + λk−1 dk−1

tenemos que:
T T
−∇f xk−1 + λk−1 dk−1 dk−1 = 0 ⇔ −∇f xk dk−1 = 0
⇔ dkT dk−1 = 0
⇔ dk ⊥ dk−1
⇔ λk dk ⊥ λk−1 dk−1
⇔ ∇xk+1 ⊥ ∇xk
Probándose que la dirección de descenso con el Método del Gradiente avanza de manera ortogonal en cada
iteración.
Ejemplo:
Consideremos el problema:
mı́n f (x1 , x2 ) = 5x21 + x22 + 4x1 x2 − 14x1 − 6x2 + 20
cuya solución óptima es (1, 1) con f (1, 1) = 10.
Para xk dado podemos calcular todo:
−10xk1 − 4xk2 + 14

dk = −∇f (xk1 , xk2 ) =
−2xk2 − 4xk1 + 6
f (xk + λdk ) = 5(xk1 + λdk1 )2 + (xk2 + λdk2 )2 +

4(xk1 + λdk1 )(xk2 + λdk2 ) −
14(xk1 + λdk1 ) − 6(xk2 + λdk2 ) + 20
Luego:
(dk1 )2 + (dk2 )2
λk =
2(5(dk1 )2 + (dk2 )2 + 4(dk1 )(dk1 ))
La siguiente tabla muestra los resultados, partiendo de x0 = (0, 10), con una tolerancia de = 10−6 .
A continuación se muestra un gráfico de f y un mapa de las curvas de nivel, mostrando las iteraciones. Se
puede ver como el avance se hace en direcciones ortogonales.
Francisco Garcı́a y Jorge Vera 2.2. Método del Gradiente 13
Hacemos notar finalmente que, en términos de trabajo, el método es “barato”: en cada iteración sólo requiere
una evaluación del gradiente y resolver el problema de la búsqueda unidireccional, pero ya dijimos que en
la práctica eso puede hacerse en forma aproximada y muy rápida.
A continuación se muestra un códgio Python que implemente el Método del Gradiente para una función de
la forma:
1
f (x) = xT Qx + cT x + α(5 − xn )4
2
import numpy as np
import scipy.optimize
from apendice import generar_datos, subrutina, funcion
def gradiente(Q, c, alpha, x0, epsilon, iteracion maxima):

"""
Esta funcion es una aplicacion del metodo del gradiente. Su entrada posee:
- Q, c y alpha: parametros de la funcion definida.
- x0: punto inicial de prueba.
- epsilon: error/ tolerancia deseada.
- iteracion_maxima: numero maximo de iteraciones.
Su retorno es:
- valor: valor de la funcion evaluada en x en la iteracion actual.
- x: solucion en la que se alcanza el valor objetivo.
"""
# 0: Se definen los parametros iniciales
iteracion, x = 0,x0
m, n = Q.shape
while iteracion <= iteracion_maxima:

# 1: Se obtiene la direccion de descenso
[valor, gradiente] = subrutina(x, Q, c, alpha, m, n, "gradiente")
direccion_descenso = - gradiente
# 2: Se analiza el criterio de parada segun la norma

if np.linalg.norm(gradiente, ord=2) <= epsilon: break
# 3: Se resuelve el subproblema de lambda

lambda_ = scipy.optimize.fminbound(
funcion, 0,10,args=(Q, c, x, alpha, direccion_descenso, n))
# 4: Se actualiza el valor de x para la siguiente iteracion del algoritmo

x, iteracion = x + lambda_ * direccion_descenso, iteracion + 1
return valor, x
if name == "__main__":
np.random.seed(2121)
n = 30
alpha, iteracion_maxima, epsilon, x0 = 10,1000,0.001,np.ones((n, 1))
Q, c = generar datos(n)
valor, x = gradiente(Q, c, alpha, x0, epsilon, iteracion_maxima)
2.3. Método de Newton

Por otro lado, está el Método de Newton, que utiliza un oráculo de segundo orden, pues define la dirección de
−1
descenso como el negativo de la inversa del Hessiano multiplicado por el gradiente: dk = − ∇2 f xk ∇f xk ,

con ∇2 f (x) definida positivo.

Vamos a explicar de dónde viene esta expresión y lo haremos primera para una variable. La idea central es
aproximar el comportamiento de la función f (y) usando el Polinomio de Taylor de segundo orden:
1
f (y) ≈ f (x) + f 0 (x)(y − x) + f 00 (x)(y − x)2
2
Se puede encontrar el mı́nimo de esta aproximación derivando e igualando a cero, considerando que x es
constante e y es la variable:
df (y) 1

d
=0→ f (x) + f 0 (x)(y − x) + f 00 (x)(y − x)2 =0
dy dy 2
f 0 (x) + f 00 (x)(y − x) = 0
f 0 (x)
y =x−
f 00 (x)
De este modo, dado un punto inicial x0 , obtenemos un segundo punto x1 como aquel que es el óptimo de
la aproximación de segundo orden de f (x0 ), de modo que: x1 = x0 − f 0 (x0 )/f 00 (x0 ). Ahora repetimos la
minimización de la aproximación, pero en x1 y el punto siguiente x2 se obtiene como: x2 = x1 −f 0 (x1 )/f 00 (x1 ).
En general, la iteración de puntos es de la forma:
f 0 (xk )
xk+1 = xk −
f 00 (xk )
Una intuición de la evolución de los puntos es la de la Figura 2.3

De manera análoga, para el caso de una función de varias variables, también usamos el polinomio de Taylor,
pero todo debe manejarse en forma vectorial y matricial. La aproximación de segundo orden de una función
f en x es:
1
q(y) = f (x) + ∇f (x)T (y − x) + (y − x)T ∇2 f (x)(y − x)
2
Para encontrar el mı́nimo de esta función se saca su gradiente y se iguala al vector cero:
1

∇q(y) = 0 →∇ f (x) + ∇f (x) (y − x) + (y − x) ∇ f (x)(y − x) = 0
T T 2
2
∇f (x) + ∇2 f (x)(y − x) = 0
y = x − [∇2 f (x)]−1 ∇f (x)
Francisco Garcı́a y Jorge Vera 2.3. Método de Newton 15
Figura 2.3: Avance con el Método de Newton dado la aproximación cuadrática de la función
El valor de y corresponde a el vector que minimiza la aproximación cuadrática de f evaluado en el vector x.

Notemos ahora que para que el método tenga sentido como método de descenso, es necesario que la dirección
cumpla con ser dirección de descenso, es decir:
∇f (xk )T d < 0
−1
En el caso de Newton, como se tiene que dk = − ∇2 f xk ∇f xk , entonces se debe cumplir que:

−1
−∇f (xk )T ∇2 f xk ∇f xk < 0

−1
∇f (xk )T ∇2 f xk ∇f xk > 0

Esto se cumple si [∇2 f (xk )]−1 es una matriz definida positiva y, por lo tanto, ∇2 f (xk ), el Hessiano, también
debe ser definida positiva. Esto se lograr, efectivamente, si f (x) es globalmente convexa.
El siguiente es un pseudo-código del algoritmo:
Algoritmo del Método de Newton
0. Sea x0 ∈ Rn , k = 0 y > 0
−1
1. Dirección de descenso: dk = − ∇2 f xk ∇f xk , con ∇2 f (x) definida positivo.

2. Si ∇f xk ≤ : STOP.

3. Sea λk solución de:

λ≥0
T
con λk solución óptima de ∇f xk + λk dk dk = 0
Si f es convexa, entonces Newton converge desde cualquier punto de partida al mı́nimo de la función. Y si
∇2 f (x) es definida positiva entonces garantiza convexidad estricta local.
El siguiente es un código Python que implementa el Método de Newton. Nótese que la única diferencia con
respecto al que implementa el Método del Gradiente es el punto en donde se elige la dirección de descenso.
import numpy as np
from apendice import generar_datos, subrutina, funcion
def newton(Q, c, alpha, x0, epsilon, iteracion maxima):

"""
Esta funcion es una aplicacion del metodo de Newton. Su entrada posee:
- Q, c, alpha: parametros de la funcion definida.
- x0: punto inicial de prueba.

- epsilon: error/ tolerancia deseada.
- iteracion_maxima: numero maximo de iteraciones.
Su retorno es:
- valor: valor de la funcion evaluada en x en la iteracion actual.
- x: solucion en la que se alcanza el valor objetivo.
"""
# 0: Se definen los parametros iniciales
iteracion, x = 0,x0
m, n = Q.shape
while iteracion <= iteracion_maxima:

# 1: Se obtiene direccion de descenso
[valor, gradiente, hessiano] = subrutina(x, Q, c, alpha, m, n, "newton")
direccion_descenso = np.dot(-np.linalg.inv(hessiano), gradiente)
# 2: Se analiza el criterio de parada segun la norma

if np.linalg.norm(gradiente, ord=2) <= epsilon: break
# 3: Se resuelve el subproblema de lambda

lambda_ = scipy.optimize.fminbound(
funcion, 0,10,args=(Q, c, x, alpha, direccion_descenso, n))
# 4: Se actualiza el valor de x para la siguiente iteracion del algoritmo

x, iteracion = x + lambda_ * direccion_descenso, iteracion + 1
return valor, x
n = 30
alpha, iteracion_maxima, epsilon, x0 = 10,1000,0.001,np.ones((n, 1))
Q, c = generar datos(n)
valor, x = newton(Q, c, alpha, x0, epsilon, iteracion_maxima)
Cápsula de video 2.3.1: Los Métodos de Descenso
Profesor Jorge Vera explica en clases lo que está detrás de los métodos de descenso, en particular del
Método del Gradiente y el Método de Newton:
https: // youtu. be/ Eow_ 2jmRU6g
2.4. Midiendo la eficiencia de un algoritmo

Una de los temas que más nos interesaran en este curso es la eficiencia computacional de los distintos
algoritmos. Para esto, necesitaremos estimar de qué forma las distintas iteraciones se van acercando a la
meta. En esta sección introduciremos algunos elementos de la medición de convergencia, que se conocen como
“tasas de convergencia”. Posteriormente veremos cómo se comportan los métodos que ya hemos comentado.
Supongamos que un algoritmo ha generado puntos x0 , x1 , . . . , xk a lo largo de las iteraciones, (que se puede
expresar como x ). Vamos a suponer que
k
k esta sucesión efectivamente se acerca a la solución óptima x∗ .
Entonces, la diferencia entre la sucesión x y x disminuye a medida que se itera más (k aumenta), es
∗
decir, converge a 0.
Francisco Garcı́a y Jorge Vera 2.4. Midiendo la eficiencia de un algoritmo 17
Definición 2.4.1: Convergencia Lineal
Se dice que la sucesión xk ) converge a x∗ en forma lineal si

xk+1 − x∗ 2
≤ α xk − x∗ 2
, k = 1, 2, ...
Donde 0 < α < 1.
El valor de α depende las propiedades de la función. Esto significa que el error que se tiene en la iteración
k + 1 es menor a una proporción α del error que se tenı́a en la iteración k.
Definición 2.4.2: Convergencia Cuadrática
Decimos que la sucesión xk ) converge a x∗ en forma cuadrática si

2
xk+1 − x∗ 2
≤ β xk − x∗ 2
, k = 1, 2, ...
para una constante β > 0.
Nótese que como la sucesión xk converge a x∗ , entonces kxk − x∗ k2 converge a 0, por lo que al estar el

término de error al cuadrado es más pequeño y ası́ la diferencia de las soluciones respecto a x∗ converge más
rápidamente que con la convergencia lineal. La convergencia cuadrática es más rápida que la lineal, en el
sentido que requiere menos iteraciones para llegar a la misma meta de error, como mostraremos ahora.
Se puede determinar una cota mı́nima para el número de iteraciones k que se deben hacer para llegar a
un determinado error > 0. En el caso de la convergencia lineal, este valor se puede calcular del siguiente
modo: Sea ek = kxk − x∗ k2 , luego por definición de la convergencia lineal:
ek ≤ αek−1 , k ∈ Z+
0
Desarrollándose múltiples veces la expresión anterior se obtiene:
ek ≤α[αek−2 ]
≤α2 ek−2
≤α3 ek−3
..
.
≤αk e0
Donde e0 = kx0 − x∗ k2 . Luego, para que ek ≤ , basta pedir que αk e0 ≤ . Esto quiere decir que la cantidad
de k iteraciones que se deben realizar para alcanzar dicha convergencia es de:
α k e0 ≤

αk ≤
e0

k ln(α) ≤ ln
e0
1 e
0
k≥ ln
| ln(1/α)|
Lo que importa acá es ver como depende del , tal como se ve, la cantidad de iteraciones que se deben
realizar es de orden de log(1/), lo cual se denota de la siguiente forma:
1

O log

Esto corresponde a la complejidad de la convergencia lineal. Mientras más pequeño es , más iteraciones se
deben hacer como era de esperarse.
Para el caso de la convergencia cuadrática, el valor de la cota mı́nima de iteraciones k que se deben hacer
para alcanzar un error máximo de se calcula de modo análogo: Sea ek = |xk − x∗ k2 , luego por definición
de la convergencia cuadrática, podemos plantear la siguiente desigualdad:
ek ≤ βe2k−1 , k ∈ Z+
0
Desarrollando múltiples veces la expresión anterior se obtiene:
ek ≤βe2k−1
2
≤β βe2k−2

≤β 3 e4k−2
..
.
k
−1 2k
≤β 2 e0
Nos interesa saber cuántas iteraciones debemos realizar para asegurar un error ≥ 0, es decir:
k
−1 2k
β2 ≤ e0
2 − 1 ln(β) + 2 ln (e0 ) ≤ ln()
k k

2k ln(β) + 2k ln (e0 ) − ln(β) ≤ ln()

2k [ln(β) + ln (e0 )] ≤ ln(β) + ln()
2k ln (βe0 ) ≤ ln(β)
Como e0 > , podemos plantear tres escenarios. Los dos primeros son escenarios que no resultan posibles:
(1) βe0 > 1 ∧ β > 1 : (2) βe0 > 1 ∧ β < 1 :

ln(β) ln(β)
2k ≤ <1⇒k<0 2k ≤ <0
ln (βe0 ) ln (βe0 )
que es una contradicción, ya que k ∈ Z+
0. lo cual es una contradicción.
El tercer escenario sı́ es posible:

(3) βe0 < 1 ∧ β < 1:1
ln(β)
2k ≥ >1
ln (βe0 )
1 ln(β)

k≥ ln
ln(2) − |ln (βe0 )|
1 ln(1/β)

k≥ ln
ln(2) |ln (βe0 )|
De este modo, la cantidad de iteraciones que se deben realizar en el caso de un algoritmo de convergencia
cuadrática es del orden de:
1

O log log

1 Notar que como se sabe que ln (βe0 ) es negativo, entonces: ln (βe0 ) = − |ln (βe0 )|. Esto se utiliza en el segundo cálculo.
Cápsula de video 2.4.1: Tasas de convergencia
Profesor Jorge Vera explica en clases los detalles y el significado de las tasas de convergencia lineal
y cuadráticas:
https: // youtu. be/ DR_ s9HCK15Y
2.4.1. Convergencia del Método del Gradiente

En esta sección vamos a ilustrar que el Método del Gradiente tiene convergencia lineal. Esto lo haremos
para un problema cuadrático estándar:
1 T
mı́n f (x) = x Qx + cT x ,
x∈Rn 2
donde Q es una matriz definida positiva y simétrica Q = QT . Vamos a ilustrar lo que ocurre con dos casos

particulares de esta función:
Caso 1:
20 5 14

Q1 = ,c =
5 1 6
Caso 2:
20 5 14

Q2 = ,c =
5 16 6
A continuación mostramos tablas que indican las sucesivas iteraciones del método y la convergencia:
Para el Caso 1:
Para el Caso 2:
Podemos observar que en el caso 1 la convergencia es significativamente más lenta. Para entender esto es
interesante observar cómo son las curvas de nivel de la función objetivo. Estas se muestran en las siguientes
figuras:
Para el Caso 1:
Para el Caso 2:
Podemos observar que en el caso 1, las curvas de nivel son mucho más “excéntricas” que en el caso 2. Eso
hace que, dado que el método avanza en direcciones ortogonales, se produzca un significativo “zigzagueo” a
medida que avanzan las iteraciones. La información respecto a la excentricidad está contenida en la matriz
Q.
Sean µmax y µmin el mayor y menor valor propio de Q respectivamente. Sea
µmax
κ(Q) =
µmin
Este valor se conoce como el “número de condicionamiento” de la matriz Q.

Teorema 2.4.1: Convergencia lineal del Método del Gradiente
Si Q es definida positiva, entonces

2
κ(Q) − 1

f (xk+1 ) − f (x∗ ) ≤ (f (xk ) − f (x∗ )), k = 1, 2 . . .
κ(Q) + 1
Mientras mayor sea κ(Q) más excéntricas son las curvas de nivel, y la convergencia del algoritmo es más
lenta. En el ejemplo tenemos que para el caso 1, κ(Q1 ) = 90, 1 mientras que para el caso 2, κ(Q2 ) = 1, 85
y eso se refleja en las diferencias de convergencia. De hecho, si las curvas de nivel fueran cı́rculos perfectos,
la convergencia es inmediata en una iteración ya que todas las direcciones −∇f (x) apuntan a centro común
de las curvas de nivel, que es la solución óptima.
Dado > 0, podemos seguir el desarrollo del comienzo de la sección y concluir que el número de iteraciones
necesario para llegar a ese error es
1 1 κ(Q) + 1

k=O log ,α =
log(α) κ(Q) − 1
El análisis que hemos presentado acá es para el caso de una función cuadrática, pero puede extenderse a una
función convexa cualquiera. En efecto, si f es convexa y x∗ es su mı́nimo global, ya sabemos que una función
puede aproximarse mediante su polinomi de Taylor de orden 2. Esa aproximación suele ser muy buena en el
caso de funciones cuadráticas, ası́ que tendremos que, en torno a x∗ :
1
f (y) ≈ f (x∗ ) + ∇f (x∗ )T (y − x∗ ) + (y − x∗ )T ∇2 f (x∗ )(y − x∗ )
2
Entonces, si el punto inicial x0 está suficientemente cerca de x∗ podemos pensar que el problema de minimizar
f es muy similar al de minimizar su aproximación cuadrática. Entonces, en este caso, la velocidad de
convergencia estará gobernada por las propiedades de ∇2 f (x∗ ), más especı́ficamente, por su condicionamiento.
Se puede probar formalmente que este argumento es correcto pero ese desarrollo escapa del nivel de este curso.
2.4.2. Cambios de variable para mejorar el condicionamiento

Existen formas que permiten solucionar (aunque sea parcialmente) el problema de la fuerte dependencia
del la eficiencia del método del gradiente en el condicionamiento del Hessiano. Aquı́ ilustramos una de esas
formas, que es mediante un cambio de variables.
Sea f (x) = 21 xT Qx + bT x donde Q es simétrica y definida positiva. Consideremos un cambio de variable de
la forma x = Ay, donde A ∈ Rn×n asumiremos que es invertible. Sea g(y) = f (Ay). La función transformada
por el cambio de variable es:
1 1
g(y) = (Ay)T Q(Ay) + bT (Ay) = y T AT QAy + bT Ay
2 2
Dado que Q es una matriz simétrica y definida positiva, podemos utilizar su diagonalización y reemplazar
en la expresión anterior por Q = B T DB:
1 T T
g(y) = y A B T DB Ay + bT Ay

2
Sea Q̄ = AT B T DB A, notemos que si Q̄ es una matriz diagonal, obtenemos una función cuadrática con

un término lineal adicional que solamente desplaza y/o amplı́a la curva. Por lo tanto, queremos que Q̄ sea
diagonal. Para que se cumpla lo anterior, BA = I, es decir, A = B −1 . Estos nos lleva a la siguiente expresión
cuadrática:
1 T
g(y) = y Dy + bT B −1 y
2
Ahora, buscamos una transformación que nos lleve a la forma cuadrática 12 z T z. Para ello podemos aplicar
el cambio de variable, y = D−1/2 z. Finalmente, combinando ambas transformaciones, obtenemos que
−1
A = BD1/2 . Dicha transformación garantiza que el método del gradiente converja en una iteración.
Por supuesto, tenemos que diagonalizar Q para lograra esto, lo cual es un proceso numérico bastante
intensivo. Existen métodos más económicos que obtienen parcialmente información de la diagonalización de
Q y permiten construir una matriz adecuada para el cambio de variable e igual mejorar significativamente
en comportamiento de método, pero no los estudiaremos aquı́. Todo este proceso es muy importante en
optimización numérica y se se suele llamar “precondicionamiento” del problema.
2.4.3. Velocidad de convergencia para el Método de Newton

En cuánto a la convergencia en el Método de Newton, existe el siguiente teorema:
Teorema 2.4.2: Convergencia del Método de Newton
Sea f dos veces continuamente diferenciable, x∗ un mı́nimo local de f y tal que ∇2 f (x∗ ) sea definida
positiva. Supongamos además que existen r > 0 y L > 0 tales que la variación de los hessianos en el
entorno de x∗ se encuentra acotado:
∇2 f (x) − ∇2 f (y) ≤ Lkx − yk, ∀x, y ∈ B (x∗ , r)

Entonces, existe γ > 0 tal que si x0 − x∗ < γ, tal que la sucesión xk k generada por el método

converge a velocidad cuadrática, es decir, existe β > 0 tal que:

2
xk+1 − x∗ ≤ β xk − x∗ , ∀k = 0, 1, . . .
Si f es convexa, y por lo tanto tiene mı́nimo, entonces Newton converge desde cualquier punto de partida
al mı́nimo de f . Si el Hessiano ∇2 f (x), es definida positiva para todo x, entonces la función es convexa y se
garantiza lo anterior. Si por lo menos en el óptimo x∗ , ∇2 f (x∗ ) es definida positiva, entonces al menos se
garantiza “convexidad estricta local” ya que la función es convexa en el entorno de x∗ .
Una de las condiciones que pide el teorema acota la norma de la variación de los Hessianos de f , proporcional
a la diferencia de los puntos donde se evalúan los Hessianos:
∇2 f (x) − ∇2 f (y) ≤ Lkx − yk, ∀x, y ∈ B (x∗ , r) ,
lo que es una condición de Lipschitz local para ∇2 f . Si L es pequeño, entonces la variación de la curvatura
en f es pequeña. Si L es demasiado grande entonces γ tiene que ser demasiado pequeño y, por lo tanto,
x0 − x∗ es muy pequeño y entonces tendremos que partir muy cerca del óptimo para que Newton funcione.
De este modo, cuando f tiene un comportamiento muy caótico, se debe partir iterando cerca del óptimo
para garantizar la convergencia. Por otro lado, k∇2 f (x∗ )− 1k2 , al igual que L, influye en el valor de β y γ,
pues debe estar acotada para garantizar la convergencia cuadrática. Esto ya que, en caso contrario, en el
entorno del óptimo f será muy plana y Newton no funciona tan bien. Ejemplo de esto último es la función
de una variable f (x) = x4 . Es fácil deducir que f es perfectamente convexa y el mı́nimo es x = 0, pero
f 00 (0) = 0 (el Hessiano NO es definida positiva) y la convergencia al óptimo es sólo lineal, no cuadrática.
2.4.4. Costo por iteración del Método del Gradiente y Newton

Hasta el momento lo que hemos analizado es el número de iteraciones que requiere un algoritmo para llegar
a la meta, digamos, una solución -aproximada o -óptima. Sin embargo, esto no nos dice mucho respecto a
cuánto tiempo real (tiempo de reloj) tardaremos en lograr esa meta. Esto es porque el costo en tiempo por
iteración puede ser diferente según el método. Más en especı́fico, el tiempo total para llegar a una meta es
la cantidad de iteraciones multiplicado por el tiempo de iteración.
Tiempo total = n° iteraciones × tiempo por iteración
El tiempo por iteración se estima en proporción a la cantidad de operaciones aritméticas de punto flotante
que el procesador de nuestro computador debe realizar. Operaciones de punto flotante son las sumas, restas,
multiplicaciones y divisiones. A esto es a lo que se llama “flop”, que es un acronismo de “floating point
Francisco Garcı́a y Jorge Vera 2.5. Linesearch: Selección del paso 23
operation”. En genral, se considera que la verdadera sobrecarga de tiempo viene de las multiplicaciones y
divisiones, las sumas y restas son despreciables, en términos comparativos.
En lo que sigue estimaremos el costo por iteración, el flops, de cada uno de los métodos (gradiente y Newton),
concentrándonos fundamentalmente en las multiplicaciones. En cada una de las iteraciones, cada uno de los
métodos utiliza una forma distinta de calcular el punto siguiente (xk ) según donde se está (xk+1 ). En el caso
del Método del Gradiente este es:
xk+1 = xk − λ∇f xk

lo que implica una suma y una multiplicación por cada coordenada, y hay n de ellas. Esto nos da un esfuerzo
de O(n) “flops”. Es importante hacer notar que aquı́ no estamos contando el detalle de las operaciones
necesarias para evaluar ∇f (x), estamos suponiendo que es un valor constante en términos de tiempo, de decir,
es O(1). Un análisis más completo deberı́a considerarlo pero eso dependerá de cada problema particular. En
Ciencias de la Computación se dice que estamos usando un “modelo de caja negra” donde la caja negra es
el oráculo que nos entrega el valor del gradiente, en tiempo fijo.
Con Newton la dirección es diferente y tenemos que invertir el Hessiano y multiplicarlo por el gradiente,
pues el punto siguiente en una iteración es:
xk+1 = xk − λ[∇2 f (xk )]−1 ∇f xk

lo que implica que se debe invertir una matriz utilizando algún método como lo es la Eliminación de
Gauss-Jordan. Esta operación en particular es de orden de O(n3 ) flops, lo que puede ser considerablemente
superior al orden del Método del Gradiente, sobre todo cuando la dimensión del problema (valor de n) es
grande. Es por esto que si bien Newton tiene un orden de la cantidad de iteraciones inferior al del Gradiente,
los tiempos invertidos en cada iteración puede ser miles de veces superior.
Con todo esto, el tiempo total de cada uno de los métodos tiene un tiempo total que es proporcional a:
1

Tiempo total Gradiente = cteG × log ×n

1

Tiempo total Newton = cteN × log log × n3

donde cteG y cteN son constantes que dependen de cada método pero no de la dimensión n.
Esto muestra el balance que se produce entre número de iteraciones y costo por iteración. Para n grande, el
factor n3 puede no ser suficientemente compensado por el doble logaritmo y puede resultar que el Método
del Gradiente termine usando menos tiempo efectivo.
Cápsula de video 2.4.2: Costo computacional de los métodos
Profesor Jorge Vera explica en clases las diferencias en costo computacional de los métodos de
gradiente y Newton:
https: // youtu. be/ olweRbMOXxw
2.5. Linesearch: Selección del paso

Los algoritmos de descenso vistos requieren resolver la etapa del “paso de avance” o linesearch, que consiste
en buscar el mı́nimo en un espacio unidireccional (una linea). Esta etapa es en la que se busca el valor de
λk que resuelva:

λ≥0
Meter un subproblema de optimización dentro de cada una de las iteraciones del problema principal puede
ser inconveniente en término del tiempo en que se ejecuta el algoritmo, esto a pesar que es un problema de
optimización en una sola variable. Ante esto, cabe decir que existe la posibilidad de relajar la búsqueda de
este paso λk .
Se han desarrollado varios métodos para realizar el linesearch, que trabajan sobre la función h(λ) =
f xk + λdk .2 .

2.5.1. Métodos de búsqueda

Estos métodos utilizan procesos de aproximación rápida para obtener una solución al paso. Revisemos
brevemente algunos de ellos.
Búsqueda de la Sección Áurea

Este método utiliza un oráculo de orden cero (solo usa solo valores de f ) y su desempeño es eficaz en la
medida que f sea “unimodal”, vale decir, que tiene solo un mı́nimo local en el intervalo de búsqueda [x1 , x3 ].
La búsqueda se realiza del siguiente modo (ver Figura 2.4): En primer lugar, se comienza con los puntos x1
y x3 que definen al intervalo, posteriormente se elige un punto x2 , ente x1 y x3 tal que esté a unidades a
la derecha de x1 y b unidades a la izquierda de x3 . También se elige un punto x4 que esté c unidades a la
derecha de x2 .
Figura 2.4: Búsqueda de Sección Áurea
Estos puntos deben estar esparcidos por la linea de búsqueda, tal que se eligen del siguiente modo que:
c a c a
= y que =
a b b−c b
De esto se obtiene que:
2
b b
− =1
a a
Resolviendo esta ecuación cuadrática, se obtiene que la razón entre b y a debe ser el número áureo:
√
b 1+ 5 a b
= = 1,618 −→ = =φ
a 2 c a
Para elegir los siguientes puntos a evaluar se utiliza un algoritmo que estudie siempre tres puntos y busque
un cuarto punto entre medio según la sección áurea. En el caso que se muestra en la imagen, se debe elegir
el conjunto de los próximos tres puntos sobre los que hacer la búsqueda de sección áurea del siguiente modo:
1. Si f (x4 ) < f (x2 ) −→ seguir buscando sobre el conjunto {x2 , x4 , x3 }
2. Si f (x4 ) > f (x2 ) −→ seguir buscando sobre el conjunto {x1 , x2 , x4 }
2 En Python, la subrutina del linesearch se puede hacer mediante la función de la librerı́a Spicy: scipy.optimize.fminbound.
Y con Matlab: fminbnd. Ambas utilizan condiciones de tipo Wolfe-Armijo.

Francisco Garcı́a y Jorge Vera 2.5. Linesearch: Selección del paso 25
Bisección
Este método utiliza un oráculo de primer orden (usa el valor de las derivadas de f ) y su desempeño es eficaz
en la medida que f sea “unimodal”, vale decir, que tiene solo un mı́nimo local en el intervalo de búsqueda
[t1 , t3 ], de este modo, se busca el punto t∗ , tal que h0 (t∗ ) ≈ 0. La búsqueda se realiza del siguiente modo
(ver Figura 2.5): En primer lugar, se comienza evaluando la derivada en los puntos t1 y t3 que definen al
intervalo, posteriormente se evalúa la derivada en un punto t2 intermedio y equidistante de t1 y t3 . En caso
que h0 (t2 ) > 0, entonces se continúa iterando del mismo modo, pero esta vez buscando entre t1 y t2 . Si
h0 (t2 ) < 0 entonces se continúa iterando del mismo modo, buscando entre t2 y t3 .
Figura 2.5: Bisección
Interpolación
Supongamos tenemos dos puntos, t1 , t2 tales que conocemos h (t1 ) , h (t2 ) y h0 (t1 ) . Se puede interpolar una
función cuadrática g(t) y minimizarla.
Sea g(t) = at2 + bt + c. Se puede formar el siguiente sistema de ecuaciones:
2
h (t1 ) = a (t1 ) + b (t1 ) + c
2
h (t2 ) = a (t2 ) + b (t2 ) + c
h0 (t1 ) = 2a (t1 ) + b
Resolviendo este sistema tenemos a, b, c y ası́ conocemos g. Ahora minimizamos g(t) = at2 + bt + c. Si f es
unimodal o convexa, entonces a > 0 y el mı́nimo se obtiene derivando g(t) e igualando a 0: g 0 (t) = 2at+b = 0,
de donde se obtiene que el mı́nimo t3 de esta interpolación cuadrática es:
b
t3 = −
2a
Se evalúa h0 (t3 ) y se decide continuar con el intervalo [t1 , t3 ] o[t3 , t2 ] y ası́ sucesivamente. Se podrı́an hacer
cosas más complejas como interpolación cúbica, pero que hace que el algoritmo sea más lento por iteración.
2.5.2. Condición de Wolfe-Armijo

Los métodos anteriores pueden encontrar una solución al paso con toda la precisión que se desee. Ahora
haremos notar que, en realidad, no es necesario tener una solución precisa, basta que se cumplan ciertas
condiciones. Esto fue establecido por P. Wolfe y R. Armijo en la década de 1970 y lo revisaremos brevemente
ahora.
T
Sea la función h(λ) = f xk + λdk y h0 (λ) = ∇f xk + λdk dk . Un valor λ cumple con las condiciones de

Wolfe y Armijo si:
h(λ) ≤ h(0) + c1 λh0 (0) (condición de Armijo)

h0 (λ) ≥ c2 h0 (0) (condición de Wolfe)
Donde 0 < c1 < c2 < 1. La primera condición corresponde a que h(λ) está acotado por abajo por la linea
h(0) + c1 λh0 (0), mostrada en azul en la Figura 2.6. La segunda condición dice que la pendiente en el nuevo
punto debe ser menos negativa que la del punto original en la dirección de la linea en cuestión (pendiente
mostrada en verde). Todo esto da un intervalo donde se cumplen ambas condiciones y se puede mostrar que
utilizando este paso, tanto el método de gradiente como el método de Newton convergen.
Figura 2.6: Condición de Wolf-Armijo
La condición de Armijo garantiza un mı́nimo decrecimiento de la función objetivo y la condición de Wolfe

garantiza un mı́nimo avance. Los valores adecuados de c1 y c2 se pueden encontrar en la literatura. Suelen
elegirse en base a la experiencia según el problema. El valor de λ se obtiene iterando con backtracking, de
modo que se parte con un λ inicial y se va iterando este valor hasta que se encuentra uno que satisfaga las
condiciones. Esto tı́picamente se puede hacer como:
λk+1 = ρλk , 0<ρ<1
Si es que cae al lado izquierdo del intervalo, ahı́ se utiliza un valor de ρ > 1 para acercarse al intervalo.
Ejemplo algoritmo de Wolfe-Armijo con backtraking
0. Data: Sea λ0 = b, k = 0
1. if h(λk ) ≤ h(0) + λk c1 h0 (λk ), entonces se cumple Armijo do
if h0 (λk ) ≥ c2 h0 (0), entonces se cumple Wolfe do
STOP.
λk+1 ← (λk + λk+1 )/2
Go to 1.
2. λk+1 = ρλk , 0 < ρ < 1, k ← k + 1, Go to 1.
Cabe mencionar que el ejemplo de la figura es de una función convexa y en esa situación existirá siempre
un intervalo en donde se puede elegir el paso. Sin embargo, si la función no es convexa, puede haber más de
un intervalo válido.
El punto que se obtiene mediante Wolfe-Armijo no es un punto en que necesariamente h0 (λ) ≈ 0, tal como
los otros métodos mencionados. Es por esto que no es necesario optimizar y se puede llegar a un punto más
relajado, pero lo importante es que es un punto que tiene un valor inferior al punto inicial y que es económico
de obtener en términos computacionales.
Cápsula de video 2.5.1: Linesearch y Condiciones de Wolfe-Armijo
Profesor Jorge Vera explica en clases las Condiciones de Wolfe y Armijo y la importancia del problema
de Linesearch:
https: // youtu. be/ apoI2SOuvTc
Francisco Garcı́a y Jorge Vera 2.6. Métodos Quasi-Newton 27
2.6. Métodos Quasi-Newton

Como comentamos en la sección anterior, el Método de Newton es muy potente debido a su convergencia
cuadrática. Sin embargo, el costo por iteración es muy alto y esto puede traducirse en ineficiencias. Desde
el comienzo de los desarrollos de algoritmos computacionales surgió la meta de desarrollar métodos que
tuvieran propiedades similares al método de Newton pero con un menor costo por iteración. Esto dió origen
a los métodos Quasi-Newton que reviseramos, brevemente, ahora.
2.6.1. Métodos Quasi-Newton: BFGS

Un Método Quasi-Newton busca disminuir el costo computacional de invertir la matriz en cada iteración, a
costa de hacer más iteraciones. Para esto, se aproxima el hessiano ∇2 f xk a una matriz “similar” B k ,
igualmente simétrica y definida positiva, pero con mejores propiedades para invertirla. De hecho, la inversa
se podrá calcular con una complejidad orden O n2 . De este modo, la dirección de descenso queda definida

como:
−1
dk = − B k ∇f xk

Y el paso siguiente como:
−1
xk+1 = xk − λ B k ∇f xk

Para definir B k adecuadamente se recurre al Teorema del Valor Medio, como explicamos a continuación.
Utilizando los gradientes y el hessiano de f , entre dos soluciones consecutivas de las iteraciones xk y xk+1
podemos plantear lo siguiente:
∇f xk+1 − ∇f xk ≈ ∇2 f xk+1 xk+1 − xk

Dado que la matriz ∇2 f xk+1 cumple esa propiedad y queremos que B k tenga las mismas propiedades del

Hessiano, imponemos elegir B k tal que cumpla con:
∇f xk+1 − ∇f xk = B k+1 xk+1 − xk

Sean: sk = xk+1 − xk y yk = ∇f xk+1 − ∇f xk . Luego, la expresión anteriormente encontrada se puede

escribir como:
yk = B k+1 sk
Esta expresión se conoce como “la condición de secante”. Además se requiere que B k+1 sea definida positiva
y simétrica.
Como la condición de secante tiene infinitas soluciones, se calcula el B k+1 de modo que sea lo más parecido
posible a B k , por lo que se resuelve el siguiente problema de optimización:
mı́nB B − Bk
s.a. B = BT
Bsk = yk
Obtener una solución de este problema que sea definida positiva solo es posible si se cumple la condición de
curvatura: sTk yk > 0. Al final de esta sección (?) se discute esto en más detalle.
La resolución de este problema de optimización requiere conceptos avanzados de análisis matricial (se resuelve
con Lagrange y está en el libro guı́a de J. Nocedal), pero lo importante es que tiene una solución explı́cita
si se utiliza una norma matricial adecuada. Con un desarrollo idéntico al expuesto, se puede formular una
−1
aproximación para el inverso del hessiano [∇2 f xk ]−1 , ya que la inversa de B k , que es B k , es lo que

k −1
realmente interesa. De este modo, se define H como B , donde el valor de H está dado por la
k
k+1
siguiente fórmula:
1
H k+1 = I − ρk sk ykT H k I − ρk yk sTk + ρk sk sTk , donde ρk = >0

ykT sk
Esto se conoce como la fórmula de Broyden-Fletcher-Goldfarb-Shanno o BFGS, por sus creadores, que la
desarrollaron en la década de 1980. Como ρk > 0, entonces la matriz a calcular H k+1 es definida positiva.
Algoritmo BFGS
0. Sea x0 ∈ Rn , H 0 ∈ Rn×n , k = 0, > 0.

1. Dirección de descenso: dk = −H k ∇f xk
2. Si ∇f xk ≤ : STOP.

3. Calcular λ por linesearch que cumpla Wolfe-Armijo.

4. Definir xk+1 = xk + λk dk .
5. Calcular H k+1 por BFGS, k ← k + 1. Go to 1.
−1
Para el valor de H 0 , se puede calcular el hessiano en la primera iteración ∇2 f x0 u otra aproximación,

incluso puede ser H 0 = I. Esto último puede pensarse como muy ineficiente pero funciona igual ya que
el método poco a poco va añadiendo información de segundo orden cuando usa la fórmula basada en el
Teorema del Valor Medio.
2.6.2. Eficiencia de BFGS

Por otro lado, ası́ como el Método del Gradiente evaluaba O(n) “flops” en cada iteración, y Newton O(n3 ),
BFGS evalúa O(n2 ) “flops”, lo que mostramos a continuación:
1. dk = −H k ∇f xk , es O(n2 )

2. ρk = ykT sk , es O(n)
3. ρk = sk sTk es O(n2 )
4. Cuidando de nunca multiplicar una matriz por otra matriz, ya que eso lo aumenta O(n3 ): cuando
se calcula H I − ρk yk sk , se debe hacer en el siguiente orden inteligente: (I − ρk sk ykT )(H k −
k T

ρk (H k yk )sTk ), de modo que:

i. w = H k yk , es O(n2 )
ii. V = wstk , es O(n2 )
iii. U = H k − ρV , es O(n2 )
iv. z T = ykT U , es O(n2 )
v. T = sk z T , es O(n2 )
vi. H k+1 = U − ρT , es O(n2 )
Cápsula de video 2.6.1: Costo Computacional de BFGS
Profesor Jorge Vera explica en clases por qué el costo computacional por iteración del Método BFGS
es O(n2 ).
https: // youtu. be/ h3JvfViUxUg
Se puede probar que BFGS converge a un mı́nimo local, si el punto inicial está “suficientemente cerca” del
óptimo, y la función es “bien comportada” y el hessiano es definido positivo, localmente en torno al óptimo,
y la función es convexa. La velocidad de convergencia no va a ser mejor que el método de Newton, pero si
que la del método del Gradiente. Si x∗ es mı́nimo local, ∇2 f (x∗ ) es definida positiva, y existe r > 0 tal que:
∇2 f (x) − ∇2 f (y) ≤ Lkx − yk, ∀x, y ∈ B (x∗ , r)
entonces se puede mostrar que si xk es la sucesión generada por BFGS, se cumple:

k
Francisco Garcı́a y Jorge Vera 2.6. Métodos Quasi-Newton 29
xk+1 − x∗
lı́m =0
k→∞ kxk − x∗ k
Esta relación implica que el error de la iteración k + 1, ek+1 , se va más rápido a cero que el error de la
iteración k, ek . De hecho, existe una sucesión de valores {αk }k , con αk → 0, cuando k → ∞, tal que:
xk+1 − x∗ ≤ αk xk − x∗ , k = 0, 1, . . .
Notar que esto es similar a la convergencia lineal, pero con la diferencia que el factor que multiplica el lado
derecho ya no es una contante, sino que una sucesión que converge a cero, por lo que el error disminuye más
rápido que a una tasa fija, pero no más rápido que el cuadrático de Newton. Esto se llama convergencia
súper-lineal, lo que es mucho mejor que convergencia lineal pero no es tan rápido como la convergencia
cuadrática. En general sucede que BFGS realiza más iteraciones que Newton pero menos que el Gradiente.
Al final, igual es mucho mejor que Newton para problemas grandes debido a que es O(n2 ), que es mucho
mejor que Newton (O(n3 )). En general es tan bueno que en Matlab y en Python se suele utilizar BFGS por
defecto para problemas no restrigidos. No se puede saber si BFGS es de orden O( 1 ).
Uno de los problemas importantes es que para n grande hay que almacenar toda la matriz H k , para eso se
utiliza el limited memory BFGS (L-BFGS) que guarda en memoria solo una parte de H k , con esto no se
acumulan todos los sk , yk , sino solo una cantidad fija de ellos, lo que mantiene la aproximación de H k . Esta
“aproximación de la aproximación” suele funcionar muy bien.
Apéndice
Demostración de que BFGS con la regla de Wolfe-Armijo cumple con ykT sk > 0:
En primer lugar, hay que considerar los siguientes tres aspectos:
(1): sk = xk+1 − xk
(2): xk+1 = xk + λk dk
sk
(1) + (2): dk = ⇔ dk λk = sk
λk
(3): yk = ∇f xk+1 − ∇f xk

Donde dk es dirección de descenso en xk . La idea es partir de la regla de Wolfe-Armijo, y demostrar que

ykT sk > 0, para lo cual hay que llegar a una expresión similar a (3) multiplicada por sk : Por la regla de
Wolfe-Armijo, el paso λk satisface:
T T
∇f xk + λk dk dk ≥ c2 ∇f xk dk
k+1 T k T

∇f x dk ≥ c2 ∇f x dk
k+1 T sk k T

∇f x λk ≥ c2 ∇f x dk
k+1 T T
T
∇f x sk ≥ c2 λk ∇f xk dk / − ∇f xk sk
k+1 T k T
T T
∇f x sk − ∇f x sk ≥ c2 λk ∇f xk dk − ∇f xk sk
T
T k T T
∇f xk+1 − ∇f xk s ≥ c2 λk ∇f xk dk − ∇f xk dk λk
T
ykT sk ≥ (c2 − 1) λk ∇f xk dk
T
Por último, como dk es dirección de descenso en xk , tenemos que ∇f xk dk < 0, y como (c2 − 1) < 0, es
posible concluir que el lado derecho es positivo.
Todo lo expuesto en este capı́tulo corresponde a algunos de los métodos “clásicos”, desarrollados mucho
tiempo atrás, aún ası́, la idea de avanzar por una dirección de descenso, usar gradiente y hessiano e iterar
está muy vigente. Pero la optimización moderna requiere enfoques nuevos para los nuevos problemas del
Internet, el Big Data, etc. Estos problemas se han reenfocado en los últimos tiempos. Ese es el próximo
capı́tulo.
2.7. Ejemplos
2.7.1. Aplicación en IA: Optimización de Redes Neuronales
Las Redes Neuronales son un modelo de gran importancia en Machine Learning y son usadas para abordar
problemas de predicción, reconocimiento de patrones, etc. La idea fundamental de una red neuronal está
inspirada en la estructura del cerebro: una red de neuronas interconectadas que se envı́an información.
Se recomienda para entender en más detalle, ver en el canal de Youtube 3Blue1Brown. De ese modo, se
implementa un mecanismo de cálculo que permite estimar una función matemática f , de n variables, de la
que sólo se conoce su valor en algunos puntos. Presentamos aquı́ un modelo básico de una red neuronal: la red
neuronal consiste en un conjunto de nodos de “input”, I = {1, 2, . . . , n}, un conjunto de nodos intermedios,
C = {1, . . . , m}, y un nodo final, s, que entrega el resultado. Los nodos I están conectados con todos los
nodos C, y los nodos C están conectados con el nodo s.
¿Cómo “calcula” la red? En forma general, cada nodo (neurona) de la red recibe un input numérico t, y
genera un output, también numérico, g(t). La función g es una función simple de evaluar y en este caso
asumiremos que una “sigmoides”, más especı́ficamente, la siguiente:
g(t) = tanh(t) (función tangente hiperbólica)
En forma más especı́fica (Figura 2.7), cada neurona de “input” i ∈ I recibe un valor xi (las coordenadas del
punto donde vamos a evaluar),P y produce el output yi = g(xi ). Después, cada neurona de la capa intermedia,
n
k ∈ C, recibe un input igual a i=1 wik yi , donde los números wik son pesos asociados a las conexiones. Con
ese input, la neurona k ∈ C genera un output igual a
n
!
X
zk = g wik yi ,k ∈ C
i=1
Pm
Luego, esos valores zk , k ∈ C, son alimentados a la neurona final s, la que recibe un input igual a k=1 pks zk ,
donde los pks son pesos asociados a las conexiones de los nodos de C hacia s, y produce el output final igual
a
m
X
v= pks zk
k=1
(para simplificar, asumiremos que la última neurona no aplica la función g). Resumiendo entonces: la red
completa recibe como input valores (x1 , . . . , xn ) y produce v. Obviamente el cálculo depende de los pesos
wik y pks , distintos pesos darán distintos outputs. La Figura 2.7 muestra el esquema de la red que hemos
descrito.
Figura 2.7: Esquema de Red Neuronal (dibujo de D. Cariaga)
Ahora queremos “entrenar” esa red neuronal para que “aprenda” la función f . Para esto, supongamos
que nos han entregado observaciones de la función f para r distintos puntos. Es decir, conocemos valores
x̄l = (x̄l1 , . . . , x̄ln ), l = 1, . . . , r y v̄ l = f (x̄l ) = f (x̄l1 , . . . , x̄ln ).
Francisco Garcı́a y Jorge Vera 2.7. Ejemplos 31
Entonces, se entregan los vectores x̄1 , . . . , x̄r como input a la red y esta calcula outputs v 1 , . . . , v r , que no
tiene por qué ser iguales a v̄ 1 , . . . , v̄ r ya que lo que calcula la red depende de los valores que se hayan dado
a los pesos wik y pks . Entonces, el problema a resolver consiste en determinar los mejores valores para estos
pesos wik y pks de modo tal que que los valores v l , calculados por la red, sean lo más parecidos posibles a
los valores v̄ l , conocidos como datos. De este modo se “entrena” la red la que, después, debiera ser capaz de
estimar la función f para otros inputs diferentes.
Este problema de entrenamiento puede ser formulado mediante un modelo de optimización de mı́nimos
cuadrados, es decir, que minimiza el error cuadrático entre lo que calcula la red y el verdadero valor. El
modelo es el siguiente:
r
X 2
mı́n v l − v̄ l
w,p
l=1
m
X
s.a. vl = pks zkl , l = 1, ..., r
k=1
n
!
X
zkl = g wik yil , l = 1, ..., r, k = 1, ..., m
i=1
yil = g x̄li , i = 1, ..., n, l = 1, ..., r

Este problema de optimización con restricciones se puede reescribir el problema anterior como un problema
irrestricto de optimización. Para ello considere las siguientes sustituciones para reescribir el valor de v l para
algún l ∈ {1, ..., r} en particular:
m m n
! m n
!
X X X X X
v =
l
pks zkl = wik yil = wik g x̄li

pks g pks g
k=1 k=1 i=1 k=1 i=1
Reemplazando este valor de v l en la función objetivo se obtiene el problema planteado en su forma sin
restricciones:
r m n
! !2
X X X
mı́n wik g x̄i l
− v̄ l

pks g
w,p
l=1 k=1 i=1
Este es un problema de optimización que se podrı́a abordar mediante el Método del Gradiente en Python.
Para esto, en primer lugar, se necesita definir la función. Para esto, debe tenerse presente que el vector x̄li es
constante, ´pues es el input que recibe la red neuronal. Las variables en este problema son los parámetros
pks y wik que se desean calibrar. Con esto en mente, se define el vector y que contiene todas las variables.
Esto es: y = [p, w] = [p1 , p2 , . . . , pn , w1 , w2 , . . . , wn2 ]3 Luego, la función se puede definir como: 1. f(y, B).
Las tres sumatorias de la función se puede formular en formas de “loop” que van sumando sucesivamente.
El primer “loop” corresponde a la sumatoria con ı́ndice l que va entre 1 y r, la segunda a la de ı́ndice k entre
1 y n y la tercera a la de ı́ndice i, también entre 1 y n4 :
def f(y, B):
r, n_cols = B.shape
n = n_cols - 1
p, w = y[0:n], y[n:n**2 + n]
suma_l = 0
for l in range(r): # 1ra sumatoria
suma_k = 0
for k in range(n): # 2da sumatoria
suma_i = 0
for i in range(n): # 3ra sumatoria
3 Acá la notación puede ser confusa. En realidad, [p, w] corresponde a un vector y no a una fila. Formalmente, se deberı́a
escribir como y = [pT , wT ]T .

4 Notar que en Python range(n) genera números entre 0 y n − 1, que para efectos prácticos es equivalente a que sea entre 1
y n.
suma_i += w[n*k+i] * tanh(B[l, i]) # Suma de la 3ra sumatoria

suma_k += p[k] * tanh(suma_i) # Suma de la 2da sumatoria
suma_l += (suma_k - B[l, n]) ** 2# Suma de la 1ra sumatoria
return suma_l
Para aplicar el método del gradiente, se puede tener en cuenta que, como la función se puede evaluar la
función en cualquier punto y, entonces es posible obtener el gradiente utilizando “derivación numérica”5 .
Para esto, basta recordar que la definición de la derivada de una función respecto a cualquier variable. Para
este problema, esto es de la siguiente forma:
∂f (y, B) f ([y1 , . . . , yi + ∆, . . . , yn2 +n ], B) − f (y, B)

= lı́m , ∀i ∈ {1, . . . , n2 + n}
∂yi ∆→0 ∆
Esto mismo se puede implementar en Python. En la función nabla(y, B) se calcula el gradiente de f(y, B)
respecto a y = [p, w] . Para esto, en primer lugar se guarda el valor original de la función f (y, B) en fval_0
y para cada una de las entradas de y se calculó la derivada direccional.
def nabla(y, B):
r, n_cols = B.shape
n = n_cols - 1
grad, delta, fval_0 = np.zeros(n+n**2), 0.001,f(y, B)
for i in range(n + n**2):

y[i] = y[i] + delta
grad[i] = (f(y, B) - fval_0) / delta
y[i] = y[i] - delta
return grad
Con estas funciones definidas, es posible utilizar un algoritmo análogo al mostrado para el Gradiente, para
ası́ calibrar los parámetros p y w que se encuentran en el vector y. Esto se puede hacer mediante el siguiente
código:
import numpy as np
from numpy import tanh
from apendice import datos_red_neuronal
def entrenar red neuronal(B, epsilon,n i,y i):

"""
Funcion que calibra los parametros de una red neuronal utilizando
el Metodo del Gradiente.
"""
def funcion2T(lambda , y,h,B): return f(y+lambda_*h, B)
# Se definen los parametros iniciales para comenzar el algoritmo

y, k, stop = y_i, 0,False
grad = nabla(y, B)
while (not stop) and (k < n_i):

# Direccion de descenso
h = - grad
# Linesearch
lambda_ = scipy.optimize.fminbound(funcion2T, 0,10,args=(y, h, B))
# Actualizacion de y, del valor de la funcion objetivo y del gradiente
y = y + lambda_*h
val, grad = f(y, B), nabla(y, B)
print(’valor:’, val)
5 Una forma más eficiente es propuesta en el Anexo 2
# Criterio de parada
if np.linalg.norm(grad, 2) < epsilon: stop = True
k += 1
return val, y
if name == ’__main__’:
n = 10
B1, B2 = datos red neuronal(29132, n)
y_i = np.random.rand(n + n ** 2)
suma_i1, suma_i2 = f(y_i, B1), f(y_i, B2)

print(’suma_inicial_B1:’, suma_i1, ’|suma_inicial_B2:’, suma_i2)
val, y = entrenar red neuronal(B1, 0.00001,4,y_i)
suma_f1, suma_f2 = f(y, B1), f(y, B2)

print(’suma_final_B1:’, suma_f1, ’|suma_final_B2:’, suma_f2)
Se podrı́a hacer algo análogo con el Método de Newton, calculando numéricamente el hessiano. Sin embargo,
para este tipo de problemas, Newton no resulta conveniente. Esto se debe a que al estar la función de tangente
hiperbólico, que no es convexa, entonces Newton tendrá problemas. Este mismo problema es causante que
puedan existir muchos óptimos locales, por lo que el punto de partida es determinante para encontrar una
buena solución.
2.7.2. Aplicación: Optimización en doblamiento de proteinas

En biologı́a se ha estudiado desde hace tiempo la forma en que las proteı́nas se combinan para dar origen a
diversos tejidos en un organismo, entre otras cosas. La forma espacial que adquiere una proteı́na tiene que
ver con la constitución de sus aminoácidos, los cuales se atraen o repelen según sus caracterı́sticas. Esto
puede ser modelado como un problema de optimización y abordado con los métodos que hemos estudiado,
pero es un problema desafiante.
Para esto, vamos a considerar un modelo conceptual de la proteı́na, el que está formado por una secuencia de
elementos rı́gidos. Dichos elementos están unidos por sus extremos en donde se pueden articular. Los distintos
elementos se atraen o repelen según la acción de fuerzas eléctricas y nucleares, de acuerdo a caracterı́sticas
conocidas. Para simplificar, asumiremos que las fuerzas se aplican en los puntos centrales de los elementos.
La figura 2.8 muestra un modelo simplificado de una proteı́na en 2 dimensiones.
Figura 2.8: Modelo de una Proteı́na.
Asumamos que tenemos K elementos, y que los puntos extremos del elemento k son (xk−1 , yk−1 ) y (xk , yk ).
Asumimos igualmente, también para simplificar, que todos los elementos tienen un largo fijo igual a d. Luego,
una restricción del sistema es que:
(xk − xk−1 )2 + (yk − yk−1 )2 = d2 , k = 1, . . . , K.
También especificaremos que el punto inicial, (x0 , y0 ) es fijo y conocido.
Para modelar las fuerzas eléctricas y nucleares que producen el doblamiento de la proteı́na, asumimos que
todo el sistema trata de alcanzar un estado de mı́nima energı́a. Esta energı́a está dada por:
X aij
distij
i6=j
donde distij es la distancia entre el elemento i y el elemento j, y aij es un coeficiente conocido que depende
que las caracterı́sticas del elemento. La distancia la calculamos entre los puntos centrales de los segmentos.
Lo que se asume es que los elementos de la proteı́na se ubican espacialmente de modo de minimizar la
energı́a.
Para modelar el problema, vamos a representar las atracciones y repulsiones en los puntos centrales, como
se indicó. Para esto, usaremos variables (u, v) para representar estos puntos centrales y la distancia la
calculamos entre estos los puntos centrales de los segmentos. Sea:
1

uk xk xk−1
= + .
vk 2 yk yk−1
Entonces, q
distij = (uj − ui )2 + (vj − vi )2 ,
Con esto, la función objetivo es: X aij
(uj − ui )2 + (vj − vi )2
p
i6=j
El problema es, entonces, minimizar esa energı́a sujeto a las restricciones del largo de los elementos y la
definición de los puntos centrales. En forma más especı́fica:
aij
mı́n √
P
i6
=j (uj −u i )2 +(vj −vi )2

uk xk xk−1
s.a. = 21 +
vk yk yk−1
(xk − xk−1 )2 + (yk − yk−1 )2 = d2 , k = 1, . . . , K.
Este problema puede todavı́a simplificarse un poco ya que las variables (u, v) no son necesarias y pueden ser
reemplazadas. Esto lleva al siguiente modelo:
−1/2
mı́n aij ( 12 (xj − xi ) + 12 (xj+1 − xi+1 ))2 + ( 12 (yj − yi ) + 12 (yj+1 − yi+1 ))2
P
i6=j
s.a.
(xk − xk−1 )2 + (yk − yk−1 )2 = d2 , k = 1, . . . , K.
Este es un problema de minimización de una función objetivo no lineal, pero sujeto a restricciones de
igualdad. Vamos a modificar el modelo de modo tal que las restricciones de igualdad puedan ser eliminadas
y den como resultado un modelo de optimización sin restricciones.
Hay varias formas de hacer eso, pero una es despejar xk de las restricciones y reemplazar esa expresión en
la función objetivo. Tenemos: q
xj = xj−1 + d2 − (yj − yj−1 )2
Pero esto puede nuevamente aplicarse:
q q
xj = xj−2 + d2 − (yj−1 − yj−2 )2 + d2 − (yj − yj−1 )2
y ası́ sucesivamente para llegar a:

j−1 q
X
xj = x0 + d2 − (yj−k − yj−k−1 )2
k=0
Esto nos lleva a:
j−1 q i−1 p
X 1 X X
mı́n aij ( ( d2 − (yj−k − yj−k−1 )2 − d2 − (yi−k − yi−k−1 )2 )+
x,y 2
i6=j k=0 k=0
j q i p
1 X X
( d2 − (yj+1−k − yj−k )2 − d2 − (yi+1−k − yi−k )2 ))2 +
2
k=0 k=0
−1/2
1 1
( (yj − yi ) + (yj+1 − yi+1 ))2
2 2
que es, obviamente, una función muy no lineal, pero claramente diferenciable, excepto en combinaciones de
puntos que puedan hacer nulo el denominador.
Ahora, discutimos las ventajas y desventajas que puedan tener los métodos que hemos estudiados, aplicados
a este problema. Notemos que la función objetivo del problema puede ser compleja de derivar, a mano es
casi imposible. En software de álgebra simbólica podrı́a usarse, pero aún ası́ posiblemente deban obtenerse
los gradiente y Hessianos mediante rutinas de derivación numéricas. En todo caso, si hay K elementos en
la molécula, que corresponden a aminoácidos, entonces el problema tiene K variables, las y. denotemos por
f la función objetivo del problema. Entonces, ∇f será necesario si se usa el método del gradiente y es un
vector de n componentes. Si queremos usar Newton, necesitaremos el Hessiano, una matriz de n × n.
Por lo tanto, para poder comparar los métodos, serı́a útil tener una idea de cuánto puede llegar a ser n. Por
ejemplo, en6 se describe el detalle biológico del problema y se indica que hay 20 aminoácidos fundamentales,
que se combinan en cadenas desde 50 a 2000 elementos. En7 se investiga el número de aminoácidos en varias
familias de proteı́nas y se dan número en el orden de varios cientos. Entonces, podemos asumir que n será
un número de varios cientos, máximo en el orden de un par de miles. Esto es una cantidad de variables
relativamente razonable para los métodos que hemos estudiado en el curso, en todo caso.
Mencionamos a continuación, algunas posibles ventajas y desventajas de los cuatro métodos frente a este
problema:
Método del gradiente:

Tiene la ventaja de ser el método que menos cálculos requiere. Hay que determinar el gradiente de la función
y, dada la forma funcional que esta tiene, no es muy claro que se pueda hacer de forma fácil en forma
analı́tica. La desventaja del método del gradiente es que es lento, en términos comparativos.
Método de Newton:
La gran ventaja de Newton es la convergencia cuadrática. Por otro lado, se requiere el Hessiano, adicionalmente
al gradiente. Posiblemente es casi imposible encontrar una fórmula analı́tica para el Hessiano, ası́ que habrá
que recurrir a derivación numérica (tal como en el problemas de las preguntas 1, 2 y 3). Cabe notar que,
según lo comentado arriba, el costo por iteración de Newton, que es O(n3 ), aún estará en el rango de lo
manejable ya que n no será demasiado grande. Según el desarrollo del problema 4, n debe estar en el orden
de decenas de miles para que comience a verse una diferencia apreciable en tiempo real de cómputo.
Método BFGS
Posiblemente es el mejor compromiso entre la lentitud del método del gradiente y la eficiencia de Newton.
Las iteraciones serán relativamente rápidas y requieren sólo de los gradientes.
Un tema adicional, que afecta al método del gradiente, Newton y BFGS, es el problema del linesearch. Hacer
un linesearch con muchas iteraciones puede ser complejo, dada la forma de la función. Un método como el
de búsqueda de sección aurea puede ser más conveniente ya que requiere solo evaluaciones de f y no las
derivadas.
2.7.3. Centro Analı́tico de un Poliedro

Considere el poliedro definido por el siguiente sistema de desigualdades lineales:
aTi x ≤ bi , i = 1, . . . , m
donde ai ∈ Rn , i = 1, . . . , m, donde A es la matriz cuyas filas son los vectores ai ∈ Rn , i = 1, . . . , m. Vamos

a suponer que P = {x : Ax ≤ b} tiene interior no vacı́o y es un conjunto acotado. Entonces, como objeto
geométrico tiene un “centro”. Una forma de encontrar uno de esos puntos especiales es calcular lo que se
6 The Shape and Structure of Proteins, recuperdado de https://www.ncbi.nlm.nih.gov/books/NBK26830/ en 3 de septiembre
de 2020.
7 Axel Tiessen, Paulino Pérez-Rodrı́guez y Luis José Delaye-Arredondo, Mathematical modeling and comparison of protein
size distribution in different plant, animal, fungal and microbial species reveals a negative correlation between protein size and
protein number, thus providing insight into the evolution of proteomes, BMC Research Notes volume 5, (2012)
conoce como el “centro analı́tico” del poliedro. Para esto, consideramos la siguiente función, definida en el
interior de P :
Xm
Φ(x) = − log(bi − aTi x)
i=1
Lo que nos interesa hacer es resolver el problema
mı́n Φ(x)
s.a. x ∈ int(P )
A primera vista, este parece un problema restringido pero en realidad no lo es. La función Φ sólo está
definida dentro del poliedro, no es posible evaluarla fuera. Entonces, si pensamos en un algoritmo que parta
en algún punto x0 ∈ int(P ), entonces ningún punto genera deberı́a estar fuera del dominio. Esto nos permite
considerar el problema como si fuera no restringido.
El método favorito para abordar este problema es el método de Newton. Para su aplicación, necesitamos
conocer ∇Φ(x) y ∇2 Φ(x). Estos se pueden calcular derivando en forma ordenada. Lo primero a notar es que
m
∂Φ(x) X aik
=
∂xk b − aTi x
i=1 i
y esto es lo mismo que AT D(x)−1 e, donde
b1 − aT1 x 0 0
 
···
 0 b2 − aT2 x ··· 0 
D(x) =  .. .. ..
 
. . . 0

 
.. .. ..
 
. . . bm − aTm x
y e denota el vector de Rm cuyas componentes son todas iguales a 1. De aquı́ se obtiene que
∇Φ(x) = AT D(x)−1 e
Derivando una vez más se llega a que
∇2 Φ(x) = AT D(x)−2 A,
Ahora vamos a argumentar que Φ es estrictamente convexa en el interior de P si m ≥ n y el conjunto de

vectores a1 , . . . , am tiene rango completo. Esto se sigue del hecho que, como la definición de la función (por el
logaritmo) garantiza que bi − aTi x sea siempre positivo, entonces D(x) es siempre definida positiva, ası́ como
D(x)−1 y D(x)−2 . Como A tiene rango máximo (sus columnas son linealmente independientes), entonces,
para u 6= 0 se tiene que uT AT D(x)Au = y T D(x)y, donde y = Au, y esto es positivo si y 6= 0. Pero como A
es de rango máximo (sus columnas son linealmente independientes) y u 6= 0, entonces y 6= 0. Con Hessiano
definido positivo, la función es estrictamente convexa.
Ahora, este es un pseudo-código para el Método de Newton aplicado al problema:
Algoritmo de Newton para el Centro Analı́tico:

0. Sea x0 ∈ Rn , k = 0, > 0.
1. Sea dk = −[AT D(x)−2 A]−1 AT D(x)−1 e
2. Si kAT D(x)−1 ek ≤ entonces STOP.
3. Sea λk solución óptima de
mı́n Φ(xk + λdk )
λ≥0
4. Sea xk+1 = xk + λk dk , k ← k + 1, Go to 1.
Como ya sabemos, el método requiere resolver el problema de linesearch. Por supuesto, podemos usar sólo
una aproximación en la medida que cumpla con las condiciones de Wolfe-Armijo. Tenemos que, definiendo
m
h(λ) = Φ(xk + λdk ) = − log(bi − aTi (xk + λdk )) tenemos que
P
i=1
h0 (λ) = ∇Φ(xk + λdk )T dk = AT D(xk + λdk )−1 e
Luego, las condiciones de Wolfe-Armijo indican que se debe elegir λ de modo tal que
h(λ) ≤ h(0) + c1 λh0 (0)

h0 (λ) ≥ c2 h0 (0)
que se traduce, para este caso particular, en:

m
X m
X
log(bi − aTi (xk + λdk )) ≤ log(bi − aTi xk ) + c1 λAT D(xk )−1 e
i=1 i=1
AT D(xk + λdk )−1 e ≥ c2 AT D(xk )−1 e
Dada la forma de la función Φ, podemos ver que si λ crece de modo que xk − λk ∇f (xk ) se acerque a la
frontera del poliedro P (es decir, esté muy cerca de la frontera de la restricción, y bi − aTi (xk + λdk ) sea
positivo pero muy cercano a 0), entonces h(λ) crecerá hacia infinito, por lo cual será imposible satisfacer
las condiciones de Wolfe-Armijo, ası́ que, necesariamente, cualquier punto que satisfaga las condiciones está
dentro del poliedro.
Más adelante en el curso veremos que esta función Φ es de gran importancia en el desarrollo de toda una
familia de algoritmos alternativos al Simplex, para Programación Lineal. Estos son los Algoritmos de Punto
Interior.
2.7.4. Localización espacial

Un problema importante en muchos ámbitos es el de localizar en el plano o el espacio ciertos objetos, los
cuales deben cumplir cierta condición con respecto a la distancia a otros que están fijos. Un ejemplo de esto
serı́a la ubicación en alguna zona geográfica de una cantidad de centros de emergencia los cuales deben estar
“cerca” de los lugares en los que podrı́an producirse emergencias.
Vamos a formular este problema de la siguiente forma. Asumiremos que existen m puntos fijos con coordenadas
u1 , . . . , um conocidas, donde ui ∈ R2 (es decir, ui = (ui1 , ui2 )). Tenemos que definir la ubicación de otros
K puntos, cuyas coordenadas (que hay que encontrar) denotaremos por x1 , . . . , xK , donde xk ∈ R2 (es
decir, xk = (xk1 , xk2 )). Existe un costo por unidad de distancian entre el punto fijo i y el punto a localizar
k, que denotamos cik . Queremos que los puntos de coordenadas xk estén ubicados de modo que, en forma
agregada, se minimice un costo total relacionado a la distancia a la que queden de los puntos fijos y los
costos por unidad de distancia. Para eso se postula resolver el problema de optimización mı́n f (x), donde
estamos llamando x al vector que forman todos los x1 , x2 , . . . , xK “pegados” (tenga cuidado con esto: como
cada xk tiene dos coordenadas, x tiene dimensión 2K), y donde:
K X
X m
f (x) = cik kui − xk k22
k=1 i=1
Esta función es evidentemente convexa ası́ que el problema es susceptible de ser abordado con los métodos
que hemos estudiado hasta ahora en el curso. En particular, vamos a considerar el Método del Gradiente
para este problema.
Primero, vamos a determinar el gradiente y el hessiano de f en un punto x ∈ R2K cualquiera. Se tiene que
la función es:
XK X m
f (x) = cik kui − xk k22
k=1 i=1
Sabemos que por la norma euclideana se puede representar de la forma:

K X
X m
f (x) = cik (xk − ui )T (xk − ui )
k=1 i=1
Derivamos entonces para obtener el gradiente ∇f (x), siendo un vector de dimensiones 2K x 1 donde:
∂f K P m
=2 cik (xk1 − ui1 )
P
∂x1k
k=1 i=1
∂f K P m
=2 cik (xk2 − ui2 )
P
∂x2k
k=1 i=1
0
 
0
 
...
  K m
1 XX
k
12
∇f (x ) =   cik (xk − ui )
  k=1 i=1
...
0
 
Es decir, la estructura del vector es “por bloques” de dimensión 2, que es cada uno de los vectores del punto
k.
Bajo la misma lógica se obtiene el Hessiano ∇2 f (x), siendo una Matriz de dimensiones 2K x 2K diagonal,
donde:
∂2f K P
m
=2
P
cik
∂(xk1 )2 k=1 i=1
∂2f K P m
=2
P
cik
∂(xk2 )2 k=1 i=1
0 0 0 0 0 0
 
0 ... 0 0 0 0
0 0 1 0 0 0
  K m
∇2 f (xk ) = 
0 0
 2 P P cik
0 1 0 0 k=1 i=1
0 0 0 0 ... 0

0 0 0 0 0 0
Ahora queremos estudiar la convergencia del Método del Gradiente aplicado a este problema, para llegar a
una solución -óptima. Como sabemos, el Método de Gradiente tiene convergencia lineal:
|f (xn ) − f (x∗ )| ≤ α|f (xn−1 ) − f (x∗ )|

Con n representando la iteración actual.
Siendo en = |f (xn ) − f (x∗ )|, sabemos que eso lleva a:

n≥ 1
| log α| log e0
Al ser la matriz Hessiana definida positiva, se sabe que:
!2
k(Q) − 1
α=
k(Q) + 1
Donde k(Q) es el condicionamiento del Hessiano:

µmax
k(Q) =
µmin
Con µmax y µmin como el mayor y menor valor propio respectivamente de la matriz Hessiana, que como se
dijo en a) depende únicamente de cik (ver las fórmulas), por lo que el condicionamiento α de la matriz no
depende de la ubicación ui de los locales de emergencia.
Ahora bien, e0 depende del punto inicial establecido, por lo que eso sı́ depende de ui .
1
n≥ ! log ( e0 )
k(Q) − 1
2 log |
k(Q) + 1
Ahora, una de las etapas del método es la realización del linesearch. Podrı́amos pensar en hacer algún método
como los explicados antes en este capı́tulo, pero eso no es realmente necesario para este problema. En efecto,
tenemos que tomando x̄ como la variable genérica en cuestión, se debe determinar de manera óptima el paso:
f (x̄ + λd)
Para esto se define la función objetivo:
K P
m
f (x̄ + λd) = cik ||(x̄ + λd)k − ui ||22
P
k=1 i=1
Entonces para encontrar el paso óptimo derivando en función de λ e igualando a cero.

K P
m
f 0 (x̄ + λd) = 0 = 2 cik ((x̄ + λd)k − ui )T dk
P
k=1 i=1
de donde se despeja λ.
Por último, una observación que queremos hacer ahora es que el problema se puede abordar resolviendo
problemas de menor tamaño. Al tener que asignar varias coordenadas a varios puntos según su proximidad
óptima a los puntos de emergencia ui , se podrı́a abordar este problema buscando el óptimo para cada punto
xk de manera individual ya que la función objetivo se separa por el ı́ndice k de los puntos. De esta forma,
se reducirı́a el tiempo de ejecución por cada subproblema, pues no se trabajarı́a con K variables a la vez. De
hecho, se podrı́a calcular todo en paralelo.
Esto afectarı́a, eso sı́, las conclusiones anteriores en que el número de iteraciones para la solución -óptima
serı́a menor. Esto es debido a que al depender de los valores propios de la matriz hessiana, al separar en
K subproblemas, estos valores serı́an más adecuados a la variable (xk1 , xk2 ) en cuestión del subproblema k
. Esto provoca que la convergencia de cada variable a su óptimo sea más especializada a sı́ misma, pues
no considera los demás valores propios de otras variables irrelevantes, haciendo que el paso de Linesearch
pudiera ser más efectivo en cada subproblema.
Recopilando todos los óptimos de cada variable, se esperarı́a que al resolver el problema de esta forma tarde
menos tiempo.
Capı́tulo 3
Métodos de Primer Orden
En muchos problemas estadı́sticos, estimar una cierta variable en función de otras, lleva a querer resolver
un sistema de ecuaciones de la forma
Ax = b
Donde A ∈ Rm×n , y b ∈ Rm . En los últimos tiempos han surgido problemas de gran tamaño, con muchı́simas
variables. Estos problemas surgen en diversas áreas de aplicación: en econometrı́a, en reconstrucción de
imágenes médicas, en problemas de “Machine Learning” en Internet, es decir en todo lo que se conoce
como Big Data. En muchos de estos problemas se tiene que m << n, por lo que el sistema Ax = b queda
subdeterminado y tiene infinitas soluciones posibles. Un enfoque, que estudiaremos en detalle más adelante,
es buscar una solución que tengas pocas componentes no nulas, es decir, pocos factores explicativos. Para
lograr pocas variables distintas de cero (xi 6= 0), el problema original se suele resolver mediante mı́nimos
cuadrados, pero agregando lo que se conoce con una “Regularización L-1”:
mı́n f (x) = τ kxk1 + kAx − bk22

x∈Rn
donde τ > 0 es una parámetro dado. El segundo término minimiza el error cudrático de ajuste de x (el cual
es convexo y diferenciable), mientras que el primer término busca “bajar” la densidad del vector x (más
adelante explicaremos en detalle la lógica de esto). El factor τ se usa para manejar el balance entre el ajuste
al sistema de ecuaciones y la densidad del vector x. De este modo, tenemos un problema con una función
objetivo f (x) es continua, convexa pero que no es diferenciable.
Lo anterior genera de inmediato el problema de que nuestros métodos del capı́tulo anterior, el Método de
Gradiente y el Método de Newton, no podrı́an usarse ya que requieren derivadas.
Por otro lado, es posible reemplazar kxk1 por una función aproximada, llamémosla g(x), de modo tal que si
consideramos el problema
mı́n f (x) = τ g(x) + kAx − bk22

x∈Rn
este sı́ será diferenciable y podremos usar los métodos de Newton y Gradiente.
Bueno, no es tan simple. Utilizar Newton para este tipo de problemas no servirá en la práctica ya que
las aplicaciones en que esto se usa llevan a problemas con cientos de miles de variables, en algunos casos
millones. Esto hará que Newton sea extremadamente lento debido a su costo O(n3 ) por iteración. Es por
esto que en este tipo de problemas tan grande uno quisiera utilizar el método del gradiente que es O(n) o
algo del estilo del método del Gradiente que sea rápido para problemas grandes. Notemos aquı́ que, incluso
las iteraciones que se hagan para resolver el problema de “linesearch” pueden agregar costos importantes.
Por eso razón, queremos tener un Método de Gradiente que sea lo más económico posible por iteración.
En este capı́tulo se aborda la forma en que métodos basados en gradientes (o sus generalizaciones, para el caso
no diferenciable) pueden usarse para abordar eficientemente toda esa categorı́a de problemas, especialmente
40
Francisco Garcı́a y Jorge Vera 3.1. Problemas diferenciables 41
en el contexto de grandes dimensiones. Todo este tema ha sido uno de los desarrollos importantes en
Optimización durante el Siglo XXI.
Especı́ficamente, comenzaremos con problema diferenciables pero en los cuales la cantidad de variables
es muy grande. Veremos, entonces, cómo obtener un Método de Gradiente que sea realmente eficiente.
Posteriormente, revisaremos qué hacer en el caso de funciones no diferenciables, como es originalmente el
problema de estimación estadı́stica que planteamos. Esto nos llevará a extender la noción de “gradiente”
mediante el estudio de algunos elementos básicos de optimización no diferenciable.
3.1. Problemas diferenciables

Tal como explicamos, comenzaremos por estudiar el problema diferenciable y mostraremos como el tradicional
Método del Gradiente puede ser modificado para que tenga un bajo costo por iteración.
3.1.1. Gradiente sin Linesearch

El problema de optimización es el mismo de antes:
P) mı́nn f (x)
x∈R
Donde f : Rn → R. Esta vez, agregamos la hipótesis que f es convexa, continua y diferenciable. Uno de los
problemas del Método del Gradiente, que es de primer orden, consiste en que en cada una de las iteraciones
tiene que calcular el paso de avance λk resolviendo un subproblema de optimización, cosa que aunque no
se haga de modo exacto en muchas ocasiones, implica costos de tiempo adicional. Una forma de solucionar
esto es no resolver el linesearch. Esto se puede hacer haciendo que λk esté definido a priori, de modo que no
se requieran cálculos iterativos de ningún tipo. Esto es usar el Método del Gradiente, pero sin linesearch.
Veamos cómo es posible lograr eso.
Como es sabido, si f es convexa, entonces el hiperplano tangente siempre estará bajo el gráfico de la función
como una cota inferior, para un x fijo:
f (y) ≥ f (x) + ∇f (x)T (y − x) = lx (y), ∀x, y ∈ Rn
Esto nos da una aproximación lineal por debajo (lx (y)) de f (y). Agregaremos, adicionalmente, el supuesto
de que ∇f (x) es L-Lipschitziana, con parámetro L > 0:
k∇f (x) − ∇f (y)k ≤ Lkx − yk, ∀x, y ∈ Rn ,
de modo que la variación de los gradientes está acotada por la variación de los puntos donde estamos
evaluando. Notar que, por el Teorema del Valor Medio, lo que deberı́a acotar a la variación de los gradientes
entre dos puntos x e y es el Hessiano. En este caso, en vez del Hessiano se utiliza L, que hace un papel
análogo pero que no requiere ninguna matriz de gran tamaño.
Entonces, para un determinado valor de L, se puede probar que f tiene una cota superior, para un x fijo:
L
f (y) ≤ f (x) + ∇f (x)T (y − x) + ky − xk22 = qx (y), ∀x, y ∈ Rn
2
Acá no hay ninguna segunda derivada que evaluar, ningún Hessiano. Las dos expresiones mencionadas nos
dan una cota inferior y una superior para f : lx (y) ≤ f (y) ≤ qx (y), y ∈ Rn .
Es posible ver las cotas globales (porque esta es convexa) para la función en un x dado, sin utilizar hessianos.
Ahora nos interesa el valor de y que minimiza la aproximación superior qx (y), es decir, queremos resolver el
siguiente problema:

L
mı́n qx (y) = mı́n f (x) + ∇f (x) (y − x) + ky − xk22
T
2
Este mı́nimo se encuentra derivando e igualando a cero:

42 Capı́tulo 3. Métodos de Primer Orden
Figura 3.1: Cotas inferior lineal y superior cuadrática
∇qx (y) = 0 ⇔∇f (x) + L(y − x) = 0

1
y = x − ∇f (x)
L
Esta expresión es similar a la del Método del Gradiente pero con paso 1/L. Se puede demostrar que este
paso:
1
λk = , ∀k
L
satisface la condición de Wolfe-Armijo. El algoritmo del Método del Gradiente equipado con este nuevo paso
es más barato que Newton ya que requiere calcular únicamente el gradiente y más barato que el Método del
Gradiente clásico ya que no requiere iteraciones adicionales para resolver un problema de Linesearch.
Cápsula de video 3.1.1: Deducción del paso para el Método Simple de Primero Orden
Profesor Jorge Vera explica en clases la deducción del paso fijo a partir de las propiedades de
convexidad y “lipschtzianidad” del problema:
https: // youtu. be/ osa-2CoAxfU
El algoritmo se muestra a continuación:
Método simple de Primer Orden (Gradiente sin Lineseach)
Data: Sea x0 ∈ Rn , k = 0 y > 0

while kdk k > do:
xk+1 = xk + L1 dk
dk+1 = −∇f xk+1 .
k =k+1
end
En análisis de esta idea es antiguo, fue desarrollado por Arkadi Nemirovsky en los 70’s y completado por
Yuri Nesterov en los 80’s, más otra cantidad de desarrollo de muchos otros investigadores. Para implementar
este algoritmo falta conocer el valor de L, pero según el problema, esto se puede hacer directamente o
simplemente aproximar. Más aún, lo que realmente importa es que la función tenga este comportamiento en
la región del espacio que es de interés. Si bien puede no ser claro cuál es esa región (ya que necesitarı́amos
conocer el mı́nimo para determinarla), en muchos problemas se sabe, por estructura, cuáles son los valores
posibles. Lo fundamental, entonces, es que se cumpla con las dos condiciones de las que se deduce este
método: lx (y) ≤ f (y) ≤ qx (y). En primer lugar, recordemos que;
k∇f (x) − ∇f (y)k ≤ Lkx − yk, ∀x, y ∈ Rn
Reordenando estos términos se tiene:
k∇f (x) − ∇f (y)k

≤ L, ∀x, y ∈ Rn
kx − yk
Si se toman valores de x y de y que estén muy cerca, entonces el lado derecho de la ecuación se aproxima a
la segunda derivada de f en la dirección x − y, de modo que tiene que ver con la norma del hessiano de f .
Ası́, el valor de L se puede calcular como el mayor valor propio de la matriz de segundas derivadas de f :
L = máx{k∇2 f (x)k2 }
x
De este modo, se puede utilizar como valor de L la norma de ∇2 f (x) que es igual al mayor valor propio:
L = k∇2 f (x)k2 = máx valor propio. En un algoritmo que aplique esto, podrı́a demorarse únicamente cuando
se inicializa y calcula la norma de ∇2 f (x), pero después de eso es rápido. En un algoritmo de este tipo, las
direcciones consecutivas de dos vectores de descenso son casi colineales, por lo que se mueve de manera muy
distinta al “zigzagueo” ortogonal del Método del Gradiente.
Con el paso 1/L, el tiempo por iteración es menor que con el método del gradiente tradicional, que debe
calcular λ, mientras que teniendo el paso predeterminado implica que no se debe hacer ningún cálculo. Sin
embargo, como veremos más adelante, habrá que pagar un precio por esto y eso se traduce en que se deben
realizar más iteraciones.
Ejemplo: Mı́nimos Cuadrados

El problema de estimación estadı́stica mencionado al principio requiere resolver el sistema:
Ax = b
Un enfoque de solución a este problema puede ser el de mı́nimos cuadrados:
1
mı́nn kAx − bk22
x∈R 2
Para resolver este problema mediante el Método del Gradiente sin linesearch se debe calcular el gradiente
de la función y un valor apropiado de L. La función f se puede trabajar del siguiente modo:
1 1
kAx − bk22 = (Ax − b)T (Ax − b)
2 2
1 1
= xT (AT A)x − bT Ax + bT b
2 2
Sea Q = AT A, c = −AT b y α = 12 bT b, entonces se puede reescribir f (x) como:
1 T
f (x) = x Qx + cT x + α
2
De este modo, ∇f (x) = Qx + c y a su vez ∇2 f (x) = Q, por lo que se puede concluir que un valor de L,
que es la constante de Lipschitz de los gradientes, se puede calcular como L = k∇2 f (x)k2 , por lo que L
es el mayor de los valores propios de Q: L = kQk2 = kAT Ak2 (recordar que la norma dos de las matrices
corresponde al mayor valor propio). Esto se puede calcular con facilidad en un computador, por ejemplo, en
Matlab, se puede hacer con el comando norm(Q).
Computacionalmente, si se evalúa el producto punto de la dirección entre dos iteraciones seguidas, suele
suceder que dicho valor se encuentre entre 0.9 y 1.0, lo que significa que se mueve prácticamente en linea
recta, con una ligera curva para llegar al óptimo. Eso significa que se aproxima de modo más directo que
como se mueve el “zigzagueante” Método del Gradiente con linesearch.
Sin embargo, en cada paso, el algoritmo avanza muy poco, por lo que debe hacer muchas más iteraciones.
Cabe recordar, eso sı́, que lo que finalmente nos importa es el tiempo total que tarda el algoritmo en llegar
a la meta y ese tiempo depende no solo del número de iteraciones sino también del tiempo invertido en
cada iteración. Un algoritmo puede hacer pocas iteraciones pero si cada una de ellas es muy larga, tardará
mucho. La promesa de lo que estamos desarrollando aquı́ es que, aún con muchas iteraciones, el bajo costo
en tiempo de cada una de ellas permita llegar a la meta antes.
A continuación se muestra un código Python para abordar el problema descrito mediante el algoritmo.
import numpy as np
from apendice import generar_datos, angulo_entre_dos_iteraciones
def fomq(A, b, x0, epsilon, iteracion maxima):

’’’
Funcion que aplica el metodo simple de primer orden a una funcion cuadratica
definida por Q y c para resolver de manera aproximada el problema: Ax =b.
Los argumentos de entrada son:
- La matriz A y el vector b. del problema en cuestion
- x0: punto inicial.
- epsilon: tolerancia deseada.
- iteracion_maxima: numero maximo de iteraciones permitido.
Su retorno es:
- val: valor alcanzado.
- x: punto donde se alcanza ese valor.
’’’
k = 0
Q = np.matmul(np.transpose(A), A)
c = -np.dot(np.transpose(A), b)
# x es el punto actual x_1 es x(k-1) y x_2 es x(k-2)
# Se usan para evaluar el avance de la trayectoria del algoritmo
x = x0
x_1 = x_2 = x
grad = np.dot(Q, x) + c
L = np.linalg.norm(Q)
while k <iteracion_maxima:
# Acase hacen los calculos fundamentales del algoritmo
h = -grad
x = x+ (1 / L) * h
val =(np.dot(np.transpose(x), np.dot(Q, x)) / 2+
np.dot(np.transpose(c), x))[0][0]
grad = np.dot(Q, x) + c
if np.linalg.norm(grad, 2) < epsilon: break
# Se calcula el producto interno entre los vectores de avance
# en iteraciones sucesivas (Esta linea no es necesaria)
x_1, x_2 = angulo entre dos iteraciones(k, x, x_1, x_2)
k = k + 1
return val, x
n = 30
A, b = generar_datos(n)
epsilon, iteracion_maxima, x0 = 0.0001,2000000,np.ones((n, 1))
val, x = fomq(A, b, x0, epsilon, iteracion_maxima)
Cápsula de video 3.1.2: Problema de Mı́nimos Cuadrados
Profesor Jorge Vera desarrolla la preparación del problema de Mı́nimos Cuadrados lineales para ser
abordado mediante un método de primer orden simple.
https: // youtu. be/ 5tdIzzq1nTQ
3.1.2. Convergencia Método Simple

Sea f convexa y continuamente diferenciable y supongamos que ∇f es L-Lipschitz. Entonces, se puede
demostrar que después de k iteraciones, se tiene que:
2
L x0 − x∗ 2
f xk − f (x∗ ) ≤

2k
Si se desarrolla esta expresión para encontrar la cantidad de iteraciones que se deben realizar para tener una
solución con error garantizadamente menor que > 0, basta imponer que el lado derecho de la desigualdad
sea ≤ :
2
L x0 − x∗ 2
≤
2k
2
L x0 − x∗ 2
≤k
2
Luego, la cantidad de iteraciones que se deben realizar es del orden de O(1/), por lo que la convergencia es
mucho peor que la convergencia lineal O(log(1/)) que presenta el Método del Gradiente clásico. De todos
modos, como indicábamos, debido a lo barato que es por iteración, el tiempo final de ejecución del algoritmo
para problemas muy grandes puede ser mucho menor que el del Método del Gradiente. Más aún, en muchos
problemas, tal como es el entrenar redes neuronales, no se exige un tan pequeño (e.g. 10−2 basta). Por
otro lado, existe la posibilidad
√ de acelerar el algoritmo con el método acelerado de Y. Nesterov, que tiene
complejidad de O(1/ ), que utiliza dos sucesiones de puntos que van “intercambiando información” de
cómo hay que moverse, de modo que se mueven marginalmente más rápido. Esto es lo que se implementa
en los métodos verdaderos. Esto se explica en la sub sección “Método acelerado” más adelante.
3.1.3. Propiedad fuerte de convexidad

Hasta ahora a f solo le hemos pedido ser convexa y que ∇f (x) tenga la propiedad de Lipschitz. Si es que
además se cumple que f tiene propiedades fuertes de convexidad (∇2 f (x) definida positiva para todo x, y
por tanto todos sus valores propios son estrictamente mayores a 0), entonces el método con el paso de 1/L
tiene convergencia lineal. Esto sucede debido a que no se “aplana” la función en ningún x, por lo que a los
algoritmos “les cuesta menos elegir la dirección de descenso”. La definición formal es la siguiente:
Definición 3.1.1: Convexidad Fuerte

Sea f convexa, con ∇f L-Lipschitz, se dice que f es fuertemente convexa si existe µ > 0, tal que:
µ
f (y) ≥ f (x) + ∇f (x)T (y − x) + ky − xk22 , ∀x, y ∈ Rn
2
Notar que la función cuadrática del lado derecho es una cota inferior para f que viene dado por la convexidad
fuerte. Además ya se habı́a encontrado una cota superior, también cuadrática, que venı́a por la propiedad
Lipschitziana de ∇f . De este modo, f se encuentra acotada por dos funciones cuadráticas:
µ L
f (x) + ∇f (x)T (y − x) + ky − xk22 ≤ f (y) ≤ f (x) + ∇f (x)T (y − x) + ky − xk22 , ∀x, y ∈ Rn
2 2
Bajo la hipótesis anterior, existe el siguiente Teorema de Convergencia para el Método Simple:
Figura 3.2: Cotas inferior y superior cuadráticas
Teorema 3.1.1: Convergencia bajo Convexidad Fuerte
Si f es fuertemente convexa de parámetro µ y ∇f es Lipschitziana de parámetro L, entonces para

todo k se tiene:
k
κf − 1

∗
x k+1
−x ≤ xk − x∗
κf + 1
Donde κf = L/µ.
Además, se puede usar que L = λmáx y µ = λmı́n , de modo que queda similar al número de condicionamiento
de la matriz Q, κ(Q) = λmáx /λmı́n que se utilizaba en el método del Gradiente aplicado a un problema
cuadrático. Utilizando todo esto, la convergencia es lineal, es decir, para llegar a una solución -aproximada
basta realizar una cantidad de iteraciones del orden:
1

O log

Esto corresponde a una velocidad lineal. Nemirovski y Yudin demostraron que ningún método que este
inspirado en direcciones de gradiente puede ser más rápido que esto. El argumento de ellos no lo mostraremos
aquı́ dado que es extremadamente técnico, pero se basa en lo que se conoce como un “argumento adversario”
o un “oráculo resistivo”: esto consiste en asumir que uno podrı́a tener un algoritmo que logre un número de
iteraciones menor y mostrar que siempre existirá un caso de función que no funciona para ese algoritmo y
requiere el número de iteraciones anterior.
3.1.4. Método acelerado de Nesterov

Por lo visto hasta ahora, tenemos que, salvo en los casos que se impongan hipótesis adicionales (como
convexidad fuerte), los métodos simples basados en gradientes pueden ser muy lentos, llegando a ser hasta
de O(1/), lo que es muy lento cuando el error, , que se busca es pequeño. Yuri Nesterov en los años 80s
desarrolló ideas para acelerar el método del gradiente, lo que permite que las iteraciones avancen más rápido.
Este método explora el espacio dinámicamente, utilizando dos sucesiones de puntos en vez de una. Sea un
x0 ∈ Rn , y sea z 0 = x0 . En la iteración k con xk y z k , calculamos:
1
z k+1 ← z k − ∇f θk z k + (1 − θk ) xk

θk L
xk+1 ← (1 − θk ) xk + θk z k+1 ,
donde θk es una sucesión que converge a cero y L es la constante de Lipschitz de ∇f . En el fondo, z k+1 se
mueve en la dirección del negativo del gradiente, pero este es evaluado en un punto intermedio entre xk y z k ,
con un paso de 1/θk L. El nuevo x se construye entre xk y z k+1 . La interpretación es que ası́ z k “arrastra”
a xk a distancias que van creciendo debido al hecho que θk va disminuyendo (ver Figura 3.3).
Figura 3.3: Tres Iteraciones con el método Acelerado de Nesterov
Este método logra, efectivamente, ser más eficiente que el método básico de primer orden. Una versión del
teorema de convergencia desarrollado por Nesterov para medir el error de la solución de la iteración k es la
siguiente:
Teorema 3.1.2: Convergencia del Método Acelerado de Primer Orden
Sea f convexa y ∇f L-Lipschitz, con θk = 2

2+k . Después de k iteraciones se tiene:
2L x0 − x∗
mı́n f xi ≤ f (x∗ ) + 2

0≤i≤k (k + 1)2
Nótese que el término que está a la izquierda no es f xk , sino que es el mejor de todos los valores que se

han encontrado hasta la iteración k. Esto se debe a que no necesariamente la mejora de la función objetivo es
monótona, como sı́ ocurre en el método del gradiente (ya que la dirección de descenso siempre es el gradiente
del punto xk . En este caso, como no se toma la dirección de descenso exactamente en el punto xk , puede
haber oscilaciones locales, pero en el global el método va disminuyendo el valor de la función objetivo. Se
puede apreciar que el segundo término del lado derecho corresponde al error, por lo que si queremos ejecutar
el algoritmo hasta alcanzar un error inferior a , entonces el número de iteraciones necesarios tiene por cota
inferior:
2L x0 − x∗ 2
≤
(k + 1)2
r
2L kx0 − x∗ k2
k≥ − 1,

√
por lo que la complejidad del algoritmo es del orden de O(1/ ), lo que es mejor a O(1/) del método sin
acelerar. Esta es la gran ventaja del método acelerado (de ahı́ su nombre) y puede, efectivamente, ser muy
eficiente en aplicaciones prácticas. El esfuerzo computacional por iteración no es significativamente diferente
al del método del gradiente básico y también requiere la evaluación del gradiente en un punto.
Comentemos, adicionalmente, que si hay convexidad fuerte y condición de L-Lipschitz de ∇f (x), entonces
este método también adquiere convergencia lineal, es decir, llega a ser de orden de O(log(1/)).
3.2. Problemas no diferenciables

Como decı́amos en la introducción a este capı́tulo, Un conjunto importante de problema aplicados, especialmente
algunos que aparecen en estimaciones estadı́sticas, reconstrucción de imágenes y otras, presentan muchas
variables pero con una función objetivo que no es necesariamente diferenciable en todas parte. En esta sección
mostramos cómo abordar estos problemas. Partiremos por explicar en más detalle el problema estadı́stico
que mostrábamos al comienzo.
3.2.1. LASSO: Least Absolute Shrinkage and Selection Operator

En muchas aplicaciones de reconstrucción de imágenes (Compressed Sensing), reconstrucción de información
(Sistemas recomendadores y Componentes Principales), Machine Learning y Big Data, surgen problemas con
muchı́simas variables (n grande) e información muy dispersa. En estos problemas se deben resolver sistemas
de ecuaciones lineales Ax = b, con x ∈ Rn , A ∈ Rm×n y b ∈ Rm , pero se tiene que m << n, por lo que
el sistema está subdeterminado (tiene muchas más variables que restricciones). Lo que se busca, entonces,
es una solución x, que sea lo más “rala” posible (“sparse”, se dice en Inglés). Esto significa imponer que
pocas componentes de x sean distinto de cero (xi 6= 0). Esto equivale a tratar de indetificar el menor número
posible de factores explicativos.
Ejemplo: Estudio de enfermedades en función de la genética

Ejemplo de lo anterior es la investigación de una enfermedad en función de las caracterı́sticas genéticas de
los pacientes. La enfermedad puede presentar distintos niveles de gravedad y se plantea la hipótesis de que
esos niveles de gravedad podrı́an ser explicados por el grado de expresión de ciertos genes (la expresión de un
gen es la forma en que su codificación se manifiesta en el organismo). El problema en esto es que los genes,
n en total, que se estudiarı́an pueden ser miles, mientras que la cantidad de pacientes m que presentan la
enfermedad que se pueden estudiar son considerablemente menos m << n. Supongamos que tenemos como
datos el grado de severidad del paciente i, yi , y también tenemos la información del grado de expresión del
gen j en el paciente i, aij . Entonces, interesa estudiar qué genes explican la enfermedad, para lo que se
plantea un modelo lineal, donde xj es el peso del gen j:
n
X
yi = aij xj + ei
j=1
donde, además, ei es un término de error estadı́stico de la estimación. Este es un problema de regresión

lineal de la forma y = Ax + e. Los problemas de regresión lineal se abordan tratando de encontrar x de
modo que Ax sea lo más parecido a y, lo que se hace, habitualmente, mediante mı́nimos cuadrados que, en
este caso, llevarı́a a un problema del tipo
X m
X n
X
mı́n e2i = mı́n (yi − aij xj )2
x x
i i=1 j=1
Ahora, dado que el problema está sobredeterminado, este problema de optimización tiene múltiples soluciones
y todas dan un óptimo igual a 0, lo que es totalmente inútil. De haı́ surge, entonces, la idea de buscar aquella
solución especı́fica tal que pocos genes sean realmente explicativos de la enfermedad. Esto se puede plantear
como un problema en que se quiere minimizar la cantidad de componentes xj 6= 0. Esto lleva al siguiente
problema:
mı́n card{j : xj 6= 0} = kxk0

s.a. Ax = y
Este problema es de naturaleza combinatorial, y se puede modelar mediante programación entera, definiendo
las siguiente variables: zj = {1 si xj 6= 0, 0 e.o.c.} Si se conoce M tal que es mayor que el módulo de cualquier
componente de x (|xj | ≤ M ), entonces, el problema de optimización queda definido del siguiente modo:
Pn
mı́n j=1 zj
s.a. Ax = y
−M zj ≤ xj ≤ M zj , ∀j
zj ∈ {0, 1}, ∀j
Francisco Garcı́a y Jorge Vera 3.2. Problemas no diferenciables 49
Este problema de programación entera, al ser de miles de variables resulta, en general, intratable de resolver
en el computador, por lo que conviene utilizar un enfoque alternativo. Lo que hay que ver acá es que en
Ax = y, la matriz A es “alargada para el lado” pues m << n, entonces, si pensáramos en soluciones “básicas”
de ese sistema, hay m variables x que son básicas y n − m no básicas,
Una idea, basada en la observación anterior, que permite aproximar el problema original de forma tratable
consiste en interpretarlo como un problema de programación lineal, lo que se puede hacer aproximando
card{j : xj 6= 0} = kxk0 por kxk1 , que es la suma de los valores absolutos de los x:
n
X
kxk1 = |xj |
j=1
De este modo, el problema de optimización queda como uno de programación lineal:
Pn
mı́n j=1 |xj |
s.a. Ax = y
Este proxi (card{j : xj 6= 0} = kxk0 ≈ kxk1 ) es mejor que utilizar kxk2 , pues tiende a hacer que en la
medida de lo posible hallan entradas en x que se sean cercanas a cero, una intuición de porqué sucede esto
se ve en la Figura 3.4.
Figura 3.4: Norma uno más similar a la norma cero que la norma dos
Este segundo problema rescata el objetivo de que la mayor cantidad posible de entradas del vector x nulas.
Como se recordará, en este tipo de problema, debido a que existen más variables (columnas de A) que
restricciones (filas de A), m > n, entonces los óptimos de programación lineal, se alcanzan en los vértices,
generan soluciones básicas que presentan gran cantidad de variables con valor = 0.
Sin embargo, aún este problema de optimización resulta difı́cil para n muy grande y la propuesta desarrollada
es tratarlo de forma aproximada utilizando una “Regularización” en el problema de mı́nimos cuadrados que
habı́amos planteado anteriormente, que se traduce en el siguiente problema de optimización irrestricto:
mı́n τ kxk1 + kAx − bk22

x∈Rn
donde τ > 0 es un parámetro dado. Este se conoce como un problema de mı́nimos cuadrados con “regularización
L-1” y esconde dos funciones objetivo, que está balanceadas por medio del parámetro τ . El primer término
busca que la mayor cantidad posible de las entradas del vector x sean nulas. El segundo término minimiza el
error de ajuste de x, ya que busca que Ax sea lo más parecido posible al vector b, es decir, el el tradicional
término de mı́nimos cuadrados. Por lo tanto, si τ es grande se tendrán pocas entradas de x distintas de cero
pero un mal ajuste, mientras que si se tiene un τ pequeño, se tendrá un buen ajuste, pero pocas variables
distintas de cero. Es por esto que este valor se debe calibrar según el error que se quiera y la cantidad de
genes o variables que expliquen el fenómeno.
3.2.2. El Método del Subgradiente

Ahora bien, uno de los problemas que tiene la formulación anterior es que la función objetivo es no
diferenciale, pues kxk1 se define como:
n
X
kxk1 = |xj |
j=1
función que no es diferenciable en el punto x = 0.

Como el problema es no diferenciable, es necesario recurrir a un concepto que juegue el mismo papel de
las derivadas en los4 problemas diferenciables. Para esto, vamos a introducir algunas nociones básicas de
análisis convexo no diferenciable, notablemente el concepto de subgradiente.
Definición 3.2.1: Concepto de Subgradiente
Sea f : Rn → R una función convexa. Un vector h ∈ Rn es una subgradiente de f en x si:
f (y) ≥ f (x) + hT (y − x), ∀y
La figura ilustra el significado del concepto. Un subgradiente es la “pendiente” de un hiperplano tangente

que está por abajo del grafo de la función. En el caso de una función diferenciable, este coincide con el
gradiente (la derivada), pero en un punto no diferenciable hay infinitos subgradientes que cumplen con la
condición. En el caso de la figura, que es en una dimensión, es un rango de intervalo para valores. En el caso
multidimensional, que es el de uso práctico, es un conjunto en el espacio multidimensional.
Figura 3.5: Subgradiente
A continuación se muestran dos ejemplos de subgradientes:

El subgradiente de f (x) = |x| es el que se muestra a continuación:

1,
 x>0
h = −1, x<0
α ∈ [−1, 1], x = 0


El subgradiente de f (x) = máx{0, (x2 − 1)} se calcula considerando que la pendiente de dicha función es
2x, x < −1 ∨ x > 1




0,

−1 < x < 1
h=


 α ∈ [−2, 0], x = −1
α ∈ [0, 2], x=1

Con todo esto explicado, se define el Subdiferencial:

Definición 3.2.2: Concepto de Subdiferencial
Sea f : Rn → R una función convexa. El conjunto ∂f (x) se le llama subdiferencial de f en x, tal que:
∂f (x) = h ∈ Rn : f (y) ≥ f (x) + hT (y − x), ∀x

El Subdiferencial ∂f (x) es, entonces, el conjunto de todos los subgradientes. Se puede argumentar fácilmente
que si x∗ es un mı́nimo global, entonces 0 ∈ ∂f (x∗ ).
Cápsula de video 3.2.1: Subgradiente
Profesor Jorge Vera explica en clases el concepto de subgradiente, con un ejemplo.

https: // youtu. be/ -WBdyuIPJTI
Con todo esto se puede definir el Método del Subgradiente, que utiliza como dirección de descenso no el
negativo del gradiente (pues la función no diferenciable no tiene), sino que se utiliza una dirección que
pertenezca al subdiferencial. Este Método del Subgradiente se presenta a continuación:
Método del Subgradiente
Data: Sea x0 ∈ Rn , k = 0, −dk ∈ ∂f (x0 ), > 0.

while Criterio de parada no se satisface do:
Elegir el paso λk
xk+1 = xk + λk dk
−dk+1 ∈ ∂f (xk+1 )
k =k+1
end
Una de las preguntas, por supuesto, es la determinación de un paso de avance adecuado. Haremos esa
discusión al hablar de la convergencia del método más adelante.
Ejemplo: Método del Subgradiente aplicado al problema LASSO

Usemos el problema de LASSO para ver cómo funciona el Método del Subgradiente. En este caso, el problema
de optimización es:

x∈Rn
Para aplicar el algoritmo, se debe elegir una dirección de descenso −dk ∈ ∂f (xk ). Para esto se busca el
subgradiente de f , haciendo abuso de notación, para esto se aplica la “subderivada” a la expresión. Como
kAx−bk22 es diferenciable, entonces su subrediente corresponde a su gradiente. De este modo, el subgradiente
de f es el siguiente:
∂f (x) = ∂ (τ kxk1 ) + ∂ kAx − bk22

= τ ∂ (kxk1 ) + ∇ kAx − bk22

 
Xn
= τ∂  |xj | + 2AT (Ax − b)
j=1
n
X
=τ ∂|xj | + 2AT (Ax − b)
j=1
Donde el valor de ∂|xj | corresponde a un vector, llamémoslo p, cuyas entradas distintas de j, pi6=j , son nulas
(pues “subderiva” respecto al componente j) y la que está en la posición j tiene la siguiente forma:

1,
 xj > 0
pj = −1, xj < 0
α ∈ [−1, 1], xj = 0


Para este caso, elegir α = 0 es suficiente para encontrar un subgradiente. Una función que pertenece a pj es
la función signo, sgn(x), cuya componente j se define del siguiente modo:

1,
 xj > 0
sgn(x)j = −1, xj < 0
0, xj = 0


Luego, se puede utilizar como subgradiente válido la siguiente función:
τ sgn(x) + 2AT (Ax − b) ∈ ∂f (x)
Cabe decir que cuando se ejecuta el código de este problema, sucede que algunas entradas de x no convergen
a cero perfectamente, sino que se acercan a números muy pequeños en valor absoluto, varios ordenes de
magnitud más pequeños que las entradas de x que son definitivamente distintas de cero. Lo que se hace,
en la práctica, es “redondear” estas entradas a 0 y ası́ se puede medir kxk0 . El tema es ir calibrando el τ
de modo que se obtenga kxk0 cercano a la cantidad de columnas (kxk0 ≈ m) y que el error de ajuste del
sistema Ax = b no sea tan grande (15 % es mucho, pero a veces es aceptable).
Relación ente lipschitzianidad y subgradiente

Sea f función L-Lipschitz, entonces, si g ∈ ∂f (x) → kgk ≤ L. Esto se debe a que como f es función
L-Lipschitz, entonces: kf (y) − f (x)k ≤ Lky − xk Además, sabemos que los subgradientes forman planos
soporte de la función, es decir:
g ∈ ∂f (x) → f (x) + g T (y − x) ≤ f (y)
Haciendo el cambio de variable: y = g + x se tiene:
f (x) + g T g ≤ f (x + g)
kgk2 ≤ f (x + g) − f (x)
kgk2 ≤ kf (x + g) − f (x)k /Aplicando Lipschitz
kgk2 ≤ Lkgk
kgk ≤ L
Esta relación es útil para estimar la constante de Lipschitz de la función f teniendo una expresión para
los subgradientes. Por ejemplo, en el caso de la función de regularización L1 de LASSO, tenı́amos que un
subgradiente, en x, era:
g(x) = τ sgn(x) + 2AT (Ax − b)

Entonces, podemos estimar la constante de Lipschitz de la función estimando kg(x)k2 :
√
kg(x)k2 ≤ τ ksgn(x)k2 + 2kAT (Ax − b)k2 ≤ τ n + 2kAT (Ax − b)k2
y para el segundo término, podemos estimar:
kAT (Ax − b)k2 ≤ kAT Ak2 kxk2 + kAT bk2
Como se ve, esta expresión depende de x, haciendo pensar que no es posible determinar una constante de
Lipschitz. Esto es verdad, efectivamente, pero sólo en un sentido global. Si pudiéramos restringirnos a un
conjunto de valores de x, por ejemplo, conocer R tal que kxk2 ≤ M , entonces podemos estimar
√
L = τ n + 2kAT Ak2 R + 2kAT bk2
En muchas aplicaciones es, efectivamente, posible asegurar que el espacio de búsqueda en las variables x
tendrá esa propiedad y, entonces, sı́ se tendrá una constante de Lipschitz para la función objetivo del problema
LASSO. Esto se ve reflejado, de hecho, en el resultado de convergencia que se presenta a continuación.
Convergencia del Método del Subgradiente

Si es que suponemos que se conoce un R > 0, tal que f es convexa y L-Lipschitz en una vecindad R de x∗ ,
es decir:
|f (x) − f (y)| ≤ Lkx − yk, ∀x, y ∈ B(x∗ , R)
(o sea se cumple Lipschitz en un espacio local cercano al objetivo). Si suponemos además que comenzamos
en el punto x0 tal que x0 ∈ B(x∗ , R), entonces se puede demostrar que si se elige un paso
a
λk = √
k+1
Con a > 0 una constante elegida juiciosamente, entonces:
R2 + a ln(k + 1)
mı́n f xi ≤ f (x∗ ) +

√
0≤i≤k 2a k + 1
Es mı́n0≤i≤k f xi en vez de f (xk ) porque este método no garantiza que en cada iteración se descienda.

Esta expresión es mala, pues implica que para tener un error pequeño se debe iterar muchı́simo (k muy
grande). Esto se puede hacer mejor si se elige que en el paso, la constante a sea R/L:
R
λk = √
L k+1
Con esto, se tiene que:
RL
mı́n f xi ≤ f (x∗ ) + √

0≤i≤k k+1
El gran problema es que se necesita conocer R y el L para calcular esto, pero como ya dijimos, en algunas
aplicaciones sı́ es posible obtenerlos. El segundo término del lado derecho de la desigualdad es el error, por
lo que si se ejecutar el algoritmo hasta alcanzar un error inferior a , entonces el número de iteraciones
necesarios tiene por cota inferior:
RL
√ ≤
k+1
2
RL
k≥ −1

Por lo que la complejidad del algoritmo es del orden de O(1/2 ), mucho peor que O(1/) del caso diferenciables
(Ya que < 1). El caso diferenciable es mejor porque en el fondo tiene derivadas que le dan estructura,
recordar que las propiedades lipschitzianas se las debı́amos al gradiente, que era una manera de aproximarse
al segundo orden, cosa que no se puede hacer con el subgradiente, que utiliza (valga la redundancia) el
subgradiente, que no tiene tanta estructura e información como lo es el gradiente. Ante esta mala noticia,
cabe decir que de todos modos, al igual que en el caso diferenciable, se puede acelerar el algoritmo, tal como
lo hace el método FISTA que se presenta más adelante.
El siguiente código muestra el algoritmo de subgradiente aplicado el problema de LASSO.
import numpy as np
def LASSO(A, b, tau, iteracion maxima):

"""
Funcion que busca resolver el problema de regulacion L1 mediante el metodo del
subgradiente. Su entrada posee:
- La matriz A, el vector b y el escalar tau de trade off de la regularizacion L1.
- iteracion_maxima: Numero maximo de iteraciones a realizar.

Su salida es:
- valor: Valor optimo del problema a minimizar.
- xk: Vector solucion del problema de k iteraciones.
"""
# Dimensiones correspondientes
m, n = A.shape
# Vector con ceros en todas sus entradas como vector inicial de partida
xk = np.zeros((n, 1))
# Estimacion del valor de R (radio) y L (constante de Lipschitz)
R = np.sqrt(np.linalg.norm(np.linalg.inv(
np.dot(A, np.transpose(A))))*np.linalg.norm(b))
L = tau*np.sqrt(n) + np.linalg.norm(np.dot(A, np.transpose(A))) * \
R + np.linalg.norm(np.dot(np.transpose(A), b))
# Numero de iteraciones segun el teorema de la convergencia
thetak = R/(L*np.sqrt(iteracion_maxima+1))
# OJO OJO: Se puede usar thetak = a/ np.sqrt(iteracion+1)
k = 0
while k <= iteracion_maxima:
# 1: Se calcula el gradiente de la funcion objetivo
subgradiente = 2*np.dot(np.transpose(A),
np.dot(A, xk) - b) + tau*np.sign(xk)
# 2: Se actualiza el valor objetivo

xk = xk - thetak*subgradiente
# 3: Se evalua el error de ajuste

error = np.amax(np.abs(np.dot(A, xk) - b)) / np.amax(np.abs(b))
if error <= 0.0001: break
k += 1
valor = np.linalg.norm(np.dot(A, xk) - b, 2)**2 + tau*np.linalg.norm(xk, 1)
return valor, xk
A, b = generar datos LASSO(30, 100)
valor, x = LASSO(A, b, 10,10000)
Cápsula de video 3.2.2: El Método del Subgradiente aplicado al problema LASSO
Profesor Jorge Vera muestra el desarrollo del Método del Subgradiente para el problema de estimación
LASSO, con resultados computacionales usando Octave, que es un “sustituto” libre de MATLAB.
https: // youtu. be/ T8AvSRaBlow
3.2.3. FISTA: Fast Iterative Shrinkage and Thresholding Algorithm

Este es un método que fue desarrollado por A.Beck y M.Teboulle e implementa un concepto de aceleración
similar al de Nesterov, utilizando dos sucesiones de puntos. Es muy usado para la reconstrucción de imágenes
y problemas de Compressed Sensing. Tomemos el problema no diferenciable LASSO, ya estudiado:

x∈Rn
donde el segundo término de la función objetivo, que es diferenciable, se puede reescribir como h(x) =
kAx − bk22 , de modo que el problema queda como:
mı́n τ kxk1 + h(x)

x∈Rn
Si L es la constante de Lipschitz de ∇h(x), entonces el algoritmo se puede describir del siguiente modo:
FISTA: Fast Iterative Shrinkage-Thresholding Algorithm
Data: x0 , z 0 ∈ Rn , k = 0, θ0 = 1.
yk = zk − L1 ∇h (zk )
Resolver:
L 2
mı́n τ kxk1 + kx − yk k2
x 2
sea xk+1 lasolución óptima.

Sea θk+1 = 12 1 + 1 + 4θk2 .
p

zk+1 = xk+1 + θθkk+1
−1
(xk+1 − xk )
k =k+1
end
La complejidad de este algoritmo es la misma que para √ el método acelerado de Nesterov, pues para llegar a
una solución -óptima se requieren del orden de O(1/ ) iteraciones.
El problema de minimización que se debe resolver en cada iteración de este problema es, en realidad, muy
simple de resolver porque se puede descomponer coordenada a coordenada del siguiente modo:
 
n n
 X L X 2

mı́n τ |xj | + (xj − (yk )j )
x 
j=1
2 j=1 
Luego, para la coordenada j ∈ {1, . . . , n} el problema es:

L 2
mı́n τ |xj | + (xj − (yk )j )
xj 2
Dado que es una función claramente convexa, basta derivar e igualar a cero para encontrar el punto x∗j donde
se alcanza el mı́nimo:
τ · sgn(x∗j ) + L x∗j − (yk )j = 0

Resolviendo se obtiene:
τ
(yk )j = x∗j + sgn(x∗j )
L
La forma del espacio geométrico conformado por las variables (yk )j y xj conforma una función de tipo Soft
Thresholding, la que se muestra en la siguiente figura

y − τ /L,
 (yk )j ≥ τ /L
xj = y + τ /L, (yk )j ≤ −τ /L
0, e.o.c.


Equivalentemente, se puede expresar lo mismo como:
n τ o
xj = sgn((yk )j ) · máx |(yk )j | − , 0
L
El siguiente es un código Python que implementa el algoritmo FISTA:
import numpy as np
from apendice import generar_datos
def LASSO FISTA(A, b, tau, iteracion maxima):

"""
Esta funcion implementa el algoritmo de FISTA para resolver el problema de
regularizacion L1: min_x {tau *||x||_1 +||Ax - b||_{2}ˆ{2}}.Su entrada posee:
- A, b, tau: Parametros propios del problema.
- iteracion_maxima : Numero maximo de iteraciones a realizar.
Su salida es:
- valor : Valor optimo del problema a minimizar.
- xk : Vector solucion del problema de k iteraciones.
"""
def xk optimo FISTA(tau, L, y):
’’’
Funcion que optimiza el problema de FISTA:
min_x {tau *||x||_1 +(L / 2) *||x - yk||{2}ˆ{2}}
’’’
x_r = np.zeros((len(y), 1))
for j in range(len(y)):
if y[j] >= (tau / L): x_r[j] = y[j] - (tau / L)
elif y[j] <= -(tau / L): x_r[j] = y[j] + (tau / L)
else: x_r[j] = 0* y[j]
return x_r
# Se setean las dimensiones

m, n = A.shape
# Se setean las condiciones iniciales, junto a los vectores que almacenando
xk, zk, thetak = np.zeros((n, 1)), np.zeros((n, 1)), 1
# Estimacion del valor de R (radio) y L (connstante de Lipschitz)
R = np.sqrt(np.linalg.norm(np.linalg.inv(np.dot(A, np.transpose(A))))
)*np.linalg.norm(np.dot(np.transpose(A), b))
L = tau*np.sqrt(n) + np.linalg.norm(np.dot(A, np.transpose(A))) * \
R + np.linalg.norm(np.dot(np.transpose(A), b))
k = 0
while k <= iteracion_maxima:

# 1: se calcula y_{k}
yk = zk - (1 / L) * 2*np.dot(np.transpose(A), np.dot(A, zk) - b)
# 2: se calcula x_{k+1}
# Alternativamente se puede resolver con Soft Thresholding
xk1 = xk optimo FISTA(tau, L, yk)
Francisco Garcı́a y Jorge Vera 3.3. Métodos de Primer Orden con Restricciones 57
# 3: se calcula theta_{k+1}
thetak1 = (1 / 2) * (1 + np.sqrt(1 + 4* thetak ** 2))
# 4: Se calcula el paso z_{k+1}

zk1 = xk1 + ((thetak - 1) / thetak1) * (xk1 - xk)
# 5: Se actualizan los valores para la siguente iteracion

k, zk, xk, thetak = k + 1,zk1, xk1, thetak1
valor = tau * np.linalg.norm(xk, 1) + 0.5*np.linalg.norm(np.dot(A, xk) - b)**2
return valor, xk
tau, iteracion_maxima = 10,800
A, b = generar datos(100, 500)
valor, xsol = LASSO FISTA(A, b, tau, iteracion_maxima)
Cápsula de video 3.2.3: Algoritmo FISTA
Profesor Jorge Vera explica en clases el algoritmo FISTA y se compara computacionalmente con el
Método de Subgradiente simple.
https: // youtu. be/ L-UT_ OTq_ 2k
3.2.4. Resumen
Hemos estudiado hasta ahora algunos métodos para problemas irrestrictos y que pueden abordar funciones
objetivo diferenciables y no diferenciables. Según las hipótesis que se impongan, pueden tener distintas
complejidades. La siguiente tabla resume las complejidades en el número de iteraciones para llegar a una
solución óptima con los Métodos de Primer Orden estudiados hasta ahora:
Problema Método Simple MétodoAcelerado

f diferenciable, ∇f L-Lipschitz O 1 O √1

f no diferenciable, f L-Lipschitz O 12 O √1

f fuerte convexa, ∇f L-Lipschitz O log 1 O log 1

Hay un teorema de Nesterov y otro de Nemirovsky que dicen que si no hay convexidad fuerte, entonces√con
el método acelerado se pueden obtener los mejores rendimientos y esos están limitados al orden = (1/ ).
Esto es, entonces, una “cota infererior” a lo que podemos lograr con conocimiento de un oráculo de primer
orden.
3.3. Métodos de Primer Orden con Restricciones

Los métodos que hemos estudiado hasta ahora asumen problemas de la forma:
mı́n f (x)
x∈Rn
Donde f es convexa, y puede ser o no diferenciable. La idea de un Método de Primer Orden se puede extender
a problemas con restricciones, como veremos ahora. Conceptualmente, la idea es relativamente simple pero
la eficiencia de la diea depende fuertemente de las caracterı́sticas del problema.
Consideremos el siguiente problema:
mı́n f (x)
s.a. x ∈ D
Donde D es convexo. Vamos a revisar en las siguientes secciones, primero, una idea general que se conoce
como Método Proyectado y otra, que corresponde a un algoritmo antiguo pero que ha tenido un fuerte
resurgimiento en años recientes, el Algoritmo de Frank-Wolfe.
El Método Proyectado
La proyección de un punto sobre un conjunto consiste en buscar aquel punto de un conjunto que está a
menor distancia de este. Denotemos por ΠD (x) la proyección de x en D. Esto corresponde a resolver el
siguiente problema:
ΠD (x) = mı́n kx − yk2

s.a. y∈D
Ası́, el problema de optimización busca minimizar la distancia entre el punto x y el punto y ∈ D.
Figura 3.6: Método Proyectado
El Método Proyectado se desarrolla, simplemente, adaptando la etapa de avance a:
xk+1 = ΠD xk + λk dk

Con dk la dirección de descenso, y λk el paso. De este modo, en primer lugar se hace un paso xk + λk dk y
luego se proyecta sobre el espacio factible D para ası́ obtener el nuevo punto xk+1 ∈ D. De este modo, el
algoritmo es el siguiente:
Algoritmo simple de primer orden proyectado
Data: x0 ∈ Rn , k = 0, d0 = −∇f x0 .


xk+1 = ΠD xk + λk dk
dk+1 = −∇f xk+1
k =k+1
end
Este método también es aplicable a funciones no diferenciables, para lo que se debe tomar la dirección de
descenso −dk ∈ ∂f (xk ). También se puede aplicar al método acelerado e incluso a FISTA. Cabe decir que
las convergencias son iguales al caso sin restricciones y se usan los mismos λ para los pasos.
Todo esto, desde un punto de vista práctico, solo tiene sentido si el conjunto D es “simple”, en el sentido
que se pueda calcular la proyección sin un esfuero computacional adicional significativo.
Un ejemplo en que puede ser simple la proyección es en el problema LASSO abordado de manera alternativa:
mı́n kAx − bk22

s.a. kxk1 ≤ ρ
Francisco Garcı́a y Jorge Vera 3.3. Métodos de Primer Orden con Restricciones 59
En este problema, el conjunto D tiene la siguiente forma: D = {x : kxk1 ≤ ρ}. En un poliedro ası́, es muy
fácil proyectar. Véase la Figura 3.7 que representa a dicho poliedro en dos dimensiones:
Figura 3.7: Poliedro sobre el que resulta sencillo proyectar
En el caso de encontrar la proyección del punto rojo sobre el poliedro D = {x : kxk1 ≤ ρ}, basta buscar
solo sobre los vértices que se encuentran delimitando el cuadrante donde está el punto, vale decir, los puntos
(0, ρ) y (ρ, 0), luego se debe definir la linea que une a estos dos puntos: x1 + x2 = ρ (en Rn corresponderı́a a
un hiperplano), luego se proyecta el punto sobre la linea, de modo que resulte sencillo ver cual es el vértice
más cercano.
Algoritmo de Frank - Wolfe

Algoritmo para resolver problemas de optimización con restricciones muy usado en lo que concierte a
Equilibrios en Redes de Transporte y en Economı́a de Transporte. Es utilizado para abordar problema
del siguiente tipo:
mı́n f (x)
s.a. Ax ≤ b
Si f fuera lineal, el problema es simple de resolver, utilizando el algoritmo SIMPLEX de Programación

Lineal. Si el f fuera no lineal, entonces se puede aproximar a una función lineal en y y se optimiza esta. Se
linealiza la función objetivo, suponiendo que estamos en un punto xk :
T
f (y) ≈ f xk + ∇f xk y − xk

La propuesta es minimizar dicha aproximación lineal, por lo que el problema a resolver queda de la siguiente
forma:
T
mı́n

∇f xk y − xk
s.a. Ay ≤ b
T
Como ∇f xk xk es una constante, el problema de optimización se puede simplificar del siguiente modo:
T
mı́n ∇f xk y
s.a. Ay ≤ b
Sea ȳ la solución óptima de este problema. Luego el punto de la siguiente iteración se elije del siguiente
modo:
xk+1 = xk + αk ȳ − xk

Aquı́, las alternativas para un α adecuado son:

1. Hacer un linesearch: mı́n f xk + α ȳ − xk

0≤α≤1
2. Usar un valor definido a priori, cosa más utilizado hoy en dı́a debido a que es más “barato” en
cada iteración. Para esto necesitamos suponer que f es convexa, y que ∇f cumple una condición de
Lipschitz, tal que: k∇f (x) − ∇f (y)k ≤ Lkx − yk, ∀{x, y} ∈ D. El siguiente paso queda definido
como:
2
αk =
k+2
Figura 3.8: Ejemplo de 4 iteraciones con Frank-Wolfe
El algoritmo en cuestión se presenta a continuación:
Algoritmo de Frank-Wolfe (paso simple)
Data: x0 : Ax0 ≤ b, k = 0, d0 = −∇f x0 .


Sea ȳ solución óptima del siguiente problema:
T
mı́n

∇f xk y − xk
s.a. Ay ≤ b
xk+1 = xk + 2 k

k+2 ȳ − x
k =k+1
end
En general, como criterio de parada se utilizan las condiciones de Karush Kuhn Tucker. Este algoritmo
puede llegar a ser muy eficiente en problemas en donde el subproblema lineal puede ser especialmente
fácil. Esto sucede si reformulamos aproximadamente el problema de LASSO, con su Regularización-L1:
mı́n{τ kxk1 + kAx − bk22 } en el siguiente problema que minimiza el ajuste sujeto a que la norma uno de x
sea menor a un parámetro adecuado ρ:
mı́n kAx − bk22

s.a. kxk1 ≤ ρ
Notar que la función objetivo es convexa, su gradiente cumple con la propiedad de Lipschitz y la restricción
es lineal. Para el problema de Regularización-L1, Frank-Wolfe presenta una ventaja muy interesante, ya que
como en cada iteración resuelve el problema:
T
mı́n

∇f xk y − xk
s.a. kyk1 ≤ ρ
entonces, como la solución óptima de este sub-problema se encuentra en un vértice del poliedro D, definido
como D = {x : kyk1 ≤ ρ}. resulta que que este problema es particularmente sencillo de resolver con
Frank-Wolfe, pues la restricción del poliedro D se puede reescribir como:
−tj ≤ yj ≤ tj , ∀j
X n
tj ≤ ρ
j=1
tj ≥ 0
Esta restricción se ilustra en la Figura 3.7. En este caso, los vértices son tales que el óptimo se encuentran en
puntos en que todas sus coordenadas son nulas salvo una que es ρ o −ρ, por lo que no es necesario ejecutar
SIMPLEX, sino simplemente recorrer el vector y ver en que entrada conviene que esté el ρ o −ρ. De este
modo, el algoritmo de Frank-Wolfe va a comenzar con el vector x0 = 0 (vector nulo) que es evidentemente
factible al estar en el centro del espacio D y en el vector x1 resultante de la primera iteración solo una
entrada va a ser distinta de cero cuando se le sume el ȳ resultante de resolver el problema como se plantea
acá (x1 = x0 + α1 ȳ − x0 ). Del mismo modo, en la segunda iteración nuevamente se va agregar una
nueva componente distinta de cero al vector y ası́ sucesivamente, de modo que va a ser posible iterar hasta
alcanzar una solución x en que una determinada cantidad de entradas sean distintas de cero. Esto es algo
muy apropiado, pues lo que se buscaba originalmente era tener una solución con pocas entradas distintas de
cero, y nuestro método va agregando entradas distintas de cero poco a poco.
La mala noticia es que en realidad, este algoritmo no es tan
rápido. Hay un Teorema de Convergencia que
dice que si se usa el paso definido a priori αk = k+2
2
, y xk k es la sucesión de puntos generados por el
algoritmo, entonces:
2L(diam(D))2
f xk ≤ f (x∗ ) +

k+2
Donde diam(D) es el “diámetro” del conjunto D (Cuánto mide el ancho más grande de D). Esto significa
que para llegar a un error > 0, necesitamos un orden de O 1 iteraciones. Lo bueno es que esto se puede
acelerar con away steps. Además, si existe convexidad fuerte esto llega a tener convergencia lineal. Nótese
que el L no se utiliza en el algoritmo, entra solo en el teorema para justificar el error, pero no en la ejecución
de este.
Cápsula de video 3.3.1: Algoritmo de Frank-Wolfe
Profesor Jorge Vera explica en clases los detalles del Algoritmo de Frank-Wolfe.
https: // youtu. be/ EqI118uOu_ Q
3.4. Ejemplos
3.4.1. Función no diferenciable restringida
Consideremos el siguiente problema de optimización en n variables:
n n
mı́n máx{0, (xj − αj )} + xj log xj
P P
j=1 j=1
s.a.
1 ≤ xj ≤ 2 , j = 1, . . . , n
donde los αj son parámetros escalares tales que 1 < αj < 2, para j = 1, . . . , n. Variantes de funciones como
estas aparecen en algunos problemas de estimación estadı́stica. La segunda parte de la función objetivo es
una función de entropı́a. Denotemos por f la función objetivo del problema. Esta función es convexa.
Queremos abordar este problema de optimización con un Método de Primer Orden. Como la función objetivo
es no diferenciable y, además, hay restricciones, desarrollaremos el Método de Subgradiente Proyectado para
este caso particular.
Primero, vamos a determinar una expresión general para ∂f (x) en cualquier punto x relevante (donde esté
definido el problema).
n n
Por comodidad de notación, llamemos g(x) = máx{0, (xj − αj )} y h(x) = xj log xj de modo que la
P P
j=1 j=1
función objetivo sea f = g + h. Tenemos que g es no diferenciable y h es diferenciable. Se puede ver de
inmediato que
∂
= log xj + 1
xj
y eso determina ∇h(x). Por otro lado, para el subdiferencial de g se ve que q ∈ ∂g(x) si tiene la siguiente
forma:
 0

xj < αj
qj = 1 xj > αj
γ ∈ [0, 1] xj = αj

Luego, ∂f (x) = ∂g(x) + {∇h(x)}.

Ahora desarrollamos los pasos principales del método. Vamos a usar el método de subgradiente con el paso
“eficiente” mostrado en el teorema de convergencia. Para el algoritmo necesitamos, entonces, explı́citamente
un subgradiente y necesitamos los parámetros R y L.
Como subgradiente en x vamos a tomar p(x) = máx{0, sgn(x)} + ∇h(x), que está basado en el desarrollo
de a).
Para R, simplemente notemos
√ que todo ocurre dentro de la caja definida por 1 √ ≤ xj ≤ 2 , j = 1, . . . , n ası́
que, por ejemplo, R = 2 n es un número válido. También es más preciso R = n (basado en el diámetro
de la caja en n dimensiones, ya que todos los puntos relevantes estarán ahı́), cualquiera de estos son valores
aceptables.
Para L vamos a usar el resultado que dice que podemos estimar la constante de Lipschitz buscando una
cota superior a kpk, donde p es un subgradiente. Ahora, usemos el subgradiente propuesto y, recordando que
todo pasa dentro de la caja:
kpk2 ≤ k máx{0, sgn(x)}k2 + k∇h(x)k2
√
Ahora, observamos que k máx{0, sgn(x)}k2 ≤ n y que para las derivadas parciales tenemos que, dentro de
la caja:
∂
≤ log 2 + 1
xj
√
ası́ que k∇h(x)k2 ≤ n(1 + log 2) y esto da el valor de L.
El algoritmo serı́a el siguiente:
[H] Sea x0 ∈ Rn , k = 0, −d0 =∈ ∂f (x0 ), > 0. Criterio de parada no se satisface xk+1 = ΠD (xk + λk dk )
−dk+1 ∈ ∂f (xk+1 ) k = k + 1
haciendo N iteraciones y usando un paso λk = √R
L N +1
. En el algoritmo, D es la caja.
Discutamos ahora cómo se aborda el problema de proyección sobre la caja. Recordemos que es fundamental,
para que todos estos algoritmos tengan real sentido práctico, que esta etapa de proyección se pueda hacer
en forma realmente eficiente.
Para esto es más conveniente, para propósitos ilustrativos, pensar en la caja 0 ≤ xj ≤ 1, j = 1, . . . , n. Si
queremos proyectar el punto u ∈ Rn , lo primero que tenemos que hacer es determinar si acaso está o no
dentro de los rangos 0-1 en alguna coordenada. Si 0 ≤ uj ≤ 1, entonces esa coordenada queda igual, es decir.
Por otro lado, si uj < 0, esa coordenada se debe poner en 0 y si uj > 1, se debe llevar a 1. En resumen:
 uj 0 ≤ uj ≤ 1

ΠD (u)j = 0 uj < 0
1 uj > 1

Todo se puede escribir igual para la caja del problema, pero corrido en 1.
3.4.2. Subgradiente de la función “Max”

Consideremos la siguiente función en n variables:
f (x) = máx {aTi x + bi }
i=1,...,m
donde ai ∈ R , i = 1, . . . , m, bi ∈ R.
n
Vamos a ver que f es convexa en el dominio en que está definida. Para esto el argumento se puede hacer
tomando una combinación λx + (1 − λ)y y evaluar:
máx {aTi (λx + (1 − λ)y) + bi } = máx {λaTi x + (1 − λ)aTi y + bi }
i=1,...,m i=1,...,m
= máx {λ(aTi x + bi ) + (1 − λ)(aTi y + bi )}

i=1,...,m
≤ λ máx {aTi x + bi } + (1 − λ) máx {aTi x + bi }

i=1,...,m i=1,...,m
donde en la última relaci+on hemos usado el hecho de que el máximo de una suma se acota superiormente
por la suma de los máximos. Esto prueba la convexidad del primer sumando.
Ahora vamos a desarrollar una expresión para ∂f (x) en cualquier punto del dominio de f . Sea J el conjunto
de ı́ndices donde se alcanza máxi=1,...,m {aTi x + bi }, es decir,
maxi=1,...,m {aTi x + bi } = aTj x + bj , j ∈ J.
Eventualmente, puede tenerse que J contenga sólo un ı́ndice, pero los puntos donde f es no diferenciable son
aquellos donde hay más de un ı́ndice donde se alcanza el máximo. Entonces, consideremos cualquier vector
h perteneciente a
conv{aj , j ∈ J}
Es fácil mostrar que h cumple la definición de subgradiente, es decir:

f (y) ≥ f (x) + hT (y − x)
En efecto, si h = λj aj , con j∈J λj = 1, tenemos:
P P
j∈J
X X X
f (x) + λj aTj (y − x) = f (x) + λj aTj y − λj aTj x
j∈J j∈J j∈J
Pero recordemos que el máximo se alcanza en los ı́ndices J y todo los términos aTj x + bj son iguales al
máximo. Entonces:
X X X
f (x) + λj aTj (y − x) = f (x) + λj aTj y − λj (aTj x + bj − bj )
j∈J j∈J j∈J
X X
= f (x) + λj (aTj y + bj ) − λj (aTj x + bj )
j∈J j∈J
X X
= f (x) + λj (aTj y + bj ) − λj f (x)
j∈J j∈J
X
= f (x) + λj (aTj y + bj ) − f (x)
j∈J
X
= λj (aTj y + bj )
j∈J
X
≤ λj máx{(aTj y + bj ), j = 1, . . . , m}
j∈J
= f (y)
lo que prueba que h es, efectivamente, un subgradiente.
3.4.3. Subgradiente y esfuerzo computacional

Considere la siguiente función, que está definida en Rn :
n
X
f (x) = xT Qx + kAxk22 + máx{αj , x4j }
j=1
donde Q ∈ Rn×n es simétrica y definida positiva, αj > 0, j = 1, . . . , n, A ∈ Rn×n .
Esta función es evidentemente convexa y claramente no diferenciable. En este ejemplo vamos a determinar
subgradientes y también analizaremos el esfuerzo computacional involucrado en el cálculo.
Pn
Para determinar ∂f (x) debemos notar que j=1 max{αj , x4j } no es diferenciable mientras que los demás
términos si lo son.
∇xT Qx = 2Qx debido a que Q es simétrica.
∇kAxk22 = 2AT (Ax)
Pn
Definimos un subdiferencial h para j=1 max{αj , x4j } por lo que tenemos lo siguiente:
√
4x3j


 si xj < − 4 αj


√

4x3j

si xj > αj

 4




√ √

∇h(x) = 0 si − 4 αj < xj < 4 αj


√ √

µ : µ ∈ [4(− 4 αj )3 , 0] xj = − 4 αj

si






√ √

ν : ν ∈ [0, 4( 4 αj )3 ] xj =

si αj
 4
Podemos también estimar una constante de Lipschitz restringida, asumiendo que sabemos que cualquier
valor x que podamos encontrar en los algoritmos cumplirá con que kxk2 ≤ R. Entonces, mostraremos cómo
estimar un valor para una constante de Lipschitz de f que sea válida en una región del espacio Rn de a lo
más radio R desde el origen, es decir, en B(0, R) = {y : kyk2 ≤ R}.
Para esto, lo más sencillo será descomponer por partes el gradiente y usar la propiedad de desigualdad
triangular. Tomando ∇f (x)2 ≤ L se tiene:
√
4x3j


 si xj < − 4 αj


√

4x3j

si xj > αj

 4




√ √

∇f (x) = 2Qx + 2AT (Ax) + 0 si − 4 αj < xj < 4 αj


√ √

 µ : µ ∈ [4(− 4 αj )3 , 0] xj = − 4 αj

si





√ √

ν : ν ∈ [0, 4( 4 αj )3 ] xj =

si αj
 4
∇g(x) = 2Qx
∇p(x) = 2AT (Ax)

√
4x3j


 si xj < − 4 αj


√

4x3j

si xj > αj

 4




√ √

∇h(x) = 0 si − 4 αj < xj < 4 αj


√ √

µ : µ ∈ [4(− 4 αj )3 , 0] xj = − 4 αj

si






√ √

ν : ν ∈ [0, 4( 4 αj )3 ] xj =

si αj
 4
Por lo tanto para cada gradiente tenemos:
∇g(x) → k2Qxk2 ≤ 2kQk2 · kxk2 = 2kQk2 · R
∇p(x) → k2AT (Ax)k2 ≤ 2kAT Ak2 · kxk2 = 2kAT Ak2 · R
√
∇h(x) → n · 4 · R3
Por lo tanto el L nos da: √

L = 2kQk2 · R + 2kAT Ak2 · R + n · 4 · R3
Ahora vamos a estimar el esfuerzo computacional, en flops, de calcular un subgradiente de f . Para estimar
el esfuerzo computacional que se requiere para calcular el subgradiente de f, es necesario analizar cada una
de las componentes por separado:
2Qx → Es una matriz por un vector, ası́ que por lo aprendido en el curso sabemos que el orden es O(n2 ).
2AT (Ax) → (Ax) es una matriz por un vector, que queda como un vector (µ), y luego tenemos AT µ,
lo que es una matriz por vector de nuevo y nos da un orden final de O(n2 ). Alternativamente podemos
tener una matriz A0 = AT A entonces A0 x constituye a una matriz por vector que corresponde a un
orden de O(n2 ).
√
4x3j


 si xj < − 4 αj


√

4x3j

si xj > αj

 4




√ √

∇h(x) = 0 si − 4 αj < xj < 4 αj En el peor de los casos, O(n2 )


√ √

µ : µ ∈ [4(− 4 αj )3 , 0] xj = − 4 αj

si






√ √

ν : ν ∈ [0, 4( 4 αj )3 ] xj =

si αj
 4
Por lo tanto, se concluye que el esfuerzo computacional máximo, en flops, es de O(n2 ).
Entonces, si bien el Método del Subgradiente tiene una iteración sencilla, de la forma xk+1 = xk − λh, que
es O(n), la determinación de los subgradientes hace que el esfuerzo computacional neto por iteración sea
O(n2 )
Capı́tulo 4
Programación Dinámica
En la optimización tradicional se usa un modelo matemático el cual es construido identificando las decisiones
que deben tomarse junto con un objetivo y restricciones que limitan a esas decisiones. Muchas veces se asume
una situación en la cual hay complejas interacciones entre las decisiones o la situación que se ha modelado se
visualiza en forma totalmente estática, vale decir, que corresponde muchas veces a decisiones que se tomarán
una vez en la aplicación del modelo.
Sin embargo, existen muchos problemas en los cuales el proceso de decisiones puede ser visualizado en
etapas secuelciales, en las cuales las decisiones que se debe tomar en una etapa se ven afectadas por las
decisiones de las etapas anteriores en una forma estructurada. Esto es especialmente notorio en el caso de
problemas que tienen un proceso secuencial de decisiones en el tiempo, por ejemplo. Pensar la modelación
del problema considerando estas relaciones entre etapas, además de incorporar el hecho que la información
puede ir cambiando en forma dinámica de una etapa a la siguiente, puede ser muy positivo. La Programación
Dinámica, que presentamos en este capı́tulo, es una metodologı́a algorı́tmica y de modelación para enfocar
problemas de esta naturaleza y resolverlos.
Para entender el contexto de la Programación Dinámica hay que reconocer los tipos de decisión que existen:
1. Decisión estática (offline): Planifica con información disponible al comienzo, luego ejecuta sin
ajustes, descartando pronósticos, decisiones futuras y capacidad de reacción. Ej. Plan de despacho con
clientes disponibles al comienzo del dı́a.
2. Decisión dinámica reactiva (miope): Replanifica cada vez que recibe información (capacidad
reactiva o de feedback) y descarta pronósticos y decisiones futuras al planificar (miope). Ej. Cada vez
que aparece un cliente rediseñar plan de despacho.
3. Decisión dinámica anticipativa (lookahead): Replanifica con pronósticos futuros cada vez que
recibe información (capacidad reactiva online). Ası́, anticipa información, pero no anticipa sus propias
reacciones futuras. Ej. Plan de despacho con rutas que también cubren clientes potenciales.
4. Decisión dinámica proactiva (feedforward): Replanifica online considerando información probabilı́stica
del futuro y decisiones en cada potencial escenario futuro. Ej. Diseño de plan que prevee ajustes del
mismo frente a arribos de clientes futuros.
Como veremos, además, en este capı́tulo, la consideración de incertidumbre se hace clave en las decisiones
dinámicas. El paradigma de decisiones dinámico-estocástico está hoy más presente que nunca ya que en
muchas aplicaciones reales existe incertidumbre en la información relevante, al ejecutar las acciones estas
podrı́an implementarse con desviaciones respecto a lo “óptimo”, etc. Además, existen incertidumbre frente a
los escenarios futuros. pueden ser implementadas con perturbación y a la necesidad de anticipar escenarios
futuros. Más aún, en muchos paradigmas modernos de toma de decisiones se realiza actualización permanente
de la información y de los datos y existe la posibilidad de incorporar esto en el modelo de decisiones.
Hoy en dı́a esto se vuelve cada vez más relevante, sobre todo por la introducción de sensores en la vida
cotidiana, tales como: GPS, cámaras de tráfico, tag en el mundo de la vialidad o puntos de venta y cámaras
de conteo en el “retail”. Ası́, hoy se dispone de mucha información en el tiempo real y el poder de computo
permite preprocesarla e incorporarla en el proceso de toma de decisiones. La Programación Dinámica permite
incorporar estos nuevos paradigmas en la modelación y es lo que ilustraremos brevemente en este capı́tulo.
66
Francisco Garcı́a y Jorge Vera 4.1. Ejemplo introductorio: Desarrollo de problemas recursivos 67
4.1. Ejemplo introductorio: Desarrollo de problemas recursivos

Para introducir este tema, recordemos el problema de la mochila: se tiene una mochila con una determinada
capacidad máxima y se tienen objetos que tienen cierto volumen y valor. El problema consiste en elegir qué
elementos meter en la mochila de modo de maximizar el valor total de lo que se lleva sujeto a el espacio
máximo disponible. El modelo básico de este problema es el siguiente:
xj : número de unidades del ı́tem j a llevar en la mochila. Es la variable de decisión.
aj : volumen unitario del ı́tem j.
ej : valor del ı́tem tipo j.
K: volumen disponible.
El problema de optimización corresponde a uno de Programación Entera que se puede plantear ası́:
n
X
z ∗ = máx ej xj
j=1
Xn
s.a. aj xj ≤ K
j=1
xj ∈ Z+
0, j = 1, . . . n
Este problema se puede pensar de otra manera que no sea Programación Entera, mediante un enfoque
que consiste en descomponer el problema en “etapas” de decisión y el uso de recursiones. Supongamos que
vamos llenando la mochila “de a un tipo de ı́tem a la vez”, en la primera etapa decidimos cuántas unidades
del ı́tem 1 llevaremos. Esta decisión impacta las alternativas disponibles para la segunda etapa, pues el
volumen disponible va a disminuir, donde nuevamente se debe decidir cuántas unidades llevar de 2 y ası́.
Hay un “estado” del “sistema” que cambió: la capacidad disponible de la mochila en una etapa dada, la cual
depende de las decisiones anteriores y de la cual depende cuánto va a caber en las siguientes etapas. Para
explicarlo más simplemente, se muestra el problema con las sumatorias extendidas:
máx e1 x1 + e2 x2 + · · · + en xn
s.a. a1 x1 + a2 x2 + · · · + an xn ≤ K
xj ∈ Z+0, j = 1, . . . n
El uso de estas “etapas” para descomponer el problema consiste que en el problema se fija, en primer lugar, el
valor de x1 , de modo que la función objetivo suma la constante e1 x1 y decide sobre el resto e2 x2 + · · · + en xn
y al valor de k se le resta x1 a1 , de modo que se procede con el siguiente problema de optimización:
cte + máx e2 x2 + · · · + en xn
s.a. a2 x2 + · · · + an xn ≤ K − a1 x1
xj ∈ Z+0, j = 2, . . . n
El problema, antes planteado de la mochila, se puede ver como uno de maximización donde primero se elige
sobre x1 y luego se maximiza sobre el resto. Llámese z ∗ a este valor:

Xn 
máx ej xj

 


 

 


 j=2 


z = máx+ e1 x1 +
∗ Xn
x1 ∈Z0 

 s.a. aj xj ≤ K − a1 x1  

j=2

 


 

xj ∈ Z0 , j = 2, . . . n
+
 
Observamos que el problema “interior” está subordinado a la decisión en el ı́ndice 1 (o etapa 1). Pues si
el valor de x1 cambia, entonces también cambia la capacidad remanente de la mochila. Para simplificar la
notación, definamos el problema Gi (b) como aquel problema de la mochila que decide con solamente los
68 Capı́tulo 4. Programación Dinámica
elementos i, . . . n disponibles a meterse y cuyo estado (que en este caso corresponde al volumen remanente
en la mochila) es b:
n
X
Gi (b) = máx ej xj
j=i
Xn
s.a. aj xj ≤ b
j=i
xj ∈ Z+
0, j = i, . . . n
Notemos que Gi corresponde a un problema con la misma estructura que el original, pero con diferente
rango de etapas y para un b dado. De este modo, el problema original de la mochila con valor óptimo z ∗ , es
lo mismo que:
z ∗ = G1 (K) = máx+ {e1 x1 + G2 (K − a1 x1 )}

x1 ∈Z0
Notemos que el óptimo depende “solo” de la primera decisión, x1 . También, podemos definir una restricción
más explı́cita para x1 :

K
x1 ≤
a1
Tenemos, entonces, la siguiente relación (que se conoce como la Ecuación de Bellman para el problema
de la mochila):
G1 (K) = máx {e1 x1 + G2 (K − a1 x1 )}

x1 ∈Z+
0
K
x1 ≤ a1
Esto se resuelve recursivamente, de modo que define un árbol, desde cuya raı́z salen todos los posibles valores
de x1 y luego, desde cada uno de estos valores sale otra ramificación con los posibles valores de x2 para el
valor correspondiente de la capacidad remanente y ası́ sucesivamente. Lo bueno es que este árbol en realidad
no crece tanto. Este problema se expande de manera recursiva, definiendo G2 (K − a1 x1 ) como un problema
de optimización análogo que depende de e2 x2 :
G2 (b) = máx {e2 x2 + G3 (b − a2 x2 )}

x2 ∈Z+
0
b
x2 ≤ a2
y G3 (b − a2 x2 ) depende de G4 y ası́ sucesivamente hasta el estado n − 1:
Gi (b) = máx+ ∈ Z+
0 {ei xi + Gi+1 (b − ai xi )}
xi ∈Z0
b
xi ≤ ai
Al final, cuando se llega a un estado terminal se pueden encontrar los valores en la etapa n, que se puede
calcular directamente:
Gn (b) = máx {en xn }

xn ∈Z+ 0
xn ≤b abn c
y desde ahı́ es posible “devolverse” por las recursiones para finalmente calcular G1 (K), este proceso
se llama backtracking. Si bien esto diera la impresión de generar una enorme cantidad de combinaciones de
valores, la buena noticia es que el árbol no crece tanto, pues cada vez hay menos capacidad remanente en la
mochila por la restricción:
Francisco Garcı́a y Jorge Vera 4.1. Ejemplo introductorio: Desarrollo de problemas recursivos 69

K − e1 x1 − e2 x2 − . . . − ei−1 xi−1
xi ≤
ai
De este modo, todo el cálculo se puede hacer, en el peor caso, en O(nK) evaluaciones totales (iteraciones)
y muchas combinaciones no es necesario evaluarlas. Además existen ordenes inteligentes en que se puede ir
ramificando, de modo de tener que hacer menos iteraciones.
Cápsula de video 4.1.1: Problema de la Mochila como Programación Dinámica
Profesor Jorge Vera explica en clases el desarrollo del Problema de la Mochila en el formato de
Programación Dinámica.
https: // youtu. be/ Cuhi0eGedN0
4.1.1. Ejemplo del Problema de la Mochila

Para entender mejor la situación, considérese el siguiente caso de problema de mochila de capacidad 10 con
datos numéricos:
z ∗ = G1 (10) = max 3x1 + 6x2 + x3

s.a. 5x1 + 3x2 + 2x3 ≤ 10
xi ∈ Z+
0, i = 1, 2, 3
En primer lugar, se elige sobre x1 , que puede tomar los valores de 0, 1 o 2:
G1 (10) = máx {3x1 + G2 (10 − 5x1 )} = máx {0 + G2 (10), 3 + G2 (5), 6 + G2 (0)}

x1 ∈{0,1,2}
Para calcular esta, se deben calcular G2 (10), G2 (5) y G2 (0):
G2 (10) = máx 6x2 + x3 G2 (5) = máx 6x2 + x3 G2 (0) = máx 6x2 + x3

s.a. 3x2 + 2x3 ≤ 10 s.a. 3x2 + 2x3 ≤ 5 s.a. 3x2 + 2x3 ≤ 0
0 , i = 2, 3
xi ∈ Z+ 0 , i = 2, 3
xi ∈ Z+ 0 , i = 2, 3
xi ∈ Z+
Ahora, estudiemos el caso en que se elige sobre x2 cuando b = 10 y cuando b = 5:
G2 (10) = máx {6x2 + G3 (10 − 3x2 )} = máx {0 + G3 (10), 6 + G3 (7), 12 + G3 (4), 18 + G3 (1)}
x2 ∈{0,1,2,3}
G2 (5) = máx {6x2 + G3 (5 − 3x2 )} = máx {0 + G3 (5), 6 + G3 (2)}

x2 ∈{0,1}
Finalmente, hay que resolver la última etapa, para lo que se tiene la siguiente tabla, donde se detallan las
ganancias óptimas para G3 (b), para distintos valores de b:
b G3 (b) x3
1 0 0
2 1 1
4 2 2
5 2 2
7 3 3
10 5 5
Estos valores se pueden reemplazar en las expresiones para G2 , encontrar los valores de estos, reemplazar
en la expresión de G1 y ası́ finalmente resolver el problema.
Cápsula de video 4.1.2: Problema de la Mochila: ejemplo
Profesor Jorge Vera muestra en clases el desarrollo de un ejemplo de Problema de la Mochila resuelto
mediante Programación Dinámica.
https: // youtu. be/ h3oV9yZGMgA
4.2. La lógica de la Programación Dinámica

La PD fue creada por Richard Bellman alrededor de 1953 para abordar algunas aplicaciones, como, por
ejemplo, la forma de calcular niveles de inventarios de diversos insumos que debı́an ser cargados en barcos
militares. Estos, al igual que el Problema de la Mochila, son problemas de Programación Entera. En ese
sentido, es muy interesante hacer notar que la Programación Dinámica due desarrollada varios años antes
que la técnica de Branch and Bound, ue es la que usamos habitualmente para abordar problemas discretos.
Bellman concivio su técnica pensando precisamente en las relaciones dinámicas del proceso de decisiones e
identificando cicertos principios fundamentales. Estos son los principios:
La búsqueda de soluciones factibles es un proceso que ocurre en etapas: 1, . . . , n y el costo total es la
suma de los costos de las decisiones individuales.
El estado es la condición presente del sistema en la etapa k, es una función de las decisiones históricas
x1 , . . . , xk−1 . Lo interesante es que conocido el estado, no se requiere la historia para atrás. Ejemplos
de estados son: la disposición en que están todas las fichas en un tablero de un juego, el nivel de
inventario, los trabajos pendientes, lo que nos queda de espacio en una mochila, etc. En general se dice
que sk ∈ Sk , que es el Espacio de estados en la etapa k ∈ 1, . . . , n.
Existe un conjunto de acciones que se pueden tomar en cada etapa k que pueden depender del estado
del sistema, de la etapa y de otras restricciones: xk ∈ U (sk )
La dinámica del sistema está descrita por una función de transición (e.g. en la mochila era b − ei xi )
y el costo de cada transición es el costo asociado a la decisión. El estado sk en la etapa k, se calcula a
partir del estado y la acción en la etapa anterior según la función de transición:
sk = fk−1 (sk−1 , xk−1 )
O más genéricamente fk : Sk × Uk → Sk+1 , k ∈ {1, . . . , n − 1}

Hay una función de costos para cada etapa que depende del estado y la acción que se tome en cada
etapa: ck : Sk × Uk → R
Se debe escribir una recursión del costo óptimo (la llamada Ecuación de Bellman del sistema) desde
la etapa actual hasta un estado de destino, de modo de considerar los posibles estados actuales y las
acciones xk ∈ Uk o ∈ U (sk ) que se pueden tomar en cada estado, considerando que estas llevan a un
nuevo estado, dado por la función de transición.
El Principio de Optimalidad de Bellman: Supongamos tenemos una solución óptima al problema,
x1 , x2 , . . . , xN . Sea k < N una etapa intermedia del problema. Entonces, la solución parcial de la etapa
1 a la k, x1 , x2 , . . . , xk es óptima para el problema correspondientes a las etapas de la 1 a la k.
Con todo eso en consideración, se define la función de valor como:
Jk (sk ) = mı́n {gk (sk , xk ) + Jk+1 (fk (sk , xk ))}

xk ∈Uk (sk )
Esto corresponde precisamente a la Ecuación de Bellman. Es el costo mı́nimo de un sistema desde la etapa k
hasta el final de horizonte, dado que el estado del sistema en la etapa k es sk . s (variables de estado) y x son
las “polı́ticas” o “controles” (la solución). De este modo, periodo a periodo se debe definir la polı́tica que está
en el espacio de decisiones que depende de sk (xk ∈ Uk (sk )). gk es la función de costos de la etapa k y fk es
la función de transición de etapas (fk (sk , xk ) = sk+1 ). Se define una condición de borde JN (sN ) = gN (sN ).
El objetivo final es calcular J0 (s0 )
Es importante tener claro el concepto de “Polı́tica”. Una polı́tica π es un vector de decisiones que es función
del estado de cada etapa: π = (x1 , x2 (s2 ) , . . . , xn (sn )) Por otro lado, una polı́tica óptima es un vector
π ∗ = (x∗1 , x∗2 (s2 ) , . . . , x∗n (sn )) que cumple para cada etapa k :
x∗k (sk ) ∈ argmin {ck (sk , xk ) + Ck+1 (fk (sk , xk ))}

xk ∈Uk (sk )
No confundir una polı́tica óptima con una solución óptima (x∗1 , x∗2 , . . . , x∗n ), donde:
x∗2 := x∗2 (f1 (x∗1 ))
x∗3 := x∗3 (f2 (x∗2 , f1 (x∗1 ))),
x∗4 := x∗4 (f3 (x∗3 , f2 (x∗2 , f1 (x∗1 )))) , . . .
Una polı́tica entrega más información, pues indica acciones en cada estado posible del sistema. Una solución
indica acciones en estados visitados por esa “ruta” de decisiones.
Cápsula de video 4.2.1: Los principios de la Programación Dinámica
Profesor Jorge Vera explica en clases los principios de la Programación Dinámica y el Principio de
Optimalidad de Bellman.
https: // youtu. be/ 9K4Hzko-tc0
4.2.1. Algoritmo Backwards DP

Con todo lo mostrado anteriormente, se puede vislumbrar que existe un algoritmo tal que se comienza
teniendo un costo terminal en una etapa t = T y se debe iterar recursivamente desde t = T − 1 hasta t = 1
calculando costos. Con lo que finalmente se puede calcular el costo inicial, que requiere de los costos de las
etapas posteriores que ya se calcularon.
Backward DP
Calcular el Costo Terminal para cada sn ∈ Sn :
Cn (sn ) = mı́n cn (sn , xn )

xn ∈Xn (sn )
for etapa k ∈ {2, . . . , n} :

for estado sk ∈ Sk :
Ck (Sk ) = mı́n ck (Sk , xk ) + Ck+1 (fk (Sk , xk ))

xk ∈Xk (Sk )
Calcular la condición inicial:

C1 = mı́n {c1 (x1 ) + C2 (f1 (x1 ))}
x1 ∈X1
La recursión en su forma aditiva es la Ecuación de Bellman. En esta parte se suma el costo actual ck (Sk , xk )
y el costo óptimo ya calculado en el loop de la etapa siguiente Ck+1 (fk (Sk , xk )).
4.3. Ejemplos
4.3.1. Reemplazo de equipos
En muchos ámbitos industriales hay equipos de alto costo. Durante su vida útil requieren inversión en
mantenimiento, cosa que eventualmente eso se hace demasiado caro. Además, el equipo suele tener un valor
residual. El problema radica en decidir cuándo reemplazar. Supongamos un problema con las siguientes
caracterı́sticas:
Horizonte de N años.
Se reemplaza al comienzo del periodo y no hay reemplazo en el último año.

El “estado” será la edad del equipo al comienzo de un perı́odo determinado. Denotemos por et la edad
al comienzo del periodo t.
I: inversión requerida para un equipo nuevo.
S(n): valor residual de un equipo de edad n.
E0 : edad inicial del equipo.
ct (n): costo operacional de un equipo de edad n en el periodo t.
En el último año, se incurre en el costo de operación y el equipo se “vende” por su valor residual.
Para tratar este problema, utilizamos una función de costo ft (et ), que corresponde al costo total
mı́nimo desde el periodo t hasta el final del horizonte para un equipo de edad et . Tenemos que calcular
f1 (E0 )
La recursión para este problema se basa en el hecho que el problema sigue una linea de tiempo para cada
año entre 1 y N . En cada año se debe tomar la desición si reemplazar o no. Veamos para el año t un vehı́culo
con edad et : En caso de reemplazar, se incurre en el costo de inversión del equipo nuevo I, en el dinero que se
gana por la venta del equipo S(et ) y en el costo operacional del equipo nuevo en el periodo correspondiente
ct (0). Si no se reemplaza, se paga únicamente el costo operacional ct (et ). En resumen, si se reemplaza se
incurre en un costo inmediato de I − S(et ) + ct (0), mientras que si no se remplaza se incurre en un costo
inmediato de solo ct (et ). Además, en el primer caso se debe considerar el costo mı́nimo para el siguiente
periodo considerando que se tiene un equipo con un año de uso, por lo que esto corresponde a ft+1 (1). De
manera similar, si no se reemplaza este valor es de ft+1 (et + 1).
De este modo, la función de recursión de Bellman sin considarar el año n es:
ft (et ) = mı́n {reemplazar, conservar}

= mı́n {I − S (et ) + ct (0) + ft+1 (1), ct (et ) + ft+1 (et + 1)}
Para el caso de estar en el periodo N , simplemente se paga el costo por operar el vehı́culo cN (eN ) y se gana
el costo remanente de este S(eN ):
fN (eN ) = cN (eN ) − S (eN )
Notar que este problema, al ser dependiente del tiempo, entonces no se puede desordenar los ordenes en que
se despliega la recursión del costo óptimo ft (et ), tal como sı́ se podı́a hacer en el problema de la mochila.
Notar también que acá hay una función de transición que, dado un estado (edad del vehı́culo) y una decisión
(reemplazar o no reemplazar), dice cuál es el valor que se evalúa en ft+1 . En este caso la función es:
(
edad + 1, Si no reemplazo
función de transición(edad) =
1, Si reemplazo
Reemplazo de equipo: ejemplo numérico

Considere el siguiente caso particular donde se quiere determinar la polı́tica óptima de reemplazo de un
equipo sobre un horizonte de 5 años: la inversión en un equipo nuevo es I = 30 (unidades monetarias).
Los valores residuales están dados por la siguiente tabla:
Edad 1 2 3 4 5
S 20 15 10 5 2
y el costo de operación y mantenimiento ánual está dado por:

Edad 0 1 2 3 4 5
S 5 7 20 30 45 60
Suponga que se parte con un equipo nuevo. Determine el plan óptimo de reemplazo usando la formulación
de Programación Dinámica que vimos en clases.
Respuesta: Acá vamos a iterar la relación que vimos en clases para el problema de reemplazo:
ft (et ) = mı́n{I − V (et ) + C(0) + ft+1 (1), ft+1 (et + 1) + C(et )}
usando los datos entregados. En lo que sigue se muestra primero el desarrollo de las recuersiones, y se
calculan los valores asociados a los datos y, después, se hace el “backtracking”. Lo que tenemos que calcular
de base es f1 (0). Tenemos entonces:
f1 (0) = mı́n{I − S(0) + C(0) + f2 (1), C(0) + f2 (1)}
El valor de S(0) noe stá dado en la tabla pero, dado que es valor residual, el valor de un eqipo nuevo es,
básicamente, igual o un poco menor al valor del equipo. Esto significa que I − S(0) > 0. Esto equivale a
imponer que en el primer año no se reemplaza. Luego,
f1 (0) = C(0) + f2 (1) = 5 + f2 (1)
Entonces:
f2 (1) = mı́n{I − S(1) + C(0) + f3 (1), C(1) + f3 (2)}

= mı́n{30 − 20 + 5 + f3 (1), 7 + f3 (2)} = mı́n{15 + f3 (1), 7 + f3 (2)}
f3 (1) = mı́n{I − S(1) + C(0) + f4 (1), C(1) + f4 (2)}
= mı́n{30 − 20 + 5 + f4 (1), 7 + f4 (2)} = mı́n{15 + f4 (1), 7 + f4 (2)}
f3 (2) = mı́n{I − S(2) + C(0) + f4 (1), C(2) + f4 (3)}
= mı́n{30 − 15 + 5 + f4 (1), 20 + f4 (3)} = mı́n{20 + f4 (1), 20 + f4 (3)}
f4 (1) = mı́n{I − S(1) + C(0) + f5 (1), C(1) + f5 (2)}
= mı́n{30 − 20 + 5 + f5 (1), 7 + f5 (2)} = mı́n{15 + f5 (1), 7 + f5 (2)}
f4 (2) = mı́n{I − S(2) + C(0) + f5 (1), C(2) + f5 (3)}
= mı́n{30 − 15 + 5 + f5 (1), 20 + f5 (3)} = mı́n{20 + f5 (1), 20 + f5 (3)}
f4 (3) = mı́n{I − S(3) + C(0) + f5 (1), C(3) + f5 (4)}
= mı́n{30 − 10 + 5 + f5 (1), 30 + f5 (4)} = mı́n{25 + f5 (1), 30 + f5 (4)}
Ahora evaluamos las “condiciones de borde” o condiciones finales (en este caso), tal como estaban en el
desarrollo en clases:
f5 (1) = C(1) − S(1) = 7 − 20 = −13

f5 (2) = C(2) − S(2) = 20 − 15 = 5
f5 (3) = C(3) − S(3) = 30 − 10 = 20
f5 (4) = C(4) − S(4) = 45 − 5 = 40
Con esto, podemos hacer el backtracking. En cada etapa, marcaremos lo que implica el alcanzar el mı́nimo,
si “reemplazo” o “conservar”. Esto permitirá obtener la polı́tica completa al final:
f4 (3) = mı́n{25 + f5 (1), 30 + f5 (4)}

= mı́n{25 − 13, 30 + 40} = mı́n{12, 70} = 12 reemplazar
f4 (2) = mı́n{20 + f5 (1), 20 + f5 (3)}
f4 (1) = mı́n{15 + f5 (1), 7 + f5 (2)}
f3 (2) = mı́n{20 + f4 (1), 20 + f4 (3)}
= mı́n{20 + 2, 20 + 12} = mı́n{22, 32} = 22 reemplazar
f3 (1) = mı́n{15 + f4 (1), 7 + f4 (2)}
= mı́n{15 + 2, 7 + 7} = mı́n{17, 14} = 14 conservar
f2 (1) = mı́n{15 + f3 (1), 7 + f3 (2)}
= mı́n{15 + 14, 7 + 22} = mı́n{29, 29} = 14 indiferente entre conservar o reemplazar
f1 (0) = 5 + f2 (1) = 5 + 29 = 34
Luego, un plan de reemplazo óptimo es: conservar el primer año, reemplazar en el segundo año, conservar
en el tercer año, y reemplazar en el cuarto año para conservar en el último. El otro plan alternativo es:
conservar el primer año, conservar en el segundo año, reemplazar en el tercer año, y reemplazar en el cuarto
año para conservar en el último. Ambos planes tiene un valor de 34.
4.3.2. Compra de acciones

Este ejemplo es una simplificación de un problema en el área financiera. Tenemos que tomar decisiones sobre
la compra de acciones a lo largo de varios periodos de tiempo, pero tenemos un capital limitado total. El
problema es que el precio de las acciones se ve afectado por nuestras propias decisiones de compra y eso
afecta lo que podemos hacer en los periodos futuros. Tenemos un cierto capital total K para invertir en
acciones y la idea es que en un horizonte de T periodos en que podemos comprar acciones, maximicemos el
valor que se extrae del rendimiento de estas. El problema tiene las siguientes caracterı́sticas:
xt : variable de la cantidad de acciones a comprar en el periodo t
et : rendimiento que la acción tendrá al final del horizonte, si se compra en el periodo t.
pt : precio de la acción en el periodo t.
pt = pt−1 + αt xt−1 , donde αt y pt son conocidos.
La pregunta es cuántas acciones comprar en cada periodo para maximizar el rendimiento total.
El problema base serı́a una modificación del problema de la mochila de no ser por el hecho que queremos
incorporar la evolución del precio, lo que le da una dinámica natural al problema. El problema de optimización
para esto, se puede plantear como:
T
X
máx et xt
t=1
T
X
s.a. pt xt ≤ K
t=1
pt = pt−1 + αt xt−1 , t = 1, . . . , T
xt ∈ Z+
0, t = 1...,T
Acá, se dispone de información del precio inicial, p0 , y se puede suponer que x0 = 0. Este modelo no es lineal
(tanto p como x son variables y hay un producto de ellas), por lo que puede ser muy difı́cil de resolver, pero
se puede llevar a una formulación de PD. Para esto, es necesario definir la función de recursión que, como
se dijo anteriormente depende del estado. El estado es fundamentalmente el capital remanente b y el precio
de las acciones p. Para esto se define la siguiente función de recursión:
Gt (b, p) = Mejor valor de negocio desde la etapa t hasta el final si tengo b de capital y precio actual p.
Esta función recursiva es de la siguiente manera:
Gt (b, p) = máx+ {et xt + Gt+1 (b − pxt , p + αt xt )}

xi ∈Z0
xi ≤b pb c
Para ver cómo será el argumento de Gt+1 hay que pensar que existe una función de transición que hace
cambiar el estado del sistema entre t y t + 1. Como el estado se comprende por b y p, entonces hay que
analizar como cambian b y p. El capital remanente claramente disminuye en pxt y el precio aumenta en αt xt .
La función de transición es
b − px
ft ((b, p), x) =
p + αt x
Cápsula de video 4.3.1: Ejemplos de Reemplazo y compra de acciones
Profesor Jorge Vera discute en clases los ejemplos anteriores.

https: // youtu. be/ AJHugh6iJM0
4.3.3. El Problema de la ruta más corta

Este es un problema clásico en Investigación de Operaciones y tiene aplicaciones en los más diversos ámbitos.
Tenemos un grafo dirigido G = (N, A), cada arco (i, j) ∈ A tiene un costo generalizado cij . Sea el nodo s
el “origen”, y el nodo t el “destino”. El problema es encontrar un camino que conecte s con t y que sea de
costo mı́nimo. Este problema tı́picamente se resuelva con el algoritmo de Dijkstra, pero también se puede
resolver utilizando Programación Dinámica.
Sea d(i) = el largo de la ruta más corta de s a i. Podemos pensar el problema como uno en que se busca
la ruta más corta desde s a i tal que exista el arco (i, t), de modo que la suma de los costos de ir de s a i
(d(i)) y de ir de i a t (cit ) sea la menor posible. Con esta idea en mente, postulamos la recursión que dice
que la ruta más corta para ir a i es corresponde al mı́nimo de la suma de la ruta m´´as corta a un nodo k
y el costo de ir de k a i, cki :
d(i) = mı́n {d(k) + cki } , d(s) = 0

k∈N \{i}
El problema que existe es qué se debe decidir en que orden calcular los d(i). Esto se repara definiendo el
estado como el nodo actual y el número de nodos utilizados para llegar a él. Sea Dn (i) el largo de la ruta
más corta de s a i usando a lo más n nodos. Entonces, esto se puede escribir recursivamente como el mı́nimo
entre la ruta más corta a i en n − 1 pasos o la suma de la ruta más corta a k en n − 1 pasos más el costo
del arco (k, i):

Dn (i) = mı́n Dn−1 (i), mı́n {Dn−1 (k) + cki } , D0 (i) = 0
k∈N \{i}
El algoritmo de Dijkstra mejora aún más estas etapas y por eso conserva un “sabor” de PD.
4.3.4. El problema del Vendedor Viajero

Este es otro problema clásico y con muchas aplicaciones. Tenemos un grafo G = (N, A), donde N es el
conjunto de nodos (digamos que hay n nodos) y A es el conjunto de arcos. Existe un costo de viaje cij
para cada arco (i, j) ∈ A. El proble es encontrar un camino que parte desde, digamos, el nodo 1 ∈ N ,
pasa por todos los otros nodos sólo una vez y regresa a 1. Este es un problema muy famoso, difı́cil de
resolver hasta la optimalidad, y que da origen a una serie de otros problemas relacionados con aplicaciones
muy importante (los problemas de ruteo en logı́stica, por ejemplo). Vamos a escribir una formulación de
Programación Dinámica para este problema.
Primero, supongamos que se tiene un circuito de vendedor viajero óptimo, que consiste en la siguiente
secuencia de nodos vistados: (i1 = 1, i2 , i3 , . . . , in , 1), con ij ∈ N , (parte de 1, pasa por todos los otros
nodos en algún orden y regresa a 1). Vamos a mostrar que si consideramos el conjunto de nodos C =
{1, i2 , i3 , . . . , ik }, para k < n, entonces el camino definido por la secuencia (i1 = 1, i2 , i3 , . . . , ik ) es el camino
más corto que parte en 1, recorre todos los otros nodos de C una sola vez y termina en ik . Es decir, se
cumple el Principio de Optimalidad de Bellman.
Esto se argumenta por contradicción. En efecto, si existiera otra secuencia de nodos distinta que va de
1 a ik , digamos (i1 = 1, j2 , j3 , . . . , ik ), y tal que su largo sea estrictamente menor que el de la secuencia
(i1 = 1, i2 , i3 , . . . , ik ), entonces el circuito de Vendedor Viajero (i1 = 1, j2 , j3 , . . . , ik , ik+1 , . . . , in , 1) tendrı́a
un largo estrictamente menor que el original (i1 = 1, i2 , i3 , . . . , in , 1), lo que contradice la optimalidad de
este último.
Ahora, supongmosa que consideramos un nodo k ∈ N y un subconjunto de los nodos, S ⊂ N , y sea C(k, S)
el costo mı́nimo de, partiendo en el nodo k, visitar todo los nodos en el conjunto S exactamente una vez y
terminar en el nodo 1. De este modo, el costo del circuito de vendedor viajero óptimo, z ∗ , está dado por:
z ∗ = C(1, N − {1})
Usando esta función C(k, S) podemos desarrollar una formulación de Programación Dinámica para el
problema. Para esto hay que, primero, visualizar que C(1, N − {1}) es efectivamente el largo del circuito
óptimo. Esto sale del hecho que C(k, N − {1}) es el largo del circuito óptimo que parte de k, recorre todos
los otros nodos de N y termina en 1. Luego, partiendo de k = 1, regresamos al punto de partida.
Ahora, consideremos C(k, S) en general. Si partimos de k, vamos a ir a un siguiente nodo en S. Este puede
ser cualquiera de esos nodos de S, ası́ que podemos separar la etapa que va de k a ese nodo j, y a partir
de j, pensar en el mejor circuito que recorre los restantes nodos y termina en 1. Si probamos todos los j
posibles en S, distintos a k, el menor de todos los largos es el circuito más corto de k a 1. Es decir,
C(k, S) = mı́n {Ckj + C(j, S − {j})}

j∈S,j6=k
Esta es la recursión que deberı́a usarse si se quiere resolver el problema usando Programación Dinámica
(cosa que, en realidad, no se hace debido a la explosión de dimensión, el problema es muy difı́cil, en general).
4.3.5. Trabajo general sobre rutas

Para mostrar el potencial de P.D. se muestra su aplicación para contar, minimizar distancias, minimizar
arco más caro y minimizar multiplicaciones dentro de una ruta (notar que son funciones crecientes). Para
esto, consideremos un tablero de ajedrez, donde existen tres movimientos: a la derecha-arriba, derecha,
derecha-abajo. El estado en cada etapa (columna) k es la fila sk ∈ {1, . . . , 8}, pues resume la información
suficiente para tomar decisiones óptimas hacia adelante. La función de transición de estados es entonces
sk = fk−1 (sk−1 , xk−1 ) :
 sk−1 − 1 si xk−1 = abajo


fk := sk−1 si xk−1 = derecho

sk−1 + 1 si xk−1 = arriba

En primer lugar, las rutas pueden ser muchas, pero se puede calcular la cantidad de rutas desde un punto
a a un punto b de manera recursiva y sin tanto cómputo. Lo que se puede hacer es llevar un conteo, para
cada casilla, cuántas rutas hay para ahı́, de modo que se va viendo columna por columna (de izquierda a
derecha) y la cantidad de rutas que existen para llegar a una casilla, puede calcularse como la suma de las
opciones para llegar a los estados anteriores (Ver Figura 4.1).
Lo interesante es que para enumerar 357 rutas, se realizaron tan solo 56 cálculos. Esto se podrı́a escribir en
un código de la siguiente manera, donde Vij es el número de rutas diferentes para acceder a fila i y columna
j desde (4, 1):
Figura 4.1: Enumeración eficiente de rutas para cada casilla (Fuente: Curso “Optimización Dinámica”, del
Prof. Mathias Klapp)
Inicio: V41 = 1, Vi1 = 0 para i 6= 4

for j = 2, . . . , 8:
for i = 1, . . . , 8:
Vij = Vi,j−1 + Ii>1 · Vi−1,j−1 + Ii<8 · Vi+1,j−1
Retornar V5,8
Notar que este mismo procedimiento se podrı́a aplicar hacia atrás y se parı́an podar los estados que al final
resultan innecesarios de calcular, ya que nunca le sirve de ruta para llegar a b.
Con un argumento similar, se podrı́a encontrar la ruta de menor costo aditivo, para lo que para cualquier
casillero, se deberı́a guardar el menor costo con que se puede llegar ahı́. Como no hay costos negativos ni
ciclos, entonces con guardar esta información, bastará para ir construyendo rutas mı́nimas a medida que se
valla avanzando por las columnas del tablero de izquierda a derecha. Para esto definamos lo siguiente:
di,k : costo por moverse desde fila i hacia fila k.
ij : fila usada en columna j.
P7
Buscamos ruta {i1 , i2 , . . . , i8 } con i1 = 4, i8 = 5 de mı́nimo valor j=1 dij ,ij+1 .
Cij : costo mı́nimo para alcanzar fila i en columna j.
Inicio: C41 = 0, Ci1 = ∞ para todo i 6= 4

for j = 2, . . . , 8:
for i = 1, . . . , 8:
Cij = mı́n {Ci,j−1 + di,i ; Ci−1,j−1 + di−1,i ; Ci+1,j−1 + di+1,i }
Retornar C5,8
Notar que con este procedimiento tampoco hay que enumerar las 357 rutas para escoger la mejor. Ahora,
con un argumento similar se puede implementar un algoritmo para buscar la ruta de mı́nimo costo máximo.
Acá buscamos {i1 , i2 , . . . , i8 } con i1 = 4, i8 = 5 de minimo valor máxj=1,...,7 dij ,ij+1 :

for j = 2, . . . , 8:
for i = 1, . . . , 8:
Cij = mı́n {máx (Ci,j−1 , di,i ) ; máx (Ci−1,j−1 , di−1,i ) ; máx (Ci+1,j−1 , di+1,i )}
Retornar C5,8
Ahora, de manera análoga, supongamos que costo se inicia en 1 y que es multiplicado por un factor fi,q > 0
al
Q moverse desde la fila i hacia la fila q. Buscamos {i1 , i2 , . . . , i8 } con i1 = 4, i8 = 5 de minimo valor
i=1,...,7 fij ,ij+1 .

for j = 2, . . . , 8:
for i = 1, . . . , 8:
Cij = mı́n {Ci,j−1 · fi,i ; Ci+1,j−1 · fi+1,i ; Ci−1,j−1 · fi−1,i }
Retornar C5,8
En este último caso, si hay costos negativos, entonces no necesariamente se alcanza el óptimo. Es muy fácil
inventarse un contraejemplo. Esto se debe a un teorema que le da validez al principio de recursión para
descomponer los costos, para lo que básicamente, la función de costos debe ser continua no decreciente.
Notar en todos los ejemplos de pseudo algoritmos anteriores, en el loop, en cada iteración se recoge
información de la iteración anterior.
4.3.6. Loteo dinámico no capacitado (ULS)

En la gestión de las operaciones industriales de todo tipo una pregunta fundamental se relaciona a las
cantidades que debe ordenarse para producción de manera tal de contar con inventario suficiente para poder
satisfacer una cierta demanda. Un primer acercamiento a esto es el problema que presentamos aquı́. El uso
de PD para el problema ULS fue desarrollado por Wagner y Whiting en la década de 1950 y desde ahı́ abrió
un gran desarrollo en lo que se conoce como “Teorı́a de Inventarios”. El problema puede ser visto también
como una versión del problema de planificación de producción “con setups”, es decir existe costo fijo por
producir. Suponemos que existe una demanda por un producto a lo largo del tiempo y en cada periodo se
debe decidir si producir o no y cuánto. Hay un costo variable de producción y también un costo fijo (o setup)
cada vez que se produce. Los datos son:
T periodos y un producto.
dt : demanda en el periodo t.
ct : costo de producción en t
ht : costo de inventario en t.
Ft : costo de set-up en el periodo t.
Se usan tres variables:
xt : producción en t,
It : inventario que se acarrea de t a t + 1,
zt : 1 si en t se produce, 0 si no.
El modelo de este problema de optimización tiene por función objetivo minimizar los costos totales para
todos los periodos. Las restricciones son: conservación del inventario, relación entre las variables xt y zt :
PT
mı́n t=1 {ct xt + ht It + Ft zt }
s.t. It = It−1 + xt − dt , t = 1, . . . , T
U LS)
xt ≤ M z t , t = 1, . . . , T
xt ≥ 0, It , ≥ 0, zt ∈ {0, 1}, t = 1, . . . , T
Donde I0 es el inventario inicial “en mano” y M es “grande”. Una formulación dinámica natural se basa
en identificar el estado del sistema con la cantidad de inventario disponible. Con eso, podemos definir una
función de recursión que depende del inventario, Ht (I), que corresponda al costo del plan de producción
desde 1 a t, con un inventario inicial I. Esta se podrı́a escribir de la siguiente manera:
Ht (I) = mı́n {ct xt + ht (I + xt − dt ) + Ft zt + Ht+1 (I + xt − dt )}

zt ∈{0,1}
0≤xt ≤M zt
Desgraciadamente esta ecuación de Bellman no va a ser de utilidad puesto que xt es una variable continua lo
que dificulta “enumerar” sus posibles valores, de forma similar a como lo hicimos en algunos de los ejemplos
anteriores. Sin embargo, el problema anterior puede interpretarse en una estructura de red, como explicamos
a continuación. Supongamos, para simplificar que I0 = 0. La red tiene la forma mostrada en la Figura 4.2.
La demanda total del todo el horizonte debe cumplirse de alguna forma, entonces la representación usa un
nodo, el de arriba, que envı́a esa demanda a cada uno de T nodos que representan los periodo de tiempo.
En cada uno de estos, se puede ver que existe el balance de que lo queda en inventario para el periodo
siguiente es igual a lo que habı́a de inventario desde el periodo anterior, más lo que se produce, menos lo
que se demanda. De este modo la red está balanceada. El problema de loteo puede ser visto, entonces, como
un problema de “diseño de red” ya que los arcos a diseñar son los de producción (que en el modelo llevan
asociadas las variables binarias del costo fijo), por lo que los arcos que conectan al nodo 0 con la bodega
Figura 4.2: Esquema de LotSizing
para cada periodo existen solo si se produce en dicho periodo. Se puede demostrar que la solución óptima
del diseño es un árbol y que una solución óptima cumple con las siguientes caracterı́sticas:
(1) La solución es tal que xt It−1 = 0, t = 1, . . . , T

Pi=t+k
(2) La solución es tal que si xt > 0, entonces existe k ≥ 0 tal que: xt = i=t di
Es decir, por (1), entonces o se tiene inventario del dı́a anterior o se produce cuando el inventario se ha
agotado y por (2) la cantidad producida es igual a la demanda de una cantidad de periodos consecutivos.
Con lo anterior se puede desarrollar una relación de PD. Denotemos por H(k) el costo óptimo de una solución
para los perı́odos 1 . . . , k. Sea t ≤ k el último perı́odo anterior a k en donde hubo producción. Entonces
podemos escribir un problema donde la variable de desición es hasta cuánto tiempo producir:
H(k) = mı́n {H(t − 1) + Ft + costo de prod. e inv. entre t y k}

1≤t≤k
Pk
Aquı́ notamos cómo será el costo entre t y k: En t se fabrica la demanda entre t y k, xt = j=t dj , lo que
cuesta ct xt . El costo en que se incurre por inventarios, considera que la cantidad de productos en inventario
van disminuyendo sucesivamente en cada en cada periodo por la llegada de la demanda. De modo que los
costos son de la siguiente manera:
     
k
X k
X k
X
ht  dj  + ht+1  dj  + ht+2  dj  + . . .
j=t j=t+1 j=t+2
Con lo anterior se puede desarrollar una relación de PD. Sean:
t
X T
X
dit = dj , gt = ct + hi
j=i i=t
Entonces podemos escribir:
H(k) = mı́n {H(t − 1) + Ft + gt dtk } , H(0) = 0

1≤t≤k
Nos interesa encontrar H(T ), el mı́nimo para 1, . . . , T . Usar el procedimiento de PD en esta recursión permite
resolver el problema en O T 2 iteraciones (o evaluaciones).
Se puede extender el análisis al caso capacitado (donde M es una capacidad real de producción), pero ese
problema es más difı́cil de resolver, (es “NP-Completo”), y en ese caso el procedimiento de programación
Dinámica se transforma en una heurı́stica: la Heurı́stica de Wagner-Whiting, moy conocida y aplicada en el
área de Gestión de Operaciones.
4.3.7. Programación de una cadena de hornos industriales

Un sistema industrial requiere que un cierto material pase por una secuencia de N hornos, cada uno de los
cuales funciona a una cierta temperatura. La temperatura de funcionamiento del horno i la denotaremos
por ui . En general, el material entra al horno i con una temperatura (que viene de la salida del horno i − 1)
igual a ti−1 y sale con una temperatura ti dada por
ti = (1 − α)ti−1 + αui
donde α ∈ (0, 1) es una parámetro conocido. Se aspira a que la temperatura final del material sea lo más
cercana a un objetivo T , y se incurre en un costo por la desviación con respecto a ese objetivo. Adicionalmente,
hay un costo de energı́a asociado a la temperatura del horno i que es de la forma u2i . Entonces, el costo del
sistema completo puede ser modelado como el costo de la desviación de la temperatura final respecto a la
meta más los costos de energı́a de los hornos. Es decir:
r(tN − T )2 + u21 + u22 + · · · + u2N
donde r > 0 es un parámetro conocido.

Queremos encontrar las temperaturas óptimas, ui , que minimizan el costo de todo el sistema. Esto se puede
formular como un problema de Programación Dinámica. Para esto asumimos que la temperatura inicial del
material (entrada al horno 1) es igual a t0 .
El modelo de Programación Dinámica se construye con los siguientes elementos:
Etapas: K = {1, . . . , N }. En la etapa n se decide qué temperatura poner en el horno n.
Estados: tn−1 ∈ R0+ . Corresponde al valor de la temperatura con que llegan los productos al horno t,
una vez que ya se han calentado los productos anteriores.
Acciones: Xn (tn−1 ) = {un ∈ R0+ . Corresponde a decidir cuánto calor un poner el horno n, dado que
el producto tiene una temperatura de tn−1 .
Función de Transición:
f (tn−1 , un ) −→ ((1 − α)tn−1 + αun )
Corresponde a la temperatura final que tiene el producto cuando sale del horno n, dado de que llegó
con temperatura t − 1 y se le agregó un calor un
Ecuaciones terminales: Por simplicidad, se crea una etapa final artificial que sirve para ser etapa
de borde que tan solo calcula el costo asociado a la diferencia con la temperatura deseada:
2
VN +1 (tN ) = r · (tN − T )
Ecuaciones recursivas de Bellman: Para la etapa N se considera el costo de la misma etapa

N , lo que corresponde al calor que se le asigna al horno N y se le suma el valor de borde que es
VN +1 ((1 − α)tN −1 + αuN ):
VN (tN −1 ) = mı́n+ u2N + VN +1 ((1 − α)tN −1 + αuN )

uN ∈R0
Similarmente, para el horno N − 1, la función recursiva tiene la siguiente forma:
VN −1 (tN −2 ) = mı́n uN −1 + VN ((1 − α)tN −2 + αuN −1 )

2
uN −1 ∈R+
0
Continuando con la misma lógica, la recursión DP es para la iteración n en general:
Vn (tn−1 ) = mı́n+ u2n + Vn+1 ((1 − α)tn−1 + αun )

un ∈R0
Finalmente, se debe calcular V1 (t0 ) para encontrar el óptimo.

Francisco Garcı́a y Jorge Vera 4.4. Procesos de decisión Markoviana 81
Considerando, por ejemplo la situación en que hay 2 hornos, N = 2, es posible encontrar explı́citamente una
relación algebraica general para la polı́tica óptima de temperaturas. Tenemos que la condición final, en este
caso, es:
2
V3 (t2 ) = r (t2 − T ) y V2 (t1 ) = mı́n u22 + J3 ((1 − α)t1 + αu2 )

u2
Reemplazamos la expresión de V3 en V2 :
n o
2
V2 (t1 ) = mı́n u22 + r (((1 − α)t1 + αu2 ) − T )
u2
Aquı́ se puede encontrar una solución explicita para la polı́tica debido a que el problema es cuadrático. Basta
derivar e igualar a 0, lo que resuelve la polı́tica de control:
2
rα (T − (1 − α)t1 ) r ((1 − α)t1 − T )
2u2 +2rα ((1 − α)t1 + αu2 − T ) = 0 −→ u∗2 (t1 ) = −→ V2∗ (t1 ) =
1 + rα2 1 + rα2
y esto da el costo óptimo de operación del horno 2, dada una temperatura de entrada t1 . Ahora nos vamos
a la etapa 1:
( 2 )
Reempla- r (1 − α)2 t0 + (1 − α)αt0 − T
V1 (t0 ) = mı́n u1 + J2 ((1 − α)t0 + αu1 ) V1 (t0 ) = mı́n u1 +
2 2
u1 zando V2 : u1 1 + rα2
Derivando e igualando a 0 se obtiene la polı́tica de temperatura para el horno 1:
2
r(1 − α)α T − (1 − α)2 t0 r (1 − α)2 t0 − T

u∗1 (t0 ) = −→ V1∗ (t0 ) =
1 + ra2 (1 + (1 − α)2 ) 1 + rα2 (1 + (1 − α)2 )
Es interesante hacer notar, en este problema, que la polı́tica toma valores continuos, a diferencia de los otros
ejemplos que hemos estudiado en donde la polı́tica toma valores discretos. Esto muestra que la aplicabilidad
de la PD es mucho más amplia. También debe hacerse notar que la posibilidad de desarrollar fórmulas
explicitas para la polı́tica y el costo se da aquı́ por el hecho de que el costo es cuadrático. Esto es un
resultado más general: si los costos son cuadráticos y la transición del sistema es lineal, entonces siempre se
pueden encontrar soluciones explicitas para el sistema.
4.4. Procesos de decisión Markoviana

La PD se hace especialmente importante cuando se consideran problema bajo incertidumbre. En muchas
aplicaciones hay elementos estocásticos que afectan el comportamiento del sistema (Ver Figura 4.3). Por
ejemplo, en el problema de compra de acciones el precio es, en realidad, una variable aleatoria que sigue
dependiendo de la cantidad comprada pero que sufre perturbaciones.
Figura 4.3: Paradigma de la Optimización Dinámica con aleatoriedad (Fuente: Mathias Klapp)
Formalmente, sea wk ∈ Wk un vector de parámetros aleatorio. La función de transición se ve afectada por

la aleatoriedad y es, en este caso:
sk+1 = fk (sk , xk , wk )
La aleatoriedad puede afectar también a los costos gk y a las restricciones.

Se define, entonces, la función de valor del problema, escrita en forma dinámica, como aquella que minimiza
el costo esperado desde el momento actual hasta el final del horizonte:
Jk (sk ) = mı́n E {gk (sk , xk , wk ) + Jk+1 (fk (sk , xk , wk ))}

xk ∈Uk (sk ,wk )
Por ejemplo, podrı́a ser que el sistema puede estar en un estado i ∈ {1, . . . , N } y el pasar de un estado sk a
otro sk+1 de una etapa a la siguiente, dependa de una probabilidad de transición y de la acción xk que se
tome en la etapa pk : Sk × Xk → Sk+1 :
pk (xk , i, j) = P rob (sk+1 = j/sk = i, acción = xk )
Un sistema de este tipo, donde la probabilidad depende de la etapa anterior y no de las antecedentes a
la anterior, se dice “Markoviano”. Supongamos que los costos de la etapa, gk , son determinı́sticos una vez
definido el estado y la acción. Entonces, el problema puede escribirse, en forma dinámica:
 
 N
X 
Jk (i) = mı́n gk (i, xk ) + pk (xk , i, j) Jk+1 (j)
xk ∈Uk (i)  
j=1
PN
Donde gk (i, xk ) es el costo de la etapa actual y j=1 pk (xk , i, j) Jk+1 (j) es el costo esperado de la etapa
siguiente. Nos interesa, por ejemplo, J1 (i0 ), donde i0 es el estado inicial del sistema. Este problema se conoce
como un “Problema de Decisión Markoviano” (MDP, Markovian Decision Process).
Backward DP para MDP
Valor terminal:
JT∗ (s), d∗T (s) ← mı́n {gT (s, xT )} , ∀s ∈ ST

x∈Xt (s)
for t = T − 1, . . . , 1:
for s ∈ St :
 
 N
X 
Jt∗ (s), d∗t (s) ← mı́n gt (s, xt ) + pk (xk , i, j) Jk+1
∗
(j)
x∈Xt (s)  
j=1
Retornar: π ∗ = d∗1 , d∗2 , . . . , d∗T −1

Muchas veces las decisiones, o polı́ticas, son además discretas, lo que conecta el problema con la Programación
Entera.
La PD Estocástica tiene amplias aplicaciones en Finanzas, problemas de Pricing y Revenue Management,
planificación bajo incertidumbre en, por ejemplo, el sector eléctrico, decisiones dinámicas en logı́stica, etc.
Hoy el tema de PD se estudia en conexión a la retroalimentación en tiempo real, o mediante simulación
computacional, de las decisiones con los datos del sistema. Hacia allá va el tema de Reinforcement Learning.
Cápsula de video 4.4.1: Programación Dinámica bajo incertidumbre
Profesor Jorge Vera discute en clases la introducción de incertidumbre en la Programación Dinámica

https: // youtu. be/ _gafKmPh1dE
4.5. Ejemplos
4.5.1. Selección dinámica de candidatos
Se debe seleccionar personal para un solo trabajo, para lo que se posee una lista de n candidatos a entrevistar
en un orden pre-definido. El conocimiento de cada candidato es 100 % online (durante la entrevista), por lo
que en entrevista t < n sabe si candidato t es mejor que los primeros t − 1.
El problema es ofrecer o no trabajo en tiempo de entrevista. Si ofrece trabajo al candidato t : se queda
con el, si no ofrece trabajo, pierde al candidato t. El objetivo es maximizar la probabilidad de escoger al
mejor candidato
Los elementos del MDP son los siguientes:
Etapas: t ∈ {1, . . . , n}
Estados: s ∈ {0, 1} : si candidato t es el mejor visto hasta ahora.
Acción: x ∈ {0, 1} : ofrecer o no trabajo.
Valor inmediato: rt (s, x) :
• rt (0, 0) = rt (1, 0) = rt (0, 1) = 0
• rt (1, 1) = P(mejor candidato está en los primeros t) = t/n
Probabilidades: pt (st+1 )
• pt (1) = 1
t+1 (que proximo candidato sea mejor que los primeros t )
• pt (0) = t
t+1 (que proximo no sea mejor que el mejor de los primeros t )
Ecuación de Bellman:
Vt (s) = máx {rt (s, 1), rt (s, 0) + ES 0 (Vt+1 (S 0 ))}
Es decir:
1

t
Vt (0) = máx 0; Vt+1 (0) + Vt+1 (1)
t+1 t+1
1

t t
Vt (1) = máx ; Vt+1 (0) + Vt+1 (1)
n t+1 t+1
Se de deduce que:
t 1
Vt (0) = Vt+1 (0) + Vt+1 (1)
t+1 t+1

t
Vt (1) = máx ; Vt (0)
n
Este problema tiene la propiedad de ser una decisión monotónica, pues si es óptimo no ofrecer trabajo en
τ < n, entonces es subóptimo ofrecerlo en t < τ , lo que implica que existe etapa umbral desde la cual es
siempre óptimo ofrecer el trabajo cuando s = 1.
4.5.2. Ruteo dinámico con demanda estocástica

Este problema surge en la reposición de cajeros automáticos/máquinas dispensadoras, en la entrega de
bebestibles a restaurantes, en la recolección de basura y en la entrega de combustible y gas. Se tiene un
camión de capacidad Q, que debe visitar un conjunto de n clientes en rutas que comienzan y terminan en
un centro de despacho (nodo 0). El objetivo es minimizar el costo esperado para cubrir a todos los clientes.
La geografı́a está descrita por un grafo G = (N, A), los datos son los siguientes:
da > 0: costos por atravesar el arco a ∈ A.
Di : demanda del cliente i ∈ N \{0}. Di ∼ Fi es una variable aleatoria y solo es conocida al llegar a i.
Si al visitar i se produce un quiebre de stock, entonces se entrega todo lo disponible y se gatilla un

viaje de recarga de emergencia (ida y vuelta) a 0 para cumplir con el resto.
Acá las decisiones son qué cliente visitar en la próxima etapa, si recargar o no de forma proactiva antes de
visitarlo. Los componentes del MDP son los siguientes
Etapas: número de clientes ya visitados.
t = {0, 1, 2, . . . , n}
Estados posibles: s := (i, q, C) donde:

• i ∈ N : posición actual
• q ∈ {0, . . . , Q} capacidad restante en el vehı́culo.
• C ⊂ [n]\{i} subconjunto de clientes que falta visitar. Se debe cumplir que |C| = n − t
Espacio de estados: Se define como:
• St := {(i, q, C) : i ∈ [n], q ≤ Q, C ⊂ [n]\{i} : |C| = n − t}
• S0 := {(0, Q, [n])}
Acciones: (j, z) ∈ Xt (i, q, C), es decir las acciones están en el espacio de acciones Xt (i, q, C) := {(j, z) :
j ∈ C, z ∈ {0, 1}}, donde:
• j ∈ C : Próximo cliente a visitar.
• z ∈ {0, 1} : si se ejecuta un retorno proactivo a 0.
Con todo esto, las Ecuaciones de optimalidad son:
Terminal:
Cn (i, q, ø) = di,0 , ∀(i, q, ø) ∈ Sn

for t = n − 1, . . . , 0:
for (i, q, C) ∈ St :
C z=0 := mı́n EDj [di,j + Ct+1 (j, q − Dj , C\{j}) | Dj ≤ q] · P (Dj ≤ q)

j∈C
+EDj [dj0 + d0j + Ct+1 (j, Q + q − Dj , C\{j}) | Dj > q] · P (Dj > q)

z=1
:= mı́n di0 + d0j + EDj [Ct+1 (j, Q − Dj , C\{j})]

C
j∈C
Ct (i, q, C) = mı́n C z=0 , C z=1

Retornar: C ∗ = C0 (0, Q, {1, . . . , n})
Este es un problema explosivo. El mayor problema es el conjunto C de clientes visitados, donde existe una
cantidad exponencial de posibilidades del orden en qué visitarlos. De hecho, el MDP posee 1 + n2n+1 · (Q + 1)
estados (uno que es que falten visitar a todos los clientes, n posibles posiciones actuales, permutaciones del
conjunto de clientes no visitados y carga del vehı́culo), 2n acciones posibles (próximo cliente a visitar y si se
hace un retorno proactivo). De este modo, el Backward DP requiere O(n2 2n Q) cálculos de objetivo, además
de el cálculo de la esperanza. Es realmente un problema duro.
Esta en general suele ser la limitante principal de los MDP, lo que se conoce como la “maldición de la
dimencionalidad”. Esto sucede cuando el número de estados, de decisiones y/o el número de transiciones crece
exponencialmente con el tamaño del problema. Este tipo de problemas se resuelve con técnicas que permiten
simplificar estados y otras cosas: Programación Dinámica Aproximada Approximate Dynamic Programming
(ADP), como los son las polı́ticas miopes (descartan el futuro), las de Lookahead (simplificar modelo del
futuro), Value Function Approximation (ML para estimar value-to-go) y Policy Function Approximation
(simplificar acciones posibles a reglas simples). Muchas de estas, son técnicas de Simulación Computacional
donde, en vez de conocer a priori las probabilidades de transición, se simula el sistema y se itera “al estilo
PD” para “aprender” el comportamiento del sistema y aproximar una polı́tica óptima. Eso hace Reiforcement
Learning.
Francisco Garcı́a y Jorge Vera 4.6. Procesos de decisión Markoviana con horizonte infinito 85
4.6. Procesos de decisión Markoviana con horizonte infinito

En el caso anterior con horizonte finito, se realizaba Backward DP, lo que requiere un valor terminal, cosa
que no se puede tener si el horizonte es infinito. Además esta vez, evaluar una polı́tica puede no ser tan
simple dado que el valor óptimo puede diverger si se suma infinitamente y el valor en el tiempo puede ser
distinto: 1 peso hoy es distinto a un peso mañana. En primer lugar, cabe señalar que para estos problemas
se utiliza el Criterio de retorno esperado descontado:
V ∗ (s) = máx {V π (s)} ,

π∈ΠM D
" T #
X
V π (s) = lı́m E λt−1 · rt (St , dπt (St )) | S1 = s
T →∞
t=1
Esto optimiza el valor presente del retorno esperado utilizando un Factor de Descuento: λ ∈ [0, 1) ($1 en
el periodo t vale $λt−1 pesos hoy (t = 1)). De este modo, se privilegia futuro de corto plazo sobre el largo
plazo. Los supuestos con los que se trabajan para este caso son:
1. Retorno finito: |rt (s, x)| < ∞, para s ∈ S, x ∈ Xt (s). (Si |rt (s, x)| < ∞, entonces V ∗ (s) < ∞).
2. Espacio de estados discreto.
3. Estacionariedad: Retorno y probabilidades independientes del tiempo t. Luego, rt (s, x) = r(s, x) y

pt (s0 | s, x) = p (s0 | s, x)
Debido al Teorema de convergencia acotada, se tiene que si At < ∞ es una serie de variables aleatorias
acotadas y At converge a la v.a. A con probabilidad 1: P (lı́mt→∞ At = A) = 1 entonces: lı́mt→∞ E (At ) =
E(A). En nuestro curso implica que:
" T # "∞ #
X X
V (s) = lı́m E
π
λ t−1
r (St , dπt (St )) | S1 = s = E λ t−1
r (St , dπt (St )) | S1 = s
T →∞
t=1 t=1
Con todo esto, queda el desafı́o de evaluar una polı́tica de esta forma:
∞
!
X
V (s1 ) = E
π
λ t−1
r (St , dπt (St )) | S1 = s1
t=1
(t)
El valor de una polı́tica π ∈ M D, donde pπ (st | s1 ) es la probabilidad de transición a st en t etapas desde
s1 se puede ecribir como:
∞
!
X X
V π (s1 ) = λt−1 · pπ(t−1) (st | s1 ) · r (st , dπt (st ))
t=1 st ∈S
En notación vectorial es:
∞
X
Vπ = λt−1 · Pπ(t−1) rdπt
t=1
(t) Qt−1 (1)

Donde V π , rdπt ∈ R|S| son los vectores de retornos y valor para la polı́tica. Pπ = k=1 Pdπ ∈ R|S|×|S| es
k
la matriz de transición asociada a polı́tica π de t etapas Si polı́tica es estacionaria, es decir π = (d, d, . . .),
entonces para evaluar su valor, puede considerarse los siguiente:
∞
X
Vd = λt−1 pt−1
d rd
t=1
∞
X
V d = rd + λPd λt−2 Pdt−2 rd
t=2
∞
X
V d = rd + λPd λt−1 Pdt−1 rd
t=1
V = rd + λPd V
d d
V − λPd V d = rd
d
(I − λPd )V d = rd
V d = (I − λPd )−1 rd
Además, existe el siguiente Teorema: Sea Ld (V ) := rd + λPd V . La única solución V ∈ RnS del sistema
V = Ld (V ) es
−1
V d = (I − λPd ) rd
y es el valor V d de una polı́tica estacionaria π = (d, d, . . .).

Tal como se recordará, invertir una matriz puede ser muy costoso, por lo que hay que buscar otra alternativa
para poder optimizar Ld (V ) = rd + λPd V , existen dos temas que son claves: Las contracciones y el Teorema
del Punto fijo:
Contracción: Una función f : Rn → Rn es una contracción si existe 0 < c < 1 tal que
kf (V ) − f (U )k ≤ c · kV − U k, para cualquier U, V ∈ Rn
Teorema de Punto Fijo: Para una contracción f : Rn → Rn se cumple que:

a. El sistema vectorial V = f (V ) posee una sola solución V ∗ .
b. Dado V 0 , la secuencia V n+1 = f (V n ) converge a V ∗ = lı́mn→∞ V n
Con esto definido, hay un Teorema que dice que: Ld es una contracción: Ld (V ) = rd + λPd V es una
contracción, por lo que V n+1 = Ld (V n ) converge a V d .
La demostración de esto es:
kLd (V ) − Ld (U )k = kλPd V − λPd U k = λ kPd (V − U )k ≤ λkV − U k (Pd es una matriz de transición )
Corolario: El valor de la polı́tica d se obtiene iterando.
Luego, para resolver V ∗ (s) = máxπ∈Π V π (s)? π ∈ ΠM D , se debe tener en cuenta que, aunque no exista valor
terminal, se cumple el principio de recursión:
 
 X 
V ∗ (s) = máx r(s, x) + λ p(j | s, x)V ∗ (j)
x∈X(s)  
j∈S
Se define la función L∗ (V ) : Rns → Rns como:

  
  X 
L∗ (V ) = máx r(s, x) + λp(j | s, x)V (j)
x∈X(s)  
j∈S
s∈S
El vector valor óptimo V ∗ ∈ Rns cumple la ecuación vectorial de Bellman:
V ∗ = L∗ (V ∗ )
Como L∗ es una contracción, entonces la función L(V ), para cada s ∈ S es:
 
 X 
L(V )(s) = máx r(s, x) + λ p(j | s, x)V (j)
x∈X(s)  
j∈S
es una contracción, por lo que la serie V n+1 = L (V n ) converge a V ∗ . Con esto resulta natural que el valor
de la polı́tica óptima es único (trivial). Pero además, existe una polı́tica óptima estacionaria. Esto es útil,
ya que a final de cuentas uno busca la polı́tica de largo plazo estacionaria que de el mayor valor.
4.6.1. Value iteration

Este es un algoritmo que se basa en el resultado del Teorema anterior, según el cual se puede ir iterando
sobre los valores para ir mejorando V hasta una convergencia a un cierto error :
Value Iteration
Input: V (0) (cualquier vector), ε (precisión)

for s ∈ S :
Calcular:
 
 X 
V (n+1) (s) = máx r(s, x) + λ p(j | s, x)V (n) (j)
x∈X(s)  
j∈S
if V (n+1) − V (n) ≤ ε·(1−λ)

2λ :
Criterio de parada se satisface.
V (n) ← V (n+1)
Retornar: polı́tica ε-óptima para cada s ∈ S :
 
 X 
dε (s) ∈ argmaxx∈X(s) r(s, x) + λ p(j | s, x)V (n+1) (j)
 
j∈S
El algoritmo aplica directamente la contracción L∗ . Tiene las garantı́as de que V dε − V (n+1) ≤ ε/2 y
∗
V dε −V ≤ ε. En este algoritmo solo se captura la polı́tica una vez al final.
Una propiedades de este algoritmo son que si V ≥ U , entonces L∗ (V ) ≥ L∗ (U ) y que si existe un n tal que
V (n+1) ≥ V n , entonces V (n+m+1) ≥ V (n+m) , para cualquier m ≥ 1.
4.6.2. Policy Iteration

Muy similar al Value Iteration, está el Policy Iteration, algoritmo más “inteligente” que a diferencia del
anterior, itera sobre distintas polı́ticas en vez de sobre distintos valores (aunque de todos modos debe
actualizar la polı́tica de acorde al valor)
Cuando se calcula el vector de valores a partir de la polı́tica en la iteración n, dn , como V (n) = V dn , se puede
calcular de forma exacta invirtiendo las matrices y también se podrı́a hacer de forma numérica mediante
un algoritmo de Punto Fijo que calcule iterativamente hasta alcanzar una convergencia. Este puede partir
desde cualquier valor, por ejemplo, desde el vector 0. Ası́, V (n) = V dn se puede calcular de dos modos:
V dn ← (I − λPdn )−1 · rdn

V dn ← lı́mn→∞ Ldn (0)
Para el algoritmo mostrado, se calcula la polı́tica invirtiendo matrices.

Policy Iteration
Input: d0 (cualquier polı́tica de decisión), n ← 0.

V dn = (I − λPdn )−1 · rdn
V (n) ← V dn
for s ∈ S :
Calcular nueva polı́tica:
 
 X 
dn+1 (s) = argmax r(s, x) + λ p(j | s, x)V (n) (j)
x∈X(s)  j∈S

(Anticiclaje: Privilegiar status quo si existe solución múltiple, i.e. dn+1 (s) = dn (s).)
if dn+1 == dn :
Criterio de parada se satisface.
n ← n + 1.
Retornar: dn
Las garantı́as de este algoritmo son que V (n+1) ≥ V (n) y que si no termina, entonces existe estado s :
V (n+1) (s) > V (n) (s). También que si X es finito, entonces termina en un número finito de iteraciones.
Iteración de valor vs polı́tica

Iteración de valor es simple y rápido por iteración, no necesariamente converge en tiempo finito y ofrece
resultados aproximados (método numérico). Iteración de polı́tica, por otro lado, es más complejo por
iteración, converge en tiempo finito y tiende a hacer menos iteraciones, además de que va mejorando y
en cada momento posee polı́tica y value-to-go factibles.
Ejemplo
Sean dos estados: s1 y s2 . Se puede tomar la acción x ∈ [0, 2] sólo se toma en s1 . Los retornos son r(s1 , x) =
−x2 y r(s2 ) = −0,5. A su vez, las probabilidades de transición son:
p (s1 | s1 , x) = 0, 5x p (s2 | s1 , x) = 1 − 0, 5x
p (s1 | s2 ) = 0 p (s2 | s2 ) = 1
Para este problema, las Ecuaciones de Bellman son:
V1 = máx −x + λ (0, 5xV1 + (1 − 0, 5x)V2 )

2
x∈[0,2]
V2 = −0, 5 + λV2
En este caso es trivial obtener V2 = − 1−λ

0,5
.
0, 5

Luego: V1 = máx −x + λ 0, 5xV1 − (1 − 0, 5x)
2
x∈[0,2] 1−λ
Con esta expresión se puede hacer Value Iteration comenzando desde un V1 incial (Por ejemplo, 0), se
reemplaza en el problema de maximización, se deriva e iguala a cero, se encuentra el x óptimo y el V óptimo
y este último valor se reemplaza sucesivamente hasta alcanzar convergencia. En Policy Iteration, se comienza
(0) (0)
con un determinado valor de x: x(0) , mediante el que se debe calcular el valor de V1x y de V2x , resolviendo
el sistema de ecuaciones:
(0) (0) (0)

V1x = − (x0 )2 + λ(0,5x(0) V1x − (1 − 0,5x(0) )V2x )
(0) 0, 5
V2x =−
1−λ
(0) (0)
Una vez calculado V1x y V2x mediante este sistema de ecuaciones (que puede implicar invertir matrices
o utilizar un algoritmo de Punto Fijo), se reemplaza en la expresión a optimizar para encontrar el x óptimo,
con lo que se tiene x(1) y se vuelve a iterar.
Ejemplo
Supongamos que debe darle instrucciones a un robot saltarı́n que debe subir por los peldaños de una escalera
de 100 pisos. El robot comienza en el piso 1 y su meta es llegar al piso 100 . En cada piso s debe definir
la acción del robot entre cuatro disponibles definidas por un parámetro p ∈ 10 ; 5 ; 5 ; 1 . Si se escoge la
1 1 2
acción p, el robot saltara un piso (terminará en el piso s + 1 ) con probabilidad p, saltará 2 con probabilidad
p × (1 − p) y ası́ sucesivamente (saltará q pisos con probabilidad p · (1 − p)q−1 ). El problema es que si salta
más allá del piso 100 caerá al piso 1 y comenzará desde cero. El costo de cada movida es $1 y que el factor
de descuento es λ = 0, 99. Modele el problema como un MDP de horizonte infinito y encuentre una polı́tica
óptima que minimice el costo total esperado de subir al piso 100.
Estados: S = {1, 2, . . . , 100}. Representan el peldaño en que se encuentra el robot.
Acciones: X(s) = {opción 1, opción 2, opción 3, opción 4} ∀s ∈ S. Corresponde a tomar una de las
cuatro posibles acciones que puede tomar el robot, donde cada una tiene asociada una probabilidad p,
que es respectivamente { 10 , 5 , 5 , 1}
1 1 2
Prob. de transición: Para describir las probabilidades de transición dado que se escogió una acción
con probabilidad p y se encontraba en el peldaño i se tiene lo siguiente:
• En caso de que no sobrepase el centésimo peldaño, sube al peldaño j con probabilidad:
P{st+1 = j|st = i, x = k} = pk · (1 − pk )j−i−1 , j ≤ 100
• En caso de que sı́ sobrepase el centésimo peldaño, cae en el primer peldaño. Esto ocurre con
probabilidad:
∞
X
P{st+1 = 1|st = i, x = k} = pk · (1 − pk )100−i+h
h=0
• En todos los otros peldaños, tal que j < i, j 6= 1, la probabilidad de caer es cero.
De este modo, se tiene la siguiente matriz P de probabilidades de transición dado que se tomo la acción
x = k, k ∈ {1, 2, 3, 4}:
 P∞
h=0 pk (1 − pk ) pk (1 − pk ) pk (1 − pk )2 pk (1 − pk )3 pk (1 − pk )98
99+h 
pk ...
∞
h=0 pk (1 − pk ) 0 pk (1 − pk ) pk (1 − pk )2 pk (1 − pk )97 
98+h
P
pk ...
 

 P∞ 
h=0 pk (1 − pk ) 0 0 pk (1 − pk ) pk (1 − pk )96 
97+h

 pk ... 
.. .. .. .. .. .. ..
 
P= . . . . . . .
 

 
 P∞
 Ph=0 pk (1 − pk ) 0 0 0 0 pk (1 − pk )1 
2+h

 ... 
∞
h=0 pk (1 − pk ) 0 0 0 0
1+h
... pk
 
 
0 0 0 0 0 ... 1
Valor inmediato: Para modelar el problema como uno de maximización, se plantea que cada movimiento
desde un escalón i 6= 100 a un escalón j tiene beneficio de −1. Todos los otros, tienen beneficio nulo.
(
rt (i, x) = −1, i 6= 100, x = {1, 2, 3, 4}
rt (s, x) =
rt (100, x) = 0, x = {1, 2, 3, 4}
Ec. de Bellman: Se puede aplicar una modelación de Bellman de esta forma:

 
 X 
L(V )(s) = máx r(s, x) + λ · P(j|st , x)V (j)
x∈X  
j∈S
Esto corresponde a una contracción, por lo que la serie V n+1 = L(V n ) converge a V ∗ .
Debido a que tanto Value iteration como Policy iteration son opciones válidas para utilizar la recursividad
para resolver el problema.
El siguiente código implementa los métodos para el ejemplo.
import numpy as np
# Vector de retorno r_d

rd = np.array([-1 for i in range(99)] + [0])
# Estados S
S = [i for i in range(100)]
# Acciones X
X = {
0: 1/10, # 0.1
1: 1/5, # 0.2
2: 2/5, # 0.4
3: 1# 1.0
}
# Diccionario de retornos dado un estado s y una accion a
dict_r = dict()
for s in range(99):
for a in X.keys():
dict_r[s, a] = -1
for a in X.keys():
dict_r[99, a] = 0
# Diccionario con las probabilidades de transicion dado un estado
# inicial (fila), un estado final (columna) y la accion (valor de p)
dict_p = dict()
for fila in range(100):
for columna in range(100):
for accion, prob in X.items():
tupla = (columna, fila, accion)
if columna == 0:
if fila == 99: probabilidad = 0
else: probabilidad = sum(prob*(1-prob)**(99-fila+i) for i in range(999))
else:
if fila == 99and columna == 99: probabilidad = 1
elif fila >= columna: probabilidad = 0
else: probabilidad = prob * (1 - prob) ** (columna - 1- fila)
dict_p[tupla] = probabilidad
r = lambda s, a: dict_r[s, a]
p = lambda s1, s, a: dict_p[(s1, s, a)]
def calcular Vd(lamb, d,rd):

’’’
Funcion que calcula el valor del vector de retorno de la politica d:
Vˆ{(d)} = <(I - lambda * P_d)ˆ{-1}, r_d>
’’’
I = np.identity(100)
pd = np.matrix([[p(c, f, d[f]) for c in range(100)] for f in range(100)])
return np.linalg.inv(I - lamb * pd).dot(rd)
def value iteration(lamb, e):

’’’
Funcion que implementa Value iteration. Su entrada posee:
- lamb: factor de descuento
- e: error de convergencia
Su retorno es el valor de la politica optima "x".
’’’
# La funcion E calcula \sum_{j \in S} {p(j|s,x) *Vˆ{(n)}(j)}
E = lambda s, a: sum([p(s1, s, a) * Vn[s1] for s1 in S])
# Se define el limite hasta el cual iterar y dos arrays (Vn, Vn1)

# que corresponden respectivamente a Vˆ{(n)} y Vˆ{(nmasn1)}
limite = e * (1 - lamb) / (2 * lamb)
Vn, Vn1 = [0 for i in range(100)], [0 for i in range(100)]
criterio_de_parada_se_satisface = False
while not criterio_de_parada_se_satisface:
for s in S:
Vn1[s] = max([(r(s, a) + lamb * E(s, a)) for a in X])
if np.linalg.norm(np.array(Vn) - np.array(Vn1), ord=2) <= limite:
criterio_de_parada_se_satisface = True
Vn = Vn1.copy()
# arg mx: Se guarda en el array d_epsilon para cada estado la accion optima
d_epsilon = [None for i in range(100)]
for s in S:
_, d_epsilon[s] = max([(r(s, a) + lamb * E(s, a), a) for a in X])
return d_epsilon
def policy iteration(lamb):

’’’
Funcion que implementa Policy iteration. Su entrada corresponde
al factor de descuento. Su retorno es el valor de la politica optima "x".
’’’
# La funcion E calcula \sum_{j \in S} {p(j|s,x) *Vˆ{(n)}(j)}
E = lambda s, a: sum([p(s1, s, a) * Vn[s1] for s1 in S])
# dn y dn1 corresponden respectivamente a d_{n} y d_{nmasn1}

dn, dn1 = [0 for i in range(100)], [0 for i in range(100)]
while True:
# Se calcula Vd (lo que exlpica la lentitud de cada iteracion)
Vn_aux = calcular Vd(lamb, dn1, rd)
Vn = Vn_aux.tolist()[0]
for s in S:
_, dn1[s] = max([(r(s, a) + lamb * E(s, a), a) for a in X])
if dn1 == dn: break
dn = dn1.copy()
return dn, Vn
lamb, epsilon = 0.99,0.001
x_value = value iteration(lamb, epsilon)

Vd = calcular Vd(lamb, x_value, rd)
print(x_value, "\n\n", Vd.tolist()[0], "\n\n\n\n")
dn, Vn = policy iteration(lamb)

print(dn, "\n\n", Vn)
Capı́tulo 5
Geometrı́a de la Programación Lineal

y Extensiones
Los problemas de Programación Lineal surgen en todas las aplicaciones y dan origen a problemas gigantes,
tal como la coordinación de un sistema de energı́a eléctrica y problemas de planificación. En algunos casos,
estos problemas llegan a ser tan grandes, que resultan inmanejable de resolver como un todo, por lo que
generalmente se abordan con metodologı́as que buscan descomponer el problema en partes más “pequeñas”
pero más manejables. Estos métodos de descomposición tı́picamente utilizan Programación Lineal. De este
modo, la teorı́a que subyace en la Programación Lineal, junto con los conceptos de Geometrı́a que esta
involucra son fundamentales para entender la forma en que operan los problemas actuales de optimización.
En este capı́tulo, entonces, abordaremos algunos de esos temas. En particular, revisaremos algunas propiedades
geométricas asociadas a la Programación Lineal, recordaremos el Algoritmo Simplex y también las fundamentos
de la Teorı́a de Dualidad, ası́ como algunas extensiones importantes que serán de utilidad en siguientes
capı́tulos.
5.1. Conceptos básicos de Geometrı́a de Programación Lineal

5.1.1. Definiciones
Conjuntos convexos
Sea un conjunto S ⊂ Rn . S se dice convexo si:
x ∈ S, y ∈ S ⇒ λx + (1 − λ)y ∈ S, ∀λ ∈ [0, 1]
Vale decir, los puntos que están en la linea que une los puntos x e y pertenecen a S. El conjunto S puede
ser abierto o cerrado. Particularmente, para una función de n variables, f : D → R es convexa si para todo
x1 , x2 ∈ D se cumple que:
f (λx1 + (1 − λ)x2 ) ≤ λf (x1 ) + (1 − λ)f (x2 ), ∀λ ∈ [0, 1]
La figura 5.1 ilustra la definición.
Envoltura convexa
Dados los puntos x1 , . . . , xp ∈ Rn , la envoltura convexa de esos puntos es el conjunto:
p p
( )
X X
conv (x1 , . . . , xp ) = λi xi : λi = 1; 0 ≤ λi ≤ 1, i = 1, . . . , p
i=1 i=1
De este modo, la envoltura convexa se forma con los promedios ponderados de los puntos {x1 , . . . , xp } ∈ Rn ,
y corresponde al conjunto convexo más pequeño que contiene a los puntos {x1 , . . . , xp } ∈ Rn . Por ejemplo, en
93
94 Capı́tulo 5. Geometrı́a de la Programación Lineal y Extensiones
Figura 5.1: Función convexa
R2 , entre dos puntos corresponde a la recta que une dichos puntos; entre tres puntos no colineales corresponde
al triángulo cuyos vértices son los puntos y el espacio dentro de este. En R3 puede corresponder a pirámides
o cubos por ejemplo. La Figura 5.2 ilustra estos casos.
Figura 5.2: Ejemplos de Envoltura convexa
Notar en el último dibujo que si un punto xi es combinación convexa de los otros puntos, entonces si se saca
este punto del conjunto convexo, el conjunto convexo queda igual. De hecho, la envolutra convexa es única
y corresponde al menor conjunto de puntos {x1 , . . . , xp } ∈ Rn que conforman a S.
Conos convexso
Un conjunto K ⊂ Rn es un cono convexo si:
i) K es convexo.
ii) x ∈ K ⇒ λx ∈ K, ∀λ ≥ 0
La segunda condición, en el fondo, dice que si x ∈ K, entonces, si se multiplica por un escalar cualquiera
λ ≥ 0 (se escala), entonces el nuevo punto sigue perteneciendo al cono.
Ejemplos famosos son el singleton(k = 0, cono trivial ), Rn , o por ejemplo el subespacio R20 + cumplen con
la definición anterior, o sea, no todos los cono tienen “punta”. Los conos contienen al cero y parten desde el
origen.
Envoltura cónica
Sean y1 , . . . , yr en Rn . La envoltura cónica de esos puntos es el conjunto:
( r )
X
cone (y1 , . . . , yr ) = µi yi : µi ≥ 0, i = 1, . . . , r
i=1
Francisco Garcı́a y Jorge Vera 5.1. Conceptos básicos de Geometrı́a de Programación Lineal 95
Figura 5.3: Cono
Se le llama también el cono generado por los vectores {y1 , . . . , yr } ∈ Rn . Si el conjunto de vectores que
definen al cono es finito, entonces el cono no puede tener una forma curva, sino que es un cono con “caras
planas”, como ilustra la figura 5.4.
Figura 5.4: Rayos extremos que definen las caras de un Cono
Ejemplo de cono convexo

Consideremos el Cono de segundo orden o cono de Lorentz, definido como:
K = {x ∈ Rn : k(x1 , x2 , . . . , xn−1 )k2 ≤ xn }
Se puede demostrar formalmente que K es un cono convexo. En primer lugar, demostraremos que K es
cono. Consideremos x ∈ K, tal que: k(x1 , x2 , . . . , xn−1 )k2 ≤ xn Multiplicando esta expresión por µ > 0,
obtenemos que:
µ k(x1 , x2 , . . . , xn−1 )k2 ≤ µxn

k(µx1 , µx2 , . . . , µxn−1 )k2 ≤ µxn
Por lo tanto, µx ∈ K. Para demostrar a convexidad, consideraremos x, y ∈ K. Como x, y ∈ K, se cumple

que: k(x1 , x2 , . . . , xn−1 )k2 ≤ xn y k(y1 , y2 , . . . , yn−1 )k2 ≤ yn Si tomamos λ ∈ [0, 1], obtenemos que:
kλ (x1 , x2 , . . . , xn−1 )k2 ≤ λxn

k(1 − λ) (y1 , y2 , . . . , yn−1 )k2 ≤ (1 − λ)yn
kλ (x1 , x2 , . . . , xn−1 )k2 + k(1 − λ) (y1 , y2 , . . . , yn−1 )k2 ≤ λxn + (1 − λ)yn /(?)
kλ (x1 , x2 , . . . , xn−1 ) + (1 − λ) (y1 , y2 , . . . , yn−1 )k2 ≤ λxn + (1 − λ)yn
k(λx1 + (1 − λ)y1 , . . . , λxn−1 + (1 − λ)yn−1 )k2 ≤ λxn + (1 − λ)yn
Lo que implica que λx + (1 − λ)y ∈ K y, por lo tanto, K es un cono convexo.

(?) Por desigualdad triangular y el principio de transitividad.
Cono Poliédrico
Como decı́amos, el cono anterior posee caras, donde sus aristas corresponden a los “rayos extremos” {y1 , . . . , yr } .
Dado esto, un cono es poliédrico si es un cono y un poliedro a la vez, por lo cual también podrı́a escribirse
como el sistema homogéneo dado por:
{x ∈ Rn : Ax ≤ 0}
para alguna matriz A ∈ Rn . Cada fila de A define un subespacio que corresponde a un hiperplano que pasa
por 0. Ejemplo de esto es:
1

−2
x≤0
−2 1
En la misma figura podemos ver también que ese poliedro (que es un cono) es generado por dos vectores:
1 2

y1 = , y2 =
2 1
Es decir, cone{y1 , y2 } = {x : Ax ≤ 0} y existen dos representaciones: una como envoltura cónica de un

conjunto de rayos y otra como desigualdades que representan un poliedro. Esto es un resultado más general,
como veremos a continuación.
Cápsula de video 5.1.1: Convexos y Conos
Profesor Jorge Vera explica en clases los conceptos de envolturas convexas y cónicas.
https: // youtu. be/ bKfO6b8ZOOA
Representación puntual y algebraica de un poliedro

Consideremos un Poliedro P , acotado (es lo que llamamos un polı́topo) y dado por el sistema Ax ≤ b. Este
puede ser el dibujo del lado izquierdo de la figura 5.5. Si v1 , . . . , vp son los puntos extremos de P , entonces,
se puede ver también en la figura, que tenemos dos alternativas para describir al Poliedro, a través de
sus vértices o alternativamente las desigualdades que definen sus caras.
Figura 5.5: Dos formas de representar el mismo poliedro

En forma más general, es posible probar el siguiente teorema:
Teorema 5.1.1: Representación algebraica-puntual de un polı́topo
Sean {x1 , . . . , xp } ∈ Rn , entonces existe una matriz A ∈ Rm×n , y un vector b ∈ Rm , para algún m
tales que:
conv (x1 , . . . , xp ) = {x ∈ Rn : Ax ≤ b}
De este modo, un poliedro P se puede expresar como Ax ≤ b algebraicamente o como la envoltura convexa
de sus vértices {v1 , . . . , vp }. Si P es acotado, se le llamo polı́topo, el cual posee vértices o puntos extremos
{v1 , . . . , vp }, que son puntos de restricciones activas.
Por supuesto, no es fácil calcular A y b a partir de los vértices, ni los vértices a partir de A y b.
Como ilustración, supongamos que tenemos ciertos puntos x1 , . . . , xp ∈ R2 , como muestra la figura 5.6.
La envoltura convexa de esos puntos es un poliedro y debe ser representable mediante desigualdades. Un
algoritmo que puede determinar esas desigualdades puede ser uno que itere para todo par de puntos formando
la linea que los une, si existen puntos a ambos lados de la linea, entonces esta linea no determina una cara
del Poliedro, mientras que si todos los puntos se encuentran a un mismo lado (o sobre la lı́nea), entonces si
corresponde a una cara.
Figura 5.6: Planos que configuran caras del Poliedro de los puntos
Si tuviéramos puntos en R3 , entonces tomarı́a de a tres puntos para definir un plano, pero el argumento
sigue en forma similar. Más en general, en Rn tenemos que encontrar combinaciones entre n puntos y ver
si están todos los restantes puntos a un solo lado de este hiperplano. Si se trabaja en Rn con k puntos,
entonces, se deben probar:

k k!
=
n (k − n)!n!
posibles hiperplanos. Por ejemplo, si n es 3 y k es 50, entonces se deben estudiar 19.600 planos posibles que
definan el conjunto pero es evidente que este número puede crecer enormemente al aumentar n y k.
Por otro lado, Si nos dan un sistema de desigualdades Ax ≤ b con m filas y n columnas, m > n, los vértices de
ese poliedro se encuentran resolviendo subsistemas de igualdades de n × n extraidos de las m desigualdades.
Existe una cantidad igual a

k m!
=
n (m − n)!n!
posibles sistemas de ecuaciones que habrı́a que probar para determinar todos los vértices. Este también
puede ser un número gigantesco.
En otras palabras, el resultado de la construcción equivalente entre desigualdades y vértices suena poco
práctico debido al esfuerzo computacional involucrado en pasar de uno a otro. Sin embargo, y esto es lo
importante: si estamos optimizando sobre el poliedro no necesitamos todos los vértices, sólo uno: el óptimo.
Eso es lo que resuelve de manera muy eficiente el Algoritmo Simplex. Al revés, muchas veces los vértices
existen pero no necesitamos todas las desigualdades, sólo unas pocas. Esto será muy relevante más adelante
cuando estudiemos técnicas de descomposición avanzadas como la Descomposición de Benders.
Cápsula de video 5.1.2: Representación puntual y algebraica
Profesor Jorge Vera explica en clases la construcción de la representación puntual y d ela

representación algebraica de un polı́topo.
https: // youtu. be/ BpKy6tXIC6o
Teorema de Minkowski-Weil-Motzkin
El resultado anterior tiene una limitante: asume que el poliedro está acotado y eso no tiene por qué ser
ası́. En este caso, la envoltura convexa de los vértices no conforma al poliedro completo, le falta algo para
poder describir la parte no acotada del conjunto. Esto se puede solucionar si el poliedro no se define solo en
términos de vértices, sino que también de rayos de un cono, como especifica el siguiente teorema:
Teorema 5.1.2: Minkowski-Weil-Motzkin
P es un poliedro, acotado o no, y se escribe como {x : Ax ≤ b}, con A ∈ Rm×n , y b ∈ Rm si y solo si

existen x1 , . . . , xp e y1 , . . . , yr , tales que:
P =C +K
donde:
C = conv (x1 , . . . , xp )
K = cone (y1 , . . . , yr )
En el fondo, esto quiere decir que puedo tener dos representaciones totalmente equivalentes, una por vectores
(representación puntual) y otra por desigualdades (representación algebraica). Al cono K se le llama “cono
de recesión”de P y se denota como Recc(P ). Se puede probar que si P está dado por el sistema Ax ≤ b
Recc(P ) = {y : Ay ≤ b0} y en caso que sea Ax = b, x ≥ 0, entonces Recc(P ) = {y : Ay = 0, y ≥ 0}.
Figura 5.7: Un Poliedro no acotado P se puede formar mediante la suma de un Poliedro acotado C y un
cono K
En forma alternativa, cualquier vector del poliedro P se puede representar por la suma de un vector que en
C más un vector que sea un rayo del cono de recesión K.
De manera más explı́cita, el punto x ∈ P si:
p
X r
X p
X
x= vi x i + hi yi : λi = 1; 0 ≤ λi ≤ 1, i = 1, . . . , p, µi ≥ 0, i = 1, . . . , r
i=1 i=1 i=1
Donde los vi corresponden a los vértices del poliedro y los hi corresponden a los rayos. Las figuras 5.7 y 5.8
ilustran la construcción.
Figura 5.8: Poliedro acotado C más los rayos de K forman al poliedro P
Cápsula de video 5.1.3: Teorema de Minkowki-Weil-Motzkin
Profesor Jorge Vera explica en clases la representación puntual-algebraica general de un poliedro.

https: // youtu. be/ BpKy6tXIC6o
Ejemplo 1
Consideremos el poliedro definido por las siguientes desigualdades:
x1 −2x2 ≤0
2x1 +2x2 ≤3
x2 ≤1
Vamos a determinar explı́citamente la descomposición de P en puntos extremos y rayos del cono de recesión
(en caso que exista). Es decir, identifique esos puntos extremos y rayos.
El siguiente diagrama muestra el poliedro y sus puntos extremos (notar que no hay restricciones de signo
en las variables):
En el siguiente diagrama se muestra el cono de recesión:

Los puntos extremos son:

1 1/2

A= , B=
1/2 1
y los rayos son:
−1 −2
y1 = , y2 =
0 −1
o múltiplos de estos, por supuesto.
Ahora, cosideremos el punto ( 21 , 12 ). Este punto se escribe de la siguiente manera usando la descomposición
anterior:
1/2 1 1/2

−1 −2
= λ1 + λ2 + µ1 + µ2
1/2 1/2 1 0 −1
y, adicionalmente:
λ1 + λ2 = 1 , λi ≥ 0, µi ≥ 0
Esto se resuelve con λ1 = 1, λ2 = 0, µ1 = 1/2, µ2 = 0.
Ejemplo 2:
Consideremos el conjunto en R3 definido por las siguientes desigualdades lineales:
x1 + x2 + x3 ≥ 2
−x1 − x2 + x3 ≤ 2
x3 ≥ 1
x1 , x2 , x3 ≥ 0
La siguiente figura muestra, aproximadamente la forma del conjunto. Esto está “visto” desde el interior del
ortante ≥ 0 mirando hacia el origen:
Los vértices (o puntos extremos) son:
1 0 0
     
v1 =  0  , v2 =  1  , v3 =  0 
1 1 2
Los rayos son:
1 0 0 1

      
y1 =  0  , y2 =  1  , y3 =  1  , y4 =  0 
0 0 1 1
Usando los elementos anteriores, el punto (5, 5, 3) se escribe de la siguiente forma:
5 1 0 0 1 0 0 1
               
 5  = λ1  0  + λ2  1  + λ3  0  + µ1  0  + µ2  1  + µ3  1  + µ4  0 
3 1 1 2 0 0 1 1
con las condiciones adicionales que:
λ1 + λ2 + λ3 = 1, λi ≥ 0, µi ≥ 0
5.1.2. Conceptos básicos aplicados a Programación Lineal

Tomemos un problema de Programación Lineal en forma estándar: mı́n cT x : Ax = b, x ≥ 0 donde A es

de m filas y n columnas, m ≤ n. Recordemos que cuando este problema alcanza el óptimo, lo hace en un
punto extremo, eso es lo que se llama una solución básica factible. Una solución básica viene de que en el
sistema Ax = b, x ≥ 0, la matriz A se puede descomponer en dos partes, una básica B y una no básica N :
A = [B | N ]. Si A ∈ Rm×n con m ≤ n, entonces B ∈ Rm×m es una matriz invertible y es la dimensión
fila (el número de restricciones) la que define el tamaño de la base. El vector x se descompone siguiendo
una estructura análoga, en coordenadas básicas y no básicas: x = [ x xN ], lo mismo el vector c de costos:
B
c = [ ccB
N
]. Con esto, una solución básica factible es tal que:
Ax =b
xB
[B | N ] · [ ] =b
xN
BxB + N xN =b
Como xN = 0, entonces se cumple que xB = B −1 b ≥ 0. Uno de los resultados funda,mentales de Programación

Lineal es que esta solución básica factible identifica a uno de los vértices del Poliedro. Más aún, el óptimo
se alcanza en uno de esos vértices, es decir, en una solución básica factible.
No acotamiento e infactibilidad
Por otro lado, el problema mı́n{cT x, s.a. Ax = b, z ≥ 0} puede ser “no acotado”, lo que se traduce en que
existe un rayo h ∈ Recc(P ), tal que cT h < 0. La prueba de esto es la siguiente: Sea x̄ una solución factible:
Ax̄ = b, x̄ ≥ 0
Luego, el punto A(x̄ + δh), δ ≥ 0 también es factible pues es mayor que el vector 0: x̄ + δh ≥ 0 y además
cumple con:
A(x̄ + δh) = Ax̄ + δAh = Ax̄ = b, pues como h ∈ Recc(P ), entonces : Ah = 0
Luego, si se evalúa este punto factible en la función objetivo, tomando el lı́mite cuando δ tiende a infinito y
el rayo h ∈ Recc(P ) tal que cT h ≤ 0, entonces se tiene que:
lı́m cT (x̄ + δh) = lı́m cT x̄ + δcT h = cT x̄ + lı́m δcT h = −∞

δ→∞ δ→∞ δ→∞
Entonces, si existe un rayo h ∈ Recc(P ), tal que cT h < 0, es un certificado de no acotamiento. El algoritmo
Simplex detecta esto precisamente en su “test de no acotamiento”.
Por otro lado, para certificar infactibilidad, se hace Simplex Fase I con variables artificiales, si se llegaba a
una solución donde todas las variables artificiales son nulas, entonces el problema era factible.
5.2. Algoritmo SIMPLEX

El problema en forma estándar: mı́n cT x : Ax = b, x ≥ 0 puede ser replanteado en la forma canónica o

reducida mediante la “separación”de los vectores y matrices en una parte básica y no básica. En primer
lugar, Ax = b, se puede plantear como:
AB xB + AR xR = b, /A−1
B
xB + A−1 AR xR = A−1
B b
| B{z } | {z }
ĀR b̄
Donde xR corresponde a las variables no básicas (∴ xR = 0), por lo que las variables básicas corresponden
a xB = b̄ − ĀR xR = b̄. La función objetivo, mı́n cT x, se puede plantear del siguiente modo en términos de
sus coordenadas básicas y no básicas:
cT x =cT (xB + xR )
=cTB xB + cTR xR
=cTB b̄ − ĀR xR + cTR xR

=cTB b̄ + cTR − cTB ĀR xR

| {z }
costos reducidos
Con todo esto, el problema de optimización se puede escribir como:
mı́n cTB b̄ + cTR − cTB ĀR xR

s.a. xB + ĀR xR = b̄
xB ≥ 0
xR = 0
En el fondo, los costos reducidos de la variable j rj corresponden a la tasa de cambio del valor objetivo por
aumentos unitarios de xj manteniendo constante la base B:
dz d
rj = = cT b̄ + cTR − cTB ĀR xR = cj − cTB Āj

dxj dxj B
El algoritmo desarrollado por Dantzig, se inspira

en el hecho de que los costos se pueden expresar como
cTB b̄ + cTR − cTB ĀR xR , entonces si cTR − cTB ĀR xR j , que corresponde a la variable j dentro de los costos

reducidos, es negativa, sucede que conviene hacer que variable sea distinta de cero, es decir entrar a la base
a dicha variable.
El valor de esta variable se puede hacer crecer hasta el punto en que se pueda. Para ver cuánto es la capacidad
máxima, se puede ver que como:
xB = A−1
B b − ĀR xR = b̄ − ĀR xR
y como xB debe no puede ser negativa, entonces el valor de b̄ − ĀR xR debe ser mayor que cero, pero
precisamente, al aumentar el valor de la variable j ∈ xR , sucederá que algún variable en el vector xB
disminuirá hasta hacerse cero. La primera variable de la base tal que pasé esto, la sacamos de la base, tal
que:
( )
b̄ b̄i
δ̄ = mı́n i , i : Āj i = mı́n , i : āij > 0

Āj i āij
Es i el ı́ndice donde el mı́nimo se alcanza.

Por otro lado, se define el vector de precios sombra π ∈ Rm asociado a una base B se se define como:
Francisco Garcı́a y Jorge Vera 5.2. Algoritmo SIMPLEX 103
T
π = A−1
B cB
Cada πi indica tasa de cambio del valor objetivo al haber un aumento unitario del recurso bi (manteniendo
la base). Para ver porqué sucede esto, consideremos la variable de holgura xh de la i-esima restricción:
aTi x + xh = bj . Si Āh es la componente i de ĀR , entonces su costo reducido es:
rh = ch − cTB Āh
= ch − cTB A−1
B Ah
= ch − π T Ah /ch = 0
= −πi
Notar que ch = 0 debido a que las variables de holgura al ser artificiales no tienen costo y π T Ah = −πi debido
a que Ah corresponde a un vector de puros ceros, salvo en la coordenada i. Luego, db dz
i
= −rh = πi . Esto
sucede en esencia ya que un cambio marginal de la f.o. respecto a la restricción de recurso i es precisamente el
negativo del costo de que la variable de holgura pudiera crecer marginalmente. Notar que es muy brillante,
dado que tenemos la forma de calcular la variación marginal respecto a las variables y las variables de
holgura, si bien no tienen costo, sus cambios igual afectal el valor de la función objetivo, y sus cambios son
precisamente aumentar la “holgura” que le impone la barrera del b, por lo que su beneficio marginal también
es el beneficio marginal de aumentar b.
Toda esta idea se implementa en el algoritmo SIMPLEX que se muestra a continuación:
Algoritmo SIMPLEX
0. Comenzar con una base factible B = AB(1) , . . . , AB(m) .


Las variables básicas actuales son xB = b̄ = B −1 b ≥ 0 y el valor objetivo es z = cTB b̄.
Calcular π: π = B −1 cTB y c̄j = cj − π T Rj , ∀j ∈ IR (ı́ndices no básicos).
if c̄j ≥ 0, ∀j ∈ IR , x es óptimo:
STOP.
elegir j tal que c̄j < 0
Calcular R̄j = B −1 Rj
if R̄j ≤ 0, el problema es no acotado:
STOP.
Sea
b̄i
δ̄ = mı́n , i : āij > 0
āij
y sea s el ı́ndice donde el mı́nimo se alcanza.
Formar una nueva base reemplazando la columna AB(s) por la columna Aj .
end
En el fondo SIMPLEX ve todas las contribuciones de cada una de las variables no básicas a la función
objetivo, esto corresponde al costo reducido c̄j . Si uno de estos es negativo, entonces combiene aumentar
la variable xj hasta donde se pueda con el test del mı́nimo cuociente. Posteriormente se hace el cambio de
base, haciendo entrar la columna j de A y sacando la asociada a la variable que sale. Cada vez que se hace
esto, se pasa de un vértice a otro.
SIMPLEX tiene una ventaja computacional, es muy eficiente, gracias a que el costo por iteración es muy
bajo. Las etapas computacionales fundamentales son resolver los sistemas:
Bπ = cB , BxB = b, B R̄j = Rj
Esto implica resolver sistemas lineales, y por lo tanto invertir matrices (B −1 ). Además B cambia de iteración
a iteración, por lo que se podrı́a pensar que es muy lento, pero la verdad es que B cambia, en cada iteración,
en solo una columna. Se puede aprovechar eso de manera muy eficiente para recalcular la inversa de la base,
cosa que llega a tener una complejidad de orden O(m) y no O(m3 ) como sucede con invertir matrices. Esto
se hace utilizando la descomposición LU , donde L es una matriz triangular inferior y U triangular superior
B = LU
Las matrices L y U se ven aproximadamente de esta forma, donde • implica de que ahı́ hay números que
no necesariamente son 0:
• 0 0 0 0 • •
   
... ... •
 • • 0 ... 0   0 0 • ... • 
0 0 0 0
   
L=
 • • • ... 
U =
 ... • 
.. .. .. .. .. .. .. .. .. ..
 
. . . . . . . . . .
   
   
• • • ... • 0 0 0 ... 0
Bx = b −→ LU x = b −→ U x = L−1 b −→ x = U −1 L−1 b
Esto es fácil de invertir, pues son matrices triangulares. Además cuando B cambia a B 0 (B −→ B 0 ), llamamos
C a la matriz que tiene sólo ceros y una sola columna distinta de cero, entonces se tiene que
B 0 = B + C −→ L−1 B 0 = L−1 B + L−1 C = U + L−1 C
L−1 C corresponde a una matriz que también tiene todas sus entradas igual a cero, salvo una columna. Como
esta matriz se le suma a U, entonces va a quedar una matriz V con la siguiente forma:
0 • • ... •
 
 0 0 • ... • 
U + L C = V =  0 0 • ... • 
 
−1  
 .. .. .. . . .. 
 . . . . . 
0 0 • ... 0
Para transformar estas matrices matrices diagonales superiores e inferiores tan solo debo pivotear, cosa que
en el peor de los casos es de orden O(m), con lo que se pasa de la matriz V a la matriz U 0 que es diagonal
superior. Luego se múltiplica L−1 B 0 = U 0 por L y ası́ se obtiene B 0 = LU 0 , y debido a que son diagonales
resultan simples de invertir.
Cápsula de video 5.2.1: Eficiencia del cambio de base del Simplex
Profesor Jorge Vera explica en clase el cambio de base del Simplex usando la descomposición LU.
https: // youtu. be/ J-GnXtqqSgQ
5.3. Dualidad
5.3.1. Problema primal y dual
En programación Lineal, la Dualidad da una visión alternativa del problema que se está planteando, de
modo que se tiene un problema equivalente pero con una visión alternativa. Si el siguiente es el Problema
primal (en forma estándar):
z ∗ = mı́n cT x
P) s.a. Ax = b
x≥0
Entonces, el dual de P ) es:
w∗ = máx bT u
D)
s.a. AT u ≤ c
Francisco Garcı́a y Jorge Vera 5.3. Dualidad 105
Si x es factible en P ) y n es factible en D, entonces se cumple que el que minimiza acota por arriba al que
maximiza:
cT x ≥ bT u, (dualidad débil)
Y si son óptimos:
z ∗ = w∗ , (dualidad fuerte)
Otros formatos de Programación dual tienen sus correspondientes duales. Por ejemplo si
z ∗ = mı́n cT x
P) s.a. Ax ≥ b
x≥0
Entonces, el dual de P ) es:
w∗ = máx bT u
D) s.a. AT u ≤ c
u≥0
Cualquier combinación de desigualdades e igualdades lleva a un correspondiente dual y ese se obtiene

haciendo transformaciones equivalentes. A veces es útil tener esta tabla, que recuerda las transformaciones:
Minimización Maximización
Variables Restricciones
≥0 ≤
≤0 ≥
irrestricta =
Restricciones Variables
≤ ≤0
≥ ≥0
= irrestricta
Por Dualidad Débil, sabemos que: bT ū ≤ cT x̄ cuando x̄ e ȳ son soluciones factibles. Y por Dualidad Fuerte,
se sabe que si x∗ e y ∗ son soluciones óptimas, entonces: bT u∗ = cT x∗
Esto mismo lleva a la conclusión que si P ) es infactible y si D es factible entonces D tiene que ser no acotado.
Más en especı́fico:
Si el primal es no acotado, entonces su dual será infactible.
Si el primal es infactible, entonces su dual puede ser infactible o no acotado.
Si el primal es degenerado (posee una restricciones de más), entonces su dual posee infinitas soluciones.
5.3.2. Algunos ejemplos de formulaciones lineales y sus duales
T
T X
X máx π·K + ut · dt
min {ct xt + ht It }
t=1
t=1
T s.a. at · π + ut ≤ ct , t = 1, . . . , T
X
s.a. at xt ≤ K (π) −→ − ut + ut+1 = ht , t = 1, . . . , T − 1
t=1 − uT = hT
It−1 − It + xt ≥ dt , t = 1, . . . , T (ut )
ut ≥ 0, t = 1, . . . , T
xt ≥ 0, t = 1, . . . , T
π≤0
T X
m
X T X
n m
mı́n (eit − pi ) zit
X X
máx xjt πt + Ki si
t=1 i=1
t=1 j=1 i=1
m n
s.a. πt + si ≤ eit − pi , t = 1, . . . , T
X X
s.a. zit = xjt , t = 1, . . . , T (πt )
i=1 j=1
−→ i = 1, . . . , m
T
X si ≤ 0, i = 1, . . . , m
zit ≤ Ki , i = 1, . . . , m (si )
t=1
zit ≥ 0, t = 1, . . . , T
i = 1, . . . , m
N !
X N P
mı́n cj t j X X
máx πj wi xij − T yj + Qα
j=1
j=1 i=1
P
s.a. πj + α ≤ cj j = 1, . . . , N
X
s.a. tj ≥ wi xij − T yj , j = 1, . . . , N (πj )
i=1
−→ πj ≥ 0, α ≤ 0 j = 1, . . . , N
N
X
tj ≤ Q (α)
j=1
tj ≥ 0, j = 1, . . . , N
mı́n eT v máx bT π
s.a. Ax + Iv = b (π) −→ s.a. AT π ≤ 0
(x, v) ≥ 0 Iπ ≤ e
X X X
mı́n cij xij máx πi d i + Wij Uij yij
(i,j)∈A i∈N (i,j)∈A
s.a. πi − πj + Wij ≤ cij (i, j) ∈ A

X X
s.a. xij − xki = di , i∈N (πi )
−→
(i,j)∈A (k,i)∈A Wij ≥ 0 (i, j) ∈ A
xij ≤ Uij yij , (i, j) ∈ A (Wij )
xij ≥ 0 (i, j) ∈ A
r
X
máx yi
mı́n γ i=1
r
s.a. 1 + viT x ≤ γ, i = 1, . . . , r (yi ) X
s.a. y i vi = 0
−→ i=1
Xr
yi = 1
i=1
yi ≥ 0, i = 1, . . . , r
N
X
máx 0 × π + qk cTk x
k=1
N X
X N N
s.a. (ρ)
X
πks dks ≤ r mı́n rρ + ps αs
k=1 s=1 s=1
N
X −→ s.a. ρdks + αs + βk ≥ 0 k, s = 1, . . . , N
πks = ps , s = 1, . . . , N (αs )
k=1
− βk = cTk x k = 1, . . . , N
N
X ρ≥0
πks − qk = 0, k = 1, . . . , N (βk )
s=1
π ≥ 0, q ∈ RN
X n
mı́n cij xij
X
máx di πi
(i,j)∈A i=1
s.a.πi − πj ≤ cij , ∀(i, j) ∈ A
X X
s.a. xij − xpi = di , i ∈ N −→
j:(i,j)∈A p:(p,i)∈A
xij ≥ 0, ∀(i, j)) ∈ A
5.3.3. Ejemplo: el dual aplicado al problema de planifiación de proyectos

Un proyecto se ha dividido en actividades que deben ser realizadas respetando relaciones de precedencia
entre ellas. Se ha decidido utilizar una red dirigida para representar estas relaciones, en la cual cada arco
está asociado a una actividad, y cada nodo representa el término o inicio de las actividades que llegan o
salen de él, respectivamente. Por ejemplo, en la red de figura, las actividades (1,2) y (1,3) son las que se
deben realizar al inicio del proyecto. El nodo 1 representa el evento o “hito” de inicio. Por otro lado, el
nodo 5 representa el término de las actividades (3,5) y (2,5), y el comienzo de las actividades (5,6) y (5,7).
Estas dos últimas no se pueden realizar mientras no se hayan completado las actividades (2,5) y (3,5). Se
ha estimado la duración de cada actividad, denotado por dij y este dato se muestra igualmente en la figura:
Más formalmente y en general, un proyecto se puede, entonces, representar con un grafo dirigido G = (N, A)
donde un nodo r representa el inicio y un nodo s representa el final del proyecto. Los arcos son las actividades
y los nodos son inicios y términos de conjuntos de actividades, dij es la duración de la actividad (i, j).
Denotemos por ti la variable de decisión que representa el instante de tiempo en que pueden comenzar las
actividades cuyos arcos salen del nodo i. Ahora notemos que la duración total del proyecto (y por ende
la función cuyo objetivo es minimizar) es ts − tr , donde r representa el punto de partida del proyecto y
s el término de este. Para las restricciones, lo importante es considerar la precedencia de las actividades,
lo que puede ser representado por cada arco en la red. De esta manera, lo anterior se puede expresar
matemáticamente como tj ≥ ti + dij ∀(i, j) ∈ A. Por lo tanto, el modelo de programación lineal asociado a
la minimización de la duración del proyecto es:
mı́n ts − tr
s.a. tj − ti ≥ dij ∀(i, j) ∈ A
ti ∈ R ∀i ∈ N
Escribamos ahora el problema dual a este. Llamemos xij a la variable dual asociada a cada arco (i, j) ∈ A.
Notemos que los coeficientes de las variables ti valen 0 excepto para r y s, cuyos coeficientes son −1 y 1
respectivamente. Estos coeficientes equivalen a los valores del lado derecho de las restricciones en el dual.
Del mismo modo, notemos que en el dual hay una restricción por cada nodo y el número de términos en la
función objetivo está limitado a la cantidad de arcos existentes en la red. Por lo tanto, el problema dual es
el siguiente:
máx
P
dij xij
(i,j)∈A
s.a.
j=r

 −1
= 0 j=
P P
xij − xjk 6 r, s ∀j ∈ N
(i,j)∈A (j,k)∈A 1 j=s

xij ≥ 0 ∀(i, j) ∈ A
Esta formulación corresponde a un problema de flujo en el que se busca maximizar el costo de la ruta, es
decir, obtener la ruta más larga (lo que se consigue en el óptimo). Por otro lado, en la formulación inicial
del problema, se buscaba minimizar la duración del proyecto, es decir, obtener la duración mı́nima (lo cual
se consigue en el óptimo). Luego, por el Teorema de Dualidad Fuerte, la ruta más larga coincide con la
duración mı́nima del proyecto. En el área de “Programación de proyectos” esa ruta más larga es la que se
conoce como “Ruta Crı́tica”. Su determinación es fundamental ya que atrasos en las actividades de la ruta
crı́tica implican atrasos en todo el proyecto.
5.3.4. Condiciones alternativas y Lema de Farkas

El siguiente resultado es muy importante y establece una especie de “condición alternativa” con respecto a
la existencia de soluciones de dos sistemas de ecuaciones y desigualdades relacionados. Esto es el:
Teorema 5.3.1: Lema de Farkas

Una y solo una de las siguientes afirmaciones es cierta:
(I) El sistema Ax ≤ b es factible
(II) Existe u ≥ 0 tal que AT u = 0, bT u < 0
La demostración de que ambas no pueden ser verdaderas simultáneamente se puede dar por contradicción:
supongamos que ambas condiciones son verdaderas al mismo tiempo, entonces, si multiplicamos (I) por
u ≥ 0, entonces se mantiene la desigualdad: uT Ax ≤ uT b, por (II) el lado derecho de la desigualdad es nulo,
pues AT u = 0, entonces se llega a que 0 ≤ uT b, lo que es una clara contradicción con la condición de (II)
bT u < 0. El resto del argumento muestra que unoa de ellas tiene que ser verdadera (es decir, no pueden ser
ambas falsas) pero eso requiere argumentos más avanzados de análisis convexo y no la mostraremos ahora.
Lo que subyace a este teorema está relacionado con dualidad. Sea el primal estándar (con c = 0) y el dual
respectivamente como:
máx 0T x mı́n bT u
P) s.a. Ax ≤ b D) s.a. AT u = 0
u≥0
Notar que el dual es factible (u = 0 cumple). Entonces se tiene que si o si se debe cumplir una, y solo una
de las siguientes opciones para un u > 0:
Si el dual es factible no acotado, tal que para un u > 0 se cumple que AT u = 0 y bT u < 0, entonces
su primal será infactible (no se cumple que Ax ≤ b).
Si el dual es acotado, tal que bT u ≥ 0, entonces su primal es factible, tal que se cumple que Ax ≤ b
con valor óptimo 0T x = 0.
Notar que AT u = 0 es un cono.

Cápsula de video 5.3.1: Dualidad y Lema de Farkas
Profesor Jorge Vera repasa en clases los conceptos de dualidad de Programación Lineal e introduce
el Lema de Farkas.
https: // youtu. be/ St9-jCUpGrE
5.3.5. Ejemplos de aplicación del Lema de Farkas

Otros formatos alternativos
Considere un sistema de la forma Ax ≤ b, Bx = d, x ≥ 0. El sistema de desigualdades e igualdades alternativo
según el Lema de Farkas se puede obtener de dos formas. Primero, el Lemma de Farkas dice que el sistema
Ax ≤ b, x ≥ 0 es infactible si y sólo si el sistema AT u ≥ 0, bT u < 0 es factible. Para el sistema propuesto,
podemos escribirlo como:
Ax ≤ b, Bx ≤ d, −Bx ≤ −d, x ≥ 0
y aplicar la formulación básica del lema, de donde se deduce que el sistema alternativo es:
AT u + B T z − B T w ≥ 0, bT u + dT z − dT w < 0, u ≥ 0, z ≥ 0, w ≥ 0
que es lo mismo que:
AT u + B T (z − w) ≥ 0, bT u + dT (z − w) < 0, u ≥ 0, z ≥ 0, w ≥ 0
Llamando v = z − w, como z ≥ 0, w ≥ 0, se tiene que v no tiene restricción de signo alguna y de ahı́ se sigue
que el resultado alternativo es:
AT u + B T v ≥ 0, bT u + dT v < 0, u ≥ 0
Otra forma de obtener el resultado es mediante dualidad. Si el problema de optimización lineal
máx cT x
s.a. Ax ≤ b
Bx = d
x≥0
es infactible, entonces su dual:

mı́n bT u + dT v
s.a. AT u + B T v ≥ c
u≥0
es no acotado. Esto significa que existe (u, v) tales que AT u + B T v ≥ 0, bT u + dT v < 0, u ≥ 0, que es lo
pedido.
Fase I del Simplex

Para la Fase I del Simplex, se resuelve el probelma con las holguras y se busca que estas sean nulas, por lo
que si el valor del siguiente problema es cero, entonces se está en un vértice que es solución factible:
mı́n eT v
s.a. Ax + Iv = b (π)
(x, v) ≥ 0
El dual de este problema corresponde a:

máx bT π
s.a. AT π ≤ 0
Iπ ≤ e
Si el óptimo de este problema es estrictamente positivo (eT v ∗ > 0), entonces por dualidad fuerte, se tiene
que bT π > 0. De esto se sigue que existe π tal que AT π ≤ 0, bT π > 0. Por el Lema de Farkas, se tiene que
el sistema Ax = b, x ≥ 0 no puede ser factible, que es lo mismo que postula la Fase I.
Problema de inversiones
Suponga que dispone de n instrumentos de inversión (bonos, por ejemplo). Sean p1 , . . . , pn los precios de
estos bonos al comienzo del periodo de inversión. Al final del horizonte, el valor de los bonos es v1 , . . . , vn .
Supongamos que se invierte x1 , . . . , xn en cada uno de los bonos (se puede tener xj < 0, es lo que en finanzas
se llama una “posición corta”). Entonces el valor de la inversión inicial es pT x y el retorno final es v T x. Dado
que el retorno real es incierto, es habitual asumir algunos escenarios futuros. Especı́ficamente, supongamos
que se asume que puede ucurrir cualesquiera de m escenarios de retornos, v 1 , . . . , v m , donde v i ∈ Rn . Si
ocurre el escenario i, el retorno será (v i )T x. Si existe un vector de inversiones x tal que pT x < 0 y (v i )T x ≥ 0,
para todos escenario i = 1, . . . , m, se dice que hay una “oportunidad de arbitraje”, que significa que hay
una garantı́a de obtener utilidades en la inversión, libre de riesgos. La teorı́a económica-financiera impone
habitualmente la condición de que no exista arbitraje. Sea V la matriz cuyas filas son los vectores v 1 , . . . , v m
(puestos como filas). Vamos a demostrar que para que no exista arbitraje, entonces debe existir y ∈ Rm tal
que p = V T y, y ≥ 0.
Para argumentar esto, necesitamos la siguiente versión del Lema de Farkas (demostrarla):
Uno y exactamente uno de los siguientes sistemas es factible:
1. Ax = b, x ≥ 0.
2. AT y ≥ 0, bT y < 0.
Ahora, sobre la base de este resultado, podemos ver que para que no haya arbitraje, no debe existir x tal
pT x < 0 y V x ≥ 0. Esto es equivalente a que exista y ∈ Rm tal que p = V T y, y ≥ 0.
5.3.6. SIMPLEX Dual

A veces, el problema dual es tal que resulta más rápido de resolver que el primal, es por eso que algunos
softwares como Gurobi, cuando el computador tiene más de un núcleo, lo que hacen es que en un núcleo
ejecutan el primal y en el otro el dual, de modo que el que el que termine primero arroja el resultado final.
Sea el primal estándar y el dual respectivamente como:
mı́n cT x máx bT u
P) s.a. Ax = b D) s.a. AT u ≤ c
x≥0
El dual se puede escribir en forma estándar añadiendole las holguras:
w∗ = máx bT u
s.a. AT u + s = c
s≥0
Si la matriz A es de m × n, con n > m, entonces, en el problema dual, cuando se transpone la matriz A y se

le añaden las holguras (matriz diagonal de n × n), se pasa a tener una matriz al lado izquierdo con n filas y
m + n columnas (m de AT y otras n de las holguras), de modo que queda una matriz de tamaño n × (m + n),
lo que es mucho más grande y por lo tanto se podrı́a pensar que es peor. Sin embargo, esta matriz es fácil
de tratar en el SIMPLEX Dual con relativa facilidad como si fuera una matriz de m × m.
Suponer una base no factible del primal xB = B −1 b < 0 , pero con costos reducidos c̄R ≥ 0, tal que:

z = mı́n cT x
s.a. Ax = b
x≥0
Dado lo anterior, entonces en el dual la solución es factible:
w = máx bT y
s.a. AT y ≤ c
y irrestricta
Y el dual con variables de holgura, queda:
w = máx bT y + 0T z
s.a. AT y + z = c
y irrestricta
z≥0
Donde por el algoritmo SIMPLEX Dual cuando agrego una columna en el dual, esta es no básica, por lo
que su base sigue siendo factible (zB = 0 , pero zR = c̄R ) . Es decir, busca primero la factibilidad en el dual
(condición óptimalidad), para luego encontrarla en el primal.
Capı́tulo 6
Optimización de gran tamaño
En las aplicaciones reales de optimización muchas veces se presentan problemas con millones de variables y
restricciones. Tal es el caso de modelos del área de la energı́a, especialmente si son bajo incertidumbre, en
logı́stica y otros, por ejemplo. Estos son los que llamaremos problemas de “gran tamaño”.
La existencia de problemas grandes no es nueva, por supuesto, lo que se entiende por “grande” es en relación
a la capacidad de cómputo y almacenamiento. Antiguamente era especialmente más difı́cil el manejo de
problemas de optimización con miles de variables, no era ni siquiera posible guardarlo en la memoria de
los computadores. Tales problemas fueron formulados en la década de 1960, por ejemplo, para la industria
petrolera y también en otras aplicaciones. Los expertos de esas épocas diseñaron enfoques para lidiar con
esto y una idea que sirvió fue el usar la información del problema en forma “parcial pero inteligente”, lo
que llevó al enfoque de Generación de Columnas. Otra idea fue descomponer un problema grande en partes
más pequeñas y más manejables que luego se pudieran unir (en algún sentido), lo que lleva a los enfoques
de descomposición de Dantizig-Wolfe y Benders. Posteriormente aparecieron enfoques de descomposición
mediante dualidad.
Pero hoy un problema con varios millones de variables y restricciones requiere igual de estos enfoques
especiales, con las modernizaciones adecuadas y ese será el tema de este capı́tulo.
6.1. Generación de columnas

El primer enfoque que estudiaremos busca utilizar de forma inteligente los datos del problema. Especı́ficamente,
si pensamos en un problema de Programación Lineal, habitualmente consideramos que tenemos “a la vista”
los datos de las restricciones y la función objetivo. Veremos en esta sección que basta usar sólo los que se
necesitan.
Motivación: problema de Cutting Stock (o corte de piezas)

Una compañı́a forestal tiene troncos de largo L que se deben cortar para obtener “trozas” de largos especı́ficos.
Hay m de largos l1 , . . . , lm y hay demandas por cada tipo de troza, d1 , . . . , dm para los distintos productos.
Cada tronco es cortado de acuerdo a un “patrón de corte.el cual especifica el número de piezas de cada tipo
que se cortan del tronco de largo L. Cada patrón de corte define una forma única de cortar el tronco y para
el patrón de corte j vamos a llamar aij la cantidad de piezas (trozas) de tipo i que se obtienen usando ese
patrón. Como los patrones se aplican a un tronco de largo L fijo, la cantidad de piezas debe ser tal que los
largos combinados no superen L. Es decir:
m
X
aij li ≤ L, ∀j = 1, . . . , n
i=1
Se busca determinar cuántos troncos usar con cada patrón de corte de modo tal de satisfacer la demanda,
pero usando la menor cantidad de troncos posibles. Lo que se busca aquı́ es ser eficientes minimizando las
pérdidas por recorte o “trim”. Sea xj la cantidad de troncos cortados con el patrón de corte j. El modelo,
para patrones aij válidos, consiste en minimizar la cantidad de troncos utilizados para satisfacer la demanda.
Esto es:
112
Francisco Garcı́a y Jorge Vera 6.1. Generación de columnas 113
n
X
mı́n xj
j=1
Xn
s.a. aij xj ≥ di , ∀i = 1, . . . , m
j=1
xj ∈ Z+
0, ∀j = 1, . . . , n
Para simplificar la complejidad que involucra el problema, al ser de programación entera, se puede aprovechar
el hecho que los números son grandes y ası́ relajar la restricción de integralidad, por lo que la restricción
de que xj ∈ Z+ 0 se cambia por xj ≥ 0, xj ∈ R, convierténdose en un problema de programación Lineal que
no es más que la relajación lineal del problema entero original. Si el problema es de tamaño muy grande,
es muy marginal lo que si pierde de optimalidad haciendo esto. Además, dada cualquier solución con parte
fraccionaria en una variables xj , siempre podemos redondear al entero superior y obtendremos una solución
factible. Tenemos, entonces, el siguiente problema:
n
X
mı́n xj
j=1
Xn
s.a. aij xj ≥ di , ∀i = 1, . . . , m
j=1
xj ≥ 0, ∀j = 1, . . . , n
Sin embargo, es fácil darse cuenta que hay una cantidad combatorialmente grande de posibles patrones de
corte, lo que se podrı́a traducir, en un caso real, que el problema tenga una cantidad enorme de variables,
aunque el número de restricciones será pequeño. Lo que argumentaremos ahora es que no es necesario conocer
en detalle todos los patrones de corte.
Para esto, necesitamos recordar lo que sucede en el algoritmo Simplex: Si conociéramos todas las columnas
A1 , . . . , An y estamos en una iteración de Simplex donde B ∈ Rm×m es la base actual y π los multiplicadores
actuales, luego para elegir que variable entra a la base, se deben calcular los costos reducidos de todas las
n − m columnas que no están en la base, para ası́ encontrar el ı́ndice de la columna no básica con menor
costo reducido c̄j = cj − π T Aj < 0 con j ∈ IN (donde In es el conjunto de ı́ndices no básicos.) Para el
problema en cuestión, como cj = 1, entonces lo que se busca es:
( m
)
X
mı́n 1 − π Aj = 1 − máx
T

πi aij
j∈IN j∈IN
i=1
Recordemos que los número aij son los que describen el patrón y que puede ser una cantidad muy grande.
Sin embargo, esos no son números cualquiera ya que cumplen ciertas condiciones, notablemente la relación
m
X
aij li ≤ L, ∀j = 1, . . . , n
i=1
Consideremos, entonces, el siguiente problema de optimización:
m
X
η = máx πi ui
i=1
Xm
s.a. ui li ≤ L
i=1
ui ∈ Z+
0, ∀i = 1, . . . , m
Notemos que cualquier solución factible de este problema es una combinación de valores que define un
patrón de corte válido y que la función objetivo es precisamente la parte del costo reducido que queremos
maximizar. De este modo, si 1 − η < 0, entonces entonces los números u1 , . . . , um pueden usarse para definir
114 Capı́tulo 6. Optimización de gran tamaño
un patrón de corte, es decir, una de las columnas formadas por los coeficientes aij del problema, para algún
j. Más aún, esa columna j entrega el menor costo reducido e identifica una nueva variable que puede entrar
a la base de Programación Lineal. Pero, si 1 − η ≥ 0, se satisface el criterio de optimalidad de Simplex, pues
no existen combinaciones de valores aij que definan patrones de cortes válidos y que, a su vez, identifiquen
una columna para entrar a la base.
De este modo, se van generando las columnas a medida que se necesitan, y no es necesario conocer
explı́citamente todas las columnas o patrones de corte con anticipación ni guardarlas en memoria.
Desde una perspectiva económica, el problema satélite busca el patrón con mayor beneficio marginal para
el problema maestro (reducción de costos, en este caso), usando para esto el valor que las distintas piezas
aportan al objetivo final, información que está contenida en los π, que son los valores óptimos de las variables
duales del problema considerando las columnas que existen hasta el momento. El patrón con mayor beneficio
marginal es, entonces, el que se debe ingresar.
Cápsula de video 6.1.1: El problema de corte de piezas
Profesor Jorge Vera explica en clases el problema de corte de piezas o Cutting Stock, para introducir
la técnica de Generación de Columnas
https: // youtu. be/ hYO5ktYyYEg
Recapitulando
Todos esto es lo que se conoce como el método de “Generación de columnas” y fue desarrollado por Gilmore
& Gomory en 1961. Este método se suele aplicar en problemas de gran tamaño (en el número de variables),
como por ejemplo donde se tiene que encontrar la ruta más corta entre dos puntos y existen millones de
rutas que los unan. El método es aplicable siempre que haya un “generador”, es decir, la estructura del
problema permita caracterizar de alguna forma matemática las relaciones que existen entre los coeficientes
de las columnas.
6.1.1. El algoritmo general

Comenzamos con un problema mı́n cT x : Ax = b, x ≥ 0 , sin conocer explı́citamente todas las columnas,

pero sı́ sabemos que los coeficientes (cj , Aj ) pertenecen a un conjunto D ⊂ Rm+1 , cuya estructura conocemos
(tı́picamente D corresponde a un conjunto de restricciones matemáticas). Notemos que acá estamos incluyendo
los coeficientes de la función objetivo y, efectivamente, estos entran dentro de la generación, en general. En
el ejemplo de motivación del problema de corte de piezas, esos coeficientes eran siempre igual a 1, pero eso
no tiene que ser ası́, ene general.
Si hemos generado una cantidad de columnas, digamos k, tenemos que hacer la operación de cálculo de
los costos reducidos para las restantes columnas (las que están contenidas en D). Ahora bien, podemos
considerar el problema:
X
mı́n cj xj
j∈J
k
X
s.a. Aj x j = b
j=1
x≥0
Este es el problema con las columnas generadas hasta el momento. Si se resuelve este problema con el
Simplex, las variables duales πi , i = 1, . . . , m que se obtienen como solución dual óptima son precisamente
los multiplicadores del Simplex que necesitamos para hacer el análisis de introducir una nueva columna Ak+1
con costo reducido negativo (si existe). Al problema parcial, formado por las columnas generadas hasta el
momento, lo llamaremos el Problema Maestro. La generación de la nueva columna se hace en el Problema
Satélite.
Ahora presentamos el algoritmo general. Llamemos, J al conjunto de ı́ndices de las columnas que se van
generando.
Algoritmo de Generación de columnas
Data: Comenzamos con unas pocas columnas {(cj , Aj ) , j ∈ J}.

Resolvemos el “Problema Maestro” (master):
X
mı́n cj xj
j∈J
X
s.a. Aj x j = b
j∈J
x≥0
Sean π las variables duales óptimas del maestro (los multiplicadores del SIMPLEX).
Se hace el “pricing” de las demás columnas, para lo que se resuelve el “Problema Satélite”, que
evalúa el costo reducido (c̄j = cj − π T Aj ), y se quiere encontrar un coeficiente cj y una columna
Aj , contenidas en el conjunto D y tales que el costo reducido sea mı́nimo, para lo que se explora el
conjunto D con el escalar u0 (que juega el papel de cj ) y el vector u (que juega el papel de Aj ):
ρ = mı́n u0 − π T u
s.a. (u0 , u) ∈ D
Si ρ ≥ 0, se ha llegado al óptimo, en caso contrario, la solución del satélite entrega una columna
para agregar al maestro y el conjunto J crece en uno:
u0 cj
   
u1  A1j
  " # 
u0
= que en el fondo corresponde a:
   
..  ..
  

 .

 u  .


um Amj
end
Podemos interpretar esto como un diálogo entre el Maestro y el Satélite: el maestro envı́a información π al
satélite, que indica “cuánto está dispuesto a pagar por algo nuevo” y este devuelve una columna, que serı́a
“lo nuevo que se puede usar que más contribuye a mejorar la función objetivo”. Con esta nueva actividad,
el maestro vuelva a evaluar los π y ası́ sucesivamente. La figura ilustra este diálogo.
mı́n
P
c x
Pj∈J j j ρ = mı́n u0 − π T u
s.a. j∈J Aj xj = b
s.a. (u0 , u) ∈ D
x≥0
(Maestro) (Satélite o Pricing)

" #
u0
u
6.1.2. Multiple Pricing

En muchos casos, el problema satélite puede tener una estructura combinatorial compleja lo que hace lento
resolverlo hasta el óptimo. Para solucionar este problema, se puede resolver de forma aproximada, basta
con (u0 , u) ∈ D cumplan que u0 − π T u < 0, es decir, que el costo reducido sea negativo, no necesariamente
el más negativo. Si se implementa esto en forma eficiente es posible encontrar varias soluciones factibles al
satélite y que tengan costo reducido negativo. Entonces, se agregan al maestro todas las columnas generadas
con costos reducidos negativos y se resuelve ese maestro. Hacer esto es lo que se conoce como “Multiple
Pricing” y es habitualmente muy usado en problemas de Generación de Columnas.
Cápsula de video 6.1.2: Generación de Columnas: el algoritmo general y un ejemplo

computacional
Profesor Jorge Vera explica en clases el algoritmo general de Generación de Columnas y muestra un
ejemplo computacional del problema de corte de piezas.
https: // youtu. be/ YIENq5jweuQ
6.1.3. Ejemplos
Problema de corte de piezas más general
Consideremos nuevamente el problema de corte de piezas pero al que hemos agregado algunas condiciones
adicionales respecto a la forma en que se hacen los cortes, motivadas por la tecnologı́a de corte. Estas son:
1. Existe un costo α por cada corte que se haga al tronco. Esto significa que si el tronco se corta 4 veces
(para obtener 5 piezas), entonces hay un costo cj = 4α asociado al patrón. Vamos a suponer que las
piezas de sobre también se consideran útiles ya que pueden ser procesadas para genración de energı́a.
2. No es posible obtener más de 3 piezas de cada tipo cuando se ejecuta un patrón de corte.
Luego, se tiene que decidir cuántos troncos usar con cada patrón de corte de modo de minimizar el costo total
(en vez de minimizar el número de troncos usados, como en el ejemplo inicial). Veamos cómo se desarrolla
la Generación de Columnas.
El problema maestro es de la forma
mı́n
P
cj xj
j∈J
aij xj ≥ di , i = 1, . . . , m
P
s.a.
j∈J
xj ≥ 0, j ∈ J
donde J es el conjunto de ı́ndices de los patrones activos en este momento. Este problema viene de la
relajación lineal del problema original, tal como se hizo en clases.
Este problema se resuelve y se obtienen las variables duales π. El satélite tiene que buscar un nuevo patrón
de corte con menor costo reducido, que es
m
X
c̄j = cj − aij πi
i=1
En este caso, el costo del patrón también tiene que ser generado ya que depende de cómo se corta el tronco.
bajo el P
supuesto de que todas las piezas se consideran útiles, podemos decir que el costo del corte es
cj = α( i aij − 1). Entonces, el satélite es de la forma:
m m

η = mı́n ui − 1) −
P P
α( πi ui
i=1 i=1
m
P
s.a. ui li ≤ L
i=1
ui ≤ 3, i = 1, . . . , m
ui ≥ 0, entero
(el término −α puede quedar fuera del problema, obviamente). Si η < 0, eso genera una columna que entra
al problema y se agrega al maestro, y el método lo resuelve nuevamente. Y ası́ sucesivamente.
Problema de la p-mediana
En este ejemplo consideramos el problema de “p-median”, que es una forma de problema de localización
de instalaciones y asignación de clientes. Tenemos un conjunto de n entidades las cuales deben ser asignadas a
una o más entidades especiales de entre ellas, llamadas “medianas” (“median”, en Inglés). Más especı́ficamente,
asumiremos que se conoce un costo dij que corresponde al costo de asignar la entidad i a la entidad j, la cual
actúa como mediana. djj corresponde al costo de usar j como mediana. Cualquier entidad puede tomar el
lugar de mediana y algunas de las otras deberán ser asociadas con ella, pero se debe hacer de modo que sea
“costo eficiente”. Una condición del problema es que deben elegirse exactamente p entidades como medianas.
Usemos la variable binaria xij = 1 si la entidad i es asociada a la mediana j, en particular xjj = 1 significa
que j es elegida como mediana. Hay una demanda (o carga de trabajo) qi en la entidad i, y cada entidad,
si es elegida como mediana, puede manejar una demanda total no mayor a Q (incluyendo la propia). El
siguiente modelo encuentra la asignación de menor costo total:
mı́n
P P
dij xij
i∈N
P j∈N
s.a. xij = 1, i ∈ N
j∈N
xjj = p
P
j∈N
P
qi xij ≤ Qxjj , j ∈ N
i∈N
xij ∈ {0, 1}, i ∈ N, j ∈ N
Lo primero que observaremos es que este modelo efectivamente selecciona p entidades como medianas y
asigna el total de las n − p restantes a estas, excluyendo la posiblidad de que alguna entidad juegue el papel
de mediana y cliente al mismo tiempo y, de este modo, el resultado es particionar N = {1, . . . , n} en p
subconjuntos, cada uno de los cuales tiene una entidad que hace el papel de mediana.
En efecto, las variables xjj seleccionan la mediana y las otras asignan las restantes. Las primeras restricciones
garantizan que cada entidad sólo puede jugar un papel, mediana o cliente. Las segundas restricciones
garantizan que haya exactamente p medianas y las últimas restricciones garantizan el cumplimiento de
la capacidad.
Las primeras restricciones, a su vez, dado que xij = 1, impiden que una misma entidad sea asignada a
P
j∈N
más de una mediana. De este modo, el conjunto de todas las entidades queda particionado en subconjuntos
los cuales tienen una mediana y otras entidaddes asignadas a ella. La partición es en conjuntos disjuntos.
Pero ahora vamos a considerar la siguiente formulación alternativa al problema. Sean S1 , S2 , . . . , SK todos
los subconjuntos de N = {1, . . . , n} con dos o más elementos. Sea Ak ∈ Rn dado por
1 i ∈ Sk

aik =
0 si no
y sea !
X
ck = mı́n dij
j∈Sk
i∈Sk
Usemos variables binarias xk = 1 si se elige el conjunto k, y 0 si no, y consideremos el siguiente modelo de

optimización:
K
mı́n
P
ck xk
k=1
K
Ak xk = 1
P
s.a.
k=1
K
xk = p
P
k=1
xk ∈ {0, 1}, k = 1, . . . , K
Vamos a argumentar que este problema resuelve el problema de p-median en forma totalmente equivalente.
Este último problema es una forma de “set partitioning”, como se conoce en optimización combinatorial.
En efecto, Cada Ak es, simplemente, un vector indicador de los elementos del conjunto k. La estructura
de esos conjuntos, y su correspondiente vector indicador, debe ser compatible con la descripción original
del problema, es decir, deben cumplir con la capacidad. Esto significa que, si aik son los coeficientes de la
columna k, entonces Sk debe ser tal que un ı́ndice de de Sk toma el papel de la mediana, digamos i0 y los
otros son los clientes asiciados, y deberá cumplirse que
X
qi ≤ Q
i∈S
De esta manera, las columnas Ak describen conjuntos válidos de entre todos los posibles sobconjuntos de
N . La primera restricción del modelo garantiza que toda entidad sea usada (de alguna forma, como cliente
o como mediana) y la segunda restricción garantiza que p subconjuntos sean seleccionados, induciendo p
medianas. Notemos también que el costo propuesto,
!
X
ck = mı́n dij
j∈Sk
i∈Sk
corresponde a seleccionar, de todas las posibles combinaciones en Sk , en donde una entidad toma el papel
de mediana y las otras de clientes, la más barata.
Ahora bien, la formulación anterior podrı́a tener un número exponencialmente grande de columnas, lo que lo
hace un excelente candidato a ser abordado mediante Generación de Columnas. La generación de Columnas
se aplica a la relajación lineal del problema:
K
mı́n
P
ck xk
k=1
K
Ak x k = 1
P
s.a.
k=1
K
xk = p
P
k=1
0 ≤ xk ≤ 1, k = 1, . . . , K
En una etapa cualquiera de la generación, tendremos el siguiente problema maestro:
mı́n
P
ck xk
k∈J
Ak x k = 1
P
s.a.
k∈J
xk = p
P
k∈J
0 ≤ xk ≤ 1, k ∈ J
donde J es una manera de denotar los conjuntos que han sido generados hasta el momento. Sea π = (v, t),
con v ∈ Rn y t escalar, el vector de variables duales óptimas en esta iteración del problema maestro. Estas
variables las usaremos para el problema satélite, el cual debe generar un nuevo conjunto asociado a una
columna de costo reducido negativo y que cumple con la estructura de tener una mediana y otras entidades
asociadas respetando la capacidad. Consideremos el siguiente problema, inspirado en el problema original:
mı́n
P P P P
dij uij − vi uij
i∈N
P j∈N i∈N j∈N
s.a. uij ≤ 1, i ∈ N
j∈N
ujj = 1
P
j∈N
P
qi uij ≤ Qujj , j ∈ N
i∈N
uij ∈ {0, 1}, i ∈ N, j ∈ N
Este problema determina la asignación, de entre las n entidades, de una como mediana (la que asigne la
variables ujj activada), y de algunas otras entidades de modo que el costo (notar que no pedimos que todas
sean asignadas), que corresponde al balance entre el costo de asignación y el inducido por las variables
duales, sea mı́nimo. Si η − t es ≤ 0, eso define una columna para agregar al maestro. Sea ū la solución
óptima de este problema. La nueva columna tiene un costo igual a
XX
dij ūij
i∈N j∈N
y el correspondiente conjunto S, que define los coeficientes de la columna Ak , quedan definidos por las
variables ūij activadas. Nótese que solo para un único ı́ndice i las variables uij se activarán en 1.
“Crew Scheduling” o Programación de Tripulaciones

Este es un problema clásico al cual se puede aplicar generación de columnas. Lo ilustramos aquı́ considerando
la situación de una empresa del sector de los ferrocarriles de alta velocidad la que tiene trenes que conectan
distintas ciudades. Cada tren tiene que tener asignada una tripulación de comando y control, las cuales deben
cubrir los tramos y pernoctar en las ciudades de un dı́a para otro. La empresa quiere determinar un esquema
de asignación de tripulaciones a segmentos de viaje para una semana. Más en especı́fico, supondremos que
la empresa atiende un conjunto N de ciudades las cuales está conectadas por lı́neas de alta velocidad. Los
viajes de trenes están descritos, entonces, por un conjunto de arcos dirigidos A ⊂ N × N . Entonces, la red
de viajes es el grafo (N, A) en donde cada arco es un segmento de viaje entre dos ciudades. Suponemos, para
simplificar, que se hace sólo un viaje al dı́a en un segmento y se repite todos los 7 dı́as de la semana. Cada
segmento debe estar cubierto por alguna tripulación en cada uno de los dı́as de la semana.
Vamos a suponer que hay M tripulaciones disponibles en la empresa. Para cada tripulación podemos definir
una serie de alternativas de “turno” o itinerario, que son opciones con las cuales pueden cubrir distintos
segmentos de viaje. La forma en que se definen estas opciones de las tripulaciones debe seguir las siguientes
reglas:
1. Cada tripulación, al inicio de la semana, parte en una ciudad conocida, denotamos esa ciudad por
sk ∈ N , para la tripulación k = 1, . . . , M . El itinerario de la tripulación puede terminar en una ciudad
diferente.
2. Los segmentos que cubra una tripulación deben ser consecutivos en la red en dı́as consecutivos y en
cada dı́a la tripulación debe estar asignada a un único segmento. De este modo, debe ocupar los 7 dı́as
de la semana en 7 segmentos (supondremos que hay muchos segmentos).
3. El costo de una opción especı́fica de itinerario para la tripulación k se calcula en función de lo siguiente:
si la tripulación es asignada al segmento (i, j) ∈ A, hay un costo ckij . Notar que pueden repetirse
ciudades.
Por ejemplo, sólo para ilustrar, una tripulación podrı́a tener la siguiente secuencia de segmentos partiendo de
la ciudad 3: (3, 1), (1, 2), (2, 4), (4, 5), (5, 8), (8, 11), (11, 4). Cada uno de esos siete segmentos se cubren desde
el dı́a 1 al dı́a 7 y el costo total de esta opción es la suma de los costos de cada uno de esos 7 segmentos.
Vamos primero a formular el problema de optimización de “crew scheduling”, que encuentra la mezcla de
opciones de itinerarios de tripulaciones de menor costo, tratando que cada segmento de viaje esté cubierto
por una opción de tripulación en cada uno de los dı́as. Adicionalmente, vamos a considerar la posibilidad
de que algún segmento no logre ser cubierto en algún dı́a y asuma que si el segmento (i, j) no puede recibir
una opción de tripulación en algún dı́a, entonces se incurre en un costo gij .
Para construir el modelo vamos a pensar que existen una cantidad de “segmentos” de viaje, que corresponden
a un tramo de itinerario en un dı́a especı́fico de la semana. A cada uno de esos tramos y dı́as (los segmentos)
se deben, entonces, asignar las tripulaciones. Entonces, podemos pensar un las posibles formas que las
tripulaciones podrı́an ser asignadas a lo largo de la semana, generando un gran conjunto de “opciones” las
cuales pueden quedar, simplemente, caracterizadas por el siguiente coeficiente:
1 si opción de tripulación j puede cubrir segmento i

aij =
0 en caso contrario
Sea cj es el costo asociado a la opción j. Entonces, necesitamos definir variables de decisión binarias xj , que
valen 1 si la opción de tripulación j es elegida y 0 si no.
Ahora, es necesario tratar de cubrir los segmentos pero dejamos abierta la posibilidad de que no sea ası́, con
el costo indicado. Para esto vamos a definir otra variable binaria, vi , que vale 1 si el segmento no es cubierto,
y 0 si lo es.
Con esto, el modelo que determina qué opciones seleccionar es el siguiente:
n m
mı́n cj xj +
P P
gi vi
j=1 i=1
n
aij xj + vi = 1, i = 1, . . . , m
P
s.a.
j=1
xj ∈ {0, 1}, vi ∈ {0, 1}, j = 1, . . . , n; i = 1, . . . , m
Ahora explicamos cómo se desarrolla una procedimiento de Generación de Columnas para este problema.
El problema maestro corresponde a la relajación lineal de modelo que hemos planteado, pero en el que no
se conocen todas las columnas. Ası́, las variables x serán continuas y tendremos un conjunto J ⊂ {1, . . . , n}
de columnas ya generadas. El problema es:
m
mı́n cj x j +
P P
gi vi
j∈J i=1
aij xj + vi = 1, i = 1, . . . , m
P
s.a.
j∈J
xj ∈ {0, 1}, vi ∈ {0, 1}, j ∈ J
Para la construcción del problema satélite consideraremos las variables duales provenientes del maestro,
πi , i = 1, . . . , m. Acá recordemos que los segmentos corresponden a un viaje por el arco (p, q) en un dı́a
especı́fico t, ası́ que es conveniente aquı́ descomponer los bloques de las variables π según el ı́ndice (p, q) y
el ı́ndice del tiempo, t. Entonces, tenemos las variables duales πpq
t
, (p, q) ∈ A, t = 1, . . . , 7.
El problema satélite debe, entonces, construir una opción de tripulación que respete las restricciones establecidas.
Para esto, planteamos un problema de optimización entera, usando variables utpq . Esta vale 1 si una
tripulación va de la ciudad p a la ciudad q en el dı́a t. En el problema satélite debemos evaluar el costo reducido
del problema maestro. Vamos a plantear este problema satélite para cada una de las M tripulaciones. De este
modo, el satélite determinará la opción de tripulación más conveniente para cada una de las tripulaciones y
tendremos que seleccionar la de menor costo reducido. El problema es el siguiente:
Francisco Garcı́a y Jorge Vera 6.2. Descomposición de Dantzig-Wolfe 121
t
η k = mı́n ckpq utpq − t
P P P
πp,q
(p,q)∈A (p,q) t=1
ut(sk ,q) = 1
P
s.a.
q:(sk ,q)∈A
(1)
ut(p,q) = ut+1 (p, q) ∈ A, t = 1, . . . , 6
P
(q,r)
r:(q,r)∈A
(2)
ut(p,q) ∈ {0, 1} (p, q) ∈ A, t = 1, . . . , 7
(3)
La función objetivo determina el costo reducido. El primer sumando es el costo de una ruta especı́fica para
la tripulación, la cual estará definida por las variables ut(p,1) , el segundo término corresponde a “π T Aj ”, es
decir, el “precio” de la columna que será generada. La restricción (1) establece que se comienza en el nodo
sk , la restricción (2) establece que la ruta que se construye avanza de un dı́a a otro a un nodo diferente.
De este modo, si η k < 0 para alguna de las tripulaciones, entonces los valores óptimos de las variables,
llamémoslos û(p,q)t definen coeficientes aij adecuados para una nueva columna a agregar al problema maestro.
Por otro lado, el costo de la nueva columna j es igual a cpq ûpq .
P k t
(p,q)∈A
6.2. Descomposición de Dantzig-Wolfe

Muchos problemas de optimización son de gran tamaño, con muchas variables y restricciones. La generación
de Columnas, como hemos visto, permite abordar un problema con muchas columnas pero hay otros que
presentan gran tamaño por todas partes. Sin embargo, a veces esos problemas tiene una estructura muy
especial. Identificar esa estructura para desarrollar una forma de resolver el problema es lo que ilustraremos
ahora con una técnica que fue originalmente desarrollada en los años 1960, pero que sigue 100 % vigente
hoy. Vamos a partir, eso sı́, motivando la estructura que consideraremos y luego iremos a los detalles.
Motivación: problema de flujos multiproducto (multicommodity flow problem)

Consideremos la situación de una red logı́stica en donde hay una cantidad de bodegas que manejan distintos
productos. Para cada producto existen ofertas y demandas en cada una de las bodegas y existen costos de
transporte. Esto es como un problema de optimización de flujos entre distintos lugares y a costo mı́nimo,
pero hay una condición adicional: existe un lı́mite de capacidad total a lo que se puede transportar entre un
lugar y otro. Este es el problema que queremos modelar.
El problema se puede representar mediante un grafo dirigido G = (N, A), con N el conjunto de nodos y A
el conjunto de arcos. Sea el conjunto K los pares de nodos de origen-destino: {ok = (rk , sk ) : rk ∈ N, sk ∈
N, ∀k ∈ K}, donde cada par k ∈ K posee una demanda de flujo dk . Por otro lado, cada arco (i, j) ∈ A posee
una capacidad uij , un costo de ckij , k ∈ K. Sea xkij la variable de la cantidad trasportada entre el arco (i, j)
para el par k ∈ K. Ver Figura 6.1.
El modelo de optimización que minimiza los costos para este problema es:
X X
mı́n ckij xkij
k∈K (i,j)∈A
X X
s.a. xkij − xkpi = bki , ∀i ∈ N, k ∈ K (1)
X
xkij ≤ uij , ∀(i, j) ∈ A (2)
k∈K
xkij ≥ 0, ∀(i, j) ∈ A, k ∈ K (3)
Donde (1), que va para cada par origen-destino k, dice que lo que sale de un nodo i, menos lo que entra es
igual a su balance bki (que es nulo cuando no es de origen ni de destino) de ese nodo:
Figura 6.1: Grafo multicommodity

dk ,
 i = rk
bki = −dk , i = sk
0, e.o.c.


(2) dice que en cada arco, la suma de los flujos para cada par origen-destino k, debe respetar su capacidad
máxima. El modelo se puede reescribir de forma alternativa, pasando (2) para arriba y expandiendo la
sumatoria para el ı́ndice k. Además se ordena (1) de tal modo que cada columna que se visualiza está
asociada a un ı́ndice de un par k ∈ K:
X X X
mı́n c1ij x1ij + c2ij x2ij + ... + cK K
ij xij
(i,j)∈A (i,j)∈A (i,j)∈A
s.a. x1ij + x2ij + ... + xK

ij ≤ uij , ∀(i, j) ∈ A
X X
x1ij − x1pi = b1i , ∀i ∈ N
X X
x2ij − x2pi = b2i , ∀i ∈ N
.. ..
. .
X X
xK
ij − xK
pi = bK
i , ∀i ∈ N
x1ij ≥ 0, ∀(i, j) ∈ A, x2ij ≥ 0, ∀(i, j) ∈ A, ... ij ≥ 0, ∀(i, j) ∈ A

xK
| {z } | {z } | {z }
columnas para k=1 columnas para k=2 columnas para k=K
En este modelo, se puede visualizar claramente una estructura muy especial. En la primera fila de la matriz
que se ve, todos los pares de origenes destinos están mezclados (restricciones comunes para todos los pares
origen destino), mientras que en las otras restricciones, cada par k ∈ K va en un bloque, de modo que no hay
interacciones entre dos pares distintos (actúan como independientes). Llevando esto mismo a una estructura
más genérica, con K bloques independientes y otra parte de restricciones comunes, tenemos un problema
lineal con la siguiente estructura (Problema Dantzig-Wolfe):
mı́n cT1 x1 +···+ cTK xK

s.a. A1 x 1 +···+ AK x K = b
D1 x1 = d1
.. .. .. ..
. . . .
DK xK = dK
x1 ≥ 0, ··· , xK ≥ 0
donde Ak ∈ Rm×nk , b ∈ Rm , Dk ∈ Rpk ×nk , dk ∈ Rpk y {ck , xk } ∈ Rnk , k ∈ K.

En forma más gráfica, la forma en que se distribuyen los coeficicentes del problema puede ser vista como
esto:
Figura 6.2: Estructura de Problema para Descomposición de Dantzig-Wolfe
El gran problema aquı́ son las restricciones comunes, que impiden que se pueda tratar el problema multiproducto
como K problemas de flujo a costo mı́nimo por separado. La capacidad en los arcos, que es común a todos
los flujos de todos los pares origen-destino es lo que genera el problema. A estas restricciones comunes está
asociada la matriz A corresponde a las denominadas “restricciones complicantes”.
Vamos a abordar este problema transformándolo en otro equivalente mediante un cambio de variable.
Esto lo vamos a hacer representando los poliedros asociados a cada bloque de una forma alternativa: no
vamos a usar las desigualdades, es decir la representación algebraica, sino que la representación puntual.
Consideremos los poliedros Pk = {x ∈ Rnk : Dk x = dk , x ≥ 0}, que son los poliedros asociados a las
restricciones de los bloques. Como sabemos, el poliedro Pk tiene puntos extremos v k1 , . . . , v krk y rayos
extremos uk1 , . . . , ukpk . Entonces por el teorema de representación de Minkowski-Weil-Motzkin, si x ∈ Pk ,
entonces existen λk1 , . . . , λkrk y µk1 , . . . , µkpk , tales que 0 ≤ λki ≤ 1, ∀i = 1, . . . , rk , µkj ≥ 0, j = 1, . . . , pk y
que x se puede escribir la combinación convexa de los vértices del polı́gono más la combinación cónica de
los rayos:
rk
X pk
X rk
X
x= λki v ki + µkj ukj , λki = 1
i=1 j=1 i=1
Para simplificar el resto de la presentación, vamos a asumir que los poliedros Pk son acotados. De este modo,
no hay que considerar los rayos. Entonces, si xk ∈ Pk , tenemos que:
rk
X rk
X
x =
k ki
λki v , λki = 1
i=1 i=1
Ahora vamos a reemplazar esta escritura de xk en el problema de optimización, de modo que ya no se trabaje
con las variables x, sino las λki :
rk
X rk
X rk
X
Ak x k = Ak λki v ki = λki Ak v ki , λki = 1

i=1 i=1 i=1
Xrk Xrk rk
X
cTk xk = cTk λki v ki = λki cTk v ki , λki = 1

i=1 i=1 i=1
De este modo, el problema de optimización queda ası́ (con las variables duales de cada conjunto de restricciones,
o multiplicadores del Simplex, a la derecha):
Pr1 Pr2 PrK

mı́n + +...+

i=1 λ1i c11 v 1i i=1 λ2i c12 v 12 i=1 λKi cTK v Ki
Pr1 Pr2 PrK
s.a. + +...+ = (π)

i=1λ1i A1 v 1i i=1 λ2i A2 v 12 i=1 λKi AK v Ki b
Pr1
i=1 λ1i = 1 (t1 )
Pr2
i=1 λ2i = 1 (t2 )
.. ..
. .
Prk
i=1 λki = 1 (tK )
0 ≤ λ1i ≤ 1, i = 1, . . . , rk , 0 ≤ λ2i ≤ 1, i = 1, . . . , rk , ··· , 0 ≤ λki ≤ 1, i = 1, . . . , rk
Notemos que este problema ahora está escrito en las variables λ. Si bien sigue teniendo la misma estructura
de bloques que el problema original, hay una gran diferencia: cada bloque k tiene solo una restricción. Las
restricciones comunes sı́ siguen siendo la misma cantidad inicial. Escrito en forma más compacta, el problema
es:
K
(r )
X X k
mı́n λki cTk v ki

k=1 i=1
K
(r )
X X k
s.a. ki
=b (π)

λki Ak v
k=1 i=1
Xrk
λki = 1 ∀k = 1, . . . , K (tk )
i=1
λki ≥ 0 ∀k = 1, . . . , K; i = 1, . . . , rk
Este problema de optimización tiene m+K restricciones o filas (pocas) y k rk variables o columnas, que son
P
muchı́simas dado que hay una por cada vértice de cada poliedro Pk . Desde luego, no conocemos esos vértices
pero sı́ conocemos su estructura: son vértices de un poliedro cuyas restricciones lineales conocemos. Esto
sugiere que deberı́amos poder usar el enfoque de Generación de Columnas de la sección anterior. Generar
columnas para este problema equivale a encontrar los vértices que generaron las columnas de este problema
(recordemos que cada columna tiene una parte que es de la formaAk v ki ).
Para las primeras m restricciones se tiene asociada una variable dual π, y para las siguientes k ∈ K una
variable tk para cada una de ellas. La operación de Pricing calcula el vector de costos reducidos de la columna
del punto extremo (k, i) como:
c̄ik = cTk v ki − π T Ak v ki − tk

Para encontrar un candidato a entrar a la base se resuelven los K problemas (uno por bloque) de Pricing
buscando el valor objetivo más negativo por bloque k = 1, . . . , K de los siguientes problemas:
ηk = mı́n cTk u − π T (Ak u)

s.a. u punto extremo de Pk
Notemos que la función objetivo se puede reescribir como (ck − AT π)T u. Entonces, el problema consiste
en encontrar un punto extremo de un poliedro que alcance el mejor valor de una función lineal. Eso no
es más que un problema de Programación Lineal sobre las restricciones que definen el poliedro, que son
Dk u = dk , u ≥ 0. De este modo, lo que queremos resolver son los problemas:
T
ηk = mı́n cTk u − π T Ak u ηk = mı́n ck − ATk π u
s.a. Dk u = dk ⇐⇒ s.a. D k u = dk
u≥0 u≥0
Entonces, si para algún k tenemos que ηk − tk < 0 y este problema alcanza el óptimo en el vértice v kj ,
entonces ese vértice v kj permite reconstruir una columna para el problema maestro que conviene hacer
entrar a la base. Esa columna es de la forma:
Ak v kj
 
 0 
..
 
.
 
 
1
 
 
..
 

.

 
0
donde el 1 va en la posición k del vector de K componentes que va debajo de Ak v kj . En coeficiente en la

función objetivo de esta columna es, por otro lado, cTk v kj . Notar, entonces, que buscar columnas para entrar
a la base es lo mismo que buscar vértices que engendren columnas para entrar a la base.
También podemos notar que esta descomposición es especialmente apropiada para usar “Multiple Pricing”.
En efecto, podemos tomar todas las columnas que resulten con costo reducido negativo mı́nimo de cada
bloque y agregarlas todas al problema maestro.
Es posible dar una interpretación económica interesante a la forma en que la Descomposición de Dantzig-Wolfe
aborda el problema. En efecto, si miramos nuevamente el problema satélite:
T
ηk = mı́n ck − ATk π u
s.a. Dk u = dk
u≥0
notamos que es “casi” lo mismo que haber resuelto en forma independiente cada problema de cada bloque,
sólo que la función objetivo es diferente: si cada bloque actuara en forma independiente, sin tomar en cuenta
las restricciones comunes, la función objetivo a considerar serı́a simplemente cTk u. Si embargo, la que se está
T
usando en cada iteración de la descomposición es ck − ATk π u. El término adicional, que involucra las
variables duales, está entregando información del “costo” que el problema del bloque debe compensar para
el problema completo, si se toman en cuenta las restricciones comunes.
Cápsula de video 6.2.1: Descomposición de Dantzig-Wolfe
Profesor Jorge Vera explica en clases la Descomposición de Dantzig-Wolfe

https: // youtu. be/ t94XbRBvoxs
6.2.1. Ejemplo
En este problema consideramos una variante del problema de flujo multiproducto que fue presentado antes,
al motivar la descomposición de Dantzig-Wolfe. La variación es que existen dos alternativas tecnológicas
diferentes para el transporte (por ejemplo, camiones normales o camiones eléctricos autónomos) y hay que
decidir el número de unidades de cada una de esas tecnologı́as a usar.
Como en el problema original, tenemos una red dirigida (N, A) para representar el problema. Hay K pares de
nodos que representan distintos orı́genes-destinos y sea ok = (rk , sk ) el par origen-destino k, rk ∈ N, sk ∈ N .
Para cada par k hay una demanda de flujo, dk que requiere ser transportada de rk a sk . Un vehı́culo de la
tecnologı́a de transporte t, t = 1, 2, tiene una capacidad igual a Ct . Por otro lado, cada arco (i, j) puede
aceptar un máximo de Uijt unidades de la tecnologı́a t, pero no pueden mezclarse distintas tecnologı́as de
transporte en un mismo arco. Para cada arco (i, j) hay un costo unitario ckijt para el flujo correspondiente
al par k con la tecnologı́a t. Tenemos, también, un costo fijt por cada unidad de la tecnologı́a t que se use
en el arco (i, j).
Para el modelo se usa una variable xkijt , correspondiente al flujo en (i, j) asociado al par k y con la tecnologı́a
t, una variable yijt correspondiente al número de unidades de la tecnologı́a t asignadas al arco (i, j), y una
variable auxiliar zijt que vale 1 si la tecnologı́a t es usada en el arco (i, j). El modelo es el siguiente:
2

mı́n fijt yijt +
P P P k k
cijt xijt
t=1 (i,j)∈A k∈K
!
2
k
xpit = bki , i ∈ N, k = 1, . . . , K
k
P P P
s.a. xijt −
t=1 j:(i,j)∈A p:(p,i)∈A
K
xkijt ≤ Ct yijt , ∀(i, j) ∈ A, t = 1, 2
P
k=1
yijt ≤ Uijt zijt , ∀(i, j) ∈ A, t = 1, 2
zij1 + zij2 ≤ 1, ∀(i, j) ∈ A
xkijt ≥ 0, yijt ∈ Z, zijt ∈ {0, 1}, ∀(i, j) ∈ A, k = 1, . . . , K, t = 1, 2
donde
dk , i = rk


bki = −dk , i = sk
0 si no

En primer lugar, dado que el problema es de Programación Entera Mixta, vamos a considerar la relajación
lineal para aplicar la descomposición. Entonces, el problema a considerar es:
2

mı́n fijt yijt +
P P P k k
cijt xijt
t=1 (i,j)∈A k∈K
!
2
k
xpit = bki , i ∈ N, k = 1, . . . , K
k
P P P
s.a. xijt −
t=1 j:(i,j)∈A p:(p,i)∈A
K
xkijt ≤ Ct yijt , ∀(i, j) ∈ A, t = 1, 2
P
k=1
yijt ≤ Uijt zijt , ∀(i, j) ∈ A, t = 1, 2
zij1 + zij2 ≤ 1, ∀(i, j) ∈ A
xkijt ≥ 0, yijt ≥ 0, 0 ≤ zijt ≤ 1, ∀(i, j) ∈ A, k = 1, . . . , K, t = 1, 2
Podemos ver que las restricciones

K
X
xkijt ≤ Ct yijt
k=1
“complican” la estructura. De hecho, si no existieran, permitirı́an que el problema se separara en K problemas

por bloques y, además, otro problema independiente para las variables z e y. Vamos a escribir el problema
en forma reordenada:
2 2
mı́n + ckijt xkijt
P P P P P
fijt yijt
t=1 (i,j)∈A k∈K t=1 (i,j)∈A
K
xkijt ≤ Ct yijt ∀(i, j) ∈ A, t = 1, 2
P
s.a.
k=1
yijt ≤ Uijt zijt ∀(i, j) ∈ A, t = 1, 2
zij1 + zij2 ≤ 1 ! ∀(i, j) ∈ A
2
xkijt − xkpit = bki i ∈ N, k = 1, . . . , K
P P P
t=1 j:(i,j)∈A p:(p,i)∈A
yijt ≥ 0, 0 ≤ zijt ≤ 1 xkijt ≥0 ∀(i, j) ∈ A, k = 1, . . . , K, t = 1, 2
Y ahora hacemos más explı́cita la suma en K, descartando las especificaciones de los rangos de los ı́ndices,
por razones de espacio:
2 2 2
mı́n + c1ijt x1ijt + ···+ cK K
P P P P P P
fijt yijt ijt xijt
t=1 (i,j)∈A t=1 (i,j)∈A t=1 (i,j)∈A
s.a.
−Ct yijt + x1ijt + ···+ xK
ijt ≤0
yijt − Uijt zijt ≤0
zij1 + zij2 ! ≤1
2
xkijt xkpit = bki
P P P
−
t=1 j:(i,j)∈A p:(p,i)∈A
..
. !
2
xkijt xkpit = bki
P P P
−
t=1 j:(i,j)∈A p:(p,i)∈A
yijt ≥ 0, 0 ≤ zijt ≤ 1 xkijt ≥ 0
Acá se puede ver claramente la estructura de bloques, la que destacamos en el siguiente diagrama:
Ahora vamos a desarrollar la descomposición. Primero notemos que es posible aquı́ hacer una decisión
respecto a cómo considerar el primer bloque, el de las variables y, z. Se puede dejar junto con las restricciones
comunes y eso dará origen a un problema maestro que tendrá como variables a x, z, además de las variables
λ asociadas a los vértices de los poliedros de los bloques de las restricciones de flujo. Alternativamente, se
puede considerar también como otro bloque. Tomaremos la primera alternativa.
Denotemos por Pk los poliedros de las restricciones de flujo de los bloques. Sólo para efectos de tener notación
más abreviada, vamos a asumir que esos poliedros son acotados y, por lo tanto, sólo hay vértices y no rayos.
Es importante destacar que es perfectamente posuble que el problema de los bloques pudiera ser no acotado.
Esto es debido a que se trata de un problema de redes (flujo a costo mı́nimo) y podrı́an existir ciclos dentro
de la red subyacente. Esos ciclos dan lugar a la posibilidad de que el problema de un bloque aislado sea no
acotado, según los costos que se formen con la retroalimentación del maestro.
Sean v kl , l = 1, . . . , rk los correspondientes vértices. Las componentes de los vértices en sı́ están asociadas a
los mismos subı́ndices de las variables originales, ası́ que tenemos que
rk
X rk
X
x= λlk v l , λlk = 1
l=1 l=1
y en forma más explı́cita:

rk
X rk
X
xkijt = kl
λlk vijt , λlk = 1
l=1 l=1
Con esta escritura el problema maestro es:

2 2 r1 2 rK
mı́n + c1ijt 1l
+ ···+ cK Kl
P P P P P P P P
fijt yijt λl1 vijt ijt λlK vijt
t=1 (i,j)∈A t=1 (i,j)∈A l=1 t=1 (i,j)∈A l=1
s.a.
r1 r1
−Ct yijt + 1l
+ ···+ 1l
≤0
P P
λl1 vijt λl1 vijt
l=1 l=1
yijt − Uijt zijt ≤0
zij1 + zij2 ≤1
rk
=1
P
λl1
l=1
..
.
rK
=1
P
λlK
l=1
yijt ≥ 0, 0 ≤ zijt ≤ 1 λlk ≥ 0
El problema satélite se obtiene según lo indica el desarrollo general, a partir del problema de los bloques.
Par esto hay que usar las variables duales del maestro, las que denotamos π, s, w, t1 , . . . , tK , en el orden de
las restricciones del maestro. Especı́ficamente, π son las variables duales de las restricciones
r1
X r1
X
−Ct yijt + 1l
λl1 vijt + ··· + 1l
λl1 vijt ≤0
l=1 l=1
y los t1 , . . . , tK son las variables duales de las restricciones

rk
X
λlk = 1
l=1
para cada bloque. El problema satélite del bloque k es, etonces:

2
mı́n (ckijt − πijt )xkijt
P P
t=1 (i,j)∈A
!
2
xkijt − xkpit = bki , i ∈ N, k = 1, . . . , K
P P P
s.a.
t=1 j:(i,j)∈A p:(p,i)∈A
xkijt ≥ 0, ∀(i, j) ∈ A, k = 1, . . . , K, t = 1, 2
Notar que aquı́ los coeficientes de la columna a considerar del problema maestro tienen coeficientes = 1, por
la estructura, ası́ que basta seguir el orden de los ı́ndices (i, j, t).
6.3. Identificando Estructuras Complicantes

Uno de los temas centrales en los enfoques de descomposición es la identificación de estructuras complicantes.
En el caso del problema de Flujo Multiproducto de la sección anterior, con el que motivamos la Descomposición
de Dantzig-Wolfe, las restricciones de capacidad en los arcos son “complicantes”: impiden que el problema sea
más fácil. En efecto, si no existieran, podrı́amos resolver cada problema de flujo, para cada par origen-destino,
por separado. Lo mismo ocurrı́a en el ejemplo detallado de la sección anterior. Pero hay otras formas en que
pueden presentarse estructuras complicantes y ese es el tema de esta sección, que nos llevará a otro método
de descomposición, también muy importante en Optimización de gran tamaño.
Tomemos otro ejemplo, para ilustrar esto. Consideremos una empresa del sector forestal la que posee n
bosques (rodales, en la jerga del sector) que pueden ser cosechadosa lo largo de T periodos (meses, por
ejemplo). Llamemos Bi la cantidad de madera disponible en el bosque i = 1, . . . , n. Vamos a suponer que
existen m puntos de destino con demanda djt en el periodo t, para el punto de demanda j y que hay costos
variables, pero también hay costos fijos cada vez que se cosecha. Denotemos por αit el costo unitario de
cosecha en el rodal i en el periodo t y por βit el costo fijo de cosechar el rodal i en el periodo t. También
llamaremos cij al costo unitario de transporte entre el rodal i y el destino j. Para construir un modelo
definiremos las siguientes variables:
Francisco Garcı́a y Jorge Vera 6.3. Identificando Estructuras Complicantes 129
xit : cantidad de madera cosechada en el rodal i en el perı́odo t.
zit : variable binaria que indica si un rodal es cosechado o no.
yijt cantidad de madera enviada desde el rodal i al destino j en el perı́odo t.
El siguiente modelo de optimización busca la forma de cosechar los bosques de modo de cumplir con la
demanda y hacerlo al menor costo combinado de cosecha y transporte:
 ! 
T  X
X n n X
X m 
mı́n αit xit + βit zit + cij yijt
 
t=1 i=1 i=1 j=1
m
X
s.a. xit = yijt ∀i; ∀t (1)
j=1
n
X
yijt ≥ djt ∀j; ∀t (2)
i=1
t−1
X
xit ≤ Bi − xik ∀i; ∀t ≥ 2 (3)
k=1
xi1 ≤ Bi ∀i (4)
xit ≤ M zit ∀i, ∀t (5)
xit ≥ 0, yijt ≥ 0, zit ∈ {0, 1} ∀i; ∀t; ∀j (6)
Queremos analizar la estructura del problema. Esto es, de qué forma se relacionan entre sı́ los elementos y
cómo se distribuyen. Esto es muy importante para establecer el método de resolución correcto ya que, como
ya hemos visto, estos hacen uso de esa estructura especial.
En esto, podemos notar que todas las restricciones, con la excepción de las (3) se pueden separar en el
ı́ndice de tiempo, t (tienen un ∀t), mientras que la (3) suma sobre el ı́ndice de tiempo. De esta forma, se
puede apreciar que (3) es una restricción “complicante”: impide que el problema se separe en problemas más
pequeños para cada periodo de tiempo. Una forma de visualizar mejor esto es dejar (3) arriba, todas las que
sean separables del tiempo abajo (que son la (1), (2), (5) y (6)) y las variables al lado izquierdo:
 ! 
T  X
X n n X
X m 
 
t=1 i=1 i=1 j=1
t−1
X
s.a. xit + xik ≤ Bi ∀i; ∀t ≥ 2 (3)
k=1
xi1 ≤ Bi ∀i (4)
m
X
xit − yijt = 0 ∀i; ∀t (1)
j=1
n
X
yijt ≥ djt ∀j; ∀t (2)
i=1
xit − M zit ≤ 0 ∀i, ∀t (5)
xit ≥ 0, yijt ≥ 0, zit ∈ {0, 1} ∀i; ∀t; ∀j (6)
Esto permite ver “restricciones complicantes” con mayor facilidad. De este modo, la estructura que se forma
es tal que solo (3) es complicante, ya que liga las variables entre sı́ por sumar sobre t, (4) solo va asociada al
tiempo t = 1 y para las restricciones (1), (2), (5) y (6) se arman bloques, uno para cada periodo de tiempo:
n
! n X
m n
! n X
m
X X X X
mı́n αi1 xi1 + βi1 zi1 + cij yij1 +...+ αiT xiT + βiT ziT + cij yijT
i=1 i=1 j=1 i=1 i=1 j=1
t−1
X
s.a. xit + xik ≤ Bi , ∀i, t ≥ 2
k=1
xi1 ≤ Bi , ∀i
m
X
xi1 − yij1 = 0, ∀i
j=1
n
X
yij1 ≥ dj1 , ∀j
i=1
xi1 − M zi1 ≤ 0, ∀i
.. ..
. .
m
X
xiT − yijT = 0, ∀i
j=1
n
X
yijT ≥ djt , ∀j
i=1
xiT − M ziT ≤ 0, ∀i
xit ≥ 0, yijt ≥ 0, zit ∈ {0, 1} ∀i, j, t
Esta forma de plantear el problema permite “ver”, entonces, una estructura apropiada de ser abordada
mediante descomposición de Dantzig - Wolfe.
Sin embargo, también existen otra forma de estructurar el problema en bloques, observando la naturaleza de
las variables y cómo se relacionan a las restricciones. Hagamos lo siguiente: formemos 2 bloques de variables:
las x con las z (que corresponden a la cosecha) se dejan en el primer bloque y las y (que corresponde
al transporte) en el segundo. Esto se hace para separar el problema en las dos partes presentes en la
estructura general: la cosecha primero y después el transporte. Sin embargo, notemos que no se puede
separar completamente, pues existe una restricción que relaciona las variables de cosecha y de transporte.
Esta serı́a la forma de reordenar el modelo:
( ! 
T
X n
X n X
X m 

t=1 i=1 i=1 j=1
t−1
X
s.a. xit − xik ≤ Bi , ∀i; ∀t ≥ 2 (3)
k=1
xi1 ≤ Bi , ∀i (4)
xit − M zit = 0, ∀i; ∀t (1)
m
X
xit − yijt = 0, ∀i; ∀t (2)
j=1
Xn
yijt ≥ djt , ∀j; ∀t (5)
i=1
xit ≥ 0, zit ∈ 0, 1, yijt ≥ 0, ∀i; ∀t; ∀j
Si se fijan las variables x y z en valores especı́ficos, estas quedan como constantes para el segundo bloque.
Con eso, las variables y forman su propio problema de optimización. Esto en el fondo quiere decir que las
variables son casi separables, pero están ligadas por uno de los tres bloques en que se puede separar estas
restricciones.
Francisco Garcı́a y Jorge Vera 6.4. Descomposición de Benders 131
Acá, las variables x y z “complican”, implican resolver un problema de programación entera, mientras que
en en el problema de las variables y, se tiene un problema más simple de programación lineal.
También es interesante pensar que las decisiones representadas por las variables y, el transporte, están
supeditadas a las decisiones de (x, z), que corresponden a la cosecha. Esto es muy razonable desde un punto
de vista práctico ya que primero se cosecha y después se transporta, pero para ser eficientes, ambas decisiones
deben estar coordinadas. Esto es lo que motiva el tema de la siguiente sección.
Cápsula de video 6.3.1: Estructuras complicantes
Profesor Jorge Vera explica en clases la importancia de identificar estructuras complicantes.

https: // youtu. be/ SuhdnqyuytY
6.4. Descomposición de Benders

Este es un enfoque de descomposición que fue propuesto por Benders en 1962, pero hasta el dı́a de hoy es
muy usado en algunos problemas gigantes en diversas áreas, como la planificación de sistemas eléctricos y
otros.
El método se aplica a un problema con la siguiente estructura (Problema Original):
mı́n cT x + dT y
s.a. Ax =b
Ex + Dy =e
x∈C y≥0
Donde A ∈ Rm×n , E ∈ Rp×n , D ∈ Rp×r , b ∈ Rm y e ∈ Rp . Las variables y son continuas y C es algún

conjunto de restricciones adicionales (integralidad, por ejemplo, y podemos asumir eso como modelo de
ejemplo) para las variables x. El tema es que puede ser conveniente separar la parte entera de la continua.
Para hacer esto, hay que pensar en la idea de separar en dos etapas: primero se toman decisiones con los
x fijos y con eso los y “viven” en un problema de programación lineal (y están subordinadas a las x). El
problema anterior se puede reescribir como:
mı́n cT x + dT y
s.a. Ax =b
+ Dy = e − Ex
x∈C y≥0
Pensemos en que la optimización en y está subordinada a la optimización en x, por lo que minimizar

(cT x + dT y) equivale a minimizar cT x y dT y por separado, pero donde y necesita un determinado valor de
x. Esto es un problema de minimización que está dentro de otro:
mı́n c x + mı́n dT y : Dy = e − Ex, y ≥ 0

T
Ax=b,x∈C
Para el problema de adentro, se tiene por dualidad fuerte que:
mı́n dT y : Dy = e − Ex, y ≥ 0 = máx (e − Ex)T u : DT u ≤ d

Luego, el problema original también se puede plantear como:
mı́n cT x + máx (e − Ex)T u : DT u ≤ d

Ax=b,x∈C
Sea P el poliedro de la restricción del dual. Vamos a suponer, de momento, que este poliedro es acotado y,
por lo tanto, puede ser generado por la envoltura convexa de sus puntos extremos, que llamaremos v 1 . . . v q .
Es decir, PD = u : DT u ≤ d = conv v 1 . . . v q . Entonces, resolver un problema de programación lineal

sobre PD es lo mismo que buscar el vértice con mayor función objetivo. Por lo tanto, el problema puede
escribirse como:
mı́n cT x + máx (e − Ex)T v i : i = 1, . . . , q

Ax=b,x∈C
Este es un problema “min-max”, minimizar el máximo de un número finito de expresiones, que se puede
tratar utilizando una variable auxiliar γ que sea cota superior de todos los valores objetivos del problema
de maximización (y por lo tanto también es cota superior del mayor), de modo que baste con minimizar γ.
Con esto, se puede expresar el problema original de manera equivalente a:
mı́n cT x + γ
s.a. Ax = b (1)
(e − Ex)T v i ≤ γ ∀i = 1, . . . , q (2)
x ∈ C, γ ∈ R
En el conjunto de restricciones (2) hay una restricción por cada vértice v i . Además, podemos aún reescribirlo
de otra manera para dejar claro que las variables son el x y el γ, mientras que los vértices v i son parámetros:
z ∗ = mı́n cT x + γ
s.a. Ax = b
T
− v i Ex − γ ≤ −eT v i , ∀i = 1 . . . q
x ∈ C, γ ∈ R
En este problema ya no aparece y, pues con todas las transformaciones ahora está representada por los
vértices v i . Ahora solo están las variables x (y γ). Este problema tiene una gran cantidad de restricciones
o filas (asociadas a todos los puntos extremos del poliedro). Vamos a resolverlo usando un enfoque que es
análogo al de generación de columnas, pero aplicado a las “filas”, es decir las restricciones. Esto es un método
de “generación de restricciones” o de “planos cortantes”. La idea es partir con unas pocas restricciones e ir
agregando otras a medida que se necesiten.
Supongamos que inicialmente conocemos los primeros k vértices extremos v 1 , . . . , v k , o sea, k restricciones.

Por lo tanto, resolvemos el Problema Maestro:
z k = mı́n cT x + γ
s.a. Ax = b (1)
Pk )
(e − Ex)T v i ≤ γ ∀i = 1, . . . , k (2)
x ∈ C, γ ∈ R
Sea xk , γ k solución óptima del problema Pk ), el que posee menor o igual cantidad de restricciones que el

problema original, lo que implica que z k ≤ z ∗ (es una relajación). Le geometrı́a de lo que se está haciendo
acá se muestra en la siguiente imagen:
donde el poliedro original es el que está en azul, pero solo las restricciones rojas representan al poliedro
original, pues se parte con un conjunto menor de restricciones. Con estas primeras restricciones se encuentra
que el “pseudo óptimo” (llamémoslo incumbente) está en x1 . La idea es llamar a un generador de restricciones
que genere una restricción que sea de utilidad (un plano cortante), es decir, que genere una restricción tal que
se encuentre un nuevo incumbente x2 más cerca del poliedro original. El gran desafı́o es cómo implementamos
algo que sea capaz de generar estas restricciones.
Lo que necesitamos es encontrar (generar) una restricción ((e − Ex)T v i ≤ γ), asociada a un v i que no
sea de los que ya han sido encontrados. Esta nueva restricción debe dejar afuera al actual incumbente (lo
“corta”), por lo que si el incumbente es (xk ,k ), entonces el nuevo vértice que se busca v i debe cumplir con
que: (e − Exk )T v i > γ k . Todo esto motiva al siguiente Problema Satélite:
T
wk = máx e − Exk u
s.a. D u ≤ d
T
Este problema de Programación Lineal encontrará una solución en un vértice del poliedro PD . Si wk > γ k ,
entonces una solución óptima v k+1 nos permite generar una nueva restricción que es agregada al problema
maestro, la cual es:
(e − Ex)T v k+1 ≤ γ
Si wk ≤ γ k , significa que xk , γ k satisface todas las restricciones (sin necesidad de haberlas escrito), entonces

nos encontramos en el óptimo final.

Notemos que el maestro es una relajación del problema original. Esto implica que z 1 ≤ z 2 ≤ . . . ≤ z k ≤ z ∗ ,
es decir, el maestro entrega siempre una cota inferior. Por otro lado, wk , el óptimo del satélite, es igual al
óptimo del problema “interior”:
wk = mı́n dT y : Dy = e − Exk , y ≥ 0

Sea y k solución óptima de este problema. Entonces, xk , y k es factible (aunque no necesariamente óptima)

para el problema original, lo que significa que cT xk + wk es una cota superior a z ∗ . De este modo, se tiene
una cota superior y una inferior al valor óptimo:
z k ≤ z ∗ ≤ w∗ + cT xk
|{z} | {z }
maestro satélite
Esto puede ser muy útil para saber a cuánto se está del óptimo, si la diferencia entre z k y wk + cT xk es
suficientemente pequeña, o aceptable, podrı́amos detener las iteraciones y tendremos, al menos, una solución
factible (xk , y k ).
Veamos ahora qué hacer si se considera la posibilidad de que PD = u : DT u ≤ d sea no acotado. En este

caso, van a existir los rayos del cono de recesión de PD , llamémoslos h1 , h2 , . . . , hr . Recordemos el problema:
mı́n cT x + máx (e − Ex)T u : DT u ≤ d

Ax=b,x∈C
Entonces, para los x posibles solución óptima, el problema interior debe tener un valor finito, de otro modo
el valor para ese x serı́a +∞. Por esa razón, queremos imponer que los x a considerar generen el el problema
interior un problema acotado. Esto se logra pidiendo que (e − Ex)T hi ≤ 0, para todos los rayos extremos
del cono de recesión.
Entonces, el problema maestro completo es:
z k = mı́n cT x + γ
s.a. Ax = b
Pk ) (e − Ex)T v i ≤ γ ∀i = 1, . . . , q
(e − Ex)T hj ≤ 0, ∀j = 1, . . . , r
x ∈ C, γ ∈ R
Entonces, al resolver el satélite:
T
s.a. D u ≤ d
T
este puede alcanzar óptimo en un vértice v k+1 , como explicábamos antes, y en entonces se agrega la restricción
(e − Ex)T v k+1 ≤ γ al maestro (“corte de optimalidad”). Pero puede resultar que sea no acotado, y en ese
caso se detecta un rayo hk+1 tal que (e − Ex)T hk+1 > 0 y se agrega la restricción (e − Ex)T hk+1 ≤ 0 (“corte
de factibilidad”).
El algoritmo completo es el siguiente:
Algoritmo de Descomposición de Benders
Data: Sea k = 0.
Resolver el “Problema Maestro”:
mı́n cT x + γ
s.a. Ax = b
(e − Ex)T v i ≤ γ ∀i = 1, . . . , q
(e − Ex)T hj ≤ 0, ∀j = 1, . . . , r
x ∈ C, γ ∈ R
obteniendo un vector solución xk y se entrega esta solución al “Problema Satélite”.
Resolver el “Problema Satélite” con el vector xk .

T
s.a. D u ≤ d
T
Existen tres casos posibles:

El problema satélite es no acotado con rayo de escape hk , que se asocia con u. Se agrega un
corte de factibilidad al problema maestro del tipo:
T
e − Exk hk ≤ 0
El problema satélite es acotado y se obtiene el valor óptimo wk . Sea v k+1 el vector dual. Si
wk > γ k entonces con la solución agregamos un corte de optimalidad al problema maestro del
tipo:
T
e − Exk v k+1 ≤ γ
El problema satélite es acotado y se obtiene el valor óptimo wk . Si w ≤ γ , entonces hemos
k k
llegado al óptimo y termina el algoritmo con solución óptima xk , y k .
Actualizar el “Problema Maestro”, k = k + 1

end
La siguiente figura ilustra el diálogo entre el Problema Maestro y el problema Satélite.
xk
mı́n cT x + γ
s.a. Ax = b T
(e − Ex)T v i ≤ γ ∀i = 1, . . . , q
(e − Ex)T hj ≤ 0, ∀j = 1, . . . , r s.a. D u ≤ d
T
x ∈ C, γ ∈ R
(γ) (Satélite)
v k+1 y hk
Cápsula de video 6.4.1: Descomposición de Benders
Profesor Jorge Vera explica en clases el algoritmo de descomposición de Benders

https: // youtu. be/ gXzp1CZPNKE
6.4.1. Ejemplos
Programación de operaciones en quirófanos
Un problema muy importante en el ámbito de la gestión hospitalaria es la programación eficiente de las
salas de operaciones. Esto es lo que abordamos, en forma simplificada, en este ejemplo. Queremos resolver
la programación de las operaciones durante un perı́odo dado, para lo cual debe determinar qué quirófanos
serán usados y qué operaciones se realizarán en qué quirófano. Tenemos N quirófanos y cada quirófano está
disponible T horas, en tiempo normal, en el perı́odo. Se deben organizar un total de P operaciones y la
duración de la operación i es de wi horas. De ser eventualmente necesario, un quirófano puede funcionar
tiempo extra, pero existen restricciones a esto: el tiempo extra total que se use sobre todo el horizonte de
planificación no puede superar Q horas. Existe un costo fijo Kj por usar el quirófano j en el perı́odo, un
costo eij por realizar la operación i en el quirófano j y un costo adicional cj por hora de sobretiempo que se
asigne al quirófano j. La programación debe ser tal que las operaciones se realicen en los quirófanos, pero
de no ser posible (por falta de tiempo), algunas operaciones deberán ser “derivadas” a otra red hospitalaria.
Esto no es deseable, ası́ que se asigna una penalidad por esta ocurrencia, β, ya que deteriora la calidad
de atención a los pacientes. El siguiente modelo de optimización determina qué quirófanos usar, cuánto
sobretiempo asignar de modo de cumplir con la mayor cantidad posible de cirugı́as y minimizar los costos,
que consideran los directos y la penalidad por derivación (note que aquı́ hay un balance entre objetivos de
costos y uno de calidad de atención, que no es necesariamente un costo monetario). La variables yj indica si
un quirófano se usa o no, la variables xij indica si la operación i se hace en el quirófano j, tj es la cantidad
de sobretiempo asignado al quirófano j y la variable zi indica si una operación es derivada o no:
N P P P
N
mı́n {Kj yj + cj tj } + β zi +
P P P
eij xij
j=1 i=1 i=1 j=1
N
xij + zi = 1, i = 1, . . . , P (1)
P
s.a.
j=1
P
j = 1, . . . , N (2)
P
xij ≤ P yj
i=1
P
wi xij ≤ T + tj , j = 1, . . . , N (3)
P
i=1
N
(4)
P
tj ≤ Q
j=1
xij , yj , zi ∈ {0, 1}, tj ≥ 0, i = 1, . . . , P ; j = 1, . . . , N. (5)
En este modelo, la función objetivo suma todos los costos relevantes, las restricciones (1) especifican que
todas las operaciones deben ser realizadas o derivadas, (2) establece que si un quirófano no es habilitado, no
se le pueden asignar operaciones, (3) calcula el tiempo usado y establece el eventual sobretiempo, (4) define
el lı́mite total al sobretiempo y, finalmente, (5) define la naturaleza de las variables.
Primero, visualicemos una estructura adecuada para utilizar la descomposición de Benders. Reescribiremos
el problema de modo que tenga la estructura básica requerida (obviamos los rangos para simplificar la
escritura):
N
P P N P N
mı́n + + +
P P P P
eij xij {Kj yj } β zi {cj tj }
i=1 j=1 j=1 i=1 j=1
s.a.
N
+ = 1
P
xij zi ∀i
j=1
P
0
P
xij − P yj ≤ ∀j
i=1
P
P
wi xij − tj ≤ T ∀j
i=1
N
P
tj ≤ Q
j=1
xij ∈ {0, 1} yj ∈ {0, 1} zi ∈ {0, 1} tj ≥ 0
Primero se identifica el problema interior de la Descomposición de Benders:
N
mı́n
P
{cj tj }
j=1
s.a.
P
(πj )
P
tj ≥ wi xij − T ∀j
i=1
N
(u)
P
tj ≤ Q
j=1
tj ≥ 0
Luego, se determina el problema dual del problema interior. Para esto se utilizan variables duales πj para
la primera restricción y u para la segundav(obviamos los rangos para simplificar la escritura):
N P
máx πj ( wi xij − T ) + uQ
P P
j=1 i=1
s.a.
πj + u ≤ cj ∀j
πj ≥ 0
u ≤ 0
Luego el problema maestro queda:

P P
N N P
mı́n eij xij + {Kj yj } + β zi + γ
P P P
i=1 j=1 j=1 i=1
s.a.
N
xij + zi = 1
P
∀i
j=1
P
xij − P yj ≤ 0
P
∀j
i=1
N P
πj ( wi xij − T ) + uQ ≤ γ
P P
j=1 i=1
N P
πj0 ( wi xij − T ) + u0 Q ≤ 0
P P
j=1 i=1
xij , yj , zi ∈ {0, 1} tj ≥ 0 ∀i, j
Donde πj y u son cortes de optimalidad dados por el problema satélite y πj0 y u0 son cortes de factibilidad
dados por el satélite. Finalmente, el problema satélite, es el mismo dual del problema interior, pero para la
solución del problema maestro. Denotemos por (x̄, ȳ, z̄, γ̄) la solución óptima del problema maestro en esta
etapa, entonces el satélite es:
N P
máx πj ( wi x¯ij − T ) + uQ
P P
j=1 i=1
s.a.
πj + u ≤ cj ∀j
πj ≥ 0
u ≤ 0
Flujo multiproducto
Consideramos en este ejemplo el mismo problema, generalización del problema de flujo multiproducto, de
la sección 5.2.1.
Para visualizar una estructura adecuada para Benders, vamos a tomar la reescritura inicial del problema:
2 2
mı́n + ckijt xkijt
P P P P P
fijt yijt
t=1 (i,j)∈A k∈K t=1 (i,j)∈A
s.a. yijt − Uijt zijt ≤0 ∀(i, j), t
zij1 + zij2 ≤1 ∀(i, j)
K
−Ct yijt + xkijt ≤0
P
∀(i, j), t
k=1 !
2
xkijt − xkpit = bki
P P P
∀i, k
t=1 j:(i,j)∈A p:(p,i)∈A
yijt ∈ N, zijt ∈ {0, 1} xkijt ≥0 ∀(i, j), k, t
Acá se ve claramente que las variables (z, y) son complicantes, además de ser enteras. Es útil visualizar los
bloques de la siguiente forma:
Ahora desarrollamos los detalles de la Descomposición de Benders. El problema interior es:

2
mı́n ckijt xkijt
P P P
k∈K t=1 (i,j)∈A
K
xkijt
P
s.a. ≤ Ct yijt ∀(i, j), t
k=1 !
2
xkijt − xkpit = bki
P P P
∀i, k
t=1 j:(i,j)∈A p:(p,i)∈A
xkijt ≥0 ∀(i, j), k, t
Para determinar su dual usemos variables duales πijt para las primeras restricciones y variables duales tik
para el conjunto de restricciones de los bloques de pares origen-destino. El dual es (obviamos los rangos para
simplificar ls escritura):
w = máx (−Ct yijt )πijt +

P P
bik tik
i,j,t i,k
tik − tjk − πijt ≤ ckijt , ∀i, j, t, k
πijt ≥ 0, ∀i, j, t
El problema maestro es:
2
mı́n fijt yijt + γ
P P
t=1 (i,j)∈A
s.a. yijt − Uijt zijt ≤ 0, ∀(i, j), t
zPij1 + zij2 ≤ 1, ∀(i,P j)
(−Ct yijt )πijt
l
+ bik tlik ≤ γ, l = 1, . . . , L
i,j,t i,k
(−Ct yijt )hlijt + bik gikl
≤ 0, l = 1, . . . , M
P P
i,j,t i,k
yijt ∈ N, zijt ∈ {0, 1}
donde (πijt
l
, tlik ) son los vértices de la región factible del dual y (hlijt , gik
l
) son los rayos de esa misma región
factible. El problema satélite, es el mismo dual del problema interior, pero para la solución del problema
maestro. Denotemos por (ȳ, γ̄) la solución óptima de problema maestro en esta etapa, entonces el satélite
es:
w = máx (−Ct ȳijt )πijt +

P P
bik tik
i,j,t i,k
tik − tjk − πijt ≤ ckijt , ∀i, j, t, k
πijt ≥ 0, ∀i, j, t
Entonces, si el problema alcanza su óptimo y w > γ̄, se ha generado un corte con puntos extremos. Si ese
problema satélite es no acotado, entonces el correspondiente rayo genera un corte de factibilidad.
6.5. Relación entre el método de Dantzig-Wolfe y Benders

Considere el problema estructurado que usamos para introducir la descomposición de Dantzig-Wolfe:
Francisco Garcı́a y Jorge Vera 6.5. Relación entre el método de Dantzig-Wolfe y Benders 139

s.a. A1 x 1 +···+ AK x K = b
D1 x1 = d1
.. .. .. ..
. . . .
DK xK = dK
x1 ≥ 0, ··· , xK ≥ 0
donde Ak ∈ Rm×nk , Dk ∈ Rpk ×nk , dk ∈ Rpk , ck ∈ Rnk , k = 1, . . . , K. El dual del problema es:
máx bT π +dT1 s1 +···+ dTK sK

s.a.
AT1 π +D1T s1 +···+ ··· ≤ c1
AT1 π +... +D2T s2 +... ≤ c2
.. .. .. .. ..
. . . . .
ATK π +... ··· +DK
T K
s ≤ cK
Se puede ver claramente que las variables π son complicantes. Notemos que no existen restricciones exclusivas
para estas variables, pero el esquema de Benders se puede aplicar igual, de hecho.
A continuación se muestra el esquema de Benders, básicamente el maestro y el satélite, primero usando los
sı́mbolos generales de los bloques. Notemos, en primer lugar, que el problema es:
máx cT π +dT s
s.a. Eπ +Ds ≤ e
que se lleva a dos etapas de la siguiente forma:
máx cT π + máx dT s : Ds ≤ e − Eπ

y que es lo mismo que:
máx cT π + mı́n (e − Eπ)T u : DT u = d, u ≥ 0

Esto lleva al siguiente maestro:
máx cT π + γ
s.a. γ ≤ (e − Eπ)T v i , i = 1, . . . , t
donde v i son vértices del poliedro definido por las restricciones DT u = d, u ≥ 0. Cuando se resuelve el
maestro en esta iteración de ı́ndice t, se obtiene una solución π t , la que es alimentada al satélite, el que es:
T
mı́n (e − Eπ t ) u
s.a. DT u = d
u≥0
Ahora es el momento de recordar qué es lo que realmente son E, e y D, según el diagrama de más arriba. El
u va por bloques de las matrices originales Dk , entre otras. Esto hace que el problema satélite anterior sea:
PK T
mı́n k=1 ck − ATk π t uk
s.a. DkT uk = dk , k = 1, . . . , K
uk > 0, k = 1, dots , K
y esto se descompone en K problemas independientes de la forma:
T
mı́n ck − ATk π t uk
s.a. DkT uk = dk
Estos satélites son exactamente el mismo problema satélite que aparecı́a en Dantzig-Wolfe. De hecho, es
también el mismo problema satélite que aparecı́a en la aplicación de Relajacjión lagrangeana al problema
original. Esto muestra cómo las distintas técnicas están relacionadas. De hecho, se dice a veces, que Bender
es “dual” a Dantzig-Wolfe o, alternativamente, a Generación de Columnas.
Capı́tulo 7
El Enfoque Dual para Problemas de

Gran Tamaño
Muchos problemas de gran tamaño son difı́ciles porque tienen restricciones complicantes. Como ya hemos
visto, una forma de manejar esto es mediante la Descomposición de Dantzig-Wolfe, si es que la estructura
puede ser descompuesta en bloques. Sin embargo, las estructuras de restricciones complicantes pueden ser
más generales y necesitamos técnicas que permitan abordarlas. En este capı́tulo estudiaremos cómo la
Dualidad Lagrangeana entrega las herramientas para abordar estos problemas. Para esto, introducimos
primero algunos elementos de la teorı́a general de Dualidad Lagrangeana para luego aplicarlos para abordar
problemas de gran tamaño.
7.1. Dualidad Lagrangeana

Vamos a introducir aquı́ las nociones generales de dualidad Lagrangeana que necesitamos. Este es un concepto
mucho más amplio de dualidad que el que se ha estudiado en Programación Lineal, pero mostraremos que
los resultados que ya conocemos se rescatan como casos particulares.
7.1.1. El Primal y el Dual

Consideremos el siguiente problema general de optimización:
mı́n f (x)
s.a. gi (x) ≤ bi , i = 1, ..., m
x∈C
Con x ∈ Rn , f : Rn → R, gi : Rn → R, i = 1, . . . , m, con C cerrado y no vacı́o. Luego, el Lagrangeano

L : R n × Rm
+ → R se define como :
m
X
L(x, λ) = f (x) + λi (gi (x) − bi )
i=1
Donde x ∈ Rn y λ ∈ Rm + son los multiplicadores de Lagrange. Notar que el Lagrangeano combina la función
objetivo con las restricciones.
Ahora se define el Problema Primal como:
mı́n máx L(x, λ)

x∈C λ≥0
Este es un problema en dos niveles. La maximización sobre las variables λ, es el problema que está dentro
del de minimización que controla un x que pertenece al conjunto C. Podemos pensar que para el problema
interior, el x está fijo.
141
142 Capı́tulo 7. El Enfoque Dual para Problemas de Gran Tamaño
Por otro lado, se define el Problema Dual como:
máx mı́n L(x, λ)

λ≥0 x∈C
En este, la minimización está dentro del problema de maximización y “ve” un λ fijo. Si alguna restricción i
es de igualdad, entonces su respectivo λi es irrestricto. Notemos que este problema “invierte” el mı́n con el
máx con respecto al Primal.
Se define también la Función Dual como:
θ(λ) = mı́n L(x, λ), λ≥0

x∈C
Luego, el problema dual es maximizar la función dual:
máx θ(λ)
λ≥0
Estos dos problemas que hemos definido se ven “extraños” y no parecen estar relacionados con lo que se
entiende por primal y dual en Programación Lineal. Sin embargo, partamos por hacer notar algo sutil: el
primal mı́nx∈C máxλ≥0 L(x, λ) coincide con el problema original. Para ver esto, se puede explicitar L(x, λ)
en el primal:
( ( m
))
X
mı́n máx f (x) + λi (gi (x) − bi )
x∈C λ≥0
i=1
Notar que como el problema de adentro funciona para un x fijo, y f (x) no depende de λ, entonces el primal
también puede escribirse como:
( (m ))
X
mı́n f (x) + máx λi (gi (x) − bi )
x∈C λ≥0
i=1
El problema interior de maximización opera con λ ≥ 0 como variable. Sucederá que si gi (x) − bi > 0 para
algún x y algún i, entonces óptimo para λ será tender a +∞, por lo que se vuelve no acotado, ya que la
máximización también se va a +∞, valor que claramente no nos interesa, pues a final de cuenta queremos
minimizar toda la expresión. Por este mismo hecho (gi (x)−bi > 0), es a su vez una violación de la restricción
del problema original. De este modo, para que el problema de minimización tenga sentido en el problema
primal (no tiene sentido minimizar {f (x) + ∞}) sobre x, debe cumplirse que gi (x) − bi ≤ 0. De este modo,
para que el problema de maximización que está dentro del primal no diverja, solo puede ser cero, que serı́a
el óptimo del problema de maximización para que la cuestión tenga sentido. Ası́, el problema primal es:
mı́n f (x)
es equivalente al
mı́n {f (x) + 0} −→ −→ s.a. gi (x) ≤ bi , ∀i
x∈C problema original
gi (x)≤bi ,∀i x∈C
Análogamente, se puede mostrar que, en el caso de Programación Lineal, el Problema Dual es igual al
dual ya conocido del problema original. Para esto considérese que en el problema original f (x) = cT x y
que gi (x) ≤ bi que eran las restricciones del problema, se escriben como αiT x ≤ bi y el conjunto C al que
pertenecen las x corresponde a x ≥ 0, por lo que el problema original queda de la siguiente forma (? Nota:
ver este caso nuevamente considerando que x ∈ Z+ 0 después de ver dualidad fuerte ?):
mı́n cT x
s.a. Ax ≤ b
x≥0
El Lagrangeano de este problema es:

Francisco Garcı́a y Jorge Vera 7.1. Dualidad Lagrangeana 143
m
X
L(x, λ) = cT x + λi bi − αiT x

i=1
Y el Problema Dual es máxλ≥0 θ(λ), con θ(λ), el problema de optimización sobre la variable x para un valor
de λ, tal que:
( m
)
X
θ(λ) = mı́n cT x + λi bi − αiT x

x≥0
i=1
( n m
! m
)
X X X
= mı́n xj cj − αij λi ) + λ i bi
x≥0
i=1 i=1 i=1
( n m
!)
X X
= b λ + mı́n
T
xj cj − αij λi )
x≥0
i=1 i=1
Pm
Del mismo modo que se hizo anteriormente, se debe observar que si cj < i=1 αij λi para un determinado
ı́ndice j, entonces el problema de minimización θ(λ) va a tener por solución en la componente j, xj , un valor
que tiende a +∞, cosa que el vaor objetivo tienda a −∞ y el problema de máxλ≥0 θ(λ) no tenga sentido (es
análogo al caso anterior donde se maximizaba y se iba a +∞). De este modo, el problema dual es tal que se
busca maximizar {bT λ + 0} sujeto a que θ(λ) no diverga, por lo que el problema dual es:
es equivalente al dual máx bT λ

máx bT λ + 0

−→ −→
AT λ≤c,λ≥0 del problema original s.a. AT λ ≤ c, λ ≥ 0
De este modo, el problema original equivale al problema primal y el dual del original equivale al problema
dual, por lo menos para Programación Lineal, por lo que hay consistencia.
Notemos también que si hemos llegado al óptimo en x∗ con variables duales λ∗ . Entonces:
m
X
z ∗ = f (x∗ ) = L (x∗ , λ∗ ) = f (x∗ ) + λ∗i (gi (x∗ ) − bi )
i=1
Luego, se debe tener que:
m
X
λ∗i (gi (x∗ ) − bi ) = 0
i=1
Estas son las holguras complementarias.

Cabe decir que detrás de todo este concepto de dualidad lagrangiana existe una interpretación económica
como un equilibrio “mı́n máx” sobre la equivalencia entre:
P ) mı́n máx L(x, λ) y D) máx mı́n L(x, λ)

x∈C λ≥0 λ≥0 x∈C
Si uno es un comprador y tiene poder de decisión sobre x y el vendedor tiene poder de decisión sobre las
variables λ, y la función lagrangeana representa el pago entre los dos, la estrategia óptima que puede adoptar
el comprador es minimizar sobre las variables x la función lagrangiana que el vendedor intentará maximizar
sobre λ. Esto es P ). Por otro lado, la estrategia que debe adoptar el vendedor es maximizar sobre su variable
de desición λ la función lagrangiana que el comprador está intentando minimizar sobre las variables x.
Esto es D). Bajo ciertas condiciones (lo que viene a continuación) estos dos problemas entregan el mismo
valor óptimo. Esto está muy relacionado con el tema de Teorı́a de Juegos, que es uno de los elementos
fundamentales sobre los que descansa la teorı́a de equilibrio económico.
7.1.2. Teorema débil y fuerte de dualidad

Para enunciar estos dos teoremas de dualidad, primero se precisa un concepto importante:
Condición de Slater: Esta condición se puede cumplir de cualquiera de las siguientes forma:
1. El problema es lineal puro
2. El problema es no lineal y la región factible tiene interior no vacı́o, es decir, ∃x̄ ∈ Rn : gi (x̄) < bi , ∀i =
1 . . . m.
Teorema débil de dualidad

El dual (que maximiza) acota por abajo al primal, y este a su vez, acota al dual por arriba:
w∗ = máx mı́n L(x, λ) ≤ mı́n máx L(x, λ) = z ∗

λ≥0 x∈C x∈C λ≥0
Sabemos, por supuesto, que esto se cumple con igualdad en el caso de Programación Lineal. Eso es lo que
dice el siguiente resultado:
Teorema fuerte de dualidad

Si el problema es convexo, o sea, f y gi son funciones convexa, C es un conjunto convexo, y además se
cumple la condición de Slater, entonces
w∗ = z ∗
Como decı́amos, Programación Lineal cumple dualidad fuerte. Pero, si el problema no es convexo, podrı́a
ocurrir que w∗ < z ∗ y en ese caso hay un “salto de dualidad” (dualty gap).
Un caso donde no se cumplen las condiciones de Slater es cuando las variables del problema son enteras ya
que la restricción de integralidad rompe con la convexidad que pudiera tener el problema. Ahora, si se vuelve
a revisar la construcción del dual del problema de Programación Lineal pero imponiendo que x ∈ Z+ 0 , puede
verse que en ningún momento del desarrollo esta restricción de integralidad es un problema para llegar a
exactamente a la misma conclusión que se llegó considerando que x ∈ R+ 0 . En otras palabras, el dual de un
problema de Programación Lineal Entera es el dual de la relajación lineal del problema, y el valor óptimo
de ese problema no es igual (necesariamente) al valor óptimo del problema original. Es por esto que, si bien
el dual del problema con variables enteras cumple con el teorema fuerte para el problema de programación
lineal (el relajado del entero), suele estar muy por abajo del óptimo del problema de programación entera,
entonces tı́picamente w∗ < z ∗ .
7.1.3. Múltiples duales

Consideremos el siguiente ejemplo de problema de optimización:
z ∗ = mı́n x + 3(y − 4)2

s.a. x2 + y 2 ≤ 4
x+y ≤3
x, y ∈ Z+0
Una observación importante es que tenemos un grado de libertad para definir “un” dual para este problema.
En efecto, qué restricciones serán elegidas para formar el lagrangiano y cuáles permanecen como definición del
conjunto C puede ser una decisión importante. Para este problema, mostramos a continuación dos posibles
definiciones de Lagrangianos y conjuntos C:
L1 (x,
λ1 , λ2 ) = x + 3(y − 4)2 + λ1 (x2 + y 2 ) + λ2 (x + y − 3) L2 (x,
λ) = x + 3(y − 4)2 + λ(x2 + y 2 )
y
C1 = x, y : x, y ∈ Z+ 0 C2 = x, y : x + y ≤ 3, x, y ∈ Z+ 0
Cada uno de estos dos Lagrangeanos da origen a dos duales diferentes que darán origen a valores duales,
w1 y w2 potencialmente diferentes. Si las restricciones de integralidad, x, y ∈ Z+ 0 no existieran, entonces el
problema original serı́a convexo, cumplirı́a la condición de Slater y, en ese caso, w1 = w2 = z ∗ . Sin embargo,
Francisco Garcı́a y Jorge Vera 7.2. Relajación Lagrangeana 145
la restricción de integralidad hace que se rompa la convexidad y, por lo tanto, no hay dualidad fuerte, es
decir, w1 < z ∗ , w2 < z ∗ . Sin embargo, uno de los dos duales será “mejor” que el otro: aquel que aporte el
valor dual más cercano a z ∗ .
En un problema de optimización que posea, en general, m restricciones, existirán, entonces, potencialmente
O(2m ) posibles duales y todos podrı́an dar valores diferentes (asumiendo que no haya dualidad fuerte). En
problema de alta dificultad, podrı́a ser imposible (o muy costoso) resolver el primal y ahı́ es donde adquiere
relevancia considerar el dual. Nos gustarı́a mucho poder “descubrir” el dual que nos entregue el mejor valor,
que será, entonces, la mejor cota inferior disponible al valor (desconocido) z ∗ . Encontrar ese “mejor” dual
puede ser un problema muy complejo, pero podrı́amos guiarnos por buenos criterios y construir un buen
dual. Esto es lo que motiva el enfoque de Relajación Lagrangeana, que se explica en la siguiente sección.
7.2. Relajación Lagrangeana

En lo que sigue, vamos a considerar, en forma más especı́fica, un problema de Programación Lineal Entera
de la siguiente forma:
mı́n cT x
s.a.
αiT x ≤ bi , i = 1, . . . , p
βiT x ≤ di , i = 1, . . . , q
x ≥ 0, entero
donde αi ∈ Rn , βi ∈ Rn , c ∈ Rn y los bi son escalares.
Supongamos que las primeras p restricciones son “complicantes”. Podemos interpretar esto en el sentido que
si esas restricciones no estuvieran presentes, el problema que queda serı́a más abordable que el problema
original. Formemos el siguiente Lagrangeano, solo con las restricciones “complicantes”:
p
X
L(x, λ) = cT x + λi (αiT x − bi )
i=1
Y sea
C = {x : x ≥ 0, entero, βiT x ≤ di , i = 1, . . . , q}
De este modo, al problema original se le“quitan” restricciones complicantes y se le “pasan” al Lagrangeano,

de modo que las restricciones que quedan en C son menos que las que habı́an en el problema original. Por esta
razón, al problema resultante se le llama “problema relajado”. La función dual asociada a ese Lagrangeano
es:
p
X
θ(λ) = mı́n{cT x + λi (αiT x − bi )}
x∈C
i=1
o, en forma más explı́cita:

p
θ(λ) = mı́n cT x + λi (αiT x − bi )
P
i=1
s.a.
βiT x ≤ di , i = 1, . . . , q
x ≥ 0, entero
NO dejemos de observar que, si bien la función objetivo se ve más compleja, es lineal en x, los valores λi
son fijos para efectos de este problema relajado.
Entonces, el problema dual consiste en obtener:
w∗ = máx θ(λ)
λ≥0
La propuesta es, entonces, resolver este dual y esperar que el valor de w∗ no sea muy diferente del problema
original. Debido al uso del Lagrangeano y al hecho que se está pasando a un problema con menos restricciones,
al enfoque resultante se le conoce como “Relajación Lagrangeana”.
Se puede demostrar que la función dual es una función cóncava en las variables λ. Luego, el problema
dual consiste en maximizar una función cóncava, lo que deberı́a ser “fácil” (es equivalente a minimizar una
convexa). Si se visualizara esta función se verı́a un gráfico del siguiente tipo:
Tal como se puede ver, este es un problema no diferenciable, el cual puede ser abordado mediante el Método
del Subgradiente, como se explica más adelante.
7.2.1. Ejemplos de Relajaciones Lagrangeanas

Problema con estructura de bloques
Consideremos un problema estándar de Programación lineal similar al que se usó para desarrollar la Descomposición
de Dantzig-Wolfe:
s.a. A1 x1 +···+ AK x K = b
D 1 x1 = d1
.. .. ..
. . .
DK xK = dK
x1 ≥ 0, ... xK ≥ 0
Como discutimos antes, las restricciones comunes son complicantes y las vamos a usar para formar un dual.
El lagrangeano se puede expresar como:
L(x, λ) = cT1 x1 + · · · + cTK xK + λT (A1 x1 + · · · + AK xK − b)
Con
C = {(x1 , . . . , xK ) ≥ 0 : Dk xk = dk , xk ≥ 0 , k = 1 . . . K}
La función dual, con λ irrestricta es:
( K K
!)
X X
θ(λ) = mı́n ck xk + λ T
Ak xk − b
x∈S
k=1 k=1
Reordenando los términos queda:
( K
!)
X T
θ(λ) = mı́n ck + ATk λ T
xk − λ b
x∈S
k=1
De modo que lo que se minimiza tiene la siguiente estructura:

Francisco Garcı́a y Jorge Vera 7.2. Relajación Lagrangeana 147
K
X
θ(λ) = θk (λ) − λT b
k=1
Donde cada θk (λ) es:
T
mı́n ck + ATk λ u
s.a. Dk u = dk
u≥0
Estos problemas tienen la misma forma que tenı́an los problemas satélite de la descomposición de Dantzig-
Wolfe. La diferencia aquı́ es el origen de los λ ya que en el caso de la descomposición, vienen de las variables
duales del problema maestro, que es una construcción parcial del problema que se está resolviendo, mientras
que acá vienen de la solución parcial de un dual lagrangiano. La interpretación de la descomposición, sin
embargo, es similar: aquı́ los λ son “precios duales” que penalizan a los satélites por no cumplir con las
restricciones comunes. Esos precios se deberı́an ir ajustando hasta alcanzar el balance óptimo.
Problema de Asignación Generalizada

Consideremos un problema donde hay entidades que se quieren asignar a trabajos, de modo que se utilizan
variables binarias xij que valen 1 cuando las entidades i son asignadas al trabajo j. Pero, existen, además,
restricciones que deben cumplirse con valores mı́nimos:
m X
X n
mı́n cij xij
i=1 j=1
Xn
s.a. xij = 1, i = 1, . . . , m (1)
j=1
Xm
aij xij ≥ bj , j = 1, . . . , n (2)
i=1
xij ∈ {0, 1}, ∀(i, j)
Este es un problema de programación entera, y no convexo. (1) dice que toda entidad es asignada a un
trabajo y (2) dice que existe un requisito mı́nimo bj para cada trabajo j, que se satisface con la contribución
de ciertos pesos aij cuando la entidad i trabaja en j. En este problema hay n + m restricciones. La idea es
relajar la familia de restricciones “complicantes”. Sin embargo, acá no es tan obvio cuáles restricciones son
las complicantes. Es por esto que se proponen ver los dos tipos de relajaciones generales que se pude hacer
en este problema.
Relajación 1
Relajamos las restricciones (1), por lo que se van a necesitar m variables duales: λi , i = 1, . . . , m que son
irrestrictas (por los “=”). De este modo, el problema relajado de la función dual es:
 
m X
X n m
X Xn
θ1 (λ) = mı́n cij xij + λi  xij − 1
i=1 j=1 i=1 j=1
m
X
s.a. aij xij ≥ bj , j = 1...n
i=1
xij ∈ {0, 1}, ∀(i, j)
Este problema sigue siendo de programación entera. Se reorganiza la función objetivo y se tiene:
n X
X m m
X
θ1 (λ) = mı́n (cij + λi )xij − λi
j=1 i=1 i=1
Xm
s.a. aij xij ≥ bj , j = 1, . . . , n
i=1
xij ∈ {0, 1}, ∀(i, j)
La suma de los λi en el último sumando, para efectos de la función dual es constante, por lo que no entra
en la minimización, solo entran los xij . Nótese que en la familia de restricciones que quedó, no hay ninguna
que combine distintos j, por lo que este problema de asignación se puede separar en n subproblemas más
pequeños:
n
X m
X
θ1 (λ) = zj (λ) − λi
j=1 i=1
Donde se define la función zj (λ) para un j fijo como:
m
X
zj (λ) = mı́n (cij + λi ) xij
i=1
Xm
s.a. aij xij ≥ bj
i=1
xij ∈ {0, 1}, ∀i
Este es un problema de minimización con solo una restricción, e integralidad. Este es un problema de mochila,
que puede ser resuelto mediante programación dinámica, entre otras alternativas. En resumen, para resolver
el problema relajado o calcular el valor de la función dual para un λ especı́fico se deben resolver n problemas
de mochila, obtener los valores óptimos y sumarlos en θ1 (λ).
Relajación 2
Relajamos las restricciones (2), por lo que se van a necesitar n variables duales: µ, i = 1, . . . , n que son no
negativas, µ ≥ 0, i = 1, . . . , n. De este modo, el problema relajado es:
m X
n n m
!
X X X
θ2 (λ) = mı́n cij xij + µj bj − aij xij
i=1 j=1 j=1 i=1
X n
s.a. xij = 1, i = 1, . . . , m
j=1
xij ∈ {0, 1}, ∀(i, j)
Este problema sigue siendo de programación entera. Se reorganiza la función objetivo y se obtiene:
m X
X n n
X
θ2 (λ) = mı́n (cij + µi aij )xij + µi bj
i=1 j=1 j=1
Xn
s.a. xij = 1, i = 1, . . . , m
j=1
xij ∈ {0, 1}, ∀(i, j)
La suma de los µi bj al lado derecho, para efectos de la función dual es constante, por lo que no entra en la
minimización, solo entran los xij . Nótese que en la familia de restricciones que quedó, no hay ninguna que
combine distintos i, por lo que este problema de asignación se puede separar en m subproblemas más chicos:
Francisco Garcı́a y Jorge Vera 7.3. Resolviendo el Problema Dual: Método del Supgradiente 149
m
X n
X
θ2 (λ) = vj (µ) + µi bj
i=1 j=1
Donde se define la función vi (µ) para un i fijo como:
n
X
vi (µ) = mı́n (cij + µi aij ) xij
j=1
Xn
s.a. xij = 1
j=1
xij ∈ {0, 1}, ∀(i, j)
Este es un problema de minimización con solo una restricción e integralidad. Este es un problema de la
mochila, pero que tiene una estructura tal que se puede resolver de manera muy fácil. Por la restricción, se
sabe que para un determinado i, entre todos los xij para distintos valores de j, solo uno vale 1, por lo que
se debe probar para los n posibles números de la función objetivo, buscar el más pequeño y ası́ se llega al
óptimo, en orden de n cálculos O(n), lo que es mucho más rápido que en el caso del problema de mochila
de la Relajación 1.
En conclusión, la evaluación de la función dual (o resolver el problema relajado) en esta Relajación 2 podrı́a
llegar a ser mucho más fácil que en el caso de la Relajación 1. Se puede demostrar, sin embargo, que el
valor dual que se obtenga de la Relajación 2 puede ser más malo que el de la Relajación 1. Esto se explica
por el hecho que el problema relajado de la segundo relajación tiene la “propiedad de integralidad”, que
significa que si se resuelve como problema de Programación Lineal, las variables tomarán valores enteros
en forma natural. En forma intuitiva, lo que ha pasado es que el problema fue “excesivamente relajado”,
perdiendo buena parte de la estructura que aporta al problema. Esa misma estructura aporta, igualmente,
complejidad, pero esa complejidad del problema no puede ser eliminada completamente. Si lo hacemos,
pagaremos el precio de una mala cota.
7.3. Resolviendo el Problema Dual: Método del Supgradiente

Como ya hemos comentado, la función dual es cóncava y el problema dual busca maximizar dicha función:
w∗ = máx θ(λ)
λ≥0
Este problema es, evidentemente, equivalente a
mı́n −θ(λ)
λ≥0
que es un problema de minimización con una función objetivo convexa no diferenciable. Como ya sabemos,
este puede ser abordado por el Método del Subgradiente que estudiamos en el Capı́tulo 2. Eso es lo que
haremos ahora, aunque reescribiremos el método directamente para abordar el problema de maximización.
Por esa razón hablaremos del método de “supgradiente” en vez de “subgradiente”, haciendo alusión al hecho
que, para una función cóncava, los supgradientes definen los hiperplanos tangentes que están por arriba del
grafo de la función.
El algoritmo es el siguiente:
Algoritmo del supgradiente para el problema dual
Data: Sea λ0 ∈ Rm , k = 0
while Criterio de parada no se satisface
do:
hk = −u, donde u ∈ ∂ −θ λk
resolver:
λk+1 = λk + tk hk
(Atención si se requiere que λ ∈ Rm
+)
end
En el algoritmo, tk es el paso de avance y explicaremos esto en breve. Notemos también que, como es
k

θ λ
cóncava, entonces −θ λ es convexa, y u ∈ ∂ −θ λ , u es un subgradiente, pero si h = −u, entonces
k
k
k
hk es un supgradiente.
Para usar el algoritmo necesitamos identificar un subgradiente y, afortunadamente, eso no es difı́cil.
Proposición: Dado λk , sea x̄k solución óptima del problema que calcula θ(λk ) para la iteración k. Sea
hi = gi (x̄k ) − bi . Entonces, h ∈ ∂(−θ(λk ))
Para dar una justificación intuitiva de este resultado, notemos que
( m
) m
X X
k
= mı́n f (xk ) + λki (gi (xk ) − bi ) = f (x̄k ) + λki (gi (x̄k ) − bi ) ,

θ λ
x∈C
i=1 i=1
donde se tiene que hi = gi (x̄k ) − bi . Ahora, si derivamos este valor óptimo en función de lambda se tendrı́a
algo ası́:
m
!
∂ ∂ X
θ λk = f (x̄k ) + λki hki =h

∂λ ∂λ i=1
Igualmente, se puede justifcar el resultado en forma rigurosa directamente de la definición de subgradiente.

De este modo, el subgradiente se obtiene como “subproducto” del proceso de evaluar la función dual y
resolver el problema relajado.
Un tema que debe abordarse en el algoritmo es qué hacer si se requiere que λ ≥ 0. En este caso, y siguiendo
las ideas del Capı́tulo 2, basta con proyectar sobre esas restricciones. Es decir, calcularemos la siguiente
iteración de esta forma:
λk+1 = máx 0, λk + tk hk

Una√ pregunta importante es el paso elegir. Esto es método de subgradiente y podrı́amos usar algo como
1/ k, donde k es el número de iteración, como se sugerı́a en el Capı́tulo 2. Esto se puede utilizar, pero en
Relajación Lagrangeana se hace algo diferente que es mejor, i que se inspira en la aplicación especı́fica a
Programación Lineal Entera. Sea U k una cota superior a z ∗ . Además, sea hk la dirección de avance y θ(λk )
el valor actual de la función dual en la iteración k. Se propone el siguiente paso en la iteración k:
U k − θ(λk )
tk = ρ ·
khk k22
Donde ρ ∈ [1/2, 2] es un factor de control que se ajusta “a mano”.

Cómo obtener esa cota superior es una gran pregunta. Veremos que eso se puede hacer mediante un
procedimiento de aproximación que llamaremos una “Heurı́stica Lagrangeana”. Los pasos son las siguientes:
En la iteración k resolvemos θ(λk ) y obtenemos una solución x̄k .
Francisco Garcı́a y Jorge Vera 7.4. Visión alternativa del dual y el algoritmo de planos cortantes 151
Esta solución no cumple las restricciones relajadas, pero sı́ las restricciones del conjunto C y que se
usaron en el problema relajado.
La idea es aplicar algún procedimiento computacional a x̄k para transformarlo en una nueva solución
x̃k que sı́ cumpla, además, las restricciones relajadas y por lo tanto sea factible al problema original.
Entonces podrı́amos utilizar U k = f (x̃k ).
De este modo, la iteración k del algoritmo tendremos dos valores que cumplen:
θ(λk ) ≤ z ∗ ≤ U k
De hecho, dado que la evolución de los valores no es necesariamente monótona, deberı́amos tomar el mejor
valor dual hasta la iteración k ası́ como la mejor cota superior hasta esa iteración:
máx θ(λi ) = w̄k ≤ z ∗ ≤ Ū k = mı́n U i

i=1,...,k i=1,...,k
De este modo, podemos juzgar el avance de las iteraciones y tomar una decisión de cuándo detenernos. Debe
recordarse que este procedimiento se aplicará a problemas difı́ciles en los que, generalmente, existirá salto
de dualidad, por lo tanto no vamos a obtener Ū k − w̄k = 0. Sin embargo, podremos detener las iteraciones
cuando esta diferencia ya no disminuya en forma significativa. En ese momento tendremos una solución
factible al problema (obtenida por la heurı́stica lagrangeana) y una estimación del error de esa solución con
respecto al óptimo.
7.4. Visión alternativa del dual y el algoritmo de planos cortantes

Vamos a introducir en esta parte una forma alternativa de escribir el problema dual. Esta forma nos dará,
también, la posibilidad de un algoritmo alternativo al Método de Subgradiente.
Para esto consideremos el siguiente problema:
P ) z ∗ = mı́n cT x
s.t. Ax ≥ b
Dx ≥ d
x entero
Sea C = {x : Dx ≥ d, x entero}. Supongamos, para simplificar, que C es un conjunto acotado (será el caso
si la integralidad es binaria). Entonces C es un conjunto finito (aunque eventualmente muy grande). Sean
x1 , x2 , . . . , xp los elementos de C. Nuestro problema es:
P ) z ∗ = mı́n cT x
s.t. Ax ≥ b
x∈C
cuyo dual Lagrangeano es:

máx mı́n{cT x + λT (b − Ax)}
λ≥0 x∈C
Pero como C es un conjunto finito, el problema
mı́n{cT x + λT (b − Ax)}
x∈C
es lo mismo que
mı́n {cT xi + λT (b − Axi )}.
i=1,...,p
Luego, el dual es:

w∗ = máx mı́n {cT xi + λT (b − Axi ), } ,
λ≥0 i=1,...,p

w∗ = máx γ
P DP C ) s.a. γ ≤ cT xi + λT (b − Axi ), i = 1, . . . , p
λ ≥ 0.
Esta forma alternativa de escribir el dual nos puede llevar a pensar que es poco práctica, ya que tiene una
cantidad enorme de restricciones (asociadas a los vértices del poliedro). Sin embargo, podemos desarrollar un
procedimiento análogo al usado para la Descomposición de Benders del capı́tulo 5, un esquema de “planos
cortantes”, como mostramos a continuación.
7.4.1. El Método de Planos Cortantes para el dual

Un procedimiento alternativo surge de la escritura “puntual” del dual qye desarrollamos en 8.5:
w∗ = máx γ
P DP C ) s.a. γ − λT (b − Axi ) ≤ cT xi , i = 1, . . . , p
λ≥0
donde x1 , . . . , xp son los elementos del conjunto C = {x : Dx ≥ d, x entero}. La idea es ir generando las
restricciones de P DP C ) a medida que las necesitemos, en un esquema de “planos cortantes”.
Supongamos que conocemos hasta el momento k puntos del conjunto C. Consideremos el problema “maestro”
con sólo las restricciones asociadas a esos k puntos:
wk = máx γ
P Mk ) s.a. γ − λT (b − Axi ) ≤ cT xi , i = 1, . . . , k
λ≥0
Como P Mk ) es una relajación de P DP C ) se tiene que wk ≥ w∗ . Sea (γ k , λk ) solución óptima de P Mk ).
Ahora tenemos que encontrar una restricción de la forma
γ − λT (b − Au) ≤ cT u
para algún u ∈ C tal que (γ k , λk ) no la cumpla, es decir:
γ k − (λk )T (b − Au) > cT u
¿Cómo encontramos ese u?. La condición anterior se puede escribir:
γ k − (λk )T b > (c − AT λk )T u
Resolvamos el siguiente problema:
η k = mı́n (c − AT λk )T u
⇔ s.a. Du ≥ d
s.a. u ∈ C
u entero
Entonces, si
η k < γ k − (λk )T b
el punto solución de este problema define un punto xk+1 ∈ C que sirve para construir una nueva restricción:
γ − λT (b − Axk+1 ) ≤ cT xk+1
que puede ser agregada al problema maestro para crear el problema P Mk+1 ). Si el valor η k es tal que
η k ≥ γ k − (λk )T b
entonces no podemos encontrar otra restricción y hemos llegado al óptimo del dual. Nótese que el problema
“satélite” para calcular η k :
s.a. Du ≥ d
u entero
es exactamente el mismo usado para calcular θ(λk ). Esto significa que la solución u = xk+1 que se obtiene
de ese problema también puede usarse para calcular una solución primal factible usando una heurı́stica
lagrangeana.
Francisco Garcı́a y Jorge Vera 7.4. Visión alternativa del dual y el algoritmo de planos cortantes 153
7.4.2. Diferencias en las relajaciones (material avanzado)

Como indicamos en el ejemplo del problema de Asignación Generalizado, algunos duales son mejores que
otros. La escritura del dual en forma de planos cortantes nos permite entender mejor lo que está pasando.
Para esto, retomemos otra vez más la forma de planos cortantes dle dual:
w∗ = máx γ
P DP C ) s.a. γ ≤ cT xi + λT (b − Axi ), i = 1, . . . , p
λ ≥ 0.
A partir de esta escritura del dual es posible demostrar el siguiente resultado:
Proposición:
w∗ = mı́n cT x
s.a. Ax ≥ b
x ∈ conv(C)
Demostración:
Reorganicemos el problema dual P DP C ) de la siguiente forma:
w∗ = máx γ
P DP C ) s.a. γ − λT (b − Axi ) ≤ cT xi , i = 1, . . . , p
λ≥0
Este es un problema de programación lineal que tiene su propio dual como tal. Sean π1 , . . . , πp las variables
duales. El dual de P DP C ) es entonces:
p
mı́n πi cT xi
P
j=1
p
πi (b − Axi ) ≤ 0
P
s.a.
j=1
p
πi = 1
P
j=1
πi ≥ 0, i = 1, . . . , p.
Reorganizando queda:
p
mı́n cT ( πi xi )
P
j=1
p
πi xi ) ≥ b
P
s.a. A(
j=1
p
πi = 1
P
j=1
πi ≥ 0, i = 1, . . . , p.
p
Pero notemos que πi xi es un punto en la envoltura convexa de C. Luego, tenemos que:
P
j=1
w∗ = mı́n cT x
s.a. Ax ≥ b
x ∈ conv(C)
como querı́amos demostrar. QED.
Comparemos bien ahora los distintos problemas que tenemos disponibles. El problema entero original es:
z ∗ = mı́n cT x
s.a. Ax ≥ b
Dx ≥ d, x entero
Mientras que el problema dual es:
w∗ = mı́n cT x
s.a. Ax ≥ b
x ∈ conv({x : Dx ≥ d, x entero})
Por otra parte, la relajación lineal del problema entero original es:
z 0 = mı́n cT x
s.a. Ax ≥ b
Dx ≥ d
Tenemos entonces que:
Proposición:
Si conv({x : Dx ≥ d, x entero}) = {x : Dx ≥ d} entonces w∗ = z 0 .
Es decir, en ese caso el valor del dual es igual al de la relajación lineal original del problema y la cota dual
no será ninguna mejora con respecto a la relajación lineal. La siguiente figura ilustra en forma comparativa
los conjuntos factibles de los distintos problemas y sus respectivas envolturas convexas.
La figura muestra las regiones lineales de los dos conjuntos de restricciones del problema: Ax ≥ b y Dx ≥ d.
En lı́nea punteada se muestra la envoltura convexa de los puntos enteros, y el correspondiente óptimo del
problema, ası́ como la relajación lineal. El valor de la Relajación Lagrangeana se alcanza la intersección de la
región Ax ≥ b con conv(C). Puede verse claramente que si la región Dx ≥ d coincide con conv(C) entonces
los valores óptimos de la Relajación Lineal y el de la Relajación Lagrangeana coinciden.
En nuestro ejemplo del Problema de Asignación Generalizado, en la relajación 2, el conjunto C estaba dado
por la región factible de los problemas:
n
vi (µ) = mı́n (cij − µj aij )xij
P
j=1
n
xij = 1
P
s.a.
j=1
xij ∈ {0, 1}∀(i, j)
Y en este caso conv(C) corresponde a la región factible de:

n
mı́n (cij − µj aij )xij
P
j=1
n
xij = 1
P
s.a.
j=1
0 ≤ xij ≤ 1∀(i, j)
Se dice que el subproblema que resulta de la relajación tiene “la propiedad de integralidad” y entonces el
valor dual no mejorará la relajación lineal. Esto no ocurre, de hecho, en la Relajación 1.
De todo este análisis se deduce que la descomposición del problema debe ser tal que el valor dual obtenido
sea efectivamente mejor cota que la de la relajación lineal. Para esto debe evitarse que el problema dual
relajado sea demasiado “fácil”. ¿Cómo saber esto a priori? Depende de la estructura del problema y del
“arte” del que está resolviendo el problema.
7.5. Ejemplos
Logı́stica de vacunas
Considere la siguiente situación: una autoridad de salud debe organizar el proceso de vacunación de n
comunidades, para lo cual debe habilitar centros de vacunación en m posibles lugares. La comunidad j tiene
una población total a vacunar igual a dj y cada persona a vacunar hará uso de recursos de capacidad de
un centro de vacunación. Denotaremos por αj la capacidad usada por una persona de la comunidad j. La
capacidad total de un centro de vacunación es C (es la misma para todos). Idealmente queremos vacunar
a todas las personas de todas las comunidades en los centros que se abran, pero si no se puede, se tendrá
que proceder a hacer vacunación a domicilio, y eso tiene un costo fj por persona de la comunidad j. Por
otro lado, abrir el centro de vacunación i tiene un costo fijo Gi . Por razones de disponibilidad de personal,
a lo más M centros pueden ser habilitados. La autoridad de salud ha formulado el siguiente modelo de
optimización entera mixta para decidir qué centros abrir y cuántas personas de cada comunidad asignar
a cada centro, de modo de lograr el mejor balance entre costos y cantidad de personas vacunadas en los
centros:
m P
n m n
máx
P P P
β xij − Gi yi − fj zj
i=1 j=1 i=1 j=1
m
xij + zj = dj , j = 1, . . . , n (1)
P
s.a.
i=1
n
i = 1, . . . , m (2)
P
αj xij ≤ Cyi ,
j=1
m
(3)
P
yi ≤ M,
i=1
xij ≥ 0, zj ≥ 0, yi ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n (4)
La variable yi vale 1 si se habilita el centro de vacunación i, 0 en caso contrario, xij es la cantidad de personas
de la comunidad j vacunadas en el centro i (pensemos en que son números grandes, por eso consideramos la
variable como continua), zj denota las personas de la comunidad j no vacunadas en centros de vacunación
(y, por lo tanto, vacunadas a domicilio). La función objetivo combina el objetivo de maximizar la cantidad
de personas vacunadas contra los costos asociados (usando un parámetro β > 0 para derle más o menos
importancia a la cantidad de personas vacunadas), las restricciones (1) definen que los vacunados y no
vacunados corresponden, en total, a la población de j, las restricciones (2) establecen el lı́mite de capacidad
de los centros y, además, que si el centro i no se abre, entonces no se le pueden asignar personas, la restricción
(3) es el lı́mite a la cantidad de centros, y (4) define la naturaleza de las variables.
El problema tiene una estructura compleja debido a que mezcla restricciones “de carga fija” (las 2) y
también de “mochila” (la 3) y, seguramente, puede ser difı́cil de resolver para cantidades grandes de centros
de vacunación y de comunidades. Vamos a visualizar posibles construcciones de duales en este prbolema y
desarrollar una de ellas.
Lo más razonable es formar un dual relajando las restricciones (1) o la (3). Esto hace que el problema
relajado tenga suficiente estructura. Si se relaja las restricciones (2) el problema se separa en uno lineal puro
y en uno entero en las variables y pero de solución trivial, ası́ que seguramente, la cota dual en esa caso no
será buena. Mostramos acá la relajación con las restricciones (3). Para esto introducimos una sóla variables
dual λ ≥ 0. El problema relajado de la función dual es:
m P
n m n m
θ(λ) = máx fj zj + λ( yi − M )
P P P P
β xij − Gi yi −
i=1 j=1 i=1 j=1 i=1
m
xij + zj = dj , j = 1, . . . , n (1)
P
s.a.
i=1
n
i = 1, . . . , m (2)
P
αj xij ≤ Cyi ,
j=1
xij ≥ 0, zj ≥ 0, yi ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n (4)
que se reordena a:
m P
n m n
θ(λ) = máx (Gi − λ)yi −
P P P
β xij − fj zj − λ × M
i=1 j=1 i=1 j=1
m
xij + zj = dj , j = 1, . . . , n (1)
P
s.a.
i=1
n
i = 1, . . . , m (2)
P
αj xij ≤ Cyi ,
j=1
xij ≥ 0, zj ≥ 0, yi ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n (4)
El problema dual es:

mı́n θ(λ)
λ≥0
Localización y Asignación de Clientes

Consideramos aquı́ un problema en el que se deben instalar centros de distribución y asignar clientes a ellos.
Tenemos que hay m posibles puntos donde se pueden instalar centros de distribución y un total de n clientes
deben ser atendidos desde un único centro de distribución. Sea fi el costo de abrir un centro de distribución
en i y sea cij el costo de asignar al cliente j al centro en i. Lo que el problema básico busca es determinar
en qué lugares se deben abrir centros de distribución y qué clientes signar a cada uno de ellos, pero además
existen externalidades negativas de tipo ambiental. Esto significa que si un cliente j se asigna a un centro
de distribución i, entonces se produce una huella de carbono igual a hij (en unidades adecuadas). Para cada
lugar donde puede haber un centro de distribución, se ha definido una huella total máxima que no se puede
superar, dada por Hi , para el lugar i.
El problema se modela con dos variables:
yi , binaria que indica si se abre el centro en i.
xij , binaria que indica si el cliente j se asigna al centro i.
El modelo es:
m m P
n
mı́n fi yi +
P P
cij xij
i=1 i=1 j=1
m
xij = 1, j = 1, . . . , n (1)
P
s.a.
i=1
n
P1 ) P
xij ≤ nyi , i = 1, . . . , m (2)
j=1
n
i = 1, . . . , m (3)
P
hij xij ≤ Hi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
Es interesante notar, también, que las restricciones (2) y (3) podrı́an ser combinadas en una sola, que tendrá
el mismo efecto:
m m P
n
P2 ) mı́n fi yi +
P P
cij xij
i=1 i=1 j=1
m
xij = 1, j = 1, . . . , n (1)
P
s.a.
i=1
n
i = 1, . . . , m (20 )
P
hij xij ≤ Hi yi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
Incluso es válida la siguiente formulación:
m m P
n
mı́n fi yi +
P P
cij xij
i=1 i=1 j=1
m
xij = 1, j = 1, . . . , n (1)
P
s.a.
i=1
n
P3 ) P
xij ≤ nyi , i = 1, . . . , m (2)
j=1
n
i = 1, . . . , m (3)
P
hij xij ≤ Hi yi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
aunque el poner yi en la restricción (3) es redundante, para efectos de la instalación de centros de distribución.
Se debe mencionar que, aunque las tres formulaciones son equivalentes, dan resultados distintos en términos
de dificultad de resolución. La formulación (3) puede resultar algo más “fuerte” que las otras y dar un valor
relajado lineal menos malo.
Ahora queremos resolver el problema usando Relajación lagrangeana. Vamos a detallar el análisis para las
formulaciones anteriores, comentando las propiedades que tendrán los correspondientes problemas relajados.
Partamos por la formulación P1 ). Lo primero que podrı́a considerarse es imitar lo que se hizo en clases con
un problema similar, y relajar las restricciones (1). Si hacemos esto, el problema relajado es:
m m P
n n m
θ1 (λ) = mı́n fi yi + cij xij + λj ( xij − 1)
P P P P
i=1 i=1 j=1 j=1 i=1
n
i = 1, . . . , m (2)
P
s.a. xij ≤ nyi ,
P R1 ) j=1
n
i = 1, . . . , m (3)
P
hij xij ≤ Hi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
m m P
n n
θ1 (λ) = mı́n fi yi + (cij + λj )xij −
P P P
λj
i=1 i=1 j=1 j=1
n
i = 1, . . . , m (2)
P
s.a. xij ≤ nyi ,
P R1 ) j=1
n
i = 1, . . . , m (3)
P
hij xij ≤ Hi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
El dual correspondiente es máxλ θ1 (λ).
Este problema relajado posee una estructura combinatorial razonablemente compleja, las variables x e y
siguen interactuando y seguramente dará origen a una buena cota. En el desarrollo de la RL deberá abordarse
el problema de una heurı́stica lagrangiana. Discutamos eso ahora. Una primera idea suponer que estamos
en la iteración k de la RL, tenemos variables duales λk y hemos resuelto el problema θ1 (λk ). Esto nos ha
dado una solución (y k , xk ) que no cumple las restricciones (1), que han sido relajadas. Entonces, podrı́amos
construir un problema sólo en la variables x, fijando los y en los valores y k . Esto nos llevará a resolver, en
cada iteración de la RL, el problema:
m m P
n n
θ1 (λ) = mı́n fi yi + (cij + λj )xij −
P P P
λj
i=1 i=1 j=1 j=1
n
xij ≤ nyik , i = 1, . . . , m (2)
P
s.a.
P H1 ) j=1
n
i = 1, . . . , m (3)
P
hij xij ≤ Hi ,
j=1
xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
Con esto, las restricciones (2) tienen lado derecho constante, no variable. El problema que tiene este enfoque
) es que el problema en las variables x ya no es tan fácil de resolver, las restricciones (3) complican todo y
hacen que el problema pierda su estructura de redes, que lo hacı́a tan simple. Esto significa que, si bien es
válido hacer esto, puede no dar una heurı́stica muy eficiente. Hay que recordar que queremos una solución
heurı́stica que se pueda calcular con rapidez.
Existen varias otras alternativas, una es la siguiente:
1. Tomar la solución (xk , y k ) y evaluar si se cumple la restricción (1). Si se cumple, estamos listos.
2. Si no se cumple, es porque hay clientes asignados a más de un lugar o no asignados.
3. Si un cliente está asignado a más de un lugar, sacarlo de los lugares más caros. Esto no afectará las
restricciones (3).
4. Si un cliente no está asignado, buscar un centro i donde haya holgura suficiente en las restricciones
(3), y asignarlo ahı́.
5. Si no se puede encontrar una asignación, abrir un centro i que esté actualmente cerrado y comenzar a
agregar ahı́ los clientes no asignados.
Con algo de suerte, este proceso heurı́stico podrı́a generar una solución factible.
Sigamos con la formulación P1 ) y consideremos otros RL, relajando las restricciones (3) más bien. El problema
relajado es:
m m P
n m n
mı́n fi yi + cij xij + λi ( hij xij − Hi )
P P P P
i=1 i=1 j=1 i=1 j=1
m
xij = 1, j = 1, . . . , n (1)
P
s.a.
P R2 ) i=1
n
i = 1, . . . , m (2)
P
xij ≤ nyi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
m m P
n m
θ2 (λ) = mı́n fi yi + (cij + λi )xij −
P P P
λi Hi
i=1 i=1 j=1 i=1
m
xij = 1, j = 1, . . . , n (1)
P
s.a.
P R2 ) i=1
n
i = 1, . . . , m (2)
P
xij ≤ nyi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
El correspondiente problema dual es máxλ≥0 θ2 (λ). El problema relajado que resulta no es más que un
problema de localización-asignación tı́pico. Lo único es que los costos son variables. Resolver este problema en
cada iteración puede resultar bastante complejo, pero suponiendo que lo hacemos, igual tenemos que pensar
en una heurı́stica lagrangeana. Supongamos, entonces, que estamos en la iteración k de la RL, tenemos
variables duales λk y hemos resuelto el problema θ2 (λk ). Esto nos ha dado una solución (y k , xk ) que no
cumple necesariamente las restricciones (3). Ahora, se puede hacer el siguiente procedimiento heurı́stico:
1. Verificar la solución (y k , xk ) en las restricciones (3), si se cumplen, estamos listos.
2. Si no se cumplen, identificar los centros i abiertos donde se excede contaminantes. Identificar también
los centros abiertos donde hay holgura en las restricciones (3).
3. Remover, en orden de costos (por ejemplo) los clientes de los centros saturados (donde se viola (3)) y
agregarlos a los centros con holgura.
4. Cuando ya no se puedan mover más clientes, comenzar a abrir centros cerrados (en orden de costos)
y colocar ahı́ los clientes agregados, hasta saturar las restricciones (3).
5. Continuar hasta obtener una solución factible.
En forma alternativa, tanto para la relajación (1), como la (2), se podrı́a considerar como heurı́stica el
ejecutar un procedimiento de tipo metaheurı́stico en las variables x. Eso igual estarı́a usando parte de la
solución relajada.
Consideremos ahora la formulación P2 ) del problema. Esta tiene la ventaja de que las restricciones originales
(2) y (3) se manejan en conjunto. Aquı́ relajaremos las restricciones (1) para obtener:
m m P
n n m
P R3 ) θ3 (λ) = mı́n fi yi + cij xij + λi ( xij − 1)
P P P P
i=1 i=1 j=1 j=1 i=1
n
i = 1, . . . , m (20 )
P
s.a. hij xij ≤ Hi yi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
m m P
n n
P R3 ) θ3 (λ) = mı́n fi yi + (cij + λi )xij −
P P P
λi
i=1 i=1 j=1 j=1
n
i = 1, . . . , m (20 )
P
s.a. hij xij ≤ Hi yi ,
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
Este problema tiene la caracterı́stica de que las restricciones (2’) generan problemas de mochila algo más
complejos, pero podrı́a resolverse en forma más o menos eficiente, en todo caso. Ahora, nuevamente tenemos
el problema de considerar una heurı́stica lagrangeana para este caso, y el procedimiento descrito para la
relajación (1) anterior puede servir aquı́ sin problemas.
Planificación de Producción
Una empresa fabrica J productos diferentes, los cuales tiene demandas sobre T periodos de tiempo. La
demanda por el item j en el periodo t es djt . La empresa tiene K fábricas diferentes que pueden fabricar
los productos, pero hay un costo fijo si se asigna la producción de un producto a una fábrica en algún
periodo de tiempo. En cada periodo, sólo una de las fábrica producirá de un mismo producto. Además,
hay costo variables de producción y hay capacidades de producción. Adicionalmente, el uso de alguna de
las fábricas para un producto genera el uso de un recurso productivo, que se requiere en una cantidad fija
(independientemente de cuánto se fabrica de los productos), y del cual hay disponibilidad limitada. Más
en especı́fico, sea cjtk el costo unitario de producción para el producto j en la fábrica k en t, Fjkt el costo
fijo de producir el producto j en la fábrica k en t, βjk la cantidad del recurso escaso que se requerirá para
el producto j en la fábrica k, y cuyo total disponible es P , para todo el problema. La fábrica k tiene una
capacidad total de Hkt horas en el periodo t y producir producto j en k consume αjk horas. Adicionalmente,
el producto se puede guardar en inventario de un periodo al siguiente, pero eso tiene un costo hjt . Asumimos
aquı́ que todo lo producido se almacena en una bodega central y los costos de transportarlo a esa bodega
son despreciables.
La empresa ha postulado un modelo de optimización en el cual usa las variables xjtk para indicar la cantidad
del producto j a fabricar en la fábrica k en el periodo t, yjkt , una variable binaria que indica si hay producción
de j en la fábrica k en t e Ijt como el inventario del producto j al final del periodo t (asumiremos que los
inventarios iniciales, Ij0 , son conocidos). El modelo es el siguiente:
( )
T K P
J J
mı́n {cjkt xjkt + Fjkt yjkt } +
P P P
hjt Ijt
t=1 k=1 j=1 j=1
K
Ijt = Ijt−1 + j = 1, . . . , J; t = 1, . . . , T (1)
P
s.a. xjtk − djt
k=1
J
k = 1, . . . , K; t = 1, . . . , T (2)
P
αjk xjkt ≤ Hkt
j=1
xjkt ≤ M yjkt j = 1, . . . , J; k = 1, . . . , K; t = 1, . . . , T (3)
K
yjkt = 1 j = 1, . . . , J; t = 1, . . . , T (4)
P
k=1
K PJ P
T
(5)
P
βjk yjkt ≤ P
k=1 j=1 t=1
xjkt ≥ 0, Ijt ≥ 0, yjkt ∈ {0, 1} j = 1, . . . , J; k = 1, . . . , K; t = 1, . . . , T (6)
Las restricciones (1) son el flujo de inventarios y satisfacción de demanda (y, se entiende, Ij0 es un dato),
las (2) establecen el limite a la capacidad de producción, las (3) definen la “carga fija”, las (4) establecen
que sólo una fábrica se encarga de cada producto en cada periodo, las (5) determinan que se cumpla la
disponibilidad del recurso escaso, y las (6) definen la naturaleza de las variables.
Vamos a abordar este problema mediante Relajación Lagrangeana pero primero discutamos la existencia de
restricciones complicantes. Por ejemplo, las restricciones (3) son complicantes, ya que relaciona las variables
x con las y. Las restricciones (2) son complicantes, ya que relacionan las variables x según el ı́ndice j de los
productos. El resto de las restricciones forma problemas independientes en el ı́ndice j.
Se planteará ahora una relajación Lagrangeana relajando las restricciones (3). Para esto, se tiene que definir
variables duales λjkt ≥ 0. El problema relajado de la función dual es:
( )
T K P
J J T P
K P
J
θ(λ) = mı́n {cjkt xjkt + Fjkt yjkt } + +
P P P P
hjt Ijt λjkt {xjkt − M yjkt }
t=1 k=1 j=1 j=1 t=1 k=1 j=1
K
Ijt = Ijt−1 + j = 1, . . . , J; t = 1, . . . , T (1)
P
s.a. xjtk − djt
k=1
J
k = 1, . . . , K; t = 1, . . . , T (2)
P
αjk xjkt ≤ Hkt
j=1
K
yjkt = 1 j = 1, . . . , J; t = 1, . . . , T (4)
P
k=1
K P J P T
(5)
P
βjk yjkt ≤ P
k=1 j=1 t=1
Reordenado queda:
T P
K P
J T P
K P
J T P
J
θ(λ) = mı́n xjkt {cjkt + λjkt } + yjkt {Fjkt − λjkt M } +
P P P
hjt Ijt
t=1 k=1 j=1 t=1 k=1 j=1 t=1 j=1
K
Ijt = Ijt−1 + j = 1, . . . , J; t = 1, . . . , T (1)
P
s.a. xjtk − djt
k=1
J
k = 1, . . . , K; t = 1, . . . , T (2)
P
αjk xjkt ≤ Hkt
j=1
K
yjkt = 1 j = 1, . . . , J; t = 1, . . . , T (4)
P
k=1
K P J P T
(5)
P
βjk yjkt ≤ P
k=1 j=1 t=1
El problema dual es maxλjkt ≥0 θ(λ)
También, se pudo haber descompuesto el problema relajado de la función dual en dos problemas, uno para
las x y otro para las y, es decir:
θ(λ) = θ1 (λ) + θ2 (λ)
donde:
K P
T P J J
T P
θ1 (λ) = mı́n xjkt {cjkt + λjkt } +
P P
hjt Ijt
t=1 k=1 j=1 t=1 j=1
K
Ijt = Ijt−1 + j = 1, . . . , J; t = 1, . . . , T (1)
P
s.a. xjtk − djt
k=1
J
k = 1, . . . , K; t = 1, . . . , T (2)
P
αjk xjkt ≤ Hkt
j=1
xjkt ≥ 0, Ijt ≥ 0 j = 1, . . . , J; k = 1, . . . , K; t = 1, . . . , T (6)
T P
K P
J
θ2 (λ) = mı́n
P
yjkt {Fjkt − λjkt M }
t=1 k=1 j=1
K
yjkt = 1 j = 1, . . . , J; t = 1, . . . , T (4)
P
k=1
K P J P T
(5)
P
βjk yjkt ≤ P
k=1 j=1 t=1
yjkt ∈ {0, 1} j = 1, . . . , J; k = 1, . . . , K; t = 1, . . . , T (6)
Discutamos ahora cuál puede ser una buena heurı́stica Lagrangeana para usar en la relajación anterior. La
heurı́stica busca encontrar una solución factible a un problema, aunque esa solución no sea necesariamente
óptima. Supongamos, que estamos en la iteración n de la RL, se ha resuelto el problema θ(λ), tenemos
variables duales λn y llegamos a una solución (xn , y n ) que puede no cumplir con las restricciones (3). Una
posible heurı́stica serı́a la siguiente:
1. Si (xn , y n ) cumple con las restricciones (3), se ha llegado a la solución.

2. Si no cumple, es porque hay asignado a fabricar una cantidad de producto j en el tiempo t a una
fábrica que no produce ese producto en ese tiempo.
3. Si pasa lo anterior, asignar la fabricación de la cantidad xjkt de un producto a una fábrica que se
encuentre produciendo ese producto en ese tiempo, ya que como dice el enunciado, sólo una fábrica
puede producir de un mismo producto. Además, se debe correr el subproblema de las x, para asegurar
que se cumplan las restricciones de capacidad.
4. Si no hay ninguna fábrica abierta que fabrique el producto en cuestión, se debe abrir una fábrica para
la producción del producto, eligiendo la que tenga menor costo fijo.
Capı́tulo 8
Heurı́sticas
En muchos problemas de optimización requiero resolver problemas difı́ciles, que se pueden resolver con
exactitud en horas o dı́as, cuando en realidad se requiere tener un resultado en cosa de segundos o minutos.
Tal es el caso del problema del vendedor viajero (PVV), cuando se debe rutear camiones desde un depot
a abastecer clientes en una ciudad. Este tipo de problemas se pueden resolver de manera aproximada,
obteniendo buenas soluciones en tiempos cortos. Esto es lo que hacen las heurı́sticas.
Ejemplo de heurı́sticas famosas son Greedy, 2-Opt o 3-Opt en el PVV. Estos últimos corresponden a tomar
dos o tres arcos no consecutivos de un circuito, borrarlos y agregar nuevas combinaciones de arcos que cierren
el circuito, a ver si eso disminuye el costo. Esto es un procedimiento rápido que si se aplica sobre muchos
pares o trı́os de arcos, se pueden obtener buenas soluciones de manera rápida. Si bien no son soluciones
óptimas, son soluciones buenas y prácticas para usarla.
Desarrollar heurı́sticas especı́ficas cada vez que tenemos un problema especı́fico es un buen camino, es lo
que se tiene que hacer para las heurı́sticas lagrangeanas, por ejemplo. Pero también se han desarrollado
conceptos generales que permiten crear heurı́sticas para “casi cualquier problema”. Estos procedimientos son
llamados “Metaheurı́sticas”:
Procedimientos de estructura general que se pueden aplicar a muchos problemas distintos.
Aunque su implementación requiere de especificaciones según el problema.
8.1. Heurı́sticas Generales: Metaheurı́sticas

Estructura básica de todos estos procedimientos: “búsqueda local”. Consideremos el siguiente problema de
optimización general:
mı́n f (x)
x∈C
donde C es el conjunto de soluciones factibles del problema, el cual asumimos, tı́picamente, que es discreto.
C va a ser nuestro “espacio de búsqueda”. Dado x ∈ C se define, según el problema, un conjunto V (x) ⊂ C
el cual llamamos una “vecindad” de x. La “vecindad” se obtiene mediante una modificación “marginal” de
la solución actual, lo que se puede hacer con una regla computacional que da vecinos de alguna solución, tal
como mover dos arcos de un circuito haciendo 2-Opt.
Algoritmo genérico de una Metaheurı́stica
Data: Sea x0 ∈ C, k = 0.
while Criterio de parada no
se satisface do:
Elegir xk+1 ∈ V xk tal que f xk+1 < f xk .

k =k+1
end
El elemento clave es cómo construir la vecindad, y esto depende del problema especı́fico. Por ejemplo: el
proceso 2-Opt para el PVV es una heurı́stica de búsqueda local.
162
Francisco Garcı́a y Jorge Vera 8.2. Simulated Annealing 163
El problema con la búsqueda local es que podemos quedar “atrapados” en un mı́nimo local si la etapa 1 no
encuentra un punto mejor. Hay varias formas de resolver eso, algunas implican violar el criterio básico de
selección:
f xk+1 < f xk

Dos procedimientos muy usados para “escaparse” de los mı́nimos locales son Simulated Annealing y Tabu
Search, que estudiaremos a continuación.
8.2. Simulated Annealing

Simulated Annealing hace una exploración en el espacio de búsqueda, tratando de ir mejorando siempre la
solución, pero en cuando considera aceptar una nueva solución más “mala” x
de vez k+1
, es decir
si f x ≥ f x , pero eso se hace con una cierta probabilidad, que es controlada de forma especial a
k+1
k
medida que avanzan las iteraciones. En general, cuando comienzo, tengo más probabilidades de cambiarme
a soluciones más malas, pero a medida que avanzo, dicha probabilidad va disminuyendo.
Para esto vamos a definir ciertos números T0 > T1 > T2 > . . . tal que Ti > 0, ∀i y Ti −→ 0 con i −→ ∞
Por ejemplo, una forma tı́pica es Ti+1 = αTi , con α < 1. Si la solución vecina es mejor me cambio de todos
modos, pero si no, con cierta probabilidad me muevo.
Algoritmo de Simulated Annealing
Data: Sea x0 ∈ C, B una constante y Tk una serie de valores que tiende a cero.
elegir al azar y ∈ V xk
if f (y) < f xk :
xk+1 = y, k = k + 1
else:
Calcular el valor de la probabilidad de aceptar y:
f (y)−f (xk )
−
p=e BTk
if U (0, 1) ≤ p:
xk+1 = y, k = k + 1
end
Para aceptar y con probabilidad p, simplemente se genera una uniforme entre 0 y 1 U (0, 1), de modo que si
esta es menor que p se acepta y
f (y)−f (xk )
f (y) − f xk

−
Tk va disminuyendo −→ va aumentando −→ e BTk
va disminuyendo
BTk
La lógica de esto es explorar el espacio de búsqueda, conocer la zona y luego profundizar en buscar buenas
soluciones. Para aceptar, simplemente se genera un número aleatorio que distribuye uniforme entre 0 y 1. Si
es que p es menor que este número aleatorio generado entonces no se acepta el vecino al que se mueve, en
caso contrario si se acepta.
Aquı́, B es una constante positiva, la distribución de probabilidad original que debiera usarse es la distribución
de Boltzman, usada en Mecánica Estadı́stica. Ahı́ B = 1,3806503×10−23 JK −1 , la constante de Boltzman.

El origen de esto está en la inspiración del Simulated Annealing: el proceso fı́sico de “annealing” en metalurgia
en el que un metal casi fundido a alta temperatura es enfirado de una menera contralada para obtener una
estructura cristalina óptima. El Simulated Annealing fue propuesto por Kirkpatridge en 1983, basado en
desarrollos anteriores.
La construcción de vecindades y selección de candidatos se suele hacer en forma aleatoria. La “Temperatura”
y otros parámetros se calibran por simulación de MonteCarlo. El criterio de parada en general corresponde
al número de iteraciones o cuando ya no hay mejora.
164 Capı́tulo 8. Heurı́sticas
8.2.1. Ejemplo: localización de centros de distribución y asignación de clientes

Vamos a usar como ejemplo el problema de localización-asignación que vimos en el tema de Relajación
lagrangeana.
m posibles puntos donde se pueden instalar centros de distribución
n clientes que deben ser atendidos desde un único centro de disribución.
fi el costo de abrir un centro en i.
cij el costo de asignar al cliente j al centro en i.
Pregunta: ¿en qué lugares abrir centros de distribución y a cuáles asignar los clientes? El modelo usa dos
tipos de variables:
yi , binaria que indica si se abre el centro en i.
xij , binaria que indica si el cliente j se asigna al centro i.
El modelo tı́pico es el siguiente:
m
X m X
X n
mı́n fi yi + cij xij
i=1 i=1 j=1
Xm
s.a. xij = 1, j = 1, . . . , n
i=1
Xn
xij ≤ nyi , i = 1, . . . , m
j=1
yi , xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
Una “vecindad” de una solución donde ciertos clientes están conectados a un determinado centro de distribución
puede ser cambiar a un cliente se centro, abrir otro centro.
Supongamos estamos actualmente con una solución factible (ȳ, x̄). Pero podemos hacer algo un poco más
estructurado. Notemos que, con y fijos, el problema en los x es un problema “fácil”. Sea:
m X
X n
g(y) = mı́n cij xij
i=1 j=1
Xm
s.a. xij = 1, j = 1, . . . , n
i=1
Xn
xij ≤ nyi , i = 1, . . . , m
j=1
xij ∈ {0, 1} i = 1, . . . , m; j = 1, . . . , n
Luego, podemos hacer la búsqueda sólo en los y con función objetivo
m
X
f (y) = fi yi + g(y)
i=1
y la evaluación de esto es barata...
Uno de los problemas de “Simulated Annealing” es que puede visitar soluciones que ya ha visitado. El ideal
serı́a no volver a visitarlas para ser más eficiente.
Francisco Garcı́a y Jorge Vera 8.3. Tabu Search 165
8.3. Tabu Search

El procedimiento fue desarrollado por Fred Glover en los 70’s. Trata de resolver los problemas que presentan
los métodos anteriores, cuando hay riesgo de volver a una solución ya visitada. Para eso vamos a “prohibir”
visitar soluciones que ya han sido analizadas, para lo que guardamos una “Lista Tabú” Además, también
vamos a permitir ir a soluciones peores.
En algunos momentos vamos a cambiar completamente la estructura de las soluciones que se están analizando,
esto es diversificación. El algoritmo mantiene una lista, L, de soluciones “tabú”. De este modo, este
algoritmo escapa de los óptimos locales por medio de la aplicación de dos reglas básicas:
No repetir soluciones visitadas.
Seguir explorando aunque se empeore la solución actual.
Algoritmo de Tabú Search
Data: Sea x0 ∈ C, k = 0, L = {ø}.

Construir vecindad V xk
Elegir y solución de
mı́n f (x) : x ∈ V xk

if y ∈ L:
Elegir otro y:
f (y) < f xk , y ∈

/L
if no se puede encontrar y adecuado:
Aceptar y : f (y) > f xk con alguna probabilidad

Aplicar diversificación para generar un nuevo y

xk+1 = y, k = k + 1, L = L ∪ {y}
end
La construcción de V xk se hace, muchas veces, en forma aleatoria y la idea es que sea “simple” y rápido

de ejecutar, sin importar necesariamente llegar al óptimo pero si a alguna buena solución en un tiempo
decente. Notar que el procedimiento hace una optimización local. Uno de los aspectos claves es el largo de
la lista Tabú, el que se calibra usando simulación. Cuando se acepta una solución peor, se puede hacer “al
estilo Simmulated Annealing”, entre otras. La diversificación es una etapa importante, se trata de generar
un patrón de solución completamente diferente, es decir, “saltar” a otra región del espacio de búsqueda.
La Búsqueda Tabú ha tenido éxito aplicada a algunos problemas combinatoriales de gran tamaño, por
ejemplo, problemas de ruteo vehicular.
8.4. Algoritmos Genéticos

Un conjunto completo de métodos heurı́sticos se ha clasificado bajo el nombre de “Algoritmos Evolutivos”. La
idea es imitar procesos evolutivos o biológicos. Las jirafas tienen el cuello largo por qué la comida estaba alta
en los árboles y los individuos con cuellos largos se pudieron alimentar mejor y reproducir mejor, haciendo
que la generación posterior tuviera en mayor proporción el cuello más largo. Con mucho tiempo, el cuello
les creció más y más según el mismo argumento.
Los algoritmos genéticos trabajan sobre una población de soluciones. Replicando un proceso similar al de la
evolución de los seres vivos, el algoritmo reproduce, muta y selecciona a las soluciones más fuertes en busca
de mejores soluciones.
La primera etapa es codificar las soluciones factibles del problema en los siguientes elementos:
Una conjunto G de “genes”.
Cada solución factible del problema combinatorial es representada por un elemento (g1 , g2 , . . . , gp ),
donde gi ∈ G. Este es un “cromosoma”.
166 Capı́tulo 8. Heurı́sticas
Se define una función h (g1 , g2 , . . . , gp ), llamada “función de adaptación” (fitness function).
Las tres componentes básicas de un algoritmo genético son:
1. Selección: Se seleccionan dos soluciones dentro de la población para su reproducción. En esta selección
se debe aplicar un criterio de aptitud, de forma de que mejores soluciones tengan mayor probabilidad
de reproducirse.
2. Crossover: Se diseña un método para obtener a partir de dos soluciones una nueva solución, de forma
similar en la que los genes de dos individuos se combinan en un nuevo individuo.
Sean v = (v1 , . . . , vp ) ∈ Gp y w = (w1 , . . . , wp ) ∈ Gp dos cromosomas.
Elegir k ∈ {1, . . . , p} aleatoriamente.
Generamos dos nuevos individuos, v 0 y w0 :
a) v 0 = (w1 , . . . , wk , vk+1 , . . . , vp )
b) w0 = (v1 , . . . , vk , wk+1 , . . . , wp )
Conservamos los nuevos individuos si están “mejor adaptados”.
3. Mutación: Las nuevas soluciones son alteradas con cierta probabilidad, de forma de obtener nuevos
atributos y diversificar la búsqueda. Para esto se hace lo siguiente:
Sea v = (g1 , . . . , gp ) ∈ Gp un cromosoma.
Elegir j ∈ {1, . . . , p} aleatoriamente.
Reemplazar gj con g 0 ∈ G, g 0 6= gj .
Esto genera un nuevo individuo cuya “adaptabilidad” es evaluada usando h.
Si es mejor que el anterior, se conserva. Si no, se busca otra mutación.
Algoritmos Genéticos
Data: 0. Comenzar con una población U 0 ⊂ Gp .

Selección: Escoger aleatoriamente un conjunto B ⊂ U de individuos “mejor adaptados”, usando h.
Aplicar “operadores genéticos” a B para generar un nuevo conjunto B 0 con mejores individuos que
B:
Reproducción: aplicar crossover entre los padres para obtener hijos.
Mutación: perturbar, con cierta probabilidad baja, las soluciones hijo obtenidas.
Reemplazo: B 0 reemplaza a B en U .
end
En general, existe una componente aleatoria para seleccionar la población inicial y para elegir los individuos
para Crossovers y Mutación, dándole mayor probabilidad de elegirse aquellos que son mejor calificados por
la función de adaptabilidad. Para la función de adaptabilidad podrı́a usarse la función objetivo original, pero
también puede incluir una medida de satisfacción de restricciones, penalizando si estas no se respetan
Los AG se han aplicado exitosamente en algunos problemas relacionados a secuenciamiento (scheduling),

que son problemas combinatoriales.
Francisco Garcı́a y Jorge Vera 8.5. Comentarios Finales 167
8.4.1. Ejemplo: problema de localización

Tomemos nuevamente el problema de Localización y Asignación de clientes. Un Algoritmo Genético se
puede desarrollar de muchas formas diferentes. Notemos, que la codificación es ”natural a que tenemos 2
variables 0-1. Tomemos el mismo esquema para el problema que usamos en el ejemplo de Búsqueda Tabú:
El cromosoma es una solución y = (y1 , . . . , ym ) y los genes son los valores yi . Como función de adaptación
podemos tomar:
m
!
X
h(y) = − fi yi + g(y)
i=1
La población inicial se generar como un conjunto de “cromosomas”, en forma aleatoria, y luego, usar los
operadores de mutación y recombinación.
Por ejemplo, el una mutación de (1,1,1,0,0,1,0) puede consistir en lo siguiente:
Mutación{(1, 1, 1, 0, 0, 1, 0)} −→ (1, 0, 1, 0, 0, 1, 0)
Y una recombinación de (1,1,1,0,0,1,0) con (0,1,0,0,1,1,0) puede obtenerse mezclando las primeras tres del
primero y las útlimas cuatro del segundo:
Recombinación{(1, 1, 1, 0, 0, 1, 0), (0, 1, 0, 0, 1, 1, 0)} −→ (1, 1, 1, 0, 1, 1, 0)
8.5. Comentarios Finales

- ¿Cuál es la mejor heurı́stica para un problema?
- ... Depende....
El buen funcionamiento depende mucho de la calibración adecuada de parámetros. Pero hay mucha experiencia
práctica que sirve de guı́a. Por ejemplo, la Búsqueda Tabú ha sido muy buena en problemas “tipo” PVV,
ruteo de vehı́culos y relacionados. Existen gran cantidad de estudio teóricos sobre ciertos procedimientos
heurı́sitcos para saber qué tan buenos son. Un punto central: balance entre velocidad de resolución y calidad
de la solución.
Capı́tulo 9
Complejidad Computacional
¿Qué es más fácil? Ordenar una lista de números, resolver un problema de Programación Lineal. resolver un
Problema de Vendedor Viajero. ¿Cuánto esfuerzo requiere hacer cada una de estas cosas? ¿Esfuerzo medido
en qué? Este son el tipo de cosas que se plantean en Complejidad Computacional
En primer lugar, consideremos cómo se resuelve un problema Para resolver un problema usamos un algoritmo.
La dificultad de este tiene que ver con el número de iteraciones y/o el tiempo de computación. Por ejemplo
¿Cuántas iteraciones requiere una algoritmo para ordenar n números? Un algoritmo puede buscar el más
pequeño de todos, dejarlo al principio y en el los n − 1 números restantes buscar el más chico. Ası́, buscarı́a
n(n − 1)
n + (n + 1) + . . . =
2
Lo que es de orden O(n2 ) De todos modos, con algoritmos como binary sort algorithm se puede resolver
en nlog(n). Para otros problemas en cambio, como el de las Torres de Hanoi, se puede demostrar que no
se puede resolver en menos de O(n2 ) movidas. El objetivo de este es trasladar los discos desde la barra de
la izquierda a la de la derecha, usando la central como ayuda, sin colocar nunca sobre un disco, otro más
grande.
9.1. Cómo se mide la eficiencia

Intuición: número de “operaciones” necesarias hasta resolver el problema puede tomarse como una medida
de la eficiencia del algoritmo. Para comparar dos algoritmos: comparar número de operaciones sobre datos
equivalentes, o problemas del mismo “tamaño”.
IDEA: estimar o calcular el número de operaciones como función de algún parámetro relacionado al tamaño
del problema, por ejemplo la cantidad de argollas de Hanoi, el tamaño de una matriz. Cada instancia de un
problema tiene un tamaño particular. Denotemos por l el tamaño de una instancia de un problema.
9.2. Problemas Fáciles y Difı́ciles

Dado un problema y un algoritmo para resolverlo, diremos que ese algoritmo resuelve el problema en tiempo
polinomial si el número de operaciones que se requieren para una instancia de tamaño l está acotada por
arriba por p(l), donde p() es un polinomio (ej. p(l) = l30 ).
Diremos que un problema es resoluble en tiempo polinomial si existe un algoritmo tal que para cualquier
instancia del problema, la resuelve en tiempo polinomial.
Ası́, por ejemplo, se puede distinguir entre problemas como ordenar números, que es resoluble en tiempo
polinomial. A esto lo llamaremos un problema fácil. Las Torres de Hanoi, en cambio, no son de orden
polinomial, sino exponencial, por lo que se dice que son difı́ciles. ¿Y Programación Entera...? Problemas de
decisión v/s de optimización
En el contexto más correcto uno considera problemas de “decisión” más que de optimización. Un problema es
de decisión si las respuestas posibles son SI o NO. Ejemplo, consideremos un poliedro P = {x ∈ Rn : Ax ≤ b}
y un vector c.
168
Francisco Garcı́a y Jorge Vera 9.3. Clases de Complejidad 169
Problema de decisión: ¿Existe x ∈ P ? R: sı́ o no.

Problema de optimización: mı́n cT x : x ∈ P .

Lo interesante es que si sabemos resolver el problema de decisión, con algunas hipótesis adicionales podemos
optimizar. Por ejemplo, en el caso de Programación Lineal: Supongamos conocemos a, b : a ≤ cT x ≤ b, ∀x ∈
P . Dado P, c, α : ¿Existe x ∈ P tal que cT x ≤ α? Si tengo un algoritmo de decisión que me dice sı́ o no,
puedo optimizar. Si la respuesta es sı́, debo seguir buscando a la izquierda de α, en caso contrario a la
derecha. Ası́, voy buscando en intervalos cada vez más acotados. Esto es un problema de búsqueda binaria.
9.3. Clases de Complejidad

Definición: Se dice que un problema de decisión pertenece a la clase P (polinomial) si existe un algoritmo
que se detiene con SI o NO en un número de etapas acotado por p(l), donde l es el tamaño de la instancia
y p es un polinomio. Estos son las problemas “fáciles”.
Definición: Se dice que un problema de decisión pertenece a la clase NP (no determinı́stico polinomial) si
para una instancia de largo l, dada una posible solución al problema, es posible verificar si la respuesta es
SI o NO para esa solución en tiempo polinomial. En otras palabras: es posible verificar si un candidato a
solución dado es la respuesta correcta, en tiempo polinomial, pero esto no significa que pueda encontrar una
respuesta correcta en tiempo polinomial. Por lo tanto, fácil de verificar, no necesariamente fácil de encontrar.
Ejemplos de problemas NP:
El Problema de Vendedor Viajero
Programación Entera
El problema de la mochila
Si el problema es NP, ¿puedo dar una cota al esfuerzo máximo necesario para encontrar una solución
correcta? Por ejemplo, en Programación Entera: ¿existe x tal que Ax ≤ b, xj ∈ {0, 1}, j = 1, . . . , n?
Es NP dado x: 1) ¿Es 0-1? 2) Ax O(n2 ) 3) ≤ b? O(n2 ). Por lo tanto es O(n2 ).
Algoritmos: enumerar todas las combinaciones 0-1 y probar hasta dar con una “Sı́”. Esto es orden
O(2n )
. Esto es una cota superior, pues en el peor de los casos puedo encontrar una respuesta en orden O(2n ).
Aunque este sea un algoritmo tonto, pero es ası́.
Entonces, hay problema fáciles, en P. Hay problemas intratables, que requieren al menos tiempo exponencial.
Hay problemas que requieren a lo más, tiempo exponencial, en NP ¿Será posible que pueda resolver un
problema NP de manera fácil? La práctica parece indicar lo contrario.
Existe un subconjunto de los problemas en NP que son los más difı́ciles de entre todos.
Definición: Sean A y B dos problemas de decisión. A es polinomialmente reducible a B si existe una
transformación g evaluable en tiempo polinomial que transforma una instancia e de A en una instancia
e0 = g(e) de B y e es SI si y sólo si la respuesta de g(e) es SI. Ası́, si tengo un algoritmo para resolver B, y
puedo transformar A en B, puedo resolver con mi algoritmo A.
9.4. Los problemas NP-Completos

Definición: Un problema B en la clase NP se dice NP − Completo si cualquier problema A en NP se
puede reducir polinomialmente a B.
¿Qué pasa si descubro un algoritmo polinomial para un problema NP-completo? Podrı́a transformar todos
los problemas del conjunto NP − completo en este nuevo problema y resolverlos de manera polinomial.
Ası́ podrı́a resolver todos los problemas NP.
FOTO FOTO FOTO FOTO
Se conocen muchos problemas NP-completos:
El problema del vendedor viajero.
170 Capı́tulo 9. Complejidad Computacional
Corte máximo en un grafo (MAXCUT).

Conjunto Independiente en un grafo.
Programación entera en muchas de sus variantes.
El primer problema NP-completo fue identificado por Cook (1972). (SATISFABILIDAD). Después Held y
Karp [1972] identificaron otros.
De ahı́ en adelante muchos otros fueron identificados... Esto explica por qué a veces se observa tanto estudio
de los problemas que son NP-completos.
PREGUNTA: dado que P ⊂ NP, ¿qué será cierto: P = NP ó P 6= NP? Si fuera P = NP, entonces
significa que efectivamente existen algoritmos eficientes para problemas enteros y combinatoriales, aunque
hasta ahora no los hemos encontrado. Pero quizá no sea ası́. Es una pregunta que sigue abierta hasta hoy
Si la inclusión es estricta, entonces los problemas combinatoriales son, efectivamente, muy difı́ciles. http://www.
claymath.org/millennium/)
Algunos piensan que podrı́a ser un caso de problema “indecidible”. Hay muchas reglas de razonamiento para
llegar a concluir si algo es verdadero o falso en las matemáticas, lo que descansa en la lógica fundamental.
Rusell querı́a sistematizar toda las matemáticas y toda la lógica. Kurt Göedel, dijo que siempre hay
afirmaciones que no pueden ser demostradas como verdaderas o falsas, que es el teorema de incompletitud
o de indecidibilidad.
El concepto de ”tamaño”tiene un significado más preciso: es el número de sı́mbolos necesarios para codificar
el problema en el lenguaje adecuado: en este caso, número de bits (incluyendo signos y marcadores).
9.5. La complejidad de Programación Lineal

Los problemas de Programación Lineal se resuelven habitualmente usando el método Simplex. El resultado
de 1972 de V. Klee y G. Minty es una caso de una instancia de problema de programación lineal en n
variables para la cual el método SIMPLEX (con varios criterios conocidos de selección de variables) requiere
realizar 2n pivotes. El Método Simplex no es polinomial, pero eso no significa que no haya otro algoritmo
más eficiente.
La pregunta sobre la complejidad de P.L. permaneció abierta hasta 1979: Leonid Khachiyan presentó un
algoritmo aplicable a P.L. que corrı́a en tiempo polinomial: Método de las Elipsoides, con un origen
anterior: Shor, Nemirovski y Yudin en los 70. El problema es que en la práctica, era muy lento.
Lo curioso es que el Simplex es teóricamente ineficiente, pero en la práctica es igual más eficiente, lo cuál es
aún es una pregunta abierta entender por qué el método SIMPLEX, pese a ser ineficiente en el peor caso,
se comporta muy bien “en promedio”. Un comportamiento “promedio”: O máx{m, n}2 pivotes para llegar
al óptimo. Pero la última palabra en polinomialidad para P.L. no estaba dicha.
1984: N. Karmarkar presentó un nuevo algoritmo que también era polinomial para programación lineal. El
método presentado era un Algoritmo de Punto Interior. Estos provee un método “teórico” polinomial para
resolver P.L. pero, además, son eficientes en la práctica.
Capı́tulo 10
Algoritmos de Punto Interior
Los Algoritmos de Punto Interior son uno de los desarrollos más importantes en optimización, tanto desde
un punto de vista teórico como practico. En este capı́tulo revisaremos los conceptos fundamentales y la
forma en que se usan. En sus orı́genes, los algoritmos de punto interior fueron desarrollos para abordar
problemas de programación lineal pero fueron extendidos al caso no lineal, convexo, de una manera tal
que la eficiencia se mantiene muy alta. Esto abrió enormes oportunidades al poder abordarse modelos de
optimización que, hasta esos momentos, no podı́an ser resueltos en forma eficiente. Si bien los desarrollos
en este tema ocurrieron entre la segunda mitad de los 1980 y durante la década de 1990, estos mantienen
su vigencia hasta el dı́a de hoy gracias a implementaciones computacional muy eficientes y disponibles en el
software habitual.
10.1. El algoritmo de Barrera

Para introducir el concepto, consideremos el siguiente problema de Programación Lineal:
z ∗ = mı́n cT x
s.a. Ax ≤ b
donde A es m × n y de rango completo. Sean α1 , . . . , αm las filas de A. Sea x∗ solución óptima.

Como sabemos muy bien, este problema puede ser resuelto mediante el algoritmo Simplex. Sin embargo, este
algoritmo se mueve por los vértices del poliedro definido por Ax ≤ b, es decir, por la frontera. Suena muy
natural tratar de avanzar por un “atajo”, es decir, por el interior del poliedro. Necesitamos operacionalizar
esto y para eso vamos a construir una función matemática que nos garantice estar en el interior y nos aleje
de la frontera del poliedro. Para hacer esto vamos a definir una “función de barrera” (logarı́tmica) para
movernos dentro del poliedro. Sea
m
X
Φ(x) = − log bi − αiT x

i=1
Podemos ver que la función evalúa la holgura de un punto x con respecto a las restricciones, pero asumiendo
que estas se cumplen. Claramente no es posible cumplir alguna de las desigualdades con igualdad ya que, en
ese caso, la función queda indefinida. Por otro lado, si el punto x está en el interior del poliedro, pero muy
cerca de la frontera, es decir, que para algún ı́ndice i, bi ≈ αiT x, entonces sucede que:
lı́m − log bi − αiT x → lı́m − log (δ) → ∞

bi →αT
i
x δ→0
En otras palabras, la función está definida sólo en el interior del poliedro definido por Ax ≤ b y cuando el
punto x se aproxima a la frontera, es decir, a las “caras” del poliedro desde adentro, los valores de Φ se hace
cada vez más grandes. De este modo, Φ actúa como “barrera”: no podemos salir del poliedro y resulta muy
malo (en términos de valores altos de Φ) estar cerca de la frontera.
171
172 Capı́tulo 10. Algoritmos de Punto Interior
Ahora vamos a usar la función de barrera junto con el problema de optimización original. Sea µ > 0, Se
define el siguiente problema:
Pµ ) mı́n cT x + µΦ(x)
s.a. Ax < b
La primera observación que haremos es que no se necesitan las restricciones, pues Ax ≤ b se va a cumplir
debido a que la misma barrera logarı́tmica no va a permitir que se esté afuera de este poliedro. Entonces, el
problema es, realmente:
Notemos que si µ es muy grande, en términos de escala relativa, µΦ(x) es el término principal en la función
objetivo, por lo tanto el problema es, básicamente, minimizar la función Φ Esto dará como resultado un
punto bastante “al medio” del poliedro.
Por otro lado, si µ toma un valor ya no tan grande, la información de la función objetivo original, cT x,
comienza a tomar peso frente a µΦ(x). La solución, en ese caso, estará “menos al medio” y posicionada más
en dirección a donde está la solución óptima del problema.
Si µ es muy chico, el peso de la barrera será mucho menor y hará que la solución del problema esté muy cerca
del óptimo x∗ . Notemos, sin embargo, que aunque esté disminuida, la barrera está presente y nos impedirá
tocar la frontera del poliedro. La figura ilustra las distintas soluciones que se obtienen según el valor de µ.
La discusión anterior sugiere el algoritmo que presentamos a continuación. Para lo que sigue, vamos a definir:
f (x, µ) = cT x + µΦ(x)
Algoritmo de Barrera Logarı́tmica
Data: x0 : Ax0 < b, µ0 > 0.

Resolver aproximadamente mı́n x∈Rn f (x, µk ) usando xk como punto de partida.
Sea xk+1 esa solución aproximada.
Actualizar µk a µk+1 < µk .
k ←k+1
end
El algoritmo presentado requiere, por supuesto, un punto de partida. Más adelante discutiremos cómo
obtenerlo. También comentaremos sobre el criterio de parada. Notemos que el problema mı́nx∈Rn f (x, µk ) se
resuelve en forma aproximada. Eso tiene que ser ası́, habitualmente nunca podremos encontrar una solución
exacta dada la no linealidad de la función de barrera. Un método iterativo tendrá que ser usado para eso y
tendrá que usar un punto de partida. Por eso se establece usar la iteración actual como punto de partida.
Notemos que la lógica del algoritmo se basa en la discusión anterior: se propone partir de algún valor para
el parámetro µ u sucesivamente disminuirlo para que el término cT x vaya tomando más importancia y la
solución que se obtenga vaya aproximándose a x∗ .
Una forma de ir definiendo la sucesión de parámetros de penalización µk es µk+1 = βµk , 0 < β < 1, con
µ0 > 0 dado.
Ahora concentrémonos en la forma de resolver el problema Pµk ).
Pµk ) mı́nn cT x + µk Φ(x)

x∈R
Es fácil ver que la función cT x + µk Φ(x) es estrictamente convexa y tiene todas las propiedades necesarias
para resolverlas con la baterı́a de herramientas mostradas en los capı́tulos anteriores. Particularmente, para
resolver el problema penalizado usaremos el método de Newton, para lo cual necesitamos calcular tanto el
gradiente como el Hessiano de f .
Derivando la función objetivo tenemos:
Francisco Garcı́a y Jorge Vera 10.1. El algoritmo de Barrera 173
∂ ∂
f (x, µ) = cj + µ Φ(x)
∂xj ∂xj
m
X αij
= cj + µ
b − αiT x
i=1 i
Sea e = [1, 1, . . . , 1, 1]T ∈ Rm y
D(x) = diag b1 − α1T x, . . . , bm − αm

T

x
donde diag (u1 , . . . , un ) una matrix diagonal con u1 , . . . , un en la diagonal.

Entonces el gradiente de la función objetivo, lo podemos escribir como:
∇f (x, µ) = c + µAT D(x)−1 e
De forma similar se calcula el Hessiano:
∇2 f (x, µ) = µAT D(x)−2 A

−1
La dirección de Newton es d = − ∇2 f (x, µ) ∇f (x, µ). En este caso:

1 T −1
d=− A D(x)−2 A c + µAT D(x)−1 e

µ
Con esta dirección usamos el método de Newton para resolver aproximadamente Pµ .
De esta manera, hemos definido un algoritmo general que resuelve una sucesión de problemas penalizados
generando una secuencia de puntos que tratan de seguir una “trayectoria central”. La Trayectoria Central
del poliedro es el conjunto de soluciones óptimas del problema
Pµ ) mı́nn cT x + µΦ(x)

x∈R
cuando µ varı́a. Mas especı́ficamente, denotemos por x(µ) la solución óptima de ese problema, para un µ
dado. La trayectoria central es el conjunto
CP = {x(µ) : µ > 0}
Esta conjunto corresponde a la trayectoria indicada por la lı́nea roja en la figura.
Como no podemos resolver el problema Pµ ) en forma exacta, sólo seguimos la trayectoria en forma aproximada.
Si se eligen adecuadamente el valor inicial de µ ası́ como la tasa a la cual decrece, β, es posible hacer que
este algoritmo funcione en forma muy eficiente, como indicamos a continuación.
10.2. Convergencia del algoritmo y complejidad

Como indicábamos, el parámetro de penalización se cambia como µk+1 = βµk , 0 < β < 1 adecuado. El
análisis teórico detallado permite concluir que basta hacer una sola iteración del Método de Newton
para mantener la cercanı́a adecuada a la trayectoria central. En particular, si se quiere encontrar una solución
con una diferencia de a lo más > 0 con el valor óptimo, se puede mostrar que basta:
√ 1

k=O m log

iteraciones principales para lograr ese objetivo.
¿Y cuánto es el costo por iteración? Volviendo a las fórmulas del gradiente y, especialmente, el Hessiano,
vemos que en cada iteración es necesario construir la matriz AT D(x)−2 A y calcular su inversa. Esta matriz
cambia completamente en cada iteración, ası́ que el costo numérico debe invertirse en cada iteración principal
y es O(m2 + n3 ). Esto puede ser muy grande, si m y n son grandes. Un tema sorprendente, respecto al
comportamiento del los algoritmos de punto interior, es que el número total de iteraciones no suele ser
excesivamente grande (en general entre 30 y 60).
Desde luego, querrı́amos comparar esto con lo que hace el Algoritmo Simplex. Para comenzar, es necesario
recordar que el Simplex podrı́a llegar a ser, en el peor de los casos, un algoritmo de complejidad exponencial
en n, aunque en la práctica eso no suele ocurrir. Aún ası́, el número de iteraciones del Simplex en un problema
grande puede ser realmente enorme. Esto significa que, eventualmente, aún con el alto costo computacional
por iteración, un algoritmo de punto interior podrı́a tardar menos tiempo.
10.3. Los métodos interiores prácticos

Lo que hemos comentado en la sección anterior es un método de punto interior en versión ”simple”. La
implementación práctica es algo diferente y la comentamos brevemente ahora. El desarrollo se aplica a un
problema en forma estándar:
z ∗ = mı́n cT x
s.a. Ax = b, x ≥ 0
definiremos la siguiente función de barrera para este problema:
n
X
Φ(x) = − log(xj )
j=1
est función tendrá las mismas propiedades que la que habı́amos mostrado. Acá debe entender el “interior”
como el interior relativo a la restricción Ax = b. De este modo, nos interesa mantener xj > 0, pero cumplir
siempre la restricción de igualdad. El problema penalizado es:
mı́n cT x + µΦ(x)
Pµ )
s.a. Ax = b
Vamos a analizar las condiciones de optimalidad de este problema. Para eso tenermos que construir el
correspondiente Lagrangiano:
n
X
L(x, π) = cT x − µ log(xj ) + π T (Ax − b)
j=1
Derivando este Lagrangeano se llega a:

1/x1

∇x L(x, π) = c − µ  ...  + AT π
 
1/xn
Luego, las condiciones KKT para este problema son:
Ax = b
AT π − µD(x)−1 e = c
Francisco Garcı́a y Jorge Vera 10.4. Algoritmos interiores: el caso general no lineal 175
donde D(x) es la matriz diagonal con elementos diagonales iguales a los xj . Este es un sistema no lineal de
ecuaciones pero se puede resolver, en forma aproximada, mediante el método de Newton “en modo ecuación”,
o, equivalentemente, planteando el problema:

Ax − b
mı́n
x,π AT π − µD(x)−1 e − c
Lo anterior permite obtener soluciones aproximadas x y π, tanto en el primal como en el dual. El argumento
teórico de convergencia permite llegar a la conclusión de que la complejidad del método resulta en
√ 1

O n log

Este tipo de algoritmo se conoce como un método Primal-Dual ya que obtiene, simultáneamente, soluciones
tanto para el problema primal como para el problema dual. Notemos que, dada la forma en que se aproximan
las soluciones, en cada iteración tenemos soluciones factibles, tanto en el primal como en el dual, pero no
cumplimos con las condiciones de holguras complementarias. Entonces, mediante un argumento de dualidad
débil podemos tener una estimación precisa del error en una iteración.
Resolver el problema de esta forma permite un avance más estable de las iteraciones, en comparación
con el algoritmo simple básico que introdujimos al comienzo. Esto es, de hecho, el método real que está
implementado en software como CPLEX o Gurobi.
10.4. Algoritmos interiores: el caso general no lineal

Consideremos el siguiente problema con un conjunto S, convexo, cerrado y acotado:
mı́n cT x
s.a. x∈S
(“int” denota interior) Observemos que siempre podemos asumir la función objetivo lineal. Si no lo es, puede
“pasarse” al conjunto S. Vamos a definir lo que es una función de barrera para este caso general. Definimos
una función estrictamente convexa Φ : int(S) → R tal que Φ(x) → ∞ cuando x se acerca a la frontera de S
desde adentro. De este modo, le pedimos a esta función Φ propiedades análogas a las que tenı́a la función
de barrera logarı́tmica en el caso del problema de programación lineal.
Para un valor µ > 0 definimos el problema penalizado:
s.a. x ∈ int(S)
Por las caracterı́sticas de Φ, podemos obviar la restricción x ∈ int(S), tal como en el caso lineal. Sea
f (x, µ) = cT x + µΦ(x). Suponiendo que podamos calcular ∇f (x, µ) y ∇2 f (x, µ), podemos plantear el
siguiente algoritmo:
Algoritmo de Barrera General
Data: Sea x0 ∈ int(S), k = 0, µ0 > 0, 0 < β < 1.

Usar el método de Newton, con xk como punto inicial, para resolver aproximadamente Pµk ):
mı́n f (x, µk ) = mı́n cT x + µk Φ(x)

sea xk+1 la solución aproximada.

µk+1 = βµk , k = k + 1.
end
Al igual que en el caso lineal, esto trata de seguir una trayectoria central por el interior de S.
La pregunta central aquı́ es cuál es la función de barrera apropiada, y eso depende de cada conjunto S, pero
la elección de la función de barrera, según el conjunto S, debe permitir que el método de Newton funcione
eficientemente. Si eso es ası́, se puede obtener convergencia lineal.
Uno de los desarrollos más significativos en Optimización es de los años 1990 en el que Yuri Nesterov y Arkadi
Nemirovski identificaron toda una clase de funciones que pueden usarse de barreras, según el conjunto S, y
para las cuales el funcionamiento del algoritmo es eficiente. Esas funciones tienen una propiedad matemática
(que no detallaremos) que se conoce como “autoconcordancia” (self-concordance). Sı́ vamos a destacar que
la clave del análisis es que en todas las iteraciones vamos a medir distancias con una norma especial que se
define a partir del Hessiano H(x, µ) = ∇2 f (x, µ). Se define, entonces, la siguiente norma “local” en x :
q
kukH(x,µ) = uT H(x, µ)u
Esta no es una norma euclidiana (Salvo si H fuera la identidad), y dependedel punto x donde estamos. La
siguiente propiedad es muy interesante: Sea x ∈ int(S) y sea BH (x, 1) = y : kx − ykH(x,µ) ≤ 1 , la bola
unitaria (en la norma local) en torno a x. Entonces:
BH (x, 1) ⊂ int(S), para todo x ∈ S
Es decir, cualquier bola de radio 1 (en la norma local) está en el interior de S. Esto parece complemente no
intuitivo pero hay que recordar que estamos viendo la geometrı́a con una norma que cambia constantemente.
Lo que esto hace es introducir una geometrı́a de Riemann, como se les conoce, en el conjunto S y la
regularidad que induce esta geometrı́a hace que el Método de Newton tengo el mejor comportamiento
posible.
10.5. Convergencia del algoritmo

Usando las propiedades anteriores se puede mostrar que basta una iteración del Método del Newton en el
problema Pµk ) para tener una solución xk suficientemente aproximada, medido en la ”norma local”. Más
aún también se puede mostrar que
cT xk − z ∗ ≤ ϑµk
donde ϑ es un parámetro que depende únicamente de las caracterı́sticas de la función de barrera. En el caso
lineal Ax ≤ b con m restricciones, se tiene ϑ = m
Entonces, como µk = µ0 β k , se tiene:
cT xk − z ∗ ≤ ϑµ0 β k
Finalmente se deduce que si se quiere encontrar una solución con una diferencia de a lo más > 0 con el
valor óptimo, basta un número de iteraciones del orden de:
√ 1

k=O ϑ log

Entonces, los algoritmos de punto interior conservan, en el caso general, el buen comportamiento que tienen
en el caso lineal. Ahora bien, qué tipos de problemas no lineales podrı́an ser abordados con estos métodos
lo presentaremos en la próxima sección.
10.6. Elementos básicos de Optimización Cónica

El siguiente es un problema lineal cónico:
mı́n cT x
s.a. Ax = b
x∈K
donde K es un cono convexo. Recordemos que K es cono convexo si es convexo y x ∈ K ⇒ λx ∈ K, λ ≥ 0.

Los siguientes son ejemplos de conos, de particular importancia:
Rn+ = {x ∈ Rn : x ≥ 0}. Este es el cono que aparecerá en el problema de programación lineal en forma
estándar. Es decir, PL es un caso particular de problema cónico.
Francisco Garcı́a y Jorge Vera 10.7. Ejemplos de problemas cónicos 177
Qn+1 = {(x, t) : x ∈ Rn , t ∈ R y kxk2 ≤ t}, el Cono de Segundo Orden o Cono de Lorenz en n + 1

dimensiones. Veremos que es particularmente importante para modelar algunos problema no lineales.
n×n
S+ = {X ∈ Rn×n : X es simétrica y semidefinida positiva }. Este cono también es de gran importancia
en desarrollo modernos de optimización, mostraremos un ejemplo más adelante.
Miremos bien el cono Qn+1 = {(x, t) : x ∈ Rn , t ∈ R y kxk2 ≤ t}, el Cono de Segundo Orden.
v
u n 2
uX
kxk2 ≤ t ⇐⇒ t xj ≤ t
j=1
La forma de este cono es la que muestra la figura:
Figura 10.1: Fuente: Static Limit Analysis of Reinforced Soil Structures by a Simple Finite Element and
Second-Order Cone Programming, http://dx.doi.org/10.1590/1679-78253745, CCBY4.0
Para cada uno de esos conos hay una función de barrera con buenas propiedades. En particular, para el cono
Rn+ la barrera es, simplemente:
Xn
Φ(x) = − log xj
j=1
Para los otros conos, explicaremos las barreras en los ejemplos. El punto clave acá es que hay problemas que
se pueden formatear como problemas de Optimización Cónica.
Cápsula de video 10.6.1: Optimización Cónica
profesor Jorge Vera explica en clases elementos básicos de Optimización Cónica y algunos ejemplos.
https: // youtu. be/ 3c27xb2zHdE
10.7. Ejemplos de problemas cónicos

10.7.1. Ejemplo 1: proyección de un punto en un poliedro
Consideremos el poliedro P = {x ∈ Rn : Ax ≤ b}. Sea u ∈ Rn dado. Queremos encontrar el punto en P más
cercano a u en norma euclidiana. Esto se encuentra resolviendo:
mı́n kx − uk2
s.a. Ax ≤ b
Esto puede ser resuelto con algún método de primer orden proyectado o con el algoritmo de Frank-Wolfe,
pero también se puede usar un algoritmo de Punto Interior, pero para esto hay que hacerle una serie de
transformaciones. El problema anterior es equivalente a:
mı́n t |vk2 ≤ t es un cono mı́n t

mı́n t
que s.a. Ax ≤ b de segundo orden s.a. Ax ≤ b
s.a. Ax ≤ b
equivale a v =x−u entonces se puede v =x−u
kx − uk2 ≤ t
kvk2 ≤ t reescribir como (v, t) ∈ Qn+1
Este es un problema lineal con restricciones cónicas: restricciones de Cono de Segundo Orden. Este problema
se conoce como SOCP: ”Second Order Cone Problem”. El problema anterior se resuelve con un algoritmo
de punto interior usando la siguiente función de barrera para el cono:
Φ(x, t) = − log t2 − kvk22

Esto es como que se tomara la restricción que vincula a las t y a kvk2 , pero elevado al cuadrado, cosa que es
importante ya que eso garantiza que la barrera sea autoconcordante. De este modo, el problema penalizado
es:
m
!
X
mı́n t − µ log t − 2
kvk22 + log bi − αiT x

i=1
s.a. v = x − u
donde α1 , . . . , αm son las filas de A. Gurobi y CPLEX pueden resolver un problema de esta forma, al igual
que otros sistemas de software que implementan algoritmos de punto interior para problemas cónicos.
10.7.2. Ejemplo 2: Support Vector Machine (SVM)

Un problema importante en Machine Learning es el de poder distinguir comportamientos de observaciones.
Por ejemplo, supongamos que en un hospital hemos estudiado a personas que llegan al servicio de urgencias
y que tienen una serie de sı́ntomas y caracterı́sticas, que se miden al ingresar ( esto se conoce como “Triage”).
Algunas de esas personas han sido atendidas y dadas de alta inmediatamente después, pero otras tuvieron
que ser admitidas al hospital después de urgencia. Nos interesa saber si alguien tendrá que ser hospitalizado,
para poder preparar unidades médicas, camas, etc. De este modo, el objetivo es: a partir de la información
anterior, inferir una “fórmula” que permita anticipar si los nuevos pacientes que llegan a urgencia y sean
evaluados en el traige, requerirán o no hospitalización. Supongamos que tenemos:
n variables que puedo observar y medir.
Hay una propiedad que quiero discriminar (por ejemplo, “alta” u “hospitalización”).
Tenemos r observaciones de esas n variables y que corresponden a “alta”.
Tenemos q observaciones de esas n variables y que corresponden a “hospitalizacı́ón”.
Sea u1 , . . . , ur vectores en Rn que corresponden a “alta”.
Sea v 1 , . . . , v q vectores en Rn que corresponden a “hospitalizacı́ón”.
Si pudiéramos visualizar en el espacio de n dimensiones para ver como se comportan los datos. Por ejemplo,
si las variables son edad y temperatura corporal, podrı́a tenerse una situación como la de la Figura 10.2.
Se puede notar que existe una lı́nea recta que separa estos dos puntos y serı́a ideal poder encontrar la ecuación
de esta lı́nea de modo que separa lo mejor posible, para ası́ poder discriminar entre todos los datos. Por
supuesto, cuando hay muchas variables, este es un problema multidimensional de encontrar un hiperplano
que separe dos nubes de puntos. La separación deberı́a ser tal que el separado esté lo más “equidistante”
posible de ambas nubes.
Recordemos que un hiperplano tiene esta forma: Hα,β = x ∈ Rn : αT x = β , donde α ∈ Rn , β ∈ R.

Necesitamos también la distancia de un punto al hiperplano. Si x̄ ∈ Rn , la distancia hasta el hiperplano es:
αT x̄ − β
dist (x̄, Hα,β ) =
kαk2
Figura 10.2: Ejemplos donde se distingue un comportamiento en urgencias y se

puede establecer un lı́mite separador
Entonces, buscamos un hiperplano Hα,β que maximice la menor distancia a ambas nubes de puntos. Es
decir, queremos resolver el siguiente problema:
máx γ
s.a. dist ui , Hα,β ≥ γ, i = 1, . . . , r

dist v j , Hα,β ≥ γ, j = 1, . . . , q

α ∈ Rn , β ∈ R
El problema anterior, en forma más explı́cita:
máx γ
αT ui − β máx γ
s.a. ≥ γ, i = 1, . . . , r Imponemoskαk2 = 1
kαk2 s.a. αT ui − β ≥ γ, i = 1, . . . , r
para normalizar.
αT v j − β Ası́, el problema es: β − αT v j ≥ γ, j = 1, . . . , q
≥ γ, j = 1, . . . , q
kαk2 kαk2 = 1
α ∈ Rn , β ∈ R
Notar que hemos impuesto arbitrariamente un “lado” al hiperplano (y estamos asumiendo que las nubes
no se intersectan), por lo que el valor absoluto se toma en el caso que corresponde y en las restricciones 1
y 2 una es el negativo de la otra. Este problema NO es convexo, debido a la restricción kαk2 = 1. Pero si
dividimos por γ y reemplazamos:
α β kαk 1
z= , δ= Lo que a su vez significa que: kzk = =
γ γ γ γ
De este modo, podemos notar que maximizar γ equivale a minimizar la norma euclidiana de z. Ası́, el
problema equivalente es:
mı́n kzk2
s.a. z T ui − δ ≥ 1, i = 1, . . . , r
δ − z T v j ≥ 1, j = 1, . . . , q
z ∈ Rn , δ ∈ R
Este problema sı́ es convexo, y puede adapatarse al formato de Cono de Segundo Orden. Ası́, el problema
se transforma en:
mı́n t mı́n t
s.a. z T ui − δ ≥ 1, i = 1, . . . , r s.a. z T ui − δ ≥ 1, i = 1, . . . , r
δ − z T v j ≥ 1, j = 1, . . . , q Que es equivalente a: δ − z T v j ≥ 1, j = 1, . . . , q
kzk2 ≤ t (z, t) ∈ Qn+1
z ∈ Rn , δ ∈ R, t ≥ 0 z ∈ Rn , δ ∈ R, t ≥ 0
donde hemos hecho explı́cita la restricción cónica.

Este problema es importante en Machine Learning donde se conoce como Support Vector Machine (SVM)
y se usa ampliamente en análisis de datos de gran tamaño.
Si las nubes no están estrictamente separadas, pero aun ası́ se pueden separar en dos clusters se busca un
rango de hiperplano que vayan por la zona donde se mezclan las nubes (Figura 10.3). Un caso nuevo que
está dentro de los dos hiperplanos simplemente es difı́cil de decidir, se produce una zona. Si la zona es muy
ancha, entonces no se puede discriminar tan bien.
Figura 10.3: Distinción de “hospitalizados” y “alta” por clusters
Si la separación no puede ser lineal pero sı́ “curva”, se le aplica una transofrmación (llamada Kernel) de los
datos de modo de llevarlos a una nueva dimención donde se puedan separar linealmente. En caso de que
una clase de datos se concentren en el centro y la otra afuera, tal como sucede con el primer cuadro de la
Figura 10.4, se puede aplicar la función f (x, y) = x2 + y 2 , lo que lleva a los puntos más lejanos del centro
a estar más “altos” en una nueva tercera dimención (segundo y tercer gráfico de la Figura 10.4) y ahı́ se
pueden separar con un hiperplano, de modo de obtener finalmente la separación deseada (último cuadro de
la Figura 10.4).
Figura 10.4: Distinción de “hospitalizados” y “alta” por clusters no lineales

10.7.3. Ejemplo 3: Cono de matrices semidefinidas positivas

Tengo m puntos en Rn , c1 , . . . , cm . Estos pueden ser el resultado de muchas observaciones de n variables
que interesa estudiar. Queremos saber si hay “tendencias” en los datos: encontrar lo que se conoce como
las “Componentes Principales”. Supongamos que tenemos datos que, al graficarlos, se ven como muestra la
figura:
Figura 10.5: Fuente: www.wikipedia.com, CCBY4.0
Claramente hay una correlación entre las dos variables pero si sólo hacemos una regresión lineal, se pierde la
información de lo que sucede en la dirección ortogonal. Por otro lado, se puede pensar en buscar la elipse de
menor volumen que encierra los puntos. Los ejes principales de esa elipse son las “componentes principales”
de los datos. Entonces, el problema que queremos resolver es encontrar un elipsoide de mı́nimo volumen que
contenga todos los puntos. recordemos que un Elipsoide se define como:
Ell(R, z) = x ∈ Rn : (x − z)T R(x − z) ≤ 1

queda determinada por el centro z y la matriz R, que tiene que ser simétrica y definida positiva. El problema
se puede plantear como:
mı́n Vol(Ell(R, z)) mı́n Vol(Ell(R, z))

(R,z) (R,z)
Que es lo T
s.a. ci ∈ Ell(R, z), i = 1, . . . , m s.a. ci − z R ci − z ≤ 1, i = 1, . . . , m

mismo que:
n×n
R ∈ S+ , z ∈ Rn n×n
R ∈ S+ , z ∈ Rn
Esto último tiene una expresión cuadrática que tiene una forma que puede ser colocada en el formato de
cono de segundo orden.
Por otro lado,
π n/2
Vol(Ell(R, z)) = det(R)−1/2
Γ n2 + 1
Entonces, minimizar Vol(Ell(R, z)) es lo mismo que minimizar − log(det(R)) (Notar que el resto es una
constante) y esa función es fácil de manejar (de hecho, se conocen expresiones para su gradiente y Hessiano,
pero no profundizaremos en esto). El problema es, entonces:
mı́n − log(det(R))
(R,z)
T
s.a. ci − z R ci − z ≤ 1, i = 1, . . . , m

n×n
R ∈ S+ , z ∈ Rn
Para el cono de matrices semidefinidas, R ∈ S+

n×n
, es habitual usar la notación R 0, ası́ que el problema
se puede también escribir como:
mı́n − log(det(R))
(R,z)
T
s.a. ci − z R ci − z ≤ 1, i = 1, . . . , m

R 0, z ∈ Rn
T
Las restricciones ci − z R ci − z ≤ 1 se pueden transformar en cónicas más lineales haciendo: (v, 1) ∈

Qn+1 , v = U (x − ci ), donde U ∈ Rn×n es tal que U T U = R.

Esto es lo que se conoce como un problema de Programación Semi-definida o SDP (Semi-definite Programming)
y puede ser abordado con algoritmos de punto interior. La pregunta es cuál es la barrera que se debe usar
para el cono S+ n×n
de matrices simétricas y definidas positivas.
Sean λ1 , . . . , λn los valores propios de R. R es d.p. si y sólo si λi > 0, i = 1, . . . , n. Entonces, la barrera
natural es:
n
X
Φ(R) = − log λi = − log det(R)
i=1
Se puede mostrar que esta función Φ es estrictamente convexa y se conocen su gradiente y Hessiano. Además,
es una barrera autoconcordante y permite que el algoritmo funcione muy eficientemente.
10.7.4. Ejemplo 4: Restricciones cuadráticas

Supongamos que en un problema de optimización aparece una restricción de la forma
xT Qx + dT x ≤ α
donde Q ∈ Rn×n es simétrica y definida positiva, d ∈ Rn y α es un escalar. En estas condiciones, la restricción
anterior define una región convexa en el espacio Rn . Vamos a mostrar como transformar esta expresión en
una que permite visualizar restricciones de cono de segundo orden.
Esto se puede hacer considerando que, como Q es definidia positiva, existe R, invertible tal que RT R = Q.
Este R puede venir, por ejemplo, de la Descomposición de Cholesky, pero también de la diagonalización de
la matriz Q. Lo que aquı́ hay que hacer es “completar el cuadrado” en la expresión de la izquierda. Esto
lleva a la siguiente formulación:
1 1
xT Rx + (1 + dT x − α)2 ≤ (1 − dT x + α)2
4 4
lo que equivale a:
1 1
r
xT Rx + (1 + dT x − α)2 ≤ (1 − dT x + α)
4 2
y que significa que
1 1

Rx, (1 + dT x − α), (1 − dT x + α) ∈ Qn+2
2 2
que es la expresión de Cono de Segundo Orden que necesitamos, y que se puede poner más simplificada
como:
((Rx, s), t) ∈ Qn+2
1
(1 + dT x − α) = s
2
1
(1 − dT x + α) = t
2
10.7.5. Ejemplo 5: Distancias con nomas “no euclideanas”

Considere el siguiente problema de optimización, que busca determinar los puntos más cercanos en dos
poliedros, pero donde la cercanı́a se mide en una norma no euclideana (obviamente, si los poliedros se
intersectan el valor óptimo es 0):
mı́n kx − ykQ
s.a. Ax = b
By = d
x≥0
y≥0
donde kukQ = uT Qu, con Q ∈ Rn×n simétrica y definida positiva. Además, se tiene que A ∈ Rm×n , b ∈
p
Rm , B ∈ Rp×n , d ∈ Rp . Este problema se puede resolver con algoritmos de punto interior en formulaciones
cónicas.
Primero vamos a reformular el problema anterior como otro de optimización lineal cónica (es decir, la función
objetivo debe ser lineal y las restricciones lineales y/o cónicas.) Tenemos que el problema equivale a:
mı́n t
s.a. kx − ykQ ≤ t
Ax = b
By = d
x≥0
y≥0
Ahora, tenemos que kx−ykQ = u(x − y)T Q(x − y). Por otro lado, como Q es d.p., se tiene que Q = M T M ,
p
donde M es también d.p. Entonces;

q q
kx − ykQ = (x − y)T Q(x − y) = (x − y)T M T M (x − y) = kM (x − y)k2
Luego, la formulación es:

mı́n t
s.a. kM (x − y)k2 ≤ t
Ax = b
By = d
x≥0
y≥0
mı́n t
s.a. Ax = b
By = d
x≥0
y≥0
(M (x − y), t) ∈ K n+1
donde K n+1 denota el cono de segundo orden. Una formulación más “limpia” serı́a la siguiente:
mı́n t
s.a. Ax = b
By = d
z = M (x − y)
x≥0
y≥0
(z, t) ∈ K n+1
¿Cuál será la barrera que se debe usar? La barrera se aplica a las desigualdades y conos, en este caso es:
 
 X n Xn 
Φ(x) = − log(t2 − z T z) + log xj + log yj
 
j=1 j=1
10.7.6. Ejemplo 6: Desigualdades lineales de matrices (Linear Matrix Inequalities)

Sean A0 , A1 , . . . , Ar matrices de Rp×p simétricas (sólo simétricas). Definamos
n
X
B(x) = A0 + Ai x i
i=1
para x ∈ Rn . B(x) es, claramente, simétrica. Queremos determinar si acaso existe un vector x tal que la
matriz B(x) sea semidefinida positiva, y en ese caso, queremos obtener el x con menor norma euclideana
que cumpla esa condición.
El modelo de optimización que resuelve el problema serı́a:
mı́n kxk2
n
B = A0 +
P
s.a. Ai x i
i=1
B0
donde B 0 denota pertenencia al cono de matrices simétricas y semidefinidas positivas.

Ahora, este problema puede ser transformado en:
mı́n t
n
B = A0 +
P
s.a. Ai x i
i=1
kxk2 ≤ t
B0
que se escribe, en forma cónica:

mı́n t
n
B = A0 +
P
s.a. Ai x i
i=1
(x, t) ∈ K n+1
B0
donde K n+1 denota el cono de segundo orden.
Ahora mostremos cuál es la barrera asociada a este problema. Como siempre, la barrera se aplica a los conos
y desigualdades. En este caso, al cono de segundo orden y al cono SDP, y es:
Φ(x) = − log(t2 − xT x) + log(det(B))

Recordemos que, para una matriz simétrica y definida positiva B,

n
Y
det(B) = λi
j=1
n
donde los λi son los valores propios de B. Entonces, log(det(B)) = log λj , ası́ que la expresión es
P
j=1
consistente con lo que habı́amos mostrado en el ejemplo de la elipse de menor volumen.
Capı́tulo 11
Optimización Bajo Incertidumbre
Desde los comienzos de la Investigación de Operaciones como disciplina cientı́fica, es decir, hacia fines de
la década de 1940, los modelos de Optimización han sido usados en los más diversos ámbitos, apoyando
distintos procesos de toma de decisiones. Pero también, desde los comienzos de la disciplina, los académicos
y profesionales prácticos se han preguntado algo fundamental: ¿Qué hacemos frente al hecho que, muchas
veces, enfrentamos situaciones de incertidumbre?
Esta incertidumbre tiene distintos orı́genes pero es una realidad: muchos parámetros de nuestros modelos
vienen de estimaciones y, por lo tanto, tiene errores. Podrı́amos argumentar que es tema de tomar más
mediciones y mejorar la estimaciones (es lo que nos enseña la estadı́stica básica) pero, además, hay parámetros
de modelos que corresponden a situaciones que no ha ocurrido aún y ahı́ necesitamos predicciones (que,
sutilmente, no es lo mismo) y para eso tenemos que vivir con los datos que tenemos. Esto ilustra la
complejidad que hay en la existencia de incertidumbre, pero algo es claro: muchas veces no puede ser
ignorada.
Desde la década de 1950 se han venido desarrollando metodologı́as que buscan lidiar con la incertidumbre,
pero en nuestros tiempos esto ha adquirido más relevancia que nunca. Hay, al menos, dos temas que
intervienen aquı́: Por un lado, hoy existen problemas de gestión cada vez más complejos en ambientes
altamente inciertos. Ejemplos de esto es la gestión de sistemas de energı́a, la gestión de sistemas hospitalarios,
y otros. Por otro lado, vivimos en una época en la cual hay una gran abundancia de datos, lo que abre una
promesa de tener mejores estimaciones que podrı́an ayudar a lidiar mejor con la incertidumbre.
En este capı́tulo exploraremos, en forma muy introductoria, algunas de las metodologı́as que se usan en el
ámbito de la Optimización bajo Incertidumbre, un tema de gran relevancia hoy en dı́a.
11.1. La necesidad de considerar la incertidumbre

A modo de motivación e introducción de la consideración de la incertidumbre, vamos a tomar como ejemplo
el famoso “Problema del Granjero”, que está desarrollado en el conocido libro de John Birge y François
Louvaux, Introduction to Stochastic Optimization.
Consideremos la situación de un granjero que cultiva trigo, maı́z y remolacha. Est agricultor debe sembrar su
granja, que tiene un total de 500 acres, con estos tres cultivos en alguna proporción. Después del crecimiento
vendrá la cosecha y en ese momento deberá cumplir tener un stock mı́nimo de maı́z y trigo (que debe entregar
a una cooperativa de la cual es socio). En caso de no poder cumplir ese mı́nimo, deberá comprar producto
al precio de ese momento. Por otro lado, si le sobra cultivo, puede venderlo en el mercado. Debe cumplir
con un inventario mı́nimo de trigo y maı́z y vende lo que sobre, pero si falta, debe comprar lo que falte.
Respecto a la remolacha, esta es 100 % del granjero y la venderá una vez cultiva, aunque el precio al cual se
le pagará depende la de cantidad cosechada. Hay costos, obviamente, por sembrar. Se conoce, también, el
rendimiento de la tierra en cada uno de los cultivos.
La siguiente tabla (tomada del libro de Birge y Louvaux) muestra los datos del problema:
185
186 Capı́tulo 11. Optimización Bajo Incertidumbre
Trigo Maı́z Remolacha

Rendimiento (T/acre) 2,5 3 20
Costo plantar ($/acre) 150 230 260
Precio venta ($/T) 170 150 36 bajo 6000 T
10 sobre 6000 T
Precio compra ($/T) 238 210 −
Requisito mı́nimo (T) 200 240 −
Superficie disponible: 500 acres
Construir un modelo para este problema es simple. Usemos las siguientes variables:
xj : superficie dedicada al cultivo j.
wj : cantidad de cultivo j vendida, para trigo y maı́z.
yj : cantidad de cultivo j comprada, para trigo y maı́z.
w3 : cantidad de remolacha vendida a precio alto.
w4 : cantidad de remolacha vendida a precio bajo.
- El modelo maximiza utilidades y es (adaptado de B&L):
máx 170w1 + 150w2 + 36w3 + 10w4 − 150x1 − 230x2 − 260x3 − 238y1 − 210y2
s.a.
x1 + x2 + x3 ≤ 500
(2, 5)x1 + y1 − w1 ≥ 200
(3, 0)x2 + y2 − w2 ≥ 240
w3 + w4 ≤ 20x3
w3 ≤ 6000
x1 , x2 , x3 , y1 , y2 , w1 , w2 , w3 , w4 ≥ 0
Si se resuelve este problema se obtiene la siguiente solución:

Cultivo Trigo Maı́z Remolacha
Superfice (acres) 120 80 300
Rendimiento (T) 300 240 6000
Venta (T) 100 − 6000
Compra (T) − − −
Ganancia total: $118, 600
Si bien esta solución se ve bastante “normal”, cuando nos damos cuenta de las facetas de incertidumbre
que existen podrı́amos entrar a cuestionar su validez. Por ejemplo, los precios de venta de los cultivos
corresponden a un dato que estima algo que solo ocurrirá muchos meses más adelante, el valor real puede
ser diferente. Esto es crı́tico si se considera la volatilidad de los mercados agrı́colas en el mundo. Con un
valor muy diferente, la actual solución podrı́a ser muy mala. Por otro lado, el rendimiento de los cultivos
es variable ya que depende de factores incontrolables como el clima. Podrı́a ocurrir que uno de los cultivos
rinda mucho menos y termina teniendo un precio de venta atractivo. En esa circunstancia podrı́amos haber
dicho “debı́a haber sembrado más...”. Es fácil visualizar el problema que aquı́ se presenta.
Vamos a comentar a continuación algunas primeras aproximaciones a la consideración de incertidumbre.
11.1.1. Análisis de Sensibilidad para entender incertidumbre

El Análisis de Sensibilidad es una de las herramientas importantes para estudiar las propiedades de una
solución óptima una vez resuelto un problema. Por ejemplo, en nuestro problema podrı́amos preguntarnos
por la sensibilidad a los precios de venta del trigo y maı́z. El análisis de sensibilidad de la solución óptima
indica que el precio de venta del trigo (original en $170 ) puede variar entre $148 y $220 y eso conserva
la optimalidad de la solución actual. Esto podrı́a usarse para tener un rango inicial de “tolerancia a la
incertidumbre”. Por ejemplo, si el precio terminara siendo $ 150 en vez de 170, sabemos que la solución
calculada aún es óptima.
Sin embargo, hay otras preguntas que el Análisis de Sensibilidad no responde con facilidad. Por ejemplo,
cómo evaluar variaciones en los rendimientos de los cultivos. Estos son coeficientes de las restricciones y
el análisis convencional se hace sobre el lado derecho y la función objetivo. Más aún, el análisis se hace a
Francisco Garcı́a y Jorge Vera 11.2. Simulando la incertidumbre 187
posteriori, cuando ya hemos hecho un supuesto determinista sobre los parámetros inciertos. El Análisis de
Sensibilidad, entonces, parece tener varias limitantes, aunque pueda dar una idea preliminar de los efectos
de la incertidumbre.
11.2. Simulando la incertidumbre

Sigamos suponiendo que el rendimiento del trigo varı́a, especı́ficamente entre rangos de un 20 % del valor
entregado, es decir, en el intervalo [2, 3] (el valor “medio” es 2,5 ). Supongamos que somos capaces de conocer
el comportamiento estocástico del rendimiento del trigo en ese intervalo. Esto último es equivalente a conocer
la distribución de probabilidad de la variable aleatoria que nos entrega el rendimiento del trigo. Asumamos,
a modo de ilustración, que el rendimiento sigue una distribución Uniforme en el intervalo [2, 3].
La propuesta ahora es ponernos en distintos escenarios. Para eso podrı́amos generar aleatoriamente distintos
escenarios de rendimiento según una distribución uniforme y resolver el problema correspondiente a cada
uno de ellos y analizar los resultados. Hacer esto es lo que se llama Simulación de Montecarlo.
Supongamos que nuestro problema original se formula como un problema de programación lineal de la forma:
zs = mı́ncT x
s.a. Ax = b
x≥0
Supongamos que generamos P escenarios de los datos contenidos en la matriz A (podrı́a ser en los ostros
elementos también). Especı́ficamente, para el escenario s generamos la matriz As s = 1, . . . , P . Especı́ficamente,
esto significa que para cada coeficiente aij generaremos escenarios con las correspondientes distribuciones (O
solo para los que nos interesen, como se rá el caso del rendimiento del trigo en nuestro ejemplo). Entonces,
tendremos que resolver cada uno de los problemas:
zs = mı́ncT x
s.a. As x = b
x≥0
para s = 1, . . . , P . El valor óptimo promedio se puede estimar como:
P
1 X
z̄ = zs
P s=1
Incluso, a partir de las estadı́sticas, podemos estimar un intervalo de confianza para el valor óptimo.
Ahora bien, ¿cuál es “la” solución? Para cada problema s, sea x∗s la correspondiente solución óptima. Si
seguimos la misma lógica que aplicamos al valor óptimo, podrı́amos pensar en promediar los vectores de las
soluciones. Si aplicamos este enfoque al Problema del Granjero, con 100 escenarios, asumiendo lo indicado
antes para el rendimiento del trigo, se obtienen las siguientes soluciones “promedio”:
Cultivo Área Venta Compra
Trigo 104,11 66,35 1,18
Maı́z 79,74 21,52 15,12
Remolacha 316,16 5,976, 21 0,0
Pero recordemos ahora que se debe cumplir un mı́nimo de cantidad cosechada de trigo, restricción que, para
el valor medio del rendimiento, es:
(2, 5)x1 + y1 − w1 ≥ 200
Al evaluar en los resultados de la simulación se tiene:
2, 5 × 104, 11 + 1, 18 − 66, 35 = 195, 10

que no es mayor a 200, como se requiere. Es decir que, con la solución promedio, la restricción, con el
rendimiento medio, no se cumple. Obviamente podrı́a argumentarse que si el rendimiento fuera 3.0 entonces
seguramente la restricción sı́ se cumple, pero eso no lo sabemos a priori. Complementariamente, si el
rendimiento termina siendo 2.1, la situación es aún peor. Esto ilustra nuevamente la complejidad del tema:
cada escenario tiene una solución óptima, pero no estamos siendo capaces de construir una solución que
funcione “bien” para todos los escenarios, o la mayor parte de ellos.
Podrı́amos sı́ construir una solución que sirviera siempre: asumir que el rendimiento será 2.0, es decir, el
peor caso. Pero esto generará una solución extremadamente conservadora que nos puede llevar a tener un
exceso de trigo en desmedro de los otros cultivos.
Como vemos de toda esta discusión, necesitamos mejores enfoques para abordar la incertidumbre, enfoques
que incorporen las caracterı́sticas de esta incertidumbre en el momento que tomamos las decisiones. En las
próximas secciones describiremos, en forma simple, algunos de estos enfoques.
Cápsula de video 11.2.1: Introduciendo la incertidumbre en Optimización
Profesor Jorge Vera explica en clases las motivaciones y desafı́os de considerar la incertidumbre en
Optimización.
https: // youtu. be/ GG3bPPtG3tI
11.3. Optimización con Restricciones Probabilı́sticas

Supongamos que en un modelo de optimización tenemos una restricción lineal de la forma:
n
X
a j xj ≤ b
j=1
Vamos a suponer que los coeficientes aj no se conocen con precisión pues son aleatorios. En ese contexto, el
lado izquierdo de la restricción es un valor aleatorio (una variable aleatoria, que depende de los valores de
x, que son las variables de decisión del problema) y, por lo tanto, no podemos tener certeza respecto a cómo
se compara con el lado derecho. Por esa razón, lo que vamos a hacer es pedir que la solución se cumpla con
al menos una cierta probabilidad α, por ejemplo, que se cumpla con 90 %, 95 % o 99 %, es decir:
 
Xn 
Prob aj xj ≤ b ≥ α
 
j=1
donde 0 < α < 1 está dado exógenamente. Esto se conoce como una Restricción Probabilı́stica o “Chance
Constraint”. Este enfoque fue desarrollado por Charnes y Cooper en 1959 y ha sido ampliamente estudiado,
aunque presenta desafı́os computacionales importantes ya que la expresión probabilı́stica suele ser extremadamente
difı́cil de tratar, salvo que se den ciertas condiciones. Una de estas condiciones es que los coeficientes aj sigan
una distribución Normal con media āj y varianza σj2 (en forma independiente de los otros). Entonces,
n
X
aj xj
j=1
Pn Pn
es una variable aleatoria Normal con media j=1 āj xj y varianza j=1 σj2 x2j (bajo la hipótesis de independencia).
Luego
Pn P
n
j=1 aj xj − j=1 āj xj
T = qP
n
j=1 σj2 x2j
es una variable aleatoria normal con media 0 varianza 1 N (0, 1). Tenemos, entonces que:
Francisco Garcı́a y Jorge Vera 11.3. Optimización con Restricciones Probabilı́sticas 189
Figura 11.1: Fuente: allaboutlean.com
  P 
n
Xn  b− j=1 āj x j 
Prob aj xj ≤ b = Prob T ≤ qP
n 2 2 
j=1 σj xj
  
j=1
donde T sigue una distribución N (0, 1). Tal como se recordará, la probabilidad de una normal P (T ≤ t) se
ve como muestra la figura:
El valor que cubre un determinado percentil,Zα , corresponde al área acumulada de la densidad y esa es la
probabilidad de que T ≤ zα . Por lo que para que se cumpla la restricción con probabilidad α, debe tenerse
que
P
n
b− j=1 āj x j
qP ≥ zα
n 2 2
j=1 σj xj
donde zα es el percentil α de la distribución Normal.

De esta forma la expresión probabilı́stica con la que partimos queda transformada en su “equivalente
determinı́stico”:
v
n
u n 2 2
X uX
āj xj + zα t σj xj ≤ b
j=1 j=1
Esta expresión no ha hecho desaparecer el aspecto probabilı́stico, pues el valor de esta restricción depende
del valor de α que se quiera. Por ejemplo, para α = 0, 95, zα = 1, 65.
La mala noticia del enfoque es que la transformación anterior se puede hacer con la distribución Normal
y “casi nada más”, pero aún ası́ es una idea potente, pues la distribución Normal es muy tı́pica en todo
tipo de fenómenos. Más aún, por el Teorema Central del Lı́mite, muchos fenómenos pueden ser aproximados
por la distribución Normal y una restricción lineal cualquiera, aún si sus sumandos tienen distribuciones
“exóticas”, la suma total tenderá a un comportamiento normal cuando n es relativamente grande.
La buena noticia es que las restricciones como la anterior, en el caso normal, se pueden manejar de manera
eficiente. Notemos que la restricción
v
n
u n 2 2
X uX
āj xj + (1, 65)t σj xj ≤ b
j=1 j=1
Es lo mismo que
v  
u n 2 2 1 
n
uX X
σj xj ≤ b− āj xj 
1, 65
t
j=1 j=1
Lo que lleva a una estructura de un cono de segundo orden. Definamos el siguiente cambio de variables:
 
n
1  X
t= b− āj xj  , uj = sj xj , j = 1, . . . , n.
1, 65 j=1
Entonces, la restricción queda: sX

u2j ≤ t
j
Como ya sabemos, esta estructura puede ser manejada con algoritmos de punto interior de manera muy
eficiente.
Cápsula de video 11.3.1: Restricciones Probabilı́sticas
Profesor Jorge Vera explica en clases el enfoque de restricciones probabilı́sticas y su manejo mediante
modelación SOCP.
https: // youtu. be/ LDh14mHykEg
11.3.1. Ejemplos
Problema de Cosechas
Una empresa del sector agropecuario necesita planificar sus actividades de cosecha de cereales sobre un
horizonte de T perı́odos de tiempo (dı́as, para fijar ideas). Existen n campos, con superficies conocidas, que
pueden ser cosechados total o parcialmente. La superficie del campo j es Sj . Las labores de cosecha en el
campo j tienen un rendimiento de αjt kilos por hectárea cosechada en el perı́odo t. Esto varı́a de perı́odo a
perı́odo debido a las condiciones operacionales a medida que avanza la temporada. Hay un costo por hectárea
cosechada en cada perı́odo, cjt . Existe un requerimiento mı́nimo diario de cereal cosechado que la empresa
debe cumplir, que es igual a dt kilos en el dı́a t. Para resolver la planificación de cosecha, la empresa ha
formulado un modelo de optimización que usa las variables xjt que corresponden a la superficie cosechada
en el campo j el dı́a t.
El modelo es:
n
T P
mı́n
P
cjt xjt
t=1 j=1
s.a.
t−1
t = 2, . . . , T ; j = 1, . . . , n (1)
P
xjt ≤ Sj − xjl ,
l=1
xj1 ≤ Sj , j = 1, . . . , n (2)
n
t = 1, . . . , T (3)
P
αjt xjt ≥ dt ,
j=1
xjt ≥ 0, j = 1, . . . , n; t = 1, . . . , T (4)
Supongamos que los rendimientos de cosecha pueden sufrir variaciones, pero se sabe que se comportan según
una distribución conocida. Más especı́ficamente, se sabe que αjt sigue una distribución Normal con media
ᾱjt y desviación estándar sjt , siendo todos esos rendimientos independientes entre sı́.
Se quiere imponer un cumplimiento probabilı́stico para las restricciones de requerimiento mı́nimo (3), a un
nivel de un 95 %. Vamos a desarrollar el correspondiente problema con restricciones probabilı́sticas.
Las restricciones a considerar son las (3):
n
X
αjt xjt ≥ dt , t = 1, . . . , T
j=1
Entonces, queremos pedir que

n
X
P rob( αjt xjt ≥ dt ) ≥ 0, 95, t = 1, . . . , T
j=1
Francisco Garcı́a y Jorge Vera 11.3. Optimización con Restricciones Probabilı́sticas 191
Siguiendo el desarrollo que ya hemos presentado (notar el sentido de la desigualdad) se obtiene la siguiente
restricción determinista equivalente:
v
n
u n 2
X uX
ᾱjt xjt − (1, 64)t sjt (xjt )2 ≥ dt , t = 1, . . . , T
j=1 j=1
Luego, el problema completo es:
T P
n
mı́n
P
cjt xjt
t=1 j=1
s.a.
t−1
t = 2, . . . , T ; j = 1, . . . , n (1)
P
l=1
xj1 ≤ Sj , s j = 1, . . . , n (2)
n n
ᾱjt xjt − (1, 64) s2jt (xjt )2 ≥ dt , t = 1, . . . , T (3)
P P
j=1 j=1
xjt ≥ 0, j = 1, . . . , n; t = 1, . . . , T (4)
Si queremos resolver este problema mediante el uso de algoritmos de punto interior, debemos considerar la
correspondiente función de barrera. En particular, el problema penalizado de la etapa k del algoritmo de
punto interior general deben considerar la función de barrera de todas las desigualdades y conos. Para esto,
vamos a reescribir el problema en la forma:
T P
n
mı́n
P
cjt xjt
t=1 j=1
s.a.
t−1
t = 2, . . . , T ; j = 1, . . . , n (1)
P
l=1
xj1 ≤ s Sj , j = 1, . . . , n (2)
n n
(1, 64) s2jt (xjt )2 ≤ t = 1, . . . , T (3)
P P
ᾱjt xjt − dt ,
j=1 j=1
xjt ≥ 0, j = 1, . . . , n; t = 1, . . . , T (4)
Introduciendo variables auxiliares, lo reescribimos:
T P
n
mı́n
P
cjt xjt
t=1 j=1
s.a.
t−1
t = 2, . . . , T ; j = 1, . . . , n (1)
P
l=1
sj1 ≤ Sj ,
x j = 1, . . . , n (2)
n
2 ≤ w, t = 1, . . . , T (3)
P
vjt
j=1
n
w= 1,64 (
1
ᾱjt xjt − dt ), t = 1, . . . , T (3,1)
P
j=1
vjt = sjt xjt , t = 1, . . . , T ; j = 1, . . . , n (3,2)
xjt ≥ 0, j = 1, . . . , n; t = 1, . . . , T (4)
La función de barrera que se debe usar es:

 
XT X
n t−1
X n
X n
X T X
X n 
Φ(x) = − log(Sj − xjl − xjt ) + log(Sj − xj1 ) + log(w2 − 2
vjt )+ log(xjt )
 
t=2 j=1 l=1 j=1 j=1 t=1 j=1
y el problema penalizado es:

T P
n
mı́n cjt xjt + µΦ(x)
P
t=1 j=1
s.a.
n
w= 1,64 (
1
ᾱjt xjt − dt ), t = 1, . . . , T (3,1)
P
j=1
vjt = sjt xjt , t = 1, . . . , T ; j = 1, . . . , n (3,2)
11.4. Modelando la Dinámica de la Incertidumbre

Muchas veces, la forma en que se toman las decisiones es frente a un evento incierto que ocurrirá en algún
futuro, pero las decisiones deben ser tomadas en el presente. Reconocer esta dinámica es importante para
un mejor tratamiento de la incertidumbre y es el tema de esta sección.
Vamos a introducir una forma de pensar que consisten en dos etapas: En una primera etapa, se toman
decisiones x especı́ficas (ej. decidimos la producción). En una segunda etapa, se manifiesta el fenómeno
aleatorio (ej. la demanda). Recién en ese entonces es posible ver qué consecuencias tuvo la decisión, como que
podrı́a haber habido demanda insatisfecha, por ejemplo. En ese momento, también, se tendrán que evaluar
los costos involucrados.
11.4.1. Ejemplo introductorio

Vamos a ilustrar esta forma de pensar con un ejemplo en el que vamos a considerar un problema de planificar
la asignación de quirófanos a operaciones en un hospital. Este es un problema muy importante y mostraremos
aquı́ una situación simplificada. En esta situación tenemos varios quirófanos que pueden operar o no y
una serie de operaciones que deben ser asignadas a los quirófanos. Cada operación tiene un tiempo de
duración pero los quirófanos tienen un tiempo limitado de operación, el cual puede ser extendido con algún
sobretiempo. Algunas operaciones puede que no se logren programar y, en ese caso, see incurrirá un costo
por eso. Más en especı́fico, tenemos los siguientes parámetros:
N quirófanos y cada quirófano está disponible T horas.
P operaciones y la duración de la operación i es de wi horas.
Si es necesario, un quirófano puede funcionar tiempo extra, pero hay un total de Q horas máximo
disponible para todos los quirófanos.
Costo fijo Kj por usar el quirófano j en el perı́odo.
Costo adicional cj por hora de sobretiempo que se asigne al quirófano j.
Costo β por operación no realizada ya que implica reasignar al paciente a otro centro asistencial.
El problema se puede modelar con las siguientes variables de decisión:
xij indica si la operación i se hace en el quirófano j.
yj indica si el quirófano j se usa o no.
zi indica si la operación no pudo ser programada.
tj es la cantidad de sobretiempo asignado al quirófano j.
El modelo para este problema es:

Francisco Garcı́a y Jorge Vera 11.4. Modelando la Dinámica de la Incertidumbre 193
N
X P
X
mı́n {Kj yj + cj tj } + βzi
j=1 i=1
N
X
s.a. xij + zi = 1, i = 1, . . . , P
j=1
P
X
xij ≤ P yj , j = 1, . . . , N
i=1
P
X
wi xij ≤ T + tj , j = 1, . . . , N
i=1
N
X
tj ≤ Q,
j=1
xij , yj , zi ∈ {0, 1}, tj ≥ 0, i = 1, . . . , P ; j = 1, . . . , N
Las decisiones principales que se deben tomar aquı́ son la asignación de las operaciones, junto con asignar
sobretiempo si es necesario. Acá aparece, de forma natural, la perspectiva que proponemos: las operaciones
se planifican por anticipado pero se hacen en el futuro. El tema es que la duración de las operaciones es, en
realidad, aleatoria y varı́a, lo que puede llevar a tener que usar sobretiempo distinto al que se podrı́a haber
planificado si no se toma esa incertidumbre en cuenta.
Vamos a construir un solo modelo que separa la primera etapa de decisiones (“here and now”), y considera,
además, una estimación del costo que generarı́an esas decisiones una vez que la incertidumbre se manifieste.
Vamos a suponer ahora que la duración de las operaciones se comporta según una distribución de probabilidades
ξ. En este caso, la decisión t es la que pertenece al futuro. Entonces, cada decisión de asignación de
operaciones a quirófanos, (y, x, z) genera una posibilidad en el futuro.
Queremos tomar hoy decisiones (y, x, z) de modo tal que el costo incurrido ahora más el costo esperado del
futuro sea mı́nimo. Para esto, planteamos el siguiente problema:
N
X P
X
mı́n Kj yj + βzi + Eξ (F (y, x, z))
j=1 i=1
N
X
s.a. xij + zi = 1, i = 1, . . . , P
j=1
P
X
xij ≤ P yj , j = 1, . . . , N
i=1
xij , yj , zi ∈ {0, 1} i = 1, . . . , P ; j = 1, . . . , N
Este problema optimiza sobre las decisiones de asignación de las operaciones a los quirófanos, minimizando
el costo especı́fico de esa asignación (incluyendo el costo de dejar operaciones sin asignar) más el costo
que esas decisiones generarán en el futuro. Como el futuro es aleatorio, especı́ficamente la duración de las
operaciones, y el sobretiempo real en que se incurra dependerá de esa duración, lo que se hace es considerar
el costo esperado de ese futuro. En el modelo, F (y, x, z) es el costo, en el futuro, de las decisiones (y, x, z),
y como es aleatorio, lo tomamos en valor esperado.
F (y, x, z) es el resultado de optimizar el sobretiempo, dada la asignación de operaciones, y se calcula como:

N
X
F (y, x, z) = mı́n cj tj
j=1
P
X
s.a. wi xij ≤ T + tj , j = 1, . . . , N
i=1
N
X
tj ≤ Q, i = 1, . . . , P ; j = 1, . . . , N.
j=1
tj ≥ 0,
Este es el que llamaremos el problema “de segunda etapa”. Acá xij (notar que y no se hace explı́cita aquı́,
tampoco z ) son las decisiones de la primera etapa y el sobretiempo, tj , son las variables de segunda etapa,
es la variable que se .ajusta en el futuro”. Como los wi son variables aleatorias, F (y, x, z) es también una
variable aleatoria y por eso tomamos su valor esperado.
Este problema que acabamos de formular se conoce como un modelo de optimización estocástica de 2 etapas
con “recurso” (2 stage stochastic model with recourse). El costo de segunda etapa es, entonces, una estimación
de lo que podrı́a pasar en el futuro pero la decisión de primera etapa tiene que servir para cualquier cosa
que pase en el futuro.
Las decisiones “de primera etapa” (x, en el modelo) se suelen llamar decisiones “here and now”. Estas tienen
sus propias restricciones y costo. Las decisiones de “segunda etapa” (los t en nuestro caso) se suelen llamar
decisiones “wait and see” y también tienen sus propios costos y restricciones, pero estos dependen de las
decisiones de primera etapa.
Cápsula de video 11.4.1: Motivando decisiones de 2 etapas
Profesor Jorge Vera explica en clases el esquema de decisiones de 2 etapas para considerar
incertidumbre.
https: // youtu. be/ KBnecox6rUg
11.4.2. Modelo Estocástico de 2 epatas: formulación general

Consideramos un problema de optimización en el que queremos minimizar el costo de primera etapa, en
el que decidimos x, más el valor esperado del costo que generan las decisiones x en la segunda
etapa. Es decir:
mı́n cT x + E(Q(x))
s.a. Ax = b
x≥0
Donde el problema de segunda etapa es:
Q(x) = mı́n dT y
s.a. Dx + T y = e
y≥0
Generalmente e (y/oD) es aleatorio y las variables y se “ajustan” o “adaptan”, al evento incierto, son
variables “wait and see”. Cuando esto ocurre se dice que se trata de un modelo con “recurso fijo” (fixed
recourse).
11.5. Cómo resolver el problema

No existe una manera analı́tica simple de caracterizar la optimalidad de un problema como el anterior. Para
comenzar, la función cT x + E(Q(x)) no es diferenciable. Un enfoque, posiblemente el más usado, se basa
Francisco Garcı́a y Jorge Vera 11.5. Cómo resolver el problema 195
en aproximar E(Q(x)) por escenarios finitos. Esto se conoce como Sample Average Approximation
(SAA) y lo explicamos a continuación. Tenemos el siguiente problema:
mı́n cT x + E(Q(x))
s.a. Ax = b
x≥0
donde
Q(x) = mı́n dT y
s.a. Dx + T y = e
y≥0
Asumiremos que e y/o D son aleatorios y siguen una distribución de probabilidad ξ conocida (muchas veces
sólo e es el aleatorio, o D solo). La idea es aproximar E(Q(x)) por un promedio sobre un número finito de
ocurrencias de los eventos aleatorios. Más especificamente, supongamos que se generan K escenarios de e y
D, a partir de la distribución ξ : e1 , . . . , eK , D1 , . . . , DK
Dadas decisiones x, por cada escenario de (D, e), hay un problema de segunda etapa, que determina
variables y para ese escenario (por eso son y k , pues corresponden al escenario k):
Qk (x) = mı́n dT y k
s.a. Dk x + T y k = ek
yk ≥ 0
y esto para k = 1, . . . , K. Podemos, entonces, aproximar E(Q(x)) por
K
1 X
Qk (x)
K
k=1
(Notar que x es el mismo para todos los escenarios: viene de la primera etapa). Reemplazando esto en el
problema de la primera etapa, obtenemos el siguiente problema:
K
1 X T k
SAA) mı́n cT x + d y
K
k=1
s.a. Ax
Dk x + T yk =b
x ≥ 0, y ≥0
k
= ek , k = 1, . . . , K
Este se conoce como el problema de Sample Average Approximation (SAA). Nótese como la formulación
considera las decisiones x como comunes y se pone en diversos escenarios de la aleatoriedad, cada uno de los
cuales genera una respuesta y según cada uno de los escenarios. Por eso, hay un solo conjunto de variables
x pero distintos y según el escenario. Esto refuerza la idea del enfoque general: las decisiones que tomemos,
x, deben ser “buenas” para cada posible futuro.
Aquı́ está el mismo problema, en forma estructurada:
1 T 1 T 2
SAA) mı́n cT x + d y +d y . . . +dT y K

K
s.a. Ax =b
1
D x +T y 1
= e1
D2 x +T y 2 = e2
.. .. ..
. . .
K
D x T yK = eK
x ≥ 0, y1 ≥ 0 y2 ≥ 0 ··· yK ≥ 0 , k = 1, . . . , K
Podemos ver que este es, claramente, un problema de gran tamaño. Si A es de m × n, D es de p × n y hay
r variables y, el problema SAA tiene: m + Kp restricciones y n + Kr variables. Podemos ver, de inmediato,
que la estructura es muy adecuada para ser abordada mediante el enfoque de Descomposición de Benders.
De hecho, la adaptación de la Descomposición de Benders a esta estructura es el método ”L-shaped”.
Entonces, la solución óptima del problema es un vector de la forma (x̄x, ȳ 1 , ȳ 2 , . . . , ȳ K ). La forma de usar,
en la práctica, esta solución serı́a la siguiente: se implementa x ahora y el tiempo pasará hasta que se tenga
que cosechar. Entonces, ahı́ se observará lo que ocurrió con el fenómeno aleatorio: si se dio algo parecido al
escenario k, entonces y k es la polı́tica “de ajuste” que se debe seguir.
Cápsula de video 11.5.1: El problema de 2 etapas general y SAA
Profesor Jorge Vera explica en clases el problema general de 2 etapas y su resolución aproximada
mediante Sample Average Approximation.
https: // youtu. be/ 2rRigALTQjw
11.5.1. Ejemplos
Problema del Granjero como problema de 2 etapas
Consideremos nuevamente el problema inicial del granjero. Asumiremos incertidumbre en los rendimientos.
Esto es, en lo que corresponderı́a a la matriz D . . . en la formulación general.
El problema del granjero tenı́a las siguientes variables:
xj : superficie dedicada al cultivo j.
wj : cantidad de cultivo j vendida, para wheat y corn.
yj : cantidad de cultivo j comprada, para wheat y corn.
w3 : cantidad de remolacha vendida a precio alto.
w4 : cantidad de remolacha vendida a precio bajo.
Las decisiones de primera etapa son, evidentemente, las decisiones de siembra, es decir, las x. Las otras
variables son “wait and see”. Podemos ver ahora cómo el enfoque de 2 etapas se adapta a la situación del
problema del granjero: sus decisiones de ahora son las decisiones de siembra, pero cuando llegue la cosecha,
ahı́ tendrá que decidir si tiene que comprar producto o, más bien, tiene producto de sobra y puede vender.
Vamos a denotar por αt , αm y αr los rendimientos del trigo, maı́z y remolacha respectivamente. El problema
del granjero modelado como problema estocástico en 2 etapas es:
máx −150x1 − 230x2 − 260x3 + E(Q(x))

s.a. x1 + x2 + x3 ≤ 500
x1 , x2 , x3 ≥ 0
donde:
Q(x) = máx +170w1 + 150w2 + 36w3 + 10w4 − 238y1 − 210y2

s.a. αt x1 + y1 − w1 ≥ 200
αm x2 + y2 − w2 ≥ 240
w3 + w4 ≤ αr x3
w3 ≤ 6000
y1 , y2 , w1 , w2 , w3 , w4 ≥ 0
Problema de Planificación de Producción

Vamos a considerar el “clásico” prbolema de planificación de producción en el que se fabrican n productos
haciendo uso de m recursos, en un horizonte de T meses. Supondremos que hay disponibilidades máximas
de los recursos y se debe satisfacer demanda. Los siguientes son los parámetros disponibles:
djt : demanda por producto j en periodo t, j = 1, ..., n, t = 1, ..., T .

bit : Disponibilidad del recurso i en periodo t, i = 1, ..., m, t = 1, ..., T .
cjt : Costo unitario de producción de j en t, j = 1, ..., n, t = 1, ..., T .
aij : Cantidad de recurso i usado en producir una unidad de producto j, i = 1, ..., m, j = 1, ..., n.
hj : Costo de dejar una unidad de producto j en inventario de un periodo al siguiente, j = 1, ..., n
Este problema se modela con las variables xjt , producción de j en t, y se usa otra variable Ijt para registrar
el inventario. El modelo es:
T P
n
mı́n {cjt xjt + hj Ijt }
P
t=1 j=1
s.t. Ijt = Ijt−1 + xjt − djt , t = 1, . . . , T ; j = 1, . . . , n
n
aij xjt ≤ bit , i = 1, . . . , m; t = 1, . . . , T
P
j=1
xjt ≥ 0, Ijt ≥ 0, t = 1, . . . , T ; j = 1, . . . , n
Este modelo requiere cumplimiento de demanda, pero si esta es aleatoria, podrı́amos no cumplir. Vamos a
modeificar el modelo para poder tomar el cuenta el posible incumplimiento de demanda. Para esto, notemos
que si no se cumple la demanda en algún periodo, la restricción de inventario sólo se podrá cumplir si
permitimos “inventario negativo”, que representa demanda insatisfecha. Vamos a considerar, entonces, Ijt
sin restricción de signo y vamos a reemplazar:
− −
Ijt = Ijt
+
− Ijt +
, Ijt ≥ 0, Ijt ≥ 0.
Supongamos ahora que existe un costo por unidad no satisfecha de demanda y es πj . Entonces, el modelo
modificado serı́a:
T P
n
−
mı́n {cjt xjt + hj Ijt
+
+ πj Ijt
P
}
t=1 j=1
−
Ijt = Ijt
+
− Ijt , t = 1, . . . , T ; j = 1, . . . , n
n
aij xjt ≤ bit , i = 1, . . . , m; t = 1, . . . , T
P
j=1
−
xjt ≥ 0, Ijt
+
≥ 0, Ijt ≥ 0, t = 1, . . . , T ; j = 1, . . . , n
Ahora vamos a suponer ahora que la demanda sigue una distribución de probabilidad ξ. Planteamos el
siguiente problema:
T P
n
mı́n {cjt xjt } + Eξ (Q(x))
P
t=1 j=1
n
aij xjt ≤ bit , i = 1, . . . , m; t = 1, . . . , T
P
s.t.
j=1
xjt ≥ 0, t = 1, . . . , T ; j = 1, . . . , n
donde Q es la consecuencia, en el futuro, de las decisiones x. El problema de segunda etapa es:
T P
n
−
Q(x) = mı́n +
+ πj Ijt
P
{hj Ijt }
t=1 j=1
−
Ijt = Ijt
+
− Ijt , t = 1, . . . , T ; j = 1, . . . , n
−
Ijt ≥ 0, Ijt ≥ 0, t = 1, . . . , T ; j = 1, . . . , n
+
Entonces acá: xjt son las decisiones de la primera etapa y los inventarios y faltantes son las variables de
ajuste, “wait and see”.
Para plantear la formulación SAA de este problema, asumamos que se han generado K escenarios de la
demanda, dkjt , k = 1, . . . , K. El problema SAA es:
T P
n K P
T P
n
−k
mı́n cjt xjt + 1 +k
+ πj Ijt
P P
K {hj Ijt }
t=1 j=1 k=1 t=1 j=1
s.t. k
Ijt = Ijt−1
k
+ xjt − dkjt , t = 1, . . . , T ; j = 1, . . . , n; k = 1, . . . , K
−k
k
Ijt = Ijt
+k
− Ijt , t = 1, . . . , T ; j = 1, . . . , n; k = 1, . . . , K
n
aij xjt ≤ bit , i = 1, . . . , m; t = 1, . . . , T
P
j=1
−k
xjt ≥ 0, Ijt
+k
≥ 0, Ijt ≥ 0, t = 1, . . . , T ; j = 1, . . . , n; k = 1, . . . , K
Destaquemos nuevamente la lógica al identificar las variables de primera y segunda etapa: el contexto del
problema es muy importante, aquı́ estamos planificando producción, es decir, planificando cuánto producir
y cuándo de cada producto. Por eso las variables xjt son las de primera etapa. Los inventarios se ajustan
una vez que se manifiesta la incertidumbre, es decir, cuando se observa la verdadera demanda.
También destaquemos por qué el modelo tuvo que ser modificado. En el modelo original de producción
todo es determinı́stico, ese modelo no se pone en la situación de no cumplir la demanda ya que esta es
perfectamente conocida. Por otro lado, en el modelo bajo incertidumbre no podemos estar seguros que
podremos cumplir con la demanda y por esa razón debemos considerar la posibilidad de dejar demanda
insatisfecha, pero eso debe tener un costo. En efecto, si no existiera el costo por demanda insatisfecha, lo
óptimo es no hacer nada y no incurrir en los costos de producción, lo que no tiene sentido desde el punto de
vista de gestión. Por eso es necesario considerar inventarios positivos y negativos (real inventario y demanda
insatisfecha). Notemos que esas variables son totalmente análogas a las de compra y venta del problema del
granjero.
Admisión de pacientes en salas de hospitalización
Consideramos aquı́ el problema de asignar un conjunto de paciente a salas de hospitalización de cuidados

intermedios en un hospital. Este problema está basado en Managing the unknown: A distributionally robust
model for the admission planning problem under uncertain length of stay, de A. Batista, D. Pozo y J. Vera,
publicado en Computers Industrial Engineering 154 (2021).
Vamos a considerar que existe un conjunto de I de pacientes que deben ser asignados a alguna de R salas a
lo largo de un horizonte de T dı́as. Cada paciente tendrá un tiempo de estadı́a en el hospital igual a ξi , para
el paciente i y existe un “beneficio” ηi de atender al paciente i (no es necesariamente un beneficio económico,
puede estar relacionado a la gravedad del paciente, el tiempo que lleva esperando, etc.) Cada sala r tiene un
lı́mite a la cantidad de paciente que puede acomodar por dı́a t. Ese lı́mite es Crt . Adicionalmente, cada vez
que un paciente está hospitalizado en alguna sala, requiere de atenciones diversas que consumen un total de
αi horas por dı́a del personal del hospital. En cada sala, existe un lı́mite Qmax
rt de horas disponible por dı́a
en la sala r. El hospital quiere atender pacientes de modo de obtener el mayor “beneficio” total posible, ası́
que necesita asignar estos a las distintas salas, para lo cual ha formulado un modelo de optimización que
usa las siguientes variables:
yirt : igual a 1 si el paciente i ocupa la sala r en el dı́a t, 0 en caso contrario.
xirt : igual a 1 si el paciente i ocupa la sala r a partir del dı́a t, 0 en caso contrario.
zir : igual a 1 si el paciente i es asignado a la sala r, 0 en caso contrario.
El modelo es:
R P
I
máx
P
ηi zir
r=1 i=1
I
r = 1, . . . , R; t = 1, . . . , T (1)
P
s.a. yirt ≤ Crt
i=1
xirt ≥ yirt − yir(t−1) i = 1, . . . , I; r = 1, . . . , R; t = 2, . . . , T (2)
R
yirt ≤ 1 i = 1, . . . , I; t = 1, . . . , T (3)
P
r=1
T
zir = i = 1, . . . , I; r = 1, . . . , R (4)
P
xirt
t=1
T
i = 1, . . . , I; r = 1, . . . , R (5)
P
yirt ≥ zir ξi
t=1
I
αi yirt ≤ Qmax r = 1, . . . , R; t = 1, . . . , T (6)
P
rt
i=1
xirt , yirt , zir ∈ {0, 1} i = 1, . . . , I; r = 1, . . . , R; t = 1, . . . , T (7)
La función objetivo maximiza el beneficio por atención de pacientes. Las restricciones (1) corresponden a
la capacidad de cada sala, las restricciones (2) y (3) aseguran que cada paciente sea atendido en periodos
consecutivos de tiempo, las restricciones (4) activan la variable zir cuando el paciente i es asignado a la sala
r en algún momento de tiempo, las restricciones (5) establecen que si el paciente i es asignado a la sala r,
debe serlo por una cantidad de dı́as al menos igual al tiempo de estadı́a que necesita, las restricciones (6)
establecen el lı́mite de recursos por sala por dı́a, y, finalmente, las restricciones (7) establecen la naturaleza
de las variables.
El problema que se presenta aquı́ es que el uso de recursos hospitalarios, representado por los parámetros
αi , es variable y eso puede provocar que, según lo que se planifique, estos no sean suficientes para cumplir
adecuadamente. El hospital decide enfrentar esto con la posibilidad de incorporar recursos adicionales, a un
costo. Vamos a suponer que el comportamiento de αi puede estimarse muy bien que siguen una distribución
normal de media ᾱi y desviación estándar σi .
Suponga, entonces, que el lı́mite de recursos, Qmax
rt puede aumentar en alguna cantidad, pero ese adicional
sale de un lı́mite total para todas las salas del hospital sobre todos los perı́odos de tiempo, igual a Q̄.
Además, por cada unidad de aumento, en alguna sala en algún periodo, el hospital incurre en un “costo”
igual a β (tampoco tiene que ser monetario, asuma que es compatible, en unidades, al “beneficio” de atender
pacientes).
Basado en la nueva situación, vamos a formular un modelo estocástico de 2 etapas. Primero, hay que modificar
el modelo para considerar el uso de recursos adicionales. Para esto, vamos a definir nuevas variables vrt que
corresponden a la cantidad de recurso adicional que se agrega en la sala r en el periodo t. El modelo extendido
es:
R P
I R P
T
máx
P P
ηi zir − βvrt
r=1 i=1 r=1 t=1
I
r = 1, . . . , R; t = 1, . . . , T (1)
P
s.a. yirt ≤ Crt
i=1
R
yirt ≤ 1 i = 1, . . . , I; t = 1, . . . , T (3)
P
r=1
T
zir = i = 1, . . . , I; r = 1, . . . , R (4)
P
xirt
t=1
T
i = 1, . . . , I; r = 1, . . . , R (5)
P
yirt ≥ zir ξi
t=1
I
≤ Qmax + vrt r = 1, . . . , R; t = 1, . . . , T (60 )
P
αi yirt rt
i=1
R T
(600 )
P P
vrt ≤ Q̄
r=1 t=1
xirt , yirt , zir ∈ {0, 1}, vrt ≥ 0 i = 1, . . . , I; r = 1, . . . , R; t = 1, . . . , T (7)
ahora, podemos pensar en un modelo de 2 etapas. Las variables “here and now” corresponde a las de
asignación y planificación, es decir, las (x, y, z). Las variables “wait and see” corresponden a los ajustes de
recursos, es deciir, las vrt , las que actuarán cuando se revele la incertidumbre.
El problema de 2 etapas es (tener cuidado con que el problema original es “max”):
R P
I
máx
P
ηi zir − E(Q(x, y, z))
r=1 i=1
I
r = 1, . . . , R; t = 1, . . . , T (1)
P
s.a. yirt ≤ Crt
i=1
R
yirt ≤ 1 i = 1, . . . , I; t = 1, . . . , T (3)
P
r=1
T
zir = i = 1, . . . , I; r = 1, . . . , R (4)
P
xirt
t=1
T
i = 1, . . . , I; r = 1, . . . , R (5)
P
yirt ≥ zir ξi
t=1
xirt , yirt , zir ∈ {0, 1} i = 1, . . . , I; r = 1, . . . , R; t = 1, . . . , T (7)
donde
R P
T
Q(x, y, z) = mı́n
P
βvrt
r=1 t=1
I
≤ Qmax + vrt r = 1, . . . , R; t = 1, . . . , T (60 )
P
s.a. αi yirt rt
i=1
R P T
(600 )
P
vrt ≤ Q̄
r=1 t=1
vrt ≥ 0 r = 1, . . . , R; t = 1, . . . , T (70 )
Para la formulación SAA vamos a asumir que, a partir del conocimiento de las distribuciones de los
parámetros αi , se han generado K escenarios, α1 , α2 , . . . , αK . Siguiendo la construcción del modelo SAA,
tenemos que est serı́a:
R P
I K P
R P
T
máx 1 k
P P
ηi zir − K βvrt
r=1 i=1 k=1 r=1 t=1
I
r = 1, . . . , R; t = 1, . . . , T (1)
P
s.a. yirt ≤ Crt
i=1
R
yirt ≤ 1 i = 1, . . . , I; t = 1, . . . , T (3)
P
r=1
T
zir = i = 1, . . . , I; r = 1, . . . , R (4)
P
xirt
t=1
T
i = 1, . . . , I; r = 1, . . . , R (5)
P
yirt ≥ zir ξi
t=1
I
αi yirt ≤ Qmax + vrt
k
r = 1, . . . , R; t = 1, . . . , T ; k = 1, . . . , K (60 )
P
rt
i=1
R T
k = 1, . . . , K (600 )
P P k
vrt ≤ Q̄
r=1 t=1
xirt , yirt , zir ∈ {0, 1}, vrt
k
≥0 i = 1, . . . , I; r = 1, . . . , R; t = 1, . . . , T ; k = 1, . . . , K (7)
11.5.2. Decisiones en etapas: comentarios

La modelación “con recurso” ha sido de gran utilidad en diversas áreas de aplicación. Una de las más antiguas
es la Planificación de Sistemas Eléctricos y también los problemas de Planificación de Producción.
El proceso puede extenderse a más de una etapa, es lo que se conoce como un “Multistage Stochastic
Problem”. En este caso la complejidad aumenta en forma significativa debido a que cada escenario de una
etapa genera otros escenarios en la etapa siguiente. Se han desarrollado, eso sı́, técnicas de aproximación que
permiten abordar estos problemas, especialmente apoyados en los recursos computacionales existentes hoy.
En ese sentido, estos problemas son buenos ejemplos de los niveles de complejidad que puede alcanzar la
optimización, muchas veces alcanzan decenas de millones de variables y restricciones, pero con las “viejas”
técnicas que hemos estudiado pueden ser abordados en forma aproximada, algo que no se podı́a hacer hace
un par de décadas.
En forma alternativa a la aproximación por SAA, el problema de 2 etapas puede ser abordado mediante una
técnica de subgradientes ya que la función objetivo es convexa. Eso lleva a otro método, que también tiene
propiedades atractivas para algunos problemas.

Capítulos 1-2 2023-2

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Capítulos 1-2 2023-2

Cargado por

Copyright:

Formatos disponibles

Pontificia Universidad Católica de Chile

1. Introducción: problemas y algoritmos 5

2. Métodos del Gradiente, Newton y extensiones 9

3. Métodos de Primer Orden 40

4.2.1. Algoritmo Backwards DP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5. Geometrı́a de la Programación Lineal y Extensiones 93

6. Optimización de gran tamaño 112

7. El Enfoque Dual para Problemas de Gran Tamaño 141

8.4. Algoritmos Genéticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

9. Complejidad Computacional 168

10.Algoritmos de Punto Interior 171

11.Optimización Bajo Incertidumbre 185

Introducción: problemas y algoritmos

1.1. El problema general

Donde x es un vector que está en Rn , f : Rn → R y el conjunto S ⊂ Rn corresponde al dominio. Este

Donde f : Rn → R, gi : Rn → R y S ⊂ Rn . Si bien, en la mayorı́a de los casos haremos explı́citas las

1.2. Soluciones aproximadas

Derivando e igualando a cero:

Figura 1.1: Solución épsilon óptima y épsilon aproximada

1.3. Algoritmos y oráculos

Oráculo/información Valores Derivadas Segundas derivadas

Figura 1.2: Puntos encontrados por un oráculo de orden cero

Métodos del Gradiente, Newton y

2.1. La idea del Algoritmo de Descenso

Definición 2.1.1: Dirección de Descenso

f (x + λd) < f (x), ∀λ ≥ 0, λ ≤ r

Alternativamente, d es dirección de descenso si la derivada direccional en la dirección d (el producto punto

Figura 2.1: Dirección de descenso

Algoritmo del Método básico de Descenso

2.2. Método del Gradiente

El Método del Gradiente o Método de Cauchy, utiliza un oráculo

Algoritmo del Método del Gradiente

2. Si k∇f (x)k < : STOP.

Figura 2.2: Dos iteraciones del Método del Gradiente

Cuya solución se encuentra derivando respecto a λ e igualando a cero:

Si λk−1 es la solución del problema de lineasearch correspondiente, entonces como

dk = −∇f xk = −∇f xk−1 + λk−1 dk−1

mı́n f (x1 , x2 ) = 5x21 + x22 + 4x1 x2 − 14x1 − 6x2 + 20

cuya solución óptima es (1, 1) con f (1, 1) = 10.

Para xk dado podemos calcular todo:

f (xk + λdk ) = 5(xk1 + λdk1 )2 + (xk2 + λdk2 )2 +

def gradiente(Q, c, alpha, x0, epsilon, iteracion maxima):

while iteracion <= iteracion_maxima:

# 2: Se analiza el criterio de parada segun la norma

# 3: Se resuelve el subproblema de lambda

# 4: Se actualiza el valor de x para la siguiente iteracion del algoritmo

x, iteracion = x + lambda_ * direccion_descenso, iteracion + 1

valor, x = gradiente(Q, c, alpha, x0, epsilon, iteracion_maxima)

2.3. Método de Newton

con ∇2 f (x) definida positivo.

Una intuición de la evolución de los puntos es la de la Figura 2.3

El valor de y corresponde a el vector que minimiza la aproximación cuadrática de f evaluado en el vector x.

Algoritmo del Método de Newton

3. Sea λk solución de:

def newton(Q, c, alpha, x0, epsilon, iteracion maxima):

- x0: punto inicial de prueba.

while iteracion <= iteracion_maxima:

# 2: Se analiza el criterio de parada segun la norma

# 3: Se resuelve el subproblema de lambda

# 4: Se actualiza el valor de x para la siguiente iteracion del algoritmo

valor, x = newton(Q, c, alpha, x0, epsilon, iteracion_maxima)

Cápsula de video 2.3.1: Los Métodos de Descenso

2.4. Midiendo la eficiencia de un algoritmo

Definición 2.4.1: Convergencia Lineal

2. Si k∇f (x)k < : STOP.

2k ln(β) + 2k ln (e0 ) − ln(β) ≤ ln()

(1) βe0 > 1 ∧ β > 1 : (2) βe0 > 1 ∧ β < 1 :

0. Sea x0 ∈ Rn , H 0 ∈ Rn×n , k = 0, > 0.

suma_i += w[nk+i] tanh(B[l, i]) # Suma de la 3ra sumatoria