\documentclass[portrait,final]{baposter}

\usepackage{times}
\usepackage{calc}
\usepackage{graphicx}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{relsize}
\usepackage{multirow}
\usepackage{bm}
\usepackage{wrapfig}
\usepackage{graphicx}
\usepackage{multicol}
\usepackage{dsfont}

\usepackage{pgfbaselayers}
\pgfdeclarelayer{background}
\pgfdeclarelayer{foreground}
\pgfsetlayers{background,main,foreground}

\usepackage{helvet}
%\usepackage{bookman}
\usepackage{palatino}

\newcommand{\captionfont}{\footnotesize}

\selectcolormodel{cmyk}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%% Some math symbols used in the text
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Format
\newcommand{\Matrix}[1]{\begin{bmatrix} #1 \end{bmatrix}}
\newcommand{\Vector}[1]{\Matrix{#1}}
\newcommand*{\SET}[1]  {\ensuremath{\mathcal{#1}}}
\newcommand*{\MAT}[1]  {\ensuremath{\mathbf{#1}}}
\newcommand*{\VEC}[1]  {\ensuremath{\bm{#1}}}
\newcommand*{\CONST}[1]{\ensuremath{\mathit{#1}}}
\newcommand*{\norm}[1]{\mathopen\| #1 \mathclose\|}% use instead of $\|x\|$
\newcommand*{\abs}[1]{\mathopen| #1 \mathclose|}% use instead of $\|x\|$
\newcommand*{\absLR}[1]{\left| #1 \right|}% use instead of $\|x\|$
\newcommand{\zbf}{{\bf z}}
\def\norm#1{\mathopen\| #1 \mathclose\|}% use instead of $\|x\|$
\newcommand{\rdkap}{(\mathbb{R}^d)^\kappa}
\newcommand{\normLR}[1]{\left\| #1 \right\|}% use instead of $\|x\|$
\DeclareMathOperator*{\argmin}{argmin}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Multicol Settings
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\setlength{\columnsep}{0.7em}
\setlength{\columnseprule}{0mm}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Save space in lists. Use this after the opening of the list
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newcommand{\compresslist}{%
\setlength{\itemsep}{1pt}%
\setlength{\parskip}{0pt}%
\setlength{\parsep}{0pt}%
}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Begin of Document
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{document}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Here starts the poster
%%%---------------------------------------------------------------------------
%%% Format it to your taste with the options
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\typeout{Poster Starts}
\background{
  \begin{tikzpicture}[remember picture,overlay]%
    \draw (current page.north west)+(-2em,-0em) node[anchor=north west] {\hspace{-2em}\includegraphics[height=1.1\textheight]{silhouettes_background}};
  \end{tikzpicture}%
}

\definecolor{silver}{cmyk}{0,0,0,0.3}
\definecolor{yellow}{cmyk}{0.504,0.288,0,0}
\definecolor{reddishyellow}{cmyk}{0.84,0.48,0,0}
\definecolor{black}{cmyk}{0,0,0.0,1.0}
\definecolor{darkYellow}{cmyk}{0.84,0.48,0,0}
\definecolor{darkSilver}{cmyk}{0,0,0,0.1}

\definecolor{lightyellow}{cmyk}{0.175,0.1,0,0}
\definecolor{lighteryellow}{cmyk}{0.14,0.08,0,0}
\definecolor{lighteryellow}{cmyk}{0.0,0.0,0,0}
\definecolor{lightestyellow}{cmyk}{0.0,0.0,0,0}


\begin{poster}{
  % Show grid to help with alignment
  grid=no,
  % Column spacing
  colspacing=1em,
  % Color style
  bgColorOne=lighteryellow,
  bgColorTwo=lightestyellow,
  borderColor=reddishyellow,
  headerColorOne=yellow,
  headerColorTwo=reddishyellow,
  headerFontColor=black,
  boxColorOne=lightyellow,
  boxColorTwo=lighteryellow,
  % Format of textbox
  textborder=roundedleft,
  % Format of text header
  eyecatcher=no,
  headerborder=open,
  headerheight=0.08\textheight,
  headershape=roundedright,
  headershade=plain,
  headerfont=\Large\textsf, %Sans Serif
  boxshade=plain,
%  background=shade-tb,
  background=plain,
  linewidth=2pt
  }
  % Eye Catcher
  {} % No eye catcher for this poster. If an eye catcher is present, the title is centered between eye-catcher and logo.
  % Title
  {\sf %Sans Serif
  %\bf% Serif
  A Discussion on Parallelization Schemes for Vector Quantization Algorithms}
  % Authors
  {\sf %Sans Serif
  % Serif
  Matthieu Durut\hspace{3em}
  Benoit Patra\hspace{3em}
  Fabrice Rossi\hspace{3em}
  }
  % University logo
  {{\begin{minipage}{16em}
    \hfill
    \includegraphics[height=5em]{../../Pictures/Logos/telecom}
    \includegraphics[height=5em]{../../Pictures/Logos/lokad}
  \end{minipage}}
  }

  \tikzstyle{light shaded}=[top color=baposterBGtwo!30!white,bottom color=baposterBGone!30!white,shading=axis,shading angle=30]

  % Width of left inset image
     \newlength{\leftimgwidth}
     \setlength{\leftimgwidth}{0.78em+8.0em}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Now define the boxes that make up the poster
%%%---------------------------------------------------------------------------
%%% Each box has a name and can be placed absolutely or relatively.
%%% The only inconvenience is that you can only specify a relative position
%%% towards an already declared box. So if you have a box attached to the
%%% bottom, one to the top and a third one which should be in between, you
%%% have to specify the top and bottom boxes before you specify the middle
%%% box.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %
    % A coloured circle useful as a bullet with an adjustably strong filling
    \newcommand{\colouredcircle}[1]{%
      \tikz{\useasboundingbox (-0.2em,-0.32em) rectangle(0.2em,0.32em); \draw[draw=black,fill=baposterBGone!80!black!#1!white,line width=0.03em] (0,0) circle(0.18em);}}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Contribution}{name=contribution,column=0,row=0}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   {}We present parallelization schemes for stochastic Vector
Quantization (VQ) algorithms in order to obtain time speed-ups using distributed
resources. Because of the non-convexity of the VQ loss function, the most intuitive parallelization scheme does
not lead to better performances than the sequential algorithm. Other schemes that
tackle this issue are proposed and implemented on Microsoft Windows Azure platform obtaining
good speed-ups.
 }


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Online and Parallel Online Learning}{name=case0_1,column=1, span=2, row=0}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  The VQ technique computes a summary of a dataset $\{\zbf_{t}\}_{t=1}^n$ of $d$
dimensional samples with $\kappa$ prototypes, $w=(w_1, \ldots,w_\kappa) \in
\rdkap$. The VQ technique belongs to the class of stochastic gradient descent algorithms and compute iterations of the prototypes as follow:

\begin{align*}
w(t+1)=w(t)-\varepsilon_{t+1} H\left(\zbf^i_{\{t+1\text{ mod }n\}},w(t)\right), \quad  t\geq0\\
with \quad H(\zbf,w) = \left( \left(w_\ell - \zbf\right) \mathds{1}_{\left\{l= \argmin_{i = 1, \ldots, \kappa} \left\|\zbf  - w_i\right\|^2\right\}}\right)_{1 \leq \ell \leq \kappa}, \quad \mbox{$\zbf \in \mathbb{R}^{d}$ and $w \in \rdkap$.}
\end{align*}

We assume having access to $M$ computing entities, each of them executing concurrent VQ procedures by computing prototype versions denoted by $\{w^{i}(t)\}_{t=0}^\infty$. We investigate techniques that provide a consensus version of the prototypes $\{w^{srd}(t)\}_{t=0}^{\infty}$ for which the convergence is speeded-up in comparison of the sequential procedure.
}

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Initial scheme}{name=IM,column=1,row=1,span=2, below=case0_1}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    \begin{minipage}[c]{0.45\linewidth}
        \small
        {
            \begin{equation}
                \begin{cases}
                    w^i(t) = w^i(t-1) - \varepsilon_{t} H\left(\zbf^i_{\{t\text{ mod }n\}},w^i(t-1)\right), \quad  t \geq1\\  %\label{eq:processing}\\
                    \begin{cases}
                        w^{srd}(t) = \frac{1}{M} \displaystyle\sum_{j=1}^{M} w^{j}(t)\\
                        w^i(t) =  w^{srd}(t) &\\
                    \end{cases} \quad \text{ if } t \text{ mod } \tau =0.
                \end{cases}
            \end{equation}

        }
    In this scheme, computations are synchronized and prototypes versions are averaged every $\tau$ points.
    \end{minipage} \hfill
    \begin{minipage}[c]{0.5\linewidth}
        \centering{\includegraphics[scale=0.25, clip=true, trim = 21mm 25mm 21mm 25mm]{../../Pictures/parallelDALVQ/pa10NoTitle}}
    \end{minipage}
 }

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Improved scheme}{name=SM,column=1,row=2,span=2, below=IM}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    \begin{minipage}[c]{0.5\linewidth}
         \small{
            \begin{equation}
                \begin{cases}
                    w^i(t) = w^i(t-1) - \varepsilon_{t} H\left(\zbf^i_{\{t\text{ mod }n\}},w^i(t-1)\right), \quad  t \geq1 \\  %\label{eq:processing}\\
                    \begin{cases}
                        w^{srd}(t) = w^{srd}(t-\tau) - \displaystyle\sum_{j=1}^M{\Delta^j_{t- \tau \rightarrow t} } & \\
                        w^i(t) =  w^{srd}(t) &\\
                    \end{cases} \text{ if } t \text{ mod } \tau =0.
                \end{cases}
            \end{equation}}

    where $\Delta^j_{t_1\rightarrow t_2} = \displaystyle\sum_{t'=t_1 + 1}^{t_2} \varepsilon_{t'}H\left(\zbf^j_{\{t'\text{ mod }n \}},w^j(t'-1)\right)$.
    \end{minipage} \hfill
    \begin{minipage}[c]{0.5\linewidth}
        \centering{\includegraphics[scale=0.25, clip=true, trim = 21mm 25mm 21mm 25mm]{../../Pictures/parallelDALVQ/correctedPa10NoTitle}}
    \end{minipage}


 }

  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Improved scheme with asynchronism and delays}{name=TM,column=1,row=3,span=2, below=SM}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    \begin{minipage}[c]{0.5\linewidth}
       \small
       {
            \begin{equation}\label{eq:delayedAveraging}
                \begin{cases}
                    w^i(t) = w^i(t-1) - \varepsilon_{t} H\left(\zbf^i_{\{t\text{ mod }n\}},w^i(t-1)\right), \quad  t \geq1& \\ %\label{eq:processing}\\
                    w^{srd}(t) = w^{srd}(t-1) - \displaystyle\sum_{j, t = \tau^{j}(t)}{\Delta^j_{\tau^{j}(\tau^{j}(t-1) -1) \rightarrow \tau^{j}(t-1)}}& \\
                    w^i(t) = w^{srd}(\tau^{i}(t-1)) - \Delta^i_{\tau^{i}(t-1) \rightarrow t}, \quad \text{ if }  t = \tau^{i}(t) \\
                \end{cases}
            \end{equation}
        }
       where $\tau^{i}(t)$ stands for the last time smaller or equal to $t$ for which the computing instance $i$ has shared results with the consensus agent.
    \end{minipage} \hfill
    \begin{minipage}[c]{0.5\linewidth}
        \centering{\includegraphics[scale=0.25, clip=true, trim = 21mm 25mm 21mm 25mm]{../../Pictures/parallelDALVQ/pa10RandomdelayedNoTitle}}
    \end{minipage}
 }

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Experiment Settings}{name=ES,column=0,span=1,below=contribution}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

All the schemes have been tested using simulated distributed
architecture. They have been evaluated on a synthetic data set of vector B-Splines using the empirical distortion loss function. For $w \in \rdkap$, it writes:

\begin{equation*}\label{eq:empiricalDisto}
C_{n,M}(w) = \frac{1}{nM} \sum_{i=1}^M \sum_{t=1}^n{\min_{\ell = 1, \ldots, \kappa} \left\|\zbf^i_t  - w_\ell\right\|^2}.
\end{equation*}

\begin{minipage}[c]{1.0\linewidth}
\begin{center}
\includegraphics[scale = 0.35]{../../Pictures/parallelDALVQ/centers}
\end{center}
\end{minipage}
    %\centering{\includegraphics[scale=0.35]{../../Pictures/parallelDALVQ/BSplines}}
  }


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Experiments on Windows Azure}{name=ExpOnAzure,column=0, span=2, below=TM, above=bottom}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{minipage}[c]{0.35\linewidth}
The latter scheme has also been implemented on top of the Cloud Computing
platform Microsoft Windows Azure. Azure BlobStorage, a No-SQL "key-value pairs" storage, is used as a communication medium between computing units. Snapshots of the consensus shared version are taken regularly and evaluated offline.
\end{minipage} \hfill
\begin{minipage}[c]{0.60\linewidth}
\centering{\includegraphics[height=0.5\linewidth]{../../Pictures/parallelDALVQ/scalabilityNoTitle}}\\
\end{minipage}

\vspace*{0.2cm}
Our software project, named CloudDALVQ (the source code is available at http://code.google.com/p/clouddalvq/), makes special care of bottleneck and latency issues related to the consensus building process. This specific design tackle the issue of delays that can significantly reduce convergence speed, as outlined in \cite{ScalingML} in the convex case. Our implementation proves to provide satisfactory scale-up up to 32 processing units.\\
  }


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Comments}{name=case1_3,column=0, span=1, below=ES, above=ExpOnAzure}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Theoretical results have recently proved that the averaging of local prototypes versions led to the best possible speed-ups (see \cite{DekelShamir}) under smoothness and convexity assumptions of the loss function. In the VQ case, this function is not convex and the na�ve averaging does not lead to any speed-up, as showed in our first experiment.\\

We provide another distributed scheme, that sums the multiple displacement terms instead of averaging the prototypes versions. This new scheme proves to provide satisfactory speed-ups. It also gives us licence to suggest an asynchronous version of this scheme (as described in equations \ref{eq:delayedAveraging}). This latter scheme is suited to implementations on high latency platforms such as cloud computing.
}

  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  \headerbox{Conclusion}{name=case2_4,column=2,span=1,above=bottom,below=case1_3,below=TM}{
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
The non-convexity of the VQ loss function forbids to employ consensus techniques such as averaging. The present work provides different distribution schemes that restore satisfactory scale-ups. These latter schemes are adapted to asynchronous implementations that are particularly suited to cloud computing environments. Our cloud implementation on Azure provides scale-ups up to dozens of processing units.\\

\smaller
    \vspace{-0.4em}
    \bibliographystyle{ieee}
    \renewcommand{\section}[2]{\vskip 0.05em}
      \begin{thebibliography}{1}\itemsep=-0.01em
      \setlength{\baselineskip}{0.4em}
      \bibitem{DekelShamir}
        Ofer Dekel, Ran Gilad-Bachrach, Ohad Shamir, and Lin Xiao
        \newblock Optimal distributed online prediction using mini-batches
        \newblock In {Advances in Neural Information Processing Systems 22 2009, p2331-2339}
      \bibitem{ScalingML}
        Daniel Hsu, Nikos Karampatziakis, John Langford, Alex J. Smola
        \newblock Parallel Online Learning
        \newblock In {Scaling up Machine Learning chapter 14, 2011, p283-306}
      \end{thebibliography}

  }%

\end{poster}%
%
\end{document}
