Using Neural Networks for Fast SAR Roughness Estimation of High
  Resolution Images
The analysis of Synthetic Aperture Radar (SAR) imagery is an important step
in remote sensing applications, and it is a challenging problem due to its
inherent speckle noise. One typical solution is to model the data using the
$G_I^0$ distribution and extract its roughness information, which in turn can
be used in posterior imaging tasks, such as segmentation, classification and
interpretation. This leads to the need of quick and reliable estimation of the
roughness parameter from SAR data, especially with high resolution images.
Unfortunately, traditional parameter estimation procedures are slow and prone
to estimation failures. In this work, we proposed a neural network-based
estimation framework that first learns how to predict underlying parameters of
$G_I^0$ samples and then can be used to estimate the roughness of unseen data.
We show that this approach leads to an estimator that is quicker, yields less
estimation error and is less prone to failures than the traditional estimation
procedures for this problem, even when we use a simple network. More
importantly, we show that this same methodology can be generalized to handle
image inputs and, even if trained on purely synthetic data for a few seconds,
is able to perform real time pixel-wise roughness estimation for high
resolution real SAR imagery.
Li Fan, Jeova Farias Sales Rocha Neto
# Using Neural Networks for Fast SAR Roughness Estimation of High Resolution Images

###### Abstract

The analysis of Synthetic Aperture Radar (SAR) imagery is an important step in remote sensing applications, and it is a challenging problem due to its inherent speckle noise. One typical solution is to model the data using the \(G_{I}^{0}\) distribution and extract its roughness information, which in turn can be used in posterior imaging tasks, such as segmentation, classification and interpretation. This leads to the need of quick and reliable estimation of the roughness parameter from SAR data, especially with high resolution images. Unfortunately, traditional parameter estimation procedures are slow and prone to estimation failures. In this work, we proposed a neural network-based estimation framework that first learns how to predict underlying parameters of \(G_{I}^{0}\) samples and then can be used to estimate the roughness of unseen data. We show that this approach leads to an estimator that is quicker, yields less estimation error and is less prone to failures than the traditional estimation procedures for this problem, even when we use a simple network. More importantly, we show that this same methodology can be generalized to handle image inputs and, even if trained on purely synthetic data for a few seconds, is able to perform real time pixel-wise roughness estimation for high resolution real SAR imagery.

 Synthetic Aperture Radar Images, Neural Networks, Image Analysis, Statistical Modeling.

## I Introduction

Synthetic Aperture Radar (SAR) data is crucial to remote sensing and earth monitoring. Its ability to capture high resolution snapshots of targets and landscapes independently of the weather conditions and sunlight has opened the way to important advancements in environmental monitoring, emergency response, evaluation of damages in natural catastrophes, urban planning and ecology, to mention a few. Because of its widespread use, there is a considerable industrial appeal for SAR image understanding algorithms. This task, however, is challenging due to the degrading speckle noise inherent to such data, which prevents the application of image processing techniques that are common in other image domains.

Thankfully, this same appeal led to the developments of statistical models that describe the SAR data despite its noise pattern. In particular, the \(G_{I}^{0}\)[1] distribution for intensity data, highly successful in both theory and practice [2], arouse to prominence in the remote sensing community because of its capacity to model well textured, extremely textured and textureless terrain data. To do so, this model relies on three parameters, one of which is roughness. It directly corresponds to the captured texture and has been extensively used for SAR data understanding [3, 4, 5, 6, 7]. Estimating such parameter became crucial in many SAR imaging techniques [7, 4]. However, the best current available algorithms for such a task, i.e. Maximum Likelihood [2], Log-cumulant [8] and Minimum Distance Estimators [5], are too computationally expensive to be applied to high resolution images within reasonable time.

Taking a different approach, deep learning has been successfully applied to SAR [9] and many other imaging domains [10]. In these techniques, one typically relies on training a large neural network on a substantial amount of labeled data, or augmentations thereof. Practically speaking, this considerably sized process can be accomplished by implementing parallelleizable learning techniques in powerful parallel processing machines, such as Graphics Processing Units (GPUs). Nowadays, many efficient and simple-to-use libraries are available for manipulating data, and training deep networks on GPUs, which prompts researchers and practicians alike to design their methodologies in a way to leverage these powerful tools.

In this work, we propose using neural network-based learning algorithm for estimating roughness maps in SAR images. In our methodology, we generate sets of \(G_{I}^{0}\) samples of varying sizes, compute their sample moments and use them to predict the parameters that generated the data. Once the network is trained on this fully synthetic data, we proceed with network inference on real data. To the best of our knowledge, our work is the first of its kind to train a neural network to estimate parameters of distributions based on sample moments from synthetic data. As we shall show, in fact, a very small network composed, trained for a few seconds on a small dataset, is sufficient to produce better estimates on unseen data than maximum likelihood and log-cumulant-based estimators in terms of mean squared error, while being also faster and less prone to failures. Finally, this same process can be fully implemented, from sample moment computation and training to network inference, on a GPU for high resolution image-sized input, with pixel-wise roughness estimation accomplished in a few milliseconds on average. Overall, we propose a simple, principled and efficient method for training neural networks for SAR image understanding, using the statistical baggage this type of data carries.

## II Preliminaries

### _SAR Statistical Modeling and Parameter Estimation_

The intensity return \(Z\) in monopolarized SAR image can be effectively modeled by the product of two independent random variables: \(X\), the _backscatter data_, and \(Y\), the inherent _speckle noise_[2]. Typically, \(Y\) is modeled as a unitary-mean Gamma distributed random variable with shape parameter corresponding to the number of looks \(L\in\mathbb{N}^{*}\) used to
capture the data, and considered known during estimation [2]. Assuming that \(X\) obeys the reciprocal of Gamma law, Frery _et Al._[1] showed that \(Z\sim G_{l}^{0}(\alpha,\gamma,L)\) with density:

\[f_{\mathcal{G}_{l}^{0}}(z,\theta)=\frac{L^{L}\Gamma(L-\alpha)}{\gamma^{\alpha} \Gamma(-\alpha)\Gamma(L)}z^{L-1}(\gamma+Lz)^{\alpha-L}, \tag{1}\]

where \(-\alpha,\gamma>0\) are called _roughness_ and scale, respectively.

The \(G_{l}^{0}\) model has become a popular choice for SAR data due to its expressiveness [1], mathematical tractability [2], and effectiveness when applied to various imaging tasks [11, 4]. In fact, it was shown that the roughness parameter \(\alpha\) plays an important role in SAR understanding [5]. With roughness close to zero, typically \(\alpha>-3\), it suggests the targeted region is highly textured, therefore urban. For \(\alpha\in[-3,-6]\), we have evidence for moderately textured regions, which can correspond to forests. Finally, \(\alpha<-6\) implies textureless areas, such as seas and pastures. Hence, using \(\alpha\) estimates instead of pixel intensities on SAR images led to improvements in image segmentation [7, 3] and region discrimination [12].

This direct application of SAR statistical modelling fueled the study and improvement of estimators for the \(G_{l}^{0}\) distribution [12, 5]. While early work employed a Maximum Likelihood Estimator (MLE) [2] for parameter estimation, later developments led to the application of Method of Moments [2], Method of Log Cumulants (LCUM) [8, 6, 7] and Minimum-Distance Estimators [5, 4] to this problem. Despite some of their successes, all these methods, especially LCUM, heavily rely on slow optimization procedures and are prone to high estimation failures [5]. These issues hinder their application in image-sized data understanding, as the current praxis relies on generating _roughness maps_ by sweeping the image with a window that collects the intensity data centered at each pixel and then proceeds with the parameter estimation algorithm [7], a process that can be excessively slow.

### _Neural Networks_

We focus on supervised learning algorithms that, given a dataset \(\mathcal{D}=\{(\mathbf{x}_{i},\mathbf{y}_{i})\}_{i=1}^{N}\), aim to compute a model \(f_{\theta}(\cdot)\) parameterized by \(\theta\) that best predicts the output \(\mathbf{y}_{i}\)'s when given the input \(\mathbf{x}_{i}\)'s. The prediction error, to be minimized, is measured via a loss, typically the Mean Squared Error (MSE):

\[\mathrm{MSE}=\frac{1}{N}\sum_{(\mathbf{x},\mathbf{y})\in\mathcal{D}}\| \mathbf{y}-f_{\theta}(\mathbf{x}))\|_{2}^{2}, \tag{2}\]

where \(\|\cdot\|_{2}\) is the Euclidean vector norm. In _Neural Networks_, we assume that \(f_{\theta}\) is composed of units of a non-linear activations \(\sigma(\cdot)\) and parameters \(\theta=\{\mathbf{W},\mathcal{B}\}\), where \(\mathcal{W}=\{W_{i}\}_{i=1}^{Q}\) are _weight_ matrices and \(\mathcal{B}=\{\mathbf{b}_{i}\}_{i=1}^{Q}\) a set of _bias_ vectors. The Multilayer Perceptron (MLP), a popular network, uses a model \(NN_{\theta}(\mathbf{x})\) formed by the composition of affine transformations of the inputs followed by the element-wise application of \(\sigma(\cdot)\):

\[NN_{\theta}(\mathbf{x})=\sigma(W_{Q}\dots\sigma(W_{2}\sigma(W_{1}\mathbf{x}+ \mathbf{b}_{1})+\mathbf{b}_{2})\dots+\mathbf{b}_{Q}). \tag{3}\]

Each transformation is typically referred to as a _layer_ of the MLP, where the first and last are the input and output layers, and others are called hidden layers. A network with multiple hidden layers is commonly known as a "deep" neural network.

Another, arguably more popular, neural network model is the Convolutional Neural Network (CNN). Different from the MLP model, in CNN, the weights in each layer are shared so that they effectively perform a convolution operation on the input. For example, consider an image \(I\) of shape \(c\times w\times l\), where \(w\) and \(l\) are 2D spatial dimensions of \(I\), and \(c\) is its number of channels (three for RGB data). One can design a matrix of weights whose application on a vectorized/flattened version of \(I\) corresponds to a convolution of \(I\) on its original shape and a _kernel matrix_ of shape \(c\times k\times k\), where \(k\ll w,l\). Using such _convolutional layers_ brings several advantages for learning on image-sized data. First, the number of weights to be learned is drastically reduced, from \(O(cwl)\) to \(O(ck^{2})\). Second, the number of weights to be learned no longer depends on the size of the input. Third, one can show that this process learns separate feature detectors, which improves the network performance on important imaging tasks such as detection, denoising and segmentation [10].

More importantly to us is the setting where MLPs and CNNs are equivalent. Suppose we have the input vectors of the dataset \(\mathcal{D}\) in \(\mathbb{R}^{d}\) and output vectors in \(\mathbb{R}^{d^{\prime}}\). Learning a dense layer for \(\mathcal{D}\) would require finding a matrix \(W\in\mathbb{R}^{d\times d^{\prime}}\). Now, consider the tensors \(X\in\mathbb{R}^{d\times w\times l}\) and \(Y\in\mathbb{R}^{d^{\prime}\times w\times l}\), where \(w\) and \(l\) are chosen such that \(wl=N\), and each \(\mathbf{x}_{n}\) (resp. \(\mathbf{y}_{n}\)) is placed in a transversal tube \(X[:,i,j]\) (resp. \(Y[:,i,j]\))1[13]. It is easy to see that training \(d^{\prime}\) kernel matrices of shape \(d\times 1\times 1\) is the same as learning the values in \(W\)[14]. As discussed in the next section, using these \(1\times 1\) convolutional layers will enable us to see our parameter estimation procedure as an inference on a pre-trained CNN, leveraging the speed of highly parallel computing engines during estimation and preventing us from using time-consuming loops for generating roughness maps.

Footnote 1: We use a notation similar to Numpy’s for array indexing (for example, \(X[i,j]\) is the element in \(X\) at indices \((i,j)\)) and slicing (or example, \(X[i,:]\) is all the elements in the \(i\)-th row of \(X\)).

## III Proposed Methodology

### _Estimating \(G_{l}^{0}\) Using Neural Networks_

Our approach for estimation relies on neural network-based learning procedure. Let \(L\in\mathbb{N}^{*}\) be known [2] and \(\mathcal{H}=\{(\mathcal{Z}_{i},\alpha_{i})\}_{i=1}^{N}\) be a dataset composed of samples \(\mathcal{Z}_{i}\) from a \(G_{l}^{0}(\alpha_{i},\gamma_{i},L)\) distribution of varying sizes, where we assume \(\gamma_{i}=-\alpha_{i}-1\)2. We also assume that \(\alpha_{i}\) is always above a given lower bound (set to \(-15\) in our experiments) [5].

Footnote 2: We follow the praxis of assuming that the samples have unit mean [2].

Our goal is to train a neural network to predict \(\alpha_{i}\) from \(\mathcal{Z}_{i}\). However, the data in \(\mathcal{Z}_{i}\) cannot be used directly, as the input vector of our network needs to be of fixed size. The final estimator also needs to be invariant to sample permutations in each input set. To solve these issues, the authors in [15] proved that that all permutation invariant functions \(t(\cdot)\) on a set \(\mathcal{S}\) can be represented as \(t(\mathcal{S})=\rho\left(\sum_{s\in\mathcal{S}}\phi(s)\right)\), where \(\rho(\cdot)\) and \(\phi(\cdot)\) are continuous functions. Setting \(\rho(x)=\frac{1}{|\mathcal{Z}_{i}|}x\) and \(\phi(x)=(\log x)^{m}\) and applying the resulting \(t(\cdot)\) on a sample \(\mathcal{Z}_{i}\) from \(\mathcal{D}\), we get:

\[\mu_{m}(\mathcal{Z}_{i})=\frac{1}{|\mathcal{Z}_{i}|}\sum_{z\in\mathcal{Z}_{i}}( \log z)^{m}, \tag{4}\]
where \(\mu_{m}(\mathcal{Z}_{i})\) conveniently represents the sample log-moment of order \(m\), a statistic commonly used in SAR literature [6, 7]. In practice, we create a vector of \(N_{m}\) moments \(\boldsymbol{\mu}_{i}=[\mu_{1}(\mathcal{Z}_{i})\ \mu_{2}(\mathcal{Z}_{i})\ \ldots\ \mu_{N_{m}}( \mathcal{Z}_{i})]\) and train our network on the dataset \(\mathcal{D}=\{(\boldsymbol{\mu}_{i},\alpha_{i})\}_{i=0}^{N}\). We use an MLP as our network architecture, since its structure can be adapted to infer full sized roughness maps, as explained in the next section.

```
Input:\(L\): # looks. \(R\): dataset size. \(T\): # epochs. \(N_{m}\): # log-mom. \(\mathcal{A}\): set of \(\alpha\) values, \(\mathcal{S}\): set of sample sizes. FunctionMain(): \(\mathcal{D}\leftarrow\) SyntheticDataset(\(L,w,h,\mathcal{A},\mathcal{K},N_{m},R\)) \(NN_{\theta}\leftarrow\)TrainNeuralNet(\(\mathcal{D},T\)) Function\(\mathcal{D}=\) SyntheticDataset(\(L,\mathcal{A},\mathcal{S},N_{m},R\)): \(\mathcal{D}\leftarrow\) Empty set repeat\(R\) times \(\alpha,s\leftarrow\) Sample uniformly from \(\mathcal{A}\) and \(\mathcal{S}\), resp. \(\gamma\leftarrow-\alpha-1\) \(\mathcal{Z}\leftarrow\{z|z\sim G_{0}^{2}(\alpha,\gamma,L),|\mathcal{Z}|=s\}\), \(\boldsymbol{\mu}\leftarrow\)ComputeMoments(\(\mathcal{Z},N_{m}\)) \(\mathcal{D}\leftarrow\mathcal{D}\cup\{(\boldsymbol{\mu},\alpha)\}\) Function\(\boldsymbol{\mu}=\)ComputeMoments(\(\mathcal{Z},N_{m}\)): foreach\(m\in\{1,2,\ldots,N_{m}\}\)do \(\mu[m]\leftarrow\frac{|\mathcal{D}|}{|\mathcal{Z}|}\sum_{i\in\mathcal{Z}}(\log z)^{m}\) Function\(NN_{\theta}=\)TrainNeuralNet(\(\mathcal{D}\), \(T\)): \(NN_{\theta}\leftarrow\)MultilayerPerceptron with parameters \(\theta\). repeat\(T\) times foreach batch\((\mathbf{x},\mathbf{y})\in\mathcal{D}\)do  Optimize\(\theta\) to minimize \(\|\mathbf{y}-NN_{\theta}(\mathbf{x})\|_{2}^{2}\)
```

**Algorithm 1**Training Roughness Estimator

Algorithm 2: Training Roughness Map Estimator

Algorithm 1 gives an overview of this training procedure. Following Main(), a synthetic \(G_{I}^{0}\) dataset is created by drawing samples of various predefined sample sizes and \(\alpha\) values. For each set, ComputeMoments() runs on each sample to find its first \(N_{m}\) log-moments and concatenate the resulting moment vector to the roughness value that generated it. Finally, an MLP is trained on these pairs of moment vectors and the \(\alpha\) parameter over a given amount of epochs.

After the network is trained, one can estimate the parameters of a given unseen sample set by (1) computing its moments via ComputeMoments() and (2) feeding them through the trained model. We hope that, although training requires extra computational time, the inference step in this process is fast.

### _Adaptation to Roughness Map Estimation_

In many practical scenarios involving parameter estimation in SAR, one wishes to estimate the roughness of all pixel locations in a potentially high resolution image \(I\)[7]. While we could apply the algorithm described previously to all \(k\times k\) sized windows in \(I\) for a given \(k>0\), in this section we show the functions described in Algorithm 1 can be easily adapted to image size data and be fully implemented on a GPU. This transition will enable us to fully parallelize our estimation algorithm in both training and inference phases, which will consequently highly reduce our computation time.

In this new setting, let \(I\in\mathbb{R}^{w\times h}\). For our training phase, each input in our training set will be composed of samples from the \(G_{I}^{0}\) distribution for unique values of \(\alpha\), \(\gamma\) and \(L\) disposed in a \(w\times h\) matrix. In the inference phase, \(I\) is a real SAR image of any size, meaning that our method will be able to estimate the roughness of an image with a network trained on purely synthetic and random data.

Our goals are (1) to efficiently compute all the desired \(N_{m}\) moments of the data surrounding each pixel in \(I\) on a \(k\times k\) window, composing a tensor \(M\in\mathbb{R}^{N_{n}\times w\times h}\), and (2) to feed this data to an appropriate network that estimates the roughness parameters of each pixel location on the image grid. For step (1), one can use an Average Pooling Layer, \(\operatorname{AvgPool}(\cdot)\), where a convolution kernel sweeps the input data, averaging the pixel values within that window [16]. Here we add an appropriate padding composed of \(G_{I}^{0}\) samples to \(\operatorname{AvgPool}\)'s input, so its output size remains the same. Now, if the input data is \(\log(I)^{m}\), where the exponentiation is computed pixel-wise, one can estimate each pixel's log-moments of order \(m\) via \(\operatorname{AvgPool}(\log(I)^{m})\). Each channel in \(M\) is computed by applying this procedure to all \(m\in\{1,2,\cdots,N_{m}\}\).

For step (2), we can use the connection between MLPs and \(1\times 1\) convolutional networks described in Section II-B and turn the MLP architecture used in Algorithm 1 in to a Fully Convolutional Neural Network (FCNN). In that network, the input of its convolutions will be the transversal tubes on \(M\), which correspond to the sample log-moments of each pixel in \(I\). During training, its output will be a matrix \(A\in\mathbb{R}^{w\times h}\), such that \(A[i,j]=\alpha,\forall i,j\), where \(\alpha\) is the roughness parameter that generated \(I\) along with \(\gamma=-\alpha-1\) and a predetermined \(L\). Algorithm 2 explains this training algorithm in more detail and is analogous to Algorithm 1 in its execution.
## IV Numerical Experiments and Discussion

### _Data and Algorithmic Setup and Assessment Methodology_

We assess the performance of our proposed methodology on two settings. The first is a synthetic one where we aim at estimating the roughness parameter from samples of the \(G_{I}^{0}\) distribution. We qualitatively compare the resulting network from Algorithm 1 to the standard estimators for this problem. In our second experiment, we qualitatively evaluate a model trained using Algorithm 2 on a real SAR image.

To sample synthetic SAR data from the \(G_{I}^{0}\) model, we make use of its multiplicative nature and sample \(X\sim\Gamma(1,L)\) and \(Y^{\prime}\sim\Gamma(-\alpha,\gamma)\) to get \(Z=X/Y^{\prime}\sim G_{I}^{0}(\alpha,\gamma,L)\)[2]. In our real experiments, we use a \(1500\times 1500\) SAR image acquired by Airborne SAR (AIRSAR) in HH polarization with \(L=1\) in C-band over Lake Superior, near Sault Saint Marie, MI.

We choose simple and analogous network architectures to be trained in both Algorithms 1 and 2. The MLP in Algorithm 1 consists of two hidden layers, one with eight and the other with four units, followed by \(\tanh()\) activation functions. The FCNN in Algorithm 2 is composed of two \(1\times 1\) convolutional layers with eight and four filters, respectively, followed again by \(\tanh()\) activations. These activations were chosen as they performed better than the traditional ReLU activation. For experimental simplicity, no batch normalization, dropout or data preprocessing were used during training.

Our networks were trained following the predicament in the TrainNeuralNet() functions in both Algorithms 1 and 2 using Adaptive Moment Estimation (ADAM) optimizer [17] with learning rate of 0.001 and batch size of 32. For Algorithm 1, we set \(\mathcal{S}=\{100,1000,10000\}\) and tested \(N_{m}=2\) and 4, and for Algorithm 2, we have \((w,h)=(10,10)\) and \(\mathcal{K}=\{2,5,\ldots,11\}\) and only used \(N_{m}=2\). Both algorithms use \(\mathcal{A}=\{-15,-13.5,\cdots,-1.5\}\), \(R=1000\) datapoints and \(T=300\) epochs, enough for their training convergence.

We compare our algorithms to LCUM and MLE results. To optimize both methods, we use Scipy's fsolve, a Python wrapper for an implementation of Powell's dog leg method [18]. We start each optimization with \(\alpha=-1.0001\).

In our synthetic experiments, the quantitative assessment of our methods' estimation performance compared the estimated roughness with their ground truth values via Mean Square Error (MSE), as depicted in 2. For each experiment, we also compared the failure rates for each algorithm, where we consider an \(\alpha\) estimate to fail if (1) it is not in the interval \([-1.5,-15]\)[5], or (2) if its optimization procedure, in the case of MLE and LCUM, did not converge.

We used a Tesla T4(R) GPU with 16Gb of RAM for our neural network training. The other methods were run on an Intel(R) Xeon(R) CPU at 2.30GHz with 26Gb of RAM. All methods were implemented in Python 3 and Pytorch 3. Training each network took around 30 seconds each.

Footnote 3: The code used to generate the results from this paper can be found at [https://github.com/jeovafarias/SAR-Roughens-Estimation-Neural-Nets.git](https://github.com/jeovafarias/SAR-Roughens-Estimation-Neural-Nets.git).

### _Results on Synthetic Data_

We start by evaluating our estimation methods on synthetic samples of size \(s\in\{9,25,49,121,1000\}\), generated using roughness \(\alpha\in\{-1.5,-7,-15\}\) and number of looks \(L\in\{1,3,8\}\). For each setting, we performed a Monte Carlo experiment with 1000 \(G_{I}^{0}\) samples. Figure 1 compares MLE, LCUM and the networks trained using Algorithm 1 with 2 and 4 log-moments when estimating \(\alpha\) for each sample. We only considered the samples whose estimation did not fail to compute the MSE values. Note that we run our networks on sample sizes that they were not trained on and, despite that, both of them outperform its counterparts in most scenarios. The one trained on fewer log-moments generally performed better, potentially corroborating the premise in LCUM that also only uses two log-moments in its algorithm. This also means that our neural network-based approach more competently utilizes the information contained in those log-moments for estimation than LCUM, especially for lower \(\alpha\) values.

Table I shows the failure rates of each method for various \(L\) values using the same data used in Figure 1. Our networks also overperform both MLE and LCUM on this domain for all depicted scenarios, especially for lower \(L\), where the estimation is typically more challenging [2]. Counterintuitively, more failures are detected in our methods as \(L\) increases. Further experimentation is necessary to better understand this phenomenon, and it is left to future work. We also found that estimation on our networks is generally 3 times faster than the other methods.

\begin{table}
\begin{tabular}{c c c c c} \hline \hline \(L\) & MLE & LCUM & \multicolumn{2}{c}{Neural Network} \\  & & 2 Log-moments & 4 Log-moments \\ \hline \(1\) & 71.84 & 37.44 & 0.14 & 3.24 \\ \(3\) & 59.84 & 25.55 & 1.46 & 6.22 \\ \(8\) & 47.99 & 18.59 & 6.04 & 6.96 \\ \hline \hline \end{tabular}
\end{table} TABLE I: Failure rates (%) on synthetic data.

Fig. 1: MSE values for the synthetic data. Missing values on graphs correspond to the method failing in all simulations.
### _Results on Real Data_

Figure 2 shows the roughness maps estimated by networks trained according to Algorithm 2 and using kernel sizes \(k=\{3,11,20,45\}\) during inference. Note that the \(\alpha\) values in all maps follow their expected understanding: higher values are related to urban areas; moderate values suggest forest zones and low values correspond to lake regions [5]. This demonstrates our methodology's ability to correctly estimate the desired pixel roughness, despite the networks having only been trained on purely synthetic data. Furthermore, we see the blurring effect one expects from applying larger kernels in their convolutions. More interestingly, however, is the observation that the network is still able to predict an expected map using kernel sizes it was not trained one (such as \(k=\{20,45\}\)). Finally and more importantly, Figure 2 also provides the timings to the computation of each map. Here, we note that we are able to estimate the roughness of each individual pixel of an image as large as \(1500\times 1500\) pixel in less than a tenth of a second for \(k=3\). Processing an image at this rate is usually considered real time [19], meaning that this estimation can be performed as the images are being acquired. As \(k\) increases, the map computation becomes slower, but it is still quickly accomplished for low \(k\).

## V Conclusion

We proposed a neural-network based algorithm for roughness estimation in \(G_{I}^{0}\) modeled SAR data, a task that is increasingly crucial in SAR image understanding. Practically, it consists of using log-moments from the samples as the input of a network that, when trained, outputs the underlying roughness value. This same network can be easily adapted to process SAR images, from moment computation to parameter estimation, leading to quick estimation of pixel-level roughness. We empirically demonstrate that such networks trained on purely synthetic data are able to outperform traditional estimation methods and return reliable roughness maps from high resolution SAR images in real time. Overall, this result shows that one can use cheap synthetic data to train performant networks for SAR imaging tasks, where labeled data acquisition is expensive. SAR data is in fact ideal for this approach, since there are good statistical models for them that allow the generation of synthetic training data, and they are structured such that important operations on them can be implemented on GPUs. Future work will consist of applying similar techniques to other data domains, where these aspects can also be found.
