Exemples de jouets pour les solveurs Plotkin-Shmoys-Tardos et Arora-Kale

Je voudrais comprendre comment le solveur SDP d’Arora-Kale se rapproche de la relaxation de Goemans-Williamson dans un temps presque linéaire, comment le solveur de Plotkin-Shmoys-Tardos se rapproche de problèmes de "compression" et de "couverture" fractionnels dans un temps presque linéaire, et comment les algorithmes sont des instanciations du cadre abstrait "apprendre des experts".

La thèse de Kale a une excellente présentation, mais je trouve très difficile de passer directement dans le cadre abstrait et je préférerais partir d'un exemple de problème simple pour lequel il est absolument évident de savoir quoi faire, puis passer à des problèmes plus généraux. , en ajoutant progressivement des "caractéristiques" à l’algorithme et à son analyse.

Par exemple:

Comment Plotkin-Shmoys résout-il la relaxation de programmation linéaire de la couverture de vertex non pondérée? Couverture de vertex pondérée? Set de couverture? Correspondance bipartite?

Quel est l'exemple le plus simple dans lequel l'algorithme Arora-Kale fait quelque chose d'intéressant? Comment calcule-t-il la plus grande valeur propre du laplacien d'un graphe?

(Calculer la plus grande valeur propre du laplacien équivaut au problème de la résolution d'une version plus faible de la relaxation Goemans-Williamson SDP de Max Cut, dans laquelle, au lieu d'exiger que chaque vecteur soit de longueur un, vous voulez la somme des carrés. des normes à être | V |.)

Luca, depuis un an, vous avez probablement recherché votre propre réponse. Je réponds à certaines de vos questions ici pour le compte rendu. Je passe en revue quelques algorithmes de relaxation lagrangienne pour les problèmes que vous avez mentionnés et trace le lien avec l’apprentissage (en particulier, à la suite de conseils d’experts). Je ne commente pas ici les algorithmes SDP.

Notez que les algorithmes particuliers que vous avez mentionnés ne fonctionnent pas dans un temps presque linéaire. (Il existe un algorithme de temps quasi linéaire pour les problèmes d'emballage ou de couverture explicitement donnés. Voir Simulation de battements pour les programmes d'emballage linéaire et de couverture fractionnés .) Les algorithmes que vous avez en tête ont en général des variantes qui s'exécutent dans un nombre presque linéaire d' itérations , mais l'itération nécessite généralement au moins un temps linéaire. Je discute de certains de ces algorithmes ci-dessous.

Quelques fonctions utiles

$y$$\mbox{Lmax}(y)$$\ln \sum_i \exp(y_i)$$\max_i y_i$

$$\max_i y_i ~\le~ \mbox{Lmax}(y) ~\le~ \max_i y_i + \ln m.$$ $\mbox{Lmin}(y)$$-\mbox{Lmax}(-y)$$\min_i y_i$

Par souci de commodité, nous utilisons le gradient de Lmin. Nous utilisons pour désigner le gradient de Lmax.$g(y)$$\nabla \mbox{Lmin}(y)$$G(y)$$\nabla \mbox{Lmax}(y)$

De manière explicite, est alors que est .$g_i(y)$$\exp(-y_i)/\sum_{i'} \exp(-y_{i'})$$G_i(y)$$\exp(y_i)/\sum_{i'} \exp(y_{i'})$

Lmin et Lmax sont lisses dans le sens suivant: pour tout vecteur et , et $d\in[0,\varepsilon]^n$$y\in R^n$

$$\mbox{Lmin}(y+d) ~\ge~ \mbox{Lmin}(y) ~+~ (1-O(\varepsilon))\, d \cdot g(y)$$ $$\mbox{Lmax}(y+d) ~\le~ \mbox{Lmax}(y) ~+~ (1+O(\varepsilon))\, d \cdot G(y).$$

Notez que les deux gradients ont 1 norme égale à 1: . (Tout au long, nous utilisons pour désigner la norme 1.)$|G(y)| = |g(y)| = 1$$|z|$

Notez également que, pour une matrice , le gradient de la fonction par rapport à est (selon la règle de la chaîne) . Plus explicitement, la dérivée partielle de la fonction par rapport à est . De même, la dérivée partielle de Lmax par rapport à est .$A$$x\mapsto \mbox{Lmin}(Ax)$$x$$(g(Ax))^T A$$x_j$$\sum_i A_{ij} \exp(-A_i x) / \sum_i \exp(-A_i x)$$(Ax)$$x_j$$\sum_i A_{ij} \exp(A_i x)/\sum_i \exp(A_i x)$

Ensemble de fractionnement

Corrige une instance de Set-Cover. Soit la matrice d’incidence élément / ensemble. Ainsi, si , sinon 0 et est la mesure dans laquelle la couverture fractionnaire couvre l'élément .$A$$A_{es} = 1$$e\in s$$A_e x$$x$$e$

Le LP est . Étant donné , l'algorithme est$\min\{ |x| : A x \ge 1; x \ge 0\}$$\varepsilon\in (0,1)$

---

1. Initialise tous les . Soit . $x_s = 0$$N=\log(n)/\varepsilon$

2. Répéter jusqu'à ce que : $\min_e A_e x \ge N$

   2.1. Choisir maximiser la dérivée partielle de Lmin wrt . (Explicitement, choisissez maximiser .) $s$$(Ax)$$x_s$
   $s$$\sum_{e\in s} \exp(-\sum_{s'\ni e} x_{s'})$

   2.2. Augmentez de . $x_s$$\varepsilon$

3. Renvoie .$x/\min_{e} A_e x$

---

L'algorithme retourne une solution approximative dans , où est le nombre d'éléments et la valeur optimale. couverture de jeu fractionnaire (trivialement ). (Un algorithme similaire apparaît dans l'article mentionné par Chandra . Vertex Cover est bien sûr un cas à part.)$(1+O(\varepsilon))$$O(|x^*|\log(n)/\varepsilon^2)$$n$$x^*$$|x^*|\le n$

( Remarque: notez que la limite d'itération ne dépend pas du nombre de jeux, mais seulement du nombre d'éléments. Ainsi, l'algorithme peut être utilisé avec un système de jeu défini implicitement, à condition que, compte tenu du poids des éléments, Trouvez un ensemble de poids total maximal (ou quasi maximal). Ce type d'oracle est identique à l'oracle de séparation requis pour appliquer l'algorithme ellipsoïde au problème double . Pour les problèmes d'emballage tels que l'emballage d'ensemble, vous avez besoin d'un oracle qui, en fonction des poids sur les éléments, retourne un ensemble en minimisant le poids total. Pour des problèmes tels que le flux multi-produits, vous pouvez, par exemple, avoir besoin de trouver un chemin minimisant la somme de certains poids d'arêtes donnés.)

Voici un croquis de la preuve de la garantie de performance. A chaque itération, la dérivée partielle du choisi est au moins égale à, où est la couverture optimale des ensembles fractionnaires.$s$$1/|x^*|$$x^*$

(Pour savoir pourquoi, rappelons que le gradient de Lmin par rapport à est . Si nous devions choisir un ensemble au hasard dans la distribution , la valeur attendue de la dérivée partielle par rapport à serait donc . Depuis , cela est au moins . Puisque , il est au moins égal à . Il doit donc exister des donnant au moins une dérivée partielle . Puisque l'algorithme choisit$(Ax)$$x$$(g(Ax))^T A$$s'$$x^*/|x^*|$$x_{s'}$$(g(Ax))^T \,A x^*/|x^*|$$Ax^* \ge 1$$|g(Ax)|/|x^*|$$|g(Ax)|=1$$1/|x^*|$$s$$1/|x^*|$$x_s$à chaque itération pour maximiser la dérivée partielle, on obtient une dérivée partielle d'au moins.)$1/|x^*|$

Ensuite, la taille de pas est choisie juste assez petite pour qu'aucune coordonnée de n'augmente de plus que . Ainsi, en raison de la finesse de Lmin, augmenter en augmente d’au moins .$\varepsilon$$A x$$\varepsilon$$x_s$$x_s+\varepsilon$$\mbox{Lmin}(Ax)$$(1-O(\varepsilon))\varepsilon/|x^*|$

De cette manière, l'algorithme conserve l'invariant (Notez que Lmin est égal à .)

$$\mbox{Lmin}(Ax) \ge (1-O(\varepsilon)) |x|/|x^*| - \ln n.$$ $(\overline 0)$$\ln n$

A la fin, dans l'invariant, le terme est fois le côté gauche; ainsi, par calcul, on obtient. Après la normalisation dans la dernière ligne de l'algorithme, cela implique.$\ln n$$O(\varepsilon)$$\min_e A_e x \ge (1-O(\varepsilon)) |x|/|x^*|$$|x| \le (1+O(\varepsilon))|x^*|$

FWIW, les inégalités impliquées dans la démonstration de l'invariant sont essentiellement les mêmes que celles impliquées dans la démonstration de la liaison de Chernoff. (En fait, cet algorithme peut être dérivé en appliquant la méthode des probabilités conditionnelles à un schéma d'arrondi aléatoire qui échantillonne de manière répétée des ensembles de la distribution (avec remplacement), en augmentant pour chaque ensemble échantillonné Cette dérandomisation donne l'algorithme suivant: l'invariant sous-jacent est simplement que l'estimateur pessimiste reste en dessous de 1. Les pénalités exponentielles de l'estimateur pessimiste proviennent de l'utilisation de la limite de Chernoff dans l'analyse du schéma d'arrondi. dans le document mentionné par Chandra .)$x^*/|x^*|$$x_s$$s$

Couverture pondérée fractionnée (et couverture fractionnaire générale)

Pour traiter efficacement des problèmes tels que Weighted Set Cover , nous modifions l'algorithme pour utiliser des incréments non uniformes (une idée due à Garg et Konemann ).

Le LP est , où s'étend sur les éléments, sur les ensembles et toutes les variables sont non -négatif. Pour présenter l’algorithme, commencez par récrire le problème en tant que problème général. Soit pour et sinon. Ensuite (avec un changement de variables, en chaque l' de ), le LP est , que nous pouvons voir comme un LP couvrant l’ensemble. Voici l'algorithme:$\min\{ c\cdot x : (\forall e) \sum_{s\ni e} x_s \ge 1\}$$e$$s$$A_{es} = 1/c_s$$e\in s$$A_{es} = 0$$x_s$$c_s$$\min\{ |x| : A x \ge 1; x \ge 0\}$

---

1. Initialise tous les . Soit .$x_s = 0$$N=\log(n)/\varepsilon$

2. Répétez jusqu'à ce que toutes les contraintes de couverture aient été supprimées:

   2.1. Choisir maximiser la dérivée partielle de Lmin wrt . (Explicitement, choisissez maximisant .)$s$$(Ax)$$x_s$
   $s$$\sum_{e\in s} \exp({-\sum_{s'\ni e} x_{s'}})/c_s$

   2.2. Augmentez de , où est choisi de manière maximale, de sorte que, pour toute contrainte de couverture restante , l'augmentation de vaut au plus .$x_s$$\delta$$\delta$$e$$A_e \cdot x$$\varepsilon$

   2.3 Supprimer toutes les contraintes couvrant telles que .$e$$A_e\cdot x \ge N$

3. Renvoie .$x/\min_e A_e\cdot x$

---

L'algorithme renvoie une solution approchée dans , où est le nombre de contraintes de couverture. (Chaque itération augmente certains restants de ; cela ne peut arriver que fois à une contrainte avant qu'elle ne soit supprimée.) La preuve de l'exactitude est essentiellement par le même invariant que pour Set Cover.$(1+O(\varepsilon))$$O(n\log(n)/\varepsilon^2)$$n$$A_e x$$\varepsilon$$N/\varepsilon$

La couverture pondérée du sommet est un cas particulier.

Correspondance bipartite fractionnaire maximale

Étant donné le graphe , le problème naturel du problème est .$G=(U,W,E)$$\max\{|x| : \forall v.\, \sum_{e\ni v} x_e \le 1\}$

Dans la représentation matricielle, il s’agit d’un LP d’emballage avec 0-1 coefficients ( si ). De tels problèmes ne nécessitent pas d’incréments non uniformes, aussi un algorithme simple, analogue à l’algorithme non pondéré de couverture (mais pour l’emballage), fera:$\max\{|x| : Ax \le 1; x \ge 0\}$$A_{ve} = 1$$v\in e$

---

1. Initialise tous les . Soit .$x_e = 0$$N=\log(n)/\varepsilon$

2. Tant que :$A x < N$

   2.1. Choisir minimisant la dérivée partielle de Lmax wrt . (Explicitement, choisissez pour minimiser .)$e$$(Ax)$$x_e$
   $e$$\sum_{v\in e} \exp(\sum_{e'\ni v} x_{e'})$

   2.2. Augmentez de . $x_e$$\varepsilon$

3. Renvoie .$x/\max_{v} A_v x$

---

L'algorithme retourne une solution approchée dans . (Cela est dû au fait que chaque itération augmente de et, enfin, avant la normalisation, .)$(1-O(\varepsilon))$$O(n\log(n)/\varepsilon^2)$$|x|$$\varepsilon$$|x| = O(N n)$

Juste pour le plaisir, voici un algorithme alternatif curieux pour Perfect Bipartite Matching. Rappelons que . Soit.$G=(U,W,E)$$n=|U|=|W|$

---

1. Initialise tous les . Soit . $x_e = 0$$N=4\ln(n)/\varepsilon$

2. Répétez fois:$n\,N$

   2.1. Choisir uniformément au hasard . 2.2. Choisissez tel que minimizing . 2.3. Augmentez de . $u$$U$
   $w$$(u,w)\in E$$\sum_{e\ni w} x_e$
   $x_{uw}$$\varepsilon$

3. Retour .$x/N$

---

Si a une correspondance parfaite, l'algorithme renvoie un tel que et, avec une probabilité élevée, pour tous les sommets , , et pour tous les sommets , . Si vous êtes intéressé par les détails de la preuve, veuillez demander ...$G$$x$$|x|=n$$u\in U$$1-O(\varepsilon) \le \sum_{e\ni u} x_e \le 1+O(\varepsilon)$$w\in W$$\sum_{e\ni w} x_e \le 1+O(\varepsilon)$

Emballage et recouvrement mixtes

Vous avez peut-être posé des questions sur l'appariement bipartite en espérant un exemple de problème d'emballage et de recouvrement mixtes , c'est-à-dire que l'une des formes Voici un algorithme pour de tels problèmes. Commencez par normaliser afin que et .

$$\exists x?~ Px \le p; Cx \ge c; x \ge 0.$$ $p=\overline 1$$c=\overline 1$

Soit le nombre de contraintes (lignes de plus lignes de ).$m$$P$$C$

---

1. Initialise tous les . Soit .$x_j = 0$$N=2\ln(m)/\varepsilon$

2. Tant que :$P x < N$

   2.1. Choisissez pour que la dérivée partielle de Lmax par rapport à soit au plus la dérivée partielle de Lmin par rapport à . (Explicitement, choisissez tel que$j$$(Px)$$x_j$$(Cx)$$x_j$$j$

   $$\frac{\sum_i P_{ij} \exp(P_i x)}{\sum_{i}\exp(P_i x)} \le \frac{\sum_i C_{ij} \exp(-C_i x)}{\sum_{i}\exp(-C_i x)}.)$$

   2.2. Augmentez de , où est choisi de manière maximale de sorte qu'aucune contrainte ou la contrainte restante n'augmente de plus de .$x_j$$\delta$$\delta$$P_i x$$C_i x$$\varepsilon$

   2.3. Supprimer toutes les contraintes couvrant telles que .$i$$C_i x \ge N$

3. Renvoie .$x/\max_i P_i x$

---

En supposant que le problème donné soit réalisable, l'algorithme renvoie un tel que et . Le nombre d'itérations est , car chaque itération augmente une contrainte de , et cela peut se produire pour chaque contrainte au plus fois.$x$$Px\le 1$$Cx\ge 1-O(\varepsilon)$$O(m\ln(m)/\varepsilon^2)$$\varepsilon$$N$

La preuve de correction est via l'invariant L'invariant implique À la fin, le côté gauche est , ce qui prouve la garantie de performance.

$$\mbox{Lmax}(Px) \le 2\ln(m) + (1+O(\varepsilon)) \mbox{Lmin}(Cx).$$ $$\max Px \le 2\ln(m) + (1+O(\varepsilon)) \min Cx.$$ $\Omega(\log(m)/\varepsilon)$

À l'étape 2.1, le souhaité doit exister tant que le problème d'origine est réalisable. (Ceci est dû au fait que, pour tout réalisable , et pour tout , si nous devions choisir un aléatoire dans la distribution , la valeur attendue de la dérivée partielle de Lmax vis-à-vis de serait au plus à (voir l’épreuve précédente pour Set Cover). De même, la valeur attendue de la dérivée partielle de Lmin par rapport à serait au moins . Ainsi, il y a un$j$ $x^*$$x$$j'$$x^*/|x^*|$$(Px)$$x_{j'}$$1/|x^*|$$(Cx)$$x_{j'}$$1/|x^*|$$j$telle que la dérivée partielle de Lmax par rapport à soit au plus la dérivée partielle de Lmin .)$(Px)$$x_{j'}$$(Cx)$

Ensuite, l'invariant est maintenu dans chaque itération car, en choisissant et , et la régularité de Lmin et Lmax, augmenter en augmente Lmax d'au plus fois augmentation de Lmin .$x_j$$\delta$$x_j$$x_j+\delta$$(Px)$$1+O(\varepsilon)$$(Cx)$

Apprendre (suivre des experts / stimuler)

Une référence pour comprendre cette connexion est le jeu adaptatif utilisant des poids multiplicatifs de Freund et Schapire. Voici un résumé rapide pour donner l’idée technique.

Considérez le jeu répété suivant. A chaque tour : $t$

1. Vous choisissez une distribution de probabilité sur (les soi-disant experts ). $p^t$$[n]$$n$
2. Connaissant , l’adversaire choisit ensuite un vecteur de gain . $p^t$$a^t\in [0,1]^{n}$
3. Vous recevez gain pour le tour. $p^t\cdot a^t$

Le jeu s'arrête après un certain nombre de tours. Votre objectif est de minimiser vos regrets par rapport à un expert unique (stratégie pure) . En d’autres , votre objectif est de minimiser .$i$$(\max_i \sum_t a^t_i) - \sum_t p^t\cdot a^t$

Corrigez tout . Laissez vecteur désignent , qui est, fois la somme vectorielle des vecteurs de payoff jusqu'à temps . Rappelons que est le gradient de Lmax .$\varepsilon>0$$y^t$$\varepsilon \sum_{s \le t} a^s$$\varepsilon$$t$$G(y)$$(y)$

Voici la stratégie de base que nous analyserons: Au tour , choisissez pour être .$t$$p^t$$G(y^{t-1})$

Par inspection, cela vous rapporte gain de au tour .$a^t \cdot G(y^{t-1})$$t$

En raison de la propriété de fluidité de , Autrement dit, à chaque tour, ne peut pas augmenter de plus de fois votre gain. Puisque , cela maintient l'invariant selon lequel est au plus le total de vos délais de paiement , plus d'autre part, votre regret par rapport au meilleur expert. est , par exemple,$F$

$$\mbox{Lmax}(y^t) \le \mbox{Lmax}(y^{t-1}) + (1+O(\varepsilon)) \varepsilon a^t \cdot G(y^{t-1}).$$ $\mbox{Lmax}(y^t)$$\varepsilon(1+O(\varepsilon))$$\mbox{Lmax}(\overline 0) = \ln n$$\mbox{Lmax}(y^t)$$\varepsilon(1+O(\varepsilon)$$\ln(n)$$i$$\max_i \sum_t a^t_i$$\varepsilon^{-1} \max_i y^t_i$, qui est au plus .$\varepsilon^{-1} \mbox{Lmax}(y^t)$

Ainsi, votre regret est au plus , plus fois votre gain total.$\varepsilon^{-1} \ln(n)$$O(\varepsilon)$

Remarque: Je pense, comme le soulignent Freund et Schapire, qu'un algorithme de "stimulation" (dans la théorie de l'apprentissage) est également implicite dans cette analyse. Voir leur papier pour plus de détails.

Minimiser le gain total

Vous pouvez obtenir une stratégie similaire pour le paramètre dans lequel l'objectif est de minimiser plutôt que de maximiser le gain total. Votre regret, que vous souhaitez toujours minimiser, est . Dans ce cas, la stratégie correspondante consiste à choisir comme étant le gradient de . Avec cette stratégie, votre regret est encore au maximum plus fois le gain total.$\sum_t p^t\cdot a^t - \min_i a^t_i$$p^t$$\mbox{Lmin}(y^t)$$\varepsilon^{-1} \ln n$$O(\varepsilon)$

Connexion aux algorithmes de relaxation lagrangienne

Pour voir la connexion aux algorithmes de relaxation lagrangienne, corrigez une instance de Set-Cover. Considérez ce dernier type de jeu (dans le but de minimiser les gains), où les experts correspondent aux éléments de votre système. Dans chaque tour, choisissez la distribution de probabilité comme étant le gradient de Lmin comme ci-dessus et demandez à l'adversaire de choisir le vecteur de paiement en fonction de comme suit: choisissez l'ensemble maximisant , alors laissez si , et sinon.$e$$p^t$$(y^t)$$a^t$$p^t$$s^t$$\sum_{e\in s} p^t_e$$a^t_e = 1$$e\in s^t$$a^t_e = 0$

Compte tenu de la condition d'arrêt correcte (décrite ci-dessous), ce processus vous donne exactement l'algorithme Set-Cover décrit au début.

La garantie de performance de l'algorithme découle de la limite de regret comme suit. Soit le nombre de fois où l’adversaire a choisi la série cours de la partie. Soit la couverture d’ensemble fractionnaire optimale. Soitsoit le nombre de tours joués. Le regret lié implique $X_s$$s$$x^*$$T=|X_s|$

$$\textstyle \sum_t a^t\cdot p^t \le \varepsilon^{-1}\ln(m) + \min_e \sum_t a_e^t.$$

En utilisant la définition de , le ième gain (le ième terme de la somme de gauche) est égal à . L'adversaire a choisi pour minimiser ce gain. Si l'adversaire avait plutôt choisi manière aléatoire dans la distribution, l’attente du gain aurait été de (Nous utilisons ci-dessus le pour tout , et ) Chaque gain étant au moins égal à$a^t$$t$$t$$\sum_{e\in s^t} p^t_e$$s^t$$s^t$$x^*/|x^*|$

$$\sum_s \frac{x^*_s}{|x^*|} \sum_{e\in s} p^t_e ~=~ \frac{1}{|x^*|} \sum_e p^t_e \sum_{s\ni e} x^*_s ~\ge~ \frac{1}{|x^*|} \sum_e p^t_e ~=~ \frac{1}{|x^*|}.$$ $\sum_{s\ni e} x^*_s \ge 1$$e$$|p^t| = 1$$1/|x^*|$, le regret lié implique Par la définition de , nous avons (chaque tour choisit un ensemble), et , donnant Nous arrêtons le processus lorsque , donc alors (réorganisation des termes) C'est-à-dire que la normalisation donne un ensemble de couverture de taille au plus fois optimum. $$\frac{T}{|x^*|} \le \varepsilon^{-1}\ln(m) + \min_e \sum_t a_e^t.$$ $X$$|X| = T$$\sum_t a_e^t = \sum_e [e\in s^t] = \sum_{s\ni e} X_s$ $$\frac{|X|}{|x^*|} \le \varepsilon^{-1}\ln(m) +\min_e \sum_{s\ni e} X_s.$$ $\min_e \sum_{s\ni e} X_s = \Omega(\varepsilon^{-2}\ln m)$ $$\frac{|X|}{\min_e \sum_{s\ni e} X_s}~ \le~ (1+O(\varepsilon)|x^*|.$$ $X$$(1+O(\varepsilon))$

Remarque: En un sens, cette interprétation de la théorie de l'apprentissage généralise l'interprétation algorithmique. Cependant, certaines des techniques algorithmiques nécessaires à l'efficacité (telles que des incréments non uniformes et des contraintes de couverture satisfaisantes) ne semblent pas se répercuter naturellement dans le cadre de la théorie de l'apprentissage. De même, les algorithmes de mélange d' emballage et LPs de couverture (par exemple , ces ) ne semblent pas avoir des analogues naturels dans la mise en théorie de l' apprentissage.