Thi Thuy

Nga Nguyen

Olivier Brun
email: brun@laas.fr

Balakrishna J Prabhu
email: bjprabhu@laas.fr

A Learning-based Scheme for Channel Allocation to Vehicular Users in Wireless Networks ⋆,⋆⋆

Keywords: Scheduling, Deep Feedforward Neural Networks, Supervised Learning, Data-Driven

. On numerical examples with realistic mobility patterns, we show that the learning algorithm yields an approximate yet satisfactory solution with much less computation time.

Introduction

In cellular wireless networks, a central scheduling problem is to choose one among several concurrent users (for example, mobile phones) to which the scheduler (henceforth also referred to as the base station) must send data to. This scheduling decision is taken every time-slot which is of the order of 2 ms [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF] and is based on what are called as channel conditions of the users. Roughly, the channel condition of a user determines the data rate at which the base station can communicate with this user. In wireless networks, these conditions can vary randomly on short as well as on long time scales. Also called fading and shadowing, these random variations are a consequence of the interference patterns induced by the different obstacles (building, trees, etc.) in the path of the radio waves used for wireless communications [START_REF] Tse | Fundamentals of Wireless Communication[END_REF]. However, the decision is not as easy as scheduling the user with the best channel condition as such a policy could lead to unfairness between users. Imagine a user with a direct line of sight path with the base station and another who is inside a building or an underground metro station. Quite possibly, the former user will always have a better channel which would starve the latter user of any communication.

To avoid these unfair allocations, a typical solution is to define a utility which is usually a concave function of the throughput2 of the users and then compute the scheduling decision as the one that maximizes the sum of the utilities of the users. For example, the utility function could be the logarithm of the average throughput of the users. These solutions fall under the umbrella of the network utility maximization problem [START_REF] Yi | Stochastic network utility maximisation -a tribute to Kelly's paper published in this journal a decade ago[END_REF].

In an ideal scenario, the base station will solve this utility maximization problem every 2 ms. However, there are two practical issues that make this infeasible. First, the throughput of a user depends upon future channel conditions which are unknown to the scheduler. Second, the integer scheduling problem is known to be NP-complete [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF]. Solving such an optimization problem over a time horizon of seconds (thousands of time-slots) and with hundreds of users can be unrealistic in time-slots of 2 ms (which are actually becoming shorter as the technology progresses). To overcome these practical issues, several heuristics have been proposed that are based on an estimation of the future data rates [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF][START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF][START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF]. The heuristics (called STO1 and STO2) in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF][START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF] use the estimated future data rates as an input to a relaxed version of the original problem restricted to a shorter time horizon thereby reducing the dimensionality of the problem. These heuristics are thus much faster to solve than the original problem but they still require solving rather frequently a large-scale convex optimization problem which can be time consuming. It was shown numerically in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF][START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF] that STO1 and STO2 performed better than the one in [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF] as well as the popular PF algorithm [START_REF] Kushner | Convergence of proportional-fair sharing algorithms under general conditions[END_REF] that does not use future estimated rates. Therefore, in this paper, we shall address the problem of improving the speed of these heuristics without compromising on their superior total utility. It is worth mentioning that although we only focus on STO1, our approach could probably be extended to other channel allocation algorithms as well.

Contributions

We propose a machine learning based solution to speed up the operations of STO1 3 . The key idea is to use a Deep Feedforward Neural Network (DFNN) to approximate the output of the relaxed optimization problem in the heuristics.

It is well-known that any continuous function can be approximated arbitrary well by a DFNN. However, discontinuous functions are much more difficult to learn. Unfortunately, as we show with a simple example, the input-output mapping realized by the STO1 algorithm is discontinuous. This makes the model slower to learn due to oscillations at discontinuity points. We characterize the discontinuity points of STO1 by explicitly indicating the set where they reside when the dimension is equal to 2. In order to reduce the impact of discontinuities, we propose several user ordering schemes. We also propose an alternative approach which amounts to learning the dual values, which are proven mathematically to be continuous.

It will be shown on numerical examples that once the DFNN is trained, it takes much less time to generate a reasonable accurate solution compared to using the specialized Python package CVXPY [START_REF] Diamond | CVXPY: A Python-embedded modeling language for convex optimization[END_REF] that uses the solver Mosek [START_REF] Mosek Aps | MOSEK Optimizer API for Python manual[END_REF] for solving of a convex optimization problem. We prune and compare different DFNN architectures and different loss functions to find the most appropriate ones for our problem. We then compare the behavior of the learning algorithm with STO1 and with other existing algorithms as well. The comparison shall be done on scenarios created with SUMO [START_REF] Lopez | Microscopic traffic simulation using sumo[END_REF] which can generate realistic mobility patterns of vehicles on road networks. Based on numerical results, the learning algorithm is shown to perform close to STO1 with much less computation time. Numerical results in section 5.6 show that, for larger scaling systems, only learning dual values could scale well in comparison with learning the primal values (either with or without ordering scheme).

Preliminary results from this paper mainly containing the numerical examples appeared in [START_REF] Nguyen | Learning resource allocation algorithms for cellular networks[END_REF].

Related works

The theory of approximation for DFNNs has been studied in many papers. Motivated by Kolmogorov's superposition theorem [START_REF] Kolmogorov | On the representation of continuous functions of many variables by superposition of continuous functions of one variable and addition[END_REF] in 1957, many approximation results have proven the approximation capabilities of feedforward neural networks for the class of continuous functions, see, e.g., [START_REF] Cybenko | Approximation by superpositions of a sigmoidal function[END_REF], [START_REF] Hornik | Multilayer feedforward networks are universal approximators[END_REF], [START_REF] Montanelli | Error bounds for deep ReLU networks using the kolmogorov-arnold superposition theorem[END_REF]. In his theorem, Kolmogorov proved that any continuous function can be represented as a superposition of continuous functions of one variable. In 1989, Cybenko proved that any multivariate continuous function with support in a hypercube can be uniformly approximated by a linear finite combinations of compositions of a sigmoidal functions and a set of affine functions [START_REF] Cybenko | Approximation by superpositions of a sigmoidal function[END_REF]. This representation is in fact a feedforward neural networks with sigmoidal activation functions. Independently with the work of Cybenko, Hornik [START_REF] Hornik | Multilayer feedforward networks are universal approximators[END_REF] also proved a similar result. Two years later, Hornik [START_REF] Hornik | Approximation capabilities of multilayer feedforward networks[END_REF] showed that multi-layer feedforward neural networks with arbitrary bounded and non-constant activation function can approximate arbitrary well real-valued continuous functions on compact subsets of R n as long as sufficiently many hidden layers are available. The adjective "deep" in "deep learning" thus simply means many layers.

Learning an algorithm to produce an approximate algorithm in order to reduce computation time has been proposed in several recent research papers [START_REF] Gregor | Learning fast approximations of sparse coding[END_REF], [START_REF] Sun | Learning to optimize: Training deep neural networks for wireless resource management[END_REF]. In [START_REF] Gregor | Learning fast approximations of sparse coding[END_REF], the authors consider a Sparse Coding problem which is used for extracting features from raw data. The problem is that Sparse Coding is often too slow for real-time processing in several applications such as pattern recognition. The authors propose a method using a non linear, feedforward function to learn Sparse Coding to produce an approximate algorithm with 10 times less computation.

Learning an algorithm for wireless resource management has been proposed in [START_REF] Sun | Learning to optimize: Training deep neural networks for wireless resource management[END_REF]. In that work, the authors used a DFNN to learn an algorithm for the interference channel power control problem. They obtain an almost real time algorithm, since passing the input through a DFNN to get the output only requires a small number of simple operations as compared to an iterative optimization algorithm. They show that, by choosing an appropriate initialization, the initial power control algorithm performs a continuous mapping which can be efficiently learnt.

In this paper, we use DFNNs for learning a channel allocation algorithm maximizing the proportional fairness between vehicular users. The proposed method is however potentially applicable to other convex optimization problems.

Organization

In Section 2, we present the resource allocation problems considered in this paper in the case of a single Base Station (BS). We also briefly describe the STO1 algorithm for allocating the channel to vehicular users. Section 3 provides an overview of the learning-based approach and formally defines the input-output relationship for the DFNN model. We discuss about the continuity of this inputoutput mapping in Section 4 and then propose several user ordering schemes for reducing the discontinuity of the original mapping, as well as an alternative approach which amounts to learning the dual values instead of the allocation. Numerical results are presented in Section 5. Finally, in Section 6 we discuss several research directions that can be followed in future work.

Wireless Scheduling Problems and Channel Allocation Heuristics

We first present the wireless scheduling problems considered in this paper in Section 2.1, and then briefly describe the channel allocation heuristics that were proposed in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF][START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF] in Section 2.2.

Problem Formulation

Consider the following downlink discrete-time channel allocation problem for a single Base Station (BS) (see [START_REF] Kushner | Convergence of proportional-fair sharing algorithms under general conditions[END_REF] and references therein):

                         max α O(α) = K i=1 log   T j=1 α ij r ij   subject to K i=1 α ij ≤ 1, j = 1, . . . , T ; α ij ∈ {0, 1}, j = 1, . . . , T, i = 1, . . . , K. (I)
Here r ij ≥ 0 is the data rate of user i in time-slot j, and α ij is the corresponding allocation in this slot. The constraints impose that the BS can choose at most one user in each time-slot. The objective of the BS is to maximize the sum of the individual user utilities which are defined as the logarithm of the total throughput of the user over a time horizon of T . As mentioned in Section 1, solving this problem is not practical because the data rates r i,j become known to the scheduler only in slot j. Further, users arrive and leave and it is not possible to know in advance which users will be present in the network in the future. Hence, the algorithms proposed use either no information on the future rate (see [START_REF] Kushner | Convergence of proportional-fair sharing algorithms under general conditions[END_REF] and references therein) or an estimation of the future rates [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF][START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF]. The latter works assume that the mean future rates of users can be predicted from their positions using Signal-to-Noise Ratio (SNR) maps.

A more fine-grained scheduling problem on the downlink involves joint power control and channel allocation which allows the BS to vary the transmit power in addition to choosing how much of the channel (or bandwidth) it can allocate to the users [START_REF] Huang | Downlink scheduling and resource allocation for ofdm systems[END_REF], and is defined as:

                         max x,p K i=1 log   T j=1 x ij log 1 + p ij γ ij x ij   subject to K i=1 x ij ≤ 1, ∀j; x ij ≥ 0, ∀i, j 1 T j i p ij ≤ P ; i p ij ≤ P max , ∀j. (II)
Here p ij (resp. x ij ) is the power (resp. fraction of bandwidth) allocated by the BS to user i in slot j. The parameter γ ij represents the channel condition of the user i in slot j and

x ij log 1 + pij γij xij
is the Shannon rate obtained by this user when it is allocated power p ij and fraction of bandwidth x ij . The utility of the user is again the logarithm of its total throughput and the objective of the BS is to maximize the sum utility. Note that there are constraints on the power allocation which involve both the maximum power that can be expended in a time slot as well as the average power spend over the whole horizon. For this joint power and channel allocation problem, an adapted version of STO1 was proposed in [START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF]. Remark 1 (Joint power control and channel allocation). For brevity, we shall explain the STO1 algorithm and its associated machine learning solution only for the channel allocation problem (I). A remark shall be made wherever the treatment of this problem differs from that of the joint power control and channel allocation problem (II).

The STO1 algorithm

STO1 is a sequential algorithm which computes the allocation on time-slot j based on the current and the past data rates, and the estimated future data rates. It operates on two time-scales (shown in Figure 1) in order to reduce its complexity. Define big-slots as a certain number (order of hundreds) of timeslots (or small-slots) that reflect the duration over which the distance of each user to the BS does not change much. It follows from the law of large numbers that, although the data rate of each user in each time-slot can vary randomly, the expected sum of its data rate over big-slots does not vary too much. For example, while the scheduling time-slots are 2 ms in length, one big slot can be equal to 100 time-slots, and one user can move at most by a few meters in a big slot. Big slots are defined to reduce the dimension of the original optimization problem as explained below. It shall be assumed that estimations are available for users' future positions at the granularity of big-slots, and that the mean of future rates based on the future positions are estimated using SNR maps.

Before giving a formal definition of the STO1 algorithm, we give an intuitive explanation. In each small-slot j, STO1 does two steps. In the first step, it solves the problem (I) but with several restrictions: (i) the horizon is shortened to J big-slots; (ii) the future allocations are computed only on the aggregated level of big-slots; and (iii) the integer constraints on α ij are relaxed. In the second step, the fractional allocation for the current small-slot is projected onto the set of the feasible integral allocations. The first step reduces the number of variables and hence the dimensionality of the problem as the future allocations are computed only for big-slots. Note that the second step is optional and is relevant only to problems with integral constraints.

A more formal definition is as follows. Denote by δ the length of a time slot. Let ∆ be the size of the big-slot in absolute time units and let m = ∆/δ be the number of small slots in a big-slot (see Figure 1). Denote by rij the mean rate in slot j for user i. At each small-slot t, with a slight abuse of notation, we shall denote by ρi,0 = (m-(t mod m))+t j=t+1 rij the total rate for user i in the remaining channel allocation slots of the current big-slot τ = 0, where t mod m denotes the remainder when dividing t by m. We also define ᾱi,0 as the corresponding allocation for the current big-slot τ = 0.

Denote by ρiτ = τ m+A j=(τ -1)m+A+1 rij where A = ⌊ t m ⌋ + 1 m, is the total average data rate that user i will get in the future big-slot τ (τ = 1, 2, ..., J -1), where big slot τ starts after the current big-slot, and J is the short time horizon in term of big slots over which we can estimate the mean future rate. We also define ᾱiτ as the corresponding allocation for user i in future big slot τ . These allocations ᾱiτ can be interpreted as the fraction of small slots that user i will be allocated in the big-slot τ .

Note that this definition is slightly different from the definition in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF]. The differences are as follows: in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF], there is no current big slot and the future bigslot starts just after the current small slots. This change in definition does not change much the overall performance of the algorithms. The above definition of two time slot types corresponds in fact to the ones introduced in [START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF].

Denote by a i (t) = t j=1 α ij r ij the total throughput allocated to user i up to time slot t, and let K(t) be the number of users inside the coverage range of the BS at time t.

The algorithm STO1 contains two steps which are as follows:

• Step 1solve the following optimization problem over a short-term horizon of J big-slots:

                   maximize K(t) i=1 log a i (t -1) + α it r it + J τ =1
ᾱiτ ρiτ subject to

K(t) i=1 α it = 1, K (t)
i=1 ᾱiτ = 1, τ = 0, . . . , J -1, α it , ᾱiτ ∈ [0, 1], τ = 0, . . . , J -1, i = 1, . . . , K(t).

(STO1-Opt) The decision variables in Problem (STO1-Opt) are the channel allocations in the current small slot, α it , and the channel allocations in the current and future big-slots, ᾱiτ . Since the future allocations are only computed on the time-scale of big-slots, there is a reduction by factor m in the number of variables in (STO1-Opt).

• Step 2obtain a feasible integral allocation from the fractional one. For example, set α i * j = 1 with i * = argmax i α ij and set it to 0 for the other users.

Remark 2. (STO1-Opt) is solved thanks to the python package CVXPY [START_REF] Diamond | CVXPY: A Python-embedded modeling language for convex optimization[END_REF] and the solver Mosek [START_REF] Mosek Aps | MOSEK Optimizer API for Python manual[END_REF]. In [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF], this optimization problem was solved using a projected gradient algorithm, since it allows to iteratively solve a convex optimization problem when the feasible set is a simplex or a Cartesian product of simplices, no matter how complex the objective function is as long as it is smooth and convex. The advantage of CVXPY [START_REF] Diamond | CVXPY: A Python-embedded modeling language for convex optimization[END_REF] is that it can be used to generalize this idea to other convex optimization problems, with more complex constraints such as power control constraints or others QoS constraints (e.g. delay constraints).

Remark 3. STO1 leans on the information about the number of users and users' channels to make decisions. In this paper, we assumed that the average channel gains in big slots with less error could be provided as input of STO1, this assumption is quite reasonable because of the law of large numbers; the number of users in the near future is not assumed to be known for the BS because that information might be more difficult to get. However, if we can get that information as input for STO1, then the variables for the new users just need to be added into the optimization problem (their channel gains are assigned to 0 before their arrival instant). This information can be updated in every small slot (every 2 ms) when STO1 computes a new allocation.

Learning Algorithm

As presented in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF] and [START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF], STO1 performs better than existing algorithms. However it has to solve an optimization problem with a large number of variables and constraints frequently, and may not be able to run in real time for some complex scenarios. The main idea proposed in this paper is to train a DFNN to predict an approximate solution to (STO1-Opt) instead of using a specialized convex optimization package. We provide an overview of the approach in Section 3.1. We then formulate the learning problem in Section 3.2, where we define the input state, the target and the architecture of the neural network.

A Learning-based Approach for Wireless Scheduling

Our goal is to approximate the input-output mapping realized by STO1 with a DFNN (see [START_REF] Goodfellow | Deep Learning[END_REF] for background material on supervised learning with DFNN). Once the approximation function (that is, the DFNN) obtained, the output can be computed by feeding the DFNN with the input value, instead of solving an optimization problem. This simpler method is expected to work faster than the original algorithm. Obviously, the same idea could be used for other problems in order to obtain an approximate method which performs almost as well as the original algorithm but requires much less computing time.

More precisely, the STO1 algorithm can be seen as a function F that maps an input x n ∈ X (a problem instance) to an output y n ∈ Y (a channel allocation), where X and Y denote the input and output spaces of STO1, respectively. Given a bunch of examples of input-output pairs (x n , y n ) N n=1 (the training data), our objective is to obtain another function F : X → Y which is in the form of a DFNN (an example of DFNN is illustrated in Figure 2) and minimizes the empirical risk where l(•) is a loss function which measures how far y n is from F (x n ). Our hope is that the learned approximation F is able to determine outputs of unseen inputs with small error.

R erm ( F ) = 1 N N n=1 l(y n , F (x n )),
It is known that optimizing the parameters (e.g., weight matrices, bias vectors, non-linear activation functions) of a neural network and deciding its architecture (e.g. numbers of layers and number of nodes in each layer ) is in general not an easy task [START_REF] Sun | On the depth of deep neural networks: A theoretical view[END_REF]. In this paper, we shall empirically compare some architectures through experiments presented in Section 5.2. After fixing the architecture, we have to find appropriate parameters by minimizing the empirical risk defined above.

System Setup for learning

Recall that, in STO1, we have two types of time scales: one is the big slot ∆ and the other one is the small slot δ. In STO1, we solve problem (STO1-Opt) with variables of size (1 + J) • K every small slot, where J is the time horizon in terms of big slots and K is the number of users in the system. The size of the allocation vector for each user is equal to 1 + J since it contains the allocation for the current small slot, α it , and the average allocation ᾱiτ for the subsequent J big slots (including the current big slot). The input of STO1 is a data rate vector of size (1 + J) • K and the total allocated throughput for the K users. The output of STO1 is the current allocation vector (α it ) i=1,...,K which is of size K, since we shall only use current allocation for making decision.

As it is defined at the moment, STO1 is not well suited to be modelled as a learning problem for the two reasons stated below.

Firstly, since K can vary over time, the dimension of the input vector will also vary. To circumvent this problem and to properly define STO1 as a function, we have to fix the size of the state. To do that, we extend the real state of the system by adding some pseudo users. Let us assume that there are at most K M users inside the system. We will then add K M -K pseudo users, where K is the number of real users in the system at time t. We will actually learn an extended version of STO1 which is STO1 when we restrict it to K users. There are many ways to extend STO1, but here we try to define an extended version that preserves as much as possible the continuity of STO1. When we mention "learning STO1", it means "learning the extended function" of STO1.

Secondly, the output of STO1 as defined above is the solution of an optimization problem. So, STO1 can be a set-valued mapping since the solution need not be unique. However, by using the CVXPY package to solve the convex optimization problem (STO1-Opt), we let it decide the way it determines one of the solutions. This way STO1 becomes a function (instead of set-valued mapping).

Remark 4 (Joint power control and channel allocation). For the joint power control and channel allocation problem, the state needs to be augmented by the remaining total power. The output of the DFNN will now give the transmit power to each user as well as the fraction of the channel it gets allocated.

State

We define a state as a matrix of size (2+J)×K M , where K M is the maximum number of users in the system. There are thus 2 + J rows, and each row has K M elements. The interpretation is as follows:

• The first row gives the current rates of the K users. We fill in the K positions on the left hand side with these current rates, and the remaining K M -K positions are filled with -1.

• The next J rows (from 2, .., J + 1) give the average rates of the users in the next J big slots. For pseudo users (the K M -K columns on the right hand side), we use the value (-1) • (∆/δ -(t mod ∆/δ)) for the current big slot and the value (-1) • ∆/δ for the other big slots.

• The last row gives the total allocated throughput of the K users. For pseudo users, we use a large enough value which is significantly greater than the total allocated throughput of real users.

By observing how STO1 works, we remark, as expected, that STO1 gives priority to users with a low allocated throughput and a high current rate. Therefore, the way we define the state (that is, by using negative values for the current and future rates of pseudo users, and extremely large values for their allocated throughput) is intended to help the model ignore quickly the pseudo users.

Remark 5. Remark that there are K real users in the system at present time. Therefore, the K places of the real users in the first row which give the current rates of those users have to be strictly positive. The future rates (from the second row to the (J + 1)-th row) can be zero.

Target

We remind the reader that we want to learn only the current allocation, not the future allocation. Therefore, the target will be a vector of size K M , where the first K positions represent the fractional allocation α it of the K users as computed by STO1, and the last positions are filled with zero. Since in the optimization problem, the sum of allocation should be equal to 1, when there is no user in the system (all positions correspond to pseudo users), the allocation vector will be set to (1/K M , ..., 1/K M ) by convention.

Figure 3 illustrates the input and output of the DFNN model as described above.

Loss, DFNN architecture, initial parameters and optimizer

We will try several different loss functions and architectures and compare them in Section 5. The initial parameters (weights) of the DFNN will be chosen as proposed in [START_REF] Lecun | Efficient backprop[END_REF], which allows the initial parameters to be not too big and not too small. The optimizer is Adam, which was first introduced in [START_REF] Kingma | Adam: A method for stochastic optimization[END_REF] and is a stochastic first-order gradient-based algorithm. The convergence of Adam is proven in [START_REF] Reddi | On the convergence of adam and beyond[END_REF].

Discussion about the continuity of the STO1 function

As discussed in Section 1.2, any continuous function can be approximated arbitrary well with a DFNN. Unfortunately, as we shall prove in Section 4.1 below, the input-output mapping F implemented by the STO1 algorithm is not continuous, implying that it is much more difficult to learn than a continuous mapping. We characterize the discontinuities of this mapping in Section 4.2. This characterization is then used in Section 4.3 to devise user ordering schemes allowing to reduce the number of discontinuities. In Section 4.4, we propose an alternative approach which amounts to learning the dual values, which are proven to be continuous, instead of the primal ones.

A simple counter-example proving that STO1 is a discontinuous function

As defined above, F is a mapping from i=K M ,j=J+2 i=1,j=1 E i,j to S K M , where S K M is the simplex of size K M and • For j = 2, . . . , J+1 and i = 1, . . . , K M , E i,j = [0, +∞]∪{-1, -2, ..., -∆/δ},

• For j = 1 and i = 1, . . . , K M , E i,1 = (0, +∞] ∪ {-1}, 0 -1 current rate
• For j = J + 2 and i = 1, . . . , K M , E i,J+2 = [0, +∞].
We can see that the pseudo users and real users lie in different connected components (see Figure 4), from which it follows that the continuity of its extension depends only on STO1. We shall thus concentrate on the continuity of the STO1 function on the connected component corresponding to the K real users. Unfortunately, STO1 itself is not a continuous function. Let us take a simple example illustrating the discontinuity. Assume that K = 2, J = 1, ∆ = δ and consider the following sequence of states:

R n =   r + (-1) n n r -(-1) n n r -(-1) n n r + (-1) n n 0 0   .
Then it is easy to show that R n → R, where

R =   r r r r 0 0   .
However

F (R n ) = [1, 0] if n = 2k, [0, 1] if n = 2k + 1.
This simple example shows that the STO1 function is not continuous. The discontinuities make the learning problem much more difficult since near discontinuity points, the DFNN model does not know which direction of the output its parameters should follow. For example, as illustrated in the above 2-dimension example, near R, the target (output) oscillates between [0, 1] and [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF]0]. Since a DFNN is a composition of many continuous functions, it is also a continuous function. Trying to fit every target near R into the DFNN model can make its parameters conflict and result in a slower convergence. Therefore in the remainder this section we shall characterize the discontinuity points of the STO1 function and discuss how to derive a continuous function from STO1.

Analysis of discontinuities

Above we showed one discontinuity point R when K = 2, J = 1. Now, our objective is to characterize the set containing all discontinuity points. Before doing that, let us analyze the property of an optimal solution resulting from the KKT conditions (which are necessary and sufficient conditions in our case). To simplify the notation, let us assume that a big slot is equal to a small slot, that is, ∆ = δ (the proof is however still valid if a big slot is equal to multiple small slots). With ∆ = δ, we can write (STO1-Opt) as follows:

           maximize K(t) i=1 log   t+J j=t α ij r ij + c i   K(t) i=1 α ij = 1, j = t, t + 1, ..., t + J, α ij ∈ [0, 1], j = t, t + 1, ..., t + J, i = 1, . . . , K(t). (I R )
Let us denote by r ij the rate of user i at time j, and let c i be the total throughput allocated to user i up to present time. Consider the state R defined by

R =     r 1t r 2t • • • r K M t • • • • • • • • • • • • r 1,t+J r 2,t+J • • • r K M ,t+J c 1 c 2 • • • c K M     ,
in which the i th column provides all the information available for user i. We denote the above optimization problem by (I R ) to emphasize that it depends on R.

The Lagrange function of this convex optimization problem is

L = O(α) + j λ j (1 -i α ij ) + i,j ρ i,j α ij where O(α) = K(t)
i=1 log t+J j=t α ij r ij + c i . The KKT conditions for problem (I R ) are as follows:

       1, Primal feasibility: i α * ij = 1 ∀j, and α * ij ≥ 0 ∀i, j, 2, Dual feasibility: ρ * ij ≥ 0 ∀i, j, 3, Complementary slackness: α * ij ρ * ij = 0 ∀i, j, 4, Lagrange stationary: ri,j ci+ k α * ik r ik = λ * j -ρ * ij ∀i, j. (KKT)
The last condition is implied by

∇ α L(α * ) = 0. From (KKT), it follows that if ρ * ij > 0, then α * ij = 0 and ri,j ci+ k α * ik r ik = λ * j -ρ * ij < λ * j .
It implies that α * ij is positive only when ρ * ij = 0 and in this case the ratio ri,j ci+ k α * ik r ik = λ * j represents the maximum ratio one user i can get in slot j. Since i α * ij = 1, there exists at least one user who gets a strictly positive allocation in time slot j, i.e, there exists at least one user i for which ρ * ij = 0. The output that we consider is only the current allocation in time slot t, therefore we shall discuss only the continuity of the allocation at time t. Let denote by I t (R) the set of users who have a strictly positive allocation in current slot, i.e, I t (R) = {i | ρ * it (R) = 0}. By defining I t (R), we implicitly claim that ρ * it is defined uniquely by R and we shall prove later this uniqueness property. Consider the following sets

A = {R|#I t (R) = 1} and B = {R|#I t (R) ≥ 2} .
Then A and B represent a partition of the whole input space since #I t (R) ≥ 1 for all states R as explained above. The set A is the set of problem instances for which there is exactly only one user having a strictly positive allocation at time t, that user thus get full allocation and others get nothing. The set B is the complement. Proposition 1 below states two fundamental properties of the set A.

Proposition 1. It holds that:

• the allocation α * t = (α * it ) K i=1 is uniquely defined by R on A, • F : R → α * t = (α * it ) K i=1 is continuous on A, i.e, all potential discontinuities lie in B.
Proof. See Appendix A. Remark 6. Note that we do not claim that all points in the set B are points of discontinuity. We just claim that any discontinuity point necessarily belongs to the set B.

Proposition 1 shows that for all problem instances R ∈ A, there exists a unique allocation α t , and moreover that this allocation is continuous in R. However, the allocation is not necessarily unique for problem instances R ∈ B, and it may even be discontinuous in this set, as shown by our simple example in Section 4.1.

Ordering schemes reducing the number of discontinuities

The counter-example in Section 4.1 exhibits a discontinuity point of F . We note however that if, by convention, we assume that users are numbered in decreasing order of current rates, then this discontinuity point disappears. This suggests that an appropriate ordering scheme could help reducing the number of discontinuities of F . As stated in Proposition 1, F is continuous on A, so the set of all discontinuities is a subset of B. It is difficult to provide further information on this set for the general case. Therefore, we shall first consider in this section a small 2-dimensional example for which the analysis is easier, in order to understand better the behaviour of the output of F and how an ordering scheme could make it continuous.

We restrict ourselves to the case K = 2, J = 1 and t = 1 and we further assume that the total allocated throughput of each one of the two users is equal to 0. It follows that the input R is of the following form: Proposition 2. With the axes shown in figure 5, we have the following claims:

• B contains the lines r22 r21 = r12 r11 and the box defined by 0 ≤ r22 r21 ≤ 1 and 0 ≤ r12 r11 ≤ 1. • On A, the optimal current allocation is unique, continuous and integer.

• On the open box defined by 0 ≤ r22 r21 < 1 and 0 ≤ r12 r11 < 1, the optimal current allocation is unique, continuous but not integer, except for the inputs R on the line r22 r21 = r12 r11 . On the segment defined by r22 r21 = 1 and r12 r11 < 1, and on the segment defined by r12 r11 = 1 and r22 r21 < 1, the optimal current allocation is unique, continuous and integer.

• On the line r22 r21 = r12 r11 , the optimal current allocation is not unique and not continuous, no matter how we choose the current allocation among the set of optimal allocations. Proof. See Appendix B.

Figure 6 illustrates Proposition 2 by showing the different regions and the optimal solution in each region.

In this 2-dimensional case, the set of discontinuities (the line) is a small set in the sense that it has Lebesgue measure equal to 0. However it makes the model difficult to learn when the matrix input is near the line, since it oscillates between α * 1 = (0, 1) and α * 1 = (1, 0) outside the box and oscillates between

α * 1 = ( 1 2 -1 2 x, 1 2 + 1 2 x) and α * 1 = ( 1 2 + 1 2 y, 1 2 -1 2
y) (x ≈ y and x, y > 0) inside the box. In order to obtain a continuous function, we propose to choose the optimal allocation when it is not unique as illustrated in Figure 7. Define H(a 1 , a 2 ) = (max(a 1 , a 2 ), min(a 1 , a 2 )). If we choose the solution as described in Figure 7, H • F is a continuous function. It is reasonable to hope that learning H • F is easier than learning the non-continuous function F directly. In general, H is an order function, i.e., H(a 1 , a 2 , ..., a K ) = (a i1 , a i2 , ..., a i K ) such that a i1 ≥ a i2 ≥ • • • ≥ a i K . Once we learn H • F , we can recover F by storing the original places of all ordered elements. In more detail, we store the original places of all ordered elements by remembering the following function q: k = q(i k ), for all k = 1, 2, ..., K

In general, choosing an order in order to have a continuous function is not an easy task, since to choose an order as above we actually have to solve an optimization problem. We instead propose several heuristic orders, that are either based on current rate, based on the ratio between current rate and cumulative (the PF index), or based on the (PS) 2 S index [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF]. The numerical results of these heuristic orders are shown in Section 5.4.

Learning the dual values

The user ordering schemes introduced in Section 4.3 provide a partial solution for reducing the negative impact of discontinuities on the learning time. In this section, we propose an alternative approach which is based on Proposition 3 below. Proposition 3. The optimal solution of the dual problem is such that:

1. λ * = (λ t , λ t+1 , ..., λ t+J ) is uniquely defined by R and continuous in R.

ρ

* = (ρ * ij ) i=K,j=t+J i=1,j=t
is uniquely defined by R and continuous in R. Proof. See Appendix C. In summary, we know that the solution α * t of (I R ) is not continuous in the input R, but that the dual variables λ * and ρ * are. We thus propose the following idea. Instead of learning the allocation vector α * t , we could learn the dual variable ρ * . As mentioned above, the users who get a positive fraction of allocation α i,t > 0 all belong to the set I t (R). Therefore, after learning the dual values (ρ * ij ), we propose to choose the current allocation as follows: α * i * (t),t = 1 and α * i,t = 0 for all i ̸ = i * (t), where i * (t) is an index in I t (R). If there are more than one index in I t (R) we choose arbitrarily an index in that set. With the notations introduced in Appendix A, this is equivalent to first learning C * = (C * 1 , C * 2 , ..., C * K M ) and then choosing arbitrarily an index in the set argmax rit C * i .

Numerical Results

In this section, we do simulations to evaluate the influence of many factors on the behaviour of the DFNN model (loss functions, architecture of the DFNN, ordering schemes and learning dual values). We use the keras library [START_REF] Chollet | [END_REF] to implement our code.

There are actually a lot of factors that can have an impact on the behavior of the learning procedure such as the initial learning rate, the learning rate decay, the optimizer, the initial weight, the number of parameters, the activation functions in layers, an so on. Here we are not able to justify all our choices, but we focus on the factors which have the most significant impact on the learning algorithm in our opinion. The initial learning rate is chosen equal to 0.0015 and after each epoch, this learning rate decays by a factor 0.998.

A Unified Data Generator for Comparison

To support the comparisons in this section, the data (both for training and validation) is generated as follows. The number of users is generated randomly from 0 to K M = 10. The sojourn time of each user is generated in (0, 400) seconds. This value could of course be increased, but here in order to reduce the learning time and be able to make many comparisons, we consider only small scenarios. Generated dataset contains separate 1501 sets, each set contains 1600 samples. Two sets are kept for validation, i.e., 3200 samples are used to evaluate models. The remaining containing 1499 sets are used for training. At each learning epoch, the model will go through 1600 samples (that is, input-output pairs). The transmission rate in each small slot is generated randomly between 0 and 5δ/∆. The rate function we use for SUMO scenarios (see Section 5.5) is

r(x) = η 1 + κ e -d(x,BS)/σ , (1)
where d(x, BS) is the distance from position x to the BS, and η represents the noise level. For the SUMO scenarios in Section 5.5, we use κ = 3, σ = 100 and η ∼ Uniform(0.7, 1.3). The others parameters are equal to J = 10, ∆ = 1 s, δ = 2 ms. We remark that the rate function has an exponential decay with distance. For other smooth decay functions such as inverse square, the fundamental nature of the results (continuity, e.g.) and the conclusions (DFNN generate good quality solutions in a much shorter time compared to optimization solvers) of this paper will remain valid.

Comparison of different DFNN architectures

In this section, we will consider four different architectures of the DFNN model and compare their performances. The four models are as follows:

• Model 1 -The first model used in this section contains 2 layers which are 1 hidden layer and 1 output layer. The hidden layer contains 500 units, and in total the model has 67, 510 parameters. The architecture of this model is illustrated in Figure 8.

• Model 2 -As the first model, the second model contains 2 layers: 1 hidden layer and 1 output layer. However, the hidden layer contains 1000 units, and in total the model has 135, 010 parameters. We take the same number of layers as in Model 1 (but more units in hidden layers) in order to compare whether it is better to have more parameters.

• Model 3 -As the two previous models, the third model contains 2 layers (1 hidden layer and 1 output layer). The hidden layer contains 100 units, and we have 13, 510 parameters in total. We take the same number of layers as in Model 1 (but fewer units in hidden layers) to compare whether it is better to have fewer parameters. • Model 4 -The last model contains 10 layers which are 9 hidden layers and 1 output layer. Each hidden layer contains 82 units, and in total, the model contains 67, 496 parameters. We take a model that has almost the same number of parameters as Model 1, to compare whether it is better to have more layers or fewer layers.

For the 4 models, the activation function used in hidden layers is the ReLU function, whereas the output layer uses the softmax function since we want the sum of the allocations to be equal to 1. In this comparison, we use the same loss function for all models, this loss function is denoted by bce dice loss which is the sum of binary cross-entropy [START_REF]Cross entropyhttps[END_REF] and dice loss (which equals 1-dice coefficient [START_REF]Sorensen dice coefficienthttps[END_REF]).

Remark 7 (Joint power control and channel allocation). For the joint power control and channel allocation problem, we still compare the four above models except that the output layer of each model will be modified since it includes not only the channel allocation but also the power.

Figure 9a illustrates the loss of the 4 models on training and validation data. Figure 9b plots loss and absolute error of the 4 models on the same axis on validation set. The same quantities but for the problem of joint power control and channel allocation are shown in Figure 10a and Figure 10b respectively.

From these figures, we observe that for the model without power control:

• Having almost the same number of parameters, Model 1 with fewer layers is better than Model 4.

• Having the same layers, Model 1 and Model 2 with more parameters are better than Model 3. • Model 1 and Model 2 behave similarly and have the same number of layers.

However Model 1 has less parameters than Model 2 so it is less costly from a computational point of view. Therefore from now on we shall use Model 1 for other comparisons in the sequel.

For the model with power control:

• Having almost the same number of parameters, Model 1 with few layers is slightly better than Model 4, but the difference is quite small in this case.

• Having the same layers, models 1, 2 and 3 are almost the same but Model 3 has fewer parameters.

Comparisons of different loss functions

To compare the quality of the learning model obtained using different loss functions, we use the same model, that is Model 1. Figure 11 presents the results obtained with the Huber loss [27] against those obtained with bce dice loss. So for the next comparisons, we shall use Model 1 and bce dice loss.

Comparison of different ordering schemes

For reasons mentioned above, we shall use Model 1 and bce dice loss for this comparison. We compare the results obtained with 4 different ordering schemes: no order, current rate order, PF order and (PS) 2 S order [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF]. Figure 12 presents our numerical results. The (PS) 2 S order seems the best one among the 4 ordering schemes.

Comparison of learning the channel allocation against learning dual values

Next, we compare the approach which learns the dual values against the approach which learns directly the allocation. As before, for learning the allocation, we use Model 1 and bce dice loss. Since the dual values need not lie in [0, 1], we cannot use a softmax activation function in the output layer and bce dice loss. We shall normalize the dual values by dividing each element by a fixed constant to reduce its magnitude before fitting it into the DFNN model and shall use Huber loss together with relu activation. The absolute errors of the different learning schemes are shown in Figure 13.

Since the values of the allocation and the dual are different, it is not possible to compare the losses or absolute errors directly as before. We shall instead compare three different learning schemes (learning allocation without order, learning allocation with (PS) 2 S order and learning the dual values) on two different mobility scenarios generated with the SUMO simulation package [START_REF] Lopez | Microscopic traffic simulation using sumo[END_REF]. SUMO is an open source software designed for simulating mobility of moving users (vehicles, bus, truck, bicycle, pedestrian, ...) in large road traffic networks. It allows to import maps of different cities and simulate realistic mobility traces. SUMO is used to simulate the mobility of vehicular users in several specific regions of the Toulouse city and to compare our learning-based approaches against existing algorithms on realistic scenarios. The comparison proceeds in two steps: SUMO is first used for generating the mobility traces of vehicles, and then these traces are fed to a Python script which implements the algorithms and computes the value of the objective function for those algorithms.

The first scenario contains 244 users and lasts 61.7 minutes. The map of this scenario is shown in Figure 14. The results obtained with the different learning schemes on this scenario are shown in Figure 16, remark that by using the term "Learning Allocation No Order" in the figure, we means learning the primal value of the optimization which is the original allocation, without any order. The second scenario contains 214 users and lasts 62.4 minutes. The map of this scenario is shown in Figure 15. The data for BS location can be found on the website4 of the French Frequency Agency (ANFR), which manages all radio frequencies in France. The results obtained with the different learning schemes on this scenario are shown in Figure 17. We also simulate two existing algorithms, (PS) 2 S [START_REF] Margolies | Exploiting mobility in proportional fair cellular scheduling: Measurements and algorithms[END_REF] and PF [START_REF] Kelly | Charging and rate control for elastic traffic[END_REF] (which are also used in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF] for comparisons) in order to show that the approximation algorithm performs better than the existing algorithms. As mentioned above, for the learning algorithm, we use Model 1 and bce dice loss.

When the number of learning epochs is large enough, the learning-based scheme performs well compared to STO1 and other algorithms. Learning the dual values outperforms the two other learning schemes: it is more stable, provides a better allocation and it converges faster than learning directly the allocation without any ordering scheme. It costs the same time for prediction as the two other approaches since they are using the same architecture (that is, Model 1). However learning directly allocation with a user ordering scheme requires to compute in addition the order, which consumes more computing time than the other two approaches.

Influence of the number of vehicles

We now investigate the influence of the dimension of the input problems on the utility as well the prediction times of the proposed DFNN approach and compare them with that of the directly solving with Mosek.

For this, in the Carmes borough, we increase the arrival rate of users so as to have more users in the network, which corresponds to a higher K M . Five different arrivals rates were chosen corresponding to K M = 10, 20, 30, 40, 50. When K M increases, the size of input, output, and the complexity of the optimization problem inside STO1 also increase. That is the reason why we need to increase the size of DFNN architecture in order to increase the quality of approximation. In more detail, we increase the size of DFNN architecture by increasing the number of neurons in the hidden layer while keeping the same unique hidden layer. To explain why we do that, we refer readers to this reference [START_REF] Heaton | Artificial Intelligence for Humans: Deep learning and neural networks[END_REF] in which the author suggests how to prune the number of hidden layers and the number of neurons in the hidden layer. For learning Dual value, table 1 shows the corresponding the number of neurons in the unique hidden layer, the corresponding number of epochs at which the validation loss converges, the corresponding training time (in seconds) for each epoch and the corresponding whole training time (which equals the number of epochs times the training time in each epoch) for different values of K M . The weights chosen to evaluate for SUMO scenarios are taken at the epoch when the validation loss converges, i.e, there is no clearly seen improvement. The average utilities obtained by the different heuristics for these values of K M = 10 are shown in figure 18 as a function of the noise level, η. It is observed that Learning with dual values outperforms other heuristics in terms of the average utilities for all noise levels except level 0.0 where STO1 is marginally better. We also observe that learning without order (that is, learning directly the output of the solver) does not scale well when K M increases from 10 to 20. For this reason, in the experiments for K M = 40 and K M = 50, only the Learning from dual values heuristic is presented. For K M = 30, a similar result was observed. Its plot has been omitted for conciseness.

K M #
For learning the primal value (the original allocation) when K M is larger, we observed that it takes very long training epochs for the loss function to converge and the convergence might be far from the true value since the convergent loss is still very high. For example, for K M = 20, learning dual value needs 1800 epochs to converge as shown in table 1, but learning primal value needs more than 9000 epochs to converge, we stopped training at epoch 9000 and observed average absolute error around 0.04, i.e, the total absolute error is around 0.04 * 20 = 0.8 while the maximum absolute error is equal to 2 where the prediction vector and the true vector (which has unique position equal to 1 and 0 everywhere else) totally disagree. That is why the performance is bad as shown in figure 5.6.

Computing times

In this time, we use another machine to simulate the system, since the old machine (the one we used in 2020 to have the results in the previous version of this paper) does not work anymore. To make a consistent measurement, we decide to redo all experiments with another machine, those measurements are shown in the below paragraph and table 2.

The computing time of STO1 depends on the convex optimization solver used, whereas the learning algorithm has only to feed the DFNN model with the input matrix. We consider the same setting as in Section 5.2, that is K = 10 (there are exactly 10 users in the system) 5 and the short term horizon is J = 10 seconds. For these values, the average computing time of Mosek is around 20.61 ms, whereas the prediction with the DFNN model (1 hidden layer with 500 neurons) takes only 0.92 ms on average. When adding power control, Mosek solves the optimization problem in around 70.39 ms, while the prediction of the DFNN model (almost the same with Model 1 but the output layer contains power vector in addition, which contains 73,020 parameters) takes 1.04 ms on average. These computing times are averaged over 3000 samples. The experiments were done on a a AMD 7413 24-core processor. Note that, for STO1 (which uses Mosek to solve optimization) the computing time increases when the number of users in the system increases. For example, when K varies from 1 to 10, Mosek computing time varies from 19.94 milliseconds (K = 1) to 20.61 milliseconds (K = 10). For DFNN, the computing time changes only when we change the its architecture, that is only when K M changes. For 5 different values of K M , Table 2 shows detailed comparisons between computing time (in ms) of STO1 versus DFNN. The architecture DFNN for a given value of K M is the one presented in Sec. 5. [START_REF] Yi | Stochastic network utility maximisation -a tribute to Kelly's paper published in this journal a decade ago[END_REF] From the above measurements, we can conclude that even running with CPU, we still can see the improvement of DFNN compared to STO1.

Summary and Discussion

We have proposed to use a DFNN for learning the channel allocation obtained with one of the heuristics (STO1) introduced in [START_REF] Nguyen | An algorithm for improved proportionalfair utility for vehicular users[END_REF] and [START_REF] Nguyen | Joint downlink power control and channel allocation based on a partial view of future channel conditions[END_REF]. Numerical results on SUMO scenarios show that the learning-based method yields approximate yet satisfactory channel allocations with much less computation time as long as there are enough learning epochs. The state of the DFNN is defined in such a way that the model is not restricted to a particular scenario, that is, it can learn the channel allocation for a general network.

There are several directions of research that can be investigated to improve the learning algorithm, such as creating a better generator of data for learning, choosing a better loss function, choosing a better architecture of the DFNN model in which how to prune architecture (number of hidden layers and number of neurons for each layer) for different K M in an automatic way would be one of the most important things, and other things such as choosing a better optimizer, the learning rate, etc. Then (II R ) is equivalent to (I R ), and C is a convex set. Let C * be the optimal solution of (II R ).

Lemma 1. The optimal solution C * is uniquely defined by R and continuous in R.

Proof. Indeed since (II R ) is a convex optimization problem, we have for any

C ∈ C: ∇O C (C * )(C -C * ) T ≤ 0. (A.1)
where O(C) = i log(C i ). Let us take R ′ close to R, with |R ′ -R| ∞ = ϵ and assume that C ′ * is solution corresponding to the matrix R ′ . By definition of the set C, there exists α * and α ′ * such that:

C * i = t+J j=t α * ij r ij + c i , ∀i, C ′ * i = t+J j=t α ′ * ij r ′ ij + c ′ i , ∀i. (A.2)
It is obvious that C * i , C ′ * i are strictly positive ∀i. From (A.1) we obtain

K i=1 C i C * i ≤ K ∀C = (C 1 , C 2 , ...C K ) ∈ C. (A.3) It follows that K i=1 C ′ * i C * i = K i=1 t+J j=t α ′ * ij r ′ ij + c ′ i t+J j=t α * ij r ij + c i = K i=1 j α ′ * ij r ij + c i + t+J j=t α ′ * ij (r ′ ij -r ij ) + (c ′ i -c i ) t+J j=t α * ij r ij + c i ≤ K i=1 C i C * i + K i=1 t+J j=t α ′ * ij (r ′ ij -r ij ) + (c ′ i -c i ) t+J j=t α * ij r ij + c i ≤ K i=1 C i C * i + A 1 ϵ ≤ K + A 1 ϵ, (A.4)
where

C i = j α ′ * ij r ij + c i for all i and A 1 = K i=1 (J+1)+1 C * i
is a positive number which does not depend on ϵ.

The fourth implication follows from |R ′ -R| = ϵ and 0 ≤ α ′ * ij ≤ 1, whereas the last implication follows from (A.3) and the fact that C

= (C i ) i ∈ C. So from 35 (A.4) we get K i=1 C ′ * i C * i ≤ K + A 1 ϵ. Similarly, we have K i=1 C * i C ′ * i ≤ K + A 2 ϵ,
where A 2 is also a positive number not depending on ϵ. It implies that

K i=1 C * i C ′ * i + C ′ * i C * i ≤ 2K + (A 1 + A 2 )ϵ.
Combining this with the fact that for each i we have

C * i C ′ * i + C ′ * i C * i ≥ 2 (this is
implied by the AM-GM inequality which claims that a + b ≥ √ ab for all a ≥ 0 and b ≥ 0), we obtain

C * i C ′ * i + C ′ * i C * i ≤ 2 + (A 1 + A 2 )ϵ, ∀ i. Define z i = C * i C ′ * i
. Then, we have z i > 0 and z i + 1/z i ≤ 2 + (A 1 + A 2 )ϵ. This is a quadratic inequality, and solving it we get

1 + Dϵ -(Dϵ) 2 + 2Dϵ ≤ z i ≤ 1 + Dϵ + (Dϵ) 2 + 2Dϵ, (A.5)
for all i, where D = A1+A2 2 > 0 does not depend on ϵ. From (A.4) and (A.5) we have that:

• From (A.4), if we take R ′ = R, the last inequality becomes

K i=1 C ′ * i C * i ≤ K,
and also

K i=1 C * i C ′ * i ≤ K.
Similarly to above implications, this implies z i + 1/z i = 2 for all i. It implies that t i = 1 for all i, i.e, C * i = C ′ * i for all i, which shows the uniqueness of the solution of (II R ).

• From (A.5), we obtain that

lim ϵ→0 C ′ * i C * i = 1 ∀i, (A .6)
i.e., lim ϵ→0 C ′ * i = C i for all i, which proves the continuity of C * in R.

Proof. (proof of proposition 1) Recall that A = {R|#I t (R) = 1}, i.e., given R ∈ A, there exists an unique i 0 such that ρ i0t = 0 and for every i ̸ = i 0 we have ρ it > 0. It yields

r i0t C * i0 = λ * t > λ * t -ρ * it = r it C * i , ∀i ̸ = i 0 , (A.7)
and α * i0t = 1, whereas α * it = 0 for all i ̸ = i 0 . This means that the allocation α * t is unique for every input state R in A. Consider R ∈ A and R ′ close to R: |R ′ -R| ∞ = ϵ. Since we consider the continuity of the current allocation only, our objective is to prove that α ′ * t = (α ′ * it ) i is close to α * t = (α * it ) i . In fact we have that α ′ * t = α * t if ϵ is small enough. Indeed, from claim (A.5) in Lemma 1, we have

C ′ * i C * i = 1 + O( √ ϵ) (0 < lim ϵ→0 O( √ ϵ) ϵ
< +∞) , where (C * i ) i and (C ′ * i ) i are the solutions of (II R ) corresponding to inputs R and R ′ , respectively. Since R ∈ A, there exists i 0 such that

ri 0 t C * i 0 > ri t C * i for all i ̸ = i 0 . It implies that r ′ i 0 t C ′ * i 0 > r ′ i t C ′ * i for all i ̸ = i 0 if ϵ is small enough. In turn, this implies that α ′ * i0t = 1 and α ′ * it = 0 for all i ̸ = i 0 , that is, α * t = α ′ * t .

Appendix B. Proof of Proposition 2

Let us characterize the set B = {R|#I 1 (R) ≥ 2}. The set A will be the complement. Since we have 2 users,

ρ * 11 = ρ * 21 = 0. (B.1)
Combining with the fourth condition in (KKT) we have:

r 11 C * 1 = r 21 C * 2 . (B.2)
There are three possible cases:

• Case 1: α * 12 ∈ (0, 1), which implies that α * 22 ∈ (0, 1).

) + t(1 -α 12 ))] ⇔ max [log(X) + log ((1 + t) -X)] (where X = α 11 + tα 12 ) ⇔ max [X ((1 + t) -X)] . (B.5)
We have

X ((1 + t) -X) ≤ (X + ((1 + t) -X)) 2 4 = (1 + t) 2 4 ,
and the equality occurs if only if X = 1+t 2 , i.e, if α 12 = 1+t 2t -α11 t . So, we get

α * = a 1 -a 1+t 2t -a t t-1 2t + a t , with a ∈ [max(0, 1-t 2 ), min(1, 1+t
2 )] to guarantee that every value in the matrix is in [0, 1]. Conclusion for case 1: on the line r12 r11 = r22 r21 , the solution is not unique, the solutions are of the above form. Let us check whether the optimal α * 11 is on the boundary or is the above stationary point. On the boundary we have:

f (0) = -∞, f (1)
= log(r 11 ) + log(r 22 ) > f (0).

For the stationary point, we have two cases: So in this case the optimal solution is given by α 11 = 1 2 1 + r22 r21 and the matrix input has to satisfy r22 r21 ≤ 1.

• If α 11 = 1 2 1 + r22 r21 ∈ [0,
• If α 11 = 1 2 1 + r22 r21 > 1 then we get r22 r21 > 1 and f attains its maximum at That is a contradiction.

Conversely, if r22 r21 > r12 r11 (here we consider only the strict inequality since the equality has been already considered in case 1) and 0 ≤ r22 r21 ≤ 1. Then the solution of (I R ) is this form: Conclusion for case 2: The region in this case is equal to the region defined by r22 r21 ≥ r12 r11 and 0 ≤ r22 r21 ≤ 1. On the triangle defined by r22 r21 > r12 r11 (strictly inequality here) and 0 ≤ r22 r21 ≤ 1, the solution is unique, and is given by

α 11 = 1 2 1 + r 22 r 21 .
The formula shows the continuity on the interior of the triangle. In this region, except on the segment defined by r22 r21 = 1 ≥ r12 r11 , the solution is not integer. .

Conclusion for case 3:

The region in this case is equal to the region defined by r22 r21 ≤ r12 r11 and 0 ≤ r12 r11 ≤ 1. On the triangle defined by r22 r21 < r12 r11 and 0 ≤ r12 r11 ≤ 1, the solution is unique, and is given by

α 11 = 1 2 1 - r 12 r 11 . (B.16)
The formula shows the continuity on the interior of the triangle. In this region, except on the segment r12 r11 = 1 ≥ r22 r21 , the solution is not integer. The above analysis characterizes the structure of the set B. Since A is the complement of B, it contains two connected components: one defined by r12 r11 > 1 and r12 r11 > r22 r21 ; and the other one defined by r22 r21 > 1 and r12 r11 < r22 r21 . Recall that on A we have: #I 1 (R) = 1, i.e at time slot 1 only one user gets a full allocation while the other one gets nothing. There are thus only two options: either (α * 11 , α * 21 ) = (0, 1) or (α * 11 , α * 21 ) = (1, 0). As stated in Proposition 1, (α * 11 , α * 21 ) is continuous on A. Together with the fact that there are only two possible options for the output which is of discrete type, this implies that F must be equal to a constant (either (0, 1) or (1, 0)) in each connected component. Therefore, to know which value of the output corresponds to each connected component, we just need to choose one point in that connected component of A and solve the optimization problem for that point.

Let use consider the first connected component of A which is defined by

Figure 1 :

 1 Figure 1: The different types of time slots in the STO1 algorithm.

Figure 2 :

 2 Figure 2: An example of Deep Feedforward Neural Network.

Figure 3 :

 3 Figure 3: Input and output of the DFNN model.

Figure 4 :

 4 Figure 4: Two connected components of E i,1 ∀i.

Figure 5

 5 Figure5shows the structure of the sets A and B, which is proven in Proposition 2.

1 1Figure 5 : 2 -

 152 Figure 5: 2-dimension illustration for the sets A and B.

1 Figure 6 :

 16 Figure 6: The output of STO1 in 2-dimension.

Figure 7 :

 7 Figure 7: Choosing solution in the line to obtain a continuous function in 2-dimension.

Figure 8 :

 8 Figure 8: Model 1 architecture.

( a )Figure 9 :Figure 10 :

 a910 Figure 9: Comparison of the 4 DFNN models.

  (a) Absolute error on training and validation set of the two losses (b) Plot on same axis of the absolute error on validation of the two losses

Figure 11 :

 11 Figure 11: Comparison of Loss functions.

Figure 13 :

 13 Figure 13: Comparisons of Absolute Error of the Learning Allocation and Learning Dual Value.

Figure 14 :

 14 Figure 14: The Carmes borough in Toulouse, with one BS (Free Mobile type LTE1800). The actual size is 200m × 400m.

Figure 15 :

 15 Figure 15: Duroux, one BS type LTE1800, operator SFR. The actual size is around 350×500m.

Figure 16 :

 16 Figure 16: Comparisons of evaluated on Carmes scenario created by SUMO of Allocation and Dual Value.

Figure 17 :

 17 Figure 17: Comparisons of evaluated on Duroux scenario created by SUMO of Allocation and Dual Value.

(d) K M = 50 Figure 18 :

 5018 Figure 18: Comparision of the average utility with the noise level for different values of K M .

7 )

 7 Case 2: α * 12 = 0 and therefore α * 22 = 1. This implies On the other hand, in this case Problem (I R ) amounts to finding the maximum of [log(r 11 α 11 ) + log(r 21 (1 -α 11 ) + r 22 )] := f (α 11 ). f ′ (α 11 ) = 0 ⇔ α 11 =

2 = r 22

 222 α 11 = 1 (and therefore α 21 = 0). But it can not happens in the set B with ρ * 11 = ρ * 21 = 0. Indeed, in this case, C * 1 = r 11 , C *

KKT= 1 2 1

 11 === ⇒ α * 12 = 0 and therefore α * 22 = 1. Therefore, (I R ) becomes an optimization problem of one variable α 11 , and by solving it we get α * 11 = 21 + r 22 ( therefore = λ * 1 ) =⇒ ρ * 11 = ρ * 21 = 0. (B.15)

Case 3 :

 3 Similar to case 2, if α * 12 = 1, then R has to satisfy: 0 ≤ r12 r11

r12 r11 > 1

 1 and r12 r11 > r22 r21 . In this region, (α * 11 , α * 21 ) = (0, 1). Indeed, let us choose one input point in this connected component such that it satisfies r 11 > 1. Since either α * 11 = 0 or α * 11 = 1, we just need to compare max O |α11=1 (α 12 ) and max O |α11=0 (α 12 ). We have O |α11=1 = log(r 11 + α 12 r 12 ) + log((1 -α 12 )r 22 ) := g(α 12 ).(B.17) This is a function of one variable α 12 , we have:g ′ (α 12 ) = 0 ⇐⇒ α 12 = 1 -r 11 1 + r 12 . (B.18)We have α 12 = 1-r11 1+r12 < 0 since r 11 > 1. Therefore the optimal α * 12 is stay in the boundary, i.e,max O |α11=1 = max O |α11=1,α12=1 , O |α11=1,α12=0 (B.19) = max (log(r 11 ) + log(r 22 ), -∞) (B.20) = log(r 11 ) + log(r 22 ). (B.21) On the other hand, O |α11=0 = log(α 12 r 12 ) + log(r 21 + (1 -α 12 )r 22 ). (B.22) Combining with the condition r12 r11 > r22 r21 we obtain O |α11=0,α12=1 = log(r 12 ) + log(r 21 ) (B.23) > log(r 11 ) + log(r 22 ) (B.24) = max O |α11=1 . (B.25)

Table 1 :

 1 Training time in second.

		neurons in time training # epochs to	whole
		hidden layer	per epoch	converge	training time
	K M = 10	500	0.265	1400	371.0
	K M = 20	700	0.282	1800	507.0
	K M = 30	1000	0.297	3000	891.0
	K M = 40	3000	0.301	4500	1354.5
	K M = 50	10000	0.393	7000	2751.0

  and Table1. The entries of the table should be read as follows. For example, for K M = 10, the computting time of STO1 varies from 19.94 ms to 20.56 ms when K varies from 1 to 10. The inference time of the DFNN depends only on K M and hence has only one value which is 0.92 ms.

	K M	10	20	30	40	50
	K	[1, 10]	[11, 20]	[21, 30]	[31, 40]	[41, 50]
	STO1 [19.9, 20.6] [20.6, 22] [22, 22.6] [22.5, 23.2] [23.3, 23.8]
	DFNN	0.92	0.93	0.95	1.04	1.18

Table 2 :

 2 Comparison of computing time (in milliseconds) between STO1 and DFNN for different numbers of users K and K M .

  11 + tα 12 ) + log(α 21 + tα 22 )] ⇔ max [log(α 11 + tα 12 ) + log((1 -α 11

	• Case 2: α * 12 = 0, which implies that α * 22 = 1.
	• Case 3: α * 12 = 1, which implies that α * 22 = 0.
	Case 1: α * 12 ∈ (0, 1) and therefore α * 22 ∈ (0, 1). From the second condition in (KKT), it implies ρ * 12 = ρ * 22 = 0. Combining with the fourth condition in
	(KKT) we have:	r 12 C * 1	=	r 22 2 C *	.		(B.3)
	Dividing (B.3) by (B.2) side by side we get:
		r 12 r 11	=	r 22 r 21	.		(B.4)
	Conversely, if r12 r11 = r22 r21 , we shall prove that the solution of (I R ) is of the form
	α * 11 α * 21 α * 12 α * 22	=	a 2t -a 1+t t	1 -a t-1 2t + a t	,
	for any a ∈ [max(0, 1-t 2 ), min(1, 1+t 2 )], where t = r12 r11 = r22 r21 . Indeed, problem
	(I R ) is equivalent to the following problem:
	max [log(α

  1], i.e r 22 ≤ r 21 , then we have:

	f	1 2	1 +	r 22 r 21	= log r 11	r 21 + r 22 2r 21	+ log	r 21 + r 22 2	(B.9)
					≥ log(r 11 ) + log(r 22 )(since r 22 ≤ r 21 )	(B.10)
					= f (1)				(B.11)

We use data rate and throughput to denote two different but related quantities. The throughput only takes into account the data rate of the time-slots in which a user is served. It is thus no more than the total data rate of this user.

STO2 is similar to STO1 but solves the optimization problem less frequently. In this paper we shall focus on STO1 but the ideas developed here can be applied to STO2 as well.

https://data.anfr.fr/anfr/portail

Recall that K is the number of cars that are present at a given time, whereas K M is the maximum number of cars that are simultaneously present in the coverage range. That is K ≤ K M .

Acknowledgment

The authors would like to thank Continental Digital Service France for supporting partially this work.

⋆ This work was funded in part by a contract with Continental Digital Services France.

Appendix A. Proof of Proposition 1

Before proving Proposition 1, we need a lemma, in which we shall consider the following equivalent problem:

where

This implies α * 11 = 0 in this case. Similarly, for the connected component defined by r22 r21 > 1 and r12 r11 < r22 r21 we have α * 11 = 1.

Conclusion:

• B contains the box restricted by 0 ≤ r12 r11 ≤ 1 and 0 ≤ r22 r21 ≤ 1 and the line r22 r21 = r12 r11 . A is the remaining region. • As proven in Proposition 1, the allocation is continuous on A, and moreover on the region defined by r12 r11 > 1 and r12 r11 > r22 r21 , α * 11 = 0, on the region defined by r22 r21 > 1 and r12 r11 < r22 r21 , α * 11 = 1.

Combining with the formulas obtained in the three above cases for the set B, we can see that the set of all discontinuities is the line r12 r11 = r22 r21 .

) is uniquely defined except on the line r22 r21 = r12 r11 .

Appendix C. Proof of Proposition 3

We first prove the first assertion. From the third condition of (KKT), for each time slot j, there exists at least one i 0 such that ρ * i0j = 0. Combining with the fourth condition of (KKT) we obtain that λ * j = max i rij C * i , that is, the maximum is attained because of the existence of i 0 . Since C * is unique and continuous in R, it implies the uniqueness and continuity of λ * .

Regarding the second assertion, it follows from the fourth condition of (KKT) that ρ * ij = λ * j -

Since C * and λ * are unique and continuous in R, it implies the uniqueness and continuity of ρ * .