Deep Reinforcement Learning for Adaptive Caching in Hierarchical Content Delivery Networks

TL;DR

This paper introduces a deep reinforcement learning framework for adaptive, decentralized caching in hierarchical content delivery networks, enabling online learning and dynamic adaptation to optimize cache performance.

Contribution

It proposes a scalable deep Q-network based approach to model and optimize caching decisions in hierarchical networks with unknown policies and dynamic request patterns.

Findings

Achieves significant improvements in caching efficiency.

Demonstrates adaptability to changing network conditions.

Validates the approach through numerical simulations.

Abstract

Caching is envisioned to play a critical role in next-generation content delivery infrastructure, cellular networks, and Internet architectures. By smartly storing the most popular contents at the storage-enabled network entities during off-peak demand instances, caching can benefit both network infrastructure as well as end users, during on-peak periods. In this context, distributing the limited storage capacity across network entities calls for decentralized caching schemes. Many practical caching systems involve a parent caching node connected to multiple leaf nodes to serve user file requests. To model the two-way interactive influence between caching decisions at the parent and leaf nodes, a reinforcement learning framework is put forth. To handle the large continuous state space, a scalable deep reinforcement learning approach is pursued. The novel approach relies on a deep Q-network to learn the Q-function, and thus the optimal caching policy, in an online fashion. Reinforcing the parent node with ability to learn-and-adapt to unknown policies of leaf nodes as well as spatio-temporal dynamic evolution of file requests, results in remarkable caching performance, as corroborated through numerical tests.

Equations

$$\begin{gathered} {\mathbf{c}}_n({\pi }_n({\mathbf{s}}_n(t,\tau )),{\mathbf{r}}_n(t+1,\tau ),{\mathbf{a}}_0(\tau )):={\mathbf{r}}_n(t+1,\tau )\odot (1-{\mathbf{a}}_0(\tau )) \\ \odot (1-{\mathbf{a}}_n(t+1,\tau ))+{\mathbf{r}}_n(t+1,\tau )\odot (1-{\mathbf{a}}_n(t+1,\tau )) \end{gathered}$$

$$\displaystyle\pi^{\ast}_{n,\tau}\!\!:=\underset{\pi_{n}\in\Pi_{n}}{\arg\min}~{}{\mathbb{E}}\Big{[}\!\sum_{t=1}^{T}\!{\bf 1}^{\!\top}\!\boldsymbol{c}_{n}(\pi_{n}(\boldsymbol{s}_{n}(t,\tau)),\boldsymbol{r}_{n}(t\!+\!1,\tau),\boldsymbol{a}_{0}(\tau))\Big{]}$$

$${\mathbf{s}}_0(\tau ):=\sum _{n=1}^N{w}_n{\bar{\mathbf{s}}}_n(\tau )\odot (1-{\pi }_n\left({\bar{\mathbf{s}}}_n(\tau )\right))$$

$$\begin{gathered} {\bar{\mathbf{c}}}_n({\pi }_0({\mathbf{s}}_0(\tau ));\{{\mathbf{a}}_n(t,\tau +1),{\mathbf{r}}_n(t,\tau +1){\}}_{t=1}^T) \\ =\frac{1}{T}\sum _{t=1}^T{\mathbf{c}}_n({\mathbf{a}}_n(t,\tau +1),{\mathbf{r}}_n\left(t,\tau +1\right),{\mathbf{a}}_0(\tau +1)) \end{gathered}$$

$${\mathbf{c}}_0({\mathbf{s}}_0(\tau ),{\pi }_0({\mathbf{s}}_0(\tau )))$$

$$=\sum _{n=1}^N{w}_n{\bar{\mathbf{c}}}_n({\mathbf{\pi }}_0({\mathbf{s}}_0(\tau ));\{{\mathbf{a}}_n(t,\tau +1),{\mathbf{r}}_n(t,\tau +1){\}}_{t=1}^T)).$$

$$\pi_{0}^{\ast}:=\underset{\pi_{0}\in\Pi_{0}}{\arg\min}\;\mathbb{E}\Big{[}\sum_{\tau=1}^{\infty}\gamma^{\tau-1}{\bf 1}\!^{\top}\!\boldsymbol{c}_{0}\!\left(\boldsymbol{s}_{0}(\tau),\pi_{0}\!\left(\boldsymbol{s}_{0}(\tau)\right)\right)\Big{]}$$

$$P^{\boldsymbol{a}}_{\boldsymbol{s}\boldsymbol{s}^{\prime}}={\textrm{Pr}}\big{\{}\boldsymbol{s}(\tau+1)=\boldsymbol{s}^{\prime}\mid\boldsymbol{s}(\tau)=\boldsymbol{s},\,\boldsymbol{a}=\pi(\boldsymbol{s})\big{\}}$$

$$V_{\pi_{0}}(\boldsymbol{s}_{0}(0)):=\mathbb{E}\Big{[}\sum_{\tau=1}^{\infty}\gamma^{\tau-1}{\bf 1}\!^{\top}\boldsymbol{\!}\boldsymbol{c}_{0}\!\left(\boldsymbol{s}_{0}(\tau),\pi_{0}(\boldsymbol{s}_{0}\left(\tau\right))\right)\Big{]}$$

$$V_{\pi}(\boldsymbol{s})=\mathbb{E}\Big{[}{\bf 1}\!^{\top}\!{\boldsymbol{c}}(\boldsymbol{s},\pi(\boldsymbol{s}))+\gamma\sum_{\boldsymbol{s}^{\prime}}P^{\pi(\boldsymbol{s})}_{\boldsymbol{s}\boldsymbol{s}^{\prime}}V_{\pi}(\boldsymbol{s}^{\prime})\Big{]}$$

$$\mathbb{E}\left[1{}^{\top }\mathbf{c}(\mathbf{s},\pi (\mathbf{s}))\right]=\sum _{{\mathbf{s}}^{\prime }}{P}_{\mathbf{s}{\mathbf{s}}^{\prime }}^{\pi (\mathbf{s})}1{}^{\top }\mathbf{c}\left(\mathbf{s},\pi (\mathbf{s})|{\mathbf{s}}^{\prime }\right).$$

$$Q_{\pi }\left(\mathbf{s},\mathbf{a}\right):=\mathbb{E}\left[1{}^{\top }\mathbf{c}\left(\mathbf{s},\mathbf{a}\right)\right]+\gamma \sum _{{\mathbf{s}}^{\prime }}{P}_{\mathbf{s}{\mathbf{s}}^{\prime }}^{\mathbf{a}}{V}_{\pi }\left({\mathbf{s}}^{\prime }\right).$$

$${\pi }^{i+1}(\mathbf{s})=\arg \underset{\mathbf{\alpha }\in \mathcal{A}}{\min }{Q}_{{\pi }^i}(\mathbf{s},\mathbf{\alpha }).$$

$${\pi }^{\ast }(\mathbf{s})=\arg \underset{\mathbf{\alpha }\in \mathcal{A}}{\min }{Q}_{{\pi }^{\ast }}(\mathbf{s},\mathbf{\alpha }),\forall \mathbf{s}\in \mathcal{S}$$

$$V_{{\pi }^{\ast }}(\mathbf{s})=\underset{\mathbf{\alpha }\in \mathcal{A}}{\min }{Q}_{{\pi }^{\ast }}(\mathbf{s},\mathbf{\alpha }),\forall \mathbf{s}.$$

$$Q_{{\pi }^{\ast }}(\mathbf{s},\mathbf{a})=\mathbb{E}\left[1^{\top }\mathbf{c}(\mathbf{s},\mathbf{a})\right]+\gamma \sum _{{\mathbf{s}}^{\prime }}{P}_{\mathbf{s}{\mathbf{s}}^{\prime }}^{\mathbf{a}}\underset{\mathbf{\alpha }}{\min }{Q}_{{\pi }^{\ast }}({\mathbf{s}}^{\prime },\mathbf{\alpha })$$

$$\boldsymbol{a}=\!\left\{\!\!\!\begin{array}[]{ll}\underset{\boldsymbol{\alpha}\in\mathcal{A}}{\arg\min}\;~{}\hat{Q}_{\tau}(\boldsymbol{s},\boldsymbol{\alpha}),&{\rm{w.p.}\;1-\epsilon_{\tau}}\\ {\rm{random}~{}\;\boldsymbol{a}\in{\mathcal{A}}},&{\rm{w.p.}\;\;\epsilon_{\tau}}\end{array}\right..$$

$${\mathcal{L}}(\boldsymbol{s},\boldsymbol{a})=\frac{1}{2}\Big{(}{\bf 1}\!^{\top}{\boldsymbol{c}}(\boldsymbol{s},\boldsymbol{a})+\gamma\min_{\boldsymbol{\alpha}\in\mathcal{A}}\,\hat{Q}_{\tau}(\boldsymbol{s}^{\prime},\boldsymbol{\alpha})-\hat{Q}_{\tau}(\boldsymbol{s},\boldsymbol{a})\Big{)}^{2}\!\!.$$

$${\hat{Q}}_{\tau +1}(\mathbf{s},\mathbf{a})={\hat{Q}}_{\tau }(\mathbf{s},\mathbf{a})-\beta \frac{\partial \mathcal{L}(\mathbf{s},\mathbf{a})}{\partial {\hat{Q}}_{\tau }(\mathbf{s},\mathbf{a})}$$

$$\displaystyle\hat{Q}_{\tau+1}(\boldsymbol{s},\boldsymbol{a})\!=\!(1\!-\!\beta)\hat{Q}_{\tau}(\boldsymbol{s},\boldsymbol{a})\!+\!\beta\Big{[}{\bf 1}\!^{\top}\!\!{\boldsymbol{c}}(\boldsymbol{s},\boldsymbol{a})\!+\!\gamma\min_{\boldsymbol{\alpha}\in\mathcal{A}}\hat{Q}_{\tau}(\boldsymbol{s}^{\prime},\boldsymbol{\alpha})\Big{]}.$$

$$\mathbf{\delta }({\mathbf{\theta }}_{\tau })$$

$$\odot (1-\mathbf{a}(\tau +1))$$

$${\mathcal{L}}(\boldsymbol{\theta}_{\tau})=\big{\|}{\boldsymbol{\delta}}(\boldsymbol{\theta}_{\tau})\big{\|}_{2}^{2}$$

$${\mathbf{\theta }}_{\tau +1}={\mathbf{\theta }}_{\tau }-{\beta }_{\tau }{\nabla \mathcal{L}(\mathbf{\theta })|}_{\mathbf{\theta }={\mathbf{\theta }}_{\tau }}$$

$${\mathbf{\delta }}^{\text{Tar}}(\mathbf{\theta };{\mathbf{E}}_{i_{\tau }})$$

$$\odot (1-\mathbf{a}(i_{\tau }+1)).$$

$${\mathcal{L}}^{\text{Tar}}(\mathbf{\theta })=\mathbb{E}\Vert {\mathbf{\delta }}^{\text{Tar}}(\mathbf{\theta };\mathbf{E}){\Vert }_2^2$$

$${\mathbf{\theta }}_{\tau +1}={\mathbf{\theta }}_{\tau }-{\beta }_{\tau }\nabla {\mathcal{L}}^{\text{Tar}}\left(\mathbf{\theta }\right){|}_{\mathbf{\theta }={\mathbf{\theta }}_{\tau }}.$$

Full text

I Introduction

In light of the tremendous growth of data traffic over both wireline and wireless communications, next-generation networks including future Internet architectures, content delivery infrastructure, and cellular networks stand in need of emerging technologies to meet the ever-increasing data demand. Recognized as an appealing solution is caching, which amounts to storing reusable contents in geographically distributed storage-enabled network entities so that future requests for those contents can be served faster. The rationale is that unfavorable shocks of peak traffic periods can be smoothed by proactively storing ‘anticipated’ highly popular contents at those storage devices and during off-peak periods [1, 2]. Caching popular content is envisioned to achieve major savings in terms of energy, bandwidth, and cost, in addition to user satisfaction [1].

To fully unleash its potential, a content-agnostic caching entity has to rely on available observations to learn what and when to cache. Toward this goal, contemporary machine learning and artificial intelligence tools hold the promise to empower next-generation networks with ‘smart’ caching control units, that can learn, track, and adapt to unknown dynamic environments, including space-time evolution of content popularities and network topology, as well as entity-specific caching policies.

Deep neural networks (DNNs) have lately boosted the notion of “learning from data” with field-changing performance improvements reported in diverse artificial intelligence tasks [3]. DNNs can cope with the ‘curse of dimensionality’ by providing compact low-dimensional representations of high-dimensional data [4]. Combining deep learning with RL, deep (D) RL has created the first artificial agents to achieve human-level performance across many challenging domains [5, 6]. As another example, a DNN system was built to operate Google’s data centers, and shown able to consistently achieve a 40% reduction in energy consumption for cooling [7]. This system provides a general-purpose framework to understand complex dynamics, which has also been applied to address other challenges including e.g., dynamic spectrum access [8], multiple access and handover control [9], [10], as well as resource allocation in fog-radio access networks [11].

I-A Prior art on caching

Early approaches to caching include the least recently used (LRU), least frequently used (LFU), first in first out (FIFO), random replacement (RR) policies, and their variants. Albeit simple, these schemes cannot deal with the dynamics of content popularities and network topologies. Recent efforts have gradually shifted toward developing learning and optimization based approaches that can ‘intelligently’ manage the cache resources. For unknown but time-invariant content popularities, multi-armed bandit online learning (e.g., [47]) was pursued in [12]. Yet, these methods are generally not amenable to online implementation. To serve delay-sensitive requests, a learning approach was developed in [13] using a pre-trained DNN to handle a non-convex problem reformulation.

In realistic networks however, popularities exhibit dynamics, which motivate well the so-termed dynamic caching. A Poisson shot noise model was adopted to approximate the evolution of popularities in [14], for which an age-based caching solution was developed in [15]. RL based methods have been pursued in [16, 17, 18, 19]. Specifically, a Q-learning based caching scheme was developed in [16] to model global and local content popularities as Markovian processes. Considering Poisson shot noise popularity dynamics, a policy gradient RL based caching scheme was devised in [17]. Assuming stationary file popularities and service costs, a dual-decomposition based Q-learning approach was pursued in [18]. Albeit reasonable for discrete states, these approaches cannot deal with large continuous state-action spaces. To cope with such spaces, DRL approaches have been considered for content caching in e.g., [19, 20, 21, 22, 6, 23]. Encompassing finite-state time-varying Markov channels, a deep Q-network approach was devised in [19]. An actor-critic method with deep deterministic policy gradient updates was used in [20]. Boosted network performance using DRL was documented in several other applications, such as connected vehicular networks [21], and smart cities [22].

The aforementioned works focus on devising caching policies for a single caching entity. A more common setting in next-generation networks however, involves a network of interconnected caching nodes. It has been shown that considering a network of connected caches jointly can further improve performance [24, 25]. For instance, leveraging network topology and the broadcast nature of links, the coded caching strategy in [24] further reduces data traffic over a network. This idea has been extended in [26] to an online setting, where popularities are modeled Markov processes. Collaborative and distributed online learning approaches have been pursued [27, 25, 28]. Indeed, today’s content delivery networks such as Akamai [29], have tree network structures. Accounting for the hierarchy of caches has become a common practice in recent works; see also [30, 31, 32, 33]. Specifically, a general framework to evaluate caching policies in a hierarchical network of caches was developed in [30]. Joint routing and in-network content caching in a hierarchical cache network was formulated in [31], for which greedy schemes with provable performance guarantees can be found in [32].

We identify the following challenges that need to be addressed when designing practical caching methods for next-generation networks.

1. c1)

Networked caching. Caching decisions of a node, in a network of caches, influences decisions of all other nodes. Thus, a desired caching policy must adapt to the network topology and policies of neighboring nodes. 2. c2)

Complex dynamics. Content popularities are random and exhibit unknown space-time, heterogeneous, and often non-stationary dynamics over the entire network. 3. c3)

Large continuous state space. Due to the shear size of available content, caching nodes, and possible realizations of content requests, the decision space is huge.

I-B This work

Prompted by the recent interest in hierarchical caching, this paper focuses on a two-level network caching, where a parent node is connected to multiple leaf nodes to serve end-user file requests. Such a two-level network constitutes the building block of the popular tree hierarchical cache networks in e.g., [30, 29]. To model the interaction between caching decisions of parent and leaf nodes along with the space-time evolution of file requests, a scalable DRL approach based on hyper deep Q-networks (DQNs) is developed. As corroborated by extensive numerical tests, the novel caching policy for the parent node can adapt itself to local policies of leaf nodes and space-time evolution of file requests. Moreover, our approach is simple-to-implement, and performs close to the optimal policy.

II Modeling and Problem Statement

Consider a two-level network of interconnected caching nodes, where a parent node is connected to $N$ leaf nodes, indexed by $n\in\mathcal{N}:=\{1,\ldots,N\}$. The parent node is connected to the cloud through a (typically congested) back-haul link; see Fig. 2. One could consider this network as a part of a large hierarchical caching system, where the parent node is connected to a higher level caching node instead of the cloud; see Fig. 2. In a content delivery network for instance, edge servers (a.k.a. points of presence or PoPs) are the leaf nodes, and a fog server acts as the parent node. Likewise, (small) base stations in a 5G cellular network are the leaf nodes, while a serving gate way (S-GW) may be considered as the parent node; see also [34, p. 110].

All nodes in this network store files to serve file requests. Every leaf node serves its locally connected end users, by providing their requested files. If a requested content is locally available at a leaf node, the content will be served immediately at no cost. If it is not locally available due to limited caching capacity, the content will be fetched from its parent node, at a certain cost. Similarly, if the file is available at the parent node, it will be served to the leaf at no cost; otherwise, the file must be fetched from the cloud at a higher cost.

To mitigate the burden with local requests on the network, each leaf node stores ‘anticipated’ locally popular files. In addition, this paper considers that each parent node stores files to serve requests that are not locally served by leaf nodes. Since leaf nodes are closer to end users, they frequently receive file requests that exhibit rapid temporal evolution at a fast timescale. The parent node on the other hand, observes aggregate requests over a large number of users served by the $N$ leaf nodes, which naturally exhibit smaller fluctuations and thus evolve at a slow timescale.

This motivated us to pursue a two-timescale approach to managing such a network of caching nodes. To that end, let $\tau=1,2,\ldots$ denote the slow time intervals, each of which is further divided into $T$ fast time slots indexed by $t=1,\ldots,T$; see Fig. 3 for an illustration. Each fast time slot may be e.g., $1$-$2$ minutes depending on the dynamics of local requests, while each slow time interval is a period of say $4$-$5$ minutes. We assume that the network state remains unchanged during each fast time slot $t$, but can change from $t$ to $t+1$.

Consider a total of $F$ files in the cloud, which are collected in the set ${\mathcal{F}}=\{1,\ldots,F\}$. At the beginning of each slot $t$, every leaf node $n$ selects a subset of files in $\mathcal{F}$ to prefetch and store for possible use in this slot. To determine which files to store, every leaf node relies on a local caching policy function denoted by $\pi_{n}$, to take (cache or no-cache) action ${\boldsymbol{a}}_{n}(t+1,\tau)=\pi_{n}(\boldsymbol{s}_{n}(t,\tau))$ at the beginning of slot $t+1$, based on its state vector ${\boldsymbol{s}}_{n}$ at the end of slot $t$. We assume this action takes a negligible amount of time relative to the slot duration; and define the state vector $\boldsymbol{s}_{n}(t,\tau)\!:=\!\boldsymbol{r}_{n}(t,\tau):=[r_{n}^{1}(t,\tau)\cdots r_{n}^{F}(t,\tau)]^{\top}$ to collect the number of requests received at leaf node $n$ for individual files over the duration of slot $t$ on interval $\tau$. Likewise, to serve file requests that have not been served by leaf nodes, the parent node takes action $\boldsymbol{a}_{0}(\tau)$ to store files at the beginning of every interval $\tau$, according to a certain policy $\pi_{0}$. Again, as aggregation smooths out request fluctuations, the parent node observes slowly varying file requests, and can thus make caching decisions at a relatively slow timescale. In the next section, we present a two-timescale approach to managing such a network of caching nodes.

III Two-timescale Problem Formulation

File transmission over any network link consumes resources, including e.g., energy, time, and bandwidth. Hence, serving any requested file that is not locally stored at a node, incurs a cost. Among possible choices, the present paper considers the following cost for node $n\in\mathcal{N}$, at slot $t+1$ of interval $\tau$

[TABLE]

where $\boldsymbol{c}_{n}(\cdot):=[c_{n}^{1}(\cdot)~{}\cdots~{}c_{n}^{F}(\cdot)]^{\top}$ concatenates the cost for serving individual files per node $n$; symbol $\odot$ denotes entry-wise vector multiplication; entries of $\boldsymbol{a}_{0}$ and $\boldsymbol{a}_{n}$ are either $1$ (cache, hence no need to fetch), or, [math] (no-cache, hence fetch); and $\bf 1$ stands for the all-one vector. Specifically, the second summand in (1) captures the cost of the leaf node fetching files for end users, while the first summand corresponds to that of the parent fetching files from the cloud.

We model user file requests as Markov processes with unknown transition probabilities [16]. Per interval $\tau$, a reasonable caching scheme for leaf node $n\in\mathcal{N}$ could entail minimizing the expected cumulative cost; that is,

[TABLE]

where $\Pi_{n}$ represents the set of all feasible policies for node $n$. Although solving (2) is in general challenging, efficient near-optimal solutions have been introduced in several recent contributions; see e.g., [16, 17, 12], and references therein. In particular, a RL based approach using tabular $Q$-learning was pursued in our precursor [16], which can be employed here to tackle this fast timescale optimization. The remainder of this paper will thus be on designing the caching policy $\pi_{0}$ for the parent node, that can learn, track, and adapt to the leaf node policies as well as user file requests.

At the beginning of every interval $\tau+1$, the parent node takes action to refresh its cache; see Fig. 4. To design a caching policy that can account for both leaf node policies and file popularity dynamics, the parent collects local information from all leaf nodes. At the end of interval $\tau$, each leaf node $n\in\mathcal{N}$ first obtains the time-average state vector ${\bar{\boldsymbol{s}}_{n}}(\tau):=(1/T)\sum_{t=1}^{T}\boldsymbol{s}_{n}(t,\tau)$, and subsequently forms and forwards the per-node vector ${\bar{\boldsymbol{s}}_{n}}(\tau)\odot({\bf 1}-\pi_{n}({\bar{\boldsymbol{s}}_{n}}(\tau)))$ to its parent node. This vector has nonzero entries the average number of file requests received during interval $\tau$, and zero entries if $\pi_{n}$ stores the corresponding files. Using the latter, the parent node forms its ‘weighted’ state vector as

[TABLE]

where the weights $\{w_{n}\geq 0\}$ control the influence of leaf nodes $n\in\mathcal{N}$ on the parent node’s policy. Similarly, having received at the end of interval $\tau+1$ the slot-averaged costs

[TABLE]

from all leaf nodes, the parent node determines its cost

[TABLE]

Having observed $\left\{\boldsymbol{s}_{0}(\tau^{\prime}),\boldsymbol{a}_{0}(\tau^{\prime}),\boldsymbol{c}_{0}({\boldsymbol{s}}_{0}(\tau^{\prime}-1),\boldsymbol{a}_{0}(\tau^{\prime})\right\}_{\tau^{\prime}=1}^{\tau}$, the objective is to take a well-thought-out action $\boldsymbol{a}_{0}(\tau+1)$ for next interval. This is tantamount to finding an optimal policy function $\pi^{\ast}_{0}$ to take a caching action $\boldsymbol{a}_{0}\left(\tau\!\!+\!1\right)=\pi^{\ast}_{0}\left(\boldsymbol{s}_{0}\left(\tau\right)\right)$.

Since the requests $\{\boldsymbol{r}_{n}(t,\tau)\}_{n,t}$ are Markovian and present actions $\{\boldsymbol{a}_{n}(t,\tau)\}_{n,t}$ also affect future costs, the optimal RL policy for the parent node will minimize the expected cumulative cost over all leaf nodes in the long term, namely

[TABLE]

where $\Pi_{0}$ represents the set of all feasible policies; expectation is over $\{\boldsymbol{r}_{n}(t,\tau)\}_{n,t}$, as well as (possibly random) parent $\boldsymbol{a}_{0}(\tau)$ and leaf actions $\{\boldsymbol{a}_{n}(t,\tau)\}_{n,t}$; and the discount factor $\gamma\in[0,1)$ trades off emphasis of current versus future costs.

It is evident from (6) that the decision taken at a given state $\boldsymbol{s}_{0}(\tau)$, namely $\boldsymbol{a}_{0}(\tau+1)=\pi(\boldsymbol{s}_{0}(\tau))$, influences the next state $\boldsymbol{s}_{0}(\tau+1)$ through $\pi_{n,\tau}(\cdot)$ in (3), as well as the cost $\boldsymbol{c}_{0}(\cdot)$ in (5). Therefore, problem (6) is a discounted infinite time horizon Markov decision process (MDP). Finding the optimal policy of an MDP is NP-hard [35]. To cope with this complexity of solving (6), an adaptive RL approach is pursued next.

IV Adaptive RL-Based Caching

RL deals with action-taking policy function estimation in an environment with dynamically evolving states, so as to minimize a long-term cumulative cost. By interacting with the environment (through successive actions and observed states and costs), RL seeks a policy function (of states) to draw actions from, in order to minimize the average cumulative cost as in (6) [36]. To proceed, we start by giving some basics on Markov decision processes (MDPs) [36, p. 310].

IV-A MDP formulation

MDPs provide a well-appreciated model for decision making tasks. It is represented by a tuple $\left<{\mathcal{S}},{\mathcal{A}},{\mathcal{C}},{\mathcal{P}}\right>$, where ${\mathcal{S}}$ denotes a set of possible states, $\mathcal{A}$ a set of feasible actions, $\mathcal{C}$ a set of costs, and $\mathcal{P}$ the set of state transition probabilities. In our problem of interest, at the end of each interval $\tau$, the parent node is in state ${\boldsymbol{s}}_{0}(\tau)\in{\mathcal{S}}$ and takes a caching decision $\boldsymbol{a}_{0}(\tau+1)\in{\mathcal{A}}$ for the next interval $\tau+1$, according to its local caching policy $\boldsymbol{a}_{0}(\tau+1)=\pi_{0}{(\boldsymbol{s}_{0}(\tau))}$. Upon proceeding to interval $\tau+1$, every leaf node $n$ serves its locally connected users. Let vector $\boldsymbol{r}_{n}(t,\tau+1)$ collect the number of received requests at node $n$ during slot $t$ across files. We model the temporal evolution of this vector with Markov dynamics as $\boldsymbol{r}_{n}(t+1,\tau+1)=\lfloor\boldsymbol{r}_{n}(t,\tau+1)+{\boldsymbol{\Delta}}_{n}(t,\tau+1)\rfloor^{+}$, where $\boldsymbol{\Delta}_{n}(t,\tau+1)$ is a multivariate Gaussian random noise; $\lfloor\cdot\rfloor$ and $(\cdot)^{+}$ denote the entry-wise floor and $\max\left\{\cdot,0\right\}$ operators. In this context, the incurred cost $\boldsymbol{c}_{0}({\boldsymbol{s}}_{0}(\tau),\pi_{0}({\boldsymbol{s}}_{0}(\tau)))\in{\mathcal{C}}$ (c.f. (5)), is a random vector with an unknown distribution. As requests $\{\boldsymbol{r}_{n}\}$ are random, caching decisions $\{\boldsymbol{a}_{n}\}$ are also random. In addition, decision $\boldsymbol{a}_{0}$ of the parent node influences those of leaf nodes via (2), as well as the next state of the parent node in (3). That is, the current decision of parent node probabilistically influences its next state. To formalize this, we use $P^{\boldsymbol{a}}_{\boldsymbol{s}\boldsymbol{s}^{\prime}}\in{\mathcal{P}}$ to denote the unknown state transition probability from state $\boldsymbol{s}$ to $\boldsymbol{s}^{\prime}$ upon taking action $\boldsymbol{a}$

[TABLE]

where the subscript [math] referring to the parent node is dropped for brevity. As $\boldsymbol{a}_{0}$ probabilistically influences the next state as well as the incurred cost, our problem is indeed an MDP. The rest of this paper targets finding an optimal policy solving (6).

IV-B RL based caching

Towards developing an RL solver for (6), define the so-termed value function to indicate the quality of policy $\pi_{0}$, starting from initial state $\boldsymbol{s}_{0}(0)$ as

[TABLE]

which represents the average cost of following policy $\pi_{0}$ to make caching decisions starting from $\boldsymbol{s}_{0}(0)$. Upon finding $V_{\pi_{0}}(\cdot)$ for all $\pi_{0}\in\Pi_{0}$, one can readily obtain $\pi_{0}^{\ast}$ that minimizes $V_{\pi_{0}}(\boldsymbol{s}_{0}(0))$ over all possible initial states $\boldsymbol{s}_{0}(0)$.

For brevity, the time index and the subscript [math] referring to the parent node will be dropped whenever it is clear from the context. To find $V_{\pi}(\cdot)$, one can rely on the Bellman equation, which basically relates the value of a policy at one state to values of the remaining states [36, p. 46]. Leveraging (8) and (7), the Bellman equation for value function $V_{\pi}(\cdot)$ is given by

[TABLE]

where the average immediate cost can be found as

[TABLE]

If $P^{\boldsymbol{a}}_{\boldsymbol{s}\boldsymbol{s}^{\prime}}$ were known $\forall\boldsymbol{a}\in{\mathcal{A}}$, $\forall{\boldsymbol{s},\boldsymbol{s}^{\prime}\in{\mathcal{S}}}$, finding $V_{\pi}(\cdot)$ would be equivalent to solving the system of linear equations (9). Indeed, if one could afford the complexity of evaluating $V_{\pi}(\cdot)$ for all $\pi\in\Pi_{0}$, the optimal policy $\pi^{\ast}$ is the one that minimizes the value function for all states. However, the large (possibly infinite) number of policies in practice discourages such an approach. An alternative is to employ the so-termed policy iteration algorithm [36, p. 64] outlined next. Define first the state-action value function, also called $Q$-function for policy $\pi$

[TABLE]

This function captures the expected immediate cost of starting from state $\boldsymbol{s}$, taking the first action to be $\boldsymbol{a}$, and subsequently following policy $\pi$ to take future actions onwards. The only difference between the value function in (8) and that of $Q$-function in (10) is that the former takes the first action according to policy $\pi$, while the latter starts with $\boldsymbol{a}$ as the first action, which may not necessarily be taken when adhering to $\pi$. Having defined the $Q$-function, we are ready to present the policy iteration algorithm, in which every iteration $i$ entails the following two steps:

Policy Evaluation. Find $V_{\pi^{i}}(\cdot)$ for the current policy ${\pi^{i}}$ by solving the system of linear equations in (9).

Policy Improvement. Update the current policy greedily as

[TABLE]

To perform policy evaluation, we rely on knowledge of $P^{\pi^{i}\!(\boldsymbol{s})}_{\boldsymbol{s}\boldsymbol{s}^{\prime}}$. However, this is impractical in our setup that involves dynamic evolution of file requests, and unknown caching policies for the leaf nodes. This calls for approaches that target directly the optimal policy $\pi^{\ast}$, without knowing $P^{\boldsymbol{a}}_{\boldsymbol{s}\boldsymbol{s}^{\prime}},\,\forall\boldsymbol{a},\boldsymbol{s},\,\boldsymbol{s}^{\prime}$. One such approach is $Q$-learning [36, p. 107].

In the ensuing section, we first introduce a $Q$-learning based adaptive caching scheme, which is subsequently generalized in Section V by invoking a DQN.

IV-C Q-learning based Adaptive Caching

The $Q$-learning algorithm finds the optimal policy $\pi^{\ast}$ by estimating $Q_{\pi^{\ast}}(\cdot,\cdot)$ ‘on-the-fly.’ It turns out that $\pi^{\ast}$ is the greedy policy over the optimal $Q$-function [36, p. 64], that is

[TABLE]

where $Q_{\pi^{\ast}}$ is estimated using Bellman’s equation for the $Q$-function. This is possible because the $V$-function is linked with the $Q$-function under $\pi^{\ast}$ through (see [36, p. 51] for details)

[TABLE]

Substituting (12) into (10), Bellman’s equation for the $Q$-function under $\pi^{\ast}$ is expressed as

[TABLE]

which plays a key role in many RL algorithms. Examples include $Q$-learning [37], and SARSA [36], where one relies on (13) to update estimates of the $Q$-function in a stochastic manner. In particular, the $Q$-learning algorithm follows an exploration-exploitation procedure to take some action $\boldsymbol{a}$ in a given state $\boldsymbol{s}$. Specifically, it chooses the action minimizing the current estimate of $Q_{\pi^{\ast}}(\cdot,\cdot)$ denoted by $\hat{Q}_{\tau}(\cdot,\cdot)$, with probability (w.p.) $1-\epsilon_{\tau}$, or, it takes a random action $\boldsymbol{a}\in\mathcal{A}$ otherwise; that is,

[TABLE]

After taking action $\boldsymbol{a}$, moving to some new state $\boldsymbol{s}^{\prime}$, and incurring cost $\boldsymbol{c}$, the $Q$-learning algorithm adopts the following loss function for the state-action pair $(\boldsymbol{s},\boldsymbol{a})$

[TABLE]

The estimated $Q$-function for a single state-action pair is subsequently updated, by following a gradient descent step to minimize the loss in (14), which yields the update

[TABLE]

where $\beta>0$ is some step size. Upon evaluating the gradient and merging terms, the update in (15) boils down to

[TABLE]

Three remarks are worth making at this point.

Remark 1*.*

As far as the fast-timescale caching strategy of leaf nodes is concerned, multiple choices are possible, including e.g., LRU, LFU, FIFO, [38], the multi-armed bandit scheme [12], and even RL ones [16, 17].

Remark 2*.*

The exploration-exploitation step for taking actions guarantees continuously visiting state-action pairs, and ensures convergence to the optimal $Q$-function [35]. Instead of the $\epsilon$-greedy exploration-exploitation step, one can employ the upper confidence bound scheme [39]. Technically, any exploration-exploitation scheme should be greedy in the limit of infinite exploration (GLIE) [40, p. 840]. An example obeying GLIE is the $\epsilon$-greedy algorithm [40, p. 840] with $\epsilon_{\tau}=1/\tau$. It converges to an optimal policy, albeit at a very slow rate. On the other hand, using a constant $\epsilon_{\tau}=\epsilon$ approaches the optimal $Q^{\ast}(\cdot,\cdot)$ faster, but its exact convergence is not guaranteed as it is not GLIE.

Clearly, finding $Q_{\pi^{\ast}}(\boldsymbol{s},\boldsymbol{a})$ entails estimating a function defined over state and action spaces. In several applications however, at least one of the two vector variables is either continuous or takes values from an alphabet of high cardinality. Revisiting every state-action pair in such settings is impossible, due to the so-called curse of dimensionality – a typical case in practice. To deal with it, function approximation techniques offer as a promising solution [36]. These aim at finding the original $Q$-function over all feasible state-action pairs, by judicious generalization from a few observed pairs. Early function approximators for RL design good hand-crafted features that can properly approximate $V_{\pi^{\ast}}(\cdot)$, $Q_{\pi^{\ast}}(\cdot,\cdot)$, or, $\pi^{\ast}(\cdot)$ [5]. Their applicability has only been limited to domains, where such features can be discovered, or, to state spaces that are low dimensional [36].

Deep learning approaches on the other hand, have recently demonstrated remarkable potential in applications such as object detection, speech recognition, and language translation, to name a few [41]. This is because DNNs are capable of extracting compact low-dimensional features from high-dimensional data. Wedding DNNs with RL results in ‘deep RL’ that can effectively deal with the curse of dimensionality, by eliminating the need of hand-crafting good features. These considerations have inspired the use of DNNs to estimate either the $Q$-function, value function, or, the policy [41]. The most remarkable success in playing AI games adopted DNNs to estimate the $Q$-function, what is termed DQN in [5].

Prompted by this success, the next leverages the power of function approximation through DNNs to develop an adaptive caching scheme for the parent node.

V Adaptive DQN-Based Caching

To find the optimal caching policy $\pi^{\ast}$ for the parent node, the success of function approximators for RL (e.g., [5]), motivated us to pursue a parametric approach to estimating $Q(\boldsymbol{s},\boldsymbol{a})$ with a DNN (cf. (11)). This DNN has as input pairs of vectors $(\boldsymbol{s},\boldsymbol{a})$, and as scalar output the corresponding estimated $Q(\boldsymbol{s},\boldsymbol{a})$ values. Clearly, the joint state-action space of the sought Q-function has cardinality $|{\mathcal{A}}\times\mathcal{S}|=|{\mathcal{A}}||\mathcal{S}|$. To reduce the search space, we shall take a parametric DQN approach [5] that we adapt to our setup, as elaborated next.

Consider a deep feedforward NN with $L$ fully connected layers, with input the $F\times 1$ state vector $\boldsymbol{s}(\tau)$ as in (3), and $F\times 1$ output cost vector $\boldsymbol{o}(\tau+1)$ [5]. Note that input does not include the action vector $\boldsymbol{a}$. Each hidden layer $l\in\{2,\ldots,L-1\}$ comprises $n_{l}$ neurons with rectified linear unit (ReLU) activation functions $h(z):=\max(0,\,z)$ for $z\in{\mathbb{R}}$; see e.g., [42]. Neurons of the $L$-th output layer use a softmax nonlinearity 111Softmax is a function that takes as input a vector $\bm{z}\in\mathbb{R}^{F}$, and normalizes it into a probability distribution via $\sigma({\bm{z}})_{f}={\rm e}^{{z}_{f}}/(\sum_{f=1}^{F}{\rm e}^{z_{f}})$, $\forall f$. to yield for the $f$-th entry of $\boldsymbol{o}$, an estimated long term cost $o_{f}$ that would incur, if file $f$ is not stored at the cache.

If this cache memory can store up to $M$ ($<F$) files at the parent node, the $M$ largest entries of the DQN output $\boldsymbol{o}(\tau+1)$ are chosen by the decision module in Fig. 5 to obtain the action vector $\boldsymbol{a}(\tau+1)$. We can think of our DQN as a ‘soft policy’ function estimator, and $\boldsymbol{o}(\tau+1)$ as a ‘predicted cost’ or a ‘soft action’ vector for interval $\tau+1$, whose ‘hard thresholding’ yields $\boldsymbol{a}(\tau+1)$. It will turn out that excluding $\boldsymbol{a}$ from the DQN input and picking it up at the output lowers the search space from $|{\mathcal{A}}||\mathcal{S}|$ to $|\mathcal{S}|$.

To train our reduced-complexity DQN amounts to finding a set of weights collected in the vector $\bm{\theta}$ that parameterizes the input-output relationship $\boldsymbol{o}(\tau+1)=Q(\boldsymbol{s}(\tau);\bm{\theta}_{\tau})$. To recursively update $\bm{\theta}_{\tau}$ to ${\bm{\theta}}_{\tau+1}$, consider two successive intervals along with corresponding states $\boldsymbol{s}(\tau)$ and $\boldsymbol{s}(\tau+1)$; the action $\boldsymbol{a}(\tau+1)$ taken at the beginning of interval $\tau+1$; and, the cost $\boldsymbol{c}({\tau}+1)$ revealed at the end of interval $\tau+1$. The instantaneous approximation of the optimal cost-to-go from interval $\tau+1$ is given by $\boldsymbol{c}({\tau}+1)+\gamma Q(\boldsymbol{s}(\tau+1);\boldsymbol{\theta}_{\tau})$, where $\boldsymbol{c}({\tau}+1)$ is the immediate cost, and $Q(\boldsymbol{s}(\tau+1);\boldsymbol{\theta}_{\tau})$ represents the predicted cost-to-go from interval $\tau+2$ that is provided by our DQN with $\bm{\theta}_{\tau}$, and discounted by $\gamma$. Since our DQN offers $Q(\boldsymbol{s}({\tau});\boldsymbol{\theta}_{\tau})$ as the predicted cost for interval $\tau+1$, the prediction error of this cost as a function of $\bm{\theta}_{\tau}$ is given by

[TABLE]

and has non-zero entries for files not stored at interval $\tau+1$.

Using the so-termed experience ${\boldsymbol{E}}_{\tau+1}:=[\boldsymbol{s}(\tau),\boldsymbol{a}(\tau+1),\boldsymbol{c}(\tau+1),\boldsymbol{s}(\tau+1)]$, and the $\ell_{2}$-norm of ${\boldsymbol{\delta}}(\boldsymbol{\theta}_{\tau})$ as criterion

[TABLE]

the sought parameter update minimizing (17) is given by the stochastic gradient descent (SGD) iteration as

[TABLE]

where $\beta_{\tau}>0$ denotes the learning rate.

Since the dimensionality of $\boldsymbol{\theta}$ can be much smaller than $|\mathcal{S}||{\mathcal{A}}|$, the DQN is efficiently trained with few experiences, and generalizes to unseen state vectors. Unfortunately, DQN model inaccuracy can propagate in the cost prediction error in (16) that can cause instability in (18), which can lead to performance degradation, and even divergence [43, 44]. Moreover, (18) leverages solely a single most recent experience ${\boldsymbol{E}}_{\tau+1}$. These limitations will be mitigated as elaborated next.

V-A Target Network and Experience Replay

NN function approximation, along with the loss (17) and the update (18), often result in unstable RL algorithms [5, 45]. This is due to: i) correlated experiences used to update the DQN parameters $\boldsymbol{\theta}$; and, ii) the influence of any change in policy on subsequent experiences and vice versa.

Possible remedies include the so-called experience replay and target network to update the DQN weights. In experience replay, the parent node stores all past experiences ${\boldsymbol{E}}_{\tau}$ in ${\mathcal{E}}:=\{\boldsymbol{E}_{1},\ldots,\boldsymbol{E}_{\tau}\}$, and utilizes a batch of $B$ uniformly sampled experiences from this data set, namely $\{\boldsymbol{E}_{i_{\tau}}\}_{i=1}^{B}\sim U(\mathcal{E})$. By sampling and replaying previously observed experiences, experience replay can overcome the two challenges. On the other hand, to obtain decorrelated target values in (16), a second NN (called target network) with structure identical to the DQN is invoked with parameter vector $\bm{\theta}^{\textrm{Tar}}$. Interestingly, $\bm{\theta}^{\textrm{Tar}}$ can be periodically replaced with $\bm{\theta}_{\tau}$ every $C$ training iterations of the DQN, which enables the target network to smooth out fluctuations in updating the DQN [5].

With a randomly sampled experience $\boldsymbol{E}_{i_{\tau}}\in\mathcal{E}$, the prediction error with the target cost-to-go estimated using the target network (instead of the DQN) is

[TABLE]

Different from (16), the target values here are found through the target network with weights $\boldsymbol{\theta}^{\textrm{Tar}}$. In addition, the error in (16) is found by using the most recent experience, while the experience here is randomly drawn from past experiences in $\mathcal{E}$. As a result, the loss function becomes

[TABLE]

where the expectation is taken with respect to the uniformly sampled experience $\boldsymbol{E}$. In practice however, only a batch of $B$ samples is available and used to update $\boldsymbol{\theta}_{\tau}$, so the expectation will be replaced with the sample mean. Finally, following a gradient descent step over the sampled experiences, we have

[TABLE]

Both the experience replay and the target network help stabilize the DQN updates. Incorporating these remedies, Alg. 1 tabulates our deep RL based adaptive caching scheme for the parent node.

VI Numerical Tests

In this section, we present several numerical tests to assess the performance of our deep RL based caching schemes which is represented in Alg. 1.

The first experiment considers a simple setup, consisting of a parent node that directly serves user file requests. A total of $F=50$ files were assumed in the cloud, each having the same size, while $M_{0}=5$ files can be stored in the cache, amounting to $10\%$ of the total. The file popularities were drawn randomly from $[0,1]$, invariant across all simulated time instants, but unknown to the caching entity. A fully connected feed-forward NN of $3$ layers was implemented for DQN with each layer comprising $50$ hidden neurons. For simplicity, we assume that the dataset $\mathcal{E}$ can store a number $\mathcal{R}$ of most recent experiences, which is also known as the replay memory. It was set to ${\mathcal{R}}=10$ in our test, along with mini-batch size $B=1$ to update the target network every $C=10$ iterations. In addition, hyper-parameter values $\gamma=0.8$, learning rate $\beta_{\tau}=0.01$, as well as $\epsilon_{\tau}=0.4$ were used throughout our numerical tests.

Figure 6 shows the convergence of the DQN parameter $\boldsymbol{\theta}_{\tau}$ to that of the target network $\boldsymbol{\theta}^{\textrm{Tar}}$. Since $\boldsymbol{\theta}^{\textrm{Tar}}$ is updated with $\boldsymbol{\theta}_{\tau}$ per $C$ iteration, the error $||\bm{\theta}_{\tau}-\bm{\theta}^{\rm{Tar}}||_{2}$ vanishes periodically. While the error changes just in a few iterations after the $\boldsymbol{\theta}^{\textrm{Tar}}$ update, it is constant in several iterations before the next $\boldsymbol{\theta}^{\textrm{Tar}}$ update, suggesting that $\boldsymbol{\theta}_{\tau}$ is fixed across those iterations. This motivates investigating the impact of $C$ on $\boldsymbol{\theta}_{\tau}$’s convergence. Figure 7 shows the convergence of $\boldsymbol{\theta}_{\tau}$ to $\boldsymbol{\theta}^{\textrm{Tar}}$ for $C=20,\,5,\,3,\,2$. Starting with $C=20$, vector $\boldsymbol{\theta}_{\tau}$ is not updated in most iterations between two consecutive updates of $\boldsymbol{\theta}^{\textrm{Tar}}$. Clearly, the smaller $C$ is, the faster the convergence for $\boldsymbol{\theta}_{\tau}$ is achieved. Indeed, this is a direct result of having static file popularity. Based on our numerical tests, having small $C$ values is preferable in dynamic settings too.

For the second experiment, a similar setup having solely the parent node, plus $M_{0}=5$ and $F=50$, was considered. Dynamic file popularities were generated with time evolutions modeled by Markov process described earlier in the paper, and again they are unknown to the caching node.

We first consider that the parent node is connected to $N=5$ leaf nodes, and every leaf node implements a local caching policy $\pi_{n}$ with capacity of storing $M_{n}=5$ files. Every leaf node receives user file requests within each fast time slot, and each slow-timescale interval consists of $T=2$ slots. File popularity exhibits different Markovian dynamics locally at leaf nodes. Having no access to local policies $\{\pi_{n}\}$, the parent node not only should learn file popularities along with their temporal evolutions, but also learn the caching policies of leaf nodes. To endow our approach with scalability to handle $F\gg 1$, we advocate the following hyper Q-network implementation. Files are first split into $K$ smaller groups of sizes $F_{1},\ldots,F_{K}$ with $F_{k}\ll F$. This yields the representation $\boldsymbol{s}^{\top}(\tau):=[{\boldsymbol{s}^{1}}^{\top}\!(\tau),\ldots,{\boldsymbol{s}^{K}}^{\top}\!(\tau)]$, where $\boldsymbol{s}^{k}\in{\mathbb{R}}^{F_{k}}$. By running $K$ DQNs in parallel, every DQN-$k$ now outputs the associated predicted costs of input files through $\boldsymbol{o}^{k}(\tau)\in{\mathbb{R}}^{F^{k}}$. Concatenating all these outputs, one obtains the predicted output cost vector of all files as $\boldsymbol{o}^{\top}(\tau+1)\!:=\![{{\boldsymbol{o}}^{1}}^{\top}\!(\tau+1),\ldots,{{\boldsymbol{o}}^{K}}^{\top}\!(\tau+1)]$; see Sec. V for discussion on finding action $\boldsymbol{a}$ from vector $\boldsymbol{o}$, and also Fig. 8 for an illustration of our hyper Q-network.

The ensuing numerical tests consider $F=1,000$ files with $K=25$ and $\{F_{k}=20\}$, where only $M_{0}=50$ can be stored. To further assess the performance, we adopt a non-causal optimal policy as a benchmark, which unrealistically assumes knowledge of future requests and stores the most frequently requested files. In fact, this is the best policy that one may ideally implement. Further, practically used cache schemes including e.g., the LRU, LFU, and FIFO [46] are also simulated. A difference between LRU, LFU, FIFO, and our proposed approach is that they refresh the cache whenever a request is received, while our scheme refreshes the cache only at the end of every time slot.

By drawing $100$ samples222During these samples, DRL policy is enforced to exploit its learned caching policy. randomly from all $2,000$ time intervals, the instantaneous reduced cost and the empirical cumulative distribution function (CDF) obtained over these $100$ random samples for different policies are plotted in Fig. 9 and Fig.10, respectively. These plots further verify how the DRL policy performs relative to the alternatives, and in particular very close to the optimal policy.

LRU, LFU, and FIFO make caching decisions based on instantaneous observations, and can refresh the cache many times within each slot. Yet, our proposed policy as well as the optimal one here learns from all historical observations to cache, and refreshes the cache only once per slot. Because of this difference, the former policies outperform the latter at the very beginning of Fig. 9, but they do not adapt to the underlying popularity evolution and are outperformed by our learning-based approach after a number of slots. The merit of our approach is further illustrated by the CDF of the reduced cost depicted in Fig. 10.

In the last test, we increased the number of leaf nodes from $10$ in the previous experiment to $N=1,000$. Figures 11 and 12 showcase that the DRL performance approaches that of the optimal policy as the number of nodes increases. This is likely because the more leaf nodes, the smoother the popularity fluctuations, and therefore the easier it becomes for DRL to learn the optimal policy.

VII Conclusions

Caching highly popular contents across distributed caching entities can substantially reduce the heavy burden of content delivery in modern data networks. This paper considered a network caching setup, comprising a parent node connected to several leaf nodes to serve end user file requests. Since the leaf nodes are closer to end users, they observe file requests in a fast timescale, and could thus serve requests, either through their locally stored files or by fetching files from the parent node. Observing aggregate requests from all leaf nodes, the parent node makes caching decisions in a slower-time scale. Such a two-timescale caching task was tackled in this paper using a RL approach. An efficient caching policy leveraging deep RL was introduced, and shown capable of learning-and-adapting to dynamic evolutions of file requests, and caching policies of leaf nodes. Simulated tests corroborated its impressive performance. This work also opens up several directions for future research, including multi-armed bandit online learning [47], and distributed deep RL using recurrent NNs [48] for future spatio-temporal file request prediction.