ift6266: writeup/nips2010_submission.tex comparison

comparison writeup/nips2010_submission.tex @ 467:e0e57270b2af

refs

author	Yoshua Bengio <bengioy@iro.umontreal.ca>
date	Sat, 29 May 2010 16:50:03 -0400
parents	6205481bf33f
children	d02d288257bf

comparison

equal deleted inserted replaced

-:6205481bf33f
+:e0e57270b2af
 \end{enumerate}
 The experimental results presented here provide positive evidence towards all of these questions.
 \section{Perturbation and Transformation of Character Images}
-This section describes the different transformations we used to generate data, in their order.
+This section describes the different transformations we used to stochastically
+transform source images in order to obtain data. More details can
+be found in this technical report~\cite{ift6266-tr-anonymous}.
 The code for these transformations (mostly python) is available at
 {\tt http://anonymous.url.net}. All the modules in the pipeline share
 a global control parameter ($0 \le complexity \le 1$) that allows one to modulate the
 amount of deformation or noise introduced.
-We can differentiate two important parts in the pipeline. The first one,
+There are two main parts in the pipeline. The first one,
-from slant to pinch, performs transformations of the character. The second
+from slant to pinch below, performs transformations. The second
-part, from blur to contrast, adds noise to the image.
+part, from blur to contrast, adds different kinds of noise.
-\subsection{Slant}
+{\large\bf Transformations}\\
+{\bf Slant}\\
-In order to mimic a slant effect, we simply shift each row of the image
+We mimic slant by shifting each row of the image
-proportionnaly to its height: $shift = round(slant \times height)$.  We
+proportionnaly to its height: $shift = round(slant \times height)$.
-round the shift in order to have a discret displacement. We do not use a
-filter to smooth the result in order to save computing time and also
-because latter transformations have similar effects.
 The $slant$ coefficient can be negative or positive with equal probability
-and its value is randomly sampled according to the complexity level.  In
+and its value is randomly sampled according to the complexity level:
-our case we take uniformly a number in the range $[0,complexity]$, so the
+e $slant \sim U[0,complexity]$, so the
 maximum displacement for the lowest or highest pixel line is of
-$round(complexity \times 32)$.
+$round(complexity \times 32)$.\\
+{\bf Thickness}\\
+Morpholigical operators of dilation and erosion~\cite{Haralick87,Serra82}
-\subsection{Thickness}
+are applied. The neighborhood of each pixel is multiplied
+element-wise with a {\em structuring element} matrix.
-To change the thickness of the characters we used morpholigical operators:
+The pixel value is replaced by the maximum or the minimum of the resulting
-dilation and erosion~\cite{Haralick87,Serra82}.
+matrix, respectively for dilation or erosion. Ten different structural elements with
+increasing dimensions (largest is $5\times5$) were used.  For each image,
-The basic idea of such transform is, for each pixel, to multiply in the
+randomly sample the operator type (dilation or erosion) with equal probability and one structural
-element-wise manner its neighbourhood with a matrix called the structuring
-element.  Then for dilation we remplace the pixel value by the maximum of
-the result, or the minimum for erosion.  This will dilate or erode objects
-in the image and the strength of the transform only depends on the
-structuring element.
-We used ten different structural elements with increasing dimensions (the
-biggest is $5\times5$).  for each image, we radomly sample the operator
-type (dilation or erosion) with equal probability and one structural
 element from a subset of the $n$ smallest structuring elements where $n$ is
 $round(10 \times complexity)$ for dilation and $round(6 \times complexity)$
-for erosion.  A neutral element is always present in the set, if it is
+for erosion.  A neutral element is always present in the set, and if it is
-chosen the transformation is not applied.  Erosion allows only the six
+chosen no transformation is applied.  Erosion allows only the six
 smallest structural elements because when the character is too thin it may
-erase it completly.
+be completely erased.\\
+{\bf Affine Transformations}\\
-\subsection{Affine Transformations}
+A $2 \times 3$ affine transform matrix (with
+6 parameters $(a,b,c,d,e,f)$) is sampled according to the $complexity$ level.
-We generate an affine transform matrix according to the complexity level,
+Each pixel $(x,y)$ of the output image takes the value of the pixel
-then we apply it directly to the image.  The matrix is of size $2 \times
+nearest to $(ax+by+c,dx+ey+f)$ in the input image.  This
-3$, so we can represent it by six parameters $(a,b,c,d,e,f)$.  Formally,
+produces scaling, translation, rotation and shearing.
-for each pixel $(x,y)$ of the output image, we give the value of the pixel
+The marginal distributions of $(a,b,c,d,e,f)$ have been tuned by hand to
-nearest to : $(ax+by+c,dx+ey+f)$, in the input image.  This allows to
-produce scaling, translation, rotation and shearing variances.
-The sampling of the parameters $(a,b,c,d,e,f)$ have been tuned by hand to
 forbid important rotations (not to confuse classes) but to give good
-variability of the transformation. For each image we sample uniformly the
+variability of the transformation: $a$ and $d$ $\sim U[1-3 \times
-parameters in the following ranges: $a$ and $d$ in $[1-3 \times
+complexity,1+3 \times complexity]$, $b$ and $e$ $\sim[-3 \times complexity,3
-complexity,1+3 \times complexity]$, $b$ and $e$ in $[-3 \times complexity,3
+\times complexity]$ and $c$ and $f$ $\sim U[-4 \times complexity, 4 \times
-\times complexity]$ and $c$ and $f$ in $[-4 \times complexity, 4 \times
+complexity]$.\\
-complexity]$.
+{\bf Local Elastic Deformations}\\
+This filter induces a "wiggly" effect in the image, following~\cite{SimardSP03},
+which provides more details.
-\subsection{Local Elastic Deformations}
+Two "displacements" fields are generated and applied, for horizontal
+and vertical displacements of pixels.
-This filter induces a "wiggly" effect in the image. The description here
-will be brief, as the algorithm follows precisely what is described in
-\cite{SimardSP03}.
-The general idea is to generate two "displacements" fields, for horizontal
-and vertical displacements of pixels. Each of these fields has the same
-size as the original image.
-When generating the transformed image, we'll loop over the x and y
-positions in the fields and select, as a value, the value of the pixel in
-the original image at the (relative) position given by the displacement
-fields for this x and y. If the position we'd retrieve is outside the
-borders of the image, we use a 0 value instead.
 To generate a pixel in either field, first a value between -1 and 1 is
-chosen from a uniform distribution. Then all the pixels, in both fields, is
+chosen from a uniform distribution. Then all the pixels, in both fields, are
 multiplied by a constant $\alpha$ which controls the intensity of the
-displacements (bigger $\alpha$ translates into larger wiggles).
+displacements (larger $\alpha$ translates into larger wiggles).
+Each field is convoluted with a Gaussian 2D kernel of
-As a final step, each field is convoluted with a Gaussian 2D kernel of
+standard deviation $\sigma$. Visually, this results in a blur.
-standard deviation $\sigma$. Visually, this results in a "blur"
-filter. This has the effect of making values next to each other in the
-displacement fields similar. In effect, this makes the wiggles more
-coherent, less noisy.
-As displacement fields were long to compute, 50 pairs of fields were
-generated per complexity in increments of 0.1 (50 pairs for 0.1, 50 pairs
-for 0.2, etc.), and afterwards, given a complexity, we selected randomly
-among the 50 corresponding pairs.
-$\sigma$ and $\alpha$ were linked to complexity through the formulas
 $\alpha = \sqrt[3]{complexity} \times 10.0$ and $\sigma = 10 - 7 \times
-\sqrt[3]{complexity}$.
+\sqrt[3]{complexity}$.\\
+{\bf Pinch}\\
+This GIMP filter is named "Whirl and
-\subsection{Pinch}
+pinch", but whirl was set to 0. A pinch is ``similar to projecting the image onto an elastic
+surface and pressing or pulling on the center of the surface''~\cite{GIMP-manual}.
-This is another GIMP filter we used. The filter is in fact named "Whirl and
+For a square input image, think of drawing a circle of
-pinch", but we don't use the "whirl" part (whirl is set to 0). As described
-in GIMP, a pinch is "similar to projecting the image onto an elastic
-surface and pressing or pulling on the center of the surface".
-Mathematically, for a square input image, think of drawing a circle of
 radius $r$ around a center point $C$. Any point (pixel) $P$ belonging to
 that disk (region inside circle) will have its value recalculated by taking
 the value of another "source" pixel in the original image. The position of
 that source pixel is found on the line thats goes through $C$ and $P$, but
 at some other distance $d_2$. Define $d_1$ to be the distance between $P$
 and $C$. $d_2$ is given by $d_2 = sin(\frac{\pi{}d_1}{2r})^{-pinch} \times
 d_1$, where $pinch$ is a parameter to the filter.
-If the region considered is not square then, before computing $d_2$, the
-smallest dimension (x or y) is stretched such that we may consider the
-region as if it was square. Then, after $d_2$ has been computed and
-corresponding components $d_2\_x$ and $d_2\_y$ have been found, the
-component corresponding to the stretched dimension is compressed back by an
-inverse ratio.
 The actual value is given by bilinear interpolation considering the pixels
 around the (non-integer) source position thus found.
+Here $pinch \sim U[-complexity, 0.7 \times complexity]$.\\
-The value for $pinch$ in our case was given by sampling from an uniform
-distribution over the range $[-complexity, 0.7 \times complexity]$.
+{\large\bf Injecting Noise}\\
+{\bf Motion Blur}\\
-\subsection{Motion Blur}
+This GIMP filter is a ``linear motion blur'' in GIMP
+terminology, with two parameters, $length$ and $angle$. The value of
-This is a GIMP filter we applied, a "linear motion blur" in GIMP
+a pixel in the final image is the approximately mean value of the $length$ first pixels
-terminology. The description will be brief as it is a well-known filter.
+found by moving in the $angle$ direction.
+Here $angle \sim U[0,360]$ degrees, and $length \sim {\rm Normal}(0,(3 \times complexity)^2)$.\\
-This algorithm has two input parameters, $length$ and $angle$. The value of
+{\bf Occlusion}\\
-a pixel in the final image is the mean value of the $length$ first pixels
+This filter selects a random rectangle from an {\em occluder} character
-found by moving in the $angle$ direction. An approximation of this idea is
+images and places it over the original {\em occluded} character
-used, as we won't fall onto precise pixels by following that
+image. Pixels are combined by taking the max(occluder,occluded),
-direction. This is done using the Bresenham line algorithm.
+closer to black. The corners of the occluder  The rectangle corners
+are sampled so that larger complexity gives larger rectangles.
-The angle, in our case, is chosen from a uniform distribution over
+The destination position in the occluded image are also sampled
-$[0,360]$ degrees. The length, though, depends on the complexity; it's
+according to a normal distribution (see more details in~\cite{ift6266-tr-anonymous}.
-sampled from a Gaussian distribution of mean 0 and standard deviation
+It has has a probability of not being applied at all of 60\%.\\
-$\sigma = 3 \times complexity$.
+{\bf Pixel Permutation}\\
+This filter permutes neighbouring pixels. It selects first
-\subsection{Occlusion}
-This filter selects random parts of other (hereafter "occlusive") letter
-images and places them over the original letter (hereafter "occluded")
-image. To be more precise, having selected a subregion of the occlusive
-image and a desination position in the occluded image, to determine the
-final value for a given overlapping pixel, it selects whichever pixel is
-the lightest. As a reminder, the background value is 0, black, so the value
-nearest to 1 is selected.
-To select a subpart of the occlusive image, four numbers are generated. For
-compability with the code, we'll call them "haut", "bas", "gauche" and
-"droite" (respectively meaning top, bottom, left and right). Each of these
-numbers is selected according to a Gaussian distribution of mean $8 \times
-complexity$ and standard deviation $2$. This means the largest the
-complexity is, the biggest the occlusion will be. The absolute value is
-taken, as the numbers must be positive, and the maximum value is capped at
-15.
-These four sizes collectively define a window centered on the middle pixel
-of the occlusive image. This is the part that will be extracted as the
-occlusion.
-The next step is to select a destination position in the occluded
-image. Vertical and horizontal displacements $y\_arrivee$ and $x\_arrivee$
-are selected according to Gaussian distributions of mean 0 and of standard
-deviations of, respectively, 3 and 2. Then an horizontal placement mode,
-$place$, is selected to be of three values meaning
-left, middle or right.
-If $place$ is "middle", the occlusion will be horizontally centered
-around the horizontal middle of the occluded image, then shifted according
-to $x\_arrivee$. If $place$ is "left", it will be placed on the left of
-the occluded image, then displaced right according to $x\_arrivee$. The
-contrary happens if $place$ is $right$.
-In both the horizontal and vertical positionning, the maximum position in
-either direction is such that the selected occlusion won't go beyond the
-borders of the occluded image.
-This filter has a probability of not being applied, at all, of 60\%.
-\subsection{Pixel Permutation}
-This filter permuts neighbouring pixels. It selects first
 $\frac{complexity}{3}$ pixels randomly in the image. Each of them are then
 sequentially exchanged to one other pixel in its $V4$ neighbourhood. Number
 of exchanges to the left, right, top, bottom are equal or does not differ
 from more than 1 if the number of selected pixels is not a multiple of 4.
+It has has a probability of not being applied at all of 80\%.\\
-It has has a probability of not being applied, at all, of 80\%.
+{\bf Gaussian Noise}\\
-\subsection{Gaussian Noise}
 This filter simply adds, to each pixel of the image independently, a
-Gaussian noise of mean $0$ and standard deviation $\frac{complexity}{10}$.
+noise $\sim Normal(0(\frac{complexity}{10})^2)$.
+It has has a probability of not being applied at all of 70\%.\\
-It has has a probability of not being applied, at all, of 70\%.
+{\bf Background Images}\\
-\subsection{Background Images}
 Following~\cite{Larochelle-jmlr-2009}, this transformation adds a random
 background behind the letter. The background is chosen by first selecting,
-at random, an image from a set of images. Then we choose a 32x32 subregion
+at random, an image from a set of images. Then a 32$\times$32 subregion
-of that image as the background image (by sampling x and y positions
+of that image is chosen as the background image (by sampling position
 uniformly while making sure not to cross image borders).
 To combine the original letter image and the background image, contrast
 adjustments are made. We first get the maximal values (i.e. maximal
 intensity) for both the original image and the background image, $maximage$
-and $maxbg$. We also have a parameter, $contrast$, given by sampling from a
+and $maxbg$. We also have a parameter $contrast \sim U[complexity, 1]$.
-uniform distribution over $[complexity, 1]$.
+Each background pixel value is multiplied by $\frac{max(maximage -
+contrast, 0)}{maxbg}$ (higher contrast yield darker
-Once we have all these numbers, we first adjust the values for the
+background). The output image pixels are max(background,original).\\
-background image. Each pixel value is multiplied by $\frac{max(maximage -
+{\bf Salt and Pepper Noise}\\
-contrast, 0)}{maxbg}$. Therefore the higher the contrast, the darkest the
+This filter adds noise $\sim U[0,1]$ to random subsets of pixels.
-background will be.
+The number of selected pixels is $0.2 \times complexity$.
+This filter has a probability of not being applied at all of 75\%.\\
-The final image is found by taking the brightest (i.e. value nearest to 1)
+{\bf Spatially Gaussian Noise}\\
-pixel from either the background image or the corresponding pixel in the
+Different regions of the image are spatially smoothed.
-original image.
+The image is convolved with a symmetric Gaussian kernel of
+size and variance choosen uniformly in the ranges $[12,12 + 20 \times
-\subsection{Salt and Pepper Noise}
-This filter adds noise to the image by randomly selecting a certain number
-of them and, for those selected pixels, assign a random value according to
-a uniform distribution over the $[0,1]$ ranges. This last distribution does
-not change according to complexity. Instead, the number of selected pixels
-does: the proportion of changed pixels corresponds to $complexity / 5$,
-which means, as a maximum, 20\% of the pixels will be randomized. On the
-lowest extreme, no pixel is changed.
-This filter also has a probability of not being applied, at all, of 75\%.
-\subsection{Spatially Gaussian Noise}
-The aim of this transformation is to filter, with a gaussian kernel,
-different regions of the image. In order to save computing time we decided
-to convolve the whole image only once with a symmetric gaussian kernel of
-size and variance choosen uniformly in the ranges: $[12,12 + 20 \times
 complexity]$ and $[2,2 + 6 \times complexity]$. The result is normalized
 between $0$ and $1$.  We also create a symmetric averaging window, of the
 kernel size, with maximum value at the center.  For each image we sample
 uniformly from $3$ to $3 + 10 \times complexity$ pixels that will be
 averaging centers between the original image and the filtered one.  We
 initialize to zero a mask matrix of the image size. For each selected pixel
 we add to the mask the averaging window centered to it.  The final image is
 computed from the following element-wise operation: $\frac{image + filtered
 image \times mask}{mask+1}$.
+This filter has a probability of not being applied at all of 75\%.\\
-This filter has a probability of not being applied, at all, of 75\%.
+{\bf Scratches}\\
-\subsection{Scratches}
 The scratches module places line-like white patches on the image.  The
-lines are in fact heavily transformed images of the digit "1" (one), chosen
+lines are heavily transformed images of the digit "1" (one), chosen
-at random among five thousands such start images of this digit.
+at random among five thousands such 1 images. The 1 image is
+randomly cropped and rotated by an angle $\sim Normal(0,(100 \times
-Once the image is selected, the transformation begins by finding the first
+complexity)^2$, using bicubic interpolation,
-$top$, $bottom$, $right$ and $left$ non-zero pixels in the image. It is
+Two passes of a greyscale morphological erosion filter
-then cropped to the region thus delimited, then this cropped version is
+are applied, reducing the width of the line
-expanded to $32\times32$ again. It is then rotated by a random angle having a
+by an amount controlled by $complexity$.
-Gaussian distribution of mean 90 and standard deviation $100 \times
-complexity$ (in degrees). The rotation is done with bicubic interpolation.
-The rotated image is then resized to $50\times50$, with anti-aliasing. In
-that image, we crop the image again by selecting a region delimited
-horizontally to $left$ to $left+32$ and vertically by $top$ to $top+32$.
-Once this is done, two passes of a greyscale morphological erosion filter
-are applied. Put briefly, this erosion filter reduces the width of the line
-by a certain $smoothing$ amount. For small complexities (< 0.5),
-$smoothing$ is 6, so the line is very small. For complexities ranging from
-0.25 to 0.5, $smoothing$ is 5. It is 4 for complexities 0.5 to 0.75, and 3
-for higher complexities.
-To compensate for border effects, the image is then cropped to 28x28 by
-removing two pixels everywhere on the borders, then expanded to 32x32
-again. The pixel values are then linearly expanded such that the minimum
-value is 0 and the maximal one is 1. Then, 50\% of the time, the image is
-vertically flipped.
 This filter is only applied only 15\% of the time. When it is applied, 50\%
 of the time, only one patch image is generated and applied. In 30\% of
 cases, two patches are generated, and otherwise three patches are
 generated. The patch is applied by taking the maximal value on any given
-patch or the original image, for each of the 32x32 pixel locations.
+patch or the original image, for each of the 32x32 pixel locations.\\
+{\bf Color and Contrast Changes}\\
-\subsection{Color and Contrast Changes}
 This filter changes the constrast and may invert the image polarity (white
 on black to black on white). The contrast $C$ is defined here as the
-difference between the maximum and the minimum pixel value of the image. A
+difference between the maximum and the minimum pixel value of the image.
-contrast value is sampled uniformly between $1$ and $1-0.85 \times
+Contrast $\sim U[1-0.85 \times complexity,1]$ (so constrast $\geq 0.15$).
-complexity$ (this insure a minimum constrast of $0.15$). We then simply
+The image is normalized into $[\frac{1-C}{2},1-\frac{1-C}{2}]$. The
-normalize the image to the range $[\frac{1-C}{2},1-\frac{1-C}{2}]$. The
 polarity is inverted with $0.5$ probability.
 \begin{figure}[h]
 \resizebox{.99\textwidth}{!}{\includegraphics{images/example_t.png}}\\
 SDA1   &  17.1\% $\pm$.13\%  &  29.7\%$\pm$.3\%  & 29.7\%$\pm$.3\%  & 1.4\% $\pm$.1\%\\ \hline
 SDA2   &  18.7\% $\pm$.13\%  &  33.6\%$\pm$.3\%  & 39.9\%$\pm$.17\%  & 1.7\% $\pm$.1\%\\ \hline
 MLP0   &  24.2\% $\pm$.15\%  & 68.8\%$\pm$.33\%  & 78.70\%$\pm$.14\%  & 3.45\% $\pm$.15\% \\ \hline
 MLP1   &  23.0\% $\pm$.15\%  &  41.8\%$\pm$.35\%  & 90.4\%$\pm$.1\%  & 3.85\% $\pm$.16\% \\ \hline
 MLP2   &  24.3\% $\pm$.15\%  &  46.0\%$\pm$.35\%  & 54.7\%$\pm$.17\%  & 4.85\% $\pm$.18\% \\ \hline
-[5]    &                     &                    &                   & 4.95\% $\pm$.18\% \\ \hline
+\cite{Granger+al-2007} &     &                    &                   & 4.95\% $\pm$.18\% \\ \hline
-[2]    &                     &                    &                   & 3.71\% $\pm$.16\% \\ \hline
+\cite{Cortes+al-2000} &      &                    &                   & 3.71\% $\pm$.16\% \\ \hline
-[3]    &                     &                    &                   & 2.4\% $\pm$.13\% \\ \hline
+\cite{Oliveira+al-2002} &    &                    &                   & 2.4\% $\pm$.13\% \\ \hline
-[4]    &                     &                    &                   & 2.1\% $\pm$.12\% \\ \hline
+\cite{Migram+al-2005} &      &                    &                   & 2.1\% $\pm$.12\% \\ \hline
 \end{tabular}
 \end{center}
 \end{table}
 \subsection{Perturbed Training Data More Helpful for SDAE}

Mercurial > ift6266

comparison writeup/nips2010_submission.tex @ 467:e0e57270b2af