Reinforcement Learning for Adaptive Caching with Dynamic Storage Pricing

TL;DR

This paper develops a reinforcement learning framework for adaptive caching in 5G small base stations, optimizing fetch-cache decisions under dynamic costs and storage constraints to improve network performance.

Contribution

It introduces a novel RL-based approach for dynamic fetch-cache decision-making considering time-varying costs and capacity limitations in edge caching.

Findings

RL-based algorithms outperform static caching policies.

The approach effectively adapts to changing cost and demand patterns.

Numerical results demonstrate improved network efficiency.

Abstract

Small base stations (SBs) of fifth-generation (5G) cellular networks are envisioned to have storage devices to locally serve requests for reusable and popular contents by \emph{caching} them at the edge of the network, close to the end users. The ultimate goal is to shift part of the predictable load on the back-haul links, from on-peak to off-peak periods, contributing to a better overall network performance and service experience. To enable the SBs with efficient \textit{fetch-cache} decision-making schemes operating in dynamic settings, this paper introduces simple but flexible generic time-varying fetching and caching costs, which are then used to formulate a constrained minimization of the aggregate cost across files and time. Since caching decisions per time slot influence the content availability in future slots, the novel formulation for optimal fetch-cache decisions falls into the class of dynamic programming. Under this generic formulation, first by considering stationary distributions for the costs and file popularities, an efficient reinforcement learning-based solver known as value iteration algorithm can be used to solve the emerging optimization problem. Later, it is shown that practical limitations on cache capacity can be handled using a particular instance of the generic dynamic pricing formulation. Under this setting, to provide a light-weight online solver for the corresponding optimization, the well-known reinforcement learning algorithm, $Q$-learning, is employed to find optimal fetch-cache decisions. Numerical tests corroborating the merits of the proposed approach wrap up the paper.

Equations

$$\text{C1:}{s}_t^f=a_{t-1}^f,\forall f,t,$$

$$\text{C2:}{r}_t^f\le w_t^f+s_t^f,\forall f,t.$$

$$\text{C3:}{a}_t^f\le s_t^f+w_t^f,\forall f,t.$$

$${\rho }_t^f={\sigma }_f({{\rho }^{\prime }}_t+{{\rho }^{\prime }}_t^f)+({{\rho }^{\prime \prime }}_t+{{\rho }^{\prime \prime }}_t^f),$$

$${\lambda }_t^f={\sigma }_f({{\lambda }^{\prime }}_t+{{\lambda }^{\prime }}_t^f)+({{\lambda }^{\prime \prime }}_t+{{\lambda }^{\prime \prime }}_t^f).$$

$$c_t:=\sum _{f=1}^F{c}_t^f(a_t^f,w_t^f;{\rho }_t^f,{\lambda }_t^f)=\sum _{f=1}^F{\rho }_t^f{a}_t^f+{\lambda }_t^f{w}_t^f,$$

$$\bar{\mathcal{C}}:=\mathbb{E}\left[\sum _{t=0}^{\infty }\sum _{f=1}^F{\gamma }^t{c}_t^f\left(a_t^f,w_t^f;{\rho }_t^f,{\lambda }_t^f\right)\right]$$

$$\text{(P1)}\underset{\{(w_k^f,a_k^f){\}}_{f,k\ge t}}{\min }$$

$$s.t.$$

$$\mathcal{X}(r_k^f,a_{k-1}^f)$$

$$\displaystyle s_{k}^{f}=a^{f}_{k-1},\;r^{f}_{k}\leq w+s^{f}_{k},\;\;a\leq s^{f}_{k}+w\Big{\}},$$

$$\text{(P2)}\underset{\{(w_k^f,a_k^f){\}}_{k\ge t}}{\min }$$

$$s.t.$$

$$\left(w_t^{f\ast },a_t^{f\ast }\right):=$$

$$=$$

$$\displaystyle V^{f}\left(s^{f},r^{f};\rho^{f},\lambda^{f}\right):=\!\!\!\!\!\!\!\!\underset{(w,a)\in\mathcal{X}(r^{f}_{t},{a^{f}_{t-1}})}{\mathop{\min}}\left\{{\mathbb{E}}_{\boldsymbol{\theta}_{k}^{f}}\left[\underset{(w_{k},a_{k})\in{\cal X}(r^{f}_{k},{a^{f}_{k-1})}}{\min}\left\{\sum\limits_{k=t}^{\infty}\gamma^{k-t}\left[c^{f}_{k}(a^{f}_{k},w^{f}_{k};\rho^{f}_{k},\lambda^{f}_{k})\Big{|}a^{f}_{t}\!=\!a,w^{f}_{t}\!=\!w,{\boldsymbol{\theta}^{f}_{t}={\boldsymbol{\theta}}^{f}}\right]\right\}\right]\right\}$$

$${\bar{V}}^f(s^f):=$$

$$=$$

$${\bar{V}}^f\left(s^f\right):={\mathbb{E}}_{{\mathbf{\theta }}^f}\left[V^f\left(s^f,r^f;{\rho }^f,{\lambda }^f\right)\right],$$

$$\text{(P3)}\underset{(w,a)}{\min }$$

$$s.t.$$

$$w_t^f=a_t^f,a_t^f={\mathbb{I}}_{\{\Delta {\bar{V}}_{\gamma }^f\ge {\lambda }_t^f+{\rho }_t^f\}}$$

$$w_t^f=0,a_t^f={\mathbb{I}}_{\{\Delta {\bar{V}}_{\gamma }^f\ge {\rho }_t^f\}}$$

$$w_t^f=1,a_t^f={\mathbb{I}}_{\{\Delta {\bar{V}}_{\gamma }^f\ge {\rho }_t^f\}}$$

$$w_t^f=0,a_t^f={\mathbb{I}}_{\{\Delta {\bar{V}}_{\gamma }^f\ge {\rho }_t^f\}}$$

$${\bar{V}}_1$$

$${\bar{V}}_0$$

$$=$$

$${\bar{V}}_0^{h=0}$$

$${\bar{V}}_1^{h=0}$$

$${\bar{V}}_0^{h=1}$$

$${\bar{V}}_1^{h=1}$$

$$Q\left(s_t,r_t,w_t,a_t;{\rho }_t,{\lambda }_t\right)$$

$$\displaystyle=\underbrace{c_{t}(a_{t},w_{t};\rho_{t},\lambda_{t})}_{\textrm{Immediate cost}}+\gamma\underbrace{{\mathbb{E}}\left[\underset{\left\{(w_{k},a_{k})\in{\cal X}(r_{k},{a_{k-1}})\right\}_{k=t+1}^{\infty}}{\min}\left\{\sum\limits_{k=t+1}^{\infty}\gamma^{k-{(t+1)}}\left[c_{k}(a_{k},w_{k};\rho_{k},\lambda_{k})\Big{|}s_{t+1}=a_{t}\right]\right\}\right]}_{\textrm{Average minimum future cost}}$$

$${\bar{Q}}_{r_t,s_t}^{w_t,a_t}:=$$

$$=$$

$$\displaystyle\bar{Q}_{r,s}^{w,a}={\mathbb{E}}[\lambda]w+{\mathbb{E}}[\rho]a+\gamma(1-p)\sum_{\forall(z_{1},z_{2}){\in\mathcal{X}(0,a)}}\bar{Q}_{0,a}^{z_{1},z_{2}}\Pr\Big{(}(w_{t+1}^{*},a_{t+1}^{*})=(z_{1},z_{2})|(s_{t+1},r_{t+1})=(a,0)\Big{)}$$

Full text

I Introduction

In the era of data deluge, storing “popular” contents at the edge of a content delivery network (CDN) or 5G cellular network, is a promising technique to satisfy the users’ demand while alleviating the congestion on the back-haul links [2, 3, 4]. To this aim, small basestations (SBs) equipped with a local cache must intelligently store reusable popular contents during off-peak periods, and utilize the stored data during on-peak hours. To endow SBs with the required learning capability, a wide range of learning and optimization approaches has been adopted (see [2], [3]).

Considering static popularity for contents, a multi-armed bandit formulation of the problem was investigated in [5], where the caching is carried out according to demand history and under unknown popularities. Coded, convexified, and distributed extensions of this problem were later studied in [6], context and trend-aware learning approaches in [7], [8], and coordinated-distributed extensions in [9]. From a learning perspective, the trade-off between the “accuracy” of learning a static popularity, and the corresponding learning “speed” is investigated in [10] and [11].

In reality however, popularities exhibit fluctuations meaning they are dynamic over a time horizon. For instance, half of the top 25 requested Wikipedia articles change on a daily basis [2, 12]. This motivates recent approaches to designing caching strategies under dynamic popularity scenarios.

To account for dynamic popularities, a Poisson shot noise model was introduced in [13], followed by an age-based thresholding caching strategy in [14]. Furthermore, reinforcement learning-based approaches were studied in [15, 16] and [17]. In [15], global and local popularities are modeled by different Markov processes, and a $Q$-learning based algorithm was proposed; while in [17], a policy gradient approach was followed to optimize a parametric policy. From an “accuracy-speed” trade-off perspective, a class of learning-based algorithms under dynamic popularities was analyzed in [18]. Modeling the evolution of the popularities as Markov processes, an online coded caching scheme was introduced in [19], to minimize the long-term average transmitted data over the back-haul. Likewise, delivery time was minimized in [20] through a coded caching strategy.

Targeting different objectives, optimization-based dynamic caching has been utilized in different approaches, see e.g., in  [21]–[22]. To minimize content-access latency, energy, storage or bandwidth utilization costs, regularization and decomposition techniques have been used in [21]. Similar approaches are followed in [23] to relax a non-convex optimization problem to allocate limited caching memory across a network while accounting for the spatio-temporal content popularity together with the rented storage price fluctuations. An online mixed-integer programming formulation has also been investigated in [24].

Different from [21, 23, 24], this paper considers a generic formulation of the problem by introducing time-varying and stochastic costs, and aims at designing more flexible caching schemes, while enabling SBs to learn the optimal fetching-caching decisions. In particular, the fetching and caching decisions are found as the solution of a constrained optimization with the objective of reducing the overall cost, aggregated across files and time instants. Since the caching decision in a given time slot not only affects the instantaneous cost, but also will influence cache availability in the future, the problem is indeed a dynamic programming (DP). First, by assuming a known stationary distribution for costs as well as popularities, the proposed generic optimization problem is shown to become separable across files, and thus it can be efficiently solved by decomposing the so-called value function associated with the original DP into a summation of smaller-dimension value functions. To reduce the computational complexity, the corresponding marginalized version of the value iteration algorithm [25] is introduced, and its performance is assessed via numerical tests. Subsequently, it is shown that having a limited caching capacity and unknown underlying distributions for pertinent parameters, is indeed a special case of this generic formulation. Thus, in order to address caching under limited storage capacity, a dual decomposition technique is developed to cope with the coupling constraint associated with the storage limitation. An online low complexity (marginalized) $Q$-learning based solver is put forth for learning the optimal fetch-cache decisions in an online fashion. The proposed approach is guaranteed to learn optimal fetching-caching decisions in stationary settings, but numerical tests corroborate its improved performance even in non-stationary scenarios.

The rest of this paper is organized as follows. Section II provides a generic formulation of the problem, where solvers adopted from reinforcement learning are developed in Section III. Limited storage and back-haul transmission rate settings are discussed in Section IV. Section V reports numerical results, and finally section VI provides concluding remarks.

II Operating conditions and costs

Consider a memory-enabled SB responsible for serving file (content) requests denoted by $f=1,2,\ldots,F$ across time. The requested contents are transmitted to users either by fetching through a (costly) back-haul transmission link connecting the SB to the cloud, or, by utilizing the local storage unit in the SB where popular contents have been proactively cached ahead of time. The system is considered to operate in a slotted fashion with $t=1,2,\ldots$ denoting time.

During slot $t$ and given the available cache contents, the SB receives a number of file requests whose provision incurs certain costs. Specifically, for a requested file $f$, fetching it from the cloud through the back-haul link gives rise to scheduling, routing and transmission costs, whereas its availability at the cache storage in the SB will eliminate such expenses. However, local caching also incurs a number of (instantaneous) costs corresponding to memory or energy consumption. This gives rise to an inherent caching-versus-fetching trade-off, where one is promoted over the other depending on their relative costs. The objective here is to propose a simple yet sufficiently general framework to minimize the sum-average cost over time by optimizing fetch-cache decisions while adhering to the constraints inherent to the operation of the system at hand, and user-specific requirements. The variables, constraints, and costs involved in this optimization are described in the ensuing subsections.

II-A Variables and constraints

Consider the system at time slot $t$, where the binary variable $r^{f}_{t}$ represents the incoming request for file $f$; that is, $r^{f}_{t}=1$ if the file $f$ is requested during slot $t$, and $r^{f}_{t}=0$, otherwise. Here, we assume that $r^{f}_{t}=1$ necessitates serving the file to the user and dropping requests is not allowed; thus, requests must be carried out either by fetching the file from the cloud or by utilizing the content currently available in the cache. Furthermore, at the end of each slot, the SB will decide if content $f$ should be stored in the cache for its possible reuse in a subsequent slot.

To formalize this, let us define the “fetching” decision variable $w^{f}_{t}\in\{0,1\}$ along the “caching” decision variable $a^{f}_{t}\in\{0,1\}$. Setting $w^{f}_{t}=1$ implies “fetching” file $f$ at time $t$, while $w^{f}_{t}=0$ means “no-fetching.” Similarly, $a^{f}_{t}=1$ implies that content $f$ will be stored in cache at the end of slot $t$ for the next slot, while $a^{f}_{t}=0$ implies that it will not. Furthermore, let the storage state variable $s_{t}^{f}\in\{0,1\}$ account for the availability of files at the local cache. In particular, $s_{t}^{f}=1$ if file $f$ is available in the cache at the beginning of slot $t$, and $s_{t}^{f}=0$ otherwise. Since the availability of file $f$ directly depends on the caching decision at time $t-1$, we have

[TABLE]

which will be incorporated into our optimization as constraints.

Moreover, since having $r_{t}^{f}=1$ implies transmission of file $f$ to the user(s), it requires either having the file in cache ($s_{t}^{f}=1$) or fetching it from the cloud ($w_{t}^{f}=1$), giving rise to the second set of constraints

[TABLE]

Finally, the caching decision $a_{t}^{f}$ can be set to $1$ only when the content $f$ is available at time $t$; that is, only if either fetching is carried out ($w_{t}^{f}=1$) or the current cache state is $s_{t}^{f}=1$. This in turn implies the third set of constraints as

[TABLE]

II-B Prices and aggregated costs

To account for the caching and fetching costs, let $\rho_{t}^{f}$ and $\lambda_{t}^{f}$ denote the (generic) costs associated with $a_{t}^{f}=1$ and $w_{t}^{f}=1$, respectively. Focusing for now on the caching cost and with $\sigma_{f}$ denoting the size of content $f$, a simple form for $\rho_{t}^{f}$ is

[TABLE]

where the first term is proportional to the file size $\sigma_{f}$, while the second one is constant. Note also that we consider file-dependent costs (via variables ${\rho^{\prime}}_{t}^{f}$ and ${\rho^{\prime\prime}}_{t}^{f}$), as well as cost contributions which are common across files (via ${\rho^{\prime}}_{t}$ and ${\rho^{\prime\prime}}_{t}$). In most practical setups, the latter will dominate over the former. For example, the caching cost per bit is likely to be the same regardless of the particular type of content, so that ${\rho^{\prime}}_{t}^{f}={\rho^{\prime\prime}}_{t}^{f}=0$. From a modeling perspective, variables $\rho_{t}^{f}$ can correspond to actual prices paid to an external entity (e.g., if associated with energy consumption costs), marginal utility or cost functions, congestion indicators, Lagrange multipliers associated with constraints, or linear combinations of those (see, e.g., [25, 26, 27, 28] and Section IV). Accordingly, the corresponding form for the fetching cost is

[TABLE]

As before, if the transmission link from the cloud to the SB is the same for all contents, the prices ${\lambda^{\prime}}_{t}$ and ${\lambda^{\prime\prime}}_{t}$ are expected to dominate their file-dependent counterparts ${\lambda^{\prime}}_{t}^{f}$ and ${\lambda^{\prime\prime}}_{t}^{f}$.

Upon defining the corresponding cost for a given file as $c^{f}_{t}(a^{f}_{t},w^{f}_{t};\rho_{t}^{f},\lambda_{t}^{f})=\rho_{t}^{f}a^{f}_{t}+\lambda_{t}^{f}w^{f}_{t}$, the aggregate cost at time $t$ is given by

[TABLE]

which is the basis for the DP formulated in the next section. For future reference, Fig. 1 shows a schematic of the system model and the notation introduced in this section.

III Optimal caching with time-varying costs

Since decisions are coupled across time [cf. constraint (1)], and the future values of prices as well as state variables are inherently random, our goal is to optimize the long-term average discounted aggregate cost

[TABLE]

where the expectation is taken with respect to (w.r.t.) the random variables $\boldsymbol{\theta}_{t}^{f}:=\{r_{t}^{f},\lambda_{t}^{f},\rho_{t}^{f}\}$, and $0<\gamma<1$ is the discounting factor whose tuning trades off current versus more uncertain future costs [29, p.44].

First, we investigate a setup where the knowledge of the realization of the random variables is causal, that is, the exact value of $\boldsymbol{\theta}_{t}^{f}$ is revealed at the beginning of each slot $t$, and fetch-cache decisions are made sequentially per slot. In addition, the variables in $\boldsymbol{\theta}_{t}^{f}$ are assumed to have stationary and known distributions (e.g., estimated through historical data), which allows for practical estimates of the expectation. Hence, the goal is to take real-time fetch-cache decisions by minimizing the expected current plus future cost while adhering to operational constraints, giving rise to the following optimization

[TABLE]

where

[TABLE]

and the expectation is taken w.r.t. $\{\boldsymbol{\theta}^{f}_{k}\}_{\forall k\geq t+1}$.

The presence of constraint (1), which has been made explicit in the definition of $\mathcal{X}(r^{f}_{k},a^{f}_{k-1})$, implies that current caching decisions impact future costs, and therefore such costs must be taken into account when making the decisions. This ultimately implies that (P$1$) is a DP [29, p. 79] and, therefore, to solve it we need to: a) identify the current and expected future aggregate cost (this second term will give rise to the so-called value-function); b) write the corresponding Bellman equations; and c) propose a method to estimate the value function. This is the subject of the ensuing subsections, which start by further exploitation of problem structure to reduce complexity.

III-A Bellman equations for the per-content problem

Focusing on (P$1$), one can readily deduce that: (i) consideration of the content-dependent prices renders the objective in (P$1$) separable across $f$, and (ii) the constraints in (P$1$) are also separable across $f$. Furthermore, the decisions $a_{t}^{f}$ and $w_{t}^{f}$ for a given $f$, do not affect the values (distribution) of $\boldsymbol{\theta}_{k^{\prime}}^{f^{\prime}}$ for files $f^{\prime}\neq f$ and for times $t^{\prime}>t$. Thus, (P$1$) naturally gives rise to the per-file optimization

[TABLE]

which must be solved for $f=1,...,F$. Indeed, the aggregate cost associated with (P$2$) will not depend on variables corresponding to files $f^{\prime}\neq f$ [25]. This is the case if, for instance, the involved variables are independent of each other (which is the setup considered here), or when the focus is on a large system where the contribution of an individual variable to the aggregate network behavior is practically negligible.

Bellman equations and value function: The DP in (P$2$) can be solved with the corresponding Bellman equations, which require finding the associated value functions [29, p. 68]. To this end, consider the system at time $t$, where the cache state as well as the file requests and cost parameters are all given, so that we can write $s^{f}_{t}=s^{f}_{0}$ and $\boldsymbol{\theta}^{f}_{t}=\boldsymbol{\theta}^{f}_{0}$. Then, the optimal fetch-cache decision $(w^{f\ast}_{t},a^{f\ast}_{t})$ is readily expressible as the solution to (8). The objective in (8) is rewritten in (9) as the summation of current and discounted average future costs. The form of (9) is testament to the fact that problem (P$2$) is a DP and the caching decision $a$ influences not only the current cost $c_{t}^{f}(\cdot)$, but also future costs through the second term as well. Bellman equations can be leveraged for tackling such a DP. Under the stationarity assumption for variables $r_{t}^{f}$, $\rho_{t}^{f}$ and $\lambda_{t}^{f}$, the term accounting for the future cost can be rewritten in terms of the * stationary value function* $V^{f}\left(s^{f},r^{f};\rho^{f},\lambda^{f}\right)$ [29, p. 68]. This function, formally defined in (10), captures the minimum sum average cost for the “state” $(s^{f},r^{f})$, parametrized by $(\lambda^{f},\rho^{f})$, where for notational convenience, we define $\boldsymbol{\theta}^{f}:=[r^{f},\rho^{f},\lambda^{f}]$.

III-B Marginalized value-function

If one further assumes that price parameters and requests are i.i.d. across time, it can be shown that the optimal solution to (P$2$) can be expressed in terms of the reduced value function [25]

[TABLE]

where the expectation is w.r.t ${\boldsymbol{\theta}^{f}}$. This is important not only because it captures the average future cost of file $f$ for cache state $s^{f}\in\{0,1\}$, but also because ${\bar{V}}^{f}(\cdot)$ is a function of a binary variable, and therefore its estimation requires only estimating two values. This is in contrast with the original four-dimensional value function in (10), whose estimation is more difficult due to its continuous arguments.

By rewriting the proposed alternative value function ${\bar{V}}^{f}(\cdot)$ in a recursive fashion as the summation of instantaneous cost and discounted future values ${\bar{V}}^{f}(\cdot)$, one readily arrives at the Bellman equation form provided in (11). Thus, the problem reduces to finding $\bar{V}^{f}(0)$ and $\bar{V}^{f}(1)$ for all $f$, after which the optimal fetch-cache decisions $(w_{t}^{f\ast},a^{f\ast}_{t})$ are easily found as the solution to

[TABLE]

If the value-function is known, so that we have access to ${\bar{V}}^{f}(0)$ and ${\bar{V}}^{f}(1)$, the corresponding optimal (Bellman) decisions can be found as

[TABLE]

where $\Delta{\bar{V}}^{f}_{\gamma}$ represents the future marginal cost, which is obtained as $\Delta{\bar{V}}^{f}_{\gamma}=\gamma({\bar{V}}^{f}(1)-{\bar{V}}^{f}(0))$, and $\mathbb{I}_{\{\cdot\}}$ is an indicator function that yields value one if the condition in the argument holds, and zero otherwise.

The next subsection discusses how ${\bar{V}}^{f}(0)$ and ${\bar{V}}^{f}(1)$ can be calculated, but first a remark is in order.

Remark 1 (Augmented value functions). The value function ${\bar{V}}^{f}(s^{f})$ can be redefined to account for extra information on $r_{t}^{f}$, $\rho_{t}^{f}$ or $\lambda_{t}^{f}$, if available. For instance, consider the case where the distribution of $r_{t}^{f}$ can be parametrized by $p^{f}$, which measures content “popularity” [30]. In such cases, the value function can incorporate the popularity parameter as an additional input to yield ${\bar{V}}^{f}(s^{f},p^{f})$. Consequently, the optimal decisions will depend not only on the current requests and prices, but also on the (current) popularity $p^{f}$. This indeed broadens the scope of the proposed approach, as certain types of non-stationarity in the distribution of $r_{t}^{f}$ can be handled by allowing $p^{f}$ to (slowly) vary with time.

III-C Value function in closed form

For notational brevity, we have removed the superscript $f$ in this subsection, and use $\bar{V}_{0}$ and $\bar{V}_{1}$ in lieu of ${\bar{V}}(0)$, and ${\bar{V}}(1)$. Denoting the long-term popularity of the content as $p:={\mathbb{E}}[r_{t}]$, using the expressions for the optimal actions in (13a)-(13d), and leveraging the independence among $r_{t}$, $\lambda_{t}$, and $\rho_{t}$, the expected cost-to-go function can be readily derived as in (14)-(III-C). The expectation in (14) is w.r.t. $\rho$, while that in (III-C) is w.r.t. both $\lambda$ and $\rho$.

Solving the system of equations in (14)-(III-C) yields the optimal values for $\bar{V}_{1}$ and $\bar{V}_{0}$. A simple solver would be to perform exhaustive search over the range of these values since it is only a two-dimensional search space. However, a better alternative to solving the given system of equations is to rely on the well known value iteration algorithm [29, p. 100]. In short, this is an offline algorithm, which per iteration $i$ updates the estimates $\{\bar{V}^{i+1}_{0},\bar{V}^{i+1}_{1}\}$ by computing the expected cost using $\{\bar{V}^{i}_{0},\bar{V}^{i}_{1}\}$, until the desired accuracy is achieved. This scheme is tabulated in detail in Algorithm 1, for which the distributions of $r,\rho,\lambda$ are assumed to be known. We refer to [29, p.100] for a detailed discussion on the value-iteration algorithm, and its convergence guarantees.

Remark 2 (Finite-horizon approximate policies). In the proposed algorithms, namely exhaustive search as well as Algorithm 1, the solver is required to compute an expectation, which can be burdensome in setups with limited computational resources. For such scenarios, the class of finite-horizon policies emerges as a computationally affordable suboptimal alternative [29, p. 242]. The idea behind such policies is to truncate the infinite summation in the objective of (P$1$); thus, only considering the impact of the current decision on a few number of future time instants denoted by $h$, typically referred to as the horizon. The extreme case of a finite-horizon policy is that of a myopic policy with $h=0$, which ignores any future impact of current decision, a.k.a. zero-horizon policy, thus taking the action which minimizes the instantaneous cost. This is equivalent to setting the future marginal cost to zero, hence solving (13a)-(13d) with $\Delta{\bar{V}}_{\gamma}=\Delta{\bar{V}}_{\gamma}^{h=0}=0$.

Another commonly used alternative is to consider the impact of the current decision for only the next time instant, which corresponds to the so-called horizon-1 policy. This entails setting the future cost at $h=1$ as $\Delta{\bar{V}}_{\gamma}^{h=1}=\gamma(\bar{V}_{1}^{h=0}-\bar{V}_{0}^{h=0})$ with

[TABLE]

which are then substituted into (13a)-(13d) to yield the actions $w^{h=1}$ and $a^{h=1}$. The notation $w^{h=0}$ and $a^{h=0}$ in (17) and (18) is used to denote the actions obtained when (13a)-(13d) are solved using the future marginal cost at horizon zero $\Delta{\bar{V}}_{\gamma}^{h=0}$, which as already mentioned, is zero; that is, under the myopic policy in lieu of the original optimal solution. Following an inductive argument, the future marginal cost at $h=2$ is obtained as $\Delta{\bar{V}}_{\gamma}^{h=2}=\gamma(\bar{V}_{1}^{h=1}-\bar{V}_{0}^{h=1})$ with

[TABLE]

which will allow to obtain the actions $w^{h=2}$ and $a^{h=2}$. While increasing horizons can be used, as $h$ grows large, solving the associated equations becomes more difficult and computation of the optimal stationary policies, is preferable.

III-D State-action value function ($Q$-function):

In many practical scenarios, knowing the underlying distributions for $\rho_{t}$, $\lambda_{t}$ and $r_{t}$ may not be possible, which motivates the introduction of online solvers that can learn the parameters on-the-fly. As clarified in the ensuing sections, in such scenarios, the so-called $Q$-function (or state-action value function) [29, p.69] becomes helpful, since there are rigorous theoretical guarantees on the convergence of its stochastic estimates; see [31] and [32]. Motivated by this fact, instead of formulating our dynamic program using the value (cost-to-go) function, we can alternatively formulate it using the $Q$-function. Aiming at an online solver, let us tackle the DP through the estimation (learning) of the $Q$-function. Equation111Equations (19)-(21), and (III-D) are shown at the top of page 7. (19) defines the $Q$-function for a specific file under a given state $\left(s_{t},r_{t}\right)$, parametrized by cost parameters $\left(\rho_{t},\lambda_{t}\right)$. Under stationarity distribution assumption for $\left\{\rho_{t},\lambda_{t},r_{t}\right\}$, the $Q$-function $Q\left(s_{t},r_{t},w_{t},a_{t};\rho_{t},\lambda_{t}\right)$ accounts for the minimum average aggregate cost at state $\left(s_{t},r_{t}\right)$, and taking specific fetch-cache decision $(w_{t},a_{t})$ as for the first decision, while followed by the best possible decisions in next slots. This function is parametrized by $\left(\rho_{t},\lambda_{t}\right)$ since while making the current cache-fetch decision, the current values for these cost parameters are assumed to be known. The original $Q$-function in (19) needs to be learned over all values of $\left\{s_{t},r_{t},w_{t},a_{t},\rho_{t},\lambda_{t},r_{t}\right\}$, thus suffering from the curse of dimensionality, especially due to the fact that $\rho_{t}$ and $\lambda_{t}$ are continuous variables.

To alleviate this burden, we define the marginalized $Q$-function $Q(s_{t},r_{t},w_{t},a_{t})$ in (21). By changing the notation for clarity of exposition, the marginalized $Q$-function, $\bar{Q}_{r_{t},s_{t}}^{w_{t},a_{t}}$, can be rewritten in a more compact form as

[TABLE]

Note that, while the marginalized value-function is only a function of the state, the marginalized $Q$-function depends on both the state $\left(r,s\right)$ and the immediate action $\left(w,a\right)$. The main reason one prefers to learn the value-function rather than the $Q$-function is that the latter is computationally more complex. To see this, note that the input space of $\bar{Q}_{r_{t},s_{t}}^{w_{t},a_{t}}$ is a four-dimensional binary space, hence the function has $2^{4}=16$ different inputs and one must estimate the corresponding $16$ outputs. Each of these possible values are called $Q$-factors, and under the stationarity assumption, they can be found using (III-D) defined for all $(r,s,w,a)$. In this expression, we have $(z_{1},z_{2})\in\{0,1\}^{2}$ and the term $\Pr\left(\left(w_{t+1}^{\ast}a^{\ast}_{t+1}\right)=(z_{1},z_{2})\right)$ stands for the probability of specific action $(z_{1},z_{2})$ to be optimal at slot $t+1$. This action is random because the optimal decision at $t+1$ depends on $\rho_{t+1}$, $\lambda_{t+1}$ and $r_{t+1}$, which are not known at slot $t$. Although not critical for the discussion, if needed, one can show that half of the 16 $Q$-factors can be discarded, either for being infeasible – recall that $(w_{t},a_{t})\!\in\!{\mathcal{X}}(r_{t},{a_{t-1}})$ – or suboptimal. This means that (III-D) needs to be computed only for $8$ of the $Q$-factors.

From the point of view of offline estimation, working with the $Q$-function is more challenging than working with the $V$-function, since more parameters need to be estimated. In several realistic scenarios however, the distributions of the state variables are unknown, and one has to resort to stochastic schemes in order to learn the parameters on-the-fly. In such scenarios, the $Q$-function based approach is preferable, because it enables learning the optimal decisions in an online fashion even when the underlying distributions are unknown.

III-E Stochastic policies: Reinforcement learning

As discussed in Section III-C, there are scenarios where obtaining the optimal value function (and, hence, the optimal stationary policy associated with it) is not computationally feasible. The closing remark in that section discussed policies which, upon replacing the optimal value function with approximations easier to compute, trade reduced complexity for loss in optimality. However, such reduced-complexity methods still require knowledge of the state distribution [cf. (17) and (18)]. In this section, we discuss stochastic schemes to approximate the value function under unknown distributions. The policies resulting from such stochastic methods offer a number of advantages since they: (a) incur a reduced complexity; (b) do not require knowledge of the underlying state distribution; (c) are able to handle some non-stationary environments; and in some cases, (d) they come with asymptotic optimality guarantees. To introduce this scheme, we first start by considering a simple method that updates stochastic estimates of the value function itself, and then proceed to a more advanced method which tracks the value of the $Q$-function. Specifically, the presented method is an instance of the celebrated $Q$-learning algorithm [33], which is the workhorse of stochastic approximation in DP [29, p. 68].

III-E1 Stochastic value function estimates

The first method relies on current stochastic estimates of $\bar{V}_{0}$ and $\bar{V}_{1}$, denoted by $\hat{\bar{V}}_{0}(t)$ and $\hat{\bar{V}}_{1}(t)$ at time $t$ (to be defined rigorously later). Given $\hat{\bar{V}}_{0}(t)$ and $\hat{\bar{V}}_{1}(t)$ at time $t$, the (stochastic) actions $\hat{w}_{t}$ and $\hat{a}_{t}$ are taken via solving (13a)-(13d) with $\Delta{\bar{V}}_{\gamma}=\gamma(\hat{\bar{V}}_{0}(t)-\hat{\bar{V}}_{1}(t))$. Then, stochastic estimates of the value functions $\hat{\bar{V}}_{0}(t)$ and $\hat{\bar{V}}_{1}(t)$ are updated as

• •

If $s_{t}=0$, then $\hat{\bar{V}}_{1}(t+1)=\hat{\bar{V}}_{1}(t)$ and $\hat{\bar{V}}_{0}(t+1)=(1-\beta)\hat{\bar{V}}_{0}(t)+\beta(\hat{w}_{t}\lambda_{t}+\hat{a}_{t}\rho_{t}+\gamma\hat{\bar{V}}_{\hat{a}_{t}}(t))$;

• •

If $s_{t}=1$, then $\hat{\bar{V}}_{0}({t+1})=\hat{\bar{V}}_{0}({t})$ and $\hat{V}_{1}(t+1)=(1-\beta)\hat{\bar{V}}_{1}(t)+\beta(\hat{w}_{t}\lambda_{t}+\hat{a}_{t}\rho_{t}+\gamma\hat{\bar{V}}_{\hat{a}_{t}}(t))$;

where $\beta>0$ denotes the stepsize. While easy to implement (only two recursions are required), this algorithm has no optimality guarantees.

III-E2 Q-learning algorithm

Alternatively, one can run a stochastic approximation algorithm on the $Q$-function. This entails replacing the $Q$-factors $\bar{Q}_{r,s}^{w,a}$ with stochastic estimates $\hat{\bar{Q}}_{r,s}^{w,a}(t)$. To describe the algorithm, suppose for now that at time $t$, the estimates $\hat{\bar{Q}}_{r,s}^{w,a}(t)$ are known for all $(r,s,w,a)$. Then, in a given slot $t$ with $(r_{t},s_{t})$, action $\left(\hat{w}^{\ast}_{t},\hat{a}^{\ast}_{t}\right)$ is obtained via either an exploration or an exploitation step. When exploring, which happens with a small probability $\epsilon_{t}$, a random and feasible action $\left(\hat{w}^{\ast}_{t},\hat{a}^{\ast}_{t}\right)\in{\mathcal{X}}\left(r_{t},a_{t-1}\right)$ is taken. In contrast, in the exploitation mode, which happens with a probability $1-\epsilon_{t}$, the optimal action according to the current estimate of $\hat{\bar{Q}}_{r,s}^{w,a}(t)$ is

[TABLE]

After taking this action, going to next slot $t+1$, and observing $\rho_{t+1},\lambda_{t+1}$, and $r_{t+1}$, the $Q$-function estimate is updated as

[TABLE]

where “o.w.” stands for “otherwise,” and $(\hat{w}^{\ast}_{t+1},\hat{a}^{\ast}_{t+1})$ is the optimal action for the next slot. This update rule describes one of the possible implementations of the $Q$-learning algorithm, which was originally introduced in [33]. This online algorithm enables making sequential decisions in an unknown environment, and is guaranteed to learn optimal decision-making rules under certain conditions [29, p.148], [32]. The aforementioned exploration-exploitation step is necessary for the factors $\hat{\bar{Q}}_{r,s}^{w,a}$ to converge to their optimal value ${{\bar{Q}}^{\ast w,a}}_{\;\;r,s}$ [34], [31]. Intuitively, under continuous updates of all state-action pairs along with regular stochastic approximation conditions on the stepsize $\beta$, the updates on $\hat{\bar{Q}}_{r,s}^{w,a}$ converge to the optimal values with probability 1. Various exploration-exploitation algorithms have been proposed to meet convergence guarantees [35, p. 839] . A necessary condition for any such exploration-exploitation approach is the greedy in the limit of infinite exploration (GLIE) property [35, p. 840]. A common choice to meet this property is the $\epsilon$-greedy approach with $\epsilon_{t}=1/t$, providing guaranteed yet slow convergence. In practice however, $\epsilon_{t}$ is set to a small value for faster convergence; see  [34] and [31] for a more detailed discussion on convergence.

The resultant algorithm for the problem at hand is tabulated in Algorithm 2. It is important to stress that in our particular case, we expect the algorithm to converge fast. That is the case because, under the decomposition approach followed in this paper as well as the introduction of the marginalized $Q$-function, the state-action space of the resultant $Q$-function has very low dimension and hence, only a small number of $Q$-factors need to be estimated.

IV Limited storage and back-haul transmission rate via dynamic pricing

So far, we have considered that the prices $\{\rho_{t}^{f},\lambda_{t}^{f}\}$ are provided by the system, and we have not assumed any explicit limits (bounds) neither on the capacity of the local storage nor on the back-haul transmission link between the SB and the cloud. In this section, we discuss such limitations, and describe how by leveraging dual decomposition techniques, one can redefine the prices $\{\rho_{t}^{f},\lambda_{t}^{f}\}$ to account for capacity constraints.

IV-A Limiting the instantaneous storage rate

In this subsection, practical limitations on the cache storage capacity are explored. Suppose that the SB is equipped with a single memory device that can store $M$ files. Clearly, the cache decisions should then satisfy the following constraint per time slot

[TABLE]

In order to respect such hard capacity limits, the original optimization problem in (P$1$) can be simply augmented with C$4$, giving rise to a new optimization problem which we will refer to as (P$4$). Solving (P$4$) is more challenging than (P$1$), since the constraints in C$4$ must be enforced at each time instant, which subsequently couples the optimization across files. In order to deal with this, one can dualize C$4$ by augmenting the cost with the primal-dual term $\mu_{t}(\sum_{f=1}^{F}\sigma_{f}a_{t}^{f}-M)$, where $\mu_{t}$ denotes the Lagrange multiplier associated with the capacity constraint C$4$. The resultant problem is separable across files, but requires finding $\mu_{t}^{*}$, the optimal value of the Lagrange multiplier, at each and every time instant.

If the solution to the original unconstrained problem (P$1$) does satisfy C$4$, then $\mu_{t}^{*}=0$ due to complementary slackness. On the other hand, if the storage limit is violated, then the constraint is active, the Lagrange multiplier satisfies $\mu_{t}^{*}>0$, and its exact value must be found using an iterative algorithm. Once the value of the multiplier is known, the optimal actions associated with (P$4$) can be found using the expressions for the optimal solution to (P$1$) provided that the original storage price $\rho_{t}^{f}$ is replaced with the new storage price $\rho_{t,aug}^{f}=\rho_{t}^{f}+\mu_{t}^{*}\sigma_{f}$ [cf. (4)]. The reason for this will be explained in detail in the following subsection, after introducing the ensemble counterpart of C$4$.

IV-B Limiting the long-term storage rate

Consider now the following constraint [cf. C$4$]

[TABLE]

where the expectation is taken w.r.t. all state variables. By setting $M^{\prime}=M$, one can view C$5$ as a relaxed version of C$4$. That is, while C$4$ enforces the limit to be respected at every time instant, C$5$ only requires it to be respected on average. From a computational perspective, dealing with C$5$ is easier than its instantaneous counterpart, since in the former only one constraint is enforced and, hence, only one Lagrange multiplier, denoted by $\mu$, must be found. This comes at the price that guaranteeing C$5$ with $M^{\prime}=M$ does not imply that C$4$ will always be satisfied. Alternatively, enforcing C$5$ with $M^{\prime}<M$, will increase the probability of satisfying C$4$, since the solution will guarantee that “on average” there exists free space on the cache memory. A more formal discussion on this issue will be provided in the remark closing the subsection.

To describe in detail how accounting for C$5$ changes the optimal schemes, let (P$5$) be the problem obtained after augmenting (P$1$) with C$5$. Suppose now that to solve (P$5$) we dualize the single constraint in C$5$. Rearranging terms, the augmented objective associated with (P$5$) is given by

[TABLE]

Equation (27) demonstrates that after dualization and provided that the multiplier $\mu$ is known, decisions can be optimized separately across files. To be more precise, note that the term $\sum_{k=t}^{\infty}\gamma^{k-t}M^{\prime}$ in the objective is constant, so that it can be ignored, and define the modified instantaneous cost as

[TABLE]

The last equation not only reflects that the dualization indeed facilitates separate per-file optimization, but it also reveals that term $\mu\sigma^{f}$ can be interpreted as an additional storage cost associated with the long-term caching constraint. More importantly, by defining the modified (augmented) prices ${\rho^{f}_{t,\textrm{aug}}}:=\rho_{t}^{f}+\mu\sigma^{f}$ for all $t$ and $f$, the optimization of (28) can be carried out with the schemes presented in the previous sections, provided that $\rho_{t}^{f}$ is replaced with ${\rho^{f}_{t,\textrm{aug}}}$.

Note however that in order to run the optimal allocation algorithm, the value of $\mu$ needs to be known. Since the dual problem is always convex, one option is to use an iterative dual subgradient method, which computes the satisfaction/violation of the constraint C$5$ per iteration [36], [37, p.223]. Clearly, this requires knowledge of the state distribution, since the constraint involves an expectation. When such knowledge is not available, or when the computational complexity to carry out the expectations cannot be afforded, stochastic schemes are worth considering. For the particular case of estimating Lagrange multipliers associated with long-term constraints, a simple but powerful alternative is to resort to stochastic dual subgradient schemes [36], [37], which for the problem at hand, estimate the value of the multiplier $\mu$ at every time instant $t$ using the update rule

[TABLE]

In the last expression, $\zeta>0$ is a (small) positive constant, the update multiplied by $\zeta$ corresponds to the violation of the constraint after removing the expectation, the notation $[\cdot]^{+}$ stands for the $\max\{0,\cdot\}$, and $\hat{a}^{f\ast}_{t}$ denotes the optimal caching actions obtained with the policies described in Section III provided that $\rho_{t}^{f}$ is replaced by $\hat{\rho}^{f}_{t,\textrm{aug}}=\rho_{t}^{f}+\hat{\mu}_{t}\sigma^{f}$.

We next introduce another long-term constraint that can be considered to limit the storage rate. This constraint is useful not only because it gives rise to alternative novel caching-fetching schemes, but also because it will allow us to establish connections with well-known algorithms in the area of congestion control and queue management. To start, define the variables $\alpha_{in,t}^{f}:=[a_{t}^{f}-s_{t}^{f}]^{+}$ and $\alpha_{out,t}^{f}:=[s_{t}^{f}-a_{t}^{f}]^{+}$ for all $f$ and $t$. Clearly, if $\alpha_{in,t}^{f}=1$, then content $f$ that was not in the local cache at time $t-1$, has been stored at time $t$; and as a result, less storage space is available. On the other hand, if $\alpha_{out,t}^{f}=1$, then content $f$ was removed from the cache at time $t$, thus freeing up new storage space. With this notation at hand, we can consider the long term constraint

[TABLE]

which basically ensures the long-term stability of the local-storage. That is, the amount of data stored in the local memory is no larger than that taken out from the memory, guaranteeing that in the long term stored data does not grow unbounded.

To deal with C$6$ we can follow an approach similar to that of C$5$, under which we first dualize C$6$ and then use a stochastic dual method to estimate the associated dual variable. With a slight abuse of notation, supposing that the Lagrange multiplier associated with stability is by also denoted $\mu$, the counterpart of (29) for the constraint C$6$ is

[TABLE]

Note that the update term in the last iteration follows after removing the expectations in C$6$ and replacing $\alpha_{in,t}^{f}$, and $\alpha_{out,t}^{f}$ with their corresponding definitions. The modifications that the expressions for the optimal policies require to account for this constraint are a bit more intricate. If $s_{t}^{f}=0$, the problem structure is similar to that of the previous constraints, and we just need to replace $\rho_{t}^{f}$ with $\hat{\rho}^{f}_{t,\textrm{aug}}=\rho_{t}^{f}+\hat{\mu}_{t}\sigma^{f}$. However, if $s_{t}^{f}=1$, it turns out that: i) deciding ${\hat{a}}_{t}^{f\ast}=1$ does not require modifying the caching price, but ii) deciding ${\hat{a}}_{t}^{f\ast}=0$ requires considering the negative caching price $-\hat{\mu}_{t}\sigma^{f}$. In other words, while our formulation in Section III only considers incurring a cost when $a_{t}^{f}=1$ (and assumes that the instantaneous cost is zero for $a_{t}^{f}=0$), to fully account for C$6$, we would need to modify our original formulation so that costs can be associated with the decision $a_{t}^{f}=0$ as well. This can be done either by considering a new cost term or, simply by replacing $\gamma\bar{V}^{f}(0)$ by $\gamma\bar{V}^{f}(0)-\hat{\mu}_{t}\sigma^{f}$ in (13a)-(13d), which are Bellman’s equations describing the optimal policies.

Remark 3 (Role of the stochastic multipliers). It is well-established that the Lagrange multipliers can be interpreted as the marginal price that the system must pay to (over-)satisfy the constraint they are associated with [37, p.241]. When using stochastic methods for estimating the multipliers, further insights on the role of the multipliers can be obtained [26, 38, 27]. Consider for example the update in (29). The associated constraint C$5$ establishes that the long-term storage rate cannot exceed $M^{\prime}$. To guarantee so, the stochastic scheme updates the estimated price in a way that, if the constraint for time $t$ is oversatisfied, the price goes down, while if the constraint is violated, the price goes up. Intuitively, if the price estimate $\hat{\mu}_{t}$ is far from its optimal value and the constraint is violated for several consecutive time instants, the price will keep increasing, and eventually will take a value sufficiently high so that storage decisions are penalized/avoided. How quickly the system reacts to this violation can be controlled via the constant $\zeta$. Interestingly, by tuning the values of $M^{\prime}$ and $\zeta$, and assuming some regularity properties on the distribution of the state variables, conditions under which deterministic short-term limits as those in C$4$ are satisfied can be rigorously derived; see, e.g., [27] for a related problem in the context of distributed cloud networks. A similar analysis can be carried out for the update in (31) and its associated constraint C$6$. Every time the instantaneous version of the constraint is violated because the amount of data stored in the memory exceeds the amount exiting the memory, the corresponding price $\hat{\mu}_{t}$ increases, thus rendering future storage decisions more costly. In fact, if we initialize the multiplier at $\hat{\mu}_{t}=0$ and set $\zeta=1$, then the corresponding price is the total amount of information stored at time $t$ in the local memory. In other words, the update in (31) exemplifies how the dynamic prices considered in this paper can be used to account for the actual state of the caching storage. Clearly, additional mappings from the instantaneous storage level to the instantaneous storage price can be considered. The connections between stochastic Lagrange multipliers and storing devices have been thoroughly explored in the context of demand response, queuing management and congestion control. We refer the interested readers to, e.g., [26, 38].

IV-C Limits on the back-haul transmission rate

The previous two subsections dealt with limited caching storage, and how some of those limitations could be accounted for by modifying the caching price $\rho_{t}^{f}$. This section addresses limitations on the back-haul transmission rate between the SB and the cloud as well as their impact on the fetching price $\lambda_{t}^{f}$.

While our focus has been on optimizing the decisions at the SB, contemporary networks must be designed following a holistic (cross-layer) approach that accounts for the impact of local decisions on the rest of the network. Decomposition techniques (including those presented in this paper) are essential to that end [36]. For the system at hand, suppose that $\mathbf{x}_{CD}$ includes all variables at the cloud network, $\bar{C}_{CD}(\mathbf{x}_{CD})$ denotes the associated cost, and the feasible set $\mathcal{X}_{CD}$ accounts for the constraints that cloud variables $\mathbf{x}_{CD}$ must satisfy. Similarly, let $\mathbf{x}_{SB}$, $\bar{C}_{SB}(\mathbf{x}_{SB})$, and $\mathcal{X}_{SB}$ denote the corresponding counterparts for the SB optimization analyzed in this paper. Clearly, the fetching actions $w_{t}^{f}$ are included in $\mathbf{x}_{SB}$, while the variable $b_{t}$ representing back-haul transmission rate (capacity) of the connecting link between the cloud and the SB, is included in $\mathbf{x}_{CD}$. This transmission rate will depend on the resources that the cloud chooses to allocate to that particular link, and will control the communication rate (and hence the cost of fetching requests) between the SB and the cloud. As in the previous section, one could consider two types of capacity constraints

[TABLE]

depending on whether the limit is imposed in the short term or in the long term.

With these notational conventions, one could then consider the joint resource allocation problem

[TABLE]

where the constraint C$7$ – either the instantaneous one in C$7a$ or the lon-term version in C$7b$ – couples both optimizations. It is then clear that if one dualizes C$7$, and the value of the Lagrange multiplier associated with C$7$ is known, then two separate optimizations can be run: one focusing on the cloud network and the other one on the SB. For this second optimization, consider for simplicity that the average constraint in (32b) is selected and let $\nu$ denote the Lagrange multiplier associated with such a constraint. The optimization corresponding to the SB is then

[TABLE]

Clearly, solving this problem is equivalent to solving the original problem in Section III, provided that the original cost is augmented with the primal-dual term associated with the coupling constraint. To address the modified optimization, we will follow steps similar to those in Section IV-B, defining first a stochastic estimate of the Lagrange multiplier as

[TABLE]

and then obtaining the optimal caching-fetching decisions running the schemes in Section III after replacing the original fetching cost $\lambda_{t}^{f}$ with the augmented one $\lambda^{f}_{t,{\textrm{aug}}}=\lambda_{t}^{f}+\hat{\nu}_{t}\sigma_{f}$.

For simplicity, in this section we will limit our discussion to the case where $\hat{\nu}_{t}$ corresponds to the value of a Lagrange multiplier corresponding to a communication constraint. However, from a more general point of view, $\hat{\nu}_{t}$ represents the marginal price that the cloud network has to pay to transmit the information requested by the SB. In that sense, there exists a broad range of options to set the value of $\hat{\nu}_{t}$, including the congestion level at the cloud network (which is also represented by a Lagrange multiplier), or the rate (power) cost associated with the back-haul link. While a detailed discussion on those options is of interest, it goes beyond the scope of the present work.

IV-D Modified online solver based on $Q$-learning

We close this section by providing an online reinforcement-learning algorithm that modifies the one introduced in Section III to account for the multipliers introduced in Section IV.

By defining per file cost $\hat{c}_{k}^{f}$ as

[TABLE]

the problem of caching under limited cache capacity and back-haul link reduces to per file optimization as follows

[TABLE]

where the updated dual variables $\hat{\mu}_{k}$ and $\hat{\nu}_{k}$ are obtained respectively by iteration (29) and (35). If we plug $\hat{c}_{k}^{f}$ instead of $c_{k}^{f}$ into the marginalized $Q$-function in (21), then the solution for (P8) in current iteration $k$ for a given file $f$ can readily be found by solving

[TABLE]

Thus, it suffices to form a marginalized $Q$-function for each file and solve (37), which can be easily accomplished through exhaustive search over $8$ possible cache-fetch decisions $(w,a)\in\mathcal{X}(r_{t},{a_{t-1}})$.

To simplify notation and exposition, we focus on the limited caching capacity constraint, and suppose that the back-haul is capable of serving any requests, thus $\hat{\nu}_{t}=0,\;\forall t$. Modifications to account also for $\hat{\nu}_{t}\neq 0$ are straightforward.

The modified $Q$-learning (MQ-learning) algorithm, tabulated in Algorithm 3, essentially learns to make optimal fetch-cache decisions while accounting for the limited caching capacity constraint in C$4$ and/or C$5$. In particular, to provide a computationally efficient solver the stochastic updates corresponding to C$5$ are used. Subsequently, if C$4$ needs to be enforced, the obtained solution is projected into the feasible set through projection algorithm $\Pi_{\rm C4}(\cdot)$. The projection $\Pi_{\rm C4}(.)$ takes the obtained solution $\{{\breve{w}^{f\ast}_{t},{\breve{a}}^{f\ast}_{t}}\}_{\forall f}$, the file sizes, as well as the marginalized $Q$-functions as input, and generates a feasible solution $\{{w}^{f\ast}_{t},{a}^{f\ast}_{t}\}_{\forall f}$ satisfying C$4$ as follows: it sorts the files with ${\breve{a}}^{f\ast}_{t}=1$ in ascending $Q$-function order, and caches the files with the lowest $Q$-values until the cache capacity is reached. Overall, our modified algorithm performs a “double” learning: i) by using reinforcement schemes it learns the optimal policies that map states to actions, and ii) by using a stochastic dual approach it learns the mechanism that adapt the prices to the saturation and congestion conditions in the cache. Given the operating conditions and the design approach considered in the paper, the proposed algorithm has moderate complexity, and thanks to the reduced input dimensionality, it also converges in a moderate number of iterations.

V Numerical tests

In this section, we numerically assess the performance of the proposed approaches for learning optimal fetch-cache decisions. Two sets of numerical tests are provided. In the first set, summarized in Figs 2-5, the performance of the value iteration-based scheme in Alg. 1 is evaluated, and in the second set, summarized in Figs. 6-7, the performance of the $Q$-learning solver is investigated. In both sets, the cache and fetch cost parameters are drawn with equal probability from a finite number of values, where the mean is $\bar{\rho}^{f}$ and $\bar{\lambda}^{f}$, respectively. Furthermore, the request variable $r^{f}$ is modeled as a Bernoulli random variable with mean $p^{f}$, whose value indicates the popularity of file $f$.

In the first set, it is assumed that $p^{f}$ as well as the distribution of $\rho^{f},\lambda^{f}$, are known a priori. Simulations are carried out for a content of unit size, and can be readily extended to files of different sizes. To help readability, we drop the superscript $f$ in this section.

Fig. 2 plots the sum average cost $\bar{\mathcal{C}}$ versus $\bar{\rho}$ for different values of $\bar{\lambda}$ and $p$. The fetching cost is set to $\bar{\lambda}\in\left\{43,45,50,58\right\}$ for two different values of popularity $p\in\{0.3,0.5\}$. As depicted, higher values of $\bar{\rho},\bar{\lambda},p$ generally lead to a higher average cost. In particular, when $\bar{\rho}\ll\bar{\lambda}$, caching is considerably cheaper than fetching, thus setting $a_{t}=1$ is optimal for most $t$. As a consequence, the total cost linearly increases with $\bar{\rho}$ as most requests are met via cached contents rather than fetching. Interestingly, if $\bar{\rho}$ keeps increasing, the aggregate cost gradually saturates and does not grow anymore. The reason behind this observation is the fact that, for very high values of $\bar{\rho}$, fetching becomes the optimal decision for meeting most file requests and, hence, the aggregate cost no longer depends on $\bar{\rho}$. While this behavior occurs for the two values of $p$, we observe that for the smallest one, the saturation is more abrupt and takes place at a lower $\bar{\rho}$. The intuition in this case is that for lower popularity values, the file is requested less frequently, thus the caching cost aggregated over a (long) period of time often exceeds the “reward” obtained when (infrequent) requests are served by the local cache. As a consequence, fetching in the infrequent case of $r_{t}=1$ incurs less cost than the caching cost aggregated over time.

To corroborate these findings, Fig. 3 depicts the sum average cost versus $p$ for different values of $\bar{\rho}$ and $\bar{\lambda}$. The results show that for large values of $\bar{\rho}$, fetching is the optimal action, resulting in a linear increase in the total cost as $p$ increases. In contrast, for small values of $\bar{\rho}$, caching is chosen more frequently, resulting in a sub-linear cost growth.

To investigate the caching-versus-fetching trade-off for a broader range of $\bar{\rho}$ and $\bar{\lambda}$, let us define the caching ratio as the aggregated number of positive caching decisions (those for which $a_{t}=1$) divided by the total number of decisions. Fig. 4 plots this ratio for different values of $(\bar{\rho},\bar{\lambda})$ and fixed $p=0.5$. As the plot demonstrates, when $\bar{\rho}$ is small and $\bar{\lambda}$ is large, files are cached almost all the time, with the caching ratio decreasing (non-symmetrically) as $\bar{\rho}$ increases and $\bar{\lambda}$ decreases.

Finally, Fig. 5 compares the performance of the proposed DP-based strategy with that of a myopic one. The myopic policy sets $a_{t}\!=\!1$ if $\lambda_{t}\!>\!\rho_{t}$ and the content is locally available (either because $w_{t}\!=\!1$ or because $s_{t}\!=\!1$), and sets $a_{t}\!=\!0$ otherwise. The results indicate that the proposed strategy outperforms the myopic one for all values of $\bar{\rho},\bar{\lambda},p$ and $\gamma$.

In the second set of tests, the performance of the online Q-learning solvers is investigated. As explained in Section III, under the assumption that the underlying distributions are stationary, the performance of the Q-learning solver should converge to the optimal one found through the value iteration algorithm. Corroborating this statement, Fig. 6 plots the sum average cost $\bar{\mathcal{C}}$ versus $\bar{\rho}$ of both the marginalized value iteration and the Q-learning solver, with $\bar{\lambda}\in\left\{29,36,44\right\}$ and $p\in\left\{0.3,0.5\right\}$. The solid lines are obtained when assuming a priori knowledge of the distributions and then running the marginalized value iteration algorithm; the results and analysis are similar to the ones reported for Fig. 2. The dashed curves however, are found by assuming unknown distributions and running the Q-learning solver. Sum average cost is reported after first $1000$ iterations. As the plot suggests, despite the lack of a priori knowledge on the distributions, the Q-learning solver is able to find the optimal decision making rule. As a result, it yields the same sum average cost as that of value-iteration under known distributions.

The last experiment investigates the impact of the instantaneous cache capacity constraint in C$4$ as well as non-stationary distributions for popularities and costs. To this end, 1,000 different realizations (trajectories) of the random state processes are drawn, each of length $T=600$. For every realization, the cost $c_{t}$ [cf. (6)] at each and every time instant is found, and the cost trajectory is averaged across the 1,000 realizations. Specifically, let $c_{t}^{i}$ denote the $i$th realization cost at time $t$, and define the averaged cost trajectory as ${\bar{c}}_{t}:=\frac{1}{1000}\sum_{i=1}^{1000}c^{i}_{t}$. Fig. 7 reports the average trajectory of ${\bar{c}}_{t}$ in a setup where the total number of files is set to $F=500$, the file sizes are drawn uniformly at random from the interval $[1,100]$, and the total cache capacity is set to $40\%$ of the aggregate file size. Adopted parameters for the MQ-learning solver are set to $\beta=0.3,$ and $\epsilon=0.01$. Three blocks of iterations are shown in the figure, where in each block a specific distribution of popularities and costs are considered. For instance, the dashed line shows the popularity of a specific file in one of the realizations, where in the fist block $p=0.23$, in the second block $p=0.37$, and in the third one $p=0.01$. The cost parameters have means $\bar{\lambda}=44,\bar{\rho}=2$, $\bar{\lambda}=40,\bar{\rho}=5$, and $\bar{\lambda}=38,\bar{\rho}=2$ in the consecutive blocks, respectively. As this plot suggests, the MQ-learning algorithm incurs large costs during the first few iterations. Then, it gradually adapts to the file popularities and cost distributions, and learns how to make optimal fetch-cache decisions, decreasing progressively the cost in each of the blocks. To better understand the behavior of the algorithm and assess its performance, we compare it with that of a myopic policy and the stationary policy whose costs are represented using a green and black line, respectively. During the first iterations, when the MQ-learning algorithm has not adapted to the distribution of pertinent parameters, the myopic policy performs better. However, as the learning proceeds, the MQ-learning starts to make more precise decisions and, remarkably, in a couple of hundreds of iterations it is able to perform very close to the optimal policy.

VI Conclusions

A generic setup where a caching unit makes sequential fetch-cache decisions based on dynamic prices and user requests was investigated. Critical constraints were identified, the aggregated cost across files and time instants was formed, and the optimal adaptive caching was then formulated as a stochastic optimization problem. Due to the effects of the current cache decisions on future costs, the problem was cast as a dynamic program. To address the inherent functional estimation problem that arises in this type of programs, while leveraging the underlying problem structure, several computationally efficient algorithms were developed, including off-line (batch) approaches, as well as online (stochastic) approaches based on Q-learning. The last part of the paper was devoted to dynamic pricing mechanisms that allowed handling constraints both in the storage capacity of the cache memory, as well as on the back-haul transmission link connecting the caching unit with the cloud.