Joint Optimization of Caching and Recommendation with Performance Guarantee for Effective Content Delivery in IoT

Abstract

Content caching and recommendation for content delivery over the Internet are two key techniques for improving the content delivery effectiveness determined by delivery efficiency and user satisfaction, which is increasingly important in the booming Internet of Things (IoT). While content caching seeks the “greatest common denominator” among users to reduce end-to-end delay in content delivery, personalized recommendation, on the contrary, emphasizes users’ differentiation to enhance user satisfaction. Existing studies typically address them separately rather than jointly due to their contradictory objectives. They focus mainly on heuristics and deep reinforcement learning methods without the provision of performance guarantees, which are required in many real-world applications. In this paper, we study the problem of joint optimization of caching and recommendation in which recommendation is performed in the cached contents instead of purely according to users’ preferences, as in the existing work. We show the NP-hardness of this problem and present a greedy solution with a performance guarantee by first performing content caching according to user request probability without considering recommendations to maximize the aggregated request probability on cached contents and then recommendations from cached contents to incorporate user preferences for cache hit rate maximization. We prove that this problem has a monotonically increasing and submodular objective function and develop an efficient algorithm that achieves a $1-{\displaystyle \frac{1}{e}}\approx 0.63$ approximation ratio to the optimal solution. Experimental results demonstrate that our algorithm dramatically improves the popular least-recently used (LRU) algorithm. We also show experimental evaluations of hit rate variations by Jensen–Shannon Divergence on different parameter settings of cache capacity and user preference distortion limit, which can be used as a reference for appropriate parameter settings to balance user preferences and cache hit rate for Internet content delivery.

1. Introduction

A Content Delivery Network (CDN) is an important technology for data delivery in the Internet of Things (IoT). It stores content in multiple proxy servers geographically to enable users to obtain content from the nearest servers geographically close to them, thereby reducing the transmission delay and loading time [1,2]. As proxy servers share the load of the originating servers and reduce their pressure of directly handling user requests, CDNs improve the overall system performance and stability. By replicating content on multiple servers, a CDN can quickly fetch the content from other servers in the event of the requested server’s failure, ensuring continuous service availability. In addition, CDN effectively reduces network bandwidth consumption and data center operating costs by caching content and optimizing data transmissions. It works by caching static content (such as images, videos, CSS, JavaScript, etc.) on CDN nodes distributed globally, and when a user requests a website, DNS routes the request to the nearest CDN node, which, based on the user’s request, caches the content and then sends it to the nearest CDN node [3]. According to the user’s request, the node will return the cached content directly to the user or get the latest content from the original server and return it. Common CDN service providers include Cloudflare, Akamai, Amazon CloudFront, Google Cloud CDN [4], etc. CDNs are widely used in a variety of websites and applications, especially those that require fast loading and high availability, such as video streaming, e-commerce, and social media.

On the other hand, recommender systems play a crucial role in today’s Internet [5]. In contrast to content caching, which focuses on the popularity of user requests, content recommendation emphasizes personalization of user interest and recommends content to users according to their individual interests, which may include new content that the users have not requested before. With the maturity of recommender systems, recommendations have shown great importance in CDN for improving its service satisfaction. For example, Netflix reports that 80% of its total product views are influenced by recommendation systems [6]. The joint optimization of content caching and recommendation at the same time for both popularity and personalization is of increasing significance for improving system effectiveness in efficiency and service satisfaction. However, achieving this faces great technical challenges due to the contradicting goals of caching and recommendation, while cache hit-rate maximization focuses on finding commonalities among user requests to improve network efficiency, recommendation emphasizes users’ individual needs for the purpose of enhancing user stickiness. As different users have different needs and access behavioral patterns, it is a challenging problem to find a balance between diverse user needs to ensure the accuracy of recommended content and the efficiency of caching frequently used content [7].

Most previous studies focus on either cache hit-rate maximization or recommender system optimization, and little is known about jointly optimizing the two, particularly with a provable performance guarantee. Our research is dedicated to solving the problem of jointly optimizing content caching and recommendation to maximize the cache hit rate without overly distorting the recommended content. We formulate this problem as a constrained optimization problem and show its NP-hardness even without considering recommendations. For the more general case when the recommendation is done among the cached contents, we show that this problem has the property of a monotonically increasing and submodular objective funcion and propose an algorithm with an approximation ratio of $1-{\displaystyle \frac{1}{e}}$.

Our contributions are summarized as follows:

•

Define the joint caching and recommendation optimization problem and show its NP-hardness even without considering the recommendation.

•

Prove that when a recommendation is made from cached contents, this problem has a monotonically increasing and submodular objective function.

•

Propose a greedy algorithm to solve the above problem with a worst-case performance guarantee of $1-{\displaystyle \frac{1}{e}}$ from the optimal solution.

•

Experimentally validate the performance of the proposed algorithm and demonstrate its variations on different parameter settings.

2. Related Work

As a classical topic in data networks, the main challenge for caching is how to accurately predict user demand and content popularity. Because content demand is temporally localized (i.e., content relevance is time-dependent, and similar content is frequently accessed in a short period of time), demand prediction for user content should take into account the temporal localization between contents. If the user content demand is accurately predicted, then the cache hit rate can be improved, which is the main problem to be solved by CDNs. CDNs are deployed by network operators, and their customers are mainly content providers such as YouTube, TikTok, etc., in recent years. One of the core competencies of these content providers is the recommendation of content, which can enhance user stickiness and thus improve the revenue of content providers. Therefore, the joint optimization of caching and recommender systems in CDNs has become an important research area, which is also the core topic of our paper. To the best of our knowledge, the joint role of caching and recommendation is considered simultaneously in [8,9,10,11,12,13,14]. The first four of them address caching recommendations for video content, while the rest address caching recommendations for generic content.

The work [8] seems to be the first that makes caching decisions based on recommender system decisions. Their recommendation-driven, caching-based scheme outperforms traditional content prediction schemes, which, however, disappear in real-world scenarios where caching serves a larger number of users. The work [10] proposed to cache the most popular content locally rather than globally. The work [12] proposed a method to identify cached content for CDNs based on a recommender system, but it was not quantitatively evaluated. What refs. [8,10,12] have in common is that caching is based on the recommender system. In other words, they consider the post-recommendation user preferences as the actual user preferences. Our work differs from theirs in that our recommender system is not used purely for the prediction of user content demand but as a user preference moderation tool for balancing user preferences with performance metrics. Our proposed algorithm tunes user preferences during the course of their prediction to improve network performance.

In fact, the studies in [9,11,13,14] are closer to ours. The work [9] ranked cached videos higher by rearranging the list of related videos, thus influencing users’ preference and then boosting the cache hit rate. The work [13] studied peer-to-peer (P2P) systems, and its algorithm mainly solves the recommendation problem considering the cost of content distribution. The work [14] proposed a framework for proactive resource and demand allocation and theoretically analyzed that the delivery cost of proactive caching will be lower. Their recommender system enhances user demand certainty by actively modifying user ratings of content. The work [11] proposed the concept of “soft cache hit”, i.e., if a user clicks on a relevant alternative to unhit content (which is already cached), it will be considered a “soft cache hit”, and also studied the caching-recommendation joint optimization problem.

In addition, the work [15] proposed a method to jointly optimize the content caching and recommendation system, aiming to improve the cache hit rate and user experience in regional networks. By analyzing the user’s request patterns and behaviors and dynamically adjusting the cached and recommended contents, it achieves more efficient content distribution and recommendation. However, its deployment is difficult due to high computational complexity and the need for frequent policy changes. The work [16] proposed a Markov model to handle recommendation-driven user requests and developed an iterative ADMM-based algorithm to minimize the access cost and maintain the quality of the recommendations to address the problem of large fluctuations in user preferences and the complex sequential consumption patterns that make traditional caching methods ineffective in edge environments. The work [17] proposed “soft cache hits” to improve the cache hit rate by caching not only the content that is directly requested by the user, but also content that is related to the requested content to improve the cache hit rate. It developed a model to evaluate the impact of recommended relevant content on cache performance and then proposed an optimization algorithm that analyzes the user’s content access patterns and relevance, enabling dynamically adjusting the caching policy to maximize “soft cache hits” and reduce content access latency. The work [18] defined a streaming experience metric that captures the fundamental tradeoff between caching and recommendations and proposed an approximation algorithm under this metric that balances cache capacity constraints and recommendation quality to maximize user satisfaction and cache hit rate. The algorithm combines cache management and recommendation systems to reduce content access latency through an optimization policy. It also provided the approximation performance of the algorithm and experimental verification of its effectiveness in real applications, showing better cache utilization and recommendation results under the given tradeoff metric between caching and recommendations.

Closely related to the above work, Liang et al. [19] studied the problem of cooperative caching of vehicles to reduce energy consumption and delay in vehicular networking. The authors solve the problem based on a deep reinforcement learning approach by considering the constraints of tolerable latency of the task and dwell time of the vehicle. Su et al. [20] studied the joint optimization cache recommendation problem by giving a reinforcement learning-based algorithm that contains prediction and allocation phases. The prediction phase estimates the values of cache choices by considering value policy dependencies, while the allocation phase determines the cache choices for each request while satisfying global budget constraints. Chen et al. [21] studied optimization in large-scale caching and recommender systems and proposed a cache-aware reinforcement learning approach to optimize recommendations through real-time computation and caching. Song et al. [22] studied the wireless edge offload scenario of device-to-device offloading, which actually recommends a user’s cached content to encountered users. The strategy takes into account both personalized preferences and relative location without burdening the cellular link. Fu et al. [23] studied the problem of maximizing the cache hit rate in wireless edge offload scenarios. The authors give a time-efficient iterative algorithm for solving the problem, taking into account the quality of personalized recommendations, the number of recommendations, and the cache capacity requirements for each user.

Zhang et al. [24] investigated the use of proactive content pushing during low peak hours to improve spectrum efficiency, revenue prediction based on reinforcement learning, and solving for joint pushing, pricing, and recommending in cache-enabled wireless access networks based on linear programming. Fu et al. [25] optimized content encoding by joint caching and recommendation, studied the problem of maximizing the hit rate of wireless edge caching networks, and achieved the optimal solution to this problem from a game-theoretic perspective. Tsigkar et al. [26] studied the relationship between the cost and revenue of CDNs that are reduced by recommendation, and the authors proposed a model to find the tradeoff between the two and gave an economic mechanism based on Nash bargaining to enhance the final financial returns. Tharakan et al. [27] investigated the joint optimization of cached recommendations for wireless edge computing, modeling the impact of recommendations on popularity through probabilistic transformation matrices and solving the optimization problem based on point estimation and Bayesian estimation methods. Zheng et al. [28] modeled the influence of a user’s preference distribution and recommendation and then proposed a heuristic algorithm with low computational complexity to solve the joint recommendation and cache optimization problem.

Deployment of joint caching and recommendation is becoming increasingly popular and has found significant performance improvements in various applications including video streaming [8,9,10] and content delivery [11,12,13,14,15,16,17,18,29].

A classification of major approaches for caching-recommendation joint optimization is shown in

Table 1. Classification of research methods in caching-recommendation joint optimization.

Research Method	Representative Papers
Recommender-Driven Caching	Verhoeyen et al. [8]
Heuristic/ML-Based Joint Optimization	Liang et al. [13]
Soft Cache Hit Strategies	Sermpezis et al. [17]
Game-Theoretic/Economic Models	Fu et al. [23]
Approximation Algorithms with Guarantees	Tsigkari et al. [19]
Probabilistic/Statistical Modeling	Tharakan et al. [27]

.

Compared with the previous work, we do not assume that a recommender system is always “honest”, i.e., our recommender system may make recommendations driven by factors such as product promotion rather than purely by user interests, which may make its recommended content deviate from cached hits. We study the joint optimization of caching and recommendation in CDNs in the general case without assuming the honesty of the recommender system and the tradeoff metric between caching and recommendations. In comparison with most existing studies that either focus only on cache optimization, or consider caching-recommendation joint optimization under special assumptions of their relationships, or provide only heuristics and deep reinforcement learning methods without proof of performance guarantee, our study synthesizes the general-case joint optimization problem of caching and recommendation, shows its NP-hardness in the simple case of a single user, and provides a solution with a performance guarantee of $1-{\displaystyle \frac{1}{e}}$ from the optimal solution for the case when the recommended contents are selected only from the cached contents.

3. Joint Optimization of Cashing and Recommendation

3.1. Overview of the Problem

Our model consists of a server that can cache a fixed amount of content. Multiple users each have unique preferences for different content, i.e., users have different distributions of request probabilities for content. For both user experience and caching reasons, the system can recommend content to each user, which will change their probability of requesting the content. In general, an “honest” recommendation system will recommend the user’s favorite content. However, for cache hit rate considerations, our system does not assume honest recommendation, i.e.,  it may recommend content that is not in the user’s preference. We show that our recommender system’s recommendations are no more distorted than those of an “honest” recommender system. Our goal is to maximize the probability that our system will reach a high cache hit rate while satisfying the constraints of cache size and content distortion tolerance.

Figure 1 shows a simple system model along with a simple example. There is a lot of content in the back-end server, and three users are only interested in content “ABCD” and f denotes each user’s preference score for that content, with a total score of 100. Here, it is assumed that each piece of content is of the same size and the CDN capacity is three. The simple caching scheme is to cache the three contents with the largest original probability P for all users. The three users have different preferences, and their common favorite is ABC, so content ABC is cached in the CDN. And the recommendation score is set to half of the original preference score. If the content has been cached, an additional 5% of the total preference score is added. In addition, the recommendation score must not exceed the original preference score. With the combined effect of the caching and recommendation, the total cache hit rate of user requests is improved from 0.8167 (P before recommendation) to 0.833 (Q after recommendation).

3.2. System Model

There are n pieces of content and m users in the system, the size of content i is $w_i$, and the cache capacity of the server is c. There are m users in the system, and the frequency of requests from user u for content i is denoted by $F_i^u$. For simplicity, $F_i$ is used to denote the frequency of a user’s request for content i, which can be counted by the system in actual operation. In practice, the raw frequency is

$$P_i={\displaystyle \frac{F_i}{{\sum }_{j=1,2,\dots ,n}{F}_j}},$$

(1)

which denotes the raw request frequency of the user for the content. The recommender system will give a recommendation score $R_i$ for content i for the user, and when no recommendation is made for content i, the recommendation score $R_i=0$. With the intervention of the recommender system, we will correct the frequency is

$${\widehat{P}}_i={\displaystyle \frac{F_i+R_i}{{\sum }_{j=1,2,\dots ,n}(F_j+R_j)}},$$

(2)

which denotes the actual request frequency of the user at this point.

For the server, we use $x_i=1$ to indicate that content i is cached and $x_i=0$ otherwise. Since the number of cached contents must not exceed the server capacity, there is ${\sum }_{j=1,2,\dots ,n}{x}_i\le c$.

On the other hand, we define the degree of distortion as

$$D\left(k\right)=1-{\displaystyle \frac{{\sum }_{i\in K}{P}_i}{{\sum }_{i\in K_{best}}{P}_i}},$$

(3)

which denotes the difference between the least “honest” recommender and the “honest” recommender when recommending up to k pieces of content. Here, $K_{best}$ denotes the set of k contents with the highest probability of being requested, which is the content that should be recommended by an “honest” recommender system, while K denotes the k contents that the recommender system actually chooses to recommend. To ensure that the distortion of the system’s recommendations for user u is less than its tolerance upper bound $d_u$, we apply the constraint $D\left(k\right)\le d_u$.

With the intervention of the recommender system, the cache hit rate of user u’s content request is

$$H=\sum _{u=1,2,\dots ,m}\sum _{i=1,2,\dots ,n}{x}_i{\widehat{P}}_i^u$$

(4)

3.3. Problem Formulation

The problem of joint optimization of caching and recommendation can be mathematically formulated as follows:

$$\begin{array}{cc}\hfill & \underset{X,R}{max}H=\sum _{u=1,2,\dots ,m}\sum _{i=1,2,\dots ,n}{x}_i{\widehat{P}}_i^u\hfill \\ \hfill & \begin{array}{cc}\hfill s.t.& \hfill \sum x_i{w}_i\le c\\ \hfill & \hfill D{\left(k\right)}_u=1-{\displaystyle \frac{{\sum }_{i\in K}{P}_i}{{\sum }_{i\in K_{best}}{P}_i}}\le d_u\\ \hfill & \hfill R_i^u\le (1+\gamma )F_i^u\\ \hfill & \hfill {\widehat{P}}_i^u\le (1+\alpha )P_i^u\\ \hfill & \hfill 0\le d_u,\alpha \le 1,-1\le \gamma \le 0\end{array}\hfill \end{array}$$

(5)

Here, i denotes the content, and u denotes the user. The first constraint indicates that the capacity of all cached content will not exceed the cacheable capacity c of the server. The second constraint indicates that the distortion value of the recommendation for user u, namely warping degree $D{\left(k\right)}_u$, will not exceed its tolerance limit $d_u$. The third and fourth constraints respectively set the upper limits on the recommendation score $R_i$ and modification frequency ${\widehat{P}}_i$ with respect to the original (request) frequency. Condition $0\le d_u\le 1$ states that the tolerance limit of distortion $d_u$ is at least 0 (no distortion) and at most 1 (100% distortion), $-1\le \gamma \le 0$ ensures that the recommended score is non-negative and at most the original frequency, and $0\le \alpha \le 1$ ensures that the corrected frequency after recommendation is at least the original frequency.

4. Problem Complexity

4.1. NP-Hardness of the Problem

Theorem 1.

The problem of joint optimization of caching and recommendation expressed in Fomulation (5) is NP-hard.

Proof. 

We prove Theorem 1 by showing how the joint optimization problem reduces to the weighted 0/1 knapsack problem through constructing a special case of the problem that relaxes the original problem to the weighted 0/1 knapsack problem.

We construct a special case of the original problem by setting $m=1$, $d=0$, $\gamma =-1$ and $\alpha =0$. Under these settings, we have the following:

• $m=1\Rightarrow u=1$, i.e., only a single user;
• $d=0\Rightarrow D_u=0$, the second constraint of Formula (5) is satisfied and hence can be removed (no distortion);
• $\gamma =-1\Rightarrow R_i^u=0$, the third constraint of Formula (5) is satisfied and hence can be removed (no recommendation);
• $\alpha =0\Rightarrow \widehat{P_i}=P_i$, the fourth constraint of Formula (5) is satisfied and hence can be removed (no modification to request frequency).

Under the above realization, the original problem is reduced to the following simplified problem:

$$\begin{array}{cc}\hfill & \underset{X}{max}H=\sum _{i=1,2,\dots ,n}{x}_i{\widehat{P}}_i\hfill \\ \hfill & \begin{array}{cc}\hfill s.t.& \hfill \sum x_i{w}_i\le c\end{array}\hfill \end{array}$$

(6)

Clearly, the problem of Formula (6) is the classical weighted 0/1-backpack problem with backpack capacity c, item value $P_i$, and weight $w_i$, which is well-known to be NP-hard. The above reduction shows that the simplified joint optimization problem is NP-hard, and therefore so is the original problem of Formula (5). □

4.2. Complexity of Cached Recommendation

To explore an efficient solution with a performance guarantee, we assume that the recommendation is performed only from the cached contents that have already been brought into memory, namely, cached recommendation, which may contain contents not on the user’s preference list, as the cache is usually much larger than the user’s preference list. This problem is apparently harder than the simplified joint optimization problem without recommendation given in Formula (6), which is already NP-hard, as shown in the proof of Theorem 1.

When the cache is large enough to accommodate the database, it becomes the general-case problem of unlimited recommendation spanning the entire database.

We solve the cached recommendation problem by decomposing it into two subproblems:

• Subproblem 1: computing the cached contents according to the given user request probability for each content until the cache capacity is filled. The goal is to maximize the total user request probability for all the contents under the cache capacity constraint.
• Subproblem 2: determine the recommended contents from the cached contents. The goal is to maximize the total user cache hit rate while satisfying the warping degree constraint and the recommendation constraint.

For Subproblem 1, we can solve it using dynamic programming optimally.

For Subproblem 2, we show that its objective function of cache hit rate is monotonically increasing and submodular, so there exists a greedy algorithm with a performance guarantee to solve the problem.

4.3. Proof of Monotonicity

Lemma 1.

The objective function of cache hit rate in Subproblem 2 is monotonically increasing.

Proof. 

The definition of an increasing set function is that the value of the set function increases as you keep adding arbitrary elements to the set of independent variables. Suppose the set of cached content is C, the full set containing all content is N, and the set of recommended content is A. Then, the hit rate is

$$\begin{array}{cc}\hfill & H\left(A\right)=1-{\displaystyle \frac{{\sum }_{i\in N/C}(F_i+R_i)}{{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e}}\hfill \\ \hfill & =1-{\displaystyle \frac{{\sum }_{i\in N/C}{F}_i}{{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e}},\hfill \end{array}$$

where $N/C$ denotes the set of uncached content, $N/\left\{e\right\}$ denotes the set of all content except content e, and $F_e$ denotes the frequency of content e. Since the recommended content is obtained only from the cached content, there are $A\subset C$ and $A\cap (N/C)=\varnothing$, so $R_i=0,\forall i\in N/C$. The above equation states that the hit rate $H\left(A\right)$ equals 1 minus the sum of probabilities of all uncached content when the recommendation is done only on the cache’s content, i.e., recommended content $A\subset C$.

When recommending an arbitrary content e, the set of recommendations becomes $A\cup \left\{e\right\}$, and the hit rate is

$$H(A\cup \left\{e\right\})=1-{\displaystyle \frac{{\sum }_{i\in N/C}{F}_i}{{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e+R_e}},$$

The hit increment is

$$\begin{array}{cc}\hfill & \mathsf{\Delta }H=H(A\cup \{e\left\}\right)-H\left(A\right)\hfill \\ \hfill & ={\displaystyle \frac{R_e·{\sum }_{i\in N/C}Fi}{[{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e][{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e+R_e].}}\hfill \end{array}$$

Since both $R_i$ and $F_i$ are greater than or equal to 0, $\mathsf{\Delta }H\ge 0$, so H is monotonically increasing. □

4.4. Proof of Submodularity

Lemma 2.

The objective function of cache hit rate in Subproblem 2 is submodular.

Proof. 

Submodularity of an aggregate function f stands for the diminishing marginal gain property of f. That is, for two sets A and B of independent variables, where $A\subset B\subset C$, $f(A\cup \{e\left\}\right)-f\left(A\right)\ge f\left(Bcup\right\{e\left\}\right)-f\left(B\right)$ holds for adding any element $e\in C\setminus B$.

For cash hit rate H in Subproblem 2, we have

$$\begin{array}{cc}\hfill & H(A\cup \{e\left\}\right)-H\left(A\right)\hfill \\ \hfill & ={\displaystyle \frac{R_e·{\sum }_{i\in N/C}Fi}{[{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e][{\sum }_{i\in N/\left\{e\right\}}(F_i+R_i)+F_e+R_e]}}\hfill \\ \hfill & =R_e·\sum _{i\in N/C}Fi/\{[\sum _{i\in A/\left\{e\right\}}(F_i+R_i)+\sum _{i\in (N/A)/\left\{e\right\}}{F}_i+F_e]\times \hfill \\ \hfill & [\sum _{i\in A/\left\{e\right\}}(F_i+R_i)+\sum _{i\in (N/A)/\left\{e\right\}}{F}_i+F_e+R_e]\}.\hfill \end{array}$$

Let

$$\tilde{A}=\sum _{i\in A/\left\{e\right\}}(F_i+R_i)+\sum _{i\in (N/A)/\left\{e\right\}}{F}_i+F_e$$

$$\tilde{B}=\sum _{i\in B/\left\{e\right\}}(F_i+R_i)+\sum _{i\in (N/B)/\left\{e\right\}}{F}_i+F_e.$$

It is easy to see that $\tilde{A}\ge 0,\tilde{B}\ge 0$, then

$$H(A\cup \left\{e\right\})-H\left(A\right)={\displaystyle \frac{R_e·{\sum }_{i\in N/C}Fi}{\tilde{A}[\tilde{A}+R_e]}}$$

$$H(B\cup \left\{e\right\})-H\left(B\right)={\displaystyle \frac{R_e·{\sum }_{i\in N/C}Fi}{\tilde{B}[\tilde{B}+R_e].}}$$

So

$$\begin{array}{cc}\hfill & \left[H\right(A\cup \left\{e\right\})-H(A\left)\right]-\left[H\right(B\cup \left\{e\right\})-H(B\left)\right]\hfill \\ \hfill & R_e·\sum _{i\in N/C}Fi·{\displaystyle \frac{\tilde{B}[\tilde{B}+R_e]-\tilde{A}[\tilde{A}+R_e]}{\tilde{A}\tilde{B}[\tilde{A}+R_e][\tilde{B}+R_e].}}\hfill \end{array}$$

In addition,

$$\tilde{B}-\tilde{A}=\sum _{i\in B/\left\{e\right\}}{R}_i-\sum _{i\in A/\left\{e\right\}}{R}_i=\sum _{i\in (B/A)/\left\{e\right\}}{R}_i\ge 0.$$

Since the function $f\left(x\right)=x(x+R_e)$ is monotonically increasing in $[0,+\infty )$, it follows that $\tilde{B}[\tilde{B}+R_e]-\tilde{A}[\tilde{A}+R_e]\ge 0$, and hence $\left[H\right(A\cup \left\{e\right\})-H(A\left)\right]-\left[H\right(B\cup \left\{e\right\})-H(B\left)\right]\ge 0$. This completes the proof. □

5. The Greedy Algorithm

Our greedy algorithm first computes the cached contents C according to the given user request probability for each content (Subproblem 1) and then performs recommendation among the contents in C (Subproblem 2).

5.1. Computing Cached Contents

We first calculate the original request probability $P_i^u$ for user u to content i, then take $p_i={\sum }_{u=1,2,\dots ,m}{P}_i^u$ as the value of content i and determine the cache set C by the dynamic programming Algorithm 1. We use $dp\left[i\right]\left[j\right]$ to denote the maximum value that can be loaded when only the first i contents are considered and the server capacity is j, denote by $selected\left[i\right]\left[j\right]$ whether the $(i-1)$th content is selected or not when the first i contents are considered and the server capacity is j. The algorithm iterates through each content and each capacity to determine whether the current content is selected. If the current content capacity is greater than the remaining capacity, the content is selected. Otherwise, it is not selected. Finally, based on the selection record table, iterating from back to front, it determines which content is selected and updates the remaining server capacity j. Eventually, the element labeled 1 in the result will be added to the cache collection C.

Algorithm 1 Dynamic Planning Cache Algorithm

1: Initialize the value table p by $p_i={\sum }_{u=1,2,\dots ,m}{P}_i^u$. 2: Initialize all elements in the maximum value matrix $dp$ and selection matrix $selected$ of $(n+1)\times (c+1)$ to zero. 3: for i from 1 to n do 4:     for j from 1 to c do 5:         if $w[i-1]>j$ then 6:             $dp\left[i\right]\left[j\right]=dp[i-1]\left[j\right]$ 7:         else 8:             if $dp[i-1]\left[j\right]<dp[i-1][j-w[i-1\left]\right]+p[i-1]$ then 9:                 $dp\left[i\right]\left[j\right]=dp[i-1][j-w[i-1\left]\right]+p[i-1]$ 10:                $selected\left[i\right]\left[j\right]=1$ 11:            else 12:                $dp\left[i\right]\left[j\right]=dp[i-1]\left[j\right]$; 13:            end if 14:        end if 15:    end for 16: end for 17: Initialize the array $result$ to 0 and $j=c$. 18: for i from n to 1 do 19:     if $selected\left[i\right]\left[j\right]=1$ then 20:         $result[i-1]=1$ 21:         $j=j-w[i-1]$ 22:     end if 23: end for 24: return result

5.2. Recommendation from Cached Contents

Once the cache set C has been determined, the set of recommendations A is initialized to be empty for each user. The cached contents are sorted by raw probability to find the smallest (probability) content that does not violate the warping degree constraint. All larger contents in C form a feasible set M from which it is guaranteed that any recommended k elements will not violate the warping constraint. The recommendation score $R_e$ for content e has two constraints: the first is that the recommendation score must not exceed $1+\gamma$ times the original frequency, i.e., $R_e\le (1+\gamma )F_e$, and the second is the constraint that the corrected frequency ${\widehat{P}}_i^u$ must not exceed $1+\alpha$ times the original, i.e., ${\widehat{P}}_e\le (1+\alpha )P_e$. Based on the second constraint, it is easy to obtain $R_e\le {\displaystyle \frac{(1+\alpha )F_e{\sum }_{i=1,2,\dots ,n}(F_i+R_i)}{{\sum }_{i=1,2,\dots ,n}{F}_i-(1+\alpha )F_e}}-F_e$. It is easy to see that the greater the total request probability of the elements in the cache, the greater the cache hit rate. Since all the elements of the feasible set M are in the cache, the larger the recommendation score of the cached elements, the larger the cache hit rate without violating the constraints. Therefore, for an element e in M, let $R_e$ be the maximum value that satisfies both constraints. Iterate over all elements e in M and their recommendation scores $R_e$ to find the element $\dot{e}$ and its recommendation score $R_{\dot{e}}$ that maximizes the hit rate, and update $A=A\cup \left\{\dot{e}\right\}$ and $M=M/\left\{\dot{e}\right\}$. Repeat to find the best element $\dot{e}$ and add it to the recommendation set A until k contents are found or M is empty. At this point, the recommendation set A for this user has been determined, and the above operation is repeated to determine the recommendation set A for all users.

5.3. Analysis

5.3.1. Approximation Ratio

Because Algorithm 1 solves Subproblem 1 optimally by the nature of dynamic programming and by Nemhauser et al. [29], the greedy solution to Subproblem 2 of maximization of a monotone submodular function has an approximation ratio of $1-{\displaystyle \frac{1}{e}}$, our greedy solution Algorithm 2 solves the joint optimization problem of cached recommendation with a worst-case approximation ratio of $1-{\displaystyle \frac{1}{e}}$ from the optimal solution.

In fact, we can simply explain why monotonic submodular functions have an approximation ratio of $1-{\displaystyle \frac{1}{e}}$. Let the optimal solution be O, $\left|O\right|\le k$, and let $S_k$ be the solution of the kth step of the greedy algorithm. In the ith step of the greedy algorithm, its marginal benefit is

$${\mathsf{\Delta }}_i=f(S_{i-1}\cup \left\{e_i\right\})-f\left(S_{i-1}\right)$$

(7)

The greedy algorithm ensures that the selected element in this step is greater than the marginal benefit of all elements, that is, for any element o, it satisfies

$${\mathsf{\Delta }}_i\ge f(S_{i-1}\cup \left\{o\right\})-f\left(S_{i-1}\right)$$

(8)

Therefore, $|O\setminus S_{i-1}|{\mathsf{\Delta }}_i$ should be greater than the sum of the marginal benefits of all $o\in O\setminus S_{i-1}$. In addition, due to the submodularity of the function, the sum of the marginal benefits of all $o\in O\setminus S_{i-1}$ should be greater than the marginal benefit of adding all elements from $O\setminus S_{i-1}$ to $S_{i-1}$ at once. In summary,

$$\begin{array}{cc}\hfill |O\setminus S_{i-1}|{\mathsf{\Delta }}_i& \ge \sum _{o\in O\setminus S_{i-1}}[f(S_{i-1}\cup \left\{o\right\})-f\left(S_{i-1}\right)]\hfill \\ \hfill & \ge f(S_{i-1}\cup O)-f\left(S_{i-1}\right)\hfill \\ \hfill & \ge f\left(O\right)-f\left(S_{i-1}\right)\hfill \end{array}$$

(9)

The last inequality here holds because the function increments. Due to $|O\setminus S_{i-1}|\le k$, the above equation is organized to obtain

$${\mathsf{\Delta }}_i\ge {\displaystyle \frac{f\left(O\right)-f\left(S_{i-1}\right)}{k}}$$

(10)

Noticing

$$f\left(S_i\right)=f\left(S_{i-1}\right)+{\mathsf{\Delta }}_i\ge f\left(S_{i-1}\right)+{\displaystyle \frac{f\left(O\right)-f\left(S_{i-1}\right)}{k}},$$

(11)

we can obtain

$$f\left(O\right)-f\left(S_i\right)\le (1-1/k)(f\left(O\right)-f\left(S_{i-1}\right)).$$

(12)

Since

$$f\left(S_0\right)=f(\varnothing )\ge 0,$$

we have

$$\begin{array}{cc}\hfill f\left(O\right)-f\left(S_1\right)& \le (1-1/k)f\left(O\right)\hfill \\ \hfill f\left(O\right)-f\left(S_2\right)& \le {(1-1/k)}^{2}f\left(O\right)\hfill \\ \hfill & ⋮\hfill \\ \hfill f\left(O\right)-f\left(S_k\right)& \le {(1-1/k)}^{k}f\left(O\right)\hfill \end{array}$$

(13)

For all $k\ge 1$, ${(1-1/k)}^k\le 1/e$. So $f\left(S_k\right)\ge (1-{\displaystyle \frac{1}{e}})f\left(O\right)$.

Algorithm 2 Recommendation from Cached Contents

1: Calculate $P_i^u={\displaystyle \frac{F_i^u}{{\sum }_{i=1,2,\dots ,n}{F}_i^u}}$ for $u=1,\dots ,m$ 2: Calculate all $valu{e}_i={\sum }_{u=1,2,\dots ,m}{P}_i^u$ 3: Call Algorithm 1 to obtain the cache set C 4: for Each user u do 5:     Initializing the Recommendation Collection $A_u=\varnothing$ 6:     Sort all cached contents by raw probability $P_i^u$ 7:     Find the k contents $K_{best}$ with the largest probability and initialize $K=K_{best}$ 8:     Calculate $D{\left(k\right)}_u=1-{\displaystyle \frac{{\sum }_{e\in X}{P}_e}{{\sum }_{e\in Y}{P}_e}}$ 9:     while $D{\left(k\right)}_u\le d_u$ do 10:       Add next content $K=K\cup e_{next}$ 11:       Remove the content with the highest probability $K=K/e_{max}$ 12:       Recalculate the warping degree $D{\left(k\right)}_u$ 13:    end while 14:    Pick up the element $e_{min}$ in K that has the smallest probability 15:    Set M to be all contents in C whose probabilities are greater than $e_{min}$ 16:    while $|A_u|\le k$$M\ne \varnothing$ do 17:        Pick up a random element $\dot{e}$ in M and initialize $R_{\dot{e}}$ 18:        for Each content e in M do 19:            $R_e=min((1+\gamma )F_e,{\displaystyle \frac{(1+\alpha )F_e{\sum }_{i=1,2,\dots ,n}(F_i+R_i)}{{\sum }_{i=1,2,\dots ,n}{F}_i-(1+\alpha )F_e}}-F_e)$ 20:            if $R_{\dot{e}}<R_e$ then 21:                $\dot{e}=e,R_{\dot{e}}=R_e$ 22:           end if 23:        end for 24:        $A_u=A_u\cup \dot{e},M=M/\dot{e}$ 25:    end while 26: end for

5.3.2. Time Complexity

For Algorithm 1, the time complexity of the first part of the content value is $O\left(nm\right)$, and the second part of solving for the $result$ is $O\left(nc\right)$, totaling $O\left(n\right(m+c\left)\right)$, where $c=\left|C\right|$.

For Algorithm 2, lines 1–3 take $O\left(n\right(m+c\left)\right)$ time. The loop in line 4 iterates a total of m times. Sorting contents by probability requires $O(nlogn)$ time complexity. The loop at line 9 requires n iterations in the worst case, and recalculating $D{\left(k\right)}_u$ once requires $k=\left|K\right|$ computations; thus, obtaining the set K requires $nk$ computations. Since $\left|M\right|=n$ in the worst case, the loop at line 16 iterates at most $min(k,n)$ times. Since it takes n computations to compute $R_e$ once, the loop at line 18 requires $n^2$ computations, so the loop at line 16 requires $min(k{n}^2,n^3)$ computations. Thus, the time complexity inside the loop at line 4 is $O(n+nlogn+nk+min(k{n}^2,n^3))$. Thus the time complexity of the whole Algorithm 2 is $O\left(n(m+c)\right)+m\times O(n+nlogn+nk+min(k{n}^2,n^3))=O(mn(logn+k+min(kn,n^2))+nc)$.

Therefore, we have the following:

Theorem 2.

The problem of joint optimization of caching and recommendation can be solved with worst-case performance guarantee of $1-{\displaystyle \frac{1}{e}}$ in polynomial time when recommendation is done from the cached contents.

6. Simulation Experiments

We use simulation experiments to validate our algorithm, in which the frequency of each user for each content is randomly generated to satisfy the sum of the frequency of each user for all contents is 1000, and the size of each content is similarly randomly generated to ensure that the sum of the size of each content is 1000 with a minimum of one.

The benchmark algorithm that serves as a reference for our algorithm is the Least Frequently Used (LFU) caching algorithm. This algorithm caches the items that attract the maximum total demand among all users, but it does not recommend any content. LFU is able to maximize the cache hit rate in the absence of recommendations.

In Figure 2, $n=100$, $m=50$, all $d_j=0.3$, all $\gamma =0$, and all $\alpha =0.2$. The figure contains the LFU algorithm and the variation of the hit rate with capacity for $k=1,10$, and 40. First, the cache hit rate increases with capacity for both the LFU algorithm and our algorithm for different values of k. The hit rate increases with capacity. The upper limit is reached when the capacity is close to the sum of the contents, when it can approach 100% hits. However, this means that virtually all content is cached, but we know that it is impractical and pointless to go to the server and cache all content. Secondly, no matter what the value of k is, our algorithm will always hit above the LFU algorithm, and the higher the value of k, the higher the hit rate. This can be interpreted as an expansion of the optional space of our recommended content, which gives our algorithm more room to play. Finally, we observe that the larger the server cache capacity, the smaller the gap between the gains of different algorithms. On the contrary, when the cache capacity is small, the difference between LFU and our algorithm is huge, which reflects the advantages of our algorithm even more.

Figure 3 and Figure 4 with $n=100$, $m=50$, $c=300$, $k=20$ and all $d_j=0.3$. Figure 3 illustrates that the incremental hit rate of our algorithm compared with the LFU algorithm varies with $\gamma$ and $\alpha$ and that the incremental hit rate mainly reflects the role of the recommendation algorithm. When $\alpha$ is constant and $\gamma$ increases, the hit rate increment increases at this time, which indicates that the larger the gamma is, the more space the recommendation algorithm has to choose from, which brings more hit rate increment. On the other hand, as $\gamma$ increases, the hit rate increment decreases. This indicates that the effect of $\gamma$ on the hit rate increase is gradually decaying and also indicates that the problem is submodular. In fact, as $\gamma$ increases, the main factor limiting the increase in hit rate becomes $\alpha$. When $\gamma$ is constant, the change in $\alpha$ is observed to be similar to that is $\gamma$. This indicates that $\alpha$ and $\gamma$ together determine the incremental hit rate. Theoretically, $\alpha$ and $\gamma$ should be set as large as possible to ensure larger hit increments. However, $\gamma$ and $\alpha$ actually limit the magnitude of distortion of the recommender system with respect to the user’s original preferences. When both $\gamma$ and $\alpha$ are large, the limits are weakened, and the recommender system’s distortion of user preferences can be large. We use Jensen–Shannon Divergence (JSD) to measure the degree of distortion of user preferences, where JSD is actually the difference in the distribution of the probability of a user’s content request after the action of the recommender system, i.e., $D_{JS}={\displaystyle \frac{1}{2}}[D_{KL}(P|\left|M\right)+D_{KL}(\widehat{P}\left|\right|M\left)\right]$, where $M=P+\widehat{P}$ and $D_{KL}\left(P\right|\left|Q\right)={\displaystyle \frac{1}{n}}{\sum }_{i=1}^{n}log[P_i/Q_i]$. Figure 4 illustrates the variation of JSD with $\gamma$ and $\alpha$.

In addition, when $\gamma$ and $\alpha$ tend to infinity, the hit rate will approach the full hit rate, but the difference in probability distributions will become huge, no matter how small the cache size is, as long as one or more contents can be stored. In fact, with $n=100$, $m=50$, $c=50$, $k=20$, all $d_j=0.3$, and $\gamma =\alpha =30$, the LFU only achieves a hit rate of 17.929. After executing the algorithm in this paper, the hit rate can reach 45.317372, which is 90.63% of the limit full hit rate compared with the ideal full hit rate of 50 but at this time, the JSD is as high as 0.212237. That is to say, the hit rate is extremely high but the distortion of the user’s preference is extremely large. The reason for this situation is that when $\gamma$ and $\alpha$ tend to infinity, the constraints on the recommendation score have actually failed. At this point, the algorithm in this paper will score the recommendation of some cached content as infinity, and then the recommendation score will completely sway the user’s request, allowing the user to access only the cached content. This will result in a very poor user experience, because what the user can request is entirely up to the system.

The experimentally relevant parameters for Figure 5 and Figure 6 are $n=100$, $m=50$, $c=100$, $k=20$, $\gamma =0$, and $\alpha =0.2$. Figure 5 and Figure 6 show how the hit rate and JSD vary with the upper limit of distortion $d_j$, respectively. It can be seen that the hit rate does not always increase as $d_j$ increases. But JSD increases all the time with $d_j$. In fact, even if $d_j$ tends to be close to the upper limit of 1, its hit rate will not be close to the full hit rate of 50 but up to 24.251540, while the JSD is as high as 0.001888. This shows that the upper limit of the degree of distortion can only determine the degree of “honesty” of the recommender system and cannot determine the degree of distortion of the system for the user’s preferences. This shows that the upper limit of distortion can only determine the degree of “honesty” of the recommender system but cannot directly determine the degree of distortion of the system to the user’s preferences.

Figure 7 shows the relationship between cache hit rate and the number of caches n under different server capacities and different user preference distributions, with the following parameters: $m=50$, $k=20$, $\gamma =0$, $\alpha =0.2$, and $d_j=0.3$. Here, the “zipf” suffix indicates that the data are experimental data whose user preferences conform to the zipf distribution; otherwise, the frequency of user preferences is completely random, i.e., conforms to the uniform distribution. We use the zipf distribution, i.e., content ranked x, with user preference probability $P\left(x\right)={\displaystyle \frac{1}{x{\sum }_{i=1}^{n}P\left(i\right)}}$. The results show that in either case, the hit rate always decreases as the number of contents n increases, which can be explained by the fact that as the contents increase, there is a greater variation in preferences among users, making it more difficult to find contents that satisfy the majority of users who match. At the same time, the hit rate under the zipf distribution is always much higher than that under the uniform distribution. For example, with $n=200$ and $c=300$, the hit rate under the zipf distribution is 45.572, while the hit rate under the uniform distribution is 37.471, which is 21.62% higher for zipf. And this difference further expands as the number of contents n increases; when $n=900$ and $c=300$, the two hit rates are 42.65 and 20.97, respectively, the former being 103.39% higher than the latter. This is due to the fact that under the uniform distribution, the hit rate decreases rapidly with the increase in the number of contents n, whereas it does not under the zipf distribution. In fact, this is due to the fact that under the uniform distribution, all user preferences are completely randomized, and the more content there is, the harder it is to find common preferences. Under the zipf distribution, on the other hand, the higher the ranking, the higher the probability that the content is preferred by the user, and the user’s preferences tend to be similar, so that an increase in the number of contents has less impact on finding the public preference content.

The relationship between cache hit rate and JSD and the number of recommended content k is shown in Figure 8 and Figure 9 for different $\alpha$ and $\gamma$, respectively. Its experiment-related parameters are $n=200$, $m=50$, $c=200$, and $d_j=0.3$. Figure 8 suggests that the hit rate increases with k but no longer increases when it reaches a certain magnitude, which is shown in the figure around $k=100$. The effect of the number of recommended contents on the increase in hit rate is not significant. It can be observed that for $\alpha =0.1$ and $\gamma =0.5$, there is almost no improvement. However, when $\alpha =10$ and $\gamma =10$, the number of recommended content k is able to bring a large improvement. The fundamental reason for this is that smaller $\alpha$ and $\gamma$ limit the distortion of user preferences by the recommender system, and the recommender system is less useful. Therefore, in order to ensure the effectiveness of improving the number of recommendations k, both $\alpha$ and $\gamma$ should be improved. On the other hand, when $\alpha$ and $\gamma$ are small, the growth trend of JSD is the same as the growth trend of hit rate, and both increase with k until convergence. Notice that when $\alpha =10$ and $\gamma =10$, the JSD shows a trend of increasing and then decreasing. This indicates that in the first half of the curve, where the hit rate increases rapidly with increasing k, the recommender system is limited by the number of recommendations k, and the increase of k liberates the recommender system’s recommending ability and brings about a rapid increase in the hit rate and JSD. In the second half of the curve, where the hit rate stabilizes as k increases, an increase in the number of recommendations k does not lead to an increase in the hit rate but reduces the distortion of user preferences. In effect, because more content can be recommended, the recommender system does not have to overly distort certain users’ preferences for certain content, which brings about a decrease in JSD.

In summary, we experimentally verified that our algorithm is greatly improved over the LFU algorithm and that the hit rate will increase as the optional recommendation set of the algorithm increases with an increase in the cache size c or k value. We observe that an increase in the number of contents, n, makes it harder to find users’ public preferences and thus reduces the hit rate, which is more serious in the case of a uniform distribution with completely randomized user preferences. In addition, the parameters $\gamma$ and $\alpha$ can directly determine the degree of distortion of the recommender system with respect to the user’s preferences, which together determine the constraints on the recommendation score; the larger the value, the larger the hit rate of the algorithm, but the larger the distortion value of the user’s preferences. On the other hand, if the parameters $\gamma$ and $\alpha$ are large enough, increasing the number of recommendations k can simultaneously improve the hit rate and reduce the distortion of user preferences. To ensure the user experience, setting too large $\gamma$ and $\alpha$ should be restricted. Finally, the experiment proves that the upper limit of distortion can only determine the degree of “honesty” of the recommender system but cannot directly determine the degree of distortion of the system to the user’s preference. However, in order to ensure the “honesty” of the recommendation system, the upper limit of distortion should not be set too large.

7. Conclusion and Future Work

In this paper, we address the problem of joint optimization of caching and recommendation for content delivery in IoT, which is NP-hard even even for only one user and without considering recommendation. We consider the case where a recommendation is made among the cached contents, which is more general than assuming a recommendation is made only in accordance with users’ preferences, as in the existing work. We solve this problem by splitting it into two subproblems: first, caching to maximize the total cache hit rate determined by user requests to all contents without considering recommendation, and then performing recommendation from the cached contents. We show that Subproblem 1 can be solved optimally by dynamic programming and Subproblem 2 possesses the submodular property, implying the existence of a solution with a performance guarantee of a worst-case approximation ratio to the optimal solution. Taking advantage of the properties of these two subproblems, we present a greedy algorithm to solve the problem of joint optimizationof cached recommendations that has a provable performance guarantee of $1-{\displaystyle \frac{1}{e}}$. We experimentally validate the performance of our algorithm and demonstrate its hit rate improvement by simulation experiments and comparison with the most popular LFU algorithm. At the same time, we also show the variation patterns of hit rate measured by Jensen–Shannon Divergence on different parameter settings of cache capacity, $\gamma$, $\alpha$, and distortion limit $d_j$. The results show that $\gamma$, $\alpha$, and $d_j$ should be set appropriately to tradeoff the cache hit rate and user-preferred distortion.

When recommendations are only made from cached content, it can reduce the frequency of obtaining content from the central server, thereby alleviating network bandwidth pressure. In environments where IoT device resources are limited, this assumption reduces network bandwidth pressure and has practical significance. In addition, we can cache the content that users may like in advance based on their browsing history. At this time, the cached content is closer to the user’s actual preferences, and recommendations from the cached content will not deviate too far from the user’s actual preferences.

In addition, we use staged optimization with caching and recommendation, and we set caching based on the user’s initial request preferences. However, recommendations change the probability distribution of user requests, and our cache optimization depends on the probability distribution of user requests, which may result in a cache that is not currently optimal after recommendations. If the cache optimization is redone, it will again lead to changes in the recommendation optimization. In practice, recommendation and caching need to be optimized alternately to obtain the best hit rate, and the caching and recommendation phases interact with each other, leading to the problem becoming an online, combinatorial optimization problem that needs to evolve over time, where each optimizationmust adapt to changing inputs caused by previous actions. The research of Robinson Duque et al. [30] provides a class of dynamic combinatorial problems that accurately solve this kind of framework. In future work, we will combine their framework to optimize a two-stage greedy caching and recommendation optimization scheme into an online recurrent caching-recommendation alternation optimization scheme to enhance the robustness and applicability of our approach in dynamic environments of real-world applications.