Submodular maximization with uncertain knapsack capacity

03/07/2018 ∙ by Yasushi Kawase, et al. ∙ 0

We consider the maximization problem of monotone submodular functions under an uncertain knapsack constraint. Specifically, the problem is discussed in the situation that the knapsack capacity is not given explicitly and can be accessed only through an oracle that answers whether or not the current solution is feasible when an item is added to the solution. Assuming that cancellation of the last item is allowed when it overflows the knapsack capacity, we discuss the robustness ratios of adaptive policies for this problem, which are the worst case ratios of the objective values achieved by the output solutions to the optimal objective values. We present a randomized policy of robustness ratio (1-1/e)/2, and a deterministic policy of robustness ratio 2(1-1/e)/21. We also consider a universal policy that chooses items following a precomputed sequence. We present a randomized universal policy of robustness ratio (1-1/√(e))/2. When the cancellation is not allowed, no randomized adaptive policy achieves a constant robustness ratio. Because of this hardness, we assume that a probability distribution of the knapsack capacity is given, and consider computing a sequence of items that maximizes the expected objective value. We present a polynomial-time randomized algorithm of approximation ratio (1-1/√(e))/4-ϵ for any small constant ϵ >0.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The submodular maximization is one of the most well-studied combinatorial optimization problems. Since it captures an essential part of decision-making situations, it has a huge number of applications in diverse areas of computer science. Nevertheless, the standard setting of the submodular maximization problem fails to capture several realistic situations. For example, let us consider choosing several items to maximize a reward represented by a submodular function subject to a resource limitation. When the amount of the available resource is exactly known, this problem is formulated as the submodular maximization problem with a knapsack constraint. However, in many practical cases, precise information on the available resource is not given. Thus, algorithms for the standard submodular maximization problem cannot be applied to this situation. Motivated by this fact, we study robust maximization of submodular functions with an uncertain knapsack capacity. Besides the practical applications, it is interesting to study this problem because it shows how much robustness can be achieved for an uncertain knapsack capacity in submodular maximization.

More specifically, we study the submodular maximization problem with an unknown knapsack capacity (SMPUC). In this problem, we are given a set of items, and a monotone nonnegative submodular function such that , where each item is associated with a size . The objective is to find a set of items that maximizes the submodular function subject to a knapsack constraint, but we assume that the knapsack capacity is unknown. We have access to the knapsack capacity through an oracle; we add items to the knapsack one by one, and we see whether or not the selected items violates the knapsack constraint only after the addition. If a selected item fits the knapsack, the selection of this item is irrevocable. When the total size of the selected items exceeds the capacity, there are two settings according to whether or not the last selection can be canceled. If the cancellation is allowed, then we remove the last selected item from the knapsack, and continue adding the remaining items to the knapsack. In the other setting, we stop the selection, and the final output is defined as the item set in the knapsack before adding the last item.

For the setting where the cancellation is allowed, we consider an adaptive policy

, which is defined as a decision tree to decide which item to pack into the knapsack next. A

randomized policy is a probability distribution over adaptive policies. Performance of an adaptive policy is evaluated by the robustness ratio defined as follows. For any number , let denote the optimal item set when the capacity is , and let denote an output of the policy. Note that if the policy is a randomized one, then

is a random variable. We call the adaptive policy

-robust, for some , if for any , the expected objective value of the policy’s output is within a ratio of the optimal value, i.e., . We also call the ratio the robustness ratio of the policy.

One main purpose of this paper is to present algorithms that produce adaptive policies of constant robustness ratios for SMPUC. Moreover, we consider a special type of adaptive policy called a universal policy. A universal policy selects items following a precomputed order of items regardless of the observations made while packing. Thus, a universal policy is identified with a sequence of the given items. This is in contrast to general adaptive policies, where the next item to try can vary with the observations made up to that point. We present an algorithm that produces a randomized universal policy that achieves a constant robustness ratio.

If the cancellation is not allowed, then there is no difference between adaptive and universal policies because the selection terminates once a selected item does not fit the knapsack. In this case, we observe that no randomized adaptive policy achieves a constant robustness ratio. Due to this hardness, we consider a stochastic knapsack capacity when the cancellation is not allowed. In this situation, we assume that the knapsack capacity is determined according to some probability distribution and the information of the distribution is available. Based on this assumption, we compute a sequence of items as a solution. When the knapsack capacity is realized, the items in the prefix of the sequence are selected so that their total size does not exceed the realized capacity. The objective of the problem is to maximize the expected value of the submodular function for the selected items. We address this problem as the submodular maximization problem with a stochastic knapsack capacity (SMPSC). We say that the approximation ratio of a sequence is if its expected objective value is at least times the maximum expected value of for any instance. The sequence computed in an -robust policy for SMPUC achieves an -approximation ratio for SMPSC. However, the opposite does not hold, and an algorithm of a constant approximation ratio may exist for SMPSC even though no randomized adaptive policy achieves a constant robustness ratio for SMPUC. Indeed, we present such an algorithm.

1.1 Related studies

There are a huge number of studies on the submodular maximization problems (e.g., [18]), but we are aware of no previous work on SMPUC or SMPSC. Regarding studies on the stochastic setting of the problem, several papers proposed concepts of submodularity for random set functions and discussed adaptive policies to maximize those functions [2, 10]. There are also studies on the submodular maximization over an item set in which each item is activated stochastically [1, 9, 12]. However, as far as we know, there is no study on the problem with stochastic constraints.

When the objective function is modular (i.e., the function returns the sum of the values associated with the selected items), the submodular maximization problem with a knapsack constraint is equivalent to the classic knapsack problem. For the knapsack problem, there are numerous studies on the stochastic sizes and rewards of items [5, 11, 15]. This problem is called the stochastic knapsack problem. Note that this is different from the knapsack problem with a stochastic capacity (KPSC), and there is no direct relationship between them. However, we observe that most of the algorithms for the stochastic knapsack problem can be applied to KPSC. Indeed, one of our algorithms for SMPSC is based on the idea of Gupta et al. [11] for the stochastic knapsack problem.

The covering version of KPSC is studied in a context of single machine scheduling with nonuniform processing speed. This problem is known to be strongly NP-hard [13], which implies that pseudo-polynomial time algorithms are unlikely to exist. This is in contrast to the fact that the classic knapsack problem and its covering version admit pseudo-polynomial time algorithms. Megow and Verschae [17] gave a PTAS for the covering version of KPSC.

To the best of our knowledge, KPSC itself has not been studied well. The only previous study we are aware of is the thesis of Dabney [4], wherein a PTAS is presented for the problem. Since the knapsack problem and its covering version are equivalent in the existence of exact algorithms, the strongly NP-hardness of the covering version implies the same hardness for KPSC.

Regarding the knapsack problem with an unknown capacity (KPUC), Megow and Mestre [16] mentioned that no deterministic policy achieves a constant robustness ratio when cancellation is not allowed. They presented an algorithm that constructs for each instance a policy whose robustness ratio is arbitrarily close to the one of an optimal policy that achieves the largest robustness ratio for the instance. When cancellation is allowed, Disser et al. [6] provided a deterministic -robust universal policy for KPUC. They also proved that no deterministic adaptive policy achieves a robustness ratio better than , which means that the robustness ratio of their deterministic universal policy is best possible even for any deterministic adaptive policy.

1.2 Contributions

with cancellation without cancellation
unknown
rand. adaptive -robust
rand. universal -robust
det. adaptive -robust
no constant robustness ratio
capacity

stochastic
rand. pseudo-poly time -approx.
capacity rand. -approx.
Table 1: Summary of main results in this paper

Contributions in this paper are summarized in Table 1. For the case where cancellation is allowed, we present three polynomial-time algorithms for SMPUC. These algorithms produce

  • a randomized adaptive policy of robustness ratio (Section 3.1);

  • a deterministic adaptive policy of robustness ratio (Section 3.2);

  • a randomized universal policy of robustness ratio (Section 3.3).

Our algorithms are constructed based on a simple greedy algorithm [14] for the monotone submodular maximization problem with a knapsack constraint. The greedy algorithm outputs a better solution among two candidates, one of which is constructed greedily based on the increase in the objective function value per unit of size, and the other of which is based on the increase in the objective function value. In our randomized adaptive policy, we achieve the robustness ratio by guaranteeing that each of the two candidate solutions is output by our policy with probability .

We convert this randomized policy into a deterministic one by mixing the two strategies which correspond to the two candidate solutions. We remark that the same approach is taken for KPUC to construct a deterministic -robust universal policy by Disser et al. [6]. They call an item swap item if it corresponds to a single-item solution for some knapsack capacity. A key idea in their policy is to pack swap items earlier than the others. However, their technique fully relies on the property that the objective function is modular, and their choice of swap items is not suitable for SMPUC. In the present paper, we introduce a new notion of single-valuable items. This enables us to design a deterministic -robust policy. We remark that our proof technique is also different from the standard one used in related work. Moreover, we modify the randomized adaptive policy to obtain the randomized universal policy. A key idea here is to guess a capacity by a doubling strategy.

We also show that no randomized adaptive policy achieves a robustness ratio better than for KPUC (Section 4.1). It is known that the robustness ratio achieved by deterministic policies for this problem is at most  [6], but there was no upper bound on the robustness ratio for randomized policies. Disser et al. [6] mentioned that it is an interesting open problem to improve the ratio by randomized policies. Our upper bound implies that, even if randomized policies are considered, the ratio cannot be improved better than . In addition, we show that no deterministic policy achieves robustness ratio better than and no randomized policy achieves robustness ratio better than for SMPUC even when each item has a unit size (Section 4.3).

When cancellation is not allowed, it has been already known that KPUC admits no deterministic universal policy of a constant robustness ratio [16]. We advance this hardness result by showing that no randomized adaptive policy achieves a constant robustness ratio (Section 4.2).

For SMPSC without cancellation, we present the following two algorithms:

  • a pseudo-polynomial time randomized algorithm of approximation ratio (Section 5.1);

  • a polynomial-time randomized algorithm of approximation ratio for any small constant (Section 5.2).

The former algorithms is based on the observation that the problem can be reduced to the submodular maximization problem with an interval independent constraint. The latter algorithm is based on the idea of Gupta et al. [11]

for the stochastic knapsack problem. Gupta et al. regarded the knapsack capacity as a time limit, and showed that a rounding algorithm for a time-index linear program (LP) gives an adaptive policy for the stochastic knapsack problem. Although the formulation size of the time-index LP is not polynomial, a simple doubling technique reduces the formulation size to polynomial with a loss of the approximation ratio. In our algorithm for

SMPSC, we first introduce a time-index convex relaxation of the problem using the multilinear extension of the objective function, and show that the rounding algorithm of Gupta et al. is a monotone contention resolution scheme for any realization of the knapsack capacity. This observation gives a pseudo-polynomial time algorithm of approximation ratio for SMPSC. We then transform it into a polynomial-time algorithm. This transformation requires a careful sketching of knapsack capacity, which was not necessary for the stochastic knapsack problem.

1.3 Organization

The rest of this paper is organized as follows. Section 2 gives notations and preliminary facts used in this paper. Section 3 presents the adaptive policies for SMPUC with cancellation. Section 4 provides the upper-bounds on the robustness ratios. Section 5 presents the approximation algorithms for SMPSC without cancellation. Section 6 concludes the paper.

2 Preliminaries

In this section, we define terminologies used in this paper, and introduce existing results which we will use.

Maximization of monotone submodular functions: The inputs of the problem are a set of items and a nonnegative set function . In this paper, we assume that (i) satisfies , (ii) is submodular (i.e., for any ), and (iii) is monotone (i.e., for any with ). The function is given as an oracle that returns the value of for any query . Let be any family such that implies . The -constrained submodular maximization problem seeks that maximizes .

We focus on the case where corresponds to a knapsack constraint. Namely, each item is associated with a size , and is defined as for some knapsack capacity . We assume that the item size () and the knapsack capacity are positive integers. We denote by for any .

Problem SMPUC: In SMPUC, the knapsack capacity is unknown. We can see whether an item set fits the knapsack only when an item is added to the item set.

A solution for SMPUC is an adaptive policy , which is represented as a binary decision tree that contains every item at most once along each path from the root to a leaf. Each node of the decision tree is an item to try packing into the knapsack. A randomized policy is a probability distribution over binary decision trees. One of the decision trees is selected according to the probability distribution. For a fixed capacity , the output of a policy is an item set denoted by obtained as follows. We start with and check whether the item at the root of fits the knapsack, i.e., whether . If the item fits, then we add to and continue packing recursively with the left subtree of . Otherwise, we have two options: when cancellation is allowed, we discard and continue packing recursively with the right subtree of ; when cancellation is not allowed, we discard and output to terminate the process.

When a policy does not depend on the observation made while packing, we call such a policy universal. Since every path from the root to a leaf in a universal policy is identical, we can identify a universal policy with a sequence of items in . For a fixed capacity , the output of a universal policy, denoted by , is constructed as follows. We start with , and add items to in iterations. In the th iteration, we check whether holds or not. If true, then is added to . Otherwise, is discarded, and we proceed to the next iteration when cancellation is allowed, and we terminate the process when cancellation is not allowed.

Problem SMPSC: In SMPSC, the knapsack capacity is given according to some probability distribution. Let . For each , we denote by the probability that the knapsack capacity is . We assume that the probability is given to an algorithm through an oracle that returns the value of for any query . Hence, the input size of a problem instance is and an algorithm runs in pseudo-polynomial time if its running time depends on linearly. A solution for SMPSC is a universal policy, i.e., a sequence of the items in . When a capacity is decided, the output of is constructed in the same way as universal policies for SMPUC. The objective of SMPSC is to find a sequence that maximizes .

Multilinear extension, continuous greedy, and contention resolution scheme:

From any vector

, we define a random subset of so that each is included in with probability , where the inclusion of is independent from the inclusion of the other items. For a submodular function , its multilinear extension is defined by for all . This function satisfies the smooth monotone submodularity, that is, for any and for any . Although it is hard to compute the value of exactly, it usually can be approximated with arbitrary precision by a Monte-Carlo simulation. In this paper, to make discussion simple, we assume that can be computed exactly.

A popular approach for solving the -constrained submodular maximization problem is to use a continuous relaxation of the problem. Let be a polytope in which each integer vector in is the incidence vector of a member of . Then, holds. In this approach, it is usually assumed that is downward-closed (i.e., if satisfies , then ), and solvable (i.e., the maximization problem can be solved in polynomial time for any ).

Calinescu et al. [3] gave an algorithm called continuous greedy for a continuous maximization problem over a solvable downward-closed polytope . They proved that the continuous greedy outputs a vector such that . Feldman [7] extended its analysis by observing that the continuous greedy algorithm with stopping time outputs a vector such that and (The performance guarantee depending on the stopping time is originally given for the measured continuous greedy algorithm proposed by [8]). It is easy to see that his analysis can be modified to prove a slightly stronger result . In addition, this analysis requires only the smooth monotone submodularity as a property of .

A fractional vector can be rounded into an integer vector by a contention resolution scheme. Let . For a vector , we denote . We consider an algorithm that receives and as inputs and returns a random subset . Such an algorithm is called -balanced contention resolution scheme if with probability 1 for all and , and holds for all and (recall that is the random subset of determined from ). It is also called monotone if for any . If a monotone -balanced contention resolution scheme is available, then we can achieve the approximation ratio claimed in the following theorem by applying it to a fractional vector computed by the measured continuous greedy algorithm with stopping time . This fact is summarized as in the following theorem.

Theorem 1 ([8]).

If there exists a monotone -balanced contention resolution scheme for , then the -constrained submodular maximization problem admits an approximation algorithm of ratio for any nonnegative monotone submodular function.

3 Adaptive policies for Smpuc with cancellation

3.1 Randomized -robust policy

In this subsection, we present a randomized adaptive policy for SMPUC in the situation that the cancellation is allowed. The idea of our algorithm is based on a simple greedy algorithm [14] for the submodular maximization problem with a knapsack constraint. The greedy algorithm generates two candidate item sets. One set is obtained greedily by repeatedly inserting an item maximizing the increase in the objective function value per unit of size. The other is obtained similarly by packing an item maximizing the increase in the objective function value. Then, the algorithm returns the set with the larger value, which leads to a -approximation solution.

The idea of choosing a better solution is not suitable for SMPUC, in which we cannot remove items from the knapsack. We resolve this issue by generating at random one of two policies and that are analogous to the above two greedy methods. One policy corresponds to the greedy algorithm based on the increase in the objective function value per unit of size. We formally present this policy as Algorithm 1. The item corresponds to a node of depth in . We remark that Algorithm 1 chooses independently of the knapsack capacity, but the choice depends on the observations which items fit the knapsack and which items did not so far. For generality of the algorithm, we assume that the algorithm receives an initial state of the knapsack, which is defined as a subset of (this will be used in Section 3.2).

1 , ;
2 foreach  do
3       let ;
4       if  fits the knapsack (i.e., ) then // left subtree
5            
6      else // right subtree
7            discard
8      ;
9      
10return ;
Algorithm 1 Greedy algorithm for

The policy tries to pack items greedily based on the increase in the objective function value. Our algorithm is summarized in Algorithm 2. We remark that Algorithm 2 chooses the item for each iteration in polynomial time with respect to the cardinality of .

1 flip a coin;
2 if head then execute Algorithm 1 for ;
3 // policy else // policy
4       , ;
5       foreach  do
6             let ;
7             if  fits the knapsack (i.e., ) then // left subtree
8                  
9            else // right subtree
10                  discard
11            ;
12            
13      return ;
14      
Algorithm 2 Randomized -robust adaptive policy

We analyze the robustness ratio of Algorithm 2. In the execution of Algorithm 1 for under some capacity , we call the order of items in the greedy order for with capacity , where is the th selected item at line 3. A key concept in the analysis of Algorithm 2 is to focus on the first item in the greedy order that is a member of but is spilled from . The following lemma is useful in analysis of Algorithm 2 and also algorithms given in subsequent sections.

Lemma 1.

Let be any positive numbers, and let be the smallest index such that and (let if there is no such index). When Algorithm 1 is executed for with capacity , it holds for any index that

Moreover, holds for any .

To prove Lemma 1, we show the following two lemmas.

Lemma 2.

For any , we have

Proof.

Suppose that , where . Let for each . Note that and . Since is submodular, we have . By summing both sides over , we obtain , which proves the lemma. ∎

Lemma 3.

Let be any positive number. For any and any such that and

it holds that

Proof.

By applying Lemma 2 with , we have . In addition, holds by monotonicity. Thus, we have

Proof of Lemma 1.

We denote and for each . Let and . We first prove by induction on that for any . For , the statement clearly holds because and .

Suppose that holds for some . If , then we have , and hence it is easy to see that . In the following, we may assume that . Note that . We observe that by choice of in Algorithm 1, it holds that

Because , we can apply Lemma 3 with , and to derive

Therefore, by using this inequality, we see that

where the last inequality holds because for any .

It remains to show that for any . The inclusion is clear. For any , we have by choice of . Thus, . This completes the proof. ∎

We are ready to analyze the robustness ratio of Algorithm 2. For any , we denote and denote by an item with the largest value in this set, i.e., .

Theorem 2.

Algorithm 2 is a randomized -robust adaptive policy.

Proof.

Let (respectively, ) be the adaptive policy in Algorithm 2 when the coin comes up head (respectively, tail). Suppose that the given capacity is . The expected value of the output by Algorithm 2 is . If , then we get . Assume that . Let be the greedy order for with capacity . Let be the smallest index such that and . We have because and . By the monotonicity and submodularity of , we have

Note that by the choice of , we have and . Thus, Lemma 1 implies that , and hence we have . ∎

3.2 Deterministic -robust policy

In this subsection, we present a deterministic adaptive policy for SMPUC by modifying Algorithm 2. To this end, let us review the result of Disser et al. [6] for KPUC, which is identical to SMPUC with modular objective functions. They obtained a deterministic -robust universal policy for KPUC based on the greedy order for with the given capacity. Their policy first tries to insert items with large values, which are called swap items. For a greedy order , an item is called a swap item if for some capacity such that is the first item that overflows the knapsack when the items are packed in the greedy order. The key property is that the greedy order does not depend on the capacity when is modular. This enables them to determine swap items from the unique greedy order, and to obtain a deterministic universal policy.

On the other hand, it is hard to apply their idea to our purpose. The difficulty is that the greedy order varies according to the capacity when is submodular. Thus, the notion of swap items is not suitable in SMPUC for choosing the items that should be tried first. In this paper, we introduce single-valuable items, which are items satisfying . In the design of our algorithm, we use a polynomial-time -approximation algorithm that computes ; for example,  [18]. Our algorithm calculates the set of the single-valuable items in a sense of -approximation. To be precise, it holds that for any item and for any item .

Our algorithm first tries to insert items in until one of these items fits the knapsack (or all the items have been canceled) and then it executes Algorithm 1 with the remaining items. We remark that, unlike the algorithm for KPUC [6], our algorithm executes Algorithm 1 once a single-valuable item fits the knapsack. We summarize our algorithm in Algorithm 3.

1 , , ;
2 foreach  do
3       Let be a -approximate solution to ;
4       if  then ;
5      
6while  and  do
7       let ;
8       if  fits the knapsack (i.e., ) then ;
9       // left subtree else discard ;
10       // right subtree ;
11      
12execute Algorithm 1 for ;
Algorithm 3 Deterministic -robust policy

Note that our algorithm constructs and decides which item to try in polynomial time. In the rest of this subsection, we let , , and denote the item sets at the beginning of line 3. Then is empty if , and consists of exactly one item otherwise. The following theorem is the main result of this section.

Theorem 3.

Algorithm 3 using a -approximation algorithm in line 3 is a -robust universal policy. In particular, it is -robust when , and it is -robust when .

We describe the proof idea. We discuss the behavior of Algorithm 3 when the given capacity is . Since the output of Algorithm 3 is for , one can think of a similar proof to the one of Theorem 2. However, we may not be able to use the value in the evaluation of here because may not contain any items that bound . We show the theorem using a different approach. A basic idea is to divide into several subsets and derive a bound by the submodularity of . A key idea is to evaluate each using properties of single-valuable items, which are shown as the following two lemmas.

Lemma 4.

It holds that for any item .

Proof.

The lemma follows because if and if . ∎

Lemma 5.

Let . If , then, for any number , it holds that .

Proof.

First, suppose that contains some item with and . Then we have by the submodularity of . Since the existence of item implies , consists of exactly one item from . We denote this item by . Any item with does not fit the knapsack with capacity . This implies that . Moreover, we have because . Hence, follows. On the other hand, holds, where the last inequality follows from . Therefore, we see that

Second, suppose that contains some item with and . Recall that implies . Since , we see that

Finally, assume that all items in have size at most . We can divide into three sets with . Therefore, we have

The lemma follows from the arguments on the three cases. ∎

Proof of Theorem 3.

Let be the deterministic policy described as Algorithm 3. Suppose that the given capacity is . We remark that for . We may assume that since otherwise . Let . We branch the analysis into two cases: (a) and (b) .

Case (a): We claim that

Since , Lemma 5 indicates that . We evaluate by using Lemma 1 with . We may assume that ; otherwise holds, which implies that . Let be the greedy order for with capacity . Let be the smallest index such that and . We denote . As , we see that . Then Lemma 1 implies that

and hence the claim follows.

Case (b): In this case, we prove the following two claims. Note that is nonempty since . Let denote the unique item in .

Claim 1.

.

Proof.

Let . Since , we observe that has at most two items. We evaluate by splitting depending on .

Suppose that and . It follows that . By Lemma 4, we have . Since , it follows that