[Paper Review] Minimizing a sum of submodular functions

Vladimir Kolmogorov|arXiv (Cornell University)|Jun 10, 2010

Complexity and Algorithms in Graphs16 references4 citations

TL;DR

This paper proposes an efficient algorithm for minimizing a sum of submodular functions by reducing the problem to a submodular flow instance in an auxiliary graph, leveraging specialized exchange capacity oracles for individual terms. The method achieves improved time complexity—especially for cardinality-dependent terms—by exploiting structure via Iwata's capacity scaling, outperforming general submodular minimization in practice for vision applications.

ABSTRACT

We consider the problem of minimizing a function represented as a sum of submodular terms. We assume each term allows an efficient computation of {\em exchange capacities}. This holds, for example, for terms depending on a small number of variables, or for certain cardinality-dependent terms. A naive application of submodular minimization algorithms would not exploit the existence of specialized exchange capacity subroutines for individual terms. To overcome this, we cast the problem as a {\em submodular flow} (SF) problem in an auxiliary graph, and show that applying most existing SF algorithms would rely only on these subroutines. We then explore in more detail Iwata's capacity scaling approach for submodular flows (Math. Programming, 76(2):299--308, 1997). In particular, we show how to improve its complexity in the case when the function contains cardinality-dependent terms.

Motivation & Objective

• To develop a faster algorithm for minimizing a sum of submodular functions, especially when individual terms admit efficient exchange capacity computation.
• To overcome the inefficiency of general submodular minimization by exploiting problem-specific structure in terms like cardinality-dependent or pairwise interactions.
• To enable practical optimization of complex energy functions in computer vision that are currently restricted to minimum $s$-$t$ cut reductions due to computational cost.
• To generalize and improve upon existing reductions by showing that submodular flow with capacity scaling can handle broader classes of submodular terms efficiently.

Proposed method

• The problem is reformulated as a submodular flow (SF) problem in an auxiliary graph, where exchange capacities correspond to those of individual submodular terms.
• The algorithm uses Iwata's capacity scaling approach for submodular flows, which iteratively refines the solution by scaling capacity thresholds.
• For each term $f_Q$, the method relies on a specialized exchange capacity oracle that computes $\min_S f_Q(S) - z(S)$ efficiently for any $z \in \mathbb{R}^Q$.
• The complexity depends on $\alpha_Q$ and $\beta_Q$, which quantify the cost of computing exchange capacities for different term types: $O(1)$ for pairs, $O(|Q|)$ for cardinality terms, and $O(|Q|^2)$ for pairwise interactions.
• The algorithm processes arcs in groups based on subset membership (e.g., $Q'$, $Q''$) and uses precomputed arrays and cumulative sums to efficiently determine valid flow transitions.
• A novel procedure, $\texttt{ProcessLeft}_{10}(v)$, is introduced to handle inter-group flows in $\bar{A}_{10}$ arcs using dynamic thresholding based on $\min \bar{g}(k',k'') > 0$.

Experimental results

Research questions

• RQ1 Can we minimize a sum of submodular functions more efficiently than general-purpose submodular minimization by exploiting structure in individual terms?
• RQ2 How can we reduce the problem to a submodular flow while preserving access to efficient exchange capacity oracles for each term?
• RQ3 What is the complexity of the resulting algorithm when terms depend on cardinality or pairwise interactions?
• RQ4 Can we improve the scaling complexity of Iwata's algorithm for submodular flows in the presence of cardinality-dependent terms?
• RQ5 Is it possible to avoid prohibitively large reductions to minimum $s$-$t$ cut by using submodular flow with structured oracles?

Key findings

• The proposed algorithm achieves a time complexity of $O\left((n + \sum_Q \alpha_Q)(n + \sum_Q \beta_Q)\log U\right)$, where $U$ is an upper bound on function values.
• For pairwise terms ($|Q|=2$), the complexity is $O(n^2 \log U)$, matching the best-known bounds for such cases.
• For cardinality-dependent terms $f_Q(S) = g(|S|)$ with concave $g$, the complexity is $O(n|Q| \log U)$, improving over prior reductions that required $O(|Q|^2)$ edges.
• For terms depending on two disjoint subsets $Q', Q''$, the complexity is $O(n|Q|^2 \log U)$, which is significantly better than general submodular minimization.
• The method avoids the need for large auxiliary graphs used in $s$-$t$ cut reductions, using only $O(|Q|)$ memory per term instead of $O(|Q|^2)$.
• The algorithm is practical for computer vision applications where terms are small and structured, enabling optimization of energy functions previously deemed too costly to minimize directly.