From: Bjørn Rustad Date: Tue, 13 May 2014 07:02:35 +0000 (+0200) Subject: Fixes X-Git-Url: http://git.rustad.me/?a=commitdiff_plain;h=c9c7dcfa4bf26a312bd8c251ab08d1be0234acce;p=prosjektoppgave Fixes --- diff --git a/cut.tex b/cut.tex index 2475ba0..593cddd 100644 --- a/cut.tex +++ b/cut.tex @@ -137,6 +137,7 @@ their argument and then ignore all pixels except the ones they actually depend on. \subsection{Network construction} +\label{sec:network_construction} We will construct a network in such a way that if a variable $u^\lambda_x$ ends up on the source side of the cut, we set $u^\lambda_x = 0$, and if it ends up on the sink side, we set $u^\lambda_x = 1$ as in diff --git a/flow.tex b/flow.tex index 8f82427..eef7b59 100644 --- a/flow.tex +++ b/flow.tex @@ -288,10 +288,10 @@ and $d$ remains a valid labeling, even if the edge $(v, u)$ appears. \begin{algorithm} \begin{algorithmic} \Function{Push}{$u$, $v$} - \State $f_{aug} \gets \min(c_f(u, v), e(u))$ - \State $f(u, v) \mathrel{+}= f_{aug}$ - \State $e(u) \mathrel{-}= f_{aug}$ - \State $e(v) \mathrel{+}= f_{aug}$ + \State $f_\text{aug} \gets \min(c_f(u, v), e(u))$ + \State $f(u, v) \mathrel{+}= f_\text{aug}$ + \State $e(u) \mathrel{-}= f_\text{aug}$ + \State $e(v) \mathrel{+}= f_\text{aug}$ \EndFunction \end{algorithmic} \caption{\sf The push procedure of the Push-Relabel algorithm} @@ -310,7 +310,7 @@ mathematical pseudocode implementation. % \If{$u$ is only node at its height} % \Call{Gap}{$u$} % \Else - \If{there is a $v$ such that $(u, v) \in E_f$} + \If{there is a $v \in V$ such that $(u, v) \in E_f$} \State $d(u) \gets \min\{d(v), \; \forall v \in V : (u,v) \in E_f\} + 1$ \Else \State $d(u) \gets N$ @@ -329,6 +329,13 @@ constraint and preflow constraint remain satisfied assuming they were satisfied before the procedure was started. \subsection{Putting it all together} + +\fixme{Should be clearer what is really happening, and especially when + we are finished/what our goal is. That we are finished as soon as + there are no more active vertices. And that how we get there does + not matter as long as we follow our constraints. +} + In the first phase of the algorithm we initialize a valid preflow and distance labeling by saturating all edges out of the source $s$, and then setting its distance label $d(s) = N$. We then run the push and @@ -338,16 +345,17 @@ and a maximum preflow is obtained. \fixme{What is saturated?} A vertex $u$ can only be successfully relabeled to obtain a new label if -the edges outgoing edges of $u$ in the residual network have changed. -This is why the push and relabel procedures often are combined into a -\emph{discharge} procedure as shown in Algorithm \ref{alg:discharge}. -When it is run on an active node $u$, as much as possible of the excess -flow is pushed to other nodes before a relabeling is done. +the outgoing edges of $u$ in the residual network have changed since the +previous relabeling. This is why the push and relabel procedures often +are combined into a \emph{discharge} procedure as shown in Algorithm +\ref{alg:discharge}. When it is run on an active vertex $u$, we push as +much as possible of the excess flow to other vertices before the vertex +is relabeled. \begin{algorithm} \begin{algorithmic} \Function{Discharge}{$u$} - \ForAll{$v$ neighbor of $u$} - \If{$c_f(u, v) > 0$ and $h(u) = h(v) + 1$} + \ForAll{$v \in V$ such that $(u, v) \in E_f$} + \If{$c_f(u, v) > 0$ and $d(u) = d(v) + 1$} \Call{Push}{$u$, $v$} \EndIf \EndFor @@ -362,37 +370,37 @@ flow is pushed to other nodes before a relabeling is done. \end{algorithm} In the second phase of the algorithm this preflow is turned into a -maximum flow by sending excess flow from inside the network back to the -source. We can skip this part of the algorithm, as we are only -interested in finding a minimum cut, and not the maximum flow. - -The following theorem allows us to find a minimum cut after the first -phase of the algorithm is finished. +maximum flow by sending excess flow which did not reach the sink, from +inside the network back to the source. We can skip this part of the +algorithm, as it is possible to identify a minimum cut as soon as the +first phase is finished, and the following theorem allows us to do that. \begin{theorem}[Cut identification] Given a network $G = (V, E, c)$, assume that the first phase of the push-relabel algorithm has terminated and no more active nodes - remain. Then there exists an $k \in \mathbb{N} \cap \left(0, - N \right)$ such that there is no vertex with label $k$, and the - vertex sets $S = \{ u : d(u) > k\}$ and $T = V - S$ define a minimum + remain. Then there exists a $k \in \mathbb{N} \cap \left(0, N + \right)$ such that there is no vertex with label $k$, and the vertex + sets $S = \{ u \in V : d(u) > k\}$ and $T = V - S$ define a minimum cut $C = (S, T)$ in $G$. \label{thm:cut_identification} \end{theorem} \begin{proof} There are $N$ nodes, the source has label $N$ and the sink has label - $0$, so the $N - 2$ remaining vertices can not occupy all the $N-1$ - other labels, and there must exist an $k$ as described. + $0$, and the $N - 2$ remaining vertices can not occupy all the $N-1$ + labels in $\{1, \ldots, N-1\}$, so there must exist an $k$ as + described. - As no vertex has label $k$, the set $T$ contains all (and only) - vertices with labels less than $k$. + As no vertex has label $k$, we can write $T = \{ u \in V : d(u) > + k\}$. - Assume there was an edge non-saturated edge $(u, v) \in E_f$ such - that $u \in S$ and $v \in T$. From the construction of $S$ and $T$, - we have $d(v) \leq d(u) + 2$, which contradicts the labeling - constraint, so no such non-saturated edge from $S$ to $T$ can - exist. From the construction of $E_f$ we now know that all edges - from $S$ to $T$ are saturated, and all edges from $T$ to $S$ have - no flow. This means that the capacity of the cut is equal to the - flow through the cut, i.e.\ $c(S, T) = f(S, T)$. + Assume there was an edge $(u, v) \in E_f$ such that $u \in S$ and $v + \in T$. From the construction of $S$ and $T$, we would have $d(v) + \leq d(u) + 2$, which contradicts the labeling constraint, so no + such non-saturated edge from $S$ to $T$ can exist. + + From the construction of $E_f$ we now know that all edges in $E$ + from $S$ to $T$ are saturated, and all edges from $T$ to $S$ have no + flow. This means that the capacity of the cut is equal to the flow + through the cut, i.e.\ $c(S, T) = f(S, T)$. Since the first phase of the algorithm has terminated, there can be no active vertices, and therefore no excess in $T$, except for the @@ -404,7 +412,7 @@ phase of the algorithm is finished. We will see later that with the gap relabeling heuristic, there will always be a gap at label $k = N - 1$ such that we can construct our cut -by taking $S = \{ u : d(u) \geq N \}$. +by taking $S = \{ u \in V : d(u) \geq N \}$. \fixme{Sketch of proof, could be nicer, shorter (split up?) and more rigorous maybe.} @@ -412,6 +420,13 @@ rigorous maybe.} \subsection{Complexity} Bleep bloop. \fixme{Edge list problematikk.} +\fixme{We have proved that when the first phase has terminated, we can + find the minimum cut, but should we maybe prove that the first phase + will terminate? Using the fact that the distance labels can only + increase? And the fact that we only push to lower vertices? + Computing the complexity is kind of like proving termination since + we find an upper bound on the number of operations. +} \subsection{Vertex selection rules} \fixme{Also mention this over complexity.} @@ -432,22 +447,23 @@ largest distance label. \subsection{Heuristics} Different heuristics exists that can speed up the algorithm considerably. Being heuristics, they are not guaranteed to work, and -might perform differently on different kinds of graphs. The most used -heuristics are the gap- and global relabeling heuristics, both aiming to -reduce the total number of relabelings needed. +might perform differently on different kinds of networks. The most used +heuristics are the gap and global relabeling heuristics, both aiming to +reduce the total number of relabeling steps. The gap relabeling heuristic aims to find a label $k$ as in Theorem \ref{thm:cut_identification} such that no vertex has that label. -Realizing that no more flow can ever be sent from the nodes $u$ such -that $d(u) > k$ we can relabel them with label $N$ and never consider -them again as they will never become active. Algorithm \ref{alg:gap} -shows a pseudocode representation of what is done once a gap $k$ is -found. +From vertices $u$ with $d(u) > k$, there are no unsaturated edges going +to vertices with smaller distance labels so no more flow can ever find +its way from these vertices to the sink. These vertices are therefore +given the label $N$ and never considered again as they will never become +active. Algorithm \ref{alg:gap} shows a pseudocode representation of +what is done once a gap $k$ is found. \begin{algorithm} \begin{algorithmic} \Function{Gap}{$k$} - \ForAll{$u$ such that $d(u) \geq k$} + \ForAll{$u \in V$ such that $d(u) > k$} \State $d(u) \gets N$ \EndFor \EndFunction @@ -466,14 +482,14 @@ procedure will not change the validity of these two things. \begin{lemma}[Gap relabeling validity] Given a network $G = (V, E, c)$, a distance labeling $d$ and a preflow $f$, assume there exists a gap $k$ such that no vertex has - label $k$. Then running the gap relabeling procedure on label $k$ - will yield a valid distance labeling and an unchanged and valid - preflow $f$. + label $k$. Running the gap relabeling procedure on label $k$ will + yield a valid distance labeling and an unchanged and valid preflow + $f$. \end{lemma} \begin{proof} - No new edges are created, no edges disappear, the flow is conserved - and only the labels are changed, so the preflow and capacity - constraint remain fulfilled after the gap relabeling. + No new edges are created, no edges disappear, the preflow is + unchanged, so the preflow and capacity constraint remain satisfied + after the gap relabeling. Define the vertex sets $S = \{ u \in V : d(u) > k\}$ and $T = V - S$. Initially, we have $d(u) \leq d(v) + 1$ for every edge $(u,v) @@ -496,34 +512,40 @@ procedure will not change the validity of these two things. \end{description} Hence, both the preflow $f$ and distance labeling $d$ are valid. + + \fixme{A bit long, could be more compact since it is not really a + very interesting proof? (And it's not really a lemma either?)} \end{proof} When running the push-relabel algorithm with the gap heuristic, we can be sure that there will never be a node $u$ with label $d(u) = N-1$ at the end of the algorithm, i.e.\ we know that there will always be a gap -at label $N-1$. Using the same reasoning as in Theorem \fixme{ref}, if -there was a vertex with label $N-1$, there would only be $N-3$ possibly -having labels in $[1, N-2]$, so a gap must exist somewhere in that -interval. When using the gap relabeling heuristic, such a gap can no -exist, so we can conclude that there is no vertex with label $N-1$. +at label $N-1$. Using the same reasoning as in Theorem +\ref{thm:cut_identification}, if there was a vertex with label $N-1$, +there would only be $N-3$ possibly having labels in $[1, N-2]$, so a gap +must exist somewhere in that interval. When using the gap relabeling +heuristic, such a gap can not exist, so we can conclude that there is no +vertex with label $N-1$. -Using Theorem \fixme{ref} we can then conclude that the sets $S = \{ u -\in V : d(u) \geq N\}$ and $T = V - S$ form a minimum cut of the network. +Using Theorem \ref{thm:cut_identification} we can then conclude that the +sets $S = \{ u \in V : d(u) \geq N\}$ and $T = V - S$ form a minimum cut +of the network. \fixme{Ugh, what a mess. Lemma maybe?} \subsection{Parametric push-relabel algorithm} Now we have an algorithm for finding a minimum $s$-$t$-cut in a network, -so let's return to the network constructed in Section \fixme{ref}. For -every level $\lambda \in ??$ we want to find a minimum $s$-$t$-cut which -gives us the thresholded image $u^\lambda$. These can then hopefully be -stacked together to form the final image $u$. +so let's return to the network constructed in Section +\ref{sec:network_construction}. For every level $\lambda \in \{0, +\ldots, L\}$ we want to find a minimum $s$-$t$-cut which gives us the +thresholded image $u^\lambda$. These can then hopefully be stacked +together to form the final image $u$. \subsubsection{Network reuse} -Solving \fixme{??} separate minimum cut problems seems like a lot of -work, but when using the push-relabel algorithm we will, if we do things -in the right order, be able to reuse the network when going from one -label to the next. +Solving $L$ separate minimum cut problems seems like a lot of work, but +when using the push-relabel algorithm we will, if we do things in the +right order, be able to reuse the network when going from one label to +the next. \begin{figure} \input{fig/norm_evolution} @@ -534,27 +556,30 @@ Going back to the network representations in Figure only the capacity of edges from sub-networks representing the fidelity term depend on our level parameter $\lambda$. From the expression in \eqref{eq:fidelity_energy0}, visualized in Figure -\ref{fig:norm_evolution} we see that the energy term $E^x(0)$ increases +\ref{fig:norm_evolution}, we see that the energy term $E^x(0)$ increases monotonically with increasing $\lambda$ parameter. Let $u, v \in V - \{s, t\}$. Since the edges in Figure \ref{fig:norm_subgraph} now are the only ones depending on $\lambda$, the following is true for \emph{decreasing} values of $\lambda$ \begin{description} \item[Edges from $s$ to $u$] - As seen in Figure \fixme{ref} the capacity of these edges will - increase monotonically with decreasing $\lambda$ parameter. + As seen in Figure \ref{fig:norm_subgraph_neg} the capacity of + these edges will increase monotonically with decreasing + $\lambda$ parameter. \item[Edges from $u$ to $v$] These edges have no $\lambda$-dependence and will remain unchanged. \item[Edges from $v$ to $t$] - As seen in Figure \fixme{ref} the capacity of these edges will - decrease monotonically with decreasing $\lambda$ parameter. + As seen in Figure \ref{fig:norm_subgraph_pos} the capacity of + these edges will decrease monotonically with decreasing + $\lambda$ parameter. \end{description} After running the push-relabel algorithm for $\lambda = k$, we are left with a network $G = (V, E, c)$, a preflow $f$ and a labeling $d$. To obtain the network for $\lambda = k-1$ we have to change the capacity of -two different kinds of edges, and this is done in the following way +two different kinds of edges, and this is done in the following way to +keep the capacity and preflow constraints satisfied. \begin{description} \item[Edges from $s$ to $u$] The capacity $c(s, u)$ is increased, and the flow is set to be @@ -567,7 +592,6 @@ two different kinds of edges, and this is done in the following way which will decrease the excess of the sink $t$, and increase the excess of $v$. \end{description} -The preflow and capacity constraints are trivially satisfied. None of these actions will create new edges in the residual network, and we do not change the labeling $d$, so the labeling constraints are also @@ -579,21 +603,21 @@ increase monotonically, we have a head start compared to if we had reset the flow and labels. \subsubsection{Output image construction} -\fixme{Mention earlier that with gap relabeling, we gap at N.} We mentioned already in section \ref{sec:total_energy} that in order to be able to construct our output image $u$, the thresholded images -$u^\lambda$ would have to stack one on top of the other \fixme{as shown -in Figure ??}. We will now show that through reuse of the distance -labels from the last iteration of the push-relabel algorithm, we can -guarantee that it is possible to stack the thresholded images. +$u^\lambda$ would have to stack one on top of the other as shown in +Figure \ref{fig:img_decomp}. We will now show that through reuse of the +distance labels from the last iteration of the push-relabel algorithm, +we can guarantee that it is possible to stack the thresholded images. + +\fixme{More precise statement than ``stack on top of each other''} Consider two subsequent runs of the push-relabel algorithm, for labels -$\lambda = k$ and $\lambda = k-1$ ending with distance labelings $d^k$ -and $d^{k-1}$ respectively. We already know that the distance -labels $d$ are monotonically increasing. This means that the set $\{ u -\in V : d(u) \geq N \}$ is increasing in size, more precisely, we have -the inclusion +$\lambda = k$ and $\lambda = k-1$ ending with distance labels $d^k$ and +$d^{k-1}$ respectively. We already know that the distance labels $d$ are +monotonically increasing. This means that the set $\{ u \in V : d(u) +\geq N \}$ is increasing in size, more precisely, we have the inclusion \begin{equation} \{ u \in V : d^k(u) \geq N \} \subseteq \{ u \in V : d^{k-1}(u) \geq N \} @@ -601,7 +625,7 @@ the inclusion We then construct our output image $u$ by giving each pixel the value \begin{equation} - u_x = \min \{ \lambda \in [0, L-1] : u^\lambda_x = 1 \}. + u_x = \min \{ \lambda \in \{0, \ldots, L-1\} : u^\lambda_x = 1 \}. \end{equation} This marks the end of the description of the implemented algorithm, but we will further discuss some possible improvements, and also look at