---
abstract: 'In the last decade, deep learning has contributed to advances in a wide range computer vision tasks including texture analysis. This paper explores a new approach for texture segmentation using deep convolutional neural networks, sharing important ideas with classic filter bank based texture segmentation methods. Several methods are developed to train Fully Convolutional Networks to segment textures in various applications. We show in particular that these networks can learn to recognize and segment a type of texture, e.g. wood and grass from texture recognition datasets (no training segmentation). We demonstrate that Fully Convolutional Networks can learn from repetitive patterns to segment a particular texture from a single image or even a part of an image. We take advantage of these findings to develop a method that is evaluated on a series of supervised and unsupervised experiments and improve the state of the art on the Prague texture segmentation datasets.'
author:
- 'Vincent Andrearczyk & Paul F. Whelan'
bibliography:
- 'refs.bib'
title: Texture segmentation with Fully Convolutional Networks
---

**Keywords:** Texture segmentation, Fully Convolutional Network, filter banks

[^1]

Introduction
============

The analysis of texture is, together with color, a key step in many computer vision tasks. Texture regions are generally defined as the statistical spatial distribution of their pixel intensities and can be described, among others, as fine, coarse, rippled or irregular [@haralick1973textural]. This paper focuses on the segmentation of images into multiple texture regions. Real world images exhibit various textures at different scales and frequencies which makes its analysis challenging. Many classic texture segmentation methods involve extracting the response to hand-crafted filter banks followed by a clustering or classification method [@liu2006image; @mevenkamp2016variational; @yuan2015factorization; @shi2000normalized; @paragios2002geodesic]. Convolutional Neural Networks (CNNs) are well suited for texture analysis [@andrearczyk2016using; @andrearczyk2016deep; @cimpoi2016deep] with a design similar to filter banks trained with powerful learning algorithms. They obtain excellent results on texture recognition datasets by discarding the overall shape analysis of classic network architectures. CNNs share several ideas with classic texture segmentation methods including filter banks and multi-scale analysis (e.g. skip layers [@long2015fully], hypercolumns [@hariharan2015hypercolumns]) and classification in the feature space. A Fully Convolutional Network (FCN) [@long2015fully] is a type of CNN which can efficiently perform semantic segmentation of objects (e.g. a car, an animal or a person). This paper thus investigates the power of FCNs in the segmentation of texture images. We develop a fully convolutional architecture optimized for the segmentation of textures which discards very deep shape information and combines the response to filter banks at various depths to make use of local (shallow features) and more global and abstract information (deeper features).

This paper differentiates between two major texture segmentation problems with different application focus. The first task is the semantic segmentation of types of textures with a potentially large intra-class variation (e.g. wood, grass and textile). This first problem is relatively similar to a classic image classification or segmentation task in which an algorithm is trained to detect an object with many possible variations (shape, scale, lighting etc.) in a supervised manner with many samples of each class. The second problem is to learn to segment textures with a single small training (supervised) sample or with no training data at all (unsupervised). Note that the approach is unsupervised but the training of FCN itself is supervised as explained in Section \[sec:methodDescription\]. For this task in particular, we make use of the repetitivity of the textural patterns which can be efficiently learned by finetuning a FCN with little training data. Three sets of experiments are therefore developed to evaluate our approaches on these tasks including A) a supervised semantic segmentation with multiple training images, B) a supervised segmentation with a single training image per class and C) an unsupervised segmentation. We evaluate our approach on images that we have generated (experiment A) as well as on the Prague texture segmentation benchmark [@haindl2008texture] (experiments B and C), on which we considerably improve the state of the art.

The contributions of this paper include i) a FCN architecture for texture segmentation combining the analysis of simple local texture patterns with more global and complex patterns while discarding the overall shape analysis; ii) we demonstrate the potential of such network to learn to segment textures with non-segmented texture images; iii) we show that this network can be trained with very little training data (single image per class and even parts of the test image itself) which enables learning texture segmentation in an unsupervised framework.

The rest of this paper is organized as follows. The related work is reviewed in Section \[sec:relatedWork\]. Our approach including network architecture and training methods is described in Section \[sec:methodDescription\]. Three sets of experiments are presented in Sections \[subsec:experimentA\], \[subsec:experimentB\] and \[subsec:experimentC\] including supervised and unsupervised texture segmentation.

Related work {#sec:relatedWork}
============

Texture analysis often involves the extraction of handcrafted local features combined with a learning algorithm to perform the desired task in the feature domain such as classification [@randen1999filtering] or clustering [@jain1991unsupervised; @liu2006image; @mevenkamp2016variational; @yuan2015factorization]. In particular, a wide range of texture segmentation methods involve the extraction of texture descriptors based on local responses to hand-designed filter banks typically with a set of scales and orientations. Gabor filters are the most commonly used filters in texture segmentation [@jain1991unsupervised; @paragios2002geodesic; @liu2006image; @mevenkamp2016variational; @yuan2015factorization]. The response to such filter banks is often used to obtain powerful texture descriptors, namely local spectral histograms [@liu2006image; @mevenkamp2016variational; @yuan2015factorization]. Other filters include intensity, gradients and Laplacian filters [@liu2006image], difference of oriented Gaussian filters [@shi2000normalized], as well as isotropic and anisotropic filters [@paragios2002geodesic]. Other types of popular texture features used in texture segmentation include statistical descriptors such as Local Binary Patterns (LBPs) [@ojala1999unsupervised] and co-occurrence matrices [@chen1979segmentation] as well as wavelet transforms [@arivazhagan2003texture]. Segmentation of texture descriptors can be performed, among others by graph cut [@shi2000normalized], curve evolution with level-set optimization [@paragios2002geodesic], region growing and merging [@chen1979segmentation] and functional minimization (Mumford-Shah functional) [@liu2006image; @mevenkamp2016variational]. Other popular segmentation approaches include k-means, mean-shift, region splitting and watershed [@szeliski2010computer].

The methods introduced so far extract hand-crafted features which are classified or clustered with a machine learning algorithm. Deep learning methods, particularly CNNs, have largely outperformed most of these methods in classification and segmentation tasks. Deep learning approaches enable replacement of hand-crafted descriptors by trainable filters combined in a cascade of layers, learning multiple levels of abstraction. CNNs are excellent image recognition networks adapted for texture classification in [@andrearczyk2016using; @cimpoi2016deep], in which the overall shape analysis is discarded as it is irrelevant in texture analysis as opposed to object recognition. The response to deep filters are extracted from the network for training a classifier in [@cimpoi2016deep] whereas the network is trained end-to-end in [@andrearczyk2016using; @andrearczyk2016deep] with back-propagation. An attempt to texture semantic segmentation is also proposed in [@cimpoi2016deep] by using a region proposal based on low level image cues and classifying these regions using the proposed deep descriptors extracted from the CNN. FCNs are introduced in [@long2015fully] to perform pixel-wise semantic segmentation. These networks are trained end-to-end similarly to CNNs except that an error is calculated for each label. To obtain a pixelwise classification, fully-connected layers are first replaced by $1\times 1$ convolution layers to allow arbitrary input sizes. The output feature maps of these $1\times 1$ convolution layers are smaller than the number of input pixels and are therefore upsampled by deconvolution and interpolation to get back to a pixelwise representation. Following the idea of hypercolumn in [@hariharan2015hypercolumns], information obtained at multiple depths in the network is combined by using connections to skip certain layers. A skip connection combines the final prediction layer with earlier layers of finer strides. These connections involve $1\times 1$ convolutions for dimensionality reduction of the finer feature maps as well as appropriate deconvolution and subsampling for summation. In this way, the local information (“where") in intermediate layers is combined to the global information (“what") in deep layers. This approach allows to extract deep features of high complexity while maintaining a locality information crucial for segmentation across boundaries.

Finally, other deep learning methods have been introduced for the segmentation of various types of images with different architectures (e.g. U-Net [@ronneberger2015u]), deeper networks and different learning methods (e.g. generative adversarial network [@luc2016semantic]). While these latest advances are of high interest and may be considered in future research, they are out of the scope of this paper as we base this work on FCNs.

Method description {#sec:methodDescription}
==================

This section describes our FCN architecture for texture segmentation as well as a simple segmentation refinement method.

Network architecture {#subsec:NetArch}
--------------------

We adapt a fully convolutional architecture for texture segmentation[^2]. As mentioned in [@andrearczyk2016using; @cimpoi2016deep], the overall shape analysis, required in classic object recognition tasks, can be discarded for the analysis of texture. In a convolutional network, the semantic or high level of abstraction information (global shape) is contained in the deepest convolution layers and fully connected layers (implemented with $1\times 1$ convolutions). For example in the VGG-16 network [@simonyan2014very] trained on Imagenet [@deng2009imagenet], the neurons in the last convolution layer respond to complex shapes in the input image such as faces, cars, persons etc. Therefore we develop an architecture based on the FCN8 network developed in [@long2015fully] with less convolution layers. We use four sets of convolution layers instead of five as the texture patterns complexity is less than the shape complexity of objects segmented in [@long2015fully].

Segmentation difficulties can occur across texture boundaries due to downsampling in deep networks, resulting in large receptive fields with high abstraction and a loss of local information. This issue can be addressed by using skip connections [@long2015fully] in FCNs in order to combine local and global information in the deconvolution layers. This is very relevant in texture segmentation as it does not only improve the boundaries segmentation but also provides high frequency details which often carry useful information about the textures. Where the FCN8 fuses the outputs of the third and fourth convolution blocks (Conv3 and Conv4) using skip layers, we aggregate the local information of the outputs of the first, second and third convolution blocks instead. This architecture that we refer to as FCNT is shown in Figure \[fig:diagram\].

![Our FCNT architecture based on [@long2015fully]. The grids reveal the relative spatial coarseness of pooling and prediction layers. Convolution layers are shown as vertical lines. Skip connections, represented by arrows allow to combine local information from early layers with more global information extracted by deeper layers (conv6). The upsampling is performed by successive deconvolution operations. Note that conv5-6 are the equivalent of fully-connected layers in classic CNN architectures. Diagram adapted from [@long2015fully]. []{data-label="fig:diagram"}](diagram_FCNT.pdf)

Refinement of segmented regions {#subsec:refinement}
-------------------------------

As explained in the previous section, we use local information from shallow layers to significantly improve the boundary segmentation. However, boundary pixels remain a difficulty and the major cause of misclassification of the FCNT. For this reason, we develop a segmentation refinement method based on the output of the network. In the classic inference phase of a FCN, each pixel is assigned a prediction vector of size equal to the number of training classes. The segmentation result is obtained by assigning each pixel to the class which corresponds to the highest score in the prediction vector. However, more information is available as each class is assigned a score in these vectors. We make use of this extra information in a basic refinement method to improve the segmentation results and to obtain a single texture region per class in experiments B and C. To do so, $N$ largest patches are first isolated and filled (step 1), where $N$ is the number of texture classes in the segmented image to refine. A patch refers to a connected region of individual class label. As shown in Figure \[fig:expB\].f, there are generally more than one patch per texture label before refinement. In an iterative process, the small isolated regions (pixels not part of any largest patch) are then assigned the second best prediction of the network to attempt to merge them with larger patches (step 2). Successively, the remaining isolated regions are assigned to class labels with incrementally lower probability scores in the output vectors (steps 4, 5, etc.) The refinement stops when a segmentation with a single patch per class is obtained. The pseudo code for this approach is given as follows.\
1) Largest patches\
while($\bar{N}\neq N$):\
2) Relabel 1, largest patches\
3) Relabel 2, largest patches\
4) if $im_3^{t-1}==im_3^{t}$: relabel 3, largest patches;\
else: back to 2)\
5) if $im_4^{t-1}==im_4^{t}$: relabel 4, largest patches;\
else: back to 2)\
6) if $im_5^{t-1}==im_5^{t}$: relabel 5, largest patches;\
else: back to 2)\
etc.\
end while,\
where $\bar{N}$ and $N$ are respectively the number of patches and the number of texture classes. “Largest patches" means that we take the largest patches of each class and fill them, i.e. the labels of the small regions fully contained in the N largest patches are changed to the patches’ labels. “Relabel $x$" refers to the relabelling of all the pixels which are not part of the largest patches to the $x^{th}$ best class prediction of the network at these pixel locations. Finally $im_X^{t}$ is the output of step X of the pseudo code at the current loop iteration. An example of refinement result is shown in Figure \[fig:expB\].f and \[fig:expB\].g.

Experiments
===========

In this section we evaluate the developed method on a set of supervised and unsupervised experiments. We conduct three types of experiments (A, B and C) as follows.

Experiment A: Supervised training with multiple training images per class {#subsec:experimentA}
-------------------------------------------------------------------------

This task is relatively similar to a classic FCN training method as multiple training instances of the same class are used. The intra-class variation forces the network to learn certain invariances to scale, orientation, and even types of textures. The major differences are the texture nature of the images and the fact that the training images are not segmented (i.e. homogeneous texture across the entire image).

### Datasets

For this experiment, we develop two datasets as follows[^3]. For the **kth-seg** dataset, we use images from the kth-tips-2b dataset [@hayman2004significance] which contains 11 classes of texture images. Each class is made of four groups and each group contains images at 9 different scales. As we use images at scale 10, each group in a particular class contains 12 images for a total of 528 images. The evaluation is based on the idea of 4-fold cross-validation used in [@andrearczyk2016using; @cimpoi2016deep]. Each group is used once to create testing images of multiple texture regions while the remaining groups are used for training. To create a test image, we randomly pick a number of images (two to five) from the test group and create a mosaic image with one texture region from each image (all from different classes). For each fold, there is a total of 396 training images and 80 test images.

![Examples of segmentation with FCNT on the supervised Prague texture segmentation task (experiment B). The network is trained with one image per texture segment (six training images in this example). a) Input image to segment; b) ground truth segmentation; c) Markov Random Field (MRF) segmentation [@kato2001color]; d) Co-Occurrence Features (COF) segmentation; e) Con-Col segmentation (see Section \[subsubsec:results\]); f) FCNT segmentation without refinement (ours); g) FCNT segmentation with refinement (ours). Best viewed in color. []{data-label="fig:expB"}](expB.pdf)

For the **Kylberg-seg** dataset, we use images from the Kylberg texture classification dataset [@Kylberg2011c] which contains 28 classes of 160 images each of size $576\times 576$. We randomly select one of 12 available orientations for each image similarly to [@andrearczyk2016using]. Half of the dataset is used for training, the rest to create test images. The images are split into four sub images of size $288\times 288$. Images from the test set are randomly picked to create test images of size $288\times 288$ with two to five texture regions from different classes, similarly to kth-seg. There is a total of 8960 training images and 80 test images. Examples of the Kylberg-seg dataset are shown in Figure \[fig:expA\].

Note that in such supervised approach with non-segmented images, we could artificially create segmented images at training time to help the network in taking boundary decisions. However, this would be heavily biased as the artificial segmentation would be very similar to the test segmentation and would not generalize well to real life texture segmentation problems as the boundary between two real textures can be melted, blurred etc.

### Details of the network

We initialize the networks (FCN8 and FCNT, see Section \[subsec:NetArch\]) with the weights learned with FCN8 on the PASCAL VOC 2011 dataset [@pascal2011]. Layers which are not common to both networks (fully-connected and deconvolution layers) are initialized with the Xavier method [@glorot2010understanding]. The width of the network in the deconvolution layers (number of feature maps in the last fully connected layer and following layers) is equal to the number of training texture classes, i.e. 11 for kth-seg and 28 for Kylberg-seg. The networks are trained with stochastic gradient descent similarly to [@long2015fully]. The training data and the amount of information and variation the networks need to learn is relatively large (as compared to experiments B and C). Therefore we train the networks for 300,000 and 400,000 iterations for the kth-seg and Kylberg-seg experiments respectively. Neither pre-processing, post-processing nor refinement is applied to demonstrate only the discriminative power of FCNs in texture segmentation with multiple training images per class.

### Results

In this experiment, we compare our framework using FCN8 developed in [@long2015fully] and our FCNT network. The results are summarized in Table \[tab:results\_a\] as the average correct assignment of pixels. Figure \[fig:expA\] illustrates segmentation result examples with two to five texture regions per image. Note that the segmentation results are directly the output of the network which learned from non-segmented images to recognize multiple classes (11 for kth-seg and 28 for Kylberg-seg) with challenging inter-class similarities and a high intra-class variation for kth-seg. The FCNT outperforms FCN8 on the developed texture segmentation datasets (except kth-5) which demonstrates the importance of using local information and discarding the overall shape analysis. However, the best architecture might depend on the application, e.g. the complexity of the texture patterns, the scale variation, the number of texture regions as well as the desired results (e.g. precise boundary decision, minimum over-segmentation, etc.).

  Datasets   kth-2   kth-3   kth-4   kth-5   Kylberg-2   Kylberg-3   Kylberg-4   Kylberg-5
  ---------- ------- ------- ------- ------- ----------- ----------- ----------- -----------
  FCN8       67.93   72.60   67.76   64.98   85.94       79.13       77.43       76.33
  FCNT       68.70   73.05   68.31   63.60   88.81       80.59       79.11       76.80

![Examples of segmentation with FCN8 [@long2015fully] and our FCNT architecture on experiment A (Kylberg-seg). First row: input test image to segment. Second row: ground truth segmentation. Third row: FCN8 segmentation. Fourth row: FCNT segmentation. Best viewed in color. []{data-label="fig:expA"}](expA.pdf)

Experiment B: Supervised training with single training image per class {#subsec:experimentB}
----------------------------------------------------------------------

This experiment is conducted using the Prague texture segmentation benchmark developed in [@haindl2008texture] which enables to test and compare algorithms on a range of supervised and unsupervised texture segmentation tasks.

### Dataset

In this experiment, we use the supervised dataset of the Prague texture segmentation benchmark [@haindl2008texture] with 20 test images. Each test image contains a number of texture regions (of different classes) ranging from 3 to 12 and a single training image is provided for each class (i.e. N training images for a test image containing N texture regions). Although different images are used for the training and testing sets, the variation between training and testing images is limited due to their visual similarity.

### Details of the network

As in experiment A, we initialize the FCNT (see Section \[subsec:NetArch\]) with the weights learned with FCN8 on the PASCAL VOC 2011 dataset [@pascal2011] and layers which are not common to both networks are initialized with the Xavier method. The width of the network in the deconvolution layers is again equal to the number of training texture classes which is given for each test image by the number of training image (3 to 12), and in turn is equal to the number of ground truth regions in the test image. We train for 5000 iterations similarly to [@long2015fully] although the results are stable to small changes of this number with a fast learning and negligible overfit.

### Results {#subsubsec:results}

For this experiment, we compare our method to three algorithms whose results are provided on the Prague texture segmentation website [@prague]. The algorithm we refer to as MRF is an implementation of the method developed in [@kato2001color], an image segmentation algorithm using a Markov Random Field pixel classification model. Little information is provided about the second algorithm, referred to as COF as it uses co-occurrence features with a nearest neighbor classifier. Finally, no information is provided regarding the best reported results on this supervised dataset. We refer to this state of the art as Con-Col as named in [@prague]. The results for this experiment are summarized in Table \[tab:results\_b\] in the form of various segmentation evaluations including region based (e.g. correct segmentation CS), pixel-wise (e.g. correct assignment CO) and consistency (e.g. global consistency error GCE) measures. For more information on these performance measures, the reader should refer to [@haindl2008texture; @prague]. The proposed FCNT (with refinement) largely outperforms the best results from the literature and largely benefits from the segmentation refinement method (see Section \[subsec:refinement\]). Figure \[fig:expB\] shows examples of segmentation results of the three algorithms from the literature as well as our method with and without segmentation refinement.

Experiment C: Unsupervised training {#subsec:experimentC}
-----------------------------------

### Dataset

In the last experiment, we use the Prague unsupervised texture segmentation dataset (ICPR 2014 contest) [@haindl2008texture]. It contains 80 test images (which include the 20 test images of experiment B) without any training sample. Each test image contains 3 to 12 texture regions which must all be segmented as individual textures.

### Pre-segmentation

While this experiment is unsupervised, labels are needed to train the network and so we need to obtain a rough pre-segmentation map from the test images. The idea is that the FCNT can learn from little training texture data and that textures are homogeneous across the regions of the test images. Therefore we can train the network from patches of texture regions roughly segmented in an unsupervised manner from the test images. Two methods are tested to obtain a pre-segmentation map.

First a simple k-means clustering method is applied on the output of a pre-trained FCNT with the image to segment as input. To that end, the input image to the pre-trained network is downsampled (with bilinear interpolation) by a factor of four in order to obtain more homogeneous label regions and a fast clustering. A k-means algorithm with known number of clusters is run on the output of the FCNT. The k-means clustering is performed in a feature space of dimensionality equal to the number of classes in the pre-trained FCNT network (11 in this case as it is pre-trained on kth-tips-2b). Note that in the ICPR 2014 contest [@haindl2008texture], the number of clusters is unknown. This experiment is designed to demonstrate the power of the FCNT in a texture segmentation with rough pre-segmentation and not to evaluate such pre-segmentation methods. We therefore use a known number of clusters as it provides a simple pre-segmentation. We leave the problem of obtaining more accurate pre-segmentation labels from the network with an unknown number of textures for future work. The obtained label image is then upsampled by the same factor used to downsample the input image. The largest connected label region for each class is filled and used for training while other small isolated regions and dilated borders between regions are not used.

In a second approach, we use shallow segmentation algorithms from the literature to obtain the pre-segmentation labels. We use the segmentation results (provided in [@prague]) from four algorithms described as follow. Factorization based texture Segmentation (FSEG) [@yuan2015factorization] uses local distribution of filter responses (local spectral histograms) to construct a feature matrix. This matrix is factorized based on singular value decomposition into two matrices, one containing representative features, the other one containing the weights used for linear combination of the representative features at each pixel location. These weights indicate the segmentation map result. The variational multi-phase segmentation framework (PCA-MS) developed in [@mevenkamp2016variational] also uses a filter bank approach. It performs a dimensionality reduction (principal component analysis) of the extracted local spectral histograms and an energy (Mumford-Shah) minimization segmentation. The Priority Multi-Class Flooding Algorithm (VRA-PMCFA) developed in [@voting; @panagiotakis2011natural] involves a voting selection of a parameterized number of representative blocks of pixels based on wavelet distributions, followed by an iterative computation of segmentation maps by clustering, flooding and region merging. Finally, the last results appear as the state of the art on the unsupervised Prague dataset [@prague], although no information is provided about the algorithm. We refer to this algorithm as MK in reference to the author’s name (Martin Kierche).

### Details of the network

When using a k-means pre-segmentation, the FCNT is pre-trained on kth-tips-2b (only for the pre-segmentation) to obtain a first output without finetuning.

For training the network with the pre-segmentation map (from k-means and other algorithms), the FCNT is initialized similarly to experiments A and B. The test image itself is fed as training data with training labels being the pre-segmentation map. The width of the network in the deconvolution layers is again equal to the number of training texture classes, given for each test image by the number of classes present in the pre-segmentation map.

As we use patches of the test image for training with rough pre-segmentation labels, we do not want the network to overfit. We assume that a majority of pixels in the pre-segmentation map are correctly classified and that the FCNT will first learn to segment these pixels which form a region of homogeneous texture. Misclassified pixels in the pre-segmentation map should exhibit a different texture. Yet, if it overfits, the network will learn a representation that merges these outliers and the correct regions into the same class. This is due to both the plasticity of the network and the small amount of training data. In order to avoid overfitting, we evaluate the output of the network on the test image during training. We stop the training 60 iterations after all the texture classes present in the pre-segmentation map are detected in the output of the trained network. In other words when at least one pixel is assigned to each class in the output of the network. This early stop method avoids overfitting the pre-segmentation training labels. Note that we limit the number of iterations to 400 if the previous condition is not reached.

### Results {#results-1}

The results are reported in Table \[tab:results\_c\] with the same measures as in experiment B. Images of segmentation results obtained with the shallow algorithms as well as our FCNT approach with different pre-segmentation methods are shown in Figure \[fig:expC\]. Our method used with existing pre-segmentation labels (FSEG, PCA-MS, VRA-PMCFA and MK) consistently improves the results from the segmentation of these shallow algorithms. The FCNT trained with labels from the MK segmentation largely outperforms the state of the art. When compared to the literature, it obtains the best score on 12 out of 18 measurements and second best score on four others.

![image](expC.pdf)

Note that these results are obtained on the Prague dataset referred to as ’large’ in [@haindl2008texture] (80 test images) whereas the supervised results are given in Table \[tab:results\_b\] for the ’normal’ Prague dataset (20 test images) in order to compare to the state of the art. A comparison is however possible as the results on the normal and large supervised datasets are very similar and the large dataset is an extended version of the normal one. For comparison, the supervised method obtains 95.64% correct segmentation (CS) on the large dataset (vs. 96.01% on the normal dataset); as expected, significantly better than the unsupervised best results (79.34%).

Conclusion
==========

This work has shown the power of FCNs in the segmentation of textures, with features of multiple complexity trained end-to-end to recognize and segment texture regions. We developed a fully convolutional architecture designed for texture segmentation by combining shallow features encoding local high frequency information and deeper features containing more abstract information. We explored several tasks including supervised and unsupervised segmentation. In particular, we showed that the developed FCN architecture can learn to perform semantic segmentation from classic texture recognition datasets with non-segmented images (kth-tips-2b and Kylberg). We have also shown that it can be trained (finetuned) with a very small amount of training data (single image per class) and even using texture regions of the test image itself as training data after a pre-segmentation process. The proposed approach largely improved the state of the art on the Prague texture segmentation benchmark including supervised and unsupervised datasets.

[^1]: *Article under consideration at Pattern Recognition Letters.*

[^2]: The network architecture implemented with Caffe [@jia2014caffe] and more details will be provided.

[^3]: Please contact the authors to obtain these datasets.
