Méthodes de décomposition pour les problèmes SDP · Projet de Fin d’Études (PFE) Spécialité : Optimisation Année scolaire : 2016/2017 Méthodes de décomposition pour les

Projet de Fin d’Études (PFE)

Spécialité : Optimisation

Année scolaire : 2016/2017

Méthodes de décomposition pour les

problèmes SDP Rapport de stage

Auteur : Julie Sliwak Promotion : 2017

Enseignant référent ENSTA ParisTech Tuteur organisme d’accueil

Pierre Carpentier Manuel Ruiz

Mention de confidentialité Non confidentiel

Méthodes de décomposition pour les problèmes SDP

SLIWAK Julie / RTE R&D Rapport non confidentiel

3

Note de non confidentialité

Ce document est non confidentiel. Il peut être communiqué à l’extérieur sous format papier mais également diffusé sous format électronique.



4

Remerciements Je voudrais remercier mon tuteur Manuel Ruiz, responsable d’étude R&D chez RTE, pour son suivi

permanent et pour tout ce qu'il m'a appris durant ce stage aussi bien au niveau des connaissances

scientifiques que sur le plan méthodologique. Je tiens aussi à le remercier de m'avoir proposé de

continuer mes travaux en thèse CIFRE avec lui.

Je voudrais aussi remercier Lucas Létocart et Emiliano Traversi, chercheurs au LIPN (Laboratoire

d'Informatique de l'université Paris Nord), pour leur collaboration et leur invitation aux JPOC

(Journées Polyèdres et Optimisation Combinatoire), séminaire qui a confirmé mon souhait de

m'engager en thèse.

Merci à mon tuteur ENSTA Pierre Carpentier pour sa participation à la réflexion autour des

méthodes de décomposition pour les SDP.

Je tiens aussi à remercier Jean Maeght, responsable d’études R&D chez RTE, qui a fait son possible

pour intégrer les stagiaires au sein de la R&D et de tous les événements qui y sont liés.

Plus généralement, j'aimerais remercier toutes les personnes de la R&D à Versailles pour leur

accueil et leur gentillesse.



5

Résumé Le problème de l’OPF (Optimal Power Flow) - problème d’optimisation des flux de puissance sur le réseau électrique – peut être formulé sous forme de QCQP (Problème Quadratique avec Contraintes Quadratiques). La relaxation SDP (Semi-Definite Pogramming) de ce problème, obtenue avec la relaxation du rang, fournit soit la solution optimale quand il n’y a pas de saut de dualité, soit une bonne borne inférieure. Les instances SDP de taille moyenne sont résolues de manière efficace par les algorithmes de points intérieurs. L’extension cordale et la décomposition en cliques sur le graphe du réseau permettent la résolution d’instances plus grandes. Toutefois, toutes les instances ne sont pas résolues par les solveurs : des problèmes numériques sont rencontrés. La décomposition en cliques permet de gérer les problèmes de mémoire mais des problèmes de convergence sont toujours observés. Pour assurer la convergence, nous proposons un algorithme de génération de colonnes qui exploite la structure décomposée fournie par les cliques. Cette méthode duale itérative implique deux étapes : la résolution d’un problème maître et celle d’un sous-problème SDP pour chaque clique. Des méthodes de stabilisation comme la méthode des faisceaux sont implémentées pour améliorer l’efficacité de l’algorithme. Des premiers résultats sont présentés sur des petites instances MATPOWER (instances de 2 à 14 nœuds). Mots-clés : OPF de grande taille – relaxation du rang – SDP de grande taille – génération de colonnes – méthode des faisceaux Abstract

The Optimal Power Flow (OPF) can be formulated as a Quadratically Constrained Quadratic Problem (QCQP). The rank one Semi-Definite Programming (SDP) provides either the optimal solution when there is no duality gap or a tight lower bound.

Small-to-medium-sized SDP instances are efficiently solved by Interior Points (IP) state-of-art solvers. Moreover, chordal extension and clique decomposition on the power network graph enable the resolution of large instances.

However, some instances still remain unsolvable due to numerical matters: memory issues are handled by clique decomposition but solvers do not succeed to fully achieve convergence. In order to ensure convergence, we propose a column generation algorithm exploiting the decomposed structure coming from cliques. This iterative dual approach involves two stages: resolution of a master problem and resolution of a smaller SDP subproblem for each clique. Stabilization methods such as conic-bundle are used to improve standard column generation efficiency. First computational results on small MATPOWER instances (networks from 2 to 14 buses) are presented.

Key-words: large-scale OPF – rank relaxation – large-scale SDP – column generation - conic-bundle



6

Table des matières

Remerciements .................................................................................................. 4

Résumé .............................................................................................................. 5

Introduction ....................................................................................................... 7

1. Présentation du sujet ................................................................................... 8

1.1. Contexte et motivations ........................................................................................... 8

1.2. Etat de l’art .............................................................................................................. 9

1.3. Formulation du problème ......................................................................................... 9

2. Méthode retenue : la génération de colonnes ............................................ 13

2.1. Comparaison de trois méthodes de la littérature .................................................... 13

2.2. Description de l’algorithme .................................................................................... 14

2.2.1. Principe de la génération de colonnes .................................................................... 14

2.2.2. Utilisation des blocs ................................................................................................ 16

2.2.3. Phase de faisabilité .................................................................................................. 18

2.2.4. Convergence ............................................................................................................ 19

3. Stabilisation : implémentation et tests ...................................................... 22

3.1. Stabilisation avec les points intérieurs .................................................................... 22

3.2. Stabilisation avec la norme 2 .................................................................................. 23

Conclusion ....................................................................................................... 28

Bibliographie .................................................................................................... 29



7

Introduction J’ai effectué mon stage à la R&D de RTE avec l’équipe optimisation du pôle Développement du Système. RTE est en charge de la gestion du réseau français de transport d'électricité à haute et très haute tension. Assurant une mission de service public, RTE est garant du bon fonctionnement et de la sûreté du système électrique en France, dans un marché ouvert à la concurrence. Dans ce cadre, RTE exploite et entretient le réseau français de transport d'électricité à haute et très haute tension, réseau le plus important d'Europe (100 000 km de lignes et 46 lignes transfrontalières). RTE est une entreprise résolument tournée vers l'avenir, acteur de la transition énergétique en cours et soucieux d'un développement durable. Ses 8300 salariés travaillent à faire de RTE une entreprise innovante et performante dans le domaine du transport de l'électricité. Les principales activités de la R&D concernent la réalisation d’études prospectives, la fourniture d’expertise sur le fonctionnement des réseaux électriques et le développement d’outils d'étude et d'exploitation du réseau. Le pôle Développement du Système développe et maintient différents modules de résolution du problème d’optimisation des flux de puissance sur le réseau électrique (OPF pour Optimal Power Flow). De précédents travaux ont montré que la résolution de ce problème non convexe passait par la résolution de problème SDP (Semi Definite Programming) de grande taille. Les seules approches actuellement disponibles consistent en des algorithmes de points intérieurs implémentés dans MOSEK ou SEDUMI qui ne sont plus efficaces lorsque le problème devient trop grand (dimensions de l’ordre de quelques milliers, dizaines de milliers). L’objectif de ce stage était donc de prototyper une méthode de décomposition pour les SDP. Ce stage a comporté trois étapes essentielles :

- l’étude des méthodes de décomposition proposées dans la littérature afin d’évaluer leurs avantages et leurs inconvénients

- le choix d’une méthode adaptée à nos problèmes - l’implémentation de cette méthode et de ses variantes

Après avoir présenté le sujet, je présenterai la méthode que nous avons retenue après l’étude de la littérature : la génération de colonnes. Enfin, je présenterai deux méthodes de stabilisation qui permettent d’améliorer l’efficacité de cet algorithme.



8

1. Présentation du sujet

1.1. Contexte et motivations L’Optimal Power Flow (OPF) est le problème d’optimisation des flux de puissance sur le réseau électrique. Le réseau électrique est modélisé par un graphe dans lequel les nœuds sont des points de consommation et/ou production et où les arêtes représentent les lignes électriques ou les transformateurs liant ces nœuds. Le réseau électrique fonctionne en courant alternatif ce qui fait intervenir l’impédance complexe des équipements ; on parle d’ACOPF (Alternative Current OPF). L’ACOPF représente généralement un état stationnaire du système. L’ACOPF se formule sous forme de Problème Quadratique avec Contraintes Quadratiques (QCQP) avec les tensions complexes en chaque nœud du réseau comme variables :

min𝑉𝐻𝐴0𝑉

𝑠. 𝑡. 𝑉𝐻𝐴𝑝𝑉 ≤ 𝑏𝑝∀𝑝 = 1. . 𝑚

𝑉 ∈ ℂ𝑛

La fonction objectif peut être la minimisation des coûts de production ou la minimisation de la production totale (ie la minimisation des pertes par effet Joule). Les contraintes sont des contraintes de bilan aux nœuds, de transfert d’énergie et de limites de production. La résolution de ce problème est un enjeu pour RTE puisque l’ACOPF intervient dans de nombreux projets. Cependant, ce QCQP est non convexe et NP-difficile et même s’il est l’objet de travaux depuis 1962 [1], il est encore aujourd’hui difficilement résolu de manière exacte. Des travaux précédents (thèse de Cédric Josz [2] et thèse en cours d’Hadrien Godard) ont montré que la résolution globale de l’ACOPF nécessite la résolution de SDP creux (relaxation du rang [3]). En effet, l’ACOPF formulé en QCQP complexe peut se réécrire à l’aide de la matrice hermitienne W :

min𝑉𝐻𝐴0𝑉

𝑠. 𝑡. 𝑉𝐻𝐴𝑝𝑉 ≤ 𝑏𝑝∀𝑝 = 1. .𝑚

𝑉 ∈ ℂ𝑛

min𝐴0 ⋅ 𝑊

𝑠. 𝑡. 𝐴𝑝 ⋅ 𝑊 = 𝑏𝑝∀𝑝 = 1. .𝑚

𝑊 = 𝑉𝑉𝐻 ⟺ {𝑊 ≽ 0

𝑟𝑎𝑛𝑔(𝑊) = 1

𝑊 ∈ ℍ𝑛

Et en supprimant la contrainte de rang (relaxation du rang), on obtient un problème SDP en nombre complexes :

min𝐴0 ⋅ 𝑊

𝑠. 𝑡. 𝐴𝑝 ⋅ 𝑊 = 𝑏𝑝∀𝑝 = 1. . 𝑚

𝑊 ≽ 0

𝑊 ∈ ℍ𝑛

Ce problème est ensuite reformulé en réels avec une matrice SDP de taille 2n.



9

Les relaxations SDP de l’ACOPF peuvent être de grande taille (certains réseaux possèdent plus de 13 000 nœuds) ; or la résolution de problèmes SDP creux de grande taille est aujourd’hui encore l’objet de recherches. La motivation de ce stage est donc la conception d’une méthode permettant de résoudre les SDP creux de grande taille issus de relaxations des ACOPF. Notre but est d’élaborer une méthode qui converge rapidement et qui exploite un bon point de départ : en effet, si on résout le QCQP avec un solveur non linéaire (problème non convexe donc on ne sait pas si on obtient l’optimum global du QCQP), on obtient un point qui est souvent proche de la solution optimale du problème SDP.

1.2. Etat de l’art Les problèmes SDP de taille moyenne sont résolus de manière efficace par les solveurs utilisant la méthode des points intérieurs (dimension de la matrice SDP et nombre de contraintes du problème allant jusqu’à quelques milliers). Pour gérer les problèmes de mémoire apparaissant pour les problèmes de plus grande taille, des travaux précédents ont montré qu’on pouvait utiliser une reformulation en cliques [4][5] issue d’un algorithme d’extension cordale et de recherche de cliques maximales. Cette reformulation en cliques permet de remplacer la contrainte SDP originelle sur une matrice de grande taille par plusieurs contraintes SDP sur des matrices de plus petite taille. Toutefois, cette reformulation en cliques ne permet pas de résoudre toutes les relaxations SDP de l’OPF : pour certaines instances MATPOWER, le solveur Mosek ne converge pas vers un point optimal. Des problèmes numériques sont mis en évidence dans [6]. Pour pallier ce problème, plusieurs équipes de chercheurs ont travaillé sur l’application de méthodes de décomposition sur le problème reformulé en cliques. Les grands algorithmes de décomposition ont été adaptés aux problèmes SDP : conic-bundle [7], Benders decomposition [8], ADMM (Alternating Direction Method of Multipliers) [9].

1.3. Formulation du problème

Le problème SDP initial s’écrit sous la forme suivante :

min𝑋∈𝑆𝑛

𝐴0 ⋅ 𝑋

𝐴𝑝 ⋅ 𝑋 = 𝑏𝑝∀𝑝 = 1. .𝑚 (𝐶1)

𝑋 ≽ 0

avec les données 𝐴0 ∈ 𝑆

𝑛; 𝐴𝑝 ∈ 𝑆𝑛, 𝑏𝑝 ∈ ℝ ∀𝑝 = 1. .𝑚 et où 𝑆𝑛 désigne l’espace des matrices

réelles symétriques de taille n. Le produit scalaire entre deux matrices symétriques A et B de taille n est défini de la manière suivante : 𝐴 ⋅ 𝐵 = 𝑡𝑟(𝐴𝐵) = ∑ ∑ 𝐴𝑖𝑗𝐵𝑖𝑗

𝑛𝑗=1

𝑛𝑖=1



10

On suppose ici que n et m sont grands (de l’ordre de quelques milliers) et que les matrices de données sont creuses. Les méthodes de décomposition pour les SDP proposées dans la littérature se basent toutes sur le théorème de complétion matricielle. Ce théorème permet en effet de remplacer la contrainte SDP initiale qui porte sur une matrice de grande taille par plusieurs contraintes SDP sur des

matrices de plus petite taille : 𝑋 ≽ 0 ⇔ 𝑋𝑖 ≽ 0 ∀𝑖 = 1. . 𝑟 𝑎𝑣𝑒𝑐 𝑋 𝑖 ∈ 𝑆𝑛𝑖 𝑒𝑡 𝑛𝑖 ≪ 𝑛

(∗ ∗ ∗ ∗ ∗

∗ ∗

) ≽ 0 ⟺

(

(∗ ∗∗ ∗

)

(∗ ∗∗ ∗

))

≽ 0 ⇔ (

∗ ∗∗ ∗

) ≽ 0 𝑒𝑡 (∗ ∗∗ ∗

) ≽ 0

NB : les blocs peuvent partager des termes Comment trouve-t-on ces blocs ? Pour trouver ces matrices Xi qu’on appelle aussi blocs, trois étapes sont nécessaires : définir la matrice sparsity pattern et son graphe associé puis trouver l’extension cordale minimale de ce graphe et enfin chercher les cliques maximales dans cette extension cordale. Les cliques définiront les blocs.

Les algorithmes d’extension cordale et de recherche de cliques maximales ne sont pas le sujet de ce stage, il faut juste noter qu’il n’y a pas une unique façon de créer les blocs. Les r cliques maximales obtenues permettent de définir les r blocs. Chaque bloc Xi est une matrice de la taille de la clique i. Les sommets contenus dans la clique i permettent de faire le lien entre les coefficients de la matrice originelle X et les coefficients du bloc Xi. Par exemple, si la clique 1 est 𝐶𝑙1 = {1,5,7} alors le bloc 1 est défini de la manière suivante :

Sparsity pattern

•Matrice qui résume les termes utilisés dans le problème

Graphe associé

•Graphe induit par la sparsity pattern

Extension cordale

•Ajout d’arêtes dans le graphe iede termes dans la sparsity pattern

Recherche des cliques maximales

•Définition des blocs



11

𝑋 1 = (

𝑋11 𝑋15 𝑋17𝑋15 𝑋55 𝑋57𝑋17 𝑋57 𝑋77

)

Si les cliques partagent des nœuds alors il y aura des termes communs entre les blocs. Par exemple, si on a une deuxième clique 𝐶𝑙2 = {5,6,7}, on voit que le terme 𝑋55 apparaît dans le bloc 1 et dans le bloc 2 :

𝑋1 = (𝑋11 𝑋15 𝑋17𝑋15 𝑿𝟓𝟓 𝑋57𝑋17 𝑋57 𝑋77

) 𝑋2 = (𝑿𝟓𝟓 𝑋56 𝑋57𝑋56 𝑋66 𝑋67𝑋57 𝑋67 𝑋77

)

Il est donc nécessaire d’ajouter des contraintes pour garder ces liens entre les blocs. On appellera ces contraintes « contraintes de recouvrement » ou contraintes (𝐶2). Il y a deux manières de définir ces contraintes : soit on garde une matrice globale X, soit on s’en passe. En termes de contraintes, cela revient à écrire :

{𝑋221 = 𝑋55𝑋112 = 𝑋55

𝑜𝑢 𝑋221 − 𝑋11

2 = 0

Ces deux écritures entraînent des méthodes de décomposition différentes. Effectivement, pour découpler suivant les blocs, il suffit dans le premier cas de fixer la valeur 𝑋55 tandis que dans le deuxième cas il faudra dualiser pour découpler. On retrouve les deux grandes classes de décomposition : décomposition par allocation et décomposition par les prix. Ensuite il faut réécrire l’objectif et les contraintes en fonction des blocs. Deux choix sont possibles.

Le premier consiste à réécrire 𝐴𝑝 ⋅ 𝑋 𝑒𝑛∑ 𝐴𝑝𝑖 ⋅ 𝑋𝑖𝑖 ∀𝑝 = 0. .𝑚 avec les matrices 𝐴𝑝

𝑖 définies de la

sorte : si 𝑋𝑘𝑙𝑖 = 𝑋𝑠𝑡 alors (𝐴𝑝

𝑖 )𝑘𝑙=

(𝐴𝑝)𝑠𝑡

𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑏𝑙𝑜𝑐𝑠 𝑝𝑎𝑟𝑡𝑎𝑔𝑒𝑎𝑛𝑡 𝑙𝑒 𝑡𝑒𝑟𝑚𝑒 𝑋𝑠𝑡.

Par exemple, supposons que le terme 𝑋55 soit dans le bloc 1 et dans le bloc 2 (𝑋221 =

𝑋55 𝑒𝑡 𝑋112 = 𝑋55) alors (𝐴𝑝

1)22=(𝐴𝑝)55

2= (𝐴𝑝

2)11∀𝑝 = 0. .𝑚.

On peut dire qu’on partage équitablement les termes qui apparaissent dans plusieurs blocs. Si on procède de cette façon, les contraintes (𝐶1) coupleront les blocs.

Le deuxième choix consiste à attribuer chaque terme (𝐴𝑝)𝑠𝑡au bloc de plus petite taille contenant

le terme 𝑋𝑠𝑡. Si on reprend notre exemple, ceci reviendrait à attribuer le terme 𝑋55 au bloc 1

(premier bloc de plus petite taille dans l’ordre lexicographique). On aura donc (𝐴𝑝1)22=

(𝐴𝑝)55𝑒𝑡 (𝐴𝑝2)11= 0.



12

En procédant de cette manière, on pourra attribuer certaines contraintes à un seul bloc et une partie des contraintes (𝐶1) sera désormais non couplante. Nous choisissons donc cette méthode de réécriture. Remarque : Dans le cas général, il est impossible de découpler toutes les contraintes (C1). Finalement, le problème réécrit avec les blocs et sans variable globale (reformulation qu’on utilisera par la suite) est de la forme :

𝑚𝑖𝑛 ∑𝐴0𝑖 ⋅ 𝑋𝑖

𝑟

𝑖=1

𝑠. 𝑡. ∑𝐴𝑝𝑖 ⋅ 𝑋𝑖

𝑟

𝑖=1

= 𝑏𝑝 ∀𝑝 = 1. . 𝑚

𝑋𝑖 ≽ 0, 𝑋𝑖 ∈ ℬ𝑖 ∀𝑖 = 1. . 𝑟



13

2. Méthode retenue : la génération de colonnes

2.1. Comparaison de trois méthodes de la littérature

Les trois algorithmes de la littérature que nous avons étudiés sont : Conic-bundle [7], Benders decomposition [8], ADMM (Alternating Direction Method of Multipliers) [9].

Pour résumer, Conic bundle est une méthode type décomposition par les prix qui utilise la génération de colonnes. Les sous-problèmes sont des sous-problèmes SDP à résoudre avec un solveur.

La décomposition de Benders est une méthode de décomposition par allocation dans laquelle il faut résoudre des sous-problèmes SDP potentiellement infaisables avec un solveur. Il faut alors mettre en œuvre un procédé de restauration de faisabilité pour s’assurer de la convergence de l’algorithme.

Enfin, ADMM (Alternating Direction Method of Multipliers) est une approche duale (utilisant le lagrangien augmenté) conçue pour la parallélisation et dans laquelle on a introduit des variables supplémentaires pour tout découpler. L’intérêt de cette méthode est de n’avoir que des problèmes faciles à résoudre (ie ne nécessitant aucun solveur : formules explicites, projections nécessitant le calcul de valeurs propres et vecteurs propres).

Avantages Inconvénients

Conic bundle Beaucoup utilisé Limite la mémoire utilisée Adapté à la parallélisation Possibilité de stabiliser et de gérer les problèmes de dégénérescence

Problèmes d’instabilité et de dégénérescence

Benders Problèmes de faisabilité lors de la résolution des sous-problèmes

ADMM Conçu pour être très parallélisable Pas besoin de solveur SDP

Difficile à faire converger

La génération de colonnes utilisée dans l’algorithme Conic bundle nous semble donc être la méthode la plus adaptée à nos problèmes. Toutefois, nous gardons en tête l’idée d’ADMM qui consiste à transformer les problèmes SDP en des problèmes de projection : il nous paraît intéressant de pouvoir résoudre les problèmes SDP grâce à la recherche de valeurs propres/vecteurs propres plutôt que d’utiliser un solveur.



14

2.2. Description de l’algorithme

2.2.1. Principe de la génération de colonnes On cherche à résoudre le problème primal :

min𝑋∈𝑆𝑛

𝐴0 ⋅ 𝑋

𝐴𝑝 ⋅ 𝑋 = 𝑏𝑝∀𝑝 = 1. .𝑚

𝑋 ≽ 0

(𝑃)

On dualise le problème initial en le réécrivant grâce au Lagrangien classique 𝐿(𝑋, 𝜆)

𝐿(𝑋, 𝜆) = 𝐴0 ⋅ 𝑋 +∑𝜆𝑝(𝑏𝑝 − 𝐴𝑝 ⋅ 𝑋)

𝑚

𝑝=1

(P) 𝑚𝑖𝑛𝑋≽0

𝑚𝑎𝑥𝜆∈ℝ𝑚

𝐿(𝑋, 𝜆) (D) 𝑚𝑎𝑥𝜆∈ℝ𝑚

𝑚𝑖𝑛𝑋≽0

𝐿(𝑋, 𝜆) = 𝑚𝑎𝑥𝜆𝜙(𝜆)

avec

𝜙(𝜆) = ∑𝜆𝑝𝑏𝑝 +

𝑚

𝑝=1


(𝐴0 −∑𝜆𝑝𝐴𝑝 ) ⋅ 𝑋

𝑚

𝑝=1

La génération de colonnes est en fait une approche duale : on cherche à maximiser 𝜙(𝜆). Pour cela, on peut réécrire le problème (D) sous la forme :

max𝜆,𝑧

∑𝜆𝑝𝑏𝑝 +

𝑚

𝑝=1

𝑧

𝑧 ≤ (𝐴0 −∑𝜆𝑝𝐴𝑝 ) ⋅ 𝑋

𝑚

𝑝=1

∀𝑋 ≽ 0

(𝐷)

Ce problème contient une infinité de contraintes. Pour le résoudre, on utilise la méthode des plans sécants. La méthode des plans sécants est une méthode itérative dans laquelle on résout le problème dual en ajoutant au fur et à mesure les contraintes. On s’arrête lorsqu’on ne trouve plus de contrainte violée. Résoudre (P) grâce à un algorithme de génération de colonnes consiste en fait à résoudre (D) avec la méthode des plans sécants.

En effet, en dualisant le problème (D) restreint à l’ensemble 𝐵 = {�̃�𝑒 ∶ 𝑒 ∈ 𝐸} ⊂ 𝑆+𝑛 = {𝑋 ∶ 𝑋 ≽

0} (problème (𝐷𝐵)), on voit qu’ajouter des contraintes dans le dual revient à ajouter des variables dans le primal :



15

max𝜆,𝑧


𝑚

𝑝=1

𝑧

𝑧 ≤ (𝐴0 −∑𝜆𝑝𝐴𝑝 ) ⋅ 𝑋𝑒

𝑚

𝑝=1

∀𝑋𝑒 ∈ 𝐵 [𝑥𝑒]

(𝐷𝐵)

min𝑥𝑒

∑(𝐴0 ⋅ �̃�𝑒)𝑥𝑒𝑒

∑(𝐴𝑝 ⋅ �̃�𝑒)𝑥𝑒 = 𝑏𝑝𝑒

∀𝑝 = 1. .𝑚 [𝜆𝑝]

∑𝑥𝑒 = 1

𝑒

[𝑧]

𝑥𝑒 ≥ 0

(𝑃𝐵)

NB : les variables duales sont entre crochets Ajouter une colonne c’est donc ajouter une variable 𝑥𝑒 dans le problème primal dont la

contribution dans l’objectif est 𝐴0 ⋅ �̃�𝑒 et 𝐴𝑝 ⋅ �̃�𝑒 dans les contraintes autres que la contrainte de

convexité.

Schéma de l’algorithme

min𝑥𝑒

∑(𝐴0 ⋅ �̃�𝑒)𝑥𝑒𝑒

∑(𝐴𝑝 ⋅ �̃�𝑒)𝑥𝑒 = 𝑏𝑝𝑒

∀𝑝 = 1. .𝑚 [𝜆𝑝]

∑𝑥𝑒 = 1

𝑒

[𝑧]

𝑥𝑒 ≥ 0

(𝑃𝐵)

�̃�𝒆 = 𝑎𝑟𝑔𝑚𝑖𝑛𝑋≽0

(𝐴0 − ∑ 𝜆𝑝𝐴𝑝 ) ⋅ 𝑋𝑚

𝑝=1 (𝑆𝑃𝜆)

Résolution du problème maître Mise à jour des variables duales 𝜆 et z pour calculer un nouveau point

extrême �̃�𝑒

Résolution du sous-problème Ajout du point extrême généré si le coût réduit 𝑅𝐶(𝜆, 𝑧) =

(𝐴0 − ∑ 𝜆𝑝𝐴𝑝 ) ⋅ �̃�𝑒 − 𝑧

𝑚𝑝=1 est

négatif Sinon stop

Initialisation avec la colonne nulle



16

La génération de colonnes consiste donc à résoudre une version restreinte du problème primal sur un sous-ensemble convexe des matrices SDP (problème (𝑃𝐵)) et à ajouter une nouvelle matrice SDP (ou plusieurs) à chaque itération jusqu’à atteindre l’optimalité. Les nouvelles matrices sont générées lors de la résolution du sous-problème SDP (𝑆𝑃𝜆). Algorithme détaillé et bornes :

0. Initialisation avec la colonne Xe nulle (B={0}) + éventuellement une autre colonne

1. Résolution du problème maître (𝑃𝐵). L’objectif de ce problème nous donne une borne

supérieure (Upper Bound) (𝑈𝐵).

2. Mise à jour des variables duales 𝜆 et 𝑧

3. Résolution du sous-problème (𝑆𝑃𝜆) qui nous donne un point �̃�𝑒. A cette étape, on peut

calculer une borne inférieure (Lower Bound) du problème qui correspond à la valeur

duale : 𝐿𝐵 = 𝜙(𝜆) = ∑ 𝜆𝑝𝑏𝑝𝑝 + (𝐴0 − ∑ 𝜆𝑝𝐴𝑝 ) ⋅ �̃�𝑒

𝑚𝑝=1

4. Test sur le coût réduit 𝑅𝐶(𝜆, 𝑧) = (𝐴0 − ∑ 𝜆𝑝𝐴𝑝 ) ⋅ �̃�𝑒 − 𝑧

𝑚𝑝=1 : s’il est strictement négatif,

𝐵 = 𝐵 ∪ {�̃�𝑒}, sinon STOP

5. Retour en 1 tant qu’on ajoute des points à l’ensemble B

Borner le sous-problème pour garantir un saut de dualité nul

La génération de colonnes étant une approche duale, elle n’est valide que si le saut de dualité est nul (ie la solution du dual coïncide avec la solution du primal).

Si le sous-problème comprend uniquement la contrainte SDP, le minimum peut être non borné :

en effet, min𝑋≽0

𝐶 ⋅ 𝑋 = {0 𝑠𝑖 𝐶 ≽ 0−∞ 𝑠𝑖𝑛𝑜𝑛

Or si la valeur du dual est non bornée, le saut de dualité est non nul et la solution du primal ne coïncide pas avec la solution du dual.

Pour borner le problème, on ajoute une contrainte sur la trace de X qui est en fait une agrégation de contraintes présentes dans nos problèmes : nous avons des contraintes VOLTM de type 𝑋𝑖𝑖 +𝑋𝑗𝑗 ≤ 𝑈𝑖𝑗, en les agrégeant, nous obtenons la contrainte 𝑡𝑟𝑎𝑐𝑒(𝑋) ≤ 𝑈 = ∑𝑈𝑖𝑗.

Remarque : l’ajout de cette contrainte de trace permet de résoudre le sous-problème sans solveur SDP. On peut en effet résoudre ce problème grâce aux valeurs propres et vecteurs propres associés à la matrice C [10].

2.2.2. Utilisation des blocs

Pour résoudre le problème maître qui est un programme linéaire, nous utilisons XPRESS ou CPLEX.



17

Pour résoudre le sous-problème qui est un problème SDP, nous utilisons le solveur Mosek. Or si le sous-problème est de grande taille, le solveur ne sera plus efficace (problèmes de mémoire notamment). Il est donc nécessaire d’utiliser la reformulation en blocs. Cette simple reformulation en blocs permet de gérer les problèmes de mémoire mais les solveurs ne sont toujours pas efficaces (problèmes de convergence). Il faut donc utiliser cette reformulation en blocs pour décomposer le problème.

La reformulation en blocs sur le sous-problème permet de découpler suivant les blocs :


(𝐴0 −∑𝜆𝑝𝐴𝑝 ) ⋅ 𝑋

𝑚

𝑝=1

= 𝑚𝑖𝑛𝑋𝑖≽0

(∑(𝐴0𝑖

𝒊

−∑𝜆𝑝𝐴𝑖𝑝 ) ⋅ 𝑋𝑖

𝑚

𝑝=1

) =∑𝑚𝑖𝑛𝑋𝑖≽0

(𝐴0𝑖 −∑𝜆𝑝𝐴

𝑖𝑝 ) ⋅ 𝑋𝑖

𝑚

𝑝=1𝑖

La reformulation en blocs permet de séparer le problème initial en plusieurs problèmes SDP de petite taille et qui sont indépendants (un problème par bloc). Ces problèmes de taille raisonnable peuvent alors être résolus par le solveur Mosek. Enfin on peut générer un point extrême du

problème initial en sommant les solutions obtenues pour chaque bloc (�̃�𝑒 = ∑ �̃�𝑒𝑖

𝑖 ).

On peut aussi appliquer la génération de colonnes dès le départ sur le problème reformulé en blocs : on utilise alors les blocs dans tout l’algorithme. Si on applique la génération de colonnes sur le problème (𝑃𝑏𝑙𝑜𝑐𝑠) :

𝑚𝑖𝑛 ∑𝐴0𝑖 ⋅ 𝑋𝑖

𝑟

𝑖=1

𝑠. 𝑡. ∑𝐴𝑝𝑖 ⋅ 𝑋𝑖

𝑟

𝑖=1

= 𝑏𝑝 ∀𝑝 = 1. .𝑚

𝑋𝑖 ≽ 0 ∀𝑖 = 1. . 𝑟

(𝑃𝑏𝑙𝑜𝑐𝑠)

Le problème maître à résoudre devient :

𝑚𝑖𝑛 ∑∑(𝐴0 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖

𝑒𝑖

∑∑(𝐴𝑝 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖

𝑒𝑖

= 𝑏𝑝 ∀𝑝 = 1. .𝑚

∑𝑥𝑒𝑖 = 1

𝑒

𝑥𝑒𝑖 ≥ 0

(𝑋𝑖 =∑𝑥𝑒𝑖 �̃�𝑒

𝑖

𝑒

)

(𝑃𝐵_𝑏𝑙𝑜𝑐𝑠)

Cette méthode est en fait préférable à celle utilisant les blocs seulement pour résoudre le sous-problème. En effet, comparons le dual des deux méthodes :



18

Problème dual lorsque les blocs ne sont utilisés que pour la résolution du sous-

problème (génération de colonnes appliquée sur (𝑃))

Problème dual lorsque les blocs sont utilisés partout

(génération de colonnes appliquée sur (𝑃𝑏𝑙𝑜𝑐𝑠))

(𝐷𝐵) (𝐷𝐵_𝑏𝑙𝑜𝑐𝑠)

max𝜆,𝑧


𝑚

𝑝=1

𝑧

𝑧 ≤ ∑ (𝐴0𝑖 −∑𝜆𝑝𝐴

𝑖𝑝 ) ⋅ 𝑋𝑒

𝑖

𝑚

𝑝=1𝑖

∀𝑋𝑒 ∈ 𝐵

max𝜆,𝑧


𝑚

𝑝=1

∑𝑧𝑖𝑖

∀𝑖, 𝑧𝑖 ≤ (𝐴0𝑖 −∑𝜆𝑝𝐴


𝑖

𝑚

𝑝=1

∀𝑋𝑒𝑖 ∈ 𝐵𝑖

On peut avoir un maximum plus élevé lorsque les blocs sont utilisés partout puisque


∑ (𝐴0𝑖 − ∑ 𝜆𝑝𝐴

𝑖𝑝 ) ⋅ 𝑋𝑖𝑚

𝑝=1𝒊 ≤ ∑ 𝑚𝑖𝑛𝑋𝑖≽0

(𝐴0𝑖 − ∑ 𝜆𝑝𝐴

𝑖𝑝 ) ⋅ 𝑋𝑖𝑚

𝑝=1𝑖 donc potentiellement une

meilleure borne pour notre problème (la valeur de ce problème étant une borne inférieure de

notre problème à résoudre). Il n’est pas garanti que la borne soit meilleure en utilisant les blocs

mais elle est au moins aussi bonne que lorsque l’on ne les utilise pas.

On choisit donc d’implémenter notre algorithme sur le problème reformulé en blocs.

2.2.3. Phase de faisabilité Il est possible qu’au début de l’algorithme, notre ensemble de points extrêmes ne contienne que des points non faisables. Pour pallier ce problème et assurer la résolution du problème maître, on utilise des variables d’écart tant qu’on n’a pas trouvé de point faisable. Concrètement on résout dans un premier temps le problème suivant qui consiste à minimiser la violation des contraintes :

MIN𝑥𝑒𝑖 ,𝜀𝑝+,𝜀𝑝

− ∑(𝜀𝑝

+ + 𝜀𝑝−

𝑝

)

∑∑(𝐴𝑝 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖

𝑒𝑖

+ 𝜀𝑝+ − 𝜀𝑝

− = 𝑏𝑝 ∀𝑝 = 1. .𝑚

∑𝑥𝑒𝑖 = 1

𝑒

𝑥𝑒𝑖 ≥ 0

𝜀𝑝+ ≥ 0 , 𝜀𝑝

− ≥ 0

L’objectif ∑ (𝜀𝑝

+ + 𝜀𝑝−)𝑝 représente les infaisabilités : on a trouvé un point faisable lorsque les

infaisabilités sont nulles (ou inférieures à 𝜀). Lorsque l’on dispose d’un point faisable, on peut fixer les variables d’écart à 0 et ajouter la fonction à minimiser dans l’objectif ; le problème maître



19

sera toujours faisable. Remarque : on n’ajoute pas de variables d’écart sur la contrainte de convexité car elle peut toujours être satisfaite par le point extrême nul qui est toujours présent dans notre ensemble de points extrêmes

2.2.4. Convergence La méthode des plans sécants est connue pour sa convergence lente essentiellement due à l’instabilité de la variable duale 𝜆. En effet, on observe des oscillations de la fonction duale 𝜙 du problème : il est possible de passer d’un bon point dual à un très mauvais. Ceci affecte la qualité des colonnes générées. Ainsi, en pratique, l’efficacité de l’algorithme de génération de colonne standard est limitée.

Résultats sur les instances case9 et case14 en partant de la colonne nulle

-7.00E+03

-6.00E+03

-5.00E+03

-4.00E+03

-3.00E+03

-2.00E+03

-1.00E+03

0.00E+00

1.00E+03

1 6

11

16

21

26

31

36

41

46

51

56

61

66

71

76

81

86

91

96

10

1

10

6

11

1

11

6

12

1

12

6

13

1

13

6

14

1

14

6

Case 9 - Après la phase de faisabilitéPoint de départ : colonne nulle

Fonction primale Fonction duale Φ

-8.00E+04

-7.00E+04

-6.00E+04

-5.00E+04

-4.00E+04

-3.00E+04

-2.00E+04

-1.00E+04

0.00E+00

1.00E+04

1 8

15

22

29

36

43

50

57

64

71

78

85

92

99

10

6

11

3

12

0

12

7

13

4

14

1

14

8

15

5

16

2

16

9

17

6

18

3

19

0

19

7

20

4

21

1

21

8

22

5

Case 14 - Evolution de 𝜙 après la phase de faisabilitéPoint de départ : colonne nulle



20

On met en évidence sur case9 (réseau complexe à 9 nœuds donc 18 variables) le comportement non monotone de la fonction duale 𝜙 (borne inférieure) contrairement à la fonction primale (objectif du problème maître) qui constitue une borne supérieure. L’instance case14 (28 variables) permet de bien visualiser le phénomène d’oscillations de la fonction duale 𝜙 dû à l’instabilité de la variable duale. De plus, il est frappant de constater que la méthode ne converge pas plus vite lorsqu’on part d’un bon point initial (la solution par exemple). En effet, tel quel, l’algorithme n’exploite pas le fait qu’il a déjà trouvé une bonne solution. Or nous disposons sur la plupart de nos instances d’un bon point initial : le point donné lors de la résolution du QCQP (QCQP présenté dans la partie 1.1 de ce rapport) par le solveur non linéaire Knitro. Par la suite, nous utiliserons souvent le terme « point NLP » pour parler du point issu de la résolution du NLP (Non Linear Problem) que représente le QCQP. Il est habituel d’utiliser la relaxation SDP du QCQP pour obtenir une borne, en revanche, la valeur obtenue en résolvant le QCQP n’est en général pas utilisée pour résoudre le SDP.

Résultats de l’utilisation du point NLP sur l’instance case9

On voit ici que l’utilisation d’un bon point de départ ne permet pas d’améliorer la fonction duale

𝜙. D’ailleurs, l’algorithme converge en 781 itérations avec seulement la colonne nulle en point de

départ alors qu’il converge en 988 itérations en ajoutant la colonne du point NLP.

-5.00E+04

-4.50E+04

-4.00E+04

-3.50E+04

-3.00E+04

-2.50E+04

-2.00E+04

-1.50E+04

-1.00E+04

-5.00E+03

0.00E+00

5.00E+03

1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79 82 85 88 91 94 97

Case 9 - 𝜙 après la phase de faisabilitéComparaison entre initialisation colonne nulle et initialisation

(colonne nulle + colonne NLP)

Initialisation colonne nulle + colonne NLP Initialisation colonne nulle uniquement



21

Il est donc nécessaire de stabiliser l’algorithme afin d’atténuer le phénomène d’oscillations de la

fonction duale 𝜙. On espère ainsi pouvoir profiter du bon point de départ qu’est le point NLP.

Enfin, des problèmes numériques rendent la convergence difficile : les matrices sur lesquelles

nous travaillons sont mal conditionnées. La résolution du problème maître est donc moins

précise, même avec les meilleurs solveurs commerciaux.



22

3. Stabilisation : implémentation et tests Les méthodes de stabilisation sont bien connues [11] et utilisent deux idées. Premièrement, un « bon » point dual défini à partir de tous les points duaux calculés sert de référence tout au long de l’algorithme ; on le met à jour lorsqu’on trouve un point suffisamment meilleur. Deuxièmement, un terme pénalisant les déplacements loin de ce point de référence est ajouté dans l’objectif du dual. Peu de conditions sont imposées sur ce terme pénalisant du point de vue théorique ; ce terme peut être modifié dynamiquement. Nous utiliserons la norme 2 pour ce terme pénalisant mais dans un premier temps, un autre type de stabilisation est possible : la stabilisation avec les points intérieurs.

3.1. Stabilisation avec les points intérieurs

La stabilisation avec les points intérieurs [12][13] est une méthode de stabilisation différente des méthodes classiques puisque la pénalisation se fait lors de la résolution du problème maître. En effet, en résolvant le problème maître (option duale) avec un algorithme barrière limité à quelques itérations sur le chemin central, on obtient un point dual à l’intérieur de l’espace dual à la place d’un point extrême si on utilise l’algorithme du simplexe. Cette méthode limite donc les variations de la variable duale et est facile à implémenter. De plus, un seul paramètre est à régler : le nombre maximal d’itérations autorisées sur le chemin central. Remarque : pour que l’algorithme converge, il est nécessaire d’augmenter le nombre d’itérations autorisées lorsqu’on ne trouve plus de coût réduit négatif - jusqu’à un seuil (e.g. 1000 itérations) au-delà duquel on réactive la procédure de crossover du solveur (XPRESS en l’occurrence) qui permet d’obtenir une solution optimale à partir de la solution des points intérieurs.

Résultats sur l’instance case14 avec 5 itérations autorisées sur le chemin central

-4.00E+06

-3.50E+06

-3.00E+06

-2.50E+06

-2.00E+06

-1.50E+06

-1.00E+06

-5.00E+05

0.00E+00

5.00E+05

1 5 9

13

17

21

25

29

33

37

41

45

49

53

57

61

65

69

73

77

81

85

89

93

97

10

1

10

5

10

9

11

3

11

7

12

1

12

5

12

9Case 14 - Evolution de 𝜙 après la phase de faisabilité

Initialisation : colonne nulle + colonne NLP

Sans stabilisation

Avec stabilisation points intérieurs



23

Sur cette instance comportant 28 variables (réseau complexe de 14 nœuds), on observe que la stabilisation avec les points intérieurs permet d’atténuer de manière significative les oscillations de la fonction duale 𝜙. En revanche, cette stabilisation ne permet pas de tirer parti du bon point initial qu’est la solution du NLP : partir de ce point ne permet toujours pas d’accélérer la convergence. Nous avons donc implémenté une autre méthode de stabilisation, plus classique et connue pour donner de bons résultats : la stabilisation avec la norme 2 ou méthode des faisceaux.

3.2. Stabilisation avec la norme 2

Pour stabiliser, on ajoute un terme pénalisant 𝐷(𝜆 − 𝜆∗) dans l’objectif du dual pour limiter les variations de la variable duale 𝜆 par rapport au meilleur point dual courant 𝜆∗. On peut utiliser la

norme 2 : 𝐷(𝜆 − 𝜆∗) =1

2𝑡||𝜆 − 𝜆∗||

2

2 avec le paramètre t qu’on appelle la tension ; c’est la

méthode des faisceaux utilisée dans la littérature et connue pour donner de bons résultats même dans le contexte de la génération de colonnes.

max𝜆,𝑧


𝑚

𝑝=1

∑𝑧𝑖𝑖

−1

2𝑡||𝜆 − 𝜆∗||

2

2

∀𝑖, 𝑧𝑖 ≤ (𝐴0𝑖 −∑𝜆𝑝𝐴


𝑖

𝑚

𝑝=1

∀𝑋𝑖𝑒 ∈ 𝐵𝑖 [𝑥𝑒

𝑖 ]

(𝐷𝐵_𝑏𝑙𝑜𝑐𝑠 − 𝐿2)

Stabiliser le dual revient à résoudre le problème primal suivant (cf article [11]) :

MIN𝑥𝑒𝑖 ,𝜖𝑝

∑∑(𝐴0 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖

𝑒𝑖

+∑(𝜆∗𝜖𝑝 + 0.5𝑡 ⋅ 𝜖𝑝2)

𝑝

𝜖𝑝 = 𝑏𝑝 −∑∑(𝐴𝑝 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖

𝑒𝑖

∀𝑝 = 1. .𝑚

∑𝑥𝑒𝑖 = 1

𝑒

∀𝑖 = 1. . 𝑟

𝜖𝑝, 𝑥𝑒𝑖 ≥ 0

(𝑃𝐵_𝑏𝑙𝑜𝑐𝑠 − 𝐿2)

Description de l’algorithme

0. Initialisation avec la colonne Xe nulle (B={0}) + éventuellement une autre colonne.

Initialisation de 𝜆∗

1. Résolution du problème maître (𝑃𝐵_𝑏𝑙𝑜𝑐𝑠 − 𝐿2). On peut alors calculer une borne

supérieure du problème à partir de la solution trouvée : 𝑈𝐵 = ∑ ∑ (𝐴0 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖𝑒𝑖 .

Si 𝑈𝐵 = 𝜙(𝜆∗) et 𝜖𝑝 = 0 ∀𝑝 (point faisable), le point est optimal, STOP



24

A cette étape, on calcule aussi l’estimateur 𝜙𝐵 de la fonction duale 𝜙 (définition ci-

dessous dans la condition de Serious Step)

2. Mise à jour des variables duales 𝜆 et 𝑧

3. Résolution des sous-problèmes (𝑆𝑃𝜆𝑖) qui nous donnent des points �̃�𝑒

𝑖 . A cette étape, on

peut calculer la valeur duale : 𝜙(𝜆) = ∑ 𝜆𝑝𝑏𝑝𝑝 + ∑ (𝐴0𝑖 − ∑ 𝜆𝑝𝐴𝑝

𝑖 ) ⋅ �̃�𝑒𝑖𝑚

𝑝=1𝑖 (borne

inférieure du problème)

4. Si "𝜙(𝜆) ≥ 𝜙(𝜆∗)" (Serious Step), mise à jour du meilleur point dual 𝜆∗ : 𝜆∗ ← 𝜆 +

éventuellement mise à jour de la tension t.

Sinon (Null Step), éventuellement mise à jour de la tension.

5. Ajout de colonnes au problème maître et retour en 1 jusqu’à optimalité

"𝝓(𝝀) ≥ 𝝓(𝝀∗)" : condition de Serious Step

On définit une Serious Step avec la condition habituellement utilisée donnée dans [11] :

𝜙(𝜆∗) − 𝜙(𝜆) ≤ 𝑚(𝜙(𝜆∗) − 𝜙𝐵(𝜆)) avec 𝑚 ∈]0,1]

Avec l’estimateur :

𝜙𝐵(𝜆) = ∑𝜆𝑝𝑏𝑝 +

𝑚

𝑝=1

𝑚𝑖𝑛𝑿𝒆∈𝑩

(𝐴0 −∑𝜆𝑝𝐴𝑝 ) ⋅ 𝑋

𝑚

𝑝=1

(signes inversés par rapport à l’article puisque nous sommes ici en maximisation dans le dual)

Remarque : Une phase de faisabilité est aussi nécessaire dans cet algorithme. Tant qu’on n’a pas

trouvé de point faisable, on résout le problème :

MIN𝑥𝑒𝑖 ,𝜖𝑝,𝜀𝑝

+,𝜀𝑝−

∑(𝜀𝑝+ + 𝜀𝑝

−

𝑝

+ 𝜆𝑝∗ 𝜖𝑝 + 0.5𝑡 ⋅ 𝜖𝑝

2)

𝜖𝑝 + 𝜀𝑝+ − 𝜀𝑝

− = 𝑏𝑝 −∑∑(𝐴𝑝 ⋅ �̃�𝑒𝑖)𝑥𝑒

𝑖

𝑒𝑖

∀𝑝 = 1. .𝑚

∑𝑥𝑒𝑖 = 1

𝑒

∀𝑖 = 1. . 𝑟

𝜖𝑝, 𝑥𝑒𝑖 ≥ 0

𝜀𝑝+ ≥ 0 , 𝜀𝑝

− ≥ 0

Les infaisabilités sont alors : ∑ (𝜀𝑝+ + 𝜀𝑝

− + 𝜖𝑝2)𝑝

Dès qu’on a trouvé un point faisable (infaisabilités nulles ou presque), on fixe les variables d’écart

𝜀𝑝+, 𝜀𝑝

− à 0 et on ajoute la fonction à minimiser dans l’objectif.



25

Initialisation

L’initialisation de la variable duale de référence 𝜆∗ est décisive : si on initialise avec un bon point,

on peut converger très vite. On propose d’initialiser avec les variables duales obtenues lors de la

résolution du NLP. L’instance case9 (instance à 18 variables) nous confirme qu’il est possible de

converger très vite avec une méthode stabilisée dans le cas où la résolution du NLP nous donne

l’optimum : nous convergeons en deux ou trois itérations en fonction de la valeur initiale de la

tension. Toutefois, une tension trop élevée (10 000 par exemple) ne permet plus cette

convergence très rapide.

L’initialisation de la tension est donc un enjeu puisqu’idéalement, elle doit prendre en compte la

qualité du point initial et être suffisamment élevée pour garantir le succès de la phase de

faisabilité. Toutefois, en mettant à jour dynamiquement la tension, on peut « corriger » si on a

mal estimé la tension et ainsi donner moins de poids à ce choix de tension initiale.

Mise à jour de la tension t

La convergence de l’algorithme peut être améliorée en changeant dynamiquement la tension au

cours de l’algorithme. L’idée est d’augmenter la tension lors de Serious Steps : on fait confiance à

l’estimateur, il est donc inutile de limiter les déplacements de la variable duale et au contraire de

baisser la tension lors de Null Steps lors desquels l’estimateur est mauvais. Il faut donc limiter les

déplacements de la variable duale pour éviter d’explorer de mauvaises directions en phase de

Null Steps.

Nous proposons la mise à jour dynamique suivante :

- Nous fixons une borne inférieure et une borne supérieure pour la tension t

- Au bout de 5 Serious Steps consécutifs, on multiplie la tension t par 10 si elle n’a pas

encore atteint sa borne supérieure

- Au bout de 5 Null Steps consécutifs, on divise la tension t par 10 si elle n’a pas encore

atteint sa borne inférieure



26

Résultats sur l’instance WB2 avec une tension initiale de 100

Sur l’instance WB2 (2 nœuds donc 4 variables seulement), en partant d’une tension de 100 et en

la mettant à jour dynamiquement comme décrit plus haut, nous convergeons en 39 itérations. En

gardant une tension constante égale à 100, nous n’avons pas convergé au bout de 200 itérations.

On observe effectivement sur le graphe qu’avec une tension dynamique, on améliore plus

rapidement la fonction duale 𝜙 (la borne inférieure du problème).

Notre mise à jour dynamique de la tension semble donc pertinente, toutefois elle pourrait

certainement être réglée plus finement.

1.00E-01

1.00E+00

1.00E+01

1.00E+02

1.00E+03

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

WB2 - (Valeur optimale - 𝜙) après phase de faisabilitéInitialisation : colonne nulle + colonne NLP

Tension statique Tension dynamique



27

Résultats sur l’instance case9mod : comparaison des trois méthodes

On observe que les deux méthodes de stabilisation permettent de se rapprocher plus vite de la

valeur optimale. Il faut cependant noter qu’avec la stabilisation avec les points intérieurs, on

trouve un point faisable après 34 itérations alors que les deux autres algorithmes détectent tout

de suite que le point NLP est faisable.

La méthode avec la norme 2 est plus efficace que la stabilisation avec les points intérieurs ce qui

est bien visible au début sur le graphe mais la tendance semble s’inverser sur la fin du graphe. En

réalité, la stabilisation avec les points intérieurs a été relâchée (plus d’itérations permises sur le

chemin central) tandis que la stabilisation avec la norme 2 ne l’a pas encore été.

Les méthodes de stabilisation permettent en effet d’atténuer le phénomène d’oscillations de la

fonction duale 𝜙 qui ralentit la convergence mais elles ne permettent pas en général d’accélérer

la dernière phase « plateau » où la fonction duale 𝜙 et son estimateur 𝜙𝐵 sont très proches. On

peut notamment se demander à quel moment il est pertinent de désactiver la stabilisation.

De plus, les performances des méthodes stabilisées sont aussi limitées par les problèmes

numériques liés au mauvais conditionnement des matrices utilisées.

1.00E-02

1.00E-01

1.00E+00

1.00E+01

1.00E+02

1.00E+03

1.00E+04

1.00E+05

1.00E+06

1 6

11

16

21

26

31

36

41

46

51

56

61

66

71

76

81

86

91

96

10

1

10

6

11

1

11

6

12

1

12

6

13

1

13

6

14

1

14

6

15

1

15

6

16

1

16

6

Case 9mod : (Valeur optimale - 𝜙) après la phase de faisabilitéInitialisation : colonne nulle + colonne NLP

Sans stabilisation Stabilisation norme 2 Stabilisation points intérieurs



28

Conclusion

Après étude de la littérature, nous avons décidé de prototyper un algorithme de génération de

colonnes pour résoudre nos problèmes. Nous avons constaté les mauvaises performances de cet

algorithme dans sa version standard dues à l’instabilité de la variable duale. Pour pallier cette

instabilité, nous avons mis en œuvre deux méthodes de stabilisation différentes.

La première s’appuie sur l’utilisation de la méthode des points intérieurs pour résoudre le

problème maître : en effet, en limitant la résolution à quelques itérations sur le chemin central,

nous empêchons les brusques variations de la variable duale. Cette première méthode de

stabilisation est simple à implémenter mais ne converge que si l’on permet une résolution exacte

« à la fin ».

La deuxième méthode de stabilisation que nous avons implémentée est une méthode classique

de stabilisation utilisant la norme 2 : la méthode des faisceaux. Cette méthode est bien connue

et utilise une variable duale de référence depuis laquelle on limite les déplacements. Elle est mise

à jour tout au long de l’algorithme. L’utilisation d’une variable duale de référence dans cet

algorithme permet d’exploiter la qualité de la solution obtenue à chaque itération. Un bon point

de départ est donc utile et utilisé dans cet algorithme. Les résultats obtenus sur nos petites

instances semblent encourageants. Toutefois, cette stabilisation comporte tout un jeu de

paramètres dont le réglage est difficile à affiner. De plus, il existe une autre méthode de

stabilisation classique utilisant la norme 1 que nous n’avons pas encore testée.

La résolution des sous-problèmes grâce aux valeurs propres et vecteurs propres est aussi une

piste à explorer. En effet, cette méthode de résolution a l’avantage de pouvoir générer plusieurs

colonnes à la fois : la colonne optimale correspondant à la valeur propre la plus négative et toutes

les colonnes correspondant aux autres valeurs propres négatives.

De plus, nous avons ajouté dans les sous-problèmes une contrainte de trace, agrégation de

contraintes présentes dans nos problèmes. Une autre possibilité est de mettre directement les

contraintes non agrégées (en les retirant du problème maître) pour générer des colonnes de

meilleure qualité.

Enfin, les QCQP, initialement formulés en nombres complexes, sont reformulés en nombres réels

avant d’être relaxés et résolus. Les travaux de Cédric Josz et Dan Molzahn [14] soulèvent la

question de la transposition des algorithmes des nombres réels aux nombres complexes. Il serait

donc intéressant d’étudier par la suite la possibilité d’étendre les méthodes de résolution aux

nombres complexes. Les travaux de Jean Charles Gilbert et Cédric Josz [15] constituent un

premier pas encourageant dans cette direction.

Toutefois, les améliorations de la méthode seront limitées tant qu’il y aura des problèmes

numériques. Un des premiers travaux à la suite de ce stage sera donc d’améliorer le

conditionnement des matrices.



29

Bibliographie [1] J. Carpentier, “Contribution to the economic dispatch problem”, Bulletin de la Société Française des Électriciens, 3(8) :431-447, 1962. [2] Cédric Josz, “Application of Polynomial Optimization to Electricity Transmission Networks”, arXiv, Aug 2016. https://arxiv.org/pdf/1608.03871v1.pdf. [3] J. Lavaei and S. Low, “Zero duality gap in optimal power flow problem,” IEEE Trans. Power Syst., vol. 27, no. 1, pp. 92–107, Feb. 2012. [4] Daniel K.Molzahn and Ian A.Hiskens, “Sparsity-Exploiting Moment-Based Relaxations of the Optimal Power Flow Problem”, IEEE Trans. Power Syst., vol. 30, no. 6, pp. 3168-3180, Nov. 2015. [5] M. Fukuda, M. Kojima, K. Murota, and K. Nakata, “Exploiting sparsity in semidefinite programming via matrix completion I: General framework,” SIAM J. Optimiz., vol. 11, no. 3, pp. 647–674, 2001. [6] Cédric Josz, Stéphane Fliscounakis, Jean Maeght, and Patrick Panciatici, “Ac power flow data in MATPOWER and QCQP format: iTesla, RTE Snapshots, and PEGASE”, arXiv, Mar. 2016. http://arxiv.org/pdf/1603.01533.pdf. [7] Kartik Krishnan Sivaramakrishnan, “A parallel interior point decomposition algorithm for block angular semidefinite programs”, Comput. Optim. Appl, 2008 [8] P. Kleniati, P. Parpas, and B. Rustem, “Decomposition-based method for sparse semidefinite relaxations of polynomial optimization problems”, Journal of Optimization Theory and Applications, 145:289–310, 2010. [9] R. Madani, A. Kalbat, and J. Lavaei, “ADMM for Sparse Semidefinite Programming with Applications to Optimal Power Flow Problem”, in Proc. 54th IEEE Conf. Decis. Control, Dec 2015, pp. 5932–5939. [10] K. Sivaramakrishnan, G. Plaza, and T. Terlaky, “A conic interior point decomposition approach for large scale semidefinite programming”, Technical Report, Department of Mathematics, North Carolina State University, Raleigh, NC, 27695, Dec. 2005. [11] H. Ben Amor, J. Desrosiers, A. Frangioni, “Stabilization in Column Generation”, Les Cahiers du GERAD, G-2004-62, HEC Montréal, Canada, 2003 [12] Louis-Martin Rousseau, Michel Gendreau and Dominique Feillet, “Interior Point Stabilization for Column Generation”, Operations Research Letters, vol. 35, Issue 5, pp. 660-668, Sept 2007. [13] K. Sivaramakrishnan, G. Plaza, and T. Terlaky, “A conic interior point decomposition approach for large scale semidefinite programming”, Technical Report, Department of Mathematics, North Carolina State University, Raleigh, NC, 27695, December 2005.

https://arxiv.org/pdf/1608.03871v1.pdf

http://arxiv.org/pdf/1603.01533.pdf



30

[14] Cédric Josz and Daniel K. Molzahn, “Moment/Sum-of-Squares Hierarchy for Complex Polynomial Optimization”, arXiv, Sep. 2016. http://arxiv.org/pdf/1508.02068v2.pdf. [15] Jean Charles Gilbert and Cédric Josz, “Plea for a semidefinite optimization solver in complex numbers – The full report”, [Research Report] INRIA Paris; LAAS. 2017, pp.46.

http://arxiv.org/pdf/1508.02068v2.pdf

Documents

Méthodes de décomposition pour les problèmes SDP · Projet de Fin d’Études (PFE) Spécialité : Optimisation Année scolaire : 2016/2017 Méthodes de décomposition pour les