Learning to Cooperate in D2D Caching Networks

TL;DR

This paper introduces an online learning algorithm for D2D caching networks that optimally manages content storage and retrieval, minimizing delivery costs without prior knowledge of request patterns.

Contribution

It proposes a distributed online gradient descent-based policy that adapts caching decisions in real-time, achieving asymptotic optimality for arbitrary request processes.

Findings

The algorithm effectively reduces delivery costs in simulated D2D networks.

It operates without prior knowledge of request distributions.

The policy is scalable and suitable for distributed implementation.

Abstract

We consider a wireless device-to-device (D2D) cooperative network where memory-endowed nodes store and exchange content. Each node generates random file requests following an unknown and possibly arbitrary spatio-temporal process, and a base station (BS) delivers any file that is not found at its neighbors' cache, at the expense of higher cost. We design an online learning algorithm which minimizes the aggregate delivery cost by assisting each node to decide which files to cache and which files to fetch from the BS and other devices. Our policy relies on the online gradient descent algorithm, is amenable to distributed execution, and achieves asymptotically optimal performance for any request pattern, without prior information.

Equations

$$\mathcal{R}=\left\{r\in\{0,1\}^{N\!\cdot\!I}~{}\bigg{|}~{}\sum_{n\in\mathcal{N}}\sum_{i\in{\mathcal{I}}}r^{i,n}=1\right\}.$$

$$\mathcal{Y}=\left\{y\in[0,1]^{N\cdot I}~{}\Bigg{|}~{}\sum_{n\in\mathcal{N}}y^{i,n}\leq C_{i},~{}i\in{\mathcal{I}}\right\}.$$

$$\sigma^{i}\big{(}r_{1},\ldots,r_{t-1};y_{1}^{i},\ldots,y_{t-1}^{i}\big{)}:\longrightarrow y_{t}^{i}\in[0,1]^{N}.$$

$${\cal Z}_{t}(y_{t})\!=\!\left\{z\!\in\![0,1]^{N\!\cdot\!I^{2}}\Bigg{|}\begin{array}[]{c}\sum_{j\in{\mathcal{I}_{+}}}z^{n,i,j}_{t}\!=\!r^{n,i}_{t},\vspace{1.5mm}\\ z^{n,i,j}_{t}\!\leq\!\ell_{ij}y^{n,j},~{}i,j\!\in\!{\mathcal{I}},n\!\in\!{\cal N}\end{array}\right\}.$$

$$f_t(y_t)=\underset{z_t\in {\mathcal{Z}}_t(y_t)}{\min }\sum _{n\in \mathcal{N}}\sum _{i\in \mathcal{I}}\sum _{j\in {\mathcal{I}}_{+}}{r}_t^{i,n}{c}_{ij}{z}_t^{n,i,j},$$

$$f_{t}\big{(}\lambda y_{1}+(1-\lambda)y_{2}\big{)}\leq\lambda f(y_{1})+(1-\lambda)f(y_{2}).$$

$$f_t(y_k)=\sum _{n\in \mathcal{N}}\sum _{i\in \mathcal{I}}\sum _{j\in {\mathcal{I}}_{+}}{r}_t^{i,n}{c}_{ij}{z}_k^{\ast ,n,i,j},\forall k\in \{1,2\},\text{and}$$

$$f_t(\overline{y})$$

$$\le \sum _{n\in \mathcal{N}}\sum _{i\in \mathcal{I}}\sum _{j\in {\mathcal{I}}_{+}}{r}_t^{i,n}{c}_{ij}{z}^{n,i,j},\forall z\in {\mathcal{Z}}_t(\overline{y}).$$

$$=\sum _{n\in \mathcal{N}}\sum _{i\in \mathcal{I}}\sum _{j\in {\mathcal{I}}_{+}}{r}_t^{i,n}{c}_{ij}\left(\lambda z_1^{\ast ,n,i,j}+(1-\lambda )z_2^{\ast ,n,i,j}\right)$$

$$\displaystyle\overset{\text{\eqref{eq:proofConv}}}{\geq}f_{t}\big{(}\lambda y_{1}+(1-\lambda)y_{2}\big{)}.\,\,\,\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\blacksquare$$

$$R_T(\sigma )=\underset{P(r_1,r_2,..r_T)}{\max }\mathbb{E}\left[\sum _{t=1}^T{f}_t(y_t(\sigma ))-\sum _{t=1}^T{f}_t(y^{\ast })\right].$$

$$y^{\ast }\in \arg \underset{y\in \mathcal{Y}}{\max }\sum _{t=1}^T{f}_t(y),$$

$$\underset{T\to \infty }{\lim }{R}_T(\sigma )/T=0.$$

$$f_t(y_t)=$$

$$\sum _{j\in \mathcal{J}(i_t)}{z}^{n_t,i_t,j}=1$$

$$z^{n_t,i_t,j}\le y_t^{n_t,j},\forall j\in \mathcal{J}(i_t).$$

$$L_t(y,z,\alpha ,\beta )$$

$$+\sum _{j\in \mathcal{J}(i_t)}{\beta }^j(z^j-y^j),$$

$${\beta }^{\ast }(y_t)\in \arg \underset{\beta \ge 0}{\max }\left(\underset{\alpha \in \mathbb{R}}{\max }\underset{z\in [0,1{]}^{I_{+}}}{\min }L(y_t,z,\alpha ,\beta )\right)$$

$$g_t^{n,i,j}(y_t)=\{\begin{array}{l}-{\beta }^{\ast ,j}(y_t),\text{ if }i=i_t,n=n_t,j\in \mathcal{J}(i_t)\\ 0,\text{ otherwise}\end{array}.$$

$$\Lambda (y,\beta )=\underset{\alpha \in \mathbb{R}}{\max }\underset{z\in [0,1{]}^{I_{+}}}{\min }L(y,z,\alpha ,\beta ),\forall y\in \mathcal{Y},\text{and hence:}$$

$$f_t(y_t)$$

$$\stackrel{(c)}{\le }\Lambda (y^{\prime },{\beta }^{\ast }(y^{\prime }))+{\beta }^{\ast }(y_t)(y^{\prime }-y_t),$$

$$y_{t+1}^j={\Pi }_{[0,1{]}^N}\left(y_t^i+\gamma {\beta }_t^{j,\ast }(y_t)e_{n_t}\right),$$

$$R_T(DOCP)\le c^{\ast }\sqrt{2CJ}\sqrt{T},$$

$${\Vert y_{t+1}-y^{\ast }\Vert }^2\le {\Vert y_t-\gamma g_t(y_t)-y^{\ast }\Vert }^2$$

$$={\Vert y_t-y^{\ast }\Vert }^2+{\gamma }^2{\Vert g_t(y_t)\Vert }^2-2\gamma g_t(y_t{)}^{\top }(y_t-y^{\ast }).$$

$$\le {\Vert y_1-y^{\ast }\Vert }^2+{\gamma }^2\sum _{t=1}^T{\Vert g_t(y_t)\Vert }^2-2\gamma \sum _{t=1}^T{g}_t(y_t{)}^{\top }(y_t-y^{\ast }).$$

$$\sum _{t=1}^T{g}_t(y_t{)}^{\top }(y_t-y^{\ast })\le \frac{2C{J}^{\ast }}{2\gamma }+\frac{\gamma T(c^{\ast }{)}^2}{2}.$$

$$R_T(DOCP)=\sum _{t=1}^T(f_t(y_t)-f_t(y^{\ast }))\le \frac{2C{J}^{\ast }}{2\gamma }+\frac{\gamma T(c^{\ast }{)}^2}{2}.$$

$$f_t(y_t)=\underset{z_t\in {\mathcal{Z}}_t(y_t)}{\min }\sum _{n\in \mathcal{N}}\sum _{i\in \mathcal{I}}\sum _{j\in {\mathcal{I}}_{+}}{r}_t^{i,n}{c}_{ij}^t{z}_t^{n,i,j},$$

Full text

I Introduction

The rapidly growing demand for mobile content delivery [1] creates new revenue opportunities for wireless networks, but also requires to increase rapidly their capacity. Unfortunately, typical solutions based on PHY-layer advances or network densification are constantly outpaced by the increasing demand [19], and this calls for new content delivery approaches. To this end, a potentially game-changing idea is to employ device-to-device (D2D) communications where memory-endowed user devices can cache popular files and exchange them with each other upon request [9]. Such cooperative D2D swarms can increase the network content delivery capacity, mitigate cellular congestion, and improve the end-user experience.

A key challenge in D2D cooperative caching is to design the caching policy, i.e., identify which files to cache at each device at any given time [20]. On the one hand the devices have small storage and therefore can store only a small subset of the possible content files; on the other hand each of them “sees” a small number of requests per unit time and hence estimating the popular files at each location becomes very challenging. In view of these limitations, the devices may consistently fail to store in their cache the files that will be requested in the future by their neighbors, rendering the D2D cache-hit ratio practically negligible and hence this solution ineffective.

Caching policies often assume that requests are generated by a given stationary process, cf. [19], and systems in practice rely on reactive policies such as LFU and LRU. These, however, solve the 1-cache problem conditionally on the request process. For example, LFU is suitable for stationary requests [7], and LRU for the adversarial model [17]. When the actual process is other than assumed these policies perform poorly [18], and this problem is exacerbated in D2D networks where popularity has hot spots in time and space. Recently, [8, 14, 2] proposed dynamic policies for caching networks, e.g., the m-LRU [8] or “lazy rule” [14] policies, which however do not offer performance guarantees. Hence, the problem of designing a policy robust to the D2D network dynamics is an equally challenging and important open problem.

In this cooperative D2D network, users might change positions and content preferences, and hence we need an algorithm that will allow each device to decide: (i) which files to cache for serving its neighbors’ needs; (ii) from which neighbors to retrieve a file, and when to use the last-resort solution of the base station (BS), Fig. 1. This requires a learning mechanism for making caching and routing decisions in an online and decentralized fashion. Previous efforts employing learning are restricted either to inference of the popularity model [3, 4]; or rely in Q-learning [21, 24] and classification techniques [15] to estimate request frequencies. These approaches are not applicable to this D2D scenario as they are centralized, exhibit often high complexity, presume a stationary model, and do not decide routing. Other interesting suggestions for D2D networks, see [13, 6], suffer from computational complexity or rely on assumptions that are valid only in some cases, e.g., known popularity. Finally, [11] proposes a decentralized D2D file sharing algorithm which however needs access to the pattern of file requests and network evolution.

Here we design a caching policy that has universally-optimal performance, which is defined as the cost for delivering the requested files to users through (cheap) D2D or (costly) BS-to-device transmissions. We formulate the D2D caching operation as an online convex optimization (OCO) problem, and develop a dynamic and distributed algorithm that solves it without the need to make any assumption about the request pattern. That is, our policy ensures asymptotically no regret, as it achieves no more average cost than a static caching configuration selected with knowledge of future requests.

The contributions of this paper can be summarized as follows. (i) We propose the idea of embedding a distributed online learning mechanism to D2D caching policies. We achieve this by formulating an OCO problem, and this opens a link between caching and this novel machine learning tool. (ii) We design an online caching policy that leverages the online gradient descent algorithm to achieve asymptotically optimal performance under any possible spatio-temporal request pattern in our D2D network. We also explain how our policy can adapt to network changes and user churn. (iii) We compare our policy with the state-of-the-art mLRU and “lazy” LRU policies, verifying that it outperforms its competitors, while converging to the optimal static policy.

II System model

Network. Consider a set ${\mathcal{I}}$ of $I$ wireless users in an area, each one with a cache of size $C_{i}\geq 0,i\in{\mathcal{I}}$. Let ${\cal L}$ be the set of direct links connecting the users, where a link appears if the devices’ proximity and the electromagnetic environment allows it to be reliably established. A link between $i$ and $j$ is associated to a cost $c_{ij},\,(i,j)\!\in\!{\cal L}$, which represents, e.g. application-layer latency performance or energy consumption during content transmission; and we assume $c_{ii}=0,\forall i\in{\mathcal{I}}$. All users maintain a connection with a base station (BS, subscripted with [math]), and we define ${\mathcal{I}_{+}}={\mathcal{I}}\cup\{0\}$ and $I_{+}=|{\mathcal{I}_{+}}|$. The users can obtain any file from the BS at cost $c_{i0}>c_{ij},~{}\forall i\!\in\!{\mathcal{I}},(i,j)\!\in\!{\cal L}$. We assume that links can deliver the requested content in the considered time window.

Requests. There is a catalog $\mathcal{N}$ with $N$ files of unit size. The system operation is time-slotted, and $r_{t}^{i,n}\!\in\!\{0,1\}$ denotes the event that a request for file $n$ has been submitted by user $i$ during slot $t$. At each $t$ we assume there is one request, or, from a different perspective, that the system decisions are updated after each request.111We can also consider batches of requests. If the batch has 1 request from each location, the pattern is biased to equal request rate at each location. An unbiased batch should contain an arbitrary number of requests from each location. Our guarantees hold for unbiased batches of arbitrary finite length. Hence, the request process is described by a sequence of vectors $\{r_{t}\}_{t=1,\dots,T}$ drawn from set:

[TABLE]

The instantaneous file popularity is expressed by the probability distribution $P(r_{t})$ (with support $\mathcal{R}$), which is allowed to be unknown and arbitrary. The same holds for the joint distribution $P(r_{1},\dots,r_{T})$ that describes the file popularity evolution, for any user location, and within an interval of $T$ slots. This generic model captures all possible spatio-temporal request sequences, including stationary (i.i.d. or otherwise), non-stationary, and adversarial models. The latter is the most general case, as they include request sequences selected by an adversary aiming to disrupt the system performance.

Caching. The cache of each user $i\in{\mathcal{I}}$ can store only $C_{i}\!<\!N$ files, but the BS has the entire catalog. Following the standard practice in wireless caching models [9, 19], we perform caching using the Maximum Distance Separable (MDS) codes. In MDS, the files are split into a fixed number of $F$ data chunks, and we store in each cache an amount of coded chunks that are pseudo-random linear combinations of the data chunks. Using the MDS properties, a user can decode the file (with high probability) if it receives any $F$ coded chunks. Hence, the caching decision vector $y_{t}$ has $N\!\cdot\!I$ elements, where $y_{t}^{i,n}\!\in\![0,1]$ denotes the amount of random coded chunks of file $n$ stored at user $i$ during slot $t$.222The fractional caching is supported by the observation that large files are composed of thousands chunks, stored independently, see literature of partial caching [16]. Hence, by rounding these fine-grained fractional decisions, we will only induce a small application-specific error. In some prior caching models, fractional variables represent probabilities of caching [22, 5]. Based on this, we introduce the convex set of eligible caching vectors:

[TABLE]

We are interested in distributed policies, where each user $i$ changes its cache $y^{i}_{t}=(y_{t}^{n,i},n\!\in\!{\cal N})$ based on information from its one-hop neighbors $j:\,(i,j)\!\in\!{\cal L}$. Thus, we define:

Definition 1** (Local Caching Policy).**

A local caching policy $\sigma^{i}$ for user $i$ is a (possibly randomized) rule

[TABLE]

The collection $\sigma=\{\sigma^{i},i\in{\mathcal{I}}\}$ of the caching policies for all users will be henceforth referred to as a “caching policy”.

Routing. Since each user $i\!\in\!\mathcal{I}$ might have more than one neighbors, we introduce routing variables to determine the cache from which the requested file will be fetched. Let $z^{n,i,j}_{t}\in[0,1]$ denote the portion of request $r_{t}^{n,i}$ that is fetched from cache $j$, and we define the routing vector $z_{t}=(z^{n,i,j}_{t},n\!\in\!{\cal N},i,j\!\in\!{\mathcal{I}})$ implemented in slot $t$. There are two important remarks here. First, due to the coded caching model, the requests can be simultaneously routed from multiple caches. In terms of communications, this can be implemented through time-sharing among the activated links, or using concurrently different network interfaces. Second, the caching and routing decisions are coupled and constrained: (i) a request cannot be routed from an unreachable cache, (ii) we cannot route from a cache more data chunks than it has, and (iii) each request must be fully routed.

We define $\ell_{ij}\!=\!1$ if $\{(i,j)\in{\cal L}\}$ and $\ell_{ij}\!=\!0$ otherwise, and thus the set of eligible routing decisions conditioned on $y_{t}$ is:

[TABLE]

Note that $z^{n,i,0}_{t}$ does not appear in the second constraint, because the BS stores the entire catalog and can serve all users. This last-resort routing option ensures that ${\cal Z}_{t}(y_{t})$ is non-empty for any $y_{t}\!\in\!\mathcal{Y}$. As it will become clear next, the optimal routing decisions can be devised for a given cache configuration. This is an inherent property of link-uncapacitated caching networks, see also [9, 19].

III Problem Formulation

A file request of a node can be served, exclusively or partially (due to MDS), by neighboring devices at a smaller cost than fetching it from the base station. Given a cache configuration $y_{t}$, the (minimum) cost to satisfy $r_{t}$ is:

[TABLE]

where the optimization decides the routing that minimizes the cost for a given file placement at the nodes. The function’s form suggests that is beneficial if the file has been cached at the device asking for it ($c_{ii}=0$) or at nearby devices that can send it with low cost. However, it is daunting to assess the impact of $y_{t}$, as it involves the solution of an optimization problem. Fortunately, the cost function above is convex:

Lemma 1**.**

Function $f_{t}(y)$ is convex in its domain ${\cal Y}$, $\forall r_{t}\in{\cal R}$.

Proof: Fix a request vector $r_{t}$ and consider cache configurations $y_{1},y_{2}\!\in\!{\cal Y}$; note that, for any $\lambda\!\in\![0,1]$, $\overline{y}\!=\!\lambda y_{1}\!+\!(1\!-\!\lambda)y_{2}$ is also a valid configuration. We will show that:

[TABLE]

Let us denote $z^{*}_{1},z^{*}_{2},\overline{z}^{*}$ the optimal routing vectors corresponding to $y_{1},y_{2},\overline{y}$, respectively. We then have:

[TABLE]

[TABLE]

It holds $\lambda z_{1}^{*}\!+\!(1\!-\!\lambda)z_{2}^{*}\!\in\!{\cal Z}_{t}(\overline{y})$, thus $\lambda f_{t}(y_{1})\!+\!(1\!-\!\lambda)f_{t}(y_{2})\!=$

[TABLE]

Subscript $t$ at the cost function (2) reminds us its dependence on the request $r_{t}$ that is generated at $t$. Since these events may vary according to a non-stationary process, we will use the concept of regret from online convex optimization [22].

We capture that the request sequence may follow any arbitrary and a priori unknown probability distribution, by using the idea of an adversary which selects $r_{t}$ at each slot $t$, while knowing $y_{t}$. This assumption reflects that, in practice, caches are populated before the requests are issued. Since by Lemma 1 $f_{t}(y)$ are convex, our problem falls in the Online Convex Optimization framework [22]. The performance metric of an algorithm in this line of work is the regret: the difference between costs incurred by the algorithm and the best static configuration in hindsight. In our case, this benchmark is the optimal cache configuration (same for all slots) devised with knowledge of all requests in the time horizon of interest $T$. Hence, the regret of policy $\sigma$ is:

[TABLE]

The expectation is over the joint probability distribution of requests and possible randomizations in $\sigma$ and,

[TABLE]

is the best fixed action in hindsight, i.e. the best chunk placement over the entire sample path of requests. Our goal is to devise a policy whose regret scales sublinearly with $T$:

[TABLE]

This “no regret” property implies that the algorithm learns to perform as good as the best cache configuration $y^{*}$. Note that if the requests are i.i.d. “no regret” implies that the performance of the policy approaches the optimal in terms of $\sim_{t}f_{t}(y^{*})$. However, our adversarial model is much more general; in this case, comparing to a static policy is a way to limit the power of the adversary while still being able to obtain meaningful policies, which are robust for all request models.

IV Distributed D2D Caching Algorithm

Our distributed caching algorithm is based on online gradient descent [25]. The main idea is to use the first order approximation $f(y)=f_{t}(y_{t})+\nabla f_{t}(y_{t})^{\top}(y-y_{t})$ as a predictor of the unknown function $f_{t+1}(y)$ that the adversary will select next. The caching configurations, then, are updated by taking an appropriate step in the direction of the gradient $\nabla f_{t}(y_{t})$.

IV-A Finding the Direction of Improvement

Since the utility function (2) is not necessarily differentiable everywhere, we will rely on subgradients. In order to find one, we first simplify $f_{t}(y)$. Let us denote $i_{t},n_{t}$ the user making the request and the file requested at slot $t$, respectively, and $\mathcal{J}(i)=\{j\in{{\mathcal{I}_{+}}}:\ell_{ij}=1\}$ the set of the nodes (including the BS) connected to user $i$. Then, it is $z^{n,i,j}=0,\forall n\neq n_{t},i\neq i_{t},j\notin\mathcal{J}(i_{t})$, and hence $f_{t}(y_{t})$ simplifies to:

[TABLE]

Equations (6)-(8) define an optimization problem, henceforth referred to as $P_{f}$, the solution of which yields the optimal routing for any $y_{t}$ (constant input for $P_{f}$). That is, to evaluate $f_{t}(\cdot)$ at vector $y_{t}$ we need to solve $P_{f}$. Despite this intricate form of $f_{t}(y_{t})$, we show that it is possible to obtain a subgradient which is needed for our online caching algorithm.

We first define the Lagrangian of $P_{f}$ as follows:

[TABLE]

where $\alpha$ and $\beta^{j}$ are the dual variables, and we simplified notation by dropping $n_{t},i_{t}$. We will prove that the subgradient of $f_{t}$ at $y_{t}$ is the optimal dual variables for (8) in $P_{f}$.

Lemma 2** (Subgradient).**

Let:

[TABLE]

and define:

[TABLE]

Then $g_{t}(y_{t})$ is a subgradient of $f_{t}$ at $y_{t}$, that is: $f_{t}(y^{\prime})\geq f_{t}(y_{t})+g_{t}(y_{t})^{\top}(y^{\prime}-y_{t}),\forall y^{\prime}\in{\cal Y}$.

Proof. We start by denoting $\beta^{*}(y^{\prime})$ the outcome of (10) for cache configuration $y^{\prime}\!\in\!{\cal Y}$ and define the function:

[TABLE]

[TABLE]

where ($\alpha$) holds since (6)-(8) has the strong duality property; (b) holds since $\Lambda(\cdot)$ is linear and we can maximize successively over the different primal or dual variables; and (c) holds as only $-\sum_{j\in\mathcal{J}(u_{t})}\beta^{j}y^{n_{t},j}$ in $L_{t}(\cdot)$ depends on $y$. Due to strong duality for $y^{\prime}$, we can replace $f_{t}(y^{\prime})\!=\!\Lambda(y^{\prime},\beta^{*}_{t}(y^{\prime}))$, and then suffices to rearrange terms. $\blacksquare$

Since $\beta^{*}_{t}(y_{t})$ is the optimal multiplier for (8), it has nonzero elements only where this constraint is tight. Intuitively, this means that after user $i_{t}$ requests file $n_{t}$, the direction of the subgradient is towards caching more parts of this file at user $i_{t}$ and at users having low-cost D2D links with $i_{t}$.

IV-B Algorithm Design

The Distributed Online Caching Policy (DOCP) is shown in Algorithm 1. The execution of the policy is iterative, where in each slot $t$ the following steps take place. First, a user $i_{t}$ submits a request for a file $n_{t}$ (step 3). This user solves (6)-(7) to find the optimal routing for the current caching configuration $y_{t}$ (step 4), and requests the parts of $n_{t}$ from the respective neighbors or the BS (step 5). A certain utility is accrued based on this routing $z_{t}^{*}$ and the existing $y_{t}^{*}$ (that was calculated based on previous requests). Then, user $i_{t}$ sends the optimal multiplier $\beta^{*,j}_{t}(y_{t})$ to each neighbor $j\in\mathcal{J}(i_{t})$ (step 8) who updates its caching policy accordingly. This involves calculating the new $y_{t+1}^{*}$, based on the latest request, and projecting them back into the feasible space (step 9):

[TABLE]

where $\Pi_{{\cal X}}(.)$ is the Euclidean projection on ${\cal X}$, and $e_{n}\!\in\!\mathbf{R}^{N}$ has zero elements except the $n$-th element being equal to 1.

Note that DOCP is indeed distributed, since only the neighbors of each requester need to update their caches. Moreover, this update is based solely on messages received by the requester, and these communication overheads are moderate as only the Lagrange multipliers are sent to 1-hop neighbors. Finally, the projection operation can be executed efficiently, i.e., in $O(N\log N)$ runtime, and for each user independently, by using the local projection algorithm introduced in [18]. We omit the details here due to lack of space.

IV-C Performance Guarantees

The next theorem proves that DOCP achieves no regret performance, under any possible spatio-temporal arrival pattern.

Theorem 1** (Regret of DOCP).**

For step size $\gamma=\frac{\sqrt{2CJ^{*}}}{c^{*}\sqrt{T}}$, the regret of DOCP satisfies:

[TABLE]

where, we defined the parameters $c^{*}\!=\!\max_{i\in{\mathcal{I}}}c_{i,0}$, $C\!=\!\max_{i\in{\mathcal{I}}}C_{i}$ and $J^{*}\!=\!\max_{i\in{\mathcal{I}}}|\mathcal{J}(i)|$.

Proof: Using non-expansiveness of Euclidean projection:

[TABLE]

Also, a telescopic sum over $T$ slots gives $\left\lVert y_{T}-y^{*}\right\rVert^{2}\leq$

[TABLE]

To proceed, note that $\left\lVert y_{1}-y^{*}\right\rVert^{2}\leq 2CJ^{*}$ and $\left\lVert g_{t}(y_{t})\right\rVert\leq(\max_{i\in{\mathcal{I}}}c_{0,i})$. Using that $\left\lVert y^{T}-y^{*}\right\rVert^{2}\geq 0$ and rearranging:

[TABLE]

Furthermore, due to convexity of $f_{t}(y)$, it holds $f_{t}(y^{*})-f_{t}(y_{t})\geq g_{t}(y_{t})^{\top}(y^{*}-y_{t})$, thus:

[TABLE]

The value of the step size and regret bound follow by minimizing the Right Hand Side of the above inequality. $\blacksquare$

Hence, no regret is achieved with a constant step which depends on $T$, and if $T$ is unknown we can select step $1/\sqrt{t}$, or employ the doubling trick, see [22, Sec. 2.3].

IV-D Dynamic Network Costs

The above model and analysis can be readily extended for the case where users change positions in different slots; or the user population evolves with time; or, finally, the users are static but the channel conditions vary. In particular, these scenarios can be captured by the updated cost function:

[TABLE]

where we have replaced the previously constant link costs with slot-specific ones $\{c_{ij}^{t},\,\forall(i,j)\in\mathcal{L},t=1,\ldots,T\}$. For instance, if link $(i,j)$ exists in slot $t$ but not in slot $(t+1)$ (e.g., nodes have moved farther), then we can use $c_{ij}^{t+1}=c_{max}>\max\{c_{i0},\forall i\in{\mathcal{I}}\}$ which will make this link non-eligible for DOCP (the BS is available and cheaper). It is interesting to note that this extension does not change the regret bound, which is set by the highest cost of the available links, that remains the one between any device and the BS.

V Numerical Results

We illustrate the performance of DOCP in a setting with $N=100$ files, and $8$ devices which are equipped with a cache of capacity $C=6$ and are placed randomly in a cell of size $1.5$Km. Devices can communicate if they are within a range of $500$m, as in current LTE-direct standards [10]. The (relative) cost of downloading a file from the base station is set to $10$; a device can fetch a file from its cache at no cost; and the respective costs from other devices vary with the distance: $2$ if the device is closer that $100$m, $5$ if the distance is within $[100m,300m)$, $7$ if in $[300m,400m)$, and $9$ if in $[400m,500m]$. File requests are drawn from a power law distribution with exponent $0.9$. We compare DOCP with the best static policy in hindsight and the lazy LRU and mLRU.

Our results are presented in Fig. 2 which shows the empirical average of the cost for the different policies. We observe that DOCP outperforms both LRU and mLRU, and the margin gets wider as time progresses. In addition, the performance of DOCP gets closer to the one of the best policy in hindsight, thus verifying the no-regret theoretical guarantee. Figure 3 compares the total cache allocation, i.e., the total fraction of each file cached at the devices, for DOCP and the best static hindsight policy. We see that, while the algorithm starts from an almost uniform allocation, by the end of the time interval $T=4000$ the DOCP cache contents are very aligned with the best configuration in hindsight. This demonstrates that DOCP indeed tends to learn the best static configuration.

VI Conclusions

D2D cooperative caching is certainly very promising, but raises previously unseen challenges in devising effective caching policies. Here, we used OCO, a fast-developing area of machine learning, to design an online distributed caching and routing policy that adapts to any (unknown) spatio-temporal request process. This makes it an ideal candidate for such dynamic, often sparse, caching networks. Our work opens a new exciting area at the nexus of online learning and D2D caching systems, and a fascinating next step is to explore how such mechanisms can incorporate incentives for ensuring users’ cooperation, leveraging credit mechanisms [12] or the human tendency to build reciprocal sharing relationships [23].