Transferability of Convolutional Neural Networks in Stationary Learning
  Tasks
Recent advances in hardware and big data acquisition have accelerated the
development of deep learning techniques. For an extended period of time,
increasing the model complexity has led to performance improvements for various
tasks. However, this trend is becoming unsustainable and there is a need for
alternative, computationally lighter methods. In this paper, we introduce a
novel framework for efficient training of convolutional neural networks (CNNs)
for large-scale spatial problems. To accomplish this we investigate the
properties of CNNs for tasks where the underlying signals are stationary. We
show that a CNN trained on small windows of such signals achieves a nearly
performance on much larger windows without retraining. This claim is supported
by our theoretical analysis, which provides a bound on the performance
degradation. Additionally, we conduct thorough experimental analysis on two
tasks: multi-target tracking and mobile infrastructure on demand. Our results
show that the CNN is able to tackle problems with many hundreds of agents after
being trained with fewer than ten. Thus, CNN architectures provide solutions to
these problems at previously computationally intractable scales.
Damian Owerko, Charilaos I. Kanatsoulis, Jennifer Bondarchuk, Donald J. Bucci Jr, Alejandro Ribeiro
# Transferability of Convolutional Neural Networks in Stationary Learning Tasks

###### Abstract

Recent advances in hardware and big data acquisition have accelerated the development of deep learning techniques. For an extended period of time, increasing the model complexity has led to performance improvements for various tasks. However, this trend is becoming unsustainable and there is a need for alternative, computationally lighter methods. In this paper, we introduce a novel framework for efficient training of convolutional neural networks (CNNs) for large-scale spatial problems. To accomplish this we investigate the properties of CNNs for tasks where the underlying signals are stationary. We show that a CNN trained on small windows of such signals achieves a nearly performance on much larger windows without retraining. This claim is supported by our theoretical analysis, which provides a bound on the performance degradation. Additionally, we conduct thorough experimental analysis on two tasks: multi-target tracking and mobile infrastructure on demand. Our results show that the CNN is able to tackle problems with many hundreds of agents after being trained with fewer than ten. Thus, CNN architectures provide solutions to these problems at previously computationally intractable scales.

 convolutional neural networks, transfer learning, deep learning, stationary process

## I Introduction

How much longer can we sustain the growing dataset size and model complexity? Over the past decade, we have seen rapid advancements in deep learning, which produced state-of-the-art results in a wide range of applications [3, 4, 5]. In large part, these successes are due to increasingly powerful hardware [3, 4] that enabled processing larger datasets [6] and training deep learning models with more parameters.

Recently, this trend has been taken to new extremes with the advent of large language models [7, 8, 9, 10]. For example, GPT-3 was trained on a dataset with approximately 374 billion words and has 175 billion parameters [7]. However, this strategy is not sustainable due to diminishing returns and increasing cost of computation and data acquisition [11, 12]. Moreover, in applications with a limited amount of data, training such large models is impractical. A natural question that arises, is whether we can build computationally efficient models, that maintain the favorable properties of deep learning. In this paper, we give an affirmative answer and develop an analytical and computational framework that uses fully convolutional models and transfer learning.

Convolutional neural networks (CNNs) are one of the most popular deep learning architectures [4], especially for image classification [13]. Though initially used for image processing, they have proven useful for a wide variety of other signals such as text, audio, weather, ECG data, traffic data, and many others [4, 14, 15]. Despite the recent increased interest in transformer-based models [5], convolutions continue to play an important role under the hood of novel architectures. For example, the autoencoder in latent diffusion models [16] is fully convolutional [17].

Transfer learning, on the other hand, is a set of methodologies that exploit knowledge from one domain to another [18, 19]. The works in [20, 21] taxonomize a wide range of transfer learning approaches. One common transfer learning approach is _parameter transfer_, where a model is pre-trained to perform one task and then some or all of its parameters are reused for another task. This process allows a model to grasp intricate patterns and features present in one domain and apply that knowledge to a different, but related domain. For example, the work in [22] employs parameter transfer to improve CNN performance on medical images by pre-training on ImageNet. Yet, the true power of transfer learning transcends mere performance improvements. It offers an opportunity to construct highly efficient and lightweight solutions, which is crucial in large-scale systems with high computational needs or constrained resources. In the context of graph neural networks, transfer learning has been explored, both theoretically and experimentally, for large-scale graphs [23]. Training on small graphs and transferring to larger graphs is a promising approach [24, 25]. However, this flavor of transfer learning has been underexploited for CNNs, with a few exceptions; [26] shows that training on CIFAR can be decomposed into training on smaller patches of images.

In this paper, we fill this gap and develop a novel theoretical and computational framework to tackle large-scale spatial problems with transfer learning and CNNs. In particular, we train a CNN model on a small version of a spatial problem and transfer it to an arbitrarily large problem, without re-training. To justify this approach we leverage the shift-equivariance property of CNNs and analyze their performance at arbitrarily large scales. Note that, many machine learning tasks are shift-equivariant in some sense. For instance, in image segmentation, if the input image is translated the output will move accordingly. Other systems exhibit this phenomenon, including financial [27], weather [28], and multi-agent systems [1].

Our analysis studies CNNs when the input-output pairs are stationary processes over space or time. This is motivated
by the fact that, in stochastic process theory, shift-invariance is equivalent to stationarity [29] and shift-equivariance is equivalent to joint stationarity of the input and output signals. We demonstrate that a CNN can be efficiently trained for tasks with jointly stationary inputs and outputs. To accomplish this, we prove a bound on the generalization error of a fully convolutional model when trained on small windows of the input and output signals. Our theory indicates that such a model can be deployed on arbitrarily large windows on the signals, with minimal performance degradation.

To support this analysis we conducted numerical experiments on two tasks: multi-target tracking [30] and mobile infrastructure on demand [31, 32]. In both problems, the inputs and outputs are finite sets, which we reinterpret as image-to-image tasks. We describe this method in detail to show how to apply our framework to a broad class of spatial problems. Overall, our contributions can be summarized as follows.

* Present a transfer learning framework for efficient training of CNNs for large-scale spatial problems.
* Prove a bound for the generalization error of a CNN trained under this framework.
* Describe a methodology to apply CNNs to non-image problems.
* Demonstrate the effectiveness of the framework in multi-target tracking and mobile infrastructure on demand.

## II Learning to process stationary signals

The following is a common machine learning (ML) problem that becomes challenging when signals have infinite support. Given an input-output signal pair \((X,Y)\), the task is to find a model \(\mathbf{\Phi}(\cdot)\) that minimizes the mean squared error (MSE) between \(\mathbf{\Phi}(X)\) and \(Y\). Let \(X\) and \(Y\) be random functions of a vector parameter \(\mathbf{t}\in\mathbb{R}^{d}\), which can represent time, space, or an abstract \(d\)-dimensional space. Mathematically, this is a minimization problem with loss

\[\mathcal{L}_{1}(\mathbf{\Phi})=\mathbb{E}\left[\int_{\mathbb{R}^{d}}|\mathbf{ \Phi}(X)(\mathbf{t})-Y(\mathbf{t})|^{2}d\mathbf{t}\right], \tag{1}\]

where \(\mathbf{\Phi}(X)(\mathbf{t})\) is the output of the model at \(\mathbf{t}\). When the signals have infinite support, the integral may diverge. To accommodate this, the MSE can be redefined as,

\[\mathcal{L}_{2}(\mathbf{\Phi})=\mathbb{E}\left[\lim_{T\rightarrow\infty}\frac{ 1}{T^{d}}\int_{\mathcal{C}^{d}_{T}}|\mathbf{\Phi}(X)(\mathbf{t})-Y(\mathbf{t} )|^{2}d\mathbf{t}\right], \tag{2}\]

where \(C^{d}_{T}\) is an open set of the points in \(\mathbb{R}^{d}\) within a \(T\)-wide hypercube, centered around the origin. The primary difference between (1) and (2) is the normalization by the hypercube volume \(T^{d}\). This extends the MSE to infinite signals where (1) diverges. Practically, large values of \(T\) represent situations where signals are too wide to be computationally tractable.

This paper explores how to solve the problem of minimizing (2). Numerically evaluating and minimizing (2) is intractable in general. To overcome this limitation, Section II-C shows that if \(\mathbf{\Phi}(\cdot)\) is a CNN trained on small windows of the signals, then (2) is bounded by the training loss of the small window plus a small quantity. To accomplish this \(X,\ Y\) are modeled as jointly stationary random signals and the output of the CNN \(\mathbf{\Phi}(X)\) is analyzed. Before this analysis is presented in II-C, the following sections define stochastic processes, stationarity, and CNNs.

### _Jointly Stationary Stochastic Processes_

We focus on continuous stationary stochastic processes with a multidimensional index. In this context, a stochastic process [29, 33, 34] is a family of random variables \(\{X(\mathbf{t})\}_{\mathbf{t}\in\mathbb{R}^{d}}\) indexed by a parameter \(\mathbf{t}\in\mathbb{R}^{d}\). One of the key assumptions in the analysis is joint stationary between signals \(X\) and \(Y\). Two continuous random signals are jointly stationary if all their finite joint distributions are shift-invariant.

**Definition 1**.: _Consider two real continuous stochastic processes \(\{X(\mathbf{t})\}_{\mathbf{t}\in\mathbb{R}^{d}}\) and \(\{Y(\mathbf{t})\}_{\mathbf{t}\in\mathbb{R}^{d}}\). The two processes are jointly stationary if and only if they satisfy (3) for any shift \(\boldsymbol{\tau}\in\mathbb{R}^{d}\), non-negative \(n,m\in\mathbb{N}_{0}\), indices \(\mathbf{t}_{i},\mathbf{s}_{i}\in\mathbb{R}^{d}\), and Borel sets of the real line \(A_{i},B_{i}\)._

\[\begin{split}& P(X(\mathbf{t}_{1})\in A_{1},...,X(\mathbf{t}_{ n})\in A_{n},...,Y(\mathbf{s}_{m})\in B_{m})\\ &=P(X(\mathbf{t}_{1}+\boldsymbol{\tau}),...,X(\mathbf{t}_{n}+ \boldsymbol{\tau})\in A_{n},...,Y(\mathbf{s}_{m}+\boldsymbol{\tau})\in B_{m}) \end{split} \tag{3}\]

Modeling \(X\) and \(Y\) as jointly stationary stochastic processes in \(d\)-dimensions has practical applications in many domains. Numerous signals can be represented by stationary or quasi-stationary processes. Examples include signals in financial [27], weather [28], sensor network [35] and multi-agent systems [1]. Therefore, understanding the performance of ML models for stationary signal processing has widespread importance. CNNs are of particular interest because they admit translational symmetries similar to jointly stationary signals. The following analysis attempts to demystify their performance and broaden our knowledge of how to train CNNs efficiently.

### _Convolutional Neural Networks_

CNNs are versatile architectures, heavily used to minimize (1) - typically to perform image processing. A CNN is a cascade of non-linear functions, called layers. The output of the \(l^{\text{th}}\) is defined recursively:

\[x_{l}(\mathbf{t})=\sigma\left(\int_{\mathbb{R}^{d}}h_{l}(\mathbf{s})x_{l-1}( \mathbf{t}-\mathbf{s})d\mathbf{s}\right). \tag{4}\]

At each layer, the output \(x_{l}\) is obtained by convolving the previous output \(x_{l-1}\) by a function \(h_{l}\) and applying a pointwise nonlinearity \(\sigma\). As the name suggests, convolution operations are the cornerstone of the architecture. They are the key to exploiting spatial symmetries since they are shift-equivariant. The CNN has \(L\) layers and is parametrized by a set of functions \(\mathcal{H}=\{h_{1},...,h_{L}\}\), also known as parameters. Let

\[\mathbf{\Phi}(X;\mathcal{H})(t)\coloneqq x_{L}(t) \tag{5}\]

represent a CNN with output \(x_{L}\) and input \(x_{0}\coloneqq X\). Then the loss function in (2) can be rewritten as a function of these parameters.

\[\mathcal{L}_{\infty}(\mathcal{H})=\mathbb{E}\left[\lim_{T\rightarrow\infty}\frac {1}{T^{d}}\int_{\mathcal{C}^{d}_{T}}|\mathbf{\Phi}(X;\mathcal{H})(\mathbf{t})- Y(\mathbf{t})|^{2}d\mathbf{t}\right] \tag{6}\]
In general, evaluating (6) is as challenging as evaluating (2), but the following two assumptions make this possible. First, the input and output signals have a stationary property. Second, the model \(\mathbf{\Phi}\) is a CNN. The next section presents our main theoretical result, which discusses how the CNN can be efficiently trained on narrow signal windows, but evaluated on arbitrarily wide signals without sacrificing performance.

### _Training on a window_

Instead of minimizing (6) directly, which is computationally prohibitive, we propose to train the CNN on narrow windows of the signals \(X,\ Y\). In particular, we can rewrite (6) to consider finite windows over the signals:

\[\mathcal{L}_{\cap}(\mathcal{H})=\frac{1}{B^{d}}\mathbb{E}\left[\int_{\mathcal{ C}_{B}^{d}}|\mathbf{\Phi}(\cap_{A}X;\mathcal{H})(\mathbf{t})-Y(\mathbf{t})|^{2} dt\right], \tag{7}\]

where \(\cap_{s}(\mathbf{t})\coloneqq 1(\mathbf{t}\in\mathcal{C}_{s}^{d})\) is an indicator function that is equal to one whenever \(\mathbf{t}\) is within a \(s\)-wide hypercube. Minimizing (7) is equivalent to learning a model between \(\cap_{A}X\) and \(\cap_{B}Y\). These are windowed versions of the original signals, with window widths \(A\) and \(B\), respectively. We will only consider \(A\geq B\) so that the input is wider than the output of the CNN. Most practical CNN architectures either shrink their input width or keep it constant because padding at each convolutional layer introduces boundary effects.

Unlike (6), the problem in (7) can be readily computed numerically because the inputs and outputs have finite support. Therefore optimizing the set of parameters \(\mathcal{H}\) with respect to \(\mathcal{L}_{\cap}\) is possible in practice using stochastic gradient descent, as shown in Sections V and VI. The window sizes \(A\) and \(B\) can be chosen to maximize training performance. For example, one might want the signals to be wide enough to saturate GPU computing while being small enough to fit into memory.

To summarize, we want to find a model \(\mathbf{\Phi}(X;\mathcal{H})\) that approximates a map from \(X\) to \(Y\), described by the loss function \(\mathcal{L}_{\infty}(\mathcal{H})\) in (6). However, minimizing \(\mathcal{L}_{\infty}(\mathcal{H})\) is challenging, especially when the signals involved are of large scale (very wide). Instead, we propose to train the CNN model using \(\mathcal{L}_{\cap}(\mathcal{H})\), which is easy to compute. Our proposed approach is theoretically justified by our novel theoretical analysis that provides an upper bound on \(\mathcal{L}_{\infty}\) in terms of \(\mathcal{L}_{\cap}\), i.e.,

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\mathcal{L}_{\cap}(\hat{\mathcal{H }})+C. \tag{8}\]

To derive this bound, let \(\hat{\mathcal{H}}\) be a set of parameters with associated windowed loss \(\mathcal{L}_{\cap}(\hat{\mathcal{H}})\), which can be obtained by minimizing (7) or other training procedure. Given the following assumptions, we show that \(\hat{\mathcal{H}}\) performs almost as well on signals with infinite support - in terms of (6).

**Assumption 1**.: _The random signals \(X\) and \(Y\) are jointly stationary following Definition 1._

In many important application domains, signals are at least approximately stationary, which makes our result directly applicable to these cases. Such a result also offers theoretical insights into the fundamental understanding and explainability of CNNs.

**Assumption 2**.: _The model \(\mathbf{\Phi}(X;\mathcal{H})\) is a convolutional neural network as defined by (4) with a set of parameters \(\mathcal{H}\)._

Given that the signals under consideration exhibit stationarity, it is appropriate to use a convolutional model, which is shift equivariant and is able to exploit stationarity. Assumptions 1 and 2 are the two keys to our analysis. The remaining assumptions are very mild and typical for model analysis.

**Assumption 3**.: _The stochastic processes \(X\) and \(Y\) are bounded so that \(|X(\mathbf{t})|<\infty\) and \(|Y(\mathbf{t})|<\infty\) for all \(\mathbf{t}\in\mathbb{R}^{d}\)._

Boundedness of the signals is a sufficient condition for the existence and finiteness of some limits. The magnitude of the bound is inconsequential to the final result.

**Assumption 4**.: _The filter functions \(h_{l}\in\mathcal{H}\) are continuous with a finite width \(K\). That is \(h_{l}(\mathbf{t})=0\) for all \(\mathbf{t}\notin[-K/2,K/2]^{d}\)._

**Assumption 5**.: _The filters have finite \(L1\) norms \(||h_{l}||_{1}\leq\infty\) for all \(h_{l}\in\mathcal{H}\)._

Assumptions 4 and 5 satisfied in typical CNN implementations since the CNN filters are finite in practice.

**Assumption 6**.: _The nonlinearities \(\sigma(\cdot)\) are normalized Lipschitz continuous, so that the Lipshitz constant is equal to 1. Mathematically this means that \(|\sigma(x)-\sigma(y)|\leq|x-y|\) for any \(x,y\in\mathbb{R}\)._

Note that the majority of pointwise nonlinear functions used in deep learning, e.g., ReLU, Leaky ReLU, hyperbolic tangent, are normalized Lipshitz for numerical stability.

Under these assumptions, Theorem 1 provides a bound on the generalization error \(\mathcal{L}_{\infty}\) of a CNN trained on a finite window and tested on an infinite window.

**Theorem 1**.: _Let \(\hat{\mathcal{H}}\) be a set of filters that achieves a cost of \(\mathcal{L}_{\cap}(\hat{\mathcal{H}})\) on the windowed problem as defined by (7) with an input window of width \(A\) and an output window width \(B\). Under Assumptions 1-6, the associated cost \(\mathcal{L}_{\infty}(\hat{\mathcal{H}})\) on the original problem as defined by (6) is bounded by the following._

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\mathcal{L}_{\cap}(\hat{\mathcal{H }})+\mathbb{E}\left[X(0)^{2}\right]C+\sqrt{\mathcal{L}_{\cap}(\hat{\mathcal{H }})\mathbb{E}\left[X(0)^{2}\right]C} \tag{9}\]

\[C=\frac{H^{2}}{B^{d}}\max\left(0,[B+LK]^{d}-A^{d}\right) \tag{10}\]

_In (9), \(H=\prod_{l}^{L}||h_{l}||_{1}\) is the product of all the L1 norms of the CNNs filters, \(L\) is the number of layers, and \(K\) is the width of the filters._

The proof is provided in Appendix A. The derivation exploits shift-equivariance of CNNs, which preserve joint stationarity of the signals. Theorem 1 shows that minimizing \(\mathcal{L}_{\infty}\) can be approximated by instead minimizing \(\mathcal{L}_{\cap}\). The maximum deterioration in performance is bounded by a quantity that is affected by the variance of the input signal, number of layers, filter widths, and the size of the input and output windows. The inequality in (9) reduces to \(\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\mathcal{L}_{\cap}(\hat{\mathcal{H }})\) whenever \(A\geq B+LK\). In this special case, the output becomes
unaffected by padding, which explains the last two terms on the right-hand side of (9).

## III Representing Sparse Problems as Mixtures

CNNs are well suited to processing images or, more generally, multi-dimensional signals. In various spatial problems [1, 31, 32, 32], the decision variables are finite sets of real vectors with random cardinality such as \(\mathcal{X}=\{\mathbf{x}\in\mathbb{R}^{d}\}\). Therefore, in this section we propose a method to represent sets of vectors such as \(\mathcal{X}\) by multi-dimensional signals \(X(\mathbf{t};\mathcal{X}):\mathbb{R}^{d}\mapsto\mathbb{R}\).

Representing the sets by a superposition of Gaussian pulses is an intuitive approach. Specifically,

\[X(\mathbf{t};\mathcal{X})\coloneqq\sum_{\mathbf{x}\in\mathcal{X}}(2\pi\sigma _{X}^{2})^{-1}\exp(-\frac{1}{2\sigma_{X}^{2}}||\mathbf{t}-\mathbf{x}||_{2}^{2 }). \tag{11}\]

where there is one pulse with variance \(\sigma_{X}^{2}\) for each element in the set. The second image in Figure 1 exemplifies this.

This approach can be made more general by incorporating additional information about the distribution of the set. Assume that each element \(\mathbf{x}\in\mathcal{X}\) is in fact a sample from a distribution that depends on \(\mathbf{t}\). The density function \(g(\mathbf{x}\mid\mathbf{t})\) describes this dependence. For example, when \(\mathbf{x}\) is a noisy measurement of some underlying quantity \(g(\mathbf{x}\mid\mathbf{t})\) describes the likelihood of sampling \(\mathbf{x}\) given \(\mathbf{t}\) as the ground truth. There could exist multiple sensors making measurements, each with a different density function \(g_{i}(\mathbf{x}\mid\mathbf{t})\). Denote \(x_{i}\in\mathcal{X}\) to make it clear that each element in \(\mathcal{X}\) is associated with some density function \(g_{i}\). Therefore the intensity function \(X(\mathbf{t};\mathcal{X})\) can be written as a sum over these densities:

\[X(\mathbf{t};\mathcal{X})\coloneqq\sum_{\mathbf{x}_{i}\in\mathcal{X}}g_{i}( \mathbf{x}_{i}|\mathbf{t}). \tag{12}\]

The function \(g_{i}\) is sometimes known as a _measurement model_. In the first image in Figure 1, the measurements contain noise applied in polar coordinates around sensors. This results in an arc-shaped distribution. Notice that (11) is a special case (12) when the distribution is Gaussian.

In practice, we window and discretize the intensity function \(X(\mathbf{t};\mathcal{X})\). The function is windowed to width \(T\) around zero and sampled with resolution \(\rho\). This produces a \(d\)-dimensional tensor \(\mathbf{X}\in\mathbb{R}^{N^{d}}\) with width \(N=\lfloor\rho T\rfloor\) along each dimension. Similarly, given a set \(\mathcal{Y}=\{\mathbf{y}\in\mathbb{R}^{d}\}\) we construct a tensor \(\mathbf{Y}\in\mathbb{R}^{N^{d}}\). This allows training a CNN to learn a mapping between \(\mathbf{X}\) and \(\mathbf{Y}\).

To summarize, our original problem was to model the relationship between \(\mathcal{X}\) and \(\mathcal{Y}\). These are random sets and we assume that there exists a dataset of their realizations. We can represent each pair in this dataset as a tensor \(\mathbf{X}\) and \(\mathbf{Y}\), respectively. Therefore, we can use a CNN to learn a map between these tensors. Hopefully, we find parameters so that \(\hat{\mathbf{Y}}:=\mathbf{\Phi}(\mathbf{X};\mathcal{H})\) is close to \(\mathbf{Y}\). However, we also need a method to recover an estimate of \(\mathcal{Y}\) from \(\hat{\mathbf{Y}}\), the output of our CNN.

To achieve this, we propose the following approach. Assume that \(\mathbf{Y}\) is obtained by following (11) and discretizing; this is the case in our experiments. Notice that the L1 norm of the output image \(||Y(\mathbf{t};\mathcal{Y})||_{1}=|\mathcal{Y}|\) is by construction equal to the cardinality of \(\mathcal{Y}\). If during discretization we preserve the L1 norm, then \(\mathbf{Y}\) has a similar property for all elements of \(\mathcal{Y}\) within the window. If CNN training is successful then \(\hat{\mathbf{Y}}\) will retain this property. Since we know the number of Gaussian components, we can use k-means clustering or fit a Gaussian mixture via expectation maximization. In our implementation, we use the subroutines provided by Scikit-Learn [36].

## IV Architecture

Theorem 1 suggests that training a CNN on small, representative windows of multi-dimensional input-output signals is effective at learning a mapping between the original signal pairs. Such as CNN can later generalize to arbitrary scales by leveraging the shift equivariance property of CNNs. In this section, we describe a fully convolutional architecture for the processing of multi-dimensional signals.

Fig. 1: Example 2D signals from multi-target tracking; see Section V for a full problem description. _(Sensor Measurements)_\(\bar{\mathbf{Z}}_{n}\) represents the measurements made by the sensors in one time-step – their positions are marked in red. The sensors are modeled as range-bearing with additive noise, therefore in Cartesian coordinates, the distribution has a distinct banana shape. This example was cherrypicked to show multiple sensors in the 1km\({}^{2}\) area, but in simulations the sensors can be up to \(R\) meters outside this area. _(Target Positions)_: \(\mathbf{X}_{n}\) represents the ground truth positions of all the targets. _(CNN Output)_: \(\mathbf{\Phi}(\bar{\mathbf{Z}}_{n};\hat{\mathcal{H}})\) is the output of the trained CNN. The CNN is trained to approximate the target positions image, given the past \(K\) sensor measurement images.
### _Fully convolutional encoder-decoder_

The inputs and outputs of the architecture are multidimensional signals:

\[\mathbf{X} \in\underbrace{\mathbb{R}^{N}\times\cdots\times\mathbb{R}^{N}}_{d \text{ times}}\times\mathbb{R}^{F_{0}}\] \[\text{and}\quad\mathbf{\Phi}(\mathbf{X},\mathcal{H}) \in\underbrace{\mathbb{R}^{N}\times\cdots\times\mathbb{R}^{N}}_{d \text{ times}}\times\mathbb{R}^{F_{L}}\]

with \(F_{0}\) and \(F_{L}\) features, respectivelly. The first \(d\) dimensions are the translationally symmetric space where the task takes place. To process these signals we propose a fully convolutional encoder-decoder architecture as shown in Figure 2. The proposed architecture is organized into three sequential components: the encoder, the hidden block, and the decoder. Each of these components contains several layers with \(L\) in total. The input to the first layer is \(\mathbf{X}\) and the output of the final layer is \(\mathbf{\Phi}(\mathbf{X},\mathcal{H})\). Each layer contains a convolution, a pointwise nonlinearity, and possibly a resampling operation.

Convolution operations are the first component of every layer. The input to the \(l^{\text{th}}\) layer is a tensor \(\mathbf{X}_{l-1}\) of order \(d+1\), such that \(\mathbf{X}_{l-1}[\mathbf{n}]\in\mathbb{R}^{F_{l-1}}\) with \(F_{l-1}\) features and index \(\mathbf{n}\in\mathbb{Z}^{d}\). This input is passed through a multiple-input multiple-output convolutional filter

\[\mathbf{Z}_{l}[\mathbf{n}]=\sum_{\mathbf{m}\in\mathbb{Z}^{d}}\mathbf{H}_{l}[ \mathbf{m}]\mathbf{X}_{l-1}[\mathbf{n}-\mathbf{m}], \tag{13}\]

to obtain an intermediate output \(\mathbf{Z}_{l}[\mathbf{n}]\in\mathbb{R}^{F_{l}}\) with \(F_{l}\) features. In (13), \(\mathbf{H}_{l}\) is a high-order tensor with \(\mathbf{H}_{l}[\mathbf{n}]\in\mathbb{R}^{F_{l}\times F_{l-1}}\) representing a filter with a finite width \(K\). As a result, the filter output \(\mathbf{Z}_{l}\) is also a high-order tensor with finite width that is indexed by \(\mathbf{n}\in\mathbb{Z}^{d}\).

The encoder and decoder are mirror images of each other. The encoder downsamples the signal, while the decoder upsamples it. This effectively compresses the signal, so that the hidden block can efficiently process it. Each encoder layer is composed of a convolutional layer, as defined in (13), followed by a downsampling operation and a pointwise nonlinearity:

\[\mathbf{X}_{l}[\mathbf{n}]=\sigma\left(\mathbf{Z}_{l}[M\mathbf{n}]\right). \tag{14}\]

Each layer in the encoder downsamples the input by a factor of \(M\). Conversely, the decoder upsamples its inputs by the same factor. Much like an encoder layer, each decoder layer contains a convolution followed by an upsampling operation and a pointwise nonlinearity:

\[\mathbf{X}_{l}[\mathbf{n}]=\sigma\left(\mathbf{Z}_{l}[\mathbf{n}/M]\right). \tag{15}\]

In (15), the use of square brackets in \(\mathbf{Z}_{l}[\mathbf{n}/M]\) indicates that the index is rounded to the nearest integer.

The hidden block layers are interposed between the encoder and decoder. Each hidden layer is composed of a convolution followed by a pointwise nonlinearity:

\[\mathbf{X}_{l}[\mathbf{n}]=\sigma\left(\mathbf{Z}_{l}[\mathbf{n}]\right). \tag{16}\]

They are similar to the encoder and decoder layers, but they do not contain any resampling operations.

The proposed encoder-decoder architecture has two main benefits. First, it is compatible with Theorem 1 because it is fully convolutional. Therefore, it preserves the stationarity of the input signals [37]. Second, it allows for efficient processing of multi-dimensional signals. The encoder downsamples the input signal, reducing the amount of computation needed in the hidden block. Afterwards, the decoder upsamples the processed signal back to the original representation. This compression is especially beneficial for our experiments because, as can be seen from figure 1, the tasks we consider have sparse input and output signals.

### _Hyperparameters_

In practice, we found the following hyperparameter values to be effective in our simulations. Our encoder and decoder layers have filters with width \(K=9\), \(F_{l}=128\) channels, and a resampling factor of \(M=2\). Meanwhile, each hidden layer uses filters with width \(K=1\) and \(F_{l}=1024\) channels. We use three encoder layers, four hidden layers, and three decoder layers. In Section V we will elaborate on how we arrived at these hyperparameters.

There are several possible practical methods of downsampling and upsampling in the encoder and decoder blocks. In our best-performing variant of the architecture, we combine them with convolutions. In the encoder, we use a convolution with a stride of two. Meanwhile, in the decoder, we use transpose convolutions with a stride of two. This approach is

Fig. 2: Diagram of the proposed CNN architecture. Above we depict a CNN with two encoder, hidden, and decoder layers. This illustrates the architecture but is different from the configuration used in the experiments.
used in [16], although it is prone to producing checkerboard artifacts [38]. Alternatively, the downsampling can be performed separately or using a pooling layer such as average pooling. Similarly, the transpose convolutions can be replaced by an upsampling or interpolation layer followed by a convolution. However, in our simulations, we found this approach to be less performant, although it allowed training to converge slightly faster.

## V Multi Target Tracking

Multi-target tracking (MTT) is a type of sequential estimation problem where the goal is to jointly determine the number of objects and their states from noisy, discrete-time sensor returns. Such sensor returns can include the pulse energy observed across a series of sampled time delays in radar systems or the pixel intensities observed from a camera system. It is distinct from _state filtering_ in that object appearance and disappearance (i.e., birth and death) must be addressed in the problem formulation. We direct the reader to [30] for a detailed overview of the field and the relevant application areas.

We focus on the canonical application known as _point object tracking_ where sensor returns are quantized via a detection process into measurements before the tracker is applied. To make the problem definition more precise, we introduce notation for the multi-target state and measurement sets at the \(n^{\text{th}}\) time-step. Let the _multi-target state_ be denoted by the set, \(\mathcal{X}_{n}\). Each element of this set represents the state of a target in some space. At each time step each sensor will produce noisy measurements of the targets, resulting in a set \(\mathcal{Z}_{n}\) of measurements in a different space. The goal in MTT is to estimate the multi-target state \(\mathcal{X}_{n}\) given all the preceding measurements \(\mathcal{Z}_{1},...,\mathcal{Z}_{n}\). The principal challenge in this task is _measurement origin uncertainty_; it is not known _a priori_ which measurements were generated by true targets, were the result of an independent clutter process (false positive) or did not generate measurements (false negative). A direct Bayesian solution to the measurement origin uncertainty problem with multiple sensors requires solving an NP-hard multi-dimensional ranked assignment problem [39].

Algorithms in this area are well-studied and include global nearest neighbor techniques [40], joint probabilistic data association [41], multi-hypothesis tracking [42], and belief propagation [43]. Recently random finite sets (RFS) have emerged as a promising all-in-one Bayesian framework that addresses the measurement origin uncertainty problem jointly [44, 45]. In particular, _labeled RFS_ were introduced in [46] specifically for MTT, resulting in the Generalized Labeled Multi-Bernoulli (GLMB) [47, 48] and Labeled Multi-Bernoulli (LMB) [49, 50] filters. However, the GLMB and LMB filters exhibit exponential complexity in the number of sensors [39, 48, 51].

Our proposed analytical and computational framework is an excellent fit to overcome these scalability issues for two reasons: (i) it is independent of the number of sensors and targets within a specific region and (ii) it can leverage transfer learning to perform MTT in large areas. The proposed CNN tracker is trained on a small \(1\text{km}^{2}\) area and tested on larger areas up to \(25\text{km}^{2}\) where the number of sensors and targets are increased proportionally to maintain a fixed density of each. The computational complexity of this approach is proportional to the simulation area rather than the number of targets and sensors. Based on Theorem 1, we would expect the tracking performance from training to be maintained as this scaling up is carried out.

### _Modeling targets and sensors_

The multi-target state changes over time. First, new targets may be born according to a Poisson distribution with mean \(\lambda_{\text{birth}}\). Second, old targets may disappear with probability \(p_{\text{death}}\). Finally, the existing target's state evolves over time. In our simulations we use a (nearly) constant velocity (CV) model [52, 53]. In the CV model the state \(\mathbf{x}_{n,i}\in\mathcal{X}\) at time-step \(n\) of the \(i^{\text{th}}\) target is given by (17).

\[\mathbf{x}_{n,i}=\begin{bmatrix}\mathbf{p}_{n,i}&\mathbf{v}_{n,i}\end{bmatrix} \tag{17}\]

A target state is composed of its position \(\mathbf{p}_{n,i}\in\mathbb{R}^{2}\) and velocity \(\mathbf{v}_{n,i}\in\mathbb{R}^{2}\). The state evolves according to (18).

\[\Delta\mathbf{p}_{n,i} =\tau\hat{\mathbf{p}}_{n,i}+\frac{\tau^{2}}{2}\boldsymbol{\mu}_{ n,i} \tag{18}\] \[\Delta\mathbf{v}_{n,i} =\tau\boldsymbol{\mu}_{n,i}\]

The CV model is discretized with time-step \(\tau\) seconds. Also, note that the acceleration \(\boldsymbol{\mu}_{n,i}\in\mathbb{R}^{2}\) is sampled from a multivariate normal distribution,

\[\boldsymbol{\mu}_{n,i}\sim\mathcal{N}\left(0,\left[\begin{smallmatrix}\sigma_ {a}^{2}&0\\ 0&\sigma_{a}^{2}\end{smallmatrix}\right]\right). \tag{19}\]

There are \(M\) sensors that provide measurements of the multi-target state. Consider the \(j^{\text{th}}\) sensor with position \(\mathbf{s}_{j}\in\mathbb{R}^{2}\). If a target with state \(\mathbf{x}_{n,i}\in\mathcal{X}_{n}\) is within the sensor's radial range of \(R\) km, then at each time step the sensor may detect the target with probability \(p_{\text{detect}}\). When this occurs then a corresponding measurement \(\mathbf{z}_{n,i}^{j}\) is added to the measurement set \(\mathcal{Z}_{n}\). Multiple sensors can detect the same target, but each can provide at most one detection per target. The measurement \(\mathbf{z}_{n,i}^{j}\) is stochastic and its distribution is known as the _measurement model_. In our simulations, the measurement model is range-bearing relative to the position of the \(j^{\text{th}}\) sensor:

\[\mathbf{z}_{n,i}^{j}\sim\mathcal{N}\left(\begin{bmatrix}||\mathbf{p}_{n,i}- \mathbf{s}_{j}||\\ \left(\mathcal{Z}_{n,i}-\mathbf{s}_{j}\right)\end{bmatrix},\begin{bmatrix} \eta_{r}^{2}&0\\ 0&\eta_{\theta}^{2}\end{bmatrix}\right). \tag{20}\]

The measurements are Gaussian distributed with a mean equal to the distance and bearing to the target. The covariance matrix is diagonal with a standard deviation of \(\eta_{r}\) meters in range and \(\eta_{\theta}\) radians in angle. Additionally, clutter is added to the measurement set \(\mathcal{Z}_{n}\). The number of clutter measurements is Poisson with mean \(\lambda_{\text{clutter}}\) per sensor. Clutter is generated independently for each sensor, with clutter positions sampled uniformly within its range.

### _Simulations_

To train the CNN we construct a dataset of images representing the MTT problem within a \(T=1\text{km}\) wide square window. Similarly, we construct a testing dataset for window
widths between 1km and 5km. For any particular window of width \(T\), constructing a dataset of images for training or testing is the same. First, we simulate the temporal evolution of the multi-target state \(\mathcal{X}_{n}\) and at each time step generate sensor measurements \(\mathcal{Z}_{n}\). Table I describes the parameters used for the simulations. At the beginning of each simulation we initialize \(\mathrm{Poisson}(\lambda_{\text{initial}})\) targets and \(\mathrm{Poisson}(\lambda_{\text{sensor}})\) sensors. Their positions are uniformly distributed within the simulation region, while the initial velocity for each target is sampled from \(\mathcal{N}(0,\sigma_{\text{v}}^{2})\).

Notice that sensors outside of the window \(T\) can make measurements of targets within the window. Unless we want to break our assumption of stationarity, we have to include these measurements as well. Thinking back to equation (6), the images should be a cropped version of some infinitely wide signal. Hence, it is actually necessary to simulate the targets and sensors over a window larger than \(T\). Luckily, the sensors have a finite range \(R\)km, so we run simulations over a square window of width \(2R+T\) - padding the simulation area by \(R\)km on each side. Similarly, we also keep track of targets that could be born outside Tkm window and targets that leave the window but might return.

To generate training data, we ran 10,000 simulations with 100 steps each at a window width of \(T=1\)km. We generate images \(\mathbf{Z}(\mathcal{Z}_{n})\) and \(\mathbf{X}(\mathcal{X}_{n})\) from \(\mathcal{Z}_{n}\) and \(\mathcal{X}_{n}\), respectivelly, using the procedure outlined in Section III. In this section, \(\mathbf{X}\) denotes the _output_ of the CNN for consistency with the literature. To provide temporal information, the input to the CNN is actually a stack of \(K=20\) past sensor measurement images:

\[\bar{\mathbf{Z}}_{n}\coloneqq\begin{bmatrix}\mathbf{Z}(\mathcal{Z}_{n-K+1})& \ldots&\mathbf{Z}(\mathcal{Z}_{n})\end{bmatrix}. \tag{21}\]

Data for \(n<K\) is excluded. We train the model for 84 epochs using AdamW [54] with a batch size of 32, a learning rate of \(6.112\times 10^{-6}\), weight decay of \(0.07490\). We arrived at these hyperparameters and the ones in Subsection IV-B by running a random search using the Optuna library [55]. The hyperparameters were sampled using the built-in tree-structured parzen estimator [56].

### _Baseline Approaches_

Our baseline for comparing the CNN's performance is defined by two state-of-the-art filters. The filters used are the sequential Monte Carlo multi-sensor iterated corrector formulation of the Labeled Multi-Bernoulli (LMB) and the \(\delta\)-Generalized Labeled Multi-Bernoulli (GLMB) [57]. The bearing-range measurement models, sensor generation, and dynamic model for the targets are the same as described in Subsection V-A.

Both filters used the Monte Carlo approximation for the adaptive birth procedure from [58]. The proposal distribution is created by decomposing the state space into observable (\(x_{o}\)) and unobservable (\(x_{u}\)) states, with observable (\(p_{B}^{o}(x_{o},l_{+})\)) and unobservable (\(p_{B}^{u}(x_{u},l_{+})\)) prior densities. For the observable states, \(\mathbb{X}_{o}\), an uninformative uniform prior distribution \(p_{B}^{o}(x_{o},l_{+})=\mathcal{U}(\mathbb{X}_{o})\) was used. The unobservable states, which for this scenario are the velocities, were sampled from a zero-mean Gaussian distribution:

\[p_{B}^{u}(x_{u},l_{+})=\mathcal{N}(x_{u};0,\begin{bmatrix}\sigma_{\text{v}}^{ 2}&0\\ 0&\sigma_{\text{v}}^{2}\end{bmatrix}). \tag{22}\]

As the scenario scaled up in the number of targets and sensors, the number of measurements increased significantly. To accommodate for this, the number of Gibbs iterations was increased for each scenario. Due to computational limitations, window sizes of \(T\in\{1,2,3\}\)km were used, with 2000, 4000, and 6000 Gibbs iterations, respectively. Every 10 Gibbs iterations the current solution was reset to the all miss-detected tuple, to encourage exploration.

### _Results_

To test the performance of the trained CNN we ran 100 simulations at each window size \(T\in\{1,2,3,4,5\}\)km and constructed images from them. Figure 3 shows example inputs and outputs of the CNN, picked at random during testing at each window size. We compare our results against state-of-the-art filters: Labeled Multi-Bernoulli (LMB) and Generalized Labeled Multi-Bernoulli (GLMB).

The output of the CNN and the output of the LMB and GLMB filters are not in the same space. Specifically, the output of the CNN filter is an image, whereas the LMB and GLMB filters output a set of vectors in \(\mathcal{X}\) and a set of weights. The vectors represent the estimated states of the targets, while the weights are their existence probability. This makes it difficult to compare the two. To draw a fair comparison, we consider two different metrics: the mean squared error (MSE) and optimal sub-pattern assignment (OSPA) [59].

In this context, the MSE is computed between the CNN output and the image representing the true target positions, as
defined by equation (11). We convert the LMB and GLMB outputs to image using a superposition of Gaussians, as described by equation (11). The only notable difference is that we weigh the Gaussians by the estimated existence probability. Figure 4 shows that the MSE of the CNN is unaffected as the window size increases. This directly supports Theorem 1. Moreover, this is the case even though our CNN implementation employs padding. Therefore, the practical effect of padding is lower than the second and third terms in (9) suggest.

However, MSE does not fairly compare the different approaches. The output of the MTT problem should be a set of estimates. OSPA [59], as defined in Definition 2, allows us to measure the average "distance" between two sets of vectors, possibly of different cardinalities. We use OSPA with a cutoff distance of \(c=500\) meters. We describe the method used to extract a set of vectors from the CNN output image in Section III.

**Definition 2**.: _(OSPA) If \(\mathcal{X}=\{\mathbf{x}_{i}\}_{i=1,...,n}\) and \(\mathcal{Y}=\{\mathbf{y}_{i}\}_{i=1,...,m}\) are two sets of vectors in \(\mathbb{R}^{d}\) with \(m\leq n\) then OSPA is defined as_

\[\text{OSPA}(\mathcal{X},\mathcal{Y},c)=\min_{\pi\in\Pi_{n}}\sqrt{\frac{1}{n} \left[\sum_{i=1}^{m}||\mathbf{x}_{i}-\mathbf{y}_{\pi_{i}}||_{2}^{2}+c(n-m) \right]}\]

_where \(c\) is some cutoff distance and \(\pi=[\pi_{1},...,\pi_{n}]\) is a permutation._

The CNN maintains consistent performance across scales and outperforms the GLMB and LMB filters. This claim is supported by Figure 5, which shows the OSPA for different values of \(T\) from testing. GLMB and LMB filters have comparable performance to the CNN at \(T=1\)km, but their performance degrades as the region is scaled up due to truncation issues. In contrast, the performance of the CNN improves at scale. Within a 1km\({}^{2}\) region the CNN obtains an OSPA of \(215\pm 73\) meters. This decreases to \(152\pm 39\) meters for a 25km\({}^{2}\) region.

We observe that our architecture has memory requirements that quickly increase for higher dimensional signals. In this section, we considered 2D signals with multiple input features representing time. However. we also attempted to process this as a 3D convolution over two spatial dimensions and time. In that case, while we were able to obtain preliminary results, we encountered significant memory bottlenecks. Sparse convolutions show promise in mitigating this challenge [60, 61].

## VI Mobile Infrastructure on Demand

In this section, we continue to evaluate the utility of our framework on a different problem, called mobile infrastructure on demand (MID). The overall goal in MID is to deploy a team _communication agents_ that provides a wireless network

Fig. 4: Comparison of MSE of the three filters for different window sizes \(T\). We report the mean value for 100 simulations at each scale. The error bars indicate a 0.95% confidence interval in the MSE.

Fig. 3: The input and output of the CNN at different window widths of \(T=\{1,...,5\}\)km [1]. To increase the contrast on this figure we rescaled the sensor image to \(\log(\mathbf{Z}(\mathcal{Z}_{n})+0.001)\), which is shown in the first row. The second row shows the corresponding output of the trained CNN, \(\mathbf{\Phi}(\mathbf{\hat{Z}}_{n};\mathcal{H}^{*})\), without any adjustments.
for a team of _task agents_. Below we describe the task, summarize previous works, and describe our experiments. There, as before, Theorem 1 motivates training a CNN on small examples but evaluating for large tasks.

The MID task is defined as follows. Let \(\mathcal{X}=\{\mathbf{x}\in\mathbb{R}^{2}\}\) be a set that represents the positions of the task agents. Denote the positions of the communication agents by a set \(\mathcal{Y}=\{\mathbf{y}\in\mathbb{R}^{2}\}\). The positions of the task agents are exogenous. The goal is to determine communication agent positions \(\mathcal{Y}\) that maximize connectivity between task agents. This task is static, unlike in MTT where system dynamics are simulated.

This problem was first formulated by [31] as a convex optimization problem. However, the time it takes to find a solution grows quickly with the total number of agents \(|\mathcal{X}|+|\mathcal{Y}|\). The runtime is 30 seconds for 20 agents [32] and can be extrapolated to 48 minutes for 100 agents and 133 _hours_ for 600 agents 1. To alleviate this issue, [32] proposes a deep learning model that imitates the convex optimization solution. The authors utilize a convolutional encoder-decoder trained with a dataset of images representing configurations with two to six task agents uniformly distributed throughout a 320x320 meter area. In that scenario, the CNN achieved nearly identical performance to the convex solver while taking far less time to compute solutions. Its zero-shot performance was also evaluated on out-of-distribution configurations with up to 20 agents. In the following set of experiments, we go one step further and test the performance on larger images that represent bigger areas and more agents. In particular, we perform MID on up to 1600x1600 meter areas and with over 600 total agents.

Footnote 1: We obtain these estimates by fitting an exponential polynomial, and power models to data from [32] and reporting the lowest runtime.

### _Simulations_

We use the following method to generate task agent configurations, \(\mathcal{X}\). Consider a square window with width \(T\) meters. The number of task agents \(|\mathcal{X}|\) is proportional to the window area, \(T^{2}\). There are five agents for \(T=320\) and 125 agents for \(T=1600\). We sample each task agent position independently from \(\mathbf{x}\sim U(-T/2,T/2)^{2}\), a uniform distribution covering the entire window. We represent each configuration \(\mathcal{X}\) by an intensity function \(X(\mathbf{t},\mathcal{X})\) following (11), so that each agent is represented by a Gaussian pulse with standard deviation \(\sigma_{X}=6.4\). The image \(\mathbf{X}\in\mathbb{R}^{N\times N}\) is sampled from \(X(\mathbf{t},\mathcal{X})\) at a spatial resolution of \(\rho=1.25\) meters per pixel.

We use the pre-trained CNN from [32]. It was trained on images representing configurations within a \(T=320\) meter wide window. It is publicly available online2. During inference, \(\mathbf{X}\) is the input to the CNN. The corresponding output \(\mathbf{\Phi}(\mathbf{X};\mathcal{H})\) is assumed to represent a proposed communication agent configuration. Figure 6 shows example inputs and outputs of the CNN for different window sizes.

Footnote 2: [https://github.com/dannox/learning-connectivity](https://github.com/dannox/learning-connectivity)

### _Baseline Approaches_

We do not compare the performance of MID to any baseline. In our experiments on the MTT task, we were able to compare the performance of the CNN against Bayesian filters. Unfortunately, this was not possible for MID due to the poor scalability of the convex optimization-based approach. Based on experimental runtimes reported in [32] we extrapolate that the runtime for 100 and 600 agents would be 48 minutes and 133 hours, respectivelly. Therefore, we are focused on comparing the performance of the CNN at different scales.

### _Modeling Multi-Agent Communication_

To test the performance of the proposed CNN framework in MID, we measure the power required to maintain a minimum bitrate between any two agents in the network. To do so, we assume a path loss channel model [62]. It provides a relatively simple description of point-to-point communication between any two agents. The model relates three key variables: the transmit power \(P(d)\) in mini-watts, the distance \(d\) in meters, and the expected communication rate \(R\). Their relationship is summarized by (23).

\[P(d)=[\text{erf}^{-1}(R)]^{2}\frac{P_{N_{0}}d^{n}}{K} \tag{23}\]

We assume that the agents' communication hardware is homogenous so that the following parameters are constant. \(P_{N_{0}}=1\times 10^{-7}\) is the noise level in the environment, \(K=5\times 10^{-6}\) is a parameter that describes the efficiency of the hardware, and \(n=2.52\) characterizes the attenuation of the wireless signal with distance. Finally, we require that any two agents to communicate at a normalized rate of \(R=0.5\). Hence, (23) expresses the required transmission power as a function of distance.

Equation (23) computes the power needed for agents to communicate directly. However, not all agents need to communicate directly. In many configurations, it is more efficient

Fig. 5: Comparison of OSPA of the three filters for different window sizes \(T\)[1]. We report the mean value for 100 simulations at each scale. The error bars indicate a 0.95% confidence interval in the MSE.
if messages are routed along multi-hop paths between agents. To measure the power needed to maintain this we introduce the _average minimum transmit power_ (AMTP).

**Definition 3**.: _(AMTP) Consider a fully connected graph between all agents. Let \(P(d)\) be the edge weights following (23) with constants \(P_{N_{0}}\), \(K\), \(n\), and \(R\). Now, consider the minimum spanning tree of this weighted graph. We define the AMTP as the average edge weight of this tree._

Notice that in Definition 3 there is a path between any two agents. Each pair of agents along this path can communicate at a rate of \(R\). Therefore, the communication rate along this path is \(R\). We assume that overhead is negligible. Therefore AMTP quantifies the average transmit power needed to sustain the minimal communication rate.

We use AMTP to evaluate the performance of the proposed CNN. Recall that the output of the CNN is an image \(\mathbf{\Phi}(\mathbf{X},\mathcal{H})\). To compute AMTP, we estimate the communication agent positions using the procedure outlined in Section III. The result is a set of vectors \(\mathcal{Y}=\{\mathbf{y}\in\mathbb{R}^{2}\}\), which, along with \(\mathcal{X}\), is used to compute AMTP.

The authors of [32] measure CNN performance via algebraic connectivity of a communication network with fixed transmission power. Algebraic connectivity is defined as the second smallest eigenvalue of the graph Laplacian. There are two main reasons to use AMTP instead. First, algebraic connectivity depends on the number of nodes in a graph. This complicates comparing networks of different sizes. Second, when the transmission power is fixed, the communication graph can be disconnected. In those cases, the connectivity is zero, even if the graph is almost connected. This is especially problematic for large graphs because it only takes a single out-of-place agent. AMTP does not require any normalization for different graph sizes and takes into account how close a communication network is to being connected.

### _Results_

To test the performance of the proposed convolutional approach in large-scale MID and the applicability of Theorem 1, we conduct the following experiments. We have a model that was trained on a \(T=320\) meter wide area and evaluate its performance on varying window sizes with \(T=320,480,960,1280,1600\) meters. At each window size, we generate 100 random task agent configurations following Subsection VI-A. For each configuration, the CNN produces a communication agent configuration.

We evaluate the AMTP for the combined communication network that includes both the task and communication agents. Table III summarizes the numerical results. The AMTP increases modestly with scale. The AMTP is lowest for a 320-meter window width. It rises to the highest level when \(T=1280\)m, rising to 11.33% higher than at \(T=320\)m. Interestingly, we observe a decrease at \(T=1600\) to only 8.61% higher than at \(T=320\)m. Simultaneously the AMTP variance decreases as the scale increases. Combined, these two observations are strong evidence that the AMTP will plateau at this level.

Additionally, we think there is a quite convincing explanation for the trend in variance. The rapid decrease in variance is acutely visualized in Figure 7. There could be two factors working together. Recall that AMTP is effectively the average transmission power over the edges of a minimum-spanning

Fig. 6: Example inputs and outputs to the CNN for the MID task at different window widths \(A=320,650,960,1280,1600\) but with a constant spatial resolution of \(\rho=1.25\) meters per pixel [2]. The top row images represent the positions of the task agents. The bottom row images represent the estimated optimal positions of the communication agents by the CNN. Additionally, the task agent positions are marked in red on the bottom images.
tree. Therefore, by the Central Limit Theorem, the variance should be inversely proportional to the number of edges in the graph. However, the variance decreases faster than that. Therefore we think there is a second factor involved: border effects due to padding. These contribute to variability but would be less pronounced as the area grows relative to the perimeter.

Overall, we observe that the proposed CNN model is a great solution to large-scale MID, as it demonstrates low levels of AMTP in all settings. Unlike in Section V we are unable to compute the MSE, because a convex optimization solution was computationally intractable at large scales. Although, Theorem 1 is a bound on the MSE, not the AMTP, good AMTP generalization is strongly aligned with the theorem as there is only a modest deterioration in performance as the window size increases.

## VII Conclusions

This paper presented a transfer learning framework that allows for efficient training of CNNs for large-scale translationally symmetric problems. Training is performed on a small window of the larger problem and the trained network is transferred to much larger areas. The proposed approach is theoretically justified, by analyzing the CNN behavior with joint stationary input-output signals. The novel analysis proves that the MSE for the large-scale problem is bounded above by the MSE for the small-scale problem and a small term. This term results from errors introduced by zero-padding before convolutions, but it is equal to zero when padding is not used. The novel convolutional framework was evaluated through simulations on two distinct problems: Multi-target tracking, and Mobile-infrastructure on demand. In both tasks, the proposed architecture showcased remarkable performance and was able to generalize to large-scale problems with high performance.

## Appendix A Proof of Theorem 1

In this section, we derive an upper bound for (6) and prove Theorem 1. For concisenes, we make the substitution \(\varepsilon(\mathbf{t})=\mathbf{\Phi}(X;\mathcal{H})(\mathbf{t})-Y(\mathbf{t})\).

\[\mathcal{L}_{\infty}(\mathcal{H})=\mathbb{E}\left[\lim_{T\to\infty}\frac{1}{T^ {d}}\int_{\mathcal{C}^{d}_{B}}|\varepsilon(\mathbf{t})|^{2}d\mathbf{t}\right] \tag{24}\]

Recall that \(\mathcal{C}^{d}_{T}\subset\mathbb{R}^{d}\) is a \(T\)-wide hypercube centered at zero.

Next, we construct a sequence that bounds the limit above. For any \(T\) let \(N=\lceil\frac{T}{B}\rceil\). When we substitute for \(T\) we can make an upper bound.

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\mathbb{E}\left[\lim_{N\to\infty} \frac{1}{(NB)^{d}}\int_{\mathcal{C}^{d}_{NB}}|\varepsilon(\mathbf{t})|^{2}d \mathbf{t}\right] \tag{25}\]

Notice that we can partition the hypercube \(\mathcal{C}^{d}_{NB}\) into smaller hypercubes. Since \(N\) is integer, we can evenly arrange \(N^{d}\) hypercubes with side length \(B\) within it. Let \(\mathcal{C}^{d}_{B}(\mathbf{\tau})\) be such a hypercube centered at \(\mathbf{\tau}\). To partition \(\mathcal{C}^{d}_{NB}\) they must be centered at

\[\mathcal{T}=\left\{iB-\frac{(N-1)B}{2}\mid i\in\mathbb{Z},0\leq i<N\right\}^ {d}. \tag{26}\]

Thus, we write the original hypercube as \(\mathcal{C}^{d}_{NB}=\bigcup_{\mathbf{\tau}\in\mathcal{T}}\mathcal{C}^{d}_{\beta} (\mathbf{\tau})\) and break-up the integral in (25) into \(N^{d}\) smaller integrals.

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\mathbb{E}\left[\lim_{N\to\infty} \frac{1}{(NB)^{d}}\sum_{\mathbf{\tau}\in\mathcal{T}}\int_{\mathcal{C}^{d}_{B}}| \varepsilon(\mathbf{t}-\mathbf{\tau})|^{2}d\mathbf{t}\right] \tag{27}\]

Above, instead of shifting the hypercube by \(\mathbf{\tau}\) we equivalently shift the integrand. By Assumption 3, the stochastic processes are bounded. Therefore, both the limit and expectation exist and are finite, so we can exchange them.

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\lim_{N\to\infty}\frac{1}{(NB)^{d }}\sum_{\mathbf{\tau}\in\mathcal{T}}\mathbb{E}\left[\int_{\mathcal{C}^{d}_{B}}| \varepsilon(\mathbf{t}-\mathbf{\tau})|^{2}d\mathbf{t}\right] \tag{28}\]

In [37], the authors show that if the input to a CNN is strictly stationary then so is the output. Their result can be extended to jointly stationary signals as follows. Consider a vector valued process \(Z(\mathbf{t})=[X(\mathbf{t}),Y(\mathbf{t})]\) that is a concatenation of \(X\) and \(Y\). Since \(X\) and \(Y\) are jointly stationary then \(Z\) is stationary. Notice that for any CNN \(\mathbf{\Phi}(X;\mathcal{H})\), we can define a new CNN with output \(\mathbf{\bar{\Phi}}(Z;\mathcal{H})(\mathbf{t})=[\mathbf{\Phi}(X;\mathcal{H}) (\mathbf{t}),Y(\mathbf{t})]\). According to [37] this output is stationary whenever \(Z\) is stationary and the difference \(\varepsilon(\mathbf{t})=\mathbf{\Phi}(X;\mathcal{H})(\mathbf{t})-Y(\mathbf{t})\) must also be stationary.

The expectation of a stationary signal is shift-invariant, meaning that \(\mathbb{E}\left[|\varepsilon(\mathbf{t}-\mathbf{\tau})|^{2}\right]=\mathbb{E} \left[|\varepsilon(\mathbf{t})|^{2}\right]\).

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\lim_{N\to\infty}\frac{1}{(NB)^{d} }\sum_{\mathbf{\tau}\in\mathcal{T}}\mathbb{E}\left[\int_{\mathcal{C}^{d}_{B}}| \varepsilon(\mathbf{t})|^{2}d\mathbf{t}\right] \tag{29}\]

Fig. 7: The distributions of the minimum transmitter power needed to maintain a normalized communication rate of at least 50% between any two agents [2]. The distributions for each window width are visualized by box plots, with notches representing a 95% confidence interval for the estimate of the median.
The summand no longer depends on \(\mathbf{\tau}\). Since the cardinality of \(\mathcal{T}\) is \(N^{d}\), this cancels out with the factor of \(N^{d}\) in the denominator. The limit expression no longer depends on \(N\), so the right hand side reduces to an average over \(\mathcal{C}_{B}^{d}\).

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\frac{1}{B^{d}}\mathbb{E}\left[\int_ {\mathcal{C}_{B}^{d}}|\varepsilon(\mathbf{t})|^{2}d\mathbf{t}\right] \tag{30}\]

At this point, it is convenient to change notation. Let \(\sqcap_{s}(\mathbf{t})\) be an indicator function that is one whenever \(\mathbf{t}\in\mathcal{C}_{s}^{d}\) for all \(s\in\mathbb{R}\). Recognize that the integral above is the L2 norm squared of \(\varepsilon(\mathbf{t})\) multiplied by a window, \(\sqcap_{B}(\mathbf{t})\).

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}})\leq\frac{1}{B^{d}}\mathbb{E}\left[ \|\sqcap_{B}(\mathbf{\Phi}(X;\hat{\mathcal{H}})-Y)\|_{2}^{2}\right] \tag{31}\]

The output of \(\mathbf{\Phi}(X;\hat{\mathcal{H}})\) is \(x_{L}\), the output of the \(L^{\text{th}}\) layer. Similarly, denote \(\tilde{x}_{L}\) as the output of the \(L^{\text{th}}\) layer in \(\mathbf{\Phi}(\sqcap_{A}X;\hat{\mathcal{H}})\). Hence, write the norm in (31) as \(||\sqcap_{B}(x_{L}-\tilde{x}_{L}+\tilde{x}_{L}-Y)||_{2}^{2}\) and apply the triangle inequality.

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}}) \leq\frac{1}{B^{d}}\mathbb{E}\left[\|\sqcap_{B}\tilde{x}_{L}-Y) \|_{2}^{2}\right]\] \[+\frac{1}{B^{d}}\mathbb{E}\left[\|\sqcap_{B}(x_{L}-\tilde{x}_{L} )\|_{2}^{2}\right]\] \[+\frac{1}{B^{d}}\mathbb{E}\left[\|\sqcap_{B}(\tilde{x}_{L}-Y) \|_{2}\|\sqcap_{B}(x_{L}-\tilde{x}_{L})\|_{2}\right] \tag{32}\]

Let us consider the expectation of each term individually. The first term is equal to \(\mathcal{L}_{\sqcap}(\hat{\mathcal{H}})\) as defined in (7); this is easy to see by substituting \(\tilde{x}_{L}=\mathbf{\Phi}(\sqcap_{A}X;\hat{\mathcal{H}})\). The second term is bounded above following Lemma 1. We define \(H\coloneqq\prod_{l=1}^{L}\|h_{l}\|_{1}\) to express this concisely. Finally, the third term can be bounded above by applying Cauchy-Schwartz to the expectation. That is \(\mathbb{E}\left[XY\right]^{2}=\mathbb{E}\left[X^{2}\right]\mathbb{E}\left[Y^{2}\right]\) where \(X,Y\) are dummy random variables.

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}}) \leq\mathcal{L}_{\sqcap}(\hat{\mathcal{H}})+\frac{H^{2}}{B^{d}} \mathbb{E}\left[\|\sqcap_{B}(X-\sqcap_{A}X)\|_{2}^{2}\right]\] \[+\sqrt{\mathcal{L}_{\sqcap}(\hat{\mathcal{H}})\frac{H^{2}}{B^{d}} \mathbb{E}\left[\|\sqcap_{B}(X-\sqcap_{A}X)\|_{2}^{2}\right]} \tag{33}\]

We can further evaluate the expectation. Since \(X\) is stationary, the second term is just the variance of \(X\) times the volume in \(\mathcal{C}_{B+LK}^{d}\setminus\mathcal{C}_{A}^{d}\). Both hypercubes are centered around zero, so the net hypervolume is the difference between their volumes. If \(B+LK\geq A\) then the hypervolume is \((B+LK)^{d}-A^{d}\), otherwise it is zero.

\[\mathcal{L}_{\infty}(\hat{\mathcal{H}}) \leq\mathcal{L}_{\sqcap}(\hat{\mathcal{H}})+\mathbb{E}\left[X(0)^ {2}\right]C+\sqrt{\mathcal{L}_{\sqcap}(\hat{\mathcal{H}})\mathbb{E}\left[X(0) ^{2}\right]C} \tag{34}\] \[C =\frac{H^{2}}{B^{d}}\max\left(0,[B+LK]^{d}-A^{d}\right) \tag{35}\]

## Appendix B Proof of Lemma 1

**Lemma 1**.: _Let \(x_{l}\) denote the output of the \(l^{\text{th}}\) layer of \(\mathbf{\Phi}(X;\mathcal{H})\) with \(L\) layers and filter width \(K\). Similarly, let \(\tilde{x}_{l}\) denote the layers' outputs in \(\mathbf{\Phi}(\sqcap_{A}X;\mathcal{H})\). Then for all integers \(L\geq 0\) the following inequality holds._

\[\|\sqcap_{B}(x_{L}-\tilde{x}_{L})\|_{2}\leq\|\sqcap_{B+LK}(X-\sqcap_{A}X)\|_{2} \prod_{l=1}^{l=L}\|h_{l}\|_{1}\]

Proof.: We proceed by induction. For \(L=0\) the above inequality holds by definition. Hence, assume that the inequality holds for some \(L>0\) and consider the left hand side for \(L+1\), which we denote \(\Delta_{L+1}\).

\[\Delta_{L+1}\coloneqq\|\sqcap_{B}(z^{L+1}-z_{A}^{L+1})\|_{2} \tag{36}\]

Then by definition of the CNN we can expand the output of the first layer.

\[\Delta_{L+1}=\|\sqcap_{B}(\sigma(h_{L+1}*x_{L})-\sigma(h_{L+1}*\tilde{x}_{L})) \|_{2} \tag{37}\]

Now we can use the fact that \(\sigma\) is normalized Lipshitz from assumption 6.

\[\Delta_{L+1}\leq\|\sqcap_{B}h_{L+1}*(x_{L}-\tilde{x}_{L})\|_{2} \tag{38}\]

Now notice that for all \(t\) such that \(|t|\leq B/2\) the values of \((h_{1}*x_{L})(t)\) depend only on \(x_{L}(s)\) for \(|s|<(B+K)/2\) because \(h_{L}\) has width \(K\). Using the monotonicity of the norm, we can simultaneously remove the \(\sqcap_{B}\) outside the convolution.

\[\Delta_{L+1}\leq\|h_{L+1}*[\sqcap_{B+K}(z^{L-1}-z_{A}^{L-1})]\|_{2} \tag{39}\]

Therefore we can apply Young's convolution inequality.

\[\Delta_{L+1}\leq\|h_{L+1}\|_{1}\|\sqcap_{B+K}(x_{L}-\tilde{x}_{L})\|_{2} \tag{40}\]

Now assuming the proposition holds for \(L\) then using the substitution \(\hat{B}=B+K\) we can obtain the desired form.

\[\Delta_{L+1} \leq\|h_{L+1}\|_{1}\|\sqcap_{\hat{B}+LK}(X-\sqcap_{A}X)\|_{2}\prod_{ l=1}^{l=L}\|h_{l}\|_{1} \tag{41}\] \[\Delta_{L+1} \leq\|\sqcap_{B+LK}(X-\sqcap_{A}X)\|_{2}\prod_{l=1}^{l=L+1}\|h_{l }\|_{1} \tag{42}\]

Thus, we have proven the inequality by induction for any integer \(L\geq 0\). 
