Exemplos de brinquedos para solucionadores de Plotkin-Shmoys-Tardos e Arora-Kale

Gostaria de entender como o solucionador Arora-Kale SDP se aproxima do relaxamento de Goemans-Williamson em tempo quase linear, como o solucionador Plotkin-Shmoys-Tardos aproxima problemas fracionários de "empacotamento" e "cobertura" em tempo quase linear e como os algoritmos são instanciações da estrutura abstrata "aprendendo com especialistas".

A tese de Kale tem uma excelente apresentação, mas acho muito difícil pular diretamente para o quadro abstrato e prefiro começar com um exemplo de um problema simples para o qual é absolutamente óbvio o que fazer e depois passar para problemas mais gerais. , adicionando progressivamente "recursos" ao algoritmo e à sua análise.

Por exemplo:

Como Plotkin-Shmoys resolve o relaxamento da programação linear da cobertura de vértices não ponderada? Cobertura de vértice ponderada? Definir capa? Correspondência bipartida?

Qual é o exemplo mais simples em que o algoritmo Arora-Kale está fazendo algo interessante? Como calcula o maior valor próprio do Laplaciano de um gráfico?

(Computar o maior autovalor do Laplaciano é equivalente ao problema de resolver uma versão mais fraca do relaxamento Max Cut de Goemans-Williamson SDP, na qual, em vez de exigir que cada vetor tenha o comprimento um, você deseja a soma dos quadrados das normas a serem | V |.)

Luca, desde que um ano se passou, você provavelmente já pesquisou sua própria resposta. Estou respondendo algumas de suas perguntas aqui apenas para registro. Reviso alguns algoritmos de relaxamento lagrangiano para os problemas mencionados e esboço a conexão com a aprendizagem (em particular, seguindo conselhos de especialistas). Eu não comento aqui sobre algoritmos SDP.

Observe que os algoritmos específicos mencionados não são executados em tempo quase linear. (Existe um algoritmo de tempo quase linear para explicitamente dados problemas de empacotamento ou cobertura. Consulte Simulação de batimento para empacotamento fracionário e cobertura de programas lineares .) Os algoritmos que você tem em mente geralmente têm variantes que são executadas em um número quase linear de iterações , mas cada a iteração normalmente requer pelo menos tempo linear também. Discuto alguns desses algoritmos abaixo.

Algumas funções úteis

Antes de começar, aqui estão algumas funções que usaremos nos esboços de prova. (Se você estiver interessado nos algoritmos, mas não nos detalhes da prova, poderá pular adiante.) Para qualquer vetor , defina como . Esta função é um limite superior em : Analogamente, defina como , um limite inferior em .$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$

Por conveniência, a seguir, usamos para indicar o gradiente de Lmin. Usamos para denotar o gradiente de Lmax.$g(y)$$\nabla \mbox{Lmin}(y)$$G(y)$$\nabla \mbox{Lmax}(y)$

Explicitamente, é enquanto é .$g_i(y)$$\exp(-y_i)/\sum_{i'} \exp(-y_{i'})$$G_i(y)$$\exp(y_i)/\sum_{i'} \exp(y_{i'})$

Lmin e Lmax são lisas no seguinte sentido: para qualquer vectores e , e $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).$$

Observe que os dois gradientes têm 1 norma igual a 1: . (Em todo o tempo, usamos para denotar a norma 1).$|G(y)| = |g(y)| = 1$$|z|$

Observe também que, para uma matriz , o gradiente da função em relação a é (pela regra da cadeia) . Mais explicitamente, a derivada parcial da função em relação a é . Da mesma forma, a derivada parcial de Lmax em relação a é .$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)$

Tampa fracionária do conjunto

Corrija uma instância de Set-Cover. Deixe denotar o elemento / conjunto da matriz de incidência. Assim, se , mais 0 e é a extensão em que a cobertura fracionária cobre o elemento .$A$$A_{es} = 1$$e\in s$$A_e x$$x$$e$

O LP é . Dado , o algoritmo é$\min\{ |x| : A x \ge 1; x \ge 0\}$$\varepsilon\in (0,1)$

---

1. Inicialize todos . Seja . $x_s = 0$$N=\log(n)/\varepsilon$

2. Repita até : $\min_e A_e x \ge N$

   2.1 Escolha maximizando a derivada parcial de Lmin wrt . (Explicitamente, escolha maximizando .) $s$$(Ax)$$x_s$
   $s$$\sum_{e\in s} \exp(-\sum_{s'\ni e} x_{s'})$

   2.2 Aumente em . $x_s$$\varepsilon$

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

---

O algoritmo retorna uma solução aproximada nas , em que é o número de elementos e é o ideal cobertura fracionária do conjunto (trivialmente ). (Um algoritmo semelhante aparece no artigo mencionado por Chandra . A Vertex Cover é obviamente um caso especial.)$(1+O(\varepsilon))$$O(|x^*|\log(n)/\varepsilon^2)$$n$$x^*$$|x^*|\le n$

( Observação: observe que o limite da iteração não depende do número de conjuntos, apenas do número de elementos. Portanto, o algoritmo pode ser usado com um sistema de conjuntos definido implicitamente, desde que, considerando os pesos, os elementos possam ser eficientemente encontre um conjunto de peso total máximo (ou quase máximo). Esse tipo de oráculo é igual ao oráculo de separação necessário para aplicar o algoritmo elipsóide ao problema duplo . Para problemas de empacotamento, como empacotamento definido, você precisa de um oráculo que, dados pesos nos elementos, retorna um conjunto que minimiza o peso total. Para problemas como fluxo de várias mercadorias, você pode, por exemplo, precisar encontrar um caminho que minimize a soma de alguns pesos de borda determinados.)

Aqui está um esboço da prova da garantia de desempenho. Em cada iteração, a derivada parcial correspondente a escolhida é pelo menos, em que é a cobertura ideal do conjunto fracionário.$s$$1/|x^*|$$x^*$

(Para entender por que, lembre-se de que o gradiente de Lmin em relação a é . Se escolhermos um conjunto aleatoriamente na distribuição , o valor esperado da derivada parcial em relação a seria assim . Como , este é pelo menos . Como , isso é pelo menos . Portanto, deve haver alguns dêem derivada parcial pelo menos . Como o algoritmo escolhe$(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$em cada iteração para maximizar a derivada parcial, ela atinge uma derivada parcial de pelo menos.) 1 / | x * |$1/|x^*|$

Em seguida, o tamanho da etapa é escolhido pequeno o suficiente para que nenhuma coordenada de aumente mais que . Portanto, devido à suavidade do Lmin, aumentar para aumenta em pelo menos .$\varepsilon$$A x$$\varepsilon$$x_s$$x_s+\varepsilon$$\mbox{Lmin}(Ax)$$(1-O(\varepsilon))\varepsilon/|x^*|$

Dessa maneira, o algoritmo mantém a invariante (Observe que Lmin é igual a .)

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

Na terminação, na invariante, o termo é vezes o lado esquerdo, portanto, pelo cálculo, obtém-se. Após a normalização na última linha do algoritmo, isso implica.$\ln n$$O(\varepsilon)$$\min_e A_e x \ge (1-O(\varepsilon)) |x|/|x^*|$$|x| \le (1+O(\varepsilon))|x^*|$

FWIW, as desigualdades envolvidas na prova do invariante são essencialmente as mesmas que as envolvidas na prova do limite de Chernoff. (De fato, esse algoritmo pode ser derivado aplicando o método de probabilidades condicionais a um esquema de arredondamento aleatório que amostra repetidamente conjuntos da distribuição (com substituição), aumentando para cada conjunto amostrado Essa derandomização disso fornece o algoritmo: a invariante subjacente é apenas que o estimador pessimista permanece abaixo de 1. As penalidades exponenciais no estimador pessimista vêm do uso de Chernoff ligado na análise do esquema de arredondamento. no artigo que Chandra mencionou .)$x^*/|x^*|$$x_s$$s$

Tampa fracionária do conjunto ponderado (e cobertura fracionária geral)

Para lidar com problemas como a tampa do conjunto ponderado de maneira eficiente , modificamos o algoritmo para usar incrementos não uniformes (uma ideia devido a Garg e Konemann ).

O LP é , em que varia sobre os elementos, varia sobre os conjuntos e todas as variáveis ​​não são -negativo. Para apresentar o algoritmo, primeiro reescreva o problema como um problema geral de cobertura. Deixe para e de outro modo. Então (com uma mudança de variáveis, escalando cada por ), o LP é , que podemos ver como um LP de cobertura geral. Aqui está o algoritmo:$\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. Inicialize todos . Seja .$x_s = 0$$N=\log(n)/\varepsilon$

2. Repita até que todas as restrições de cobertura tenham sido excluídas:

   2.1 Escolha maximizando a derivada parcial de Lmin wrt . (Explicitamente, escolha maximizando .)$s$$(Ax)$$x_s$
   $s$$\sum_{e\in s} \exp({-\sum_{s'\ni e} x_{s'}})/c_s$

   2.2 Aumente em , onde é escolhido no máximo, de modo que, para cada restrição de cobertura restante , o aumento em seja no máximo .$x_s$$\delta$$\delta$$e$$A_e \cdot x$$\varepsilon$

   2.3 Apagar todos os constrangimentos que cobrem de tal modo que .$e$$A_e\cdot x \ge N$

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

---

O algoritmo retorna uma solução aproximada nas iterações , em que é o número de restrições de cobertura. (Cada iteração aumenta alguns restantes em ; isso pode acontecer apenas vezes com uma restrição antes de ser excluída.) A prova de correção é basicamente a mesma invariante da Set Cover.$(1+O(\varepsilon))$$O(n\log(n)/\varepsilon^2)$$n$$A_e x$$\varepsilon$$N/\varepsilon$

A cobertura ponderada de vértice é um caso especial.

Correspondência bipartida fracionária máxima

Dado um gráfico , o LP natural para o problema é .$G=(U,W,E)$$\max\{|x| : \forall v.\, \sum_{e\ni v} x_e \le 1\}$

Na representação matricial, esse é um LP com coeficientes 0-1 ( se ). Tais problemas não exigem incrementos não uniformes; portanto, um algoritmo simples, análogo ao algoritmo Set Cover não ponderado (mas para empacotamento), fará:$\max\{|x| : Ax \le 1; x \ge 0\}$$A_{ve} = 1$$v\in e$

---

1. Inicialize todos . Seja .$x_e = 0$$N=\log(n)/\varepsilon$

2. Enquanto :$A x < N$

   2.1 Escolha minimizando a derivada parcial de Lmax wrt . (Explicitamente, escolha para minimizar .)$e$$(Ax)$$x_e$
   $e$$\sum_{v\in e} \exp(\sum_{e'\ni v} x_{e'})$

   2.2 Aumente em . $x_e$$\varepsilon$

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

---

O algoritmo retorna uma solução aproximada nas iterações . (Isso ocorre porque cada iteração aumenta by e, finalmente, antes da normalização, .)$(1-O(\varepsilon))$$O(n\log(n)/\varepsilon^2)$$|x|$$\varepsilon$$|x| = O(N n)$

Apenas por diversão, aqui está um curioso algoritmo alternativo para o Perfect Bipartite Matching. Lembre-se de que . Seja.$G=(U,W,E)$$n=|U|=|W|$

---

1. Inicialize todos . Seja . $x_e = 0$$N=4\ln(n)/\varepsilon$

2. Repita vezes:$n\,N$

   2.1 Escolha uniformemente aleatoriamente a partir de . 2.2 Escolha modo que minimizando . 2.3 Aumente em . $u$$U$
   $w$$(u,w)\in E$$\sum_{e\ni w} x_e$
   $x_{uw}$$\varepsilon$

3. Retorno .$x/N$

---

Se tiver uma correspondência perfeita, o algoritmo retornará um tal que e, com alta probabilidade, para todos os vértices , e para todos os vértices , . Se você estiver interessado nos detalhes da prova, pergunte ...$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)$

Embalagem e Cobertura Mistas

Você pode ter perguntado sobre a correspondência bipartida na esperança de obter um exemplo de um problema misto de embalagem e cobertura, ou seja, uma das formas Aqui está um algoritmo para esses problemas. Primeiro, normalizar modo que e .

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

Seja o número de restrições (linhas em mais linhas em ).$m$$P$$C$

---

1. Inicialize todos . Seja .$x_j = 0$$N=2\ln(m)/\varepsilon$

2. Enquanto :$P x < N$

   2.1 Escolha para que a derivada parcial de Lmax em relação a seja no máximo a derivada parcial de Lmin em relação a . (Explicitamente, escolha tal 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 Aumente em , onde é escolhido no máximo, de forma que nenhuma restrição ou a restrição restante aumente em mais de .$x_j$$\delta$$\delta$$P_i x$$C_i x$$\varepsilon$

   2.3 Apagar todos os constrangimentos que cobrem tal que .$i$$C_i x \ge N$

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

---

Supondo que o problema fornecido seja viável, o algoritmo retorna um tal que e . O número de iterações é , porque cada iteração aumenta alguma restrição em , e isso pode ocorrer para cada restrição no máximo vezes.$x$$Px\le 1$$Cx\ge 1-O(\varepsilon)$$O(m\ln(m)/\varepsilon^2)$$\varepsilon$$N$

A prova de correção é feita através da invariante O invariante implica No final, o lado esquerdo é , comprovando a garantia de desempenho.

$$\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)$

Na etapa 2.1, o desejado deve existir desde que o problema original seja viável. (Isso ocorre porque, para qualquer possível e qualquer , se escolhermos um aleatório da distribuição , o valor esperado da derivada parcial de Lmax em relação a seria no máximo (consulte o esboço de prova anterior para Set Cover). Da mesma forma, o valor esperado da derivada parcial de Lmin em relação a seria pelo menos . Portanto, existe um$j$x ∗ x j ′ x ∗ / | x * | ( P x ) x j ′ 1 / | x * | $x^*$$x$$j'$$x^*/|x^*|$$(Px)$$x_{j'}$$1/|x^*|$$(Cx)$$x_{j'}$$1/|x^*|$$j$tal que a derivada parcial de Lmax em relação a seja no máximo a derivada parcial de Lmin .)$(Px)$$x_{j'}$$(Cx)$

Em seguida, a invariante é mantida em cada iteração porque, pela escolha de e , e pela suavidade de Lmin e Lmax, aumentar para aumenta Lmax em no máximo vezes o aumento de Lmin .$x_j$$\delta$$x_j$$x_j+\delta$$(Px)$$1+O(\varepsilon)$$(Cx)$

Aprendizagem (após especialistas / reforço)

Uma referência para entender essa conexão é o jogo adaptável usando pesos multiplicativos , de Freund e Schapire. Aqui está um resumo rápido para fornecer a ideia técnica.

Considere o seguinte jogo repetido. Em cada rodada : $t$

1. Você escolhe uma distribuição de probabilidade em (os chamados especialistas ). $p^t$$[n]$$n$
2. Conhecendo , o adversário escolhe um vetor de pagamento . $p^t$$a^t\in [0,1]^{n}$
3. Você recebe o pagamento pela rodada. $p^t\cdot a^t$

O jogo para após algumas rodadas. Seu objetivo é minimizar seu arrependimento em comparação com qualquer especialista (ie, estratégia pura) . Ou seja, seu objetivo é minimizar .$i$$(\max_i \sum_t a^t_i) - \sum_t p^t\cdot a^t$

Corrija qualquer . Deixe o vetor denotar , isto é, vezes a soma do vetor dos vetores de payoff até o tempo . Lembre-se de que é o gradiente de Lmax .$\varepsilon>0$$y^t$$\varepsilon \sum_{s \le t} a^s$$\varepsilon$$t$$G(y)$$(y)$

Aqui está a estratégia básica que analisaremos: Na rodada , escolha para ser .$t$$p^t$$G(y^{t-1})$

Por inspeção, isso dá o resultado na rodada .$a^t \cdot G(y^{t-1})$$t$

Devido à propriedade de suavidade de , Ou seja, em cada rodada, não pode aumentar em mais de vezes o seu pagamento. Como , isso mantém a invariante de que é no máximo o seu tempo total de pagamento , mais por outro lado, o seu pesar em comparação com o melhor especialista. é , ou seja,$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$ ε - 1 Lmax ( y t ), que, por sua vez, é no máximo .$\varepsilon^{-1} \mbox{Lmax}(y^t)$

Portanto, seu arrependimento é no máximo , mais vezes o seu pagamento total.$\varepsilon^{-1} \ln(n)$$O(\varepsilon)$

Observação: Eu acho que, como Freund e Schapire apontam, um algoritmo de "reforço" (na teoria da aprendizagem) também está implícito nessa análise. Veja o artigo deles para mais detalhes.

Minimizando o pagamento total

Você pode derivar uma estratégia semelhante para a configuração em que o objetivo é minimizar , em vez de maximizar, o pagamento total. Seu arrependimento, que você ainda deseja minimizar, é . Nesse caso, a estratégia correspondente é escolher para ser o gradiente de . Com essa estratégia, seu arrependimento é novamente no máximo mais vezes seu pagamento 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)$

Conexão com algoritmos de relaxação lagrangiana

Para ver a conexão com os algoritmos de relaxação lagrangiana, corrija uma instância de Set-Cover. Considere o último tipo de jogo (com o objetivo de minimizar os ganhos), em que os especialistas correspondem aos elementos do seu sistema definido. Em cada rodada, escolha a distribuição de probabilidade para ser o gradiente de Lmin como acima, e faça com que o adversário escolha o vetor de payoff em função de seguinte maneira: escolha o conjunto maximizando , então deixe se , e caso contrário.$e$$p^t$$(y^t)$$a^t$$p^t$s t Σ e ∈ s p t e uma t e = 1 e ∈ s t a t e = 0$s^t$$\sum_{e\in s} p^t_e$$a^t_e = 1$$e\in s^t$$a^t_e = 0$

Dada a condição de parada correta (discutida abaixo), esse processo fornece exatamente o algoritmo Set-Cover discutido no início.

A garantia de desempenho do algoritmo segue do arrependimento vinculado da seguinte forma. Seja o número de vezes que o adversário escolheu set durante a jogada. Seja a cobertura ideal do conjunto fracionário. Sejaser o número de rodadas jogadas. O limite de arrependimento implica $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.$$

Usando a definição de , o th recompensa (o prazo th na soma à esquerda) é igual a . O adversário escolheu para minimizar esse pagamento. Se o adversário tivesse escolhido aleatoriamente na distribuição, a expectativa do pagamento seria (Acima, usamos esse para todos os e ) Como cada recompensa é pelo menos$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^*|$, o limite de arrependimento implica Pela definição de , temos (cada rodada escolhe um conjunto) e , fornecendo Paramos o processo quando , então (reorganizando os termos) Ou seja, normalizar fornece no máximo uma cobertura fracionada de conjunto vezes ótimo. $$\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))$

Observação: De certa forma, essa interpretação da teoria da aprendizagem generaliza a interpretação algorítmica. No entanto, algumas das técnicas algorítmicas necessárias para a eficiência (como incrementos não uniformes e eliminação de restrições de cobertura satisfeitas) não parecem ser levadas naturalmente para a configuração da teoria da aprendizagem. Da mesma forma, algoritmos para embalagem mista e cobertura de LPs (por exemplo, esses ) não parecem ter análogos naturais no cenário da teoria da aprendizagem.