---
abstract: 'Semantic segmentation requires methods capable of learning high-level features while dealing with large volume of data. Towards such goal, Convolutional Networks can learn specific and adaptable features based on the data. However, these networks are not capable of processing a whole remote sensing image, given its huge size. To overcome such limitation, the image is processed using fixed size patches. The definition of the input patch size is usually performed empirically (evaluating several sizes) or imposed (by network constraint). Both strategies suffer from drawbacks and could not lead to the best patch size. To alleviate this problem, several works exploited multi-scale information by combining networks or layers. This process increases the number of parameters resulting in a more difficult model to train. In this work, we propose a novel technique to perform semantic segmentation of remote sensing images that exploits a multi-scale paradigm without increasing the number of parameters while defining, in training time, the best patch size. The main idea is to train a dilated network with distinct patch sizes, allowing it to capture multi-scale characteristics from heterogeneous contexts. While processing these varying patches, the network provides a score for each patch size, helping in the definition of the best size for the current scenario. A systematic evaluation of the proposed algorithm is conducted using four high-resolution remote sensing datasets with very distinct properties. Our results show that the proposed algorithm provides improvements in pixelwise classification accuracy when compared to state-of-the-art methods.'
author:
- 'Keiller Nogueira, Mauro Dalla Mura, Jocelyn Chanussot, William Robson Schwartz, Jefersson A. dos Santos [^1] [^2]'
bibliography:
- 'bibliography.bib'
title: 'Dynamic Multi-Scale Segmentation of Remote Sensing Images based on Convolutional Networks'
---

[Nogueira ]{}

Semantic Segmentation, Deep Learning, Convolutional Neural Networks, Multi-scale, Remote Sensing

Introduction {#sec:intro}
============

The increased accessibility to high spatial resolution data provided by new sensor technologies has opened new horizons to the remote sensing community, allowing a better understanding of the Earth’s surface. Towards such understanding, one of the most important task is semantic labeling (or segmentation), which may be stated as a task of assigning a semantic category to every pixel in an image. Semantic segmentation allows the creation of thematic maps aiming to help in the comprehension of a scene. In fact, semantic labeling has been an essential task for the remote sensing community [@richards1999remote] given that its outcome, the thematic map, generates essential and useful information capable of assisting in the decision making of a wide range of fields, including environmental monitoring, agriculture [@nogueira2015coffee], disaster relief [@fustes2014cloud], urban planning [@volpi2017dense].

Given the importance of such task, several methods [@dey2010review; @deeplearningreview] have been proposed for the semantic segmentation of remote sensing images. The current state-of-the-art method for semantic segmentation is based on a resurgent approach, called deep learning [@deeplearningbook], that can learn specific and adaptable spatial features directly from the images. Specifically, deep learning aims at designing end-to-end trainable neural networks, i.e., systems that map raw input into an output space depending on the task. These systems are capable of learning features and classifiers (in distinct layers) and adjust the parameters, at running time, based on accuracy, giving more importance to one layer than another depending on the problem. This end-to-end feature learning (e.g., from image pixels to semantic labels) is the great advantage of deep learning when compared to previous state-of-the-art methods [@lecun2015deep], such as low-level [@penatti2012comparative] and mid-level (e.g. Bag of Visual Words [@sivic2003video]) descriptors.

Among all networks, a specific type, called Convolutional (Neural) Networks, ConvNets or CNNs [@deeplearningbook], is the most traditional one for learning visual features in computer vision applications, as well as remote sensing. This type of network relies on the natural stationary property of an image, i.e., the information learned in one part of the image can be used to describe any other region of the image. Furthermore, ConvNets usually obtain different levels of abstraction for the data, ranging from local low-level information in the initial layers (e.g., corners and edges), to more semantic descriptors, mid-level information (e.g., object parts) in intermediate layers, and high-level information (e.g., whole objects) in the final layers.

Although originally proposed for image classification, to become more suitable for the semantic labeling task, these ConvNets were adapted to output a dense prediction, i.e., to produce another image (usually with the same resolution of the input) that has each pixel associated to a semantic class. Based on this idea, several networks [@long2015fully; @badrinarayanan2015segnet; @noh2015learning] achieved state-of-the-art for the labeling task in the computer vision domain. Because of their success, these approaches were naturally introduced into the remote sensing scenario. Although somehow successful in this domain, these approaches could be improved if some differences for aerial images were taken into account. Specifically, the main difference concerns the definition of spatial context. In classical computer vision applications, the spatial context is restricted by the scene. In the case of remote sensing images, the context is typically delimited by an input patch (mainly because of memory constraints, given the huge size of remote sensing images). Therefore, the definition of the best input patch size is of vital importance for the network, given that patches of small size could not bring enough information to allow the network to capture the patterns while, larger patches could lead to semantically mixed information, which could affect the performance of the ConvNet. In the literature, the definition of this patch size is usually performed using two approaches: (i) empirically [@sherrah2016fully; @volpi2017dense], by evaluating several sizes and selecting the best one, which is a very expensive process, given that, for each size, a new network must be trained (without any guarantee for the best patch configuration), and (ii) imposed [@audebert2016semantic; @marmanis2016classification], in which the patch size is defined by network constraints (i.e., changing the patch size implies modifying the architecture). This could be a potentially serious limitation given that the patch size required by the network could be not even close to the optimal one. Hence, it is clear that both current strategies suffer from drawbacks and could not lead to the best patch size.

An attempt to alleviate such dependence of the patch size is to aggregate multi-scale information[^3]. Multi-scale paradigm has been proven to be essential for segmentation methods [@santos2012multiscale; @sherrah2016fully], given that it allows the model to extract and capture patterns of varying granularity, helping the method to aggregate more useful information. Therefore, several works [@marcu2016dual; @audebert2016semantic; @maggiori2016high; @marmanis2016classification; @paisitkriangkrai2016semantic; @wang2017gated] incorporate the benefits of the multi-scale paradigm in their architectures using different approaches. Some of them [@marcu2016dual; @paisitkriangkrai2016semantic; @audebert2016semantic] train several distinct layers or networks, one for each scale, and combine them for the final prediction. Others [@marmanis2016classification; @maggiori2016high; @wang2017gated] extract and merge features from distinct layers in order to aggregate multi-scale information. Independently of the approach, to aggregate multi-scale information, more parameters are included in the final model, resulting in a more complex learning process [@deeplearningbook].

In this work, we propose a novel technique to perform semantic segmentation of remote sensing images that exploits the multi-scale paradigm without increasing the number of parameters while defining adaptively the optimal patch size for the inference stage. Specifically, this technique is based upon an architecture composed exclusively on dilated convolutions [@YuKoltun2016], which are capable of processing input patch of varying sizes without distinction, given that they learn the patterns without downsampling the input. In fact, the multi-scale information is aggregated to the model by allowing it to be trained using patches of varying sizes (and contexts), a process that does not require any combination of distinct networks or layers (a common process of deep learning-based multi-scale approaches), resulting in a method with fewer parameters and easier to train. Furthermore, during the training stage, the network gives a score (based on accuracy or loss) for each patch size. Then, in the prediction phase, the process selects the patch size with the highest score to perform the segmentation. Therefore, differently from empirically selecting the best patch size which requires a new network trained for each evaluated patch (increasing the computational complexity and training time), the proposed technique evaluates several patches during the training stage and selects the best one for the inference phase doing only a unique training procedure. Aside from the aforementioned advantages, the proposed networks can be fine-tuned for any semantic segmentation application, since it does not depend on the patch size to process the data. This allows other applications to benefit from the patterns extracted by our models, a very interesting feature specially when working with small amounts of labeled data [@nogueira2017towards].

In practice, these are the contributions of this work:

-   Our main contribution is a novel approach that performs remote sensing semantic segmentation by doing a unique training procedure that aggregates multi-scale information while determining the best input patch size for the inference stage,

-   Network architectures capable of performing semantic segmentation of remote sensing datasets with distinct properties, and that can be trained or fine-tuned for any semantic segmentation application.

The paper is structured as follows. Related works are presented in Section \[sec:relwork\] while the concept of dilated convolutions are introduced in Section \[sec:background\]. We explain the proposed technique in Section \[sec:methodology\]. Section \[sec:experiments\] presents the experimental protocol and Section \[sec:results\] reports and discusses the obtained results. Finally, in Section \[sec:conclusions\] we conclude the paper and point promising directions for future work.

Related Work {#sec:relwork}
============

As introduced, deep learning has made its way into the remote sensing community, mainly due to its success in several computer vision tasks. Towards a better understanding of the Earth’s surface, a myriad of techniques [@marcu2016dual; @audebert2016semantic; @maggiori2016high; @sherrah2016fully; @marmanis2016classification; @paisitkriangkrai2016semantic; @wang2017gated] have been proposed to perform semantic segmentation in remote sensing images. Based on previous successful models [@kokkinos2015pushing; @long2015fully], several of the proposed works exploit the benefits of the multi-scale paradigm. In [@audebert2016semantic], the authors fine-tuned a deconvolutional network (based on SegNet [@badrinarayanan2015segnet]) using $256\times256$ fixed size patches. To incorporate multi-scale knowledge into the learning process, they proposed a multi-kernel technique at the last convolutional layer. Specifically, the last layer is decomposed into three branches. Each branch processes the same feature maps but using distinct filter sizes generating different outputs which are combined into the final dense prediction. They argue that these different scales smooth the final predictions due to the combination of distinct fields of view and spatial context.

Sherrah [@sherrah2016fully] proposed methods based on fully convolutional networks [@long2015fully]. The first architecture was purely based on the fully convolutional paradigm, i.e., the network has several downsampling layers (generating a coarse map) and a final bilinear interpolation layer, which is responsible to restore the coarse map into a dense prediction. In the second strategy, the previous network was adapted by replacing the downsampling layers with dilated convolutions, allowing the network to maintain the full resolution of the image. Finally, the last strategy evaluated by the authors was to fine-tune [@nogueira2017towards] pre-trained networks over the remote sensing datasets. None of the aforementioned strategies exploit the benefits of the multi-scale paradigm. Furthermore, these techniques were evaluated using several input patch sizes with final architectures processing patches with $128\times128$ or $256\times256$ pixels depending on the dataset.

Marcu et al. [@marcu2016dual] combined the outputs of a dual-stream network in order to aggregate multi-scale information for semantic segmentation. Specifically, each network processes the image using patches of distinct size, i.e., one network process $256\times256$ patches (in which the global context is considered) while the other processes $64\times64$ patches (where local context is taken into account). The output of these architectures are combined in a later stage using another network. Although they can train the network jointly, in an end-to-end process, the number of parameters is really huge allowing them to use only small values of batch size (10 patches per batch). In [@paisitkriangkrai2016semantic], the authors proposed a multi-scale semantic segmentation by combining ConvNets, hand-crafted descriptors, and Conditional Random Fields [@lafferty2001conditional]. Specifically, they trained three ConvNets, each with a different patch size ($16\times16$, $32\times32$ and $64\times64$ pixels). Features extracted from these networks are combined with hand-crafted ones and classified using random forest classifier. Finally, Conditional Random Fields [@lafferty2001conditional] are used as a post-processing method in an attempt to improve the final results.

In [@marmanis2016classification], the authors proposed a multi-scale method that combines boundary detection with deconvolution networks (specifically, based on SegNet [@badrinarayanan2015segnet]). The main contribution of this work is the Class-Boundary (CB) network, which is responsible to help the proposed methods to give more attention to the boundaries. Based on this CB network, they proposed several methods. The first uses three networks that receive as input the same image but with different resolutions (as well as the output of the corresponding CB network) and output the label predictions, which are aggregated, in a subsequent fusion stage, generating the final label. They also experimented fully convolutional architectures [@long2015fully] (with several skip layers in order to aggregate multi-scale information) and an ensemble of several architectures. All aforementioned networks initially receive $256\times256$ fixed size patches. Maggiori et al. [@maggiori2016high] proposed a multi-scale method that performs labeling segmentation based on upsampled and concatenated features extracted from distinct layers of a fully convolutional network [@long2015fully]. Specifically, the network, that receives as input patches of $256\times256$ or $512\times512$ pixels (depending on the dataset), is composed of several convolutional and pooling layers, which downsample the input image. Downsampled feature maps extracted from several layers are, then, upsampled, concatenated and finally classified by another convolutional layer. This proposed strategy resembles somehow the DenseNets [@huang2016densely], with the final layer having connections to previous layers. Wang et al. [@wang2017gated] proposed to extract features from distinct layers of the network to capture multi-scale low- and high-level information. They fine-tuned a ResNet-101 [@he2016deep] to extract salient information from $600\times600$ patches. Feature maps are then extracted from intermediate layers, combined with entropy maps, and upsampled to generate the final dense prediction. In this work, we perform semantic segmentation by exploiting a multi-scale network composed uniquely of dilated convolutions. The main differences that may pointed out with respect to the aforementioned works: (i) the proposed technique exploits a fully convolutional network that does not downsample the input data (a common process performed in most works [@long2015fully; @YuKoltun2016; @marmanis2016classification]), (ii) the multi-scale strategy is exploited during the training process without any modification of the network or combination of several architectures, and (iii) instead of evaluating possible patch sizes (to find the best one) or to use a patch size determined by network constraints (which could not be the best one), the proposed algorithm determines the best patch size adaptively in training time.

Dilated ConvNets {#sec:background}
================

Dilated convolutions were originally proposed for the computation of wavelet transform [@holschneider1990real] and employed in the deep learning context (as an alternative to deconvolution layers) mainly for semantic segmentation [@YuKoltun2016; @chen2016deeplab; @sherrah2016fully]. In dilated convolutional layers, filter weights are employed differently when compared to standard convolutions. Specifically, filters of this layer may have gaps (or “holes”) between their parameters. These gaps, inserted according to the dilation rate $r$, enlarge the convolutional kernel but preserve the number of trainable parameters since the inserted holes are not considered in the convolution process. Therefore, the final alignment of the kernel weights are defined by this dilation rate $r$. Formally, for each location $i$, the output $y$ of an one-dimension dilated convolution given as input a signal $x$ and filter $w$ of length $K$ is calculated as:

$$\begin{aligned}
 \label{eq:dilated_conv}
    y[i] = \sum_{k=1}^{K} x[i + rk] w[k]
    \end{aligned}$$

The dilation rate parameter $r \in \mathbb{N}$ corresponds to the stride with which the input signal is sampled. As illustrated by Figure \[fig:dilated\_example\], smaller rates result in a more clustered filter (in fact, rate 1 generates a kernel identical to the standard convolution) while larger rates make an expansion of the filter, producing a larger kernel with several gaps. Since this whole process is independent of the input data, changing the dilation rate does not impact in the resolution of the layer outcome, i.e., in a dilated convolution, independent of the rate, input and output have the same resolution (considering appropriate stride and padding).

By enlarging the filter (with such gaps), the network expands its receptive field (since the weights will be arranged in a more sparse shape) but preserves the resolution and no downsampling in the data is performed. Hence, this process has several advantages, such as: (i) supports the expansion of the receptive field without increasing the number of trainable parameters per layer [@YuKoltun2016], which reduces the computational burden, and (ii) preserves the feature map resolution, which may help the network to extract even more useful information from the data, mainly of small objects.

To better understand the aforementioned advantage, a comparison between dilated and standard convolution is presented in Figure \[fig:comparison\_dilated\]. Given an image, the first network (in red) performs a downsampling operation (that reduces the resolution by a factor of 2) and a convolution, using horizontal Gaussian derivative as kernel. The obtained low-resolution feature map is then enlarged by an upsampling operation with a factor of 2 that restores the original resolution but not the information lost during the downsampling process. The second network (blue) computes the response of a dilated convolution on the original image. In this case, the same kernel was used but rearranged with dilation rate $r = 2$. Although the filter size increases, only non-zero values are taken into account when performing the convolution. Therefore, the number of filter parameters and of operations per position stay constant. Furthermore, it is possible to observe that salient features are better represented by the dilated model since no downsampling is performed over the input data.

![Comparison between dilated and standard convolutions. Top (red) row presents the feature extraction process using a standard convolution over a downsampled image and then an upsample in order to recover the input resolution. Bottom (blue) row presents the feature extraction process using dilated convolution with rate $r = 2$ applied directly to the input (without downsample). The outcomes clearly show the benefits of dilated convolutions over standard ones. []{data-label="fig:comparison_dilated"}](dilated_vs_standard_png.png){width="48.00000%"}

Dynamic Multi-Scale Dilated Convolution {#sec:methodology}
=======================================

In this section, we present the proposed method for dynamic multi-scale semantic segmentation of remote sensing images. The proposed methodology is presented in Section \[subsec:proposed\] while the network architectures are described in Section \[subsec:arch\].

Dynamic Multi-Scale Algorithm {#subsec:proposed}
-----------------------------

As introduced, we propose a novel method to perform semantic segmentation of remote sensing images that (i) exploits the multi-scale paradigm without increasing the number of trainable parameters of the network, and (ii) defines, in training time, the best patch size that should be exploited by the network in the test phase.

The multi-scale paradigm is aggregated into the model by allowing the ConvNet to explore, in the training step, patches of multiple sizes at every new batch processed by the network. Specifically, in the training phase, the processing of **each batch** may be divided into five main steps, as presented in Figure \[fig:overview\]: (i) a new patch size $\lambda_k$ is randomly selected from a distribution $\mathcal{S}$ (which may be any valid distribution, such as uniform or multinomial), (ii) a new batch is created based on patches of the currently selected size, i..e, patches of $\lambda_k \times \lambda_k$ pixels, (iii) the ConvNet processes this batch normally, using it to learn the parameters through the backpropagation algorithm, (iv) for the current batch, the network outputs the prediction maps, which are used to calculate some statistics (such as loss and accuracy), that represent how well the current batch has performed, and (v) these statistics are used to update the score of the current selected size $\lambda_k$, according to:

\
All these steps are repeated during the training process until convergence or number of iterations is reached. Therefore, during the training, a new size is used to create patches that compose the batch processed by the network. These patches of multiple sizes aggregate and contribute with multi-scale information allowing the network to capture and extract features by considering distinct context regions.

The second benefit of the proposed method is almost a direct application of the patch scores created in the training phase. Specifically, in the prediction phase, scores over the patch sizes (created during the training phase, step v) are averaged and analyzed. The best patch size $\lambda_{best}$ (which corresponds to the highest or lowest score, for accuracy and loss, respectively) is then selected and used to create patches for the input images. The network still outputs the prediction maps but no updates in the patch scores are performed.

![image](overview_train_v3.pdf){width="\textwidth"}

Architectures {#subsec:arch}
-------------

Motivated by the fact that dilated convolutions [@YuKoltun2016] can process input images of any size, they fit perfectly in the proposed multi-scale methodology, given that a network composed of such layers is capable of processing the input without downsampling it. This creates the possibility of processing patches of any size without constraints. Although these layers have the advantage of computing feature responses at the original image resolution, a network composed uniquely of dilated convolutions would be costly to train especially when processing entire (large) scenes. However, as previously mentioned, processing an entire remote sensing image is not possible (because of its huge size) and, therefore splitting the image into small patches is already necessary, which naturally alleviates the training process.

Though, in this work, we explore networks composed of dilated convolutions, other types of ConvNets could be used, such as fully convolutions [@long2015fully] and deconvolutions [@noh2015learning; @badrinarayanan2015segnet]. These networks can also process patches of varying size, but they have restrictions related to a high variation of patch sizes. Specifically, these networks need to receive a patch larger enough to allow the generation of a coarse map, that is upsampled to the original size. If the patch is too small, the network could fall in a situation where it is not possible to create the coarse map and, consequently, the final upsampled map. Such problem is overcome by dilated ConvNets [@YuKoltun2016], which are allowed to process patches of any size in the same way, without distinction, outputting results always with the same resolution of the input data (given proper configurations, such as stride and padding). Such concept is essential to allow the variance of patch sizes, from very small values (such as $7\times7$) to larger ones (for instance, $256\times256$).

Considering this, four architectures, illustrated in Figure \[fig:cnn\_arch\], have been developed and evaluated in this work. The first network, presented in Figure \[dilated1\], is composed of seven layers: six dilated convolutions (that are responsible to capture the patterns of the input images) and a final $1\times1$ convolution layer, which is responsible to generate the dense predictions. There is no pooling or normalization in this network, and all layers have stride 1. Specifically, the first two convolutions have $5\times5$ filters with dilation rate $r$ 1 and 2, respectively. The following two convolutions have $4\times4$ filters but rate 3 and 4 while the last two convolutions have smaller filters ($3\times3$) but 5 and 6 as dilation rate. Because this network has 6 layers responsible for the feature extraction, it will be referenced as **Dilated6**. The second network (Figure \[dilated2\]) is based on densely connected networks [@huang2016densely], which recently achieved outstanding results on the image classification task. This network is very similar to the first one having the same number of layers. The main difference between these networks is that a layer has as input feature maps of all preceding layers. Hence, the last layer has access to all feature maps generated by all other layers of the network. This process allows the network to combine different feature maps with distinct level of abstraction, supporting the capture and learning of a wide range of feature combination. Because this network has 6 layers responsible for the feature extraction and is densely connected, it will be referenced in this work as **DenseDilated6**. The third network, presented in Figure \[dilated3\], has the same configuration of the Dilated6, but with pooling layers between each convolutional one. Given a specific combination of stride and padding, no downsampling is performed over the inputs in these pooling layers. Because of the number of layers and the pooling layers, this network will be referenced hereafter as **Dilated6Pooling**. The last network (Figure \[dilated4\]) is an extension of the previous one, having 8 dilated convolutions instead of only 6. The last two layers have smaller filters ($3\times3$) but 7 and 8 as dilation rate. There are pooling layers between all convolutional ones. Given that this network has 8 dilated convolutional and pooling layers, it will be referenced hereafter as **Dilated8Pooling**.

Experimental Setup {#sec:experiments}
==================

In this section, we present the experimental setup. Specifically, Section \[subsec:datasets\] presents datasets employed in this work. Baselines are described in Section \[subsec:baselines\] while the experimental protocol is introduced in Section \[subsec:protocol\].

Datasets {#subsec:datasets}
--------

To better evaluate the effectiveness of the proposed method, we carried out experiments on four high-resolution remote sensing datasets with very distinct properties. The first one is an agricultural dataset composed of multispectral high-resolution scenes of coffee crops and non-coffee areas. The others are urban datasets which have the objective of mapping targets such as roads, buildings, and cars. The first one is the GRSS Data Fusion contest dataset (consisting of very high-resolution images), while the others are the Vaihingen and Potsdam datasets, provided in the framework of the 2D semantic labeling contest organized by the ISPRS Commission III[^4] and composed of multispectral high-resolution images.

### Coffee Dataset {#subsubsec:coffee_dataset}

This dataset [@keiller2016icpr] is composed of 5 images taken by the SPOT sensor in 2005 over a famous coffee grower county (Monte Santo) in the State of Minas Gerais, Brazil. Each image has $500\times500$ pixels with green, red, and near-infrared bands (in this order), which are the most useful and representative ones for discriminating vegetation areas [@santos2012multiscale]. More specifically, the dataset consists of 1,250,000 pixels classified into two classes: coffee (637,544 pixels or 51%) and non-coffee (612,456 pixels or 49%). Figure \[fig:coffee\_results\] presents the images and ground-truths of this dataset.

This dataset is very challenging for several different reasons, including: (i) high intraclass variance, caused by different crop management techniques, (ii) scenes with different plant ages, since coffee is an evergreen culture and, (iii) images with spectral distortions caused by shadows, since the South of Minas Gerais is a mountainous region.

### GRSS Data Fusion Dataset {#subsubsec:grss_dataset}

Proposed for the 2014 IEEE GRSS Data Fusion Contest, this dataset [@liao2015processing] is composed of two (training and testing) fine-resolution visible (RGB) images that cover an urban area near Thetford Mines in Quebec, Canada. Both training and testing images have $0.2$ meter of spatial resolution, with the former having $2830\times3989$ pixels of resolution while the latter has $3769\times4386$ pixels. Training and testing images, as well as the respective ground-truths, are presented in Figure \[fig:grss\_results\].

Pixels are categorized into seven classes: trees, vegetation, road, bare soil, red roof, gray roof, and concrete roof. The dataset is not balanced, as can be seen in Table \[tab:grss\_stat\]. It is important to highlight that not all pixels are classified into one of these categories, with some pixels considered as uncategorized or unclassified.

  ****                                               
  ------------------- --------- -------- ----------- --------
  **Classes**                                        
  **Road**              112,457    19.83     808,490    55.77
  **Trees**              27,700     4.89     100,528     6.93
  **Red roof**           45,739     8.05     136,323     9.40
  **Grey roof**          53,520     9.44     142,710     9.84
  **Concrete roof**      97,821    17.25     109,423     7.55
  **Vegetation**        185,242    32.65     102,948     7.10
  **Bare soil**          44,738     7.89      49,212     3.41
  **Total**             567,217   100.00   1,449,634   100.00

  : Number of pixels per class for the GRSS Data Fusion dataset.[]{data-label="tab:grss_stat"}

### Vaihingen Dataset {#subsec:vaihingen}

As introduced, this dataset [@vaihingen] was released for the 2D semantic labeling contest of the International Society for Photogrammetry and Remote Sensing (ISPRS). It is composed by a total of 33 image tiles (with an average size of $2494\times2064$ pixels), that are densely classified into six possible labels: impervious surfaces, building, low vegetation, tree, car, clutter/background. The pixel distribution for the labeled images can be seen in Table \[tab:isprs\_stat\].

Sixteen of these images are fully annotated while the remaining ones compose the test set (which are the ones evaluated by the contest). Each of these images is composed of near infrared, red and green channels (in this order) with a spatial resolution of $0.9$ meter. A Digital Surface Model (DSM) coregistered to the image data was also provided, allowing the creation of a normalized DSM (nDSM) by [@gerke2015use]. In this work, we use the spectral information (NIR-R-G) and the nDSM. Specifically, the input data for the method consists of 4 dimensions: NIR-R-G and nDSM. Examples of the Vaihingen Dataset can be seen in Figure \[fig:vaihingein\_validation\_results\].

  ****                                                          
  ------------------------- ------------ -------- ------------- --------
  **Classes**                                                   
  **Impervious Surfaces**     21,815,349    27.94   245,930,445    28.46
  **Building**                20,417,332    26.15   230,875,852    26.72
  **Low Vegetation**          16,272,917    20.84   203,358,663    23.54
  **Tree**                    18,110,438    23.19   126,352,970    14.62
  **Car**                        945,687     1.21    14,597,667     1.69
  **Clutter/Background**         526,083     0.67    42,884,403     4.96
  **Total**                   78,087,806   100.00   864,000,000   100.00

  : Number of pixels per class for ISPRS dataset, i.e., Vaihingen and Potsdam.[]{data-label="tab:isprs_stat"}

### Potsdam Dataset {#subsec:potsdam}

Also proposed for the 2D semantic labeling contest, this dataset [@potsdam] has 38 tiles of same size ($6000\times6000$ pixels), with a spatial resolution of $0.5$ meter. From the available patches, 24 are densely annotated (with same classes as for the Vaihingen dataset), in which pixel distribution is presented in Table \[tab:isprs\_stat\]. This dataset consists of 4-channel images (near infrared, red, green and blue), Digital Surface Model (DSM) and normalized DSM (nDSM). In this work, all spectral channels plus the nDSM are used as input for the ConvNet, resulting in a 5-dimensional input data. Some samples of these images are presented in Figure \[fig:postdam\_validation\_results\].

Baselines {#subsec:baselines}
---------

For the coffee dataset, we employed the Cascaded Convolutional Neural Network (CCNN) [@nogueira2015coffee] as baseline. This method employs a multi-scale strategy by aggregating several ConvNets in order to perform classification of fixed size tiles towards a final segmentation of the image. For the GRSS Data Fusion Dataset, we employed, as baseline, the work of Santana et al. [@santanadeep]. Their algorithm extracts features with many levels of context from superpixels by exploiting different layers of a pre-trained convolutional network, which are then combined in order to aggregate multi-scale information.

Aside this, for both aforementioned datasets, we also consider as baseline the method conceived by [@keiller2016icpr], in which specific networks are used to perform labeling segmentation using the pixelwise paradigm, i.e., each pixel is classified independently by the classifier. Also, for these two datasets, we considered as baselines: (i) Fully Convolutional networks (FCN) [@long2015fully]. In this case, the pixelwise architectures proposed by [@keiller2016icpr] were converted into fully convolutional network and exploited as baseline. (ii) Deconvolutional networks [@badrinarayanan2015segnet; @noh2015learning]. Again, the pixelwise architectures proposed by [@keiller2016icpr] were converted deconvolutional network (based on the well-known SegNet [@badrinarayanan2015segnet] architecture) and exploited as baseline in this work. (iii) dilated network [@YuKoltun2016], which is, in this case, the Dilated6 (Figure \[dilated3\]). All these networks were trained traditionally using patches of constant size defined according to set of experiments of [@keiller2016icpr], i.e., patches of $7\times7$ and $25\times25$ for Coffee and GRSS Data Fusion datasets, respectively.

For the remaining datasets (Vaihingen and Potsdam), we refer to the official results published on the challenge website[^5] as baselines for our proposed work.

Experimental Protocol {#subsec:protocol}
---------------------

For the Coffee [@keiller2016icpr] and the GRSS Data Fusion [@liao2015processing] datasets, we employed the same protocol of [@keiller2016icpr]. Specifically, for the former dataset, we conducted a five-fold cross-validation to assess the performance of the proposed algorithm. In this strategy, five runs are executed, where, at each run, three coffee scenes are used as training while, one is used as validation and the remaining one is used as test. The results reported are the average metric of the five runs followed by its corresponding standard deviation. For the GRSS Data Fusion dataset, an image was used for training while the other was used for test, since this dataset has a clear definition of training/testing.

For Vaihingen [@vaihingen] and Potsdam [@potsdam] datasets, we followed the protocol proposed by [@volpi2017dense]. For the Vaihingen dataset, 11 out of the 16 annotated images were used to train the network. The 5 remaining images (with IDs 11, 15, 28, 30, 34) were employed to validate and evaluate the segmentation generalization accuracy. For the Potsdam dataset, 18 (out of 24) images were used for training the proposed technique. The remaining 6 images (with IDs 02\_12, 03\_12, 04\_12, 05\_12, 06\_12, 07\_12) were employed for validation of the method.

Some metrics were evaluated [@congalton2008assessing] for the datasets: overall and average accuracy, kappa index and F1 score. Overall accuracy is a metric that considers the global aspects of the classification, i.e., it takes into account all correctly classified pixels indistinctly. On the other hand, average accuracy reports the average (per-class) ratio of correctly classified samples, i.e., it outputs an average of the accuracy of each class. Kappa index measures the agreement between the reference and the prediction map. Finally, F1 score is defined as the harmonic mean of precision and recall. These metrics were selected based on their diversity: overall accuracy and kappa are biased toward large classes (relevance of classes with small amount of samples are canceled out by those of with large amount) while average accuracy and F1 are calculated specifically for each class and, therefore, are independent of class size. Hence, the presented results are always some combination of such metrics in order to provide enough information about the effectiveness of the proposed method. The proposed method and network were implemented using TensorFlow [@tensorflow2015], a framework conceived to allow an efficient exploitation of deep learning with Graphics Processing Units (GPUs). All experiments were performed on a 64 bits Intel i7 4960X machine with 3.6GHz of clock and 64GB of RAM memory. Four GeForce GTX Titan X with 12GB of memory, under a 8.0 CUDA version, were employed in this work. Note, however, that each GPU was used independently and that all networks proposed here can be trained using only one GPU. Ubuntu version 16.04.3 LTS was used as operating system[^6].

The ConvNet and its parameters were adjusted by considering a full set of experiments guided by [@bengio2012practical]. After all the setup experiments, the best values for hyperparameters, presented in Table \[tab:parameters\], were determined for each dataset. The number of iterations increases with the complexity of the dataset in order to ensure convergence. In the proposed models, the learning rate, responsible to determine how much an updating step influences the current value of the network weights, starts with a high value and is reduced during the training phase using the exponential decay [@tensorflow2015] with parameters defined according the last column of Table \[tab:parameters\].

Results and Discussion {#sec:results}
======================

In this section, we present and discuss the obtained results. Specifically, we first analyze the parameters of the proposed technique: Section \[subsec:distri\] presents the results achieved using different patch distributions, Section \[subsec:score\] analyzes distinct functions to update the patch size score, and Section \[subsec:range\] evaluates distinct range for the patch size. After, a convergence analysis of the proposed technique is performed in Section \[subsec:convergence\]. Then, a comparison between networks trained with the proposed and standard techniques is presented in Section \[subsec:dilated\_comparison\]. Finally, comparison with state-of-the-art is reported in Section \[subsec:state\].

Patch Distribution Analysis {#subsec:distri}
---------------------------

As explained in the beginning of Section \[subsec:proposed\], the algorithm receives as input a list of possible patch sizes and a correspondent distribution. In fact, any distribution could be used, including uniform or multinomial. Given the influence of this distribution over the proposed algorithm, experiments have been conducted to determine the most appropriate distribution in our case. Towards this, we selected and compared three distinct distributions. First is the **uniform** distribution over a range of values, i.e., given two extreme points, all intermediate values inside this range should have the same probability of being selected. Second is the uniform distribution but over selected values (and not a range). In this case, referenced as **uniform fixed**, the probability distribution is equally divided into the given values (the intermediate points have no probability of being selected). The last distribution evaluated is the **multinomial**. In this case, ordinary values inside a range have the same probability but several given points have twice the chance to be selected.

The main difference between the evaluated distributions is related to the prior knowledge of the application. In the uniform distribution, no prior knowledge is assumed, and all patch sizes from the input range have the same probability, taking more time to converge the model. The uniform fixed distribution assumes a good knowledge of the application and only pre-defined patch sizes can be (equally) selected and evaluated, taking less time to converge the model. The multinomial distribution tries to blend previous ideas. Assuming certain prior knowledge of the application, the multinomial distribution weights the probabilities allowing the network to give more attention to specific pre-defined patch sizes but without discarding the others. If prior intuition is confirmed, these pre-defined patch sizes are randomly selected more often and the network should converge faster. Otherwise, the proposed process is still able to use other (non pre-defined) patch sizes and converge the network anyway. Results of this analysis can be seen in Table \[tab:distribution\_analysis\]. Note that all experiments were performed using the Coffee dataset [@keiller2016icpr], Dilated6 network (Figure \[dilated1\]), accuracy as score function, and hyperparameters presented in Table \[tab:parameters\]. In these experiments, patches size varied from $25\times25$ to $50\times50$. Specifically, for the uniform distribution, any value between 25 and 50 have the same probability of being selected, while for the multinomial distribution, all values have some chance to be selected, but these two points have twice the probability. For the uniform fixed, these two patch sizes split the total probability and each one has 50% of being selected. Overall, the variation of the distribution has no serious impact on the final outcome, since results are statistically equal. However, given its simplicity and faster convergence, for the remaining of this work, results will be reported using the **uniform fixed** distribution.

Score Function Analysis {#subsec:score}
-----------------------

As presented in Figure \[fig:overview\], the last step is responsible to update the score of patches that can be selected in the testing stage. In this work, we evaluated two possible score functions that could be employed in this step: the loss and the accuracy. In the first case, the loss is a measure (obtained using cross entropy [@deeplearningbook] in this case) that represents the error generated in terms of the ground-truth and the network predictions. In the second case, the score is represented by the classification accuracy [@congalton2008assessing] of the images.

To analyze the most appropriate score function, experiments were performed varying only this particular parameter and maintaining the remaining ones. Specifically, these experiments were conducted using: the Coffee dataset [@keiller2016icpr], Dilated6 network (Figure \[dilated1\]), uniform fixed distribution (over $25\times25$ and $50\times50$), and same hyperparameters presented in Table \[tab:parameters\]. Results can be seen in Table \[tab:score\_analysis\]. Through the table, it is possible to see that both score functions achieved similar results being statistically equal. However, since **accuracy score** is more intuitive, for the remaining of this work, results will be reported using this function.

Range Analysis {#subsec:range}
--------------

Although the presented approach is proposed to select automatically the best patch size, in training time, avoiding lots of experiments to adjust such size (as done in several works [@keiller2016icpr; @paisitkriangkrai2016semantic; @volpi2017dense]), in this section, the patch size range is analyzed in order to determine the robustness of the method.

This range is evaluated on all datasets, except Potsdam. Such dataset is very similar to Vaihingen one, therefore, analysis and decisions made over the latter dataset are also applicable to the Potsdam one. Furthermore, in order to evaluate such dataset, a validation set, created according to [@volpi2017dense], was used. Experiments were conducted varying only the patch size range but maintaining the remaining configurations. Particularly, the experiments employed the same hyperparameters (presented in Table \[tab:parameters\]), Dilated6 network (Figure \[dilated1\]), and uniform fixed.

Table \[tab:range\] presents the obtained results. Each dataset was evaluated in several ranges, selected based on previous works [@keiller2016icpr; @volpi2017dense]. Specifically, each dataset was evaluated in a large range (comprising from small to large sizes) and subsets of such range. Table \[tab:range\] also presents the most selected patch size (for the testing phase) for each experiment, giving some insights about how the proposed method behaves during such step. For the Coffee dataset [@keiller2016icpr], obtained results are very similar, being considered statistically equal. Hence, any patch size range could be selected for further experiments, showing the robustness of the proposed algorithm which yielded similar results independently of the patch size range. Because of processing time, in this case, patch size range $25,50$ was selected and used in all further experiments.

For remaining datasets, a specific range achieved the best result. For the GRSS Data Fusion dataset [@liao2015processing], the best result was obtained when considering the largest range ($7,14,21,28,35,42,49,56,63,70$), i.e., the range varying from small to large patch sizes. For Vaihingen [@vaihingen], the intermediate range ($45,55,65,75,85$) achieved the best result. Therefore, in these cases, such ranges were selected and used in remaining experiments of this work. However, as can be seen through Table \[tab:range\], other ranges also produce competitive result and could be used without high loss of performance, which confirms the robustness of the proposed method to patch size range, allowing it to process images without the need of experimentally searching for the best patch size configuration.

In terms of patch size selection, the algorithm really varies depending on the experiment. For the Coffee dataset, the most selected patch sizes were 50 and 75, showing a trend towards such interval. For the remaining datasets, larger patches were favored in our experiments. This may be justified by the fact that urban areas have complex interactions and larger patches allow the network to capture more information about the context. Though the best patch size is really dependent on the experiment, current results showed that the proposed approach is able to learn and select the best patch size in processing time producing interesting outcomes when compared to state-of-the-art works, a fact reconfirmed in Section \[subsec:state\].

Convergence Analysis {#subsec:convergence}
--------------------

In this section, we analyze the convergence of the proposed technique. Figure \[fig:convergence\] presents the convergence of the datasets using the Dilated6 network, accuracy as score function, uniform fixed, and hyperparameters presented in Table \[tab:parameters\]. According to the figure, the loss and accuracy vary significantly at the beginning of the process but, with the reduction of the learning rate, the networks converge independently of the use of distinct patch sizes. Moreover, the test/validation accuracy (green line) converges and stabilizes showing that the networks can learn to extract features from patches of multiple sizes while selecting the best patch size for testing.

Performance Analysis {#subsec:dilated_comparison}
--------------------

To analyze the efficiency of the proposed algorithm, several experiments were conducted comparing the same network trained using two distinct methods: (i) the **traditional** training process [@deeplearningbook], in which the network is trained using patches of constant size, without any variation. This method is the standard one when it comes to neural networks and is the most exploited in the literature for training deep learning-based techniques. Also, this is the approach used to empirically selects the best patch size, which is traditionally done by training several network, one for each considered patch. (ii) the proposed **dynamic** training process, in which the network is trained with patches of varying size.

Two datasets were selected to be evaluated using these training strategies: (i) the GRSS Data Fusion dataset, which has the largest patch size range (according to Section VI-C of the paper) allowing a better comparison between the training strategies, and (ii) Vaihingen dataset, which is very similar to Potsdam one and, therefore, allows the conclusions to be applied to this one.

Specifically, in these experiments, Dilated6 network (Figure \[dilated1\]) is trained using both strategies. For the proposed dynamic training process, previous experiments were taken into account, i.e., this process uses uniform fixed, patch ranging according to Section \[subsec:range\], accuracy as score function, and hyperparameters presented in Table \[tab:parameters\]. After training the network using varying patch sizes, each possible patch size is processed independently by the inference phase, resulting in several outcomes, one for each possible patch size. Concerning the traditional training process, the same network was trained using each of the possible patch sizes.

Results can be seen in Figure \[fig:results\_comp\_multiscale\]. Outcomes concerning Vaihingen dataset are related to the validation set, created according [@volpi2017dense]. As can be seen through the results, networks trained with the proposed approach outperform the models trained with the traditional training process. This shows the ability of the proposed method to capture multi-scale information from distinct context patches which improve the performance of the final model, independently of the patch size used during the inference stage.

State-of-the-art Comparison {#subsec:state}
---------------------------

### Coffee dataset {#subsec:coffee_state_results}

Using analysis performed on previous sections, we have conducted several experiments over the Coffee dataset [@keiller2016icpr]. Results of these experiments, as well as state-of-the-art baselines, are presented in Table \[tab:coffe\_results\]. In order to allow a visual comparison, prediction maps for the Coffee dataset using different networks trained with the proposed method are presented in Figure \[fig:coffee\_results\]. Overall, all baselines produced similar results. While the pixelwise network [@keiller2016icpr] yielded a slightly worse result with higher standard deviation, all other baselines reached basically the same level of performance, with a smaller standard deviation. This may be justified by the fact that the pixelwise network does not learn much information about the pixel interaction (since each pixel is processed independently), while the other methods process and classify a set of pixels simultaneously. Because of these similar results, all baselines are statistically equivalent.

This same behavior may be seen among the networks trained with the proposed methodology. Although these networks achieved comparable results, such models outperformed the baselines. Furthermore, the Dilated6 trained with the proposed dynamic method produced better results than the same network trained with traditional training process (mainly in the Kappa Index). These results show the effectiveness of the proposed technique that produces state-of-the-art outcomes by capturing multi-scale information while selecting the best patch size, two great advantages when compared to the traditional training process.

[&gt;m[2.5cm]{} &gt;m[2.5cm]{} &gt;m[2.5cm]{} &gt;m[2.5cm]{} &gt;m[2.5cm]{} &gt;m[2.5cm]{} @m[0pt]{}@ ]{} **Original Image** & **Ground-Truth** & **Dilated6** & **DenseDilated6** & **Dilated6Pooling** & **Dilated8Pooling** &\
& & & & & &\
& & & & & &\

\[fig:coffee\_results\]

### GRSS Data Fusion Dataset {#subsec:grsss_state_results}

We also performed several experiments on the GRSS Data Fusion Contest dataset [@liao2015processing] considering all analysis carried out in previous sections. Experimental results, as well as baselines, are presented in Table \[tab:grss\_results\]. The prediction maps obtained for the test set are presented in Figure \[fig:grss\_results\].

Overall, Dilated6 produced the best result among all approaches. In general, networks trained with the proposed method outperformed the baselines. Moreover, the Dilated6 trained with the proposed dynamic technique outperformed the baseline composed of the same network trained using traditional training process, corroborating with previous conclusions.

Among the baseline methods, although all achieved comparable results, the best outcome was yielded by the Deep Contextual [@santanadeep]. This method also leverages from multi-scale information, since it combines features extracted from distinct layers of pre-trained ConvNets. When comparing this method with the best result of the proposed technique (Dilated6), one may see the gap between the models, since the proposed method improves the results for all metrics when compared to the Deep Contextual [@santanadeep] approach. This reaffirms the effectiveness of the proposed dynamic method, corroborating with previous conclusions.

### Vaihingen Dataset {#subsec:vaihingen_state_results}

As introduced in Section \[subsec:baselines\], official results for the Vaihingen dataset are reported only by the challenge organization that held some images that are used for testing the submitted algorithms. Therefore, one must submit the proposed algorithm to have it evaluated. In our case, following previous analysis, we submitted five approaches: the first four are related to each network presented in Section \[sec:methodology\] trained with the 6 classes (which are represented in the official results as UFMG\_1 to 4), and the fifth one, represented in the official results as UFMG\_5, is the Dilated8 network (Figure \[dilated4\]) trained with only 5 classes, i.e., all labels except the clutter/background one. This last submission is due to the lack of training data for that class which corresponds to only 0.67% of the dataset (as stated in Table \[tab:isprs\_stat\]). It is important to note that all submissions related to the proposed work do not use any post-processing, such as Conditional Random Fields (CRF) [@lafferty2001conditional]. Some official results reported by the organization are summarized in Table \[tab:vaihingen\_results\]. In addition to our results, this table also compiles the **best results of each work** with enough information to make a fair comparison, i.e., in which the proposed approach is minimally explained.

It is possible to notice that the proposed work yielded competitive results. The best result, in terms of overall accuracy, was $90.3\%$ achieved by DLR\_9 [@marmanis2016classification] and GSN3 [@wang2017gated]. Our best result (UFMG\_4) appears in fifth place by yielding $89.4\%$ of overall accuracy, outperforming several methods, such as ADL\_3 [@paisitkriangkrai2015effective] and RIT\_L8 [@liu2017dense], that also tried to aggregate multi-scale information. However, as can be seen in Table \[tab:vaihingen\_results\] and Figure \[vaihingen\], while the others have a larger number of trainable parameters, our approach has only 2 millions, which makes it less pruned to overfitting and, consequently, easier to train, showing that the proposed method really helps in extracting all feasible information of the data using limited architectures (in terms of parameters). In fact, the number of parameters of the network is so relevant that authors of DLR\_9 submission [@marmanis2016classification], one of the best results but with higher number of parameters, do not recommend their proposed method for practical usage because of the memory consumption and expensive training phase. Furthermore, the obtained results, that do not have any post-processing, are better than others, such as DST\_2 [@sherrah2016fully], that employ CRF as post-processing method, which shows the potential of dilated convolutions in aggregate refined information.

Aside this, the proposed work (UFMG\_5) achieved the best result ($82.5\%$ of F1 Score) in the car class, which is one of the most difficult classes of this dataset when compared to others (such as building) because of its composition (small objects) and its high intraclass variance (caused by a great variety of models and colors). This may be justified by the fact that the proposed network does not downsample the input image preserving important details for such classes composed of small objects. However, this submission ignores the clutter/background class, which could be considered as an advantage making the comparison unfair. But, there are other works doing the same training protocol (i.e., ignoring the clutter/background class), such as INR [@maggiori2016high]. Yet such works have not achieved good accuracy as the proposed work. Furthermore, still considering the car class, the second best result ($81.3\%$ of F1 Score) is also yielded by our proposed work (UFMG\_4), which employs all classes during the training phase, which shows the effectiveness and robustness of our work mainly for classes related to small objects.

[&gt; m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt; m[1.95cm]{} @m[0pt]{}@ ]{} **Image** & **nDSM** & **Ground-Truth** & **Dilated6** & **DenseDilated6** & **Dilated6 Pooling** & **Dilated8 Pooling** & **Dilated8 Pooling** &\
& & & & & & & &\

\[fig:vaihingein\_validation\_results\]

[&gt; m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} @m[0pt]{}@ ]{} **Image** & **nDSM** & **Dilated6** & **DenseDilated6** & **Dilated6 Pooling** & **Dilated8 Pooling** & **Dilated8 Pooling** &\
& & & & & & &\

\[fig:vaihingein\_test\_results\]

### Potsdam Dataset {#subsec:potsdam_state_results}

As for the Vaihingen dataset, official results for the Potsdam dataset are reported only by the challenge organization. For this dataset, we have four submissions, one for each network presented in Section \[sec:methodology\] trained with the 6 classes (which are represented in the official results as UFMG\_1 to 4). In this dataset, there is no need to disregard the clutter/background class, since it has a sufficient amount of samples (4.96%). As before, all submissions related to the proposed work does not use any post-processing. Table \[tab:potsdam\_results\] summarizes some results reported by the organizers. Again, in addition to our results, the table also compiles the **best results of each work** with enough information to make a fair comparison.

The proposed work achieved competitive results, appearing in third place according to the overall accuracy. DST\_5 [@sherrah2016fully] and RIT\_L7 [@liu2017dense] are the best result in terms of overall accuracy. However, they have a larger number of trainable parameters when compared to our proposed networks, as can be seen in Figure \[potsdam\]. This outcome corroborates with previous results , reaffirming obtained conclusions.

[&gt; m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt; m[1.95cm]{} @m[0pt]{}@ ]{} **Image** & **nDSM** & **Ground-Truth** & **Dilated6** & **DenseDilated6** & **Dilated6 Pooling** & **Dilated8 Pooling** & **Dilated8 Pooling** &\
& & & & & & & &\

\[fig:postdam\_validation\_results\]

[&gt; m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} &gt;m[1.95cm]{} @m[0pt]{}@ ]{} **Image** & **nDSM** & **Dilated6** & **DenseDilated6** & **Dilated6 Pooling** & **Dilated8 Pooling** & **Dilated8 Pooling** &\
& & & & & & &\

\[fig:postdam\_test\_results\]

Conclusions {#sec:conclusions}
===========

In this paper, we propose a novel approach based on Convolutional Neural Networks to perform semantic segmentation of remote sensing scenes. The method exploits networks composed uniquely of dilated convolution layers that do not downsample the input. Based on these networks and their no downsampling property, the proposed approach: (i) employs, in the training phase, patches of different sizes, allowing the networks to capture multi-scale characteristics given the distinct context size, and (ii) updates a score for each of these patch sizes in order to select the best one during the testing phase.

We performed experiments on four high-resolution remote sensing datasets with very distinct properties: (i) Coffee dataset [@keiller2016icpr], composed multispectral high-resolution scenes of coffee crops and non-coffee areas, (ii) GRSS Data Fusion dataset [@liao2015processing], consisting of very high-resolution of visible spectrum images, (iii) Vaihingen dataset [@vaihingen], composed of multispectral high-resolution images and normalized Digital Surface Model, and (iv) Potsdam dataset [@potsdam], also composed of multispectral high-resolution images and normalized Digital Surface Model.

Experimental results have showed that our method is effective and robust. It achieved state-of-the-art results in two datasets (Coffee and GRSS Data Fusion datasets) outperforming several techniques (such as Fully Convolutional [@long2015fully] and deconvolutional networks [@badrinarayanan2015segnet]) that also exploit the multi-scale paradigm. This shows the potential of the proposed method in learning multi-scale information using patches of multiple sizes.

For the other datasets (Vaihingen and Potsdam), although the proposed technique did not achieve state-of-the-art, it yielded competitive results. In fact, our approach outperformed some relevant baselines that exploit post-processing techniques (although we did not employ any) and other multi-scale strategies. Among all methods, the proposed one has the least number of parameters and is, therefore, less pruned to overfitting and, consequently, easier to train. At the same time, it produces one of the highest accuracy, which shows the effectiveness of the proposed technique in extracting all feasible information from the data using limited architectures (in terms of parameters). Furthermore, the proposed technique achieved one of the best results for the car class, which is one of the most difficult classes of these datasets because of its composition (small objects). This demonstrates the benefits of processing the input image without downsampling it, a process that preserves important details for classes that are composed of small objects.

Aside this, the proposed networks can fine-tuned for any semantic segmentation application, since it does not depend of the patch size to process the data. This allows other applications to benefit from the patterns extracted by our models, a very important process mainly when working with small amounts of labeled data [@nogueira2017towards].

The presented conclusions open some opportunities towards a simplified use of deep learning methods for better understanding the Earth’s surface, which is still needed for remote sensing applications, such as agriculture or urban planning. In the future, we plan to better analyze the relation between the number of classes in the dataset and the number of parameters in the ConvNet.

Acknowledgments {#acknowledgments .unnumbered}
===============

This work was partially financed by CNPq (grant 312167/2015-6), CAPES (grant 88881.131682/2016-01), and Fapemig (APQ-00449-17). The authors gratefully acknowledge the support of NVIDIA Corporation with the donation of the GeForce GTX TITAN X GPU used for this research.

[^1]: K. Nogueira, W. R. Schwartz, and J. A. dos Santos are with the Department of Computer Science, Federal University of Minas Gerais, Brazil email: {keiller.nogueira, william, jefersson}@dcc.ufmg.br

[^2]: M. Dalla Mura, and J. Chanussot are with Univ. Grenoble Alpes, CNRS, Grenoble – Institute of Engineering Univ. Grenoble Alpes – INP, GIPSA-lab, 38000 Grenoble, France email: {keiller.nogueira, mauro.dalla-mura, jocelyn.chanussot}@gipsa-lab.grenoble-inp.fr

[^3]: Definition of multi-scale information is very broad and abstract, but in this work, multi-scale refers to spatial context difference, i.e., any method that aggregates image with distinct context are aggregating multi-scale information.

[^4]: <http://www2.isprs.org/commissions/comm3/wg4/semantic-labeling.html>

[^5]: <http://www2.isprs.org/vaihingen-2d-semantic-labeling-contest.html> and <http://www2.isprs.org/potsdam-2d-semantic-labeling.html>.

[^6]: As soon as the paper is accepted for publication, we will make all code and trained models publicly available.
