Diffusion Model as a Base for Cold Item Recommendation

Abstract

Cold items are a critical problem in the recommendation domain because newly introduced items lack user–item interactions to train accurate collaborative filters (CFs). Recent studies have adopted neural networks such as MLPs and autoencoders to predict collaborative embeddings learned by CFs, using items’ side information available at the time of registration. As a generative model, diffusion models have achieved success in various fields, such as image generation and natural language processing, through their superior generative capability. This paper proposes a diffusion model as a base for cold item recommendation by generating collaborative embeddings for cold items. First, using a diffusion model with our customized predictor, we directly generate items’ collaborative embeddings conditioned on their side information. Then, a second-stage refiner, which adopts simple MLPs and dropout, is trained to calculate the final recommendation scores. The proposed method requires only the user embeddings from the existing model and the side information of cold items, making it easy to integrate into existing recommender systems. Extensive experiments on real-world datasets show that the proposed method outperforms state-of-the-art baseline methods and indicates the potential of diffusion models in cold item recommendation.

1. Introduction

Collaborative filtering (CF) [1], a widely used approach for personalized recommendation, suffers from the cold item problem when newly introduced items are added to recommender systems [2,3,4]. “Cold items” refer to items that lack sufficient user interactions. Because CF methods rely on user–item interaction data to make accurate recommendations, their performance significantly degrades when recommending cold items. Extensive studies have been conducted on the cold item problem, as it is essential for ensuring users can discover relevant and diverse content in a timely manner, while also helping item providers gain early exposure for newly introduced items. One group of studies [5,6,7,8,9,10,11,12] studied the methods for fast warm-up, which achieves accurate recommendations using as little interaction data as possible. Another group [13,14,15,16,17,18,19,20,21,22] is interested in improving start-time recommendation accuracy when no interaction data are available.

To improve the start-time accuracy of cold item recommendation, content-based filters [23] that exploit the similarity of side information between candidate items and the items interacted with by a target user were studied in the early era of personalized recommendation. Side information refers to metadata that describe items—such as tags, texts, or images—typically provided by item creators or sellers. It offers auxiliary signals that are strongly correlated with the latent properties of the items. Therefore, it plays a pivotal role in user interactions because it is often the first and only information that users encounter before deciding interactions with items. As a result, items with similar side information tend to elicit similar interaction patterns from users. Furthermore, side information is readily available at the time of item registration, as item providers are generally motivated to include detailed descriptions to attract user attention. Therefore, in the absence of historical interaction data, side information becomes the most critical factor for inferring the interaction patterns of new items. Although the traditional content-based filters mitigated the problem to some extent, there is still room for improvement.

In the last decade, several theoretical foundations and methods that can be applicable to cold item recommendations, such as compressed sensing [24] and pairwise comparisons [25], have been proposed. Among them, methods using neural networks have been studied the most. The studies in [13,14,15,16,17,18,19,20,21,22] tried to “generate” items’ collaborative embeddings, which are originally learned by CFs from items’ side information. These works explored various effective network architectures to achieve their goal. Specifically, these include convolutional neural networks [17] and autoencoders [13,14,15,16], and parameter sharing between user and item predictors [18], techniques to prevent overfitting [19,20], and the design of effective objective functions [20,21,22] are also investigated.

The diffusion model (DM) [26,27] is a powerful generative model which has shown prominent results in various domains [28,29,30,31,32]. Unlike traditional generative models like GANs and VAEs, which face stability and representation limitations, diffusion models employ a forward-noising and reverse-denoising process, aligning well with the nature of recommendation tasks where user interactions often contain noise and require reconstruction. Because of their superior generative power and denoising performance, researchers have started investigating effective ways to apply DMs in recommender systems. For instance, DMs were adopted to recommend items from the user’s interaction vector [33,34,35,36,37], denoising the collaborative embeddings learned by base recommender models [38,39], and incorporating multi-modal knowledge [40] to improve general recommendation performance. DMs are also applied to augment data for the next-item [41,42,43] and cross-domain recommendation settings [44].

DMs are inherently well suited for improving the start-time accuracy of cold items, as they control the generation process based on given conditions. By conditioning on side information, DMs can generate more “natural” collaborative embeddings for cold items. However, only a few studies [44,45] have applied DMs to cold item recommendation, and these are not directly focused on improving start-time recommendation accuracy. Further investigation is needed to explore how DMs can be effectively applied in this domain. To this end, we propose a method that adopts a DM as the foundation for cold item recommendation, leveraging its generative capability without modifying existing CF-based recommender systems.

Our proposed method consists of two modules. In the first module, we use a DM [46] to directly generate items’ collaborative embeddings, conditioned on their side information. To more accurately generate collaborative embeddings of cold items, we adopt guidance information calculated from a mixture-of-expert architecture in the predictor of the DM. Then, the generated item collaborative embeddings, along with the user embeddings calculated by the base recommender, are passed to the second module, which refines the embeddings to enable more accurate recommendations. We train the second module using the same interaction data from the training set that was used to train the base recommender.

Our contributions are three-fold:

• To the best of our knowledge, our work is the first to evaluate the potential of DMs in improving the start-time recommendation accuracy of cold item recommendations.
• We propose a simple add-on method that is easy to implement compared to more complex models, and easily applicable to existing base recommender systems without modifications.
• Through extensive evaluations on real-world datasets, we demonstrated that the proposed method outperforms state-of-the-art approaches. In addition, a hyperparameter sensitivity analysis and an ablation study show how DM hyperparameters affect recommendation performance and highlight the relationship between the DM module and the refinement module. We believe these findings offer valuable insights for future research.

The rest of this paper consists of five sections. Section 2 provides a comprehensive overview of existing research relevant to this study, and contrasts the differences between prior work and the proposed method. Section 3 describes the proposed method in detail, outlining the underlying concepts and explain details for implementation. Section 4 gives the evaluation details including the dataset, evaluation metrics, and comparison methods. The evaluation and analysis of the proposed method, along with a discussion of the results, are presented in Section 5. Finally, Section 6 concludes the paper by summarizing the key findings and suggesting directions for future work.

2. Related Work

This section reviews the studies related to the proposed method. Since the proposed method adopts a DM for cold item recommendation, we first review works adopting general neural network architectures for cold item recommendation. We then discuss works adopting DMs to recommender systems.

2.1. Cold Item Recommendation

Studies on cold-start recommendation (for both users and items) can be broadly classified into two categories. The first group of studies [5,6,7,8,9,10,11,12] focuses on fast warm-up, which aims to achieve accurate recommendations using minimal interaction data. To achieve their goal, they adopted meta-learning [5,6]. Some studied the fast warm-up of cold users by training per-user recommenders [7], adopting memory structures [8], or using task-adaptive mechanisms [9] to effectively re-use information for fast adaptation. Other studies [10,11,12,47] studied cold item warm-up. Pan et al. [10] learned item embeddings that encode the interaction characteristics of items by meta-learning. Lu et al. [11] adopted a Heterogeneous Information Network (HIN) [48,49] to improve the performance of meta-learning. Zhu et al. [12] updated collaborative embeddings of cold items using meta-scaling and meta-shift. Pan et al. [47] trained multiple meta-learners to exploit different types of item contents, such as review text and images, to improve the next-item recommendation performance.

Another group of studies tried to increase the start-time recommendation accuracy of cold items by using side information. Since the cold item problem arises from a lack of interaction data, knowledge propagation on graphs can be one of the solutions to augment deficient user–item interaction data. Wang et al. [50] improved cold item recommendation performance in cross-domain settings by transferring knowledge from a source domain graph with sufficient interactions and side information to a target domain graph that contains only side information. Togashi et al. [51] generated pseudo-user–item interactions based on the strength of semantic relations calculated with a knowledge graph.

As another approach, methods that tried to predict collaborative embeddings of cold items based on their side information were studied. Various neural network architectures suitable for collaborative embedding predictors were investigated to achieve accurate prediction. For music recommendation, Galvan et al. [13] integrated the gravity model into an attribute graph connecting similar artists and side musical information for graph autoencoder to suggest cold artists to users, and Oramas et al. [17] evaluated a CNN architecture for music embedding generation from side information such as track and artist information. Zhao et al. [15] trained two variational autoencoders [52], the first encoder to encode the item collaborative embeddings and the second encoder to generate the collaborative embeddings encoded by the first encoder based on the side information of cold items. Hansen et al. [16] used an autoencoder to predict collaborative embeddings, represented as binary hash codes, from the side information of cold items. Raziperchikolaei et al. [18] reduced model training time by sharing the parameters of the first layer between the item and user collaborative embedding predictors.

In addition to the effective network structure, other factors, such additional information and training techniques, are also investigated. Ouyang et al. [53] suggested a side information adaptation using the side information of the content neighbors of cold items. Volkovs et al. [19] proposed an effective training method for collaborative embedding predictors by adopting a dropout technique. Zhu et al. [20] showed that directly reducing the error of collaborative embedding predictor by explicitly defining the error in the objective function can improve cold item recommendation performance. Wei et al. [21] and Zhou et al. [22] adopted contrastive learning [54] techniques to train more accurate cold item recommender models.

2.2. Recommendation with Diffusion Models

Recent advancements in DMs have demonstrated significant potential in improving recommender systems by addressing issues such as data sparsity, noisy interactions, and user preference modeling.

As one of the pioneering works in this area, DMs have been effectively used to generate robust user–item interaction representations. Choi et al. [37] introduced a perturbation recovery paradigm to model user–item interactions, similar to score-based generative models but applied to collaborative filtering. Wang et al.’s work [33] extended traditional DMs to tackle high resource costs in large-scale item prediction and temporal shifts in user preferences. It introduced latent-space clustering and temporal weighting to enhance recommendation performance. Similarly, the Denoising Diffusion Recommender Model [27] applied DMs to denoise user and item collaborative embeddings, improving robustness against implicit feedback noise.

Graph-based approaches leveraged DMs to enhance collaborative filtering. Zhu et al.’s work [34] applied heat equation-based smoothing on an item–item similarity graph to refine user preferences. Hou et al. [35] integrated multi-hop cross-attention autoencoders to capture high-order collaborative signals, significantly improving user–item interaction modeling.

DMs were also applied to the sequential recommendation. Niu et al. [43] combined multi-scale CNNs and residual LSTMs to extract local and global user behavior patterns. They effectively improved short-term and long-term sequence modeling by conditioning the diffusion process on user interaction sequences, significantly enhancing sequential recommendation accuracy. Ma et al. [41] employed a time-interval DM to infer users’ preferences across all items, addressing the data sparsity issue. Similarly, Yang et al. [42] reshaped sequential recommendation as a learning-to-generate problem using guided diffusion, removing the reliance on negative sampling.

In multi-modal recommendation, Ma et al. [39] and Jiang et al. [40] integrated diffusion models to align multi-modal content features (e.g., text, image, and audio) with user–item interactions, leading to improved recommendation accuracy.

For the cold start problem, Wang et al. [44] integrated a variance-scheduled diffusion process with a classifier to enhance cold start multi-scenario recommendations. To improve recommendation accuracy, they effectively learned domain-specific and shared representations to balance knowledge transfer between cold start and rich data domains. However, no notable works have been published in the cold item recommendation domain that seek to improve start-time cold item recommendations.

3. Cold Item Recommender with a Diffusion Model Base

In this section, we first define the problem to be solved, then introduce the diffusion model as a preliminary model, and finally present our proposed method.

Table 1. Notations.

Notation	Explanation
u, i	A user, an item
U, I, $I_w$, $I_c$	The set of users, items, warm items, cold items
$e_u$, $e_i$	The ground-truth collaborative embeddings of u, and i
$c_i$	Side information embedding of i
$t{e}_t$	Time step embedding of timestep t
$R^{tr}$, $R^{te}$	training and test data
$L_u^k$	Top-k cold item recommendation list for u
$x_0$	The original dataset of DM. It indicates $e_i$ in this paper
$d_{cond}$, $d_{cf}$	The dimension of side information ($c_i$), collaborative embeddings ($e_u,e_i$)
$d_{time}$	The dimension of time step embedding ($t{e}_t$)
$r_{ui}$	The interaction indicator between user u and item i
${\widehat{r}}_{ui}$	The predicted interaction indicator between u and i
E	The set of experts in Mixture-of-Experts architecture

represents the notations frequently used throughout this paper.

3.1. Cold Item Recommendation

The cold item recommendation problem that we are trying to solve is defined as follows. Users in a user set U and items in an item set I make interactions such as clicks and ratings. Items in I are classified into one of the two mutually non-intersected subsets: warm item set $I_w$ and cold item set $I_c$. Regardless of their subset, each item i has its side information embedding $c_i$. The interactions are represented as two rating matrices, $R^{tr}\in {\mathbb{R}}^{\left|U\right|\times |I_w|}$ and $R^{te}\in {\mathbb{R}}^{\left|U\right|\times |I_c|}$, whose elements indicate interactions between users and warm items and between users and cold items, respectively. Each user $u\in U$ and warm item $i\in I_w$ has its own collaborative embedding $e_u$ and $e_i$, which is calculated by a base CF method by using $R^{tr}$ as the training data.

Our goal is, for a given $u\in U$ and cold item set $I_c$, to calculate an ordered list of k cold items $L_u^k$ that maximizes the prediction accuracy about u’s interaction in $R^{te}$. To calculate $L_u^k$, we can only use $e_u$, and $c_i$ of cold items as input. In the training, we exploit the information from $e_u$ and $e_i$, collaborative embeddings of users and warm items, $R^{tr}$, and $c_i$ of all items.

3.2. Preliminary: Diffusion Model

DM generates realistic data that satisfy a given condition (requirement, e.g., generate an image from its description represented by text embedding) from pure Gaussian noise. DM consists of a forward process that adds noise to the original data and a backward process that generates the original data from noise.

Forward Process: In the forward process, Gaussian noises are added T times to given original data $x_0$ to obtain a noised data sequence $x_1$, $x_2$, …, $x_T$. Noised data $x_t$ at timestep t are sampled from $x_{t-1}$ using Equation  (1).

$$q\left(x_t\right|x_{t-1})=\mathcal{N}(x_t;\sqrt{1-{\beta }_t}{x}_{t-1},{\beta }_t\mathrm{I})$$

(1)

where $\mathcal{N}$, I, and ${\beta }_t$ indicate Gaussian distribution, the identity matrix, and noise scale at timestep t, respectively. ${\beta }_t$ increases as timestep t increases. It can be learned from the data, but generally a predefined fixed scheduler is used such as the linear scheduler [27], or cosine scheduler [55], or sigmoid scheduler [56]. We adopted the linear scheduler represented in Equation (2), due to its empirical stability [33,38] and implementation simplicity.

$${\beta }_t={\beta }_s·(1-{\displaystyle \frac{t-1}{T-1}})+{\beta }_e·{\displaystyle \frac{t-1}{T-1}}$$

(2)

where ${\beta }_s$, ${\beta }_e$, and the maximum timestep T are hyperparameters. Following the proposal by Ho et al. [27], we set ${\beta }_s=0.0001$. The optimal values for ${\beta }_e$ and T will be evaluated in Section 5.

As shown in Equation (1), sampling $x_t$ depends on its previous $x_{t-1}$ only, and when Gaussian noises are applied, we can assume $x_t$ is sampled from $x_0$ by the single noise addition represented in Equations (3) and (4) [46].

$$q\left(x_t\right|x_0)=\mathcal{N}(x_t;\sqrt{{\overline{\alpha }}_t}{x}_0,1-{\overline{\alpha }}_t\mathrm{I})$$

(3)

$${\overline{\alpha }}_t={\Pi }_{i=1}^t{\alpha }_i,{\alpha }_t=1-{\beta }_t$$

(4)

Since ${\beta }_t$ increases as t increases, ${\alpha }_t$ and ${\overline{\alpha }}_t$ decrease. As a result, the information in $x_0$ decreases, but the noise increases as t increases. At the last time step T, $x_T$ converges to pure Gaussian noise.

Backward Process: The backward process of DM is a denoising process. From $x_T$, the fully noised data at the final timestep, the noise is removed step by step to recover $x_0$. The ground-truth denoising step, which is derived by using Bayes’ rule, is represented in Equations (5)–(7).

$$q\left(x_{t-1}\right|x_t,x_0)=\mathcal{N}(x_{t-1};{\mu }_q(x_t,x_0,t),{\sigma }_q^2\left(t\right)\mathrm{I})$$

(5)

$${\mu }_q(x_t,x_0,t)={\displaystyle \frac{\sqrt{{\alpha }_t}(1-{\overline{\alpha }}_{t-1})x_t+\sqrt{{\overline{\alpha }}_{t-1}}(1-{\alpha }_t)x_0}{1-{\overline{\alpha }}_t}}$$

(6)

$${\sigma }_q^2\left(t\right)={\displaystyle \frac{(1-{\overline{\alpha }}_{t-1})(1-{\alpha }_t)}{(1-{\overline{\alpha }}_t)}}$$

(7)

Unfortunately, we do not know the original data $x_0$ at the inference time. Therefore, instead of using $x_0$, we train and adopt a $x_0$-predictor which predicts $x_0$ from $x_t$ and t by using neural networks. In addition, because we want to control DM’s denoising (generation) direction, the predictor also takes the generation condition c as an input. As a result, $x_0$ in Equation (6) is replaced by $x_0$-predictor ${\widehat{x}}_{\theta }(x_t,t,c)$ and generates a new equation, Equation (8). The final denoising sample follows Equation (9).

$${\mu }_{\theta }(x_t,t,c)={\displaystyle \frac{\sqrt{{\alpha }_t}(1-{\overline{\alpha }}_{t-1})x_t+\sqrt{{\overline{\alpha }}_{t-1}}(1-{\alpha }_t){\widehat{x}}_{\theta }(x_t,t,c)}{1-{\overline{\alpha }}_t}}$$

(8)

$$p_{\theta }\left(x_{t-1}\right|x_t,c)=\mathcal{N}(x_{t-1};{\mu }_{\theta }(x_t,t,c),{\sigma }_q^2\left(t\right)\mathrm{I})$$

(9)

Training: DM training is equivalent to training ${\widehat{x}}_{\theta }(x_t,t,c)$. Because the goal of ${\widehat{x}}_{\theta }(x_t,t,c)$ is to predict $x_0$, the objective function is designed to minimize the prediction error. We follow Ho et al.’s proposal [27], Equation (10), which not only reduces computational cost but also assigns greater importance to predictions made from noisier inputs, i.e., the more challenging cases.

$$L_d={\mathbb{E}}_{t,x_0,c}\Vert x_0-{\widehat{x}}_{\theta }(x_t,t,c)\Vert$$

(10)

where $\Vert ·\Vert$ represents the vector norm.

Algorithm 1 shows the DM training details. For a given data point $x_0$ and its condition c, an arbitrary timestep t is uniformly sampled between 1 and T, and the gradient of the objective function is calculated for the predictor training.

Algorithm 1 DM Train

Input: Dataset X with assigned conditions to its elements, maximum timestep T Output: Trained model parameter $\theta$ 1: Initialize $\theta$ with random values 2: while $\theta$ is not converged do 3:     Randomly sample a batch $X^{\prime }\subset X$ 4:     for all $(x_0,c)\in X^{\prime }$ do 5:         Sample $t\sim U(1,T)$ 6:         Sample $x_t\sim q\left(x_t\right|x_0)$ (Equation (3)) 7:         Calculate loss $L_d$ using Equation (10) 8:         Update $\theta$ using gradient descent with ${\nabla }_{\theta }{L}_d$ 9:     end for 10: end while

Inference: Algorithm 2 shows DM’s inference procedure details. DM takes a given pure Gaussian noise and condition pair and performs denoising for each timestep to generate the data satisfying the condition. The reparameterization trick [57] is adopted for sampling.

Algorithm 2 DM Inference

Input: Condition c, maximum timestep T 1: $x_T\sim \mathcal{N}(0,\mathrm{I})$ 2: for  t←T to 1 do 3:     $ϵ\sim \mathcal{N}(0,\mathrm{I})$ 4:     if t == 1 then 5:         $ϵ=0$ 6:     end if 7:     $x_{t-1}={\mu }_{\theta }(x_t,t,c)+{\sigma }_q\left(t\right)ϵ$    (${\mu }_{\theta }(·)$: Equation (8), ${\sigma }_q\left(t\right)$: The square root of Equation (7)) 8: end for 9: return  $x_0$

3.2.1. Overview of the Proposed Method

We first describe the overview of the proposed method and then explain the details in the following subsections. Figure 1 shows the two-phase recommendation of the proposed method. In the first phase, the DM-based generator generates collaborative embeddings of cold items using their side information as input. Then, the generated collaborative embeddings of cold items and the collaborative embeddings of users calculated by the base recommender are fed into the refiner to calculate more accurate recommendations for each user. The generated embeddings contain some errors that originated from information deficiency. For instance, coarse-grained side information of the cold items is given as the generation condition, and valuable user-side information, the ground-truth collaborative embeddings of users, is not considered. We employed the refiner to correct the error in the generated collaborative embeddings by the DM-based generator.

We train the DM-based generator first and then train the refiner using the trained generator. Although we adopted the refiner, it is worth noting that we can directly use the collaborative embeddings of cold items generated by the DM-based generator to calculate recommendation scores just by applying dot products with user collaborative embeddings.

3.2.2. DM-Based Generator

The DM-based generator is a DM that generates collaborative embeddings $e_i$ of cold items from their side information $c_i$ as its generation condition. Therefore, in the training, we assigned $e_i$ and $c_i$ to the original data $x_0$ and c in Algorithm 1, respectively.

Network architecture: For the $x_0$-predictor ${\widehat{x}}_{\theta }(x_t,t,c_i)$ in Equation (8), instead of simple MLPs used in previous works [33,38], we added a guideline predictor consisting of a Mixture-of-Experts network (MoE) [58] to handle complex collaborative embedding distributions more effectively and adapt to diverse patterns with limited information on items’ side information. As shown in Figure 2, side information $c_i$ is given to the MoE to generate the first prediction of collaborative embedding ${\widehat{x}}_0^{\left(1\right)}$; then, with the inputs of DM, ${\widehat{x}}_0^{\left(1\right)}$ is fed into the MLP as additional information to predict $x_0$, the collaborative embedding of cold item $e_i$.

The MoE network consists of the gate network represented in Equation (11) and multiple experts $e\in E$ that have the same network structure described in Equation (12), but different parameters are learned from each other.

$$g=sigmoid(W_g\times c_i+b_g)$$

(11)

where $g\in {\mathbb{R}}^{\left|E\right|}$ indicates the gate vector whose elements represent the weights assigned to individual experts’ output. $W_g\in {\mathbb{R}}^{\left|E\right|\times d_{cond}}$, $b_g\in {\mathbb{R}}^{\left|E\right|}$, and $sigmoid$ indicate the gate network’s weight matrix, bias, and the sigmoid activation function, respectively.

$${\widehat{x}}_{0,e}=W_e\times c_i+b_e$$

(12)

where $W_e\in {\mathbb{R}}^{d_{cf}\times d_{cond}}$ and $b_e\in {\mathbb{R}}^{d_{cf}}$ represent the weight matrix and bias of individual expert e. We chose a single-layer linear transformation without an activation function as the expert network because our pre-experiments showed that the configuration mentioned above shows better performance than more complicated non-linear networks, which is also supported by other works [20,59].

The first prediction ${\widehat{x}}_0^{\left(1\right)}$ for $x_0$ is calculated by the weighted sum of the experts’ outputs, as represented in Equation (13).

$${\widehat{x}}_0^{\left(1\right)}=tanh({\Sigma }_{e=1}^{\left|E\right|}{g}_i·{\widehat{x}}_{0,e})$$

(13)

where $g_i$ and $tanh$ represent the value of the i-th element of g and the hyperbolic tangent activation function, respectively.

With ${\widehat{x}}_0^{\left(1\right)}$, $x_t$, $c_i$, and the time step embedding [60] $t{e}_t\in {\mathbb{R}}^{d_{time}}$, which is related to time step t, are concatenated and passed to the three-layer MLP to calculate the final prediction ${\widehat{x}}_0^{\left(2\right)}$ for $x_0$. The network structure of the MLP is represented in Equations (14)–(16).

$$ml{p}^{\left(1\right)}=swish(W_{mlp}^{\left(1\right)}\times (x_t\Vert {\widehat{x}}_0^{\left(1\right)}\Vert c_i\Vert t{e}_t)+b_{mlp}^{\left(1\right)})$$

(14)

where $W_{mlp}^{\left(1\right)}\in {\mathbb{R}}^{d_{cf}\times (2\times d_{cf}+d_{cond}+d_{time})}$ and $b_{mlp}^{\left(1\right)}\in {\mathbb{R}}^{d_{cf}}$ represent the weight matrix and bias of the first layer of the MLP. $swish$ indicates the swish activation function [61].

$$ml{p}^{\left(2\right)}=swish(W_{mlp}^{\left(2\right)}\times ml{p}^{\left(1\right)}+b_{mlp}^{\left(2\right)})$$

(15)

$${\widehat{x}}_0^{\left(2\right)}=W_{mlp}^{\left(3\right)}\times ml{p}^{\left(2\right)}+b_{mlp}^{\left(3\right)}$$

(16)

where $W_{mlp}^{\left(l\right)}\in {\mathbb{R}}^{d_{cf}\times d_{cf}}$ and $b_{mlp}^{\left(l\right)}\in {\mathbb{R}}^{d_{cf}}$ represent the weight matrix and bias of the l-th layer of the MLP. The only difference in the network structure between the second and third layers is the existence of the activation function. We attached a linear transformation layer as the third layer because the value of collaborative embeddings does not indicate the probability, and we do not have concrete prior knowledge about its range.

Training: The quality of ${\widehat{x}}_0^{\left(1\right)}$ is important because the MLP that calculates the final prediction exploits the prediction of the MoE as its prediction guide. To improve the prediction accuracy of ${\widehat{x}}_0^{\left(1\right)}$, we adopted the objective function in Equation (17) instead of Equation (10) in Algorithm 1.

$$L_d={\mathbb{E}}_{t,x_0,c}(\Vert x_0-{\widehat{x}}_0^{\left(1\right)}{\Vert }_1+\Vert x_0-{\widehat{x}}_0^{\left(2\right)}{\Vert }_1)$$

(17)

where ${\Vert ·\Vert }_1$ indicates the L1-norm. Instead of MSE, we adopted MAE because the scale of the element of the embedding vector that we want to predict is small, and MAE forces the model to reduce small prediction errors. We give the fixed weight to each error in Equation (17) to keep the model simple because our pre-experiments achieved the best performance with the configuration.

Inference: We can generate the collaborative embedding of the cold item by calculating $x_0$ in Algorithm 2 with $c_i$ as the input condition c.

3.3. Second-Phase Refiner

The refiner’s purpose in the second phase is to reduce the error that may be caused by the lack of user-side information or coarse side information of cold items by adjusting the ground-truth user collaborative embeddings and the generated item collaborative embeddings to predict more accurate user–item interactions. Figure 3 shows the architecture of the refiner (Refiner). The ground-truth user collaborative embeddings $e_u$, generated item collaborative embeddings ${\widehat{e}}_i$, and items’ side information $c_i$ are given. With the information provided, the Refiner calculates the recommendation score ${\widehat{r}}_{ui}$ which is proportional to the probability of interaction between user u and item i by calculating Equation (18) with the refined user vector ${\widehat{e}}_u^{+}$ and item vector ${\widehat{e}}_i^{+}$. The Refiner adopts two sub-networks: one for users and one for items. The user-side sub-network that calculates ${\widehat{e}}_u^{+}$ is represented in Equation (19).

$${\widehat{r}}_{ui}={\widehat{e}}_u^{+}·{\widehat{e}}_i^{+}$$

(18)

$${\widehat{e}}_u^{+}=W_U^{\left(2\right)}\times BN(tanh(W_U^{\left(1\right)}\times e_u+b_U^{\left(1\right)}))+b_U^{\left(2\right)}$$

(19)

where $W_U^{\left(1\right)},W_U^{\left(2\right)}\in {\mathbb{R}}^{d_{cf}\times d_{cf}}$, and $b_U^{\left(1\right)},b_U^{\left(2\right)}\in {\mathbb{R}}^{d_{cf}}$ represent weights and biases of the first and second layer, respectively. $BN$ indicates the batch normalization [62].

The item-side sub-network comprises the two layers represented in Equations (20) and (21).

$$h_i=BN(tanh(W_I^{\left(1\right)}\times ({\tilde{e}}_i\Vert c_i)+b_I^{\left(1\right)}))$$

(20)

$${\widehat{e}}_i^{+}=W_I^{\left(2\right)}\times (h_i\Vert {\tilde{e}}_i\Vert c_i)+b_I^{\left(2\right)}$$

(21)

where $W_I^{\left(1\right)}\in {\mathbb{R}}^{d_{cf}\times (d_{cf}+d_{cond})}$ and $W_I^{\left(2\right)}\in {\mathbb{R}}^{d_{cf}\times (2d_{cf}+d_{cond})}$, and $b_I^{\left(1\right)},b_I^{\left(2\right)}\in {\mathbb{R}}^{d_{cf}}$ represent weights and biases of the first and second layers, respectively. At the inference time, ${\tilde{e}}_i$ indicates the predicted collaborative embedding of the cold item calculated by the DM-based generator. We designed each of the two layers as a collaborative embedding refiner, which refines ${\tilde{e}}_i$ based on the side information $c_i$ and the output of the previous layer as guidelines.

Training: To train the Refiner, we use the interaction information $R^{tr}$ that is used to train the base recommender and the ground-truth item collaborative embeddings $e_i$ calculated by the base recommender. For each positive interaction of user u whose value of $r_{ui}\in R^{tr}$ is one, five negative user–item interactions whose value of $r_{ui}\in R^{tr}$ is zero are sampled. The sets of positive and negative interactions are joined to create the training dataset $D^{tr}$. With $D^{tr}$, the Refiner is trained to minimize the objective function represented in Equation (22). The details of the training procedure are found in Algorithm 3.

$$L_{Refiner}={\displaystyle \frac{1}{|D_{tr}|}}{\Sigma }_{r_{ui}\in D_{tr}}{\Vert r_{ui}-{\widehat{r}}_{ui}\Vert }_2^2$$

(22)

Algorithm 3 Refiner Train

Input: Dataset $D_{tr}$, the sets of ground-truth user, item, generated item collaborative embeddings, and items’ side information: $E_U$, $E_I$, ${\widehat{E}}_I$, and $C_I$ Output: Trained model parameter $\theta$ 1: Initialize $\theta$ with random values 2: while $\theta$ is not converged do 3:     Randomly sample a batch $D_{tr}^{\prime }\subset D_{tr}$ 4:     for all $r_{ui}\in D_{tr}^{\prime }$ do 5:         Extract $e_u$, $e_i$, ${\widehat{e}}_i$, and $c_i$ from $E_U$, $E_I$, ${\widehat{E}}_I$, and $C_I$, respectively 6:         Calculate ${\widehat{e}}_u^{+}$ and ${\widehat{e}}_i^{+}$ by using Equations (19)–(21). 7:         Calculate ${\widehat{r}}_{ui}$ by using Equation (18) with ${\widehat{e}}_u^{+}$ and ${\widehat{e}}_i^{+}$ 8:         Calculate loss $L_{Refiner}$ by using Equation (22) 9:         Update $\theta$ using gradient descent with ${\nabla }_{\theta }{L}_{Refiner}$ 10:     end for 11: end while

When we calculate ${\widehat{e}}_i^{+}$, following the ideas of Wang et al. [20] and Volkovs et al. [19], input ${\tilde{e}}_i$ for the item-side sub-network represented in Equations (20) and (21) is sampled by Equation (23). By allowing the network access to the ground-truth and generated embeddings alternately for the given side information, we expect the model to more accurately guess the ground-truth embeddings based on the generated embedding under the given side information.

$${\tilde{e}}_i=\left\{\begin{array}{cc}{\widehat{e}}_i,\hfill & \mathrm{with}\mathrm{probability}0.5\hfill \\ e_i,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(23)

Inference: The Refiner calculates refined user embeddings ${\widehat{e}}_u^{+}$ from users’ ground-truth collaborative embeddings. Similarly, refined item embeddings ${\widehat{e}}_i^{+}$ are calculated with the generated collaborative embeddings and side information of cold items as input. Once calculated, we can store the two kinds of embeddings in the system. For an arbitrary user u and cold item i pair, we can calculate ${\widehat{r}}_{ui}$ by using Equation (18) with ${\widehat{e}}_u^{+}$ and ${\widehat{e}}_i^{+}$. The ordered recommendation list of k-items for user u, $L_u^k$, is calculated by sorting the top k items that have the highest ${\widehat{r}}_{ui}$ scores in descending order.

4. Evaluation Environment

We describe the evaluation environment, which includes the datasets used, evaluation metrics, and the baseline methods compared in the evaluation.

4.1. Datasets

We evaluated the proposed method with two real-world datasets, CiteULike and MovieLens25M.

CiteULike [63] is a well-known dataset used for research in recommender systems. The data were collected from CiteULike, an online reference management and social bookmarking platform where users can save and share academic papers. The dataset includes about 0.2 million user–save–article interactions. As side information, abstracts of the articles are provided. We followed [19,20,63] to calculate the embeddings for side information. Specifically, we first selected the top 8000 high-scored words from the words that appeared in the abstract corpus by applying tf-idf and constructed an 8000-dimensional multi-hot feature vector for each paper. After that, the multi-hot vectors were deduced to 300-dimensional embedding vectors by applying SVD [64]. We randomly selected 1018 and 2378 non-interacted items as the validation and test item sets, and interactions related to the two item sets were used as validation and test sets, respectively. The remainder of the interactions were used as the training set.

MovieLens25M (ML25M) [65] is a dataset for movie recommendation research, released by the Grouplens (https://grouplens.org/ (accessed on 30 March 2025)). It contains 25 million user ratings and movie metadata and is one of the largest publicly available datasets. The dataset includes side information such as titles, genres, release years, and additional tagging information. We calculated the 400-dimensional side information embedding from the tag genome data [66] of each movie by applying VAE [52]. For train–validation–test data separation, we made five non-intersected movie groups of the same size. We selected one group and used 70% of its movies as the test movie set and the remaining 30% as the validation movie set. The last four movie groups were used as the train movie set. The interaction data associated with the three movie sets were used as the test, validation, and training sets. From all sets, ratings of less than 3.0 in 5-scale ratings were filtered out as negative ratings. We performed 5-fold cross-validation by selecting another group for the test and validation groups.

Collaborative embedding of base CF method: We used BPR [67], one of the most popular CF algorithms in academia and industry, as the base CF method to compute the collaborative embeddings. We calculated the collaborative embeddings of dimensions 200 and 128 using the training dataset for CiteULike and ML25M, respectively.

Table 2. Dataset statistics.

Dataset	Training Set				Evaluation Set			Test Set
	Users	Items	Clicks	Sparsity	Users	Items	Clicks	Users	Items	Clicks
CiteULike	5551	13,584	164,210	99.78%	5551	1018	13,037	5551	2378	27,739
ML25M	162,466	11,053	11,369,010	99.37%	55,056	829	519,586	161,053	1934	3,541,109

represents the statistics of the datasets.

Quality of side information embeddings: We used SVD and VAE to obtain compact embeddings for words and tag distributions, respectively. Both methods are optimized to minimize the reconstruction error of the original word or tag distribution of an item from the embedding. To investigate whether severe compression could result in information loss, we conducted experiments by varying the embedding dimensions. We observed that increasing the dimensionality beyond the values reported in the description of CiteULike and ML25M did not lead to significant improvements in reconstruction performance. This suggests that the chosen dimensions are reasonable balances between compression and information preservation.

4.2. Evaluation Metrics

We assessed the recommendation performance by employing Precision@k (P@k) [68], Recall@k (R@k) [68], and NDCG@k (N@k) [69].

P@k represents the fraction of relevant items (the items that the user has interacted with) included in the top k positions of the recommendation list. It is computed using Equation (24).

$$\mathrm{P}@\mathrm{k}={\displaystyle \frac{1}{\left|U\right|}}\sum _{u\in U}{\displaystyle \frac{|L_u^k\cap I_u^{+}|}{|L_u^k|}}$$

(24)

R@k measures the proportion of the interacted items within the top k recommendations relative to the total number of interacted items in the test dataset. It is determined by Equation (25).

$$\mathrm{R}@\mathrm{k}={\displaystyle \frac{1}{\left|U\right|}}\sum _{u\in U}{\displaystyle \frac{|L_u^k\cap I_u^{+}|}{|I_u^{+}|}}$$

(25)

Here, $I_u^{+}$ refers to the set of items that user u has interacted with, while $L_u^k$ denotes the set of recommended items that appeared within the top k positions of the recommendation list for u.

N@k considers the interacted items’ relevance and ranking position within the top k recommendations. Even if the number of relevant items in the top-k list remains the same, N@k assigns higher scores to items appearing in earlier ranks. It is computed using Equation (26).

$$\mathrm{N}@\mathrm{k}={\displaystyle \frac{DCG@k}{IDCG@k}}$$

(26)

$$DCG@k={\displaystyle \frac{1}{\left|U\right|}}\sum _{u\in U}\sum _{l=1}^k{\displaystyle \frac{1_{I_u^{+}}\left(l\right)}{max(1,lo{g}_2\left(l\right))}}$$

(27)

Here, $1_{I_u^{+}}\left(l\right)$ in Equation (27) represents the indicator function that identifies whether an item appeared in the l-th position in $L_u^k$ is included in $I_u^{+}$ or not. It takes a value of one if the item is included in $I_u^{+}$, and zero otherwise. $IDCG@k$ (Ideal $DCG@k$) corresponds to the maximum possible $DCG@k$ where all relevant items ($i\in I_u^{+}$) are ranked consecutively from the top of the recommendation list.

4.3. Comparison Methods

We conducted a comparison between the proposed method and five existing related approaches.

DropoutNet [19]: This approach is designed to predict recommendation scores obtained from the base recommender model by randomly masking collaborative embeddings in its input pair’s CF embedding and side information embedding during training. By doing so, the model is trained to infer missing collaborative embeddings based solely on the item’s side information, enabling it to generalize to cold items more effectively.

Heater [20]: Heater aims to directly predict collaborative embeddings by optimizing an objective function that enforces the model to learn collaborative embeddings from cold items’ side information. The recommendation score is then derived from the predicted collaborative embeddings. To enhance prediction accuracy, Heater employs a Mixture-of-Experts predictor and CF embedding dropout strategies.

CVAR [15]: This method utilizes two encoders and a decoder within a variational autoencoder (VAE) framework [52] to transform the item’s side information into collaborative embeddings. The first encoder processes pre-trained collaborative embeddings from a base CF model while the decoder reconstructs the collaborative embeddings from the encoded representations. Meanwhile, the second encoder learns representations from the item’s side information. The objective function encourages the encoding from the second encoder to closely match that of the first encoder for the same item, ensuring that the decoder can generate valid collaborative embeddings, thus improving cold item recommendations.

CCFC [22]: CCFC leverages contrastive learning to enhance CF embedding prediction. This method enforces similar items (e.g., those with overlapping user interaction histories) to have closely aligned collaborative embeddings while ensuring that the learned embeddings remain distinct from those of unrelated items. Through this contrastive learning strategy, CCFC refines the quality of side information-driven CF embedding predictions.

GME [53]: It enhances the cold item’s side information representation by aggregating information from its neighbors with similar side information using a graph attention network. The score predictor then leverages these enriched side information representations to estimate recommendation scores effectively.

DMCIR: DMCIR (Diffusion Model-based Cold Item Recommender) indicates the DM-based generator of the proposed method to generate the collaborative embeddings from cold items’ side information. Since it generates the collaborative embeddings of the item side, it can recommend items to users by calculating dot product between the generated collaborative embeddings of candidate items and the collaborative embeddings of target users.

DMCIR+: DMCIR+ represents the results that applied the Refiner of the proposed method to the collaborative embeddings generated by DMCIR.

The methods were implemented and evaluated using TensorFlow 2.15 (https://www.tensorflow.org/ (accessed on 30 March 2025)) on a machine equipped with a Ryzen Threadripper Pro 3945WX 12-core CPU (AMD), 128 GB of RAM (Samsung, Suwon Republic of Korea), and a TITAN RTX GPU (nVidia, Santa Clara, CA, USA). The source code for the proposed method is publicly available at https://github.com/JungkyuHan/DMCIR (accessed on 30 March 2025). For the implementation of comparison methods, when the official source codes were available [15,19,20,22], we referred to them. Additionally, we adopted the hyperparameter settings that yielded the best validation performance. We evaluated the models with different initial model parameters five times and reported the average performance. DMCIR/DMCIR+ used the hyperparameters shown in

Table 3. Hyperparameters of DMCIR/DMCIR+.

Dataset	Common		DMCIR					DMCIR+
	${\mathit{d}}_{\mathit{cf}}$	${\mathit{d}}_{\mathit{cond}}$	${\mathit{\beta }}_{\mathit{s}}$	${\mathit{\beta }}_{\mathit{e}}$	$\mathit{T}$	$\left|\mathit{E}\right|$	Optimizer (Lr)	Optimizer (Lr)
CiteULike	200	300	0.0001	0.05	400	3	Adam (0.001)	Momentum SGD (0.005)
ML25M	128	400	0.0001	0.05	300	5	Adam (0.001)	Momentum SGD (0.005)

.

5. Result Analysis

We conducted the experiments to address the following three research questions:

• RQ1. How well does the diffusion model perform in cold item recommendations? How much can its performance be improved by incorporating the post-recommender model (the Refiner)?
• RQ2. What are the optimal hyperparameter values for the DM-based generator in collaborative embedding prediction?
• RQ3. To what extent does the quality of embeddings influence model performance?

5.1. Overall Performance (RQ1)

Table 4. Overall recommendation performance.

Dataset	Metric	DONet	Heater	CVAR	CCFC	GME	DMCIR	DMCIR+
CiteULike	P@10	0.099	0.119	0.112	0.119	0.116	0.120	0.127
	P@20	0.076	0.089	0.088	0.089	0.087	0.090	0.095
	P@50	0.050	0.055	0.054	0.054	0.055	0.054	0.058
	R@10	0.213	0.256	0.251	0.273	0.248	0.263	0.278
	R@20	0.325	0.372	0.376	0.389	0.361	0.379	0.401
	R@50	0.506	0.554	0.557	0.557	0.532	0.549	0.581
	N@10	0.223	0.274	0.262	0.276	0.265	0.277	0.291
	N@20	0.270	0.313	0.304	0.313	0.311	0.317	0.334
	N@50	0.327	0.360	0.351	0.347	0.356	0.353	0.376
ML25M	P@10	0.282	0.328	0.281	0.287	0.231	0.309	0.330
	P@20	0.236	0.270	0.237	0.232	0.186	0.255	0.270
	P@50	0.168	0.184	0.168	0.157	0.127	0.176	0.185
	R@10	0.194	0.224	0.192	0.205	0.138	0.210	0.230
	R@20	0.301	0.343	0.301	0.301	0.207	0.332	0.346
	R@50	0.485	0.523	0.489	0.462	0.323	0.503	0.531
	N@10	0.404	0.466	0.399	0.418	0.332	0.436	0.471
	N@20	0.472	0.531	0.465	0.466	0.375	0.503	0.535
	N@50	0.590	0.636	0.588	0.562	0.455	0.618	0.645

Boldface type: the best performance. Underline: the second-best performance.

shows the overall performance. DMCIR, the recommendation that directly used the collaborative embeddings generated by the DM-based generator, shows decent performance. Only Heater in ML25M and CCFC in CiteULike outperform or match DMCIR. The observation highlights the diffusion model’s superior capability in generating high-quality outputs. DMCIR+, recommended with the Refiner-generated collaborative embeddings from DMCIR’s results, achieved the best performance among all other comparison methods over all datasets. This observation suggests that certain collaborative information is challenging to infer solely from the items’ side information and that some can be effectively captured through a refinement process incorporating user-side collaborative embeddings.

Among the comparison methods, those that incorporate explicit collaborative embedding training guidance into their objective functions—namely Heater and CCFC—consistently outperform the others in most cases. This observation indicates that providing predictive guidance on collaborative embeddings during training effectively enhances the performance of cold item recommendation. DMCIR+ leverages the output of DMCIR as prediction guidance and achieves the best performance.

The elapsed time for cold item recommendation is shown in

Table 5. Overall elapse time (in second) for recommendation.

Dataset	Users	Items	Item Gen	Item Refine	User Refine	Rec
CiteULike	5551	16,980	36.840	0.050	0.010	0.048
ML25M	162,540	13,816	20.640	0.029	0.121	0.874

. It demonstrates how quickly the system can incorporate new items into the top recommendations for relevant users. “Item Gen” refers to the time required by the DM-based generator to generate item embeddings. “Item Refine” and “User Refine” indicate the time taken by the Refiner to refine item and user embeddings, respectively. As shown, generating about 17,000 item embeddings takes approximately 40 seconds, and the Refiner completes both refinement steps in less than one second. The calculation of recommendation item lists (“Rec” column) for ML25M (162,540 users and 13,816 candidate items) is also completed in under one second. Since the generation and refinement steps are performed only once per item, the “Rec” process dominates the actual recommendation cost. We argue that achieving recommendations for approximately 160,000 users in under one second is fast enough for deployment in commercial recommender systems.

5.2. DM’s Hyperparameter Effect (RQ2)

DM’s Noise Schedule: Here, we evaluate the performance of DMCIR with various values of ${\beta }_e$ in Equation (2). Figure 4 plots the decay ratio of $x_0$ in the forward process to timestep t ($\sqrt{\overline{{\alpha }_t}}$ in Equation (3)) for different ${\beta }_e$ values. As the value of ${\beta }_e$ increases, the speed of the original signal decay also increases.

Table 6. Performance of DMCIR with regard to the noise schedule.

Dataset	Metric	${\mathit{\beta }}_{\mathit{e}}=0.02$	${\mathit{\beta }}_{\mathit{e}}=0.03$	${\mathit{\beta }}_{\mathit{e}}=0.04$	${\mathit{\beta }}_{\mathit{e}}=0.05$	${\mathit{\beta }}_{\mathit{e}}=0.06$
CiteULike	P@10	0.118	0.120	0.120	0.120	0.120
	P@20	0.089	0.090	0.090	0.090	0.090
	P@50	0.054	0.054	0.054	0.055	0.055
	R@10	0.260	0.263	0.263	0.263	0.262
	R@20	0.373	0.377	0.379	0.379	0.376
	R@50	0.545	0.546	0.549	0.550	0.549
	N@10	0.272	0.275	0.277	0.275	0.277
	N@20	0.312	0.314	0.317	0.317	0.317
	N@50	0.351	0.352	0.353	0.355	0.354
ML25M	P@10	0.307	0.292	0.294	0.299	0.296
	P@20	0.254	0.236	0.238	0.239	0.238
	P@50	0.175	0.174	0.176	0.176	0.176
	R@10	0.209	0.226	0.229	0.231	0.229
	R@20	0.322	0.355	0.357	0.357	0.353
	R@50	0.499	0.497	0.503	0.501	0.499
	N@10	0.435	0.445	0.446	0.451	0.449
	N@20	0.501	0.523	0.526	0.526	0.522
	N@50	0.613	0.612	0.620	0.618	0.616

Boldface type: the best performance. Underline: the second-best performance.

plots the performance of DMCIR with ${\beta }_e\in \{0.02,0.03,0.04,0.05,0.06\}$. The other hyperparameters, the number of experts $\left|E\right|$ and the maximum timestep T are fixed to 5 and 400, respectively. The average performance increases as ${\beta }_e$ increases to 0.05. The performance starts to decrease at ${\beta }_e=0.06$.

This trend indicates that the original information available in the last part of the forward process affects the reconstruction accuracy. As shown ${\beta }_e=0.02$ in Figure 4, when ${\beta }_e$ is small, the signal-to-noise ratio (SNR) of the original information does not become zero at T. As Lin et al. [70] pointed out, the remaining original information in the training phase makes the denoiser (predictor) try to seek the original information at $x_T$, which is regarded as a pure Gaussian noise. Because we do not know collaborative embeddings of cold items, we set a pure Gaussian noise as $x_T$ is in the inference phase. The performance drop at small ${\beta }_e=0.02$ is caused because the denoiser considers a noise as information from $x_0$. The phenomenon is mitigated as ${\beta }_e$ increases, but when ${\beta }_e$ is greater than 0.05, the available information of $x_0$ in the last part of the forward process becomes too small. That also hinders the performance of the denoiser.

It is important to determine the optimal value of ${\beta }_e$. Based on our experimental result showing that ${\beta }_e\in [0.04,0.05]$ yields consistently fair performance across datasets, we suggest 0.04 to 0.05 as a reasonable choice.

Maximum Timesteps: For DM, an optimal value of the maximum timesteps T is critical. When the value of T is too small, although the training and inference costs are reduced, the noise scale applied to each timestep increases. That makes the denoising process difficult. On the other hand, when the value of T is too large, the denoising process becomes easier, resulting in increased computational costs. Figure 5 shows DMCIR’s performance with the CiteULike ((a)) and ML25M ((b)) datasets to various $T\in \{100,200,300,400,500,600\}$. We fixed the other parameters as ${\beta }_e=0.05$ and $\left|E\right|=5$.

Generally, the recommendation performance increases as the value of T increases and reaches its peak at 300 and 400. After that, the performance starts to decline. This observation is caused by the extremely small noise size of the single timestep. The extremely small size of the noise is also difficult to predict accurately. Considering the performance and cost trade-off, the value of T as 300 or 400 is a good choice.

The Number of Experts in $x_0$-Predictor of DM: The $x_0$-predictor of DMCIR adopts a Mixture-Of-Experts architecture to generate the first prediction ${\widehat{x}}_0^{\left(1\right)}$ in Equation (13), which is used for prediction guidance of DM. In Figure 6, we show the recommendation performance of DMCIR with CiteULike ((a)) and ML25M ((b)) datasets to various number of experts $\left|E\right|\in \{0,1,3,5,7\}$. “$\left|E\right|=0$” indicates that MoE in Figure 2 is removed. The other parameters were fixed as ${\beta }_e=0.05$ and $T=400$.

In all datasets, the worst performance was observed when “$\left|E\right|=0$”, indicating that MoE contributes to the recommendation performance. The performance increases as $\left|E\right|$ increases to some point, $\left|E\right|=3$ for CiteULike and $\left|E\right|=5$ for ML25M, and then starts to decline in both datasets but the details are different. The performance gain caused by the MoE with the CiteULike dataset is smaller than that with ML25M, which shows significant improvement. The observation was caused by the characteristics of the datasets. The users and side information of items in the CiteULike dataset are specialists and abstracts of papers. In contrast, the users and side information of items in the ML25M dataset are ordinary people and tags assigned to movies. Therefore, the uncertainty in the relationship between user interactions and side information is lower in the CiteULike dataset, which allows the performance of the $x_0$-predictor without MoE to approach that of the MoE-enhanced $x_0$-predictor.

5.3. Embedding Quality (RQ3)

Generated embedding quality to the Refiner’s performance: The Refiner takes the collaborative embeddings calculated by DM-based generator to calculate refined collaborative embeddings for the final recommendation. Therefore, the relationship analysis between input and the final recommendation quality is important. To this end, we compared the performance of the DMCIR model with two different configurations and the performance of the two DMCIR+ models whose input collaborative embeddings are the output of each DMCIR model.

Table 7. Embedding quality to the Refiner’s performance.

Dataset	Metric	${\mathrm{DMCIR}}_0$	${\mathrm{DMCIR}}_{\mathbf{opt}}$	${\mathrm{DMCIR}}_0$+	${\mathrm{DMCIR}}_{\mathbf{opt}}$+
CiteULike	P@10	0.119	0.120	0.125	0.127
	P@20	0.089	0.090	0.095	0.095
	P@50	0.054	0.054	0.058	0.058
	R@10	0.259	0.263	0.274	0.278
	R@20	0.376	0.379	0.398	0.401
	R@50	0.546	0.549	0.581	0.581
	N@10	0.273	0.277	0.288	0.291
	N@20	0.314	0.317	0.334	0.334
	N@50	0.352	0.353	0.375	0.376
ML25M	P@10	0.273	0.309	0.326	0.330
	P@20	0.235	0.255	0.269	0.270
	P@50	0.169	0.176	0.185	0.185
	R@10	0.183	0.210	0.226	0.230
	R@20	0.296	0.332	0.344	0.346
	R@50	0.484	0.503	0.529	0.531
	N@10	0.384	0.436	0.464	0.471
	N@20	0.462	0.503	0.532	0.535
	N@50	0.492	0.618	0.645	0.645

Boldface type: the best performance. Underline: the second-best performance.

shows the result. ${\mathrm{DMCIR}}_0$ and ${\mathrm{DMCIR}}_{opt}$ indicate that DMCIR with the number of experts is zero and with the best number of experts (three for CiteULike, five for ML25M), respectively. ${\mathrm{DMCIR}}_0$+ and ${\mathrm{DMCIR}}_{opt}$+ use the outputs of ${\mathrm{DMCIR}}_0$ and ${\mathrm{DMCIR}}_{opt}$ as inputs, respectively.

The performance of DMCIR+ is proportional to its input item collaborative embeddings. This indicates that the qualitative first prediction of item collaborative embeddings is essential to calculate more accurate refined embeddings. An interesting finding is that while the performance difference between ${\mathrm{DMCIR}}_0$ and ${\mathrm{DMCIR}}_{opt}$ and the difference between ${\mathrm{DMCIR}}_0$+ and ${\mathrm{DMCIR}}_{opt}$+ in CiteULike are similar, in ML25M the difference between ${\mathrm{DMCIR}}_0$+ and ${\mathrm{DMCIR}}_{opt}$+ is much smaller compared to the difference between ${\mathrm{DMCIR}}_0$ and ${\mathrm{DMCIR}}_{opt}$. That indicates that, in the ML25M dataset, some information captured by the MoE architecture in DMCIR from item collaborative embeddings can be compensated by the refining process, which is re-considering user embeddings and user–item interactions. Thus, further research is required to extract and integrate information using integrated architecture. However, calculating high-quality collaborative embeddings upstream is still important to achieving top recommendation accuracy, especially at the top part of the recommendation list that users most frequently examine.

Side information quality to model performance: Since the proposed method relies on side information as a pivotal input, the quality of the side information is crucial. To investigate the relationship between the quality of side information and model performance, we evaluated our method using side information embeddings of varying quality. Specifically, we calculated degraded side information by randomly dropping p % of the original content prior to embedding calculation. Figure 7 shows the relative R@20 scores calculated with side information of different qualities. Across all datasets and model types, performance consistently degrades with lower-quality side information, demonstrating that side information quality is a critical factor in the effectiveness of the proposed method.

Embedding Transformation Analysis: Here, we analyze how the Refiner transforms its input collaborative embeddings—specifically, the ground-truth user embeddings and the generated item embeddings. Since the Refiner projects these inputs into a different space, it is not straightforward to directly compare the input and output embeddings of the Refiner. To address this, we evaluate the transformation by examining the relative angles between embeddings. We compute the pairwise cosine similarity and construct similarity matrices for each set of vectors. For each dataset, we obtain four matrices: $S_U^{in}$, $S_I^{in}$, $S_U^{re}$, $S_I^{re}$, representing the similarity matrices for users’ ground-truth embeddings, items’ generated embeddings, refined user embeddings, and refined item embeddings, respectively.

Figure 8 shows the value distribution of the elements in the absolute difference matrix $D_x=|S_x^{in}-S_x^{re}|$. Across datasets, the relative angles between user embeddings remain mostly unchanged. However, for item embeddings, the CiteULike dataset shows only minor changes, whereas the ML25M dataset exhibits more significant transformations. This observation is further illustrated in Figure 9, which displays side-by-side visualizations of item embeddings before and after refinement. The visualized distributions of embeddings in CiteULike are similar to each other, whereas in ML25M, they show more noticeable differences. We think that this difference is caused by the varying quality of side information. Compared to the abstracts of academic papers used in CiteULike, the tags associated with full-length movies in ML25M are less effective in representing item content. As a result, Refiner performs more substantial transformations on the embeddings generated from the less informative movie tags.

6. Conclusions

This paper presented a novel diffusion model framework as an add-on solution for improving cold item recommendation performance in collaborative filtering (CF) systems. Our diffusion model-based generator generates collaborative embeddings for cold items by effectively leveraging items’ side information. The second-phase refiner further enhances recommendation accuracy by utilizing simple neural network components and dropout regularization, ensuring effective refinement of embeddings with minimal system overhead.

Through extensive experiments on real-world datasets, we demonstrated that our approach outperforms state-of-the-art methods in cold item scenarios, particularly at the start of item introduction. The model’s performance and insights from hyperparameter sensitivity and ablation studies highlight the practical value and flexibility of integrating diffusion models into recommender systems. Our findings suggest that the diffusion models are a promising direction for addressing long-standing challenges in cold item recommendation.

Future work will explore four main directions: (1) Developing more effective predictor architectures for the diffusion model to enhance the accuracy of generated collaborative embeddings. (2) Designing an end-to-end architecture that tightly integrates the diffusion generation module and the refiner module to improve overall efficiency and performance. (3) Conducting a thorough study for a more comprehensive analysis of the noise scheduler’s stability in the diffusion model in the context of cold item recommendations. (4) Investigating structured comparison techniques to improve the reliability of item representations in cold-start recommendation settings.