Uma Família de Algoritmos Simples para Programação Linear

(1)

Uma Fam´ılia de Algoritmos Simples para Programa¸

c˜

ao Linear

Jair da Silva,

Centro de Ciˆencias Exatas e Tecnologia, UFMS, CCET, 79070-900, Campo Grande, MS

Aurelio R. L. Oliveira, Marta I. Velazco , Carla T. L. S. Ghidini

E-mail: [email protected], [email protected], [email protected] Depto de Matem´atica, Estat´ıstica e Computa¸c˜ao Cient´ıfica, UNICAMP, IMECC,

13083-859, Campinas, SP

Resumo: Nesse trabalho, apresentamos uma fam´ılia de algoritmos para programa¸cão linear. Esta fam´ılia surgiu da generaliza¸cão do algoritmo de ajustamento pelo par ótimo, que por sua vez é baseado no algoritmo de Von Neumann. O algoritmo de Von Neumann é muito atrativo por causa de sua simplicidade, mas ele não é prático para resolver problemas de programa¸cão li-near até a otimalidade, visto que, sua convergência é lenta. O algoritmo de ajustamento pelo par ´

otimo foi desenvolvido com o objetivo de melhorar a convergência prática do algoritmo de Von Neumann, mantendo suas caracter´ısticas atraentes, ao generalizarmos, mantivemos essas ca-racter´ısticas. Através de experimentos numéricos em um conjunto de problemas de programa¸cão linear mostramos melhorias significativas sobre o algoritmo de ajustamento pelo par ótimo.

Palavras-chave: Programa¸c˜ao Linear, Algoritmo de Von Neumann, Algoritmos Simples

1 Introdu¸

c˜

ao

O algoritmo de Von Neumann foi publicado por Dantzig no in´ıcio de 1990 [3, 4] e mais tarde foi estudado por Epelman e Freund [5] e Beck e Teboulle [1]. As propriedades atrativas desse método são seu custo computacional baixo por itera¸cão que é dominado por multiplica¸cão matrix-vetor, a possibilidade de explorar a esparsidade dos dados do problema original e geralmente possuir raio de convergência inicial rápido. Epelman e Freund [5] referem-se a este algoritmo como “elementar”, no sentido de que ele faz somente cálculos simples a cada itera¸cão e, conseq¨ uente-mente, é muito pouco sofisticado, especialmente quando comparado com os algoritmos de pontos interiores modernos.

Gon¸calves em [8] propõe três novos algoritmos desenvolvidos para contornar algumas di-ficuldades de convergência do método original de Von Neumann, dentre eles, o algoritmo de ajustamento pelo par ótimo foi o que obteve o melhor desempenho na prática. O algoritmo de ajustamento pelo par ótimo herda as melhores propriedades do algoritmo de Von Neumann. Embora Gon¸calves prove que em termos de convergência o algoritmo de ajustamento pelo par ´

otimo é superior ao algoritmo de Von Neumann, ainda assim, ele não é uma op¸cão prática para resolver problemas lineares até a otimalidade, visto que, sua convergência também é lenta.

No trabalho [9], generalizamos a idéia apresentada por João Gon¸calves, Robert Storer e Jacek Gondzio em [8], para desenvolver o algoritmo de ajustamento pelo par ótimo. Ao generalizar a idéia em [8], desenvolvemos o algoritmo de ajustamento ´otimo para p coordenadas. Na realidade para cada p temos um algoritmo diferente, onde p ´e limitado pela ordem do problema, assim desenvolvemos uma fam´ılia de algoritmos.

Neste trabalho, através de experimentos numéricos em um conjunto de problemas de pro-grama¸cão linear mostramos melhorias significativas sobre o algoritmo de ajustamento pelo par ´

(2)

2 Descri¸

c˜

ao do Problema

Consideremos o problema de encontrar uma solu¸c˜ao fact´ıvel do conjunto de restri¸c˜oes lineares:

P x = 0, etx = 1, x≥ 0,

(1)

onde P ∈ ℜm×n, x∈ ℜn _{e e} _{∈ ℜ}n_´_{e o vetor com todas as coordenadas iguais a um e as colunas}

de P tem norma um, isto ´e,||Pj|| = 1, para j = 1, . . . , n.

Geometricamente as colunas Pj podem serem vistas, como pontos sobre a hiperesfera

m-dimensional com raio unitário e centro na origem (ver Figura 1). O problema acima então pode ser descrito como de atribuir pondera¸c˜oes xj não negativos `as colunas Pj de modo que depois

de reescalado seu centro de gravidade seja a origem.

P₂ P 3 n P s P₁ uk−1 bk−1 bk P 0

Figura 1: Ilustra¸c˜ao do algoritmo de Von Neumann.

Note que qualquer problema de programa¸c˜ao linear pode ser reduzido ao problema (1), ver [9].

3 Algoritmo de Von Neumann

Em 1948, Von Neumann propˆos para Dantzig, em comunica¸c˜ao privada um algoritmo para programa¸c˜ao linear, que foi divulgado por Dantzig no in´ıcio dos anos 1990 em [3, 4]. Descrevemos a seguir este algoritmo:

Algoritmo de Von Neumann

Dado: x0 ≥ 0, com etx0= 1. Calcule b0= P x0.

Para k = 1, 2, 3, ... fa¸ca

[1] Calcule

s+= argmin_j=1,...,nP_jtbk−1, vk−1= P_st+bk−1.

[2] Se vk−1 > 0, ent˜ao PARE; o problema (1) ´e infact´ıvel.

[3] Calcule uk−1 =||bk−1||, λ = 1−vk−1 (uk−1₎2_−2v k−1+1. [4] Atualize bk= λbk−1+ (1− λ)P_s+, xk = λxk−1+ (1− λ)e_s+,

onde e_s+ ´e o vetor da base canˆonica com 1 na s+-´esima coordenada.

Fim

4 Algoritmo de Ajustamento pelo Par ´

Otimo

O algoritmo de ajustamento pelo par ótimo é a generaliza¸cão do algoritmo de redu¸cão por pesos ver [8]. De um certo modo, podemos dizer que o algoritmo de ajustamento pelo par ótimo, prioriza apenas duas variáveis em cada itera¸cão, porque ele encontra o valor ótimo para duas coordenadas e ajusta o restante das coodenadas em fun¸cão destes valores. Este algoritmo come¸ca

(3)

identificando os vetores P_s+ e P_s− que tem o maior e menor ˆangulo com o vetor bk−1, em seguida ele encontra os valores xk_s+, xk_s− e λ onde xk_j = λx

k−1

j para todo j̸= s+ e j ̸= s−, que minimiza

a distˆancia de bk a origem satisfazendo a convexidade e as restri¸cões de não negatividade. Este problema de otimiza¸cão tem a solu¸cão facilmente calculada examinando as condi¸cões Karush-Kuhn-Tucker (KKT). Descrevemos o algoritmo de ajustamento pelo par ótimo a seguir:

Algoritmo de Ajustamento pelo par ´Otimo Dado: x0≥ 0, com etx0= 1. Calcule b0 = P x0.

Para k = 1, 2, 3, ... fa¸ca

[1] Calcule

s+= argmin_j=1,...,n{P_jtbk−1},

s−= argmax_j=1,...,n{P_jtbk−1| xj > 0},

vk−1 = P_st+bk−1.

[2] Se vk−1 > 0, ent˜ao PARE; o problema (1) ´e infact´ıvel.

[3] Resolva o problema minimizar ||b||2 s.a λ0(1− xk_s+−1− xk_s−−1) + λ1+ λ2 = 1, λi ≥ 0, para i = 0, 1, 2, (2) onde, b = λ0(bk−1− x_sk+−1Ps+ − xk_s₋−1P_s−) + λ₁P_s+ + λ₂P_s−. [4] Atualize bk= λ0(bk−1− xk_s+−1Ps+− xk−1 s− Ps−) + λ1Ps++ λ₂P_s−, uk=||bk||, xk_j =      λ0xk_j−1, j̸= s+e j̸= s−, λ1, j = s+, λ2, j = s−. k = k + 1. Fim.

5 Algoritmo de Ajustamento ´

Otimo para p Coordenadas

O algoritmo de ajustamento pelo par ótimo constru´ıdo por Gon¸calves em sua tese prioriza duas coordenadas em cada itera¸cão. Vamos nos referir a este, como o algoritmo para 2 variáveis. Utilizando a mesma idéia contida neste algoritmo podemos generalizá-lo e construir o algoritmo para p vari´aveis. A idéia central utilizada no algoritmo para 2 variáveis para dar prioridade as duas coordenadas é resolver o subproblema (2). Este subproblema pode ser generalizado, e ao invés de utilizarmos duas colunas para formular o problema, podemos utilizar qualquer quantidades de colunas e assim dar importância a quantas variáveis desejarmos.

A maneira como escolhemos as variáveis para dar prioridade é livre e podemos escolhê-las, de acordo com o problema que iremos resolver. Uma escolha natural se vamos construir um algoritmo para p vari´aveis, ´e tomarmos p/2 colunas que fazem o maior ângulo com o vetor bk e as outras p/2 colunas s˜ao as que fazem o menor ˆangulo com o vetor bk, se p for ´ımpar colocamos

uma coluna a mais para o conjunto de vetores que formam o maior ˆangulo com o vetor bk por exemplo.

O algoritmo de ajustamento ´otimo para p coordenadas segue as mesmas linhas do algoritmo de ajustamento pelo par ´otimo:

Algoritmo de Ajustamento ´Otimo para p Coordenadas Dado: x0≥ 0, com etx0= 1. Calcule b0= P x0.

Para k = 1, 2, 3, ... fa¸ca

[1] Calcule

P_η+

1, . . . , Pη +

s1 que fazem os maiores ˆangulos com o vetor b

(4)

P_η−

1, . . . , Pηs2− que fazem os menores ˆangulos com o vetor b

k−1 _{e tal que} xk_i−1 > 0, i = η₁−, . . . , η−_s₂, onde s1+ s2 = p. vk−1= minimoi=1,...,s1P t η+_i b k−1_.

[2] Se vk−1> 0, ent˜ao PARE; o problema (1) ´e infact´ıvel.

[3] Resolva o problema minimizar ||b||2 s.a λ0  ₁₋∑s1 i=1 xk_η−1+ i − s2 ∑ j=1 xk_η−1− j  ₊∑s1 i=1 λ_η+ i + s ∑ j=1 λ_η− j = 1, λ_η+ i ≥ 0, para, i = 1, . . . , s1, λ_η− i ≥ 0, para, j = 1, . . . , s2, (3) onde, b = λ0  bk−1− s1 ∑ i=1 xk−1 η_i+ Pη+_i − s2 ∑ j=1 xk−1 η_j− Pη−_j  + s1 ∑ i=1 λ_η+ i Pη + i + s2 ∑ j=1 λ_η− j Pη−j. [4] Atualize bk= λ0  bk−1− s1 ∑ i=1 xk−1 η_i+ Pη+_i − s2 ∑ j=1 xk−1 η−_j Pη_j−  + s1 ∑ i=1 λ_η+ i Pη + i + s2 ∑ j=1 λ_η− jPηj−, uk =||bk||, xk j =        λ0xkj−1, j /∈ {η+1, . . . , ηs+1, η − 1, . . . , ηs−2}, λ_η+ i , j = η + i , i = 1, . . . , s1, λ_η− j , j = η − j , j = 1, . . . , s2. k = k + 1. Fim

5.1 Resolu¸c˜ao do Subproblema Usando M´etodos de Pontos Interiores

Em cada itera¸cão do algoritmo de ajustamento ´otimo para p coordenadas, ´e necessário resolver o subproblema (3). No caso p = 2, que ´e o algoritmo de ajustamento pelo par ótimo, Gon¸calves resolve este subproblema verificando as condi¸cões KKT, mais precisamente, ele verifica todas as poss´ıveis solu¸cões fact´ıveis das equa¸cões KKT, que neste caso são 7 ver [8]. No caso geral que é o algoritmo para p coordenadas, se resolvermos o subproblema seguindo o mesmo racioc´ınio, o número de casos poss´ıveis de solu¸c˜oes fact´ıveis cresce exponencialmente com o valor de p e este número de casos é exatamente 2p+1− 1 ver [9].

Este fato torna inviável a programa¸cão de um código do algoritmo de ajustamente ótimo para p coodenadas para valores razoavelmente altos de p. Com a finalidade de contornar este problema, abordamos o subproblema (3) de outra forma e podemos resolvê-lo aplicando métodos de pontos interiores. A grande vantagem de usar métodos de pontos interiores para resolver o subproblema (3), é que o custo computacional para resolver um problema de grande porte com uma matriz de ordem 10×10 ou de ordem 100×100 não é significativo, além disso, a programa¸cão de um código para o algoritmo de ajustamento ´otimo para p coordenadas fica bem mais f´acil.

A seguir descreveremos como reformulamos o subproblema (3), para usar um m´etodo de pontos interiores para resolvˆe-lo.

Podemos reescrever bk= Pkλk, onde Pk=

[ wkP_η+ 1 . . . Pη + s1. . . Pη1−. . . Pηs2− ] , wk= bk−1− − s1 ∑ i=1 xk−1 η+_i Pη_i+− s2 ∑ j=1 xk−1 η_j− Pη−_j e λk= ( λ0, λ_η+ 1, . . . , λη + s1, . . . , λη−1 , . . . , λη−s2 ) .

Assim, o subproblema pode ser reescrito como minimizar 1₂||Pkλk||2

s.a atλk= 1,

−λk≤ 0,

(5)

onde a = (a1, 1, . . . , 1) e a1 = 1− s1 ∑ i=1 xk−1 η+_i − s2 ∑ j=1 xk−1

η_j− . Portanto as equa¸c˜oes KKT do problema

(4) s˜ao dadas por P_ktPkλk+ ark− lk= 0 l_ktλk= 0 at_λ k− 1 = 0, (5)

com 0 ≤ lk, λk, onde rk e lk s˜ao os multiplicadores de Lagrange de igualdade e desigualdade

respectivamente. Estas são as equa¸cões aonde aplicamos um método de pontos interiores.

6 Propriedades Te´

oricas do Novo M´

etodo

Em [9], foi demonstrado que o desempenho do novo método é superior em rela¸cão ao algoritmo de Von Neumann. Tamb´em mostrou-se que se p2≥ p1 então o algoritmo de ajustamento ótimo

para p2 coordenadas possui um desempenho superior em rela¸c˜ao ao algoritmo de ajustamento

´

otimo para p1 coordenadas. A seguir apresentamos os teoremas demonstrado em [9].

Teorema 1 O decr´escimo em ||bk|| obtido por uma itera¸cão do algoritmo de ajustamento ótimo para p coordenadas, com 1 ≤ p ≤ n, onde n é dimensão das colunas de P, no pior caso é igual ao obtido por uma itera¸cão do algoritmo Von Neumann.

Teorema 2 O decr´escimo em ||bk|| obtido por uma itera¸cão do algoritmo de ajustamento ótimo para p2 coordenadas, no pior caso é igual ao obtido por uma itera¸cão do algoritmo de ajustamento

´

otimo para p1 coordenadas com p1 ≤ p2 ≤ n, onde n ´e a dimens˜ao das colunas de P .

7 Resultados Num´

ericos

Em nossos experimentos computacionais, foi utilizada uma cole¸cão de 136 problemas de pro-grama¸cão linear. O conjunto de problemas é dividido em 94 problemas da Netlib [2], 7 problemas do Kennington [10], e 35 outros problemas, que não estão dispon´ıveis publicamente e foram ob-tidos com Gon¸calves [8]. Os experimentos foram realizados em uma máquina com processador Intel Core 2 Quad Q9550 2.83 GHz e com 4GB de RAM, em Linux usando o compilador gcc.

Inicialmente executamos o algoritmo de Von Neumann sobre todos os problemas testes e paramos o algoritmo quando a diferen¸ca relativa entre bk−1 e bk foi inferior a 0, 5%. Para cada problema, gravamos o tempo t1 (segundos de CPU) e o n´umero de itera¸c˜oes at´e o tempo t1. Tamb´em gravamos os tempos t2, t3, t4 e t5 (segundos de CPU), esses tempos t2, t3, t4, t5 cor-respondem respectivamente ao tempo de execu¸c˜ao do algoritmo de Von Neumann 3, 5, 10, e 20 vezes o n´umero de itera¸c˜oes em t1. Em seguida, executamos o algoritmo de ajustamento ´otimo para p coordenadas com p = 2, p = 4, p = 10 e p = 20 e, para cada problema, gravamos o res´ıduo ||bk||, para os tempos ti, i = 1, . . . , 5.

Na Tabela 1, apresentamos o total de ganhos dos algoritmos nos problemas em cinco tempos diferentes, ou seja, a percentagem de problemas em que o algoritmo obteve o menor valor do res´ıduo ||bk||, nos tempos t1 at´e t5. A medida do tempo utilizada ´e segundo de CPU.

Tabela 1: Percentual total de ganhos dos algoritmos nos problemas em cinco tempos diferentes

Algoritmo t1 t2 t3 t4 t5

Algoritmo com p=2 17,6% 8,8 % 17,6 % 5,8% 8,8 % Algoritmo com p=4 30,8% 36,0% 30,1 % 21,3 % 23,5 % Algoritmo com p=10 21,3% 30,1% 27,2% 26,4 % 22,7 % Algoritmo com p=20 30,1% 25,0% 25,0% 46,3% 44,8%

(6)

A Tabela 1 mostra que a fam´ılia de algoritmos ´e superior ao algoritmo de ajustamento pelo par ´otimo, que ´e o caso quando p = 2. Nos tempos t4 e t5 podemos notar que o aumento de p, dentro de valores moderados, melhora de forma clara o comportamento do algoritmo.

Na Tabela 2 apresentamos para 30 desses problemas o res´ıduo inicial ||b0|| e o res´ıduo final

||bk_{|| para a fam´ılia de algoritmos com p = 2, p = 4, p = 10 e p = 20 no tempo t4. Esses}

problemas são compostos da seguinte maneira: os 13 primeiros são da cole¸cão Netlib [2], os 7 problemas seguintes são do Kennington [10] e os 10 últimos foram obtidos com Gon¸calves [8].

Tabela 2: O res´ıduo inicial ||b0|| e o res´ıduo final ||bk|| para a fam´ılia de algoritmos com p = 2, p = 4, p = 10 e p = 20 no tempo t4 para 30 problemas

Problema t4 ∥b0|| ∥bk||p = 2 ∥bk||p = 4 ∥bk||p = 10 ∥bk||p = 20 25fv47 0.029999 0.0412200 0.01018641 0.00873679 0.00803010 0.00787409 80bau3b 0.140000 0.19116674 0.00057034 0.00044748 0.00029273 0.00027945 adlittle 0.000001 0.10179012 0.00358657 0.00347792 0.00297776 0.00109284 afiro 0.000001 0.07248839 0.00550951 0.00473803 0.00512445 0.00491070 agg 0.000001 0.02631100 0.01745662 0.01582553 0.01634469 0.01767965 agg2 0.010000 0.04560447 0.00011407 0.00196998 0.00042432 0.00016327 agg3 0.010000 0.04541540 0.00454151 0.00095714 0.00044020 0.00016100 bandm 0.000001 0.03272470 0.01721324 0.03272470 0.03272470 0.01976061 beaconfd 0.010000 0.0895998 0.00353467 - 0.00101757 -blend 0.010000 0.04778603 0.00485745 0.00450623 0.00347062 0.00153875 bnl1 0.010000 0.06790380 0.01031799 0.00598910 0.00572614 0.00553834 bnl2 0.040000 0.02347880 0.01055613 0.00928479 0.00733928 0.00696482 boeing1 0.020000 0.0889046 0.01208535 0.00849489 0.00941634 0.00901070 cre-a 0.020000 0.20343858 0.00518147 0.00442127 0.00321419 0.17712447 cre-b 0.130000 0.38141155 0.02653284 0.01204324 0.01063743 0.24327604 cre-c 0.010000 0.20881139 0.00558803 0.00575423 0.00234614 0.17383039 cre-d 0.089999 0.38518965 0.01010639 0.00172659 0.00699138 0.24422172 osa-07 0.059999 0.45860119 0.00316221 0.00269401 0.00183989 0.26033264 osa-14 0.140000 0.45969207 0.00236939 0.00163928 0.00137778 0.00101630 osa-60 0.689999 0.45958406 0.00139096 0.00095525 0.00071558 0.00054528 fort51 0.020001 0.1815249 0.00143539 0.00101758 0.00081646 0.00055991 fort52 0.020001 0.22681611 0.00020160 0.00020070 0.00019858 0.00019814 fort53 0.020001 0.22681628 0.00023213 0.00023033 0.00022672 0.00022539 fort54 0.020001 0.17303731 0.00061525 0.00047913 0.00037457 0.00032758 fort55 0.020001 0.17304066 0.00061525 0.00047776 0.00037958 0.00032758 fort56 0.020001 0.21803023 0.00018194 0.00018011 0.00018033 0.00017930 fort57 0.020001 0.21803058 0.00020813 0.00020629 0.00020501 0.00020406 fort58 0.020001 0.22271595 0.00019802 0.00019695 0.00019478 0.00019495 fort59 0.020001 0.22271618 0.00141698 0.00022454 0.00022276 0.00023765 fort60 0.020001 0.2204521 0.00020135 0.00019958 0.00019697 0.00019755

8 Conclus˜

oes

Neste trabalho apresentamos uma nova fam´ılia de algoritmos para programa¸cão linear. A grande vantagem desta fam´ılia de algoritmos é a sua simplicidade e seu raio de convergência inicial rápido. Apresentamos resultados computacionais que mostram que a fam´ılia de algoritmos é superior, quando comparado com o algoritmo de ajustamento pelo par ótimo que é o caso

(7)

quando p = 2. Os tempos t4 e t5 deixam expl´ıcito o que diz o teorema 2 para valores de p moderados, que aumentando o valor de p aumenta a robustez do algoritmo de ajustamento para

p coordenadas.

Apesar das melhorias em rela¸cão ao algoritmo de ajustamento pelo par ótimo, a fam´ılia de algoritmos ainda é pouco prática para a resolu¸cão de problemas de programa¸cão linear até a otimalidade. No entanto, ela pode ser útil em algumas situa¸cões como por exemplo para melhorar o ponto inicial de métodos de pontos interiores como em [6], ou para trabalhar em conjunto com métodos de pontos interiores utilizando seu raio de convergência inicial rápido como em [7], contudo, pesquisas futuras são necessárias para medir o impacto que a fam´ılia de algoritmos pode ter nessa dire¸cão.

Referˆ

encias

[1] A. Beck and M. Teboulle. A conditional gradient method with linear rate of convergence for solving convex linear systems. Mathematical Methods of Operations Research, 2004. [2] NETLIB collection LP test sets. Netlib lp repository. Online at

http://www.netlib.org/lp/data.

[3] G. B. Dantzig. Converting a converging algorithm into a polynomially bounded algorithm. Technical report, Stanford University, SOL 91-5, 1991.

[4] G. B. Dantzig. An ϵ-precise feasible solution to a linear program with a convexity constraint in _ϵ12 iterations independent of problem size. Technical report, Stanford University, SOL

92-5, 1992.

[5] M. Epelman and R. M. Freund. Condition number complexity of an elementary algorithm for computing a reliable solution of a conic linear system. Mathematical Programing, 88:451– 485, 2000.

[6] C. T. L. S. Ghidini, A. R. L. Oliveira, and J. Silva. Optimal adjustment algorithm for p co-ordinates and the starting point in interior point methods. American Journal of Operations

Research, 2011.

[7] C. T. L. S. Ghidini, A. R. L. Oliveira, J. Silva, and M.I. Velazco. Combining a hybrid preconditioner and a optimal adjustment algorithm to accelerate the convergence of interior point methods. Aceito para publica¸c˜ao em Linear Algebra and its Applications, 2012.

[8] J. P. M. Gon¸calves, R. H. Storer, and J. Gondzio. A family of linear programming algorithms based on an algorithm by von neumann. Optimization Methods and Software, 2009. [9] J. Silva. Uma Fam´ılia de Algoritmos para Programa¸c˜ao Linear Baseada no Algoritmo de

Von Neumann. PhD thesis, IMECC – UNICAMP, Campinas SP, Mar¸co, 2009.

[10] J.L. Kennington S. Niemi W.J. Carolan, J.E. Hill and S.J. Wichmann. An empirical eva-luation of the korbx algorithms for military airlift applications. Oper. Res, 38:240–248, 1990.