Ví dụ về đồ chơi cho người giải Plotkin-Shmoys-Tardos và Arora-Kale

Tôi muốn hiểu cách giải quyết Arora-Kale SDP gần đúng với sự thư giãn của Goemans-Williamson trong thời gian gần như tuyến tính, làm thế nào bộ giải Plotkin-Shmoys-Tardos xấp xỉ các vấn đề "đóng gói" và "bao phủ" trong thời gian gần như tuyến tính và cách các thuật toán là những gợi ý của khuôn khổ trừu tượng "học hỏi từ các chuyên gia".

Luận án của Kale có một bài thuyết trình tuyệt vời, nhưng tôi cảm thấy rất khó khăn khi trực tiếp nhảy vào khuôn khổ trừu tượng, và tôi thích bắt đầu từ một ví dụ về một vấn đề đơn giản mà nó hoàn toàn rõ ràng phải làm gì, và sau đó chuyển sang các vấn đề chung hơn , dần dần thêm "tính năng" vào thuật toán và phân tích.

Ví dụ:

Làm thế nào để Plotkin-Shmoys giải quyết sự thư giãn lập trình tuyến tính của nắp đỉnh không trọng số? Bao đỉnh có trọng số? Đặt bìa? Kết hợp lưỡng cực?

Ví dụ đơn giản nhất trong đó thuật toán Arora-Kale đang làm điều gì đó thú vị là gì? Làm thế nào để nó tính toán giá trị riêng lớn nhất của Laplacian của đồ thị?

. của các chỉ tiêu sẽ là | V |.)

Luca, kể từ khi một năm trôi qua, có lẽ bạn đã nghiên cứu câu trả lời của riêng mình. Tôi đang trả lời một số câu hỏi của bạn ở đây chỉ để ghi lại. Tôi xem xét một số thuật toán thư giãn Lagrangian cho các vấn đề bạn đề cập và phác thảo kết nối với việc học (đặc biệt, theo lời khuyên của chuyên gia). Tôi không bình luận ở đây về các thuật toán SDP.

Lưu ý rằng các thuật toán cụ thể mà bạn đề cập không chạy trong thời gian gần như tuyến tính. (Có một thuật toán gần tuyến tính thời gian cho rõ ràng đóng gói nhất định hoặc bao gồm các vấn đề. Xem Đập Simplex cho Fractional Bao bì và Che tuyến tính Chương Trình .) Các thuật toán bạn có trong tâm trí thường có các biến thể đó chạy trong một số gần như tuyến tính của sự lặp lại , nhưng mỗi lặp thường yêu cầu ít nhất là thời gian tuyến tính là tốt. Tôi thảo luận về một số thuật toán dưới đây.

Một số chức năng hữu ích

Trước khi bắt đầu, đây là một số chức năng mà chúng tôi sẽ sử dụng trong các bản phác thảo bằng chứng. (Nếu bạn quan tâm đến các thuật toán, nhưng không phải là chi tiết bằng chứng, bạn có thể bỏ qua phía trước.) Đối với bất kỳ vectơ $y$ , hãy xác định $\mbox{Lmax}(y)$ là $\ln \sum_i \exp(y_i)$ . Chức năng này là một trên ràng buộc về $\max_i y_i$ :

$$\max_i y_i ~\le~ \mbox{Lmax}(y) ~\le~ \max_i y_i + \ln m.$$ Tương tự, xác định$\mbox{Lmin}(y)$ là$-\mbox{Lmax}(-y)$ , giới hạn dưới của$\min_i y_i$ .

Để thuận tiện cho những gì tiếp theo, chúng tôi sử dụng $g(y)$ để biểu thị độ dốc $\nabla \mbox{Lmin}(y)$ của Lmin. Chúng tôi sử dụng $G(y)$ để biểu thị độ dốc $\nabla \mbox{Lmax}(y)$ của Lmax.

Một cách rõ ràng, $g_i(y)$ là $\exp(-y_i)/\sum_{i'} \exp(-y_{i'})$ trong khi $G_i(y)$ là $\exp(y_i)/\sum_{i'} \exp(y_{i'})$ .

Lmin và Lmax là mịn theo nghĩa sau: đối với bất kỳ vectơ $d\in[0,\varepsilon]^n$ và $y\in R^n$ ,

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

Lưu ý rằng cả hai độ dốc đều có 1 chỉ tiêu bằng 1: $|G(y)| = |g(y)| = 1$ . (Xuyên suốt chúng tôi sử dụng $|z|$ để biểu thị định mức 1).

Cũng lưu ý rằng, đối với một ma trận $A$ , gradient của hàm $x\mapsto \mbox{Lmin}(Ax)$ với đối với $x$ là (theo quy tắc dây chuyền) $(g(Ax))^T A$ . Nói rõ hơn, đạo hàm riêng của hàm đối với $x_j$ là $\sum_i A_{ij} \exp(-A_i x) / \sum_i \exp(-A_i x)$. Tương tự, đạo hàm riêng của Lmax $(Ax)$ đối với $x_j$ là $\sum_i A_{ij} \exp(A_i x)/\sum_i \exp(A_i x)$ .

Bìa đặt phân số

Sửa một trường hợp Set-Cover. Đặt $A$ là ma trận tỷ lệ phần tử / tập hợp. Do đó, $A_{es} = 1$ nếu $e\in s$ , khác 0 và $A_e x$ là phạm vi bao trùm phân số $x$ bao gồm phần tử $e$ .

LP là $\min\{ |x| : A x \ge 1; x \ge 0\}$ . Với $\varepsilon\in (0,1)$ , thuật toán là

---

1. Khởi tạo tất cả $x_s = 0$ . Hãy để $N=\log(n)/\varepsilon$ .

2. Lặp lại cho đến khi $\min_e A_e x \ge N$ :

   2.1. Chọn $s$ tối đa hóa đạo hàm riêng của Lmin $(Ax)$ wrt $x_s$ .
   (Rõ ràng, chọn $s$ tối đa hóa $\sum_{e\in s} \exp(-\sum_{s'\ni e} x_{s'})$ ).

   2.2. Tăng $x_s$ bằng $\varepsilon$ .

3. Trả về $x/\min_{e} A_e x$ .

---

Trở về thuật toán một $(1+O(\varepsilon))$ giải pháp gần đúng trong $O(|x^*|\log(n)/\varepsilon^2)$ lặp đi lặp lại, nơi $n$ là số nguyên tố và $x^*$ là tối ưu phân đoạn bộ bìa (trivially $|x^*|\le n$ ). (Một thuật toán tương tự xuất hiện trong bài báo Chandra đã đề cập . Vertex Cover tất nhiên là một trường hợp đặc biệt.)

( Lưu ý: Lưu ý rằng giới hạn lặp không phụ thuộc vào số lượng tập hợp, chỉ số lượng phần tử. Do đó, thuật toán có thể được sử dụng với một hệ thống tập xác định ngầm, miễn là có trọng số cho các phần tử, người ta có thể sử dụng một cách hiệu quả tìm một tập hợp tổng trọng lượng tối đa (hoặc gần tối đa). Loại tiên tri này giống như lời tiên tri tách cần thiết để áp dụng thuật toán ellipsoid cho bài toán kép . Đối với các vấn đề về đóng gói, như đóng gói, bạn cần một lời tiên tri đó, trọng số đã cho trên các phần tử, trả về một tập hợp tối thiểu hóa tổng trọng số. Đối với các vấn đề như dòng chảy đa hàng hóa, ví dụ, bạn có thể cần tìm một đường dẫn giảm thiểu tổng trọng số của một số trọng số cạnh đã cho.)

Đây là một bản phác thảo bằng chứng về đảm bảo hiệu suất. Trong mỗi lần lặp, đạo hàm riêng một phần, số $s$ được chọn ít nhất là $1/|x^*|$, Nơi $x^*$ là phân đoạn bộ bìa tối ưu.

(To see why, recall that the gradient of Lmin$(Ax)$ with respect to $x$ is $(g(Ax))^T A$. If we were to choose a set $s'$ at random from the distribution $x^*/|x^*|$, the expected value of the partial derivative with respect to $x_{s'}$ would thus be $(g(Ax))^T \,A x^*/|x^*|$. Since $Ax^* \ge 1$, this is at least $|g(Ax)|/|x^*|$. Since $|g(Ax)|=1$, this is at least $1/|x^*|$. Thus, there must exist some $s$ giving partial derivative at least $1/|x^*|$. Since the algorithm chooses $x_s$ in each iteration to maximize the partial derivative, it achieves a partial derivative of at least $1/|x^*|$.)

Then, the step size $\varepsilon$ is chosen just small enough so that no coordinate of $A x$ increases by more than $\varepsilon$. Thus, because of the smoothness of Lmin, increasing $x_s$ to $x_s+\varepsilon$ increases $\mbox{Lmin}(Ax)$ by at least $(1-O(\varepsilon))\varepsilon/|x^*|$.

In this way, the algorithm maintains the invariant

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

At termination, in the invariant, the $\ln n$ term is $O(\varepsilon)$ times the left-hand side, so by calculation one gets $\min_e A_e x \ge (1-O(\varepsilon)) |x|/|x^*|$. After the normalization in the last line of the algorithm, this implies $|x| \le (1+O(\varepsilon))|x^*|$.

FWIW, the inequalities involved in proving the invariant are essentially the same as those involved in proving the Chernoff bound. (In fact, this algorithm can be derived by applying the method of conditional probabilities to a randomized-rounding scheme that repeatedly samples sets from the distribution $x^*/|x^*|$ (with replacement), increasing $x_s$ for each sampled set $s$. This derandomization of that gives the algorithm: the underlying invariant is just that the pessimistic estimator stays below 1. The exponential penalties in the pessimistic estimator come from the using the Chernoff bound in the analysis of the rounding scheme. This basic idea is explained further in the paper Chandra mentioned.)

Fractional Weighted Set Cover (and general fractional Covering)

To handle problems such as Weighted Set Cover efficiently, we modify the algorithm to use non-uniform increments (an idea due to Garg and Konemann).

The LP is $\min\{ c\cdot x : (\forall e) \sum_{s\ni e} x_s \ge 1\}$, where $e$ ranges over the elements, $s$ ranges over the sets, and all variables are non-negative. To present the algorithm, first rewrite the problem as a general covering problem. Let $A_{es} = 1/c_s$ for $e\in s$ and $A_{es} = 0$ otherwise. Then (with a change of variables, scaling each $x_s$ by $c_s$), the LP is $\min\{ |x| : A x \ge 1; x \ge 0\}$, which we can view as a general covering LP. Here is the algorithm:

---

1. Initialize all $x_s = 0$. Let $N=\log(n)/\varepsilon$.

2. Repeat until all covering constraints have been deleted:

   2.1. Choose $s$ maximizing the partial derivative of Lmin$(Ax)$ w.r.t. $x_s$.
   (Explicitly, choose $s$ maximizing $\sum_{e\in s} \exp({-\sum_{s'\ni e} x_{s'}})/c_s$.)

   2.2. Increase $x_s$ by $\delta$, where $\delta$ is chosen maximally such that, for every remaining covering constraint $e$, the increase in $A_e \cdot x$ is at most $\varepsilon$.

   2.3 Delete all covering constraints $e$ such that $A_e\cdot x \ge N$.

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

---

The algorithm returns a $(1+O(\varepsilon))$-approximate solution in $O(n\log(n)/\varepsilon^2)$ iterations, where $n$ is the number of covering constraints. (Each iteration increases some remaining $A_e x$ by $\varepsilon$; this can happen only $N/\varepsilon$ times to a constraint before it is deleted.) The proof of correctness is via essentially the same invariant as for Set Cover.

Weighted Vertex Cover is a special case.

Maximum Fractional Bipartite Matching

Given a graph $G=(U,W,E)$, the natural LP for the problem is $\max\{|x| : \forall v.\, \sum_{e\ni v} x_e \le 1\}$.

In matrix representation, this is a packing LP $\max\{|x| : Ax \le 1; x \ge 0\}$ with 0-1 coefficients ($A_{ve} = 1$ if $v\in e$). Such problems do not require non-uniform increments, so a simple algorithm analogous to the unweighted Set Cover algorithm (but for packing) will do:

---

1. Initialize all $x_e = 0$. Let $N=\log(n)/\varepsilon$.

2. While $A x < N$:

   2.1. Choose $e$ minimizing the partial derivative of Lmax$(Ax)$ w.r.t. $x_e$.
   (Explicitly, choose $e$ to minimize $\sum_{v\in e} \exp(\sum_{e'\ni v} x_{e'})$.)

   2.2. Increase $x_e$ by $\varepsilon$.

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

---

The algorithm returns a $(1-O(\varepsilon))$-approximate solution in $O(n\log(n)/\varepsilon^2)$ iterations. (This is because each iteration increases $|x|$ by $\varepsilon$, and finally, before normalization, $|x| = O(N n)$.)

Just for fun, here is a curious alternative algorithm for Perfect Bipartite Matching. Recall that $G=(U,W,E)$. Let $n=|U|=|W|$.

---

1. Initialize all $x_e = 0$. Let $N=4\ln(n)/\varepsilon$.

2. Repeat $n\,N$ times:

   2.1. Choose $u$ uniformly at random from $U$.
   2.2. Choose $w$ such that $(u,w)\in E$ minimizing $\sum_{e\ni w} x_e$.
   2.3. Increase $x_{uw}$ by $\varepsilon$.

3. Return $x/N$.

---

If $G$ has a perfect matching, the algorithm returns an $x$ such that $|x|=n$, and, with high probability, for all vertices $u\in U$, $1-O(\varepsilon) \le \sum_{e\ni u} x_e \le 1+O(\varepsilon)$, and for all vertices $w\in W$, $\sum_{e\ni w} x_e \le 1+O(\varepsilon)$. If you are interested in the details of the proof, please ask...

Mixed Packing and Covering

You may have asked about bipartite matching hoping for an example of a mixed packing and covering problem, that is, one of the form

$$\exists x?~ Px \le p; Cx \ge c; x \ge 0.$$ Here's one algorithm for such problems. First, normalize so that $p=\overline 1$ and $c=\overline 1$.

Let $m$ be the number of constraints (rows in $P$ plus rows in $C$).

---

1. Initialize all $x_j = 0$. Let $N=2\ln(m)/\varepsilon$.

2. While $P x < N$:

   2.1. Choose $j$ so that the partial derivative of Lmax$(Px)$ with respect to $x_j$ is at most the partial derivative of Lmin$(Cx)$ with respect to $x_j$. (Explicitly, choose $j$ such that

   $$\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. Increase $x_j$ by $\delta$, where $\delta$ is chosen maximally such that no constraint $P_i x$ or remaining constraint $C_i x$ increases by more than $\varepsilon$.

   2.3. Delete all covering constraints $i$ such that $C_i x \ge N$.

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

---

Assuming the given problem is feasible, the algorithm returns an $x$ such that $Px\le 1$ and $Cx\ge 1-O(\varepsilon)$. The number of iterations is $O(m\ln(m)/\varepsilon^2)$, because each iteration increases some constraint by $\varepsilon$, and this can happen for each constraint at most $N$ times.

The proof of correctness is via the invariant

$$\mbox{Lmax}(Px) \le 2\ln(m) + (1+O(\varepsilon)) \mbox{Lmin}(Cx).$$ The invariant implies $$\max Px \le 2\ln(m) + (1+O(\varepsilon)) \min Cx.$$ At termination the left-hand side is $\Omega(\log(m)/\varepsilon)$, proving the performance guarantee.

In Step 2.1, the desired $j$ must exist as long as the original problem is feasible. (This is because, for any feasible $x^*$, and any $x$, if we were to choose a random $j'$ from the distribution $x^*/|x^*|$, the expected value of the partial derivative of Lmax$(Px)$ with respect to $x_{j'}$ would be at most $1/|x^*|$ (see the previous proof sketch for Set Cover). Likewise, the expected value of the partial derivative of Lmin$(Cx)$ with respect to $x_{j'}$ would be at least $1/|x^*|$. Thus, there is an $j$ such that the partial derivative of Lmax$(Px)$ with respect to $x_{j'}$ is at most the partial derivative of Lmin$(Cx)$.)

Then the invariant is maintained in each iteration because, by the choice of $x_j$ and $\delta$, and the smoothness of Lmin and Lmax, increasing $x_j$ to $x_j+\delta$ increases Lmax$(Px)$ by at most $1+O(\varepsilon)$ times the increase in Lmin$(Cx)$.

Learning (following experts / boosting)

One reference for understanding this connection is Adaptive game playing using multiplicative weights, by Freund and Schapire. Here is a quick summary to give the technical idea.

Consider the following repeated game. In each round $t$:

1. You choose a probability distribution $p^t$ on $[n]$ (the $n$ so-called experts).
2. Knowing $p^t$, the adversary then chooses a payoff vector $a^t\in [0,1]^{n}$.
3. You receive payoff $p^t\cdot a^t$ for the round.

The game stops after some number of rounds. Your goal is to minimize your regret in comparison to any single expert (i.e., pure strategy) $i$. That is, your goal is to minimize $(\max_i \sum_t a^t_i) - \sum_t p^t\cdot a^t$.

Fix any $\varepsilon>0$. Let vector $y^t$ denote $\varepsilon \sum_{s \le t} a^s$, that is, $\varepsilon$ times the vector sum of the payoff vectors up to time $t$. Recall that $G(y)$ is the gradient of Lmax$(y)$.

Here's the basic strategy we will analyze: On round $t$, choose $p^t$ to be $G(y^{t-1})$.

By inspection, this gives you payoff $a^t \cdot G(y^{t-1})$ in round $t$.

Because of the smoothness property of $F$,

$$\mbox{Lmax}(y^t) \le \mbox{Lmax}(y^{t-1}) + (1+O(\varepsilon)) \varepsilon a^t \cdot G(y^{t-1}).$$ That is, in each round, $\mbox{Lmax}(y^t)$ can't increase by more than $\varepsilon(1+O(\varepsilon))$ times your payoff. Since $\mbox{Lmax}(\overline 0) = \ln n$, this maintains the invariant that $\mbox{Lmax}(y^t)$ is at most your total payoff times $\varepsilon(1+O(\varepsilon)$, plus $\ln(n)$. On the other hand, your regret in comparison to the best expert $i$ is $\max_i \sum_t a^t_i$, i.e., $\varepsilon^{-1} \max_i y^t_i$, which is in turn at most $\varepsilon^{-1} \mbox{Lmax}(y^t)$.

Thus, your regret is at most $\varepsilon^{-1} \ln(n)$, plus $O(\varepsilon)$ times your total payoff.

Remark: I think, as Freund and Schapire point out, a "boosting" algorithm (in learning theory) is also implicit in this analysis. See their paper for more details.

Minimizing total payoff

You can derive a similar strategy for the setting where the goal is to minimize, rather than maximize, the total payoff. Your regret, which you still want to minimize, is $\sum_t p^t\cdot a^t - \min_i a^t_i$. In that case, the corresponding strategy is to choose $p^t$ to be the gradient of $\mbox{Lmin}(y^t)$. With this strategy your regret is again at most $\varepsilon^{-1} \ln n$ plus $O(\varepsilon)$ times your total payoff.

Connection to Lagrangian-relaxation algorithms

To see the connection to Lagrangian-relaxation algorithms, fix a Set-Cover instance. Consider the latter type of game (with the goal of minimizing payoff), where the experts correspond to the elements $e$ of your set system. In each round, choose the probability distribution $p^t$ to be the gradient of Lmin$(y^t)$ as above, and have the adversary choose the payoff vector $a^t$ as a function of $p^t$ as follows: choose the set $s^t$ maximizing $\sum_{e\in s} p^t_e$, then let $a^t_e = 1$ if $e\in s^t$, and $a^t_e = 0$ otherwise.

Given the correct stopping condition (discussed below), this process gives you exactly the Set-Cover algorithm discussed at the start.

The performance guarantee of the algorithm follows from the regret bound as follows. Let $X_s$ be the number of times the adversary chose set $s$ during the play. Let $x^*$ be the optimal fractional set cover. Let $T=|X_s|$ be the number of rounds played. The regret bound implies

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

Using the definition of $a^t$, the $t$th payoff (the $t$th term in the sum on the left) equals $\sum_{e\in s^t} p^t_e$. The adversary chose $s^t$ to minimize this payoff. If the adversary had instead chosen $s^t$ randomly from the distribution $x^*/|x^*|$, the expectation of the payoff would have been

$$\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^*|}.$$ (Above we use that $\sum_{s\ni e} x^*_s \ge 1$ for all $e$, and $|p^t| = 1$.) Since each payoff is at least $1/|x^*|$, the regret bound implies $$\frac{T}{|x^*|} \le \varepsilon^{-1}\ln(m) + \min_e \sum_t a_e^t.$$ By the definition of $X$, we have $|X| = T$ (each round chooses one set), and $\sum_t a_e^t = \sum_e [e\in s^t] = \sum_{s\ni e} X_s$, giving $$\frac{|X|}{|x^*|} \le \varepsilon^{-1}\ln(m) +\min_e \sum_{s\ni e} X_s.$$ We make the process stop when $\min_e \sum_{s\ni e} X_s = \Omega(\varepsilon^{-2}\ln m)$, so then (rearranging terms) $$\frac{|X|}{\min_e \sum_{s\ni e} X_s}~ \le~ (1+O(\varepsilon)|x^*|.$$ That is, normalizing $X$ gives a fractional set cover of size at most $(1+O(\varepsilon))$ times optimum.

Remark: In a sense, this learning theory interpretation generalizes the algorithmic interpretation. However, some of the algorithmic techniques necessary for efficiency (such as non-uniform increments and dropping satisfied covering constraints) don't seem to carry over into the learning theory setting naturally. Likewise, algorithms for mixed packing and covering LPs (e.g. these) don't seem to have natural analogues in the learning-theory setting.