DAERec-GCA: A Deep Autoencoder-Based Collaborative Filtering Framework with Genre-Channel Alignment

Featured Application

The proposed framework is suitable for top-N recommendation in sparse user–item settings where item-side genre information is available. Its genre-channel-aligned design enables side-information integration with controlled parameter growth relative to flattened genre-aware formulations.

Abstract

In top-N recommendation, incorporating item-side information can improve ranking quality under sparse user–item interactions; however, common flat concatenation strategies may weaken the structural correspondence between user ratings and item attributes while simultaneously increasing model size. To address this issue, this study proposes DAERec-GCA, a deep autoencoder-based collaborative filtering framework that organizes rating signals and genre information in a genre-channel-aligned two-dimensional representation. The model applies shared weights across genre channels and aggregates channel outputs to generate item scores, enabling side-information integration without the parameter growth associated with flattened genre-aware formulations. The framework was evaluated on MovieLens-100K, 1M, and 10M under a warm-start five-fold cross-validation protocol using ranking-based metrics. In addition, a structured ablation study was conducted against ROnly, Flat1D, GenreProfile, GenreEmbed, and GenreGated, together with a controlled train-side sparsity analysis and a computational profiling analysis covering trainable parameters, epoch time, inference latency, and peak GPU memory. The results show that DAERec-GCA remains competitive across all three datasets and exhibits its clearest advantage under sparse and moderately sparse training conditions. The findings suggest that genre-channel alignment provides a practical trade-off between structural expressiveness, parameter efficiency, and recommendation quality in sparse recommendation settings.

1. Introduction

The rapid growth of digital platforms has produced an overwhelming volume of user-generated content, intensifying the problem of information overload. One effective approach to addressing this challenge is to filter irrelevant content through recommendation systems [1]. These systems are widely deployed in e-commerce, streaming platforms, and social media, where accurate and scalable recommendation mechanisms are essential for enhancing user experience.

Among recommendation paradigms, collaborative filtering (CF) remains one of the most widely adopted approaches due to its ability to learn preferences directly from user–item interactions [2]. Early memory-based methods such as k-nearest neighbors [3,4,5,6,7,8] are simple and interpretable but suffer from limited scalability and poor performance under sparse data conditions [9]. To overcome these limitations, model-based techniques—most notably matrix factorization (MF) [10]—have been extensively studied to learn latent user and item representations [11]. Although MF improves predictive accuracy, its performance tends to degrade when the interaction matrix is highly sparse or when auxiliary contextual information is not effectively incorporated.

To mitigate these challenges, recent advances in deep autoencoder (DAE)-based collaborative filtering leverage deep neural networks to reconstruct the user–item interaction matrix, thereby improving the accuracy and robustness of the generated recommendations. In particular, autoencoder-based architectures [12,13,14,15] have demonstrated strong capability in reconstructing incomplete user–item matrices by learning compact latent representations. Variants such as denoising and variational autoencoders further improve robustness to missing or noisy data [16,17,18,19]. Concurrently, several studies have incorporated side information—such as user demographics, item genres, textual features, and metadata—into autoencoder-based frameworks [20,21,22,23]. While the integration of side information has been widely explored in the literature, the structural manner in which this information is embedded into neural architecture remains underexplored.

Motivation and Novelty

While deep autoencoders (DAEs) have emerged as an effective approach for collaborative filtering, their performance is frequently constrained by the sparsity of user–item interaction matrices. Existing hybrid models attempt to alleviate this limitation by incorporating side information—such as item genres—through feature concatenation, graph-based regularization, or cross-domain transfer learning to leverage knowledge from information-rich source domains. To provide a general overview of recent approaches in deep and hybrid recommendation systems evaluated on MovieLens datasets, representative studies and their methodological characteristics are summarized in Table 1.

Table 1. Selected recent studies on deep and hybrid recommendation models evaluated on MovieLens datasets.

Model	Year	Dataset	Specific Side Information	Filtering Method	Learning/ Loss Function
MTMM-GNN [20]	2025	ML (5496 Films)	Feature extraction from movie titles and genres using the GloVe embedding model	Multi-task Hybrid/Multi-modal GNN	BPR + MSE
FN-CF [16]	2024	ML-100K, ML-1M, ML-10M	None	Hybrid (Fuzzy Set + Bernoulli MF + Deep NN)	Bernoulli Distribution Log-Likelihood and Cross-Entropy Loss
IAE [17]	2023	ML-100K, ML-1M	None	Deep Autoencoder (DAE)	MSE
PETCF [21]	2023	ML-1M	Age, gender, occupation and genre	Collaborative Filtering	MAP Estimation Objective Function
IOVA-CF [18]	2022	ML-1M, ML-10M	None	VAE (Variational AutoEncoder)	ELBO-based loss combining Bernoulli reconstruction term and KL divergence with implicit optimal prior
CNNCF [22]	2022	ML-100K, ML-1M	age, gender, occupation, ZIP; BERT-embedded title, year, genre	Deep Learning (CNN)/Hybrid Item-Content (Cross Convolutional Filters)	RMSE/MAE
ADLRS [23]	2022	80:20 random split; 5 repetitions	Text-based Content (with BERT Embeddings)	Hybrid (MF + BERT + DAE)	Regularized Squared Error (MSE-based)
BeMF [19]	2021	ML-1M	None	Probabilistic MF/Classification-Based Model	Log-likelihood of the Bernoulli distribution including L2 regularization

Most existing approaches incorporate auxiliary features such as genres through simple concatenation into a one-dimensional representation, implicitly assuming that the semantic relationships between item attributes and user interactions are preserved after flattening. However, such a transformation may weaken the alignment between rating signals and semantic categories while simultaneously increasing parameter complexity.

The central motivation of DAERec-GCA is to preserve the structural alignment between user preferences and item characteristics. Unlike standard models that treat genre as an appended feature vector, DAERec-GCA represents the input as a structured two-dimensional matrix ($G_u\in {\mathbb{R}}^{m\times g}$) in which user ratings are explicitly aligned with genre-specific channels. It is important to distinguish the proposed DAERec-GCA framework from traditional convolution-based or multi-channel neural recommender models. While CNN-based collaborative filtering approaches exploit local receptive fields and spatial neighborhood structures, DAERec-GCA relies neither on convolutional operations nor on spatial locality assumptions. Instead, the proposed architecture is built upon a fully connected deep autoencoder with shared weights across genre channels to introduce a structural inductive bias rather than a geometric one. The two-dimensional representation in DAERec-GCA serves to preserve the alignment between ratings and side information, rather than to model spatial correlations as in image-based learning. Accordingly, DAERec-GCA should be understood as a structured, genre-aware autoencoder design that differs from convolutional or graph-based recommender architectures in both its input representation and its learning mechanism.

The main contributions of this study are summarized as follows:

• Genre-channel-aligned representation: A two-dimensional input formulation is introduced in which user rating signals are aligned with item genre information across genre-specific channels, providing a structured alternative to flat genre-aware representations.
• Parameter-efficient shared-weight architecture: A weight-sharing encoder–decoder design is proposed, where transformations are applied consistently across genre channels, controlling parameter inflation while preserving channel-wise structure.
• Systematic structural ablation: The effect of the proposed design is examined through comparisons with ROnly, Flat1D, GenreProfile, GenreEmbed, and GenreGated, enabling a more direct analysis of the roles of representation structure and genre-integration strategy.
• Controlled sparsity sensitivity analysis: A controlled train-side sparsity experiment is conducted by reducing the retained training interactions per user under fixed test splits, providing direct evidence of how recommendation performance changes as observed feedback becomes more limited.
• Empirical computational profiling: The proposed model and its variants are profiled covering trainable parameters, epoch time, inference latency, and peak GPU memory, allowing the efficiency discussion to be supported by measured computational evidence.

The remainder of this paper is organized as follows. Section 2 introduces the materials and methods, including the datasets, preprocessing procedure, and evaluation metrics. Section 3 presents the proposed DAERec-GCA framework, including its notation, input construction, model architecture, scoring mechanism, optimization procedure, top-N generation process, and computational complexity analysis. Section 4 provides experimental results, covering hyperparameter optimization, ablation analysis, and recommendation evaluation. Section 5 presents the discussion, with emphasis on structural design, sparsity robustness, and computational scalability. Section 6 concludes the study.

2. Materials and Methods

2.1. Datasets

The experiments in this study utilized the MovieLens-100K (ML-100K), MovieLens-1M (ML-1M), and MovieLens-10M (ML-10M) datasets, which are widely used benchmarks in the recommendation literature and include item genre metadata [24]. Dataset characteristics are summarized in Table 2.

Table 2. Details about the datasets used in this study.

Dataset Name	#User	#Movie	#Rating	Rating Range	#Genre	SparsityRate
ML-100K	943	1682	100,002	1–5	18	93.7%
ML-1M	6040	3952	1,000,211	1–5	18	95.8%
ML-10M	71,567	10,681	10,000,054	1–5	18	98.69%

In recommendation systems, the sparsity rate refers to the proportion of missing entries in a user–item interaction matrix. Such matrices are typically highly sparse, as individual users tend to interact with only a small fraction of the available items. It can be quantified by Equation (1).

$$SparsityRate=1-\left(NotZeroRating\right)/\left(AllRatings\right)$$

(1)

Each dataset entry contains user ID, movie ID, rating, genre labels, and a timestamp. Movies are associated with one or more of 18 genres: action, adventure, animation, children’s, comedy, crime, documentary, drama, fantasy, film noir, horror, musical, mystery, romance, science fiction, thriller, war, and western. Genre membership is represented as a binary indicator: a value of 1 denotes that a movie belongs to the corresponding genre, and 0 otherwise.

2.2. Dataset Preprocessing

To ensure reproducibility, all MovieLens datasets were processed using an identical deterministic preprocessing pipeline prior to model development. The ratings table was restricted to userId, movieId, and rating fields, while genre metadata were extracted from the movie table. Genre labels were transformed into binary multi-hot vectors and joined with the interaction data via movieId, yielding a unified interaction–side-information table. Entries marked as (no genres listed) were excluded where present. User and item identifiers were subsequently mapped to zero-based contiguous indices to facilitate efficient matrix construction. To mitigate the effect of extreme sparsity, a user-level k-core filtering step was applied, retaining only users with at least five recorded interactions. From the filtered table, a unique item–genre matrix $M$ was derived and used to construct the genre-channel-aligned representation $G_u=R_u\odot M$. For evaluation, the processed data were partitioned under a warm-start setting using five-fold cross-validation for the main experimental analysis, and a 20% hold-out split for hyperparameter search. In the ranking protocol, interactions with a rating of at least 3.5 were treated as relevant (relevance threshold $\tau =3.5$), and users with fewer than five relevant test items were excluded. Under the leave-one-out (LOO) protocol, each user contributes exactly one relevant test item; accordingly, no minimum relevant-item filter is applied. For each user, the most recent interaction—determined by timestamp—is reserved as the test instance, while the remaining interactions are used for training. Note that an additional item, the second most recent interaction, is reserved for validation (early stopping) but does not participate in the test evaluation and does not alter the leave-one-out definition.

2.3. Evaluation Metrics

To assess recommendation performance across all evaluated models, five metrics are employed throughout this study, each computed at cutoff level K: Precision@K, Recall@K, F1@K, NDCG@K, and HitRatio@K (HR@K), formally defined in Equations (2)–(6), respectively.

$${\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}@K}_u={\displaystyle \frac{\mid L_u^K\cap T_u\mid }{K}}, \mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}@K={\displaystyle \frac{1}{\mid U\mid }}{\sum }_{u\in U}{\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}@K}_u,\begin{array}{cccc}& & & \end{array}$$

(2)

$${\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}@K}_u={\displaystyle \frac{\mid L_u^K\cap T_u\mid }{\mid T_u\mid }},\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}@K={\displaystyle \frac{1}{\mid U\mid }}{\sum }_{u\in U}{\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}@K}_u,\begin{array}{cccc}& & & \end{array}$$

(3)

$$\begin{array}{cccc}& {\mathrm{F}1@K}_u=\left\{\begin{array}{cc}{\displaystyle \frac{2\cdot {\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}@K}_u\cdot {\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}@K}_u}{{\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}@K}_u+{\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}@K}_u}},& \mathrm{if} {\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}@K}_u+{\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}@K}_u>0\\ 0,& \mathrm{otherwise}\end{array}\right.& & \end{array}$$

(4a)

$$\mathrm{F}1@K={\displaystyle \frac{1}{\mid U\mid }}\sum _{u\in U}{\mathrm{F}1@K}_u$$

(4b)

$${\mathrm{D}\mathrm{C}\mathrm{G}@K}_u={\sum }_{j=1}^K{\displaystyle \frac{re{l}_{u,j}}{{\log }_2\left(j+1\right)}}, re{l}_{u,i}=\left\{\begin{array}{cc}1,& \mathrm{if} r_{u,i}^{\mathrm{t}\mathrm{e}\mathrm{s}\mathrm{t}}\ge \tau \\ 0,& \mathrm{otherwise}\end{array}\right.,$$

(5a)

$$\mathrm{I}\mathrm{D}\mathrm{C}\mathrm{G}@K_u=\sum _{j=1}^{\min \left( ∣T_u∣, K\right)}{\displaystyle \frac{1}{{\log }_2\left(j+1\right)}}$$

(5b)

$${\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}@K}_u={\displaystyle \frac{{\mathrm{D}\mathrm{C}\mathrm{G}@K}_u}{{\mathrm{I}\mathrm{D}\mathrm{C}\mathrm{G}@K}_u}}, \mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}@K={\displaystyle \frac{1}{\mid U\mid }}{\sum }_{u\in U}{\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}@K}_u,$$

(5c)

$$\begin{array}{cccc}& {\mathrm{H}\mathrm{R}@K}_u=\left\{\begin{array}{cc}1,& \mathrm{if} \mid L_u^K\cap T_u\mid >0\\ 0,& \mathrm{otherwise}\end{array}\right.& & ,\end{array}\begin{array}{cccc}& \mathrm{H}\mathrm{R}@K={\displaystyle \frac{1}{\mid U\mid }}{\sum }_{u\in U}{\mathrm{H}\mathrm{R}@K}_u& & \end{array}$$

(6)

Let $U$ denote the set of evaluated users, $L_u^K$ the top-$K$ recommendation list for user $u$, and $T_u$ the set of relevant test items. The overlap $\mid L_u^K\cap T_u\mid$ represents the number of correctly recommended items. As defined in Equations (2) and (3), Precision@K_u and Recall@K_u are computed at the user level and then macro-averaged over all users in $U$. Precision@K_u measures the proportion of relevant items within the recommendation list, while Recall@K_u reflects the fraction of all relevant items successfully retrieved. F1@K_u, defined in Equation (4a), is the harmonic mean of user-level Precision@K_u and Recall@K_u; it is computed per user and then macro-averaged across users. Hence, it is not equal to the harmonic mean of the averaged Precision@K and Recall@K values. NDCG@K measures ranking quality by assigning position-discounted credit to relevant items. As defined in Equation (5a), the Discounted Cumulative Gain for user $u$ accumulates relevance scores across the top-$K$ recommended items, each discounted by the logarithm of its rank position. Relevance is determined in a binary fashion: $re{l}_{u,j}=1$ if the item at position $j$ carries a test rating $r_{u,i}^{test}\ge \tau$, and $re{l}_{u,j}=0$ otherwise, where $\tau =3.5$ is the relevance threshold. Since binary relevance is employed ($rel\in \left\{0, 1\right\}$), the formulation in Equation (5a) is numerically equivalent to the exponential form ${\displaystyle \frac{2^{rel}-1}{{\log }_2\left(j+1\right)}}$ used in standard implementations. Equation (5b) defines the Ideal DCG ($\mathrm{I}\mathrm{D}\mathrm{C}\mathrm{G}@K_u$), representing the maximum achievable $\mathrm{D}\mathrm{C}\mathrm{G}@K_u$ for user $u$, obtained by assuming that all $\mid T_u\mid$ relevant items are placed at the highest positions in optimal order. The summation is capped at $\min (\mid T_u\mid ,K)$ because at most $\mid T_u\mid$ positions can receive a relevance score of 1, and the list length is bounded by $K$. Users for whom $\mid T_u\mid =0$ are excluded from the evaluation. As given in Equation (5c), $\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}@K_u$ is obtained by normalizing $\mathrm{D}\mathrm{C}\mathrm{G}@K_u$ by $\mathrm{I}\mathrm{D}\mathrm{C}\mathrm{G}@K_u$, yielding a score in [0, 1] where 1 indicates a perfect ranking. The final reported metric $\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}@K$ is the macro-average of per-user $\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}@K_u$ values over all evaluated users in $U$, as shown in the right-hand side of Equation (5c). HR@K, defined in Equation (6), indicates whether at least one relevant item appears in the top-$K$ list, and is macro-averaged across users. In all cases, reported results correspond to macro-averaged user-level metrics, with higher values indicating stronger recommendation performance.

2.4. Deep Autoencoder-Based Collaborative Filtering Recommendation Systems

Deep autoencoders are fully connected neural networks designed for unsupervised representation learning. They consist of three components: an encoder, a bottleneck, and a decoder. The encoder maps input data to a compressed representation; the bottleneck holds this compact latent code; and the decoder reconstructs the original input from the bottleneck representation [25]. The basic structure of a deep autoencoder is shown in Figure 1. Equations (7)–(9) provide the basic mathematical formulations of deep autoencoders, respectively.

$$z=E_{\phi }\left(\phi ;x\right)=f\left(W_{enc}x+b_{enc}\right)$$

(7)

$$x^{\prime }=D_{\theta }\left(\theta ;z\right)=g\left(W_{dec}z+b_{dec}\right)$$

(8)

$${\mathcal{L}}_{mse}={\displaystyle \frac{1}{S}}\sum {‖x-x^{\prime }‖}^2$$

(9)

where

$x$: original input data,

$x^{\mathrm{\prime }}$: reconstructed output data,

$W_{enc}$ and $W_{dec}$: weights of the encoder and decoder, respectively,

$b_{enc}$ and $b_{dec}$: biases of the encoder and decoder, respectively,

$f$ and g: activation functions for encoder and decoder layers, respectively,

$\phi$ = {$W_{enc}, b_{enc}$},

$\theta$ = {$W_{dec}, b_{dec}$},

$E_{\phi }\left(\phi ;x\right)$ and $D_{\theta }\left(\theta ;z\right)$: encoder and decoder functions, respectively,

$z$: “bottleneck” or “latent space” representation

${\mathcal{L}}_{mse}$: Mean squared error (MSE)

$S$: total number of training samples,

||.||²: squared Euclidean distance between the vectors.

Figure 1. The basic structure of a deep autoencoder. Green layers represent the encoder, the blue layer denotes the bottleneck (latent representation z), orange layers represent the decoder, and dashed lines indicate inter-layer connections.

Figure 1. The basic structure of a deep autoencoder. Green layers represent the encoder, the blue layer denotes the bottleneck (latent representation z), orange layers represent the decoder, and dashed lines indicate inter-layer connections.

The encoder maps input data to a lower-dimensional representation known as the bottleneck or latent space. Each encoder layer processes the output of the preceding layer by applying a learned weight matrix, a bias vector, and a nonlinear activation function, as formally expressed in Equation (7). The decoder reconstructs the original input from the bottleneck representation by applying a symmetric sequence of weight matrices, bias vectors, and activation functions, as given in Equation (8). During training, a loss function quantifies the dissimilarity between the original input and its reconstruction. The choice of loss function depends on the data characteristics and task objectives; the mean squared error (MSE) is widely adopted in this setting. Once the architecture and loss function are defined, the autoencoder is trained using gradient-based optimization algorithms such as Adam, AdaGrad, RMSprop, or AdaDelta. During this process, the model parameters are iteratively updated according to the gradients of the loss function, with the objective of minimizing the total reconstruction loss over the training set.

3. A Deep Autoencoder-Based Collaborative Filtering Framework with Genre-Channel Alignment: DAERec-GCA

DAERec-GCA is a deep autoencoder-based recommendation framework that integrates collaborative filtering with genre-aware side information. While traditional autoencoder-based models typically treat user–item interactions as flattened one-dimensional vectors, DAERec-GCA introduces a genre-channel-aligned formulation in which interaction signals and item-side genre information are jointly organized in a structured two-dimensional representation.

The central motivation of the proposed framework is that user preferences may be more accurately characterized not only through item-level interactions but also through their alignment with semantic item attributes. By reorganizing the input into genre-specific channels, DAERec-GCA preserves the structural correspondence between user–item interactions and genre information, enabling the model to apply shared transformations across channels as a structured alternative to flattened representations.

The following subsections introduce formal notation and preliminary definitions that establish the mathematical foundation of the model. The DAERec-GCA architecture is then described in detail, covering the construction of the genre-channel-aligned two-dimensional input representation, the weight-sharing encoder–decoder design, and the channel aggregation mechanism. The objective function and training procedure are subsequently presented.

3.1. Notations

The symbols and definitions used throughout the mathematical formulation of the model are summarized in Table 3, providing a consistent formal basis for the subsequent architectural description.

Table 3. The notations and descriptions used in DAERec-GCA.

Category	Symbol	Description
Sets and Dimensions	U, I, J	Sets of users, items, and genres, respectively.
	k, m, g	Total number of users, items, and genres, respectively.
Input Structures	$R\in {\mathbb{R}}^{k\times m}$	User-item interaction (rating) matrix.
	$M\in \{0, 1{\}}^{m\times g}$	Item-genre information matrix (masking matrix).
	$G_u\in {\mathbb{R}}^{m\times g}$	Genre-channel 2D structural alignment tensor for user u (${\mathrm{G}}_{\mathrm{u}}={\mathrm{R}}_{\mathrm{u}}\odot \mathrm{M}$).
Model Functions	${\mathrm{E}}_{\varphi }\left(\cdot \right),{\mathrm{D}}_{\theta }\left(\cdot \right)$	Encoder and decoder functions with parameters $\varphi$ and $\theta$.
	$W^{\left(l\right)},b^{\left(l\right)}$	Shared weight matrix and bias vector for the l-th hidden layer.
	$h_j^{\left(l\right)}$	Latent representation of the j-th genre channel at layer l.
Output and Scoring	$G_u^{\prime }\in {\mathbb{R}}^{m\times g}$	Reconstructed genre-channel tensor produced by the decoder.
	$s_{u,i}$	Final estimated recommendation score for item i and user u.
Optimization	$\mathcal{L}$	Total loss value of the objective function.
	${\mathcal{L}}_{pos}{,\mathcal{L}}_{neg}$	The loss components corresponding to observed positive interactions and sampled negative interactions, respectively.
	D+,D−	Sets of observed positive interactions and dynamically sampled negative interactions, respectively.
	$\mathrm{P}\mathrm{W},\mathrm{N}\mathrm{W}$	Positive loss weight and negative loss weight, respectively.
	NPP	Number of negative samples drawn per positive interaction.
	Θ = {ϕ, θ}	Set of trainable model parameters.
	LR, WD	Learning Rate (LR) and Weight Decay (WD).
	$\mathrm{sig}\left(\cdot \right)$	Sigmoid activation function for probabilistic output generation.

The core of the proposed DAERec-GCA architecture lies in its ability to process user–item interactions through genre-specific channels, thereby preserving the underlying semantic structure of the data. This mechanism is illustrated in Figure 2, which presents a conceptual block diagram of the proposed framework.

Figure 2. Basic Block Diagram of Architecture of DAERec-GCA. The green and orange blocks represent the encoder and decoder, respectively, and the blue block denotes the bottleneck. Solid arrows indicate the forward data flow, while the dashed line between input and output represents the reconstruction objective used for loss calculation.

As depicted in Figure 2, for each user u, the input layer processes the m × g dimensional structural alignment matrix G_u. After passing through the encoder–decoder architecture, the reconstructed output in $G_u^{\prime }$ is obtained. The reconstructed values are then aggregated to estimate item-level recommendation scores and generate the final top-N recommendation list.

3.2. Generation of Input for DAERec-GCA and Two-Dimensional Structural Alignment

The input construction begins by transforming the sparse user–item interaction vector $R_u\in {\mathbb{R}}^m$ into a structured two-dimensional tensor. Using the item–genre binary mask matrix $M\in \{0, 1{\}}^{m\times g}$, the interaction signal is projected onto $g$ distinct genre channels through an element-wise multiplication (with broadcasting), formally defined in Equation (10).

$$G_u=R_u\odot M\in {\mathbb{R}}^{m\times g}$$

(10)

For the MovieLens-100K dataset, this yields a tensor of size $1682\times 18$, where each of the 18 channels represents the user’s interaction history within a specific genre (action, adventure, animation, children’s, comedy, crime, documentary, drama, fantasy, film noir, horror, musical, mystery, romance, science fiction, thriller, war, and western). An illustrative example is depicted in Figure 3.

Figure 3. An illustrative example of the generation of the Genre-Rating Matrix.

An 18-dimensional binary vector is first constructed for each movie, with each bit set to 1 for genres associated with that movie and 0 otherwise, forming the genre mask matrix $M$. This mask is then element-wise multiplied by the user’s rating vector, replacing the 1-valued entries with the corresponding rating while preserving the 0-valued entries as unobserved indicators. Through this operation, a personalized two-dimensional Genre-Rating Matrix $G_u$ is generated for each user, allowing the model to simultaneously capture the distribution of user preferences across different semantic domains.

3.3. Weight-Shared Encoder and Bottleneck

The aligned two-dimensional tensor $G_u$ is processed through a deep encoder $E_{\varphi }$ that employs a weight-sharing mechanism across genre channels. Unlike conventional autoencoders that assign distinct weights to every input feature—often resulting in a large parameter space—DAERec-GCA applies the same shared weight matrix $W^{\left(l\right)}$ independently to each genre channel $j$ at layer $l$, as defined in Equation (11).

$$h_j^{\left(l\right)}=\sigma \left(W^{\left(l\right)}{h}_j^{\left(l-1\right)}+b^{\left(l\right)}\right),\hspace{1em}j=1,\dots ,g$$

(11)

By learning shared transformations across all $g$ channels, DAERec-GCA reduces the total number of trainable parameters and encourages the extraction of latent patterns that generalise across genre contexts. This design is particularly beneficial under sparse data conditions, as it allows the model to exploit patterns distributed across multiple channels during representation learning. Although each genre channel is processed independently in the forward pass, all channels share the same encoder–decoder parameters. Consequently, the shared weights are jointly learned from all genre channels during training, introducing an implicit coupling mechanism. The resulting transformations are therefore influenced by patterns distributed across genres and encoded within a common latent space, enabling cross-genre dependencies to be captured through shared parameterization.

3.4. Symmetrical Decoder and Reconstruction

To reconstruct the structured input and generate recommendation scores, the architecture employs a symmetrical decoder $D_{\theta }$ followed by a channel aggregation layer. This stage translates the compressed latent representations back into the original item space while preserving the genre-specific context captured by the encoder.

3.4.1. Symmetrical Reconstruction Path

The decoder mirrors the encoder’s structure to reconstruct the interaction tensor. The 64-neuron bottleneck representation $Z\in {\mathbb{R}}^{64\times g}$ is first projected back to a 128-neuron intermediate layer across all $g$ channels, and subsequently expanded to the original $m$-dimensional item space, yielding the reconstructed tensor $G_u^{\prime }\in R^{m\times g}$. As in the encoding phase, weight-sharing is applied across genre channels, ensuring that the reconstruction logic remains consistent with the feature extraction logic.

3.4.2. Channel Aggregation and Scoring Layer

The final stage converts the reconstructed genre-channel tensor into a one-dimensional item-level score vector. Since an item may belong to multiple genres, the reconstructed values across genre channels are combined into a single score using a global mean pooling operation, as given in Equation (12).

$$s_{u,i}=ChannelAggregation\left(G_{u,\left(i,\cdot \right)}^{\mathrm{\prime }}\right)={\displaystyle \frac{1}{g}}\sum _{j=1}^g{G}_{u,\left(i,j\right)}^{\mathrm{\prime }}$$

(12)

This aggregation step provides a simple and computationally efficient mechanism for combining the reconstructed signals from all genre channels into a unified item-level score. Although the forward computations are performed independently per channel, the aggregation ensures that the final prediction reflects the combined contribution of all genre-conditioned representations.

3.5. Objective Function and Optimization

The training of DAERec-GCA is formulated as a binary classification task, with the objective of distinguishing observed user interests from unobserved items. Given the extreme sparsity of recommendation datasets—where unobserved interactions vastly outnumber observed ones—a Weighted Binary Cross-Entropy (WBCE) loss function is employed.

To mitigate the impact of class imbalance, the total loss $\mathcal{L}$ is decomposed into two components: the loss over observed positive interactions ${\mathcal{L}}_{pos}$, and the loss over sampled negative interactions ${\mathcal{L}}_{neg}$, as defined in Equation (13).

$$\mathcal{L}\mathcal{ }=\mathcal{ }PW \cdot {\mathcal{L}}_{\mathrm{p}\mathrm{o}\mathrm{s}} + NW \cdot {\mathcal{L}}_{\mathrm{n}\mathrm{e}\mathrm{g}}$$

(13)

$${\mathcal{L}}_{pos}=-{\sum }_{\left(u,i\right)\in D^{+}}\log \left(\mathrm{sig}\left(s_{u,i}\right)\right)$$

(14)

$${\mathcal{L}}_{neg}=-{\displaystyle \sum _{\left(u,i\right)\in D^{-}}}\log \left(1-\mathrm{sig}\left(s_{u,i}\right)\right)$$

(15)

The loss components are defined in Equations (14) and (15), where $D^{+}$ denotes the set of observed positive interactions, $D^{-}$ the set of dynamically sampled negative interactions, and $\mathrm{sig}(\cdot )$ the sigmoid function that maps item scores $s_{u,i}$ to the probability range $\left(0, 1\right)$.

Three hyperparameters govern the training dynamics under class imbalance: Positive Weight (PW), Negative Weight (NW), and Negatives Per Positive (NPP). PW controls the contribution of positive interactions to the total objective, while NW scales the contribution of sampled negative interactions. NPP is not a direct loss coefficient; rather, it determines how many unobserved items are sampled per positive interaction during training.

Negative sampling is performed dynamically at the user level. For each user $u$, the negative candidate pool is defined as the complement of the user’s observed training items within the full item set. At each training step, up to $NPP\times n_u^{+}$ negative items are sampled uniformly at random without replacement from this pool, where $n_u^{+}$ denotes the number of positive interactions for user $u$, subject to the pool size. These sampled instances form the set $D^{-}$ used in the negative loss component.

Accordingly, PW increases the optimization emphasis on observed preferences, NW adjusts the penalty assigned to sampled negatives, and NPP controls the sampling density of the negative class. Together, these three factors provide a balanced and computationally efficient optimization scheme for sparse top-$N$ recommendation. Under this objective, the model parameters $\mathsf{\Theta }=\{\varphi , \theta \}$ are optimized using the RMSprop algorithm.

3.6. Top-N Recommendation Generation

Once the parameters $\varphi$ and $\theta$ are optimized, DAERec-GCA proceeds to the inference phase to generate personalized recommendations. For a given user $u$, the interaction vector $R_u$ is transformed into the genre-channel-aligned tensor $G_u$ and passed through the encoder–decoder architecture. The reconstructed tensor $G_u^{\mathrm{\prime }}$ is then aggregated across genre channels using Equation (12) to obtain an item-level score $s_{u,i}$ for each item $i$.

To produce the final top-$N$ recommendation list, a filtering and ranking procedure is applied. Let $I$ denote the complete item set and $I_u^{+}$ the set of items with which user $u$ has interacted during training. To ensure novelty, the candidate pool is restricted to unobserved items, defined by the set difference in Equation (16).

The generation of the final personalized recommendation list $L_u$ of size N is achieved by ranking the candidate items in descending order based on their predicted scores. Mathematically, $L_u$ is defined as a subset of $C_u$ where every selected item has a predicted score greater than or equal to any unselected candidate item according to Equation (17).

$$C_u=I\setminus I_u^{+}.$$

(16)

$$L_u\subset C_u,\hspace{1em}\left|L_u\right|=N,\hspace{1em}\mathrm{s}.\mathrm{t}.\hspace{1em}{s}_{u,i}\ge s_{u,j}\hspace{1em}\forall i\in L_u,\forall j\in C_u\setminus L_u$$

(17)

By satisfying this condition, the system effectively sorts the candidate space and extracts the top N items with the highest probabilities ($s_{u,i}$). Consequently, the resulting set $L_u$ corresponds exactly to the final top-N recommendation list generated for the user. This score-based ranking process not only guarantees that the user is presented with the most relevant, but it also directly aligns with the top-N evaluation protocols and metrics (e.g., Recall@K, NDCG@K) utilized in the subsequent experimental analysis.

The complete end-to-end training and inference procedure of DAERec-GCA is formally summarized in Algorithm 1.

Algorithm 1. End-to-End Pipeline of DAERec-GCA for top-N Recommendation

Inputs: User–item interactions $\mathcal{D}=\left\{\left(u, i, r_{ui}\right)\right\}$;   Item–genre mask matrix $M\in {\left\{0, 1\right\}}^{m\times g}$; Relevance thresholds $\tau$;   Negative sampling ratio NPP; Hyperparameters (PW, NW);   Epochs E; Batch size B; Cutoffs K; Random seeds S;

Output: Top-N List and performance metrics

For each seed s ∈ S:           For each run t:                 // Warm-start user-level split:                     For each user u:                           Split interactions into $D_u^{train}$ and $D_u^{test}$ using seed s                     Initialize deep autoencoder model Θ = {φ, θ} and optimizer                 // Training phase:                     For epoch = 1 to E:                           For each mini-batch of users $U_b$:                                 Construct dense rating matrix $R_b\in {\mathbb{R}}^{\left\{\left|U_b\right|\times m\right\} }from D^{train}$                                 Compute input tensor $G_b= R_b\odot M \in {\mathbb{R}}^{\left\{\left|U_b\right|\times m\times g\right\}}$ // 2D Alignment                                 Reconstruct $G_b^{\prime }\leftarrow Mode{l}_{\mathsf{\Theta }}\left(G_b\right)$                                  //  Forward Pass                                 Compute item logits ${\underset{\mathrm{Y}}{^}}_b=ChannelAggregation\left(G_b^{\prime }\right)\in {\mathbb{R}}^{\left\{\left|U_b\right|\times m\right\}}$                                 Identify positives $P_b= \mathbb{I}\left(R_b\ge \tau \right)$                                 Sample NPP $·|P_u$| unobserved items to form Nb                // Negative sampling                                 $\mathcal{L} = PW·WBCE\left({\underset{\mathrm{Y}}{^}}_b\left[P_b\right], 1\right)+ NW·WBCE\left({\underset{\mathrm{Y}}{^}}_b\left[N_b\right], 0\right)$      //Compute weighted loss                                 Update Θ via RMSprop                         End                     End                   //Evaluation phase (Top-N ranking):                       For each test user u:                                   Compute item logits ${\underset{\mathrm{y}}{^}}_u$ using $D_u^{train}$                                   Mask training items by setting their scores to −∞                                   Define relevant test items: $I_u^{+}=\{ i | \left(u, i\right)\in D_u^{test}, r_{u}i\ge \tau \}$                                   For each K ∈ K:                                           Recommend top-K items by descending ${\underset{\mathrm{y}}{^}}_u$                                           Compute Precision@K, Recall@K, F1@K, HR@K, NDCG@K                                   End                     End

Algorithm 1 encapsulates the complete end-to-end pipeline of DAERec-GCA, integrating genre-channel alignment, the shared-weight autoencoder architecture, and the weighted loss function into a unified and computationally efficient procedure.

3.7. Computational Complexity Analysis

This section provides a theoretical analysis of the computational complexity of DAERec-GCA, focusing on the dominant parameter and arithmetic costs introduced by the genre-channel-aligned representation (Equation (10)) and the shared encoder–decoder design. Let $h$ denote the hidden dimension of the encoder–decoder backbone.

Because encoder–decoder weights are shared across genre channels, the trainable parameter count does not grow linearly with the number of channels. Instead, the dominant parameter complexity $P_{\mathrm{DAERec}\text{-}\mathrm{GCA}}$, given in Equation (18), is determined solely by the shared item-to-hidden and hidden-to-item transformations. The forward pass, however, is applied across all $g$ channels, yielding an inference cost $C_{\mathrm{infer}}$ that scales with both the item dimension and the number of channels, as expressed in Equation (19). For $E$ training epochs and $k$ users, the overall training complexity $C_{\mathrm{train}}$ is given in Equation (20)

$$P_{\mathrm{DAERec}\text{-}\mathrm{GCA}}=\mathsf{\Theta }\left(mh\right)$$

(18)

$$C_{\mathrm{infer}}=O\left(gmh\right)$$

(19)

$$C_{\mathrm{train}}=O\left(Ekghm\right)$$

(20)

This complexity structure highlights the key trade-off of DAERec-GCA: the model preserves a structured, genre-aware formulation and performs channel-wise computation across all $g$ channels under shared parameterization, while avoiding the substantial parameter inflation of a naively flattened genre-expanded design. The primary computational advantage therefore lies in maintaining controlled parameter growth, rather than in reducing the raw arithmetic cost of multi-channel processing.

4. Results

This section presents a comprehensive empirical evaluation of DAERec-GCA. First, the results of a stagewise hyperparameter optimization procedure conducted under a hold-out validation setting are reported to identify the most suitable architectural and training configuration. A structured ablation study then isolates and quantifies the contribution of the proposed genre-channel-aligned formulation relative to five baseline variants. Finally, the top-$N$ ranking performance of the optimized model is evaluated under a warm-start five-fold cross-validation protocol, with leave-one-out results reported as a complementary evaluation setting.

4.1. Hyperparameter Optimization of DAERec-GCA

A stagewise hyperparameter optimization strategy was employed to identify an effective configuration for DAERec-GCA. This hierarchical approach is grounded in coordinate descent principles [26], decomposing the search into sequential stages in which a specific group of parameters is optimized while all previously identified best values are held fixed [27]. All experiments were conducted on the MovieLens-100K dataset using an 80:20 hold-out split, with the same set of random seeds $S=\{42; 999; \mathrm{13,579}; \mathrm{414,243}; \mathrm{987,654}\}$ applied across all configurations, yielding five independent repetitions per setting for statistical robustness. For this evaluation, users were required to have at least five historical ratings and at least one positive item in the test set.

NDCG@K was adopted as the primary evaluation metric, as it provides a position-aware measure of ranking quality. The optimization was executed in four sequential stages, focusing respectively on network architecture, optimizer and activation function, learning rate and weight decay, and loss function weighting. The results, illustrated in Figure 4, indicate that each stage contributed meaningfully to the model’s final ranking performance.

Figure 4. (a) Performance comparison across different model architectures based on NDCG@10, where the best-performing architecture (A5_2) is highlighted with a darker shade. (b) Heatmap analysis of Stage 2 hyperparameter sweep showing the interaction between various optimization algorithms and activation functions. (c) Heatmap analysis Learning Rate and Weight Decay Tuning of Stage 3. (d) Comparative Analysis for Stage 4 Loss Factor Sensitivity according to PW, NW and NPP, asterisk indicates the best-performing hyperparameter combination.

4.1.1. Stage 1: Network Architecture Selection

The first stage focused on determining the optimal model capacity. Thirteen distinct architectures with varying depths and widths were evaluated, as listed in Table 4, to identify the hidden-layer configuration that most effectively captures genre-based features.

Table 4. Deep autoencoder network architecture names used in the experimental study.

Architecture Name	Layer Number	Neuron Group Number in Each Layer
A5_1	5	1682-64-4-64-1682
A5_2	5	1682-128-64-128-1682
A5_3	5	1682-80-40-80-1682
A5_4	5	1682-20-10-20-1682
A7_1	7	1682-256-64-16-64-256-1682
A7_2	7	1682-128-32-8-32-128-1682
A7_3	7	1682-64-16-4-16-64-1682
A7_4	7	1682-40-20-10-20-40-1682
A7_5	7	1682-128-64-4-64-128-1682
A9_1	9	1682-256-64-16-4-16-64-256-1682
A9_2	9	1682-128-64-32-8-32-64-128-1682
A9_3	9	1682-80-40-20-10-20-40-80-1682
A9_4	9	1682-256-128-64-4-16-64-256-1682

As shown in Figure 4a, architecture A5_2, achieving a peak NDCG@10 of $0.2720\pm 0.0042$, was selected for all subsequent stages as it provides an effective balance between representational capacity and model complexity.

4.1.2. Stage 2: Selection of Optimizer and Activation Function

With the architecture fixed, the interaction between four optimizers and seven activation functions was explored. As shown in Figure 4b, the combination of RMSprop and CELU yielded the highest NDCG@10 of $0.2815\pm 0.0041$ and was carried forward as the baseline for Stage 3.

4.1.3. Stage 3: Learning Rate and Weight Decay Tuning

The grid search over learning rate (LR) and weight decay (WD) yielded the most substantial performance gain across all stages. As shown in Figure 4c, the optimal configuration LR = ${10}^{-3}$, WD = ${10}^{-4}$ achieved a peak NDCG@10 of $0.3234\pm 0.0065$.

4.1.4. Stage 4: Loss Function Weighting and Negative Sampling

The final stage conducted a sensitivity analysis over the loss-weighting parameters: Positive Weight (PW), Negatives Per Positive (NPP), and Negative Weight (NW). As shown in Figure 4d, the left panel (PW = 1.0) identifies the optimal subspace at NPP = 2 and NW = 1.0, where the highest NDCG@10 of 0.3268 ± 0.0062 was recorded. The right panel (PW = 2.0) demonstrates a consistent performance decrease across all NPP and NW combinations when the positive weight is doubled, suggesting that over-weighting positive interactions leads to suboptimal gradient balancing within the DAERec-GCA architecture. These results confirm that balanced penalties for positive and negative samples, combined with moderate negative sampling, yield the most robust ranking performance.

Table 5 summarizes the full stagewise optimization results. The best configuration—architecture A5_2, RMSprop optimizer, CELU activation, LR = ${10}^{-3}$, WD = ${10}^{-4}$, PW = 1.0, NPP = 2, NW = 1.0—achieved an NDCG@10 of 0.3268 and was adopted as the reference model for all subsequent experiments. The resulting architecture for the ML-100K dataset is depicted in Figure 5.

Table 5. Stagewise optimization protocol and search space.

Stage	Targeted Parameters	Constants (Baseline)	Best Selection
Stage 1	Network Architecture	Adam, ELU, LR: 10−3, WD: 10−3, PW: 1.0, NPP: 2, NW: 0.7	A5_2
Stage 2	Optimizer & Activation	Arch: A5_2, LR: 10−3, WD: 10−3, PW: 1.0, NPP: 2, NW: 0.7	RMSprop & CELU
Stage 3	LR & WD	Arch: A5_2, Opt: RMSprop, Act: CELU, PW: 1.0, NPP: 2, NW: 0.7	LR: 10−3, WD: 10−4
Stage 4	Loss Factors (PW, NPP, NW)	Arch: A5_2, Opt: RMSprop, Act: CELU, LR: 10−3, WD: 10−4	PW: 1, NPP: 2, NW: 1

Figure 5. Architecture of DAERec-GCA for ML-100K Dataset.

Figure 5 illustrates the tensor dimensions and layer transitions for the ML-100K configuration: the input matrix $G\in {\mathbb{R}}^{1682\times 18}$ is progressively compressed into a latent representation $Z\in {\mathbb{R}}^{64\times 18}$ before being reconstructed back to its original dimensions.

4.2. Ablation Study

To empirically validate the core architectural and representation choices of DAERec-GCA, a series of controlled ablation experiments was conducted. Each variant systematically isolates the effect of a specific design component, enabling a direct assessment of its individual contribution to overall performance. The ablation analysis targets two critical dimensions: the presence and structural role of genre information, and the effect of input encoding dimensionality.

Genre-Augmented vs. Genre-Independent Inputs (ROnly): This variant investigates the isolated contribution of genre information to recommendation performance. Genre masking is entirely disabled: rather than constructing the aligned tensor G_u = R_u ⊙ M, the rating vector R_u is replicated uniformly across all g genre channels, yielding a homogeneous m × g tensor in which every channel carries an identical copy of the interaction signal. Because the model architecture, weights, and all hyperparameters remain unchanged, any performance differential between ROnly and DAERec-GCA is attributable solely to the presence or absence of genre-discriminative content within the aligned channels, directly quantifying the informational value of genre augmentation under sparse collaborative data.

Two-Dimensional vs. Flattened Input Encoding (Flat1D): This variant examines whether the two-dimensional structural organization of the genre-channel representation is itself essential for learning high-quality latent patterns, independent of the genre information it carries. The genre-channel tensor G_u = R_u ⊙ M is computed identically to DAERec-GCA but is subsequently flattened into a one-dimensional vector of dimension m × g before being fed into a standard fully connected autoencoder. This flattening operation has two critical consequences: it dismantles the semantic alignment between rating values and their corresponding genre positions, and it disables the weight-sharing mechanism, expanding the first-layer parameter count from O(m·h) to O(m·g·h)—an approximately 18-fold increase for g = 18. The Flat1D variant therefore isolates whether the performance advantage of DAERec-GCA stems from the genre information content alone or is further amplified by the structure-preserving weight-sharing design.

Rating-Weighted Genre Profile Concatenation (GenreProfile): This variant represents a practical 1D alternative to 2D structural alignment, in which genre information is introduced as a compact user-level summary statistic rather than as a per-item channel structure. For each user u, a g-dimensional genre profile p_u is computed as the rating-weighted mean of the genre mask vectors of all rated items: $p_{u,j}= \sum _i\left(r_{u,i} · M_i\right) /\sum _i{r}_{u,i}$, j = 1, …, g. This profile is projected through a linear layer to a d-dimensional embedding (d = 32) and concatenated with R_u, forming an (m + d)-dimensional input to a flat autoencoder with output dimension m. The GenreProfile variant tests whether a lightweight aggregated genre summary—which discards per-item genre resolution in favor of compact user-level statistics—provides a sufficient substitute for the fine-grained structural alignment of DAERec-GCA.

Learned Genre Embedding Concatenation (GenreEmbed): This variant extends the genre profile approach by replacing the hand-crafted rating-weighted summary with fully end-to-end learnable genre representations. A trainable embedding matrix E ∈ ℝ^{g×d} is optimized jointly with the autoencoder parameters. Item-level genre embeddings are obtained as the genre-count-normalized projection of the binary mask vectors, and a user-level embedding z_u ∈ ℝ^d is derived as the interaction-weighted average of these item embeddings. The resulting z_u is concatenated with R_u and processed by a flat autoencoder structurally identical to the GenreProfile variant. This variant thereby directly tests whether task-specific learnable genre representations offer a measurable advantage over hand-crafted genre statistics within the 1D autoencoder framework, particularly under the sparse interaction conditions characteristic of the evaluated datasets.

Bottleneck Genre Gating (GenreGated): This variant investigates an alternative integration point for genre information, introducing genre conditioning at the latent space level rather than at the input. The encoder follows a standard flat architecture that maps R_u to a b-dimensional bottleneck representation h_u. In parallel, the rating-weighted genre profile p_u is projected to the same dimension via a dedicated linear layer and passed through a sigmoid activation, yielding a genre-conditioned gate vector γ_u = σ(W_g · $p_u$) ∈ (0, 1)^b. The gated bottleneck is then obtained through element-wise multiplication $\widetilde{h_u}$ = hᵤ ⊙ γᵤ and passed to a symmetric decoder. This late-fusion mechanism allows the genre signal to selectively suppress or amplify individual latent dimensions after the encoder has already compressed the full rating signal, providing a differentiable attention-like modulation over the latent space. The GenreGated variant simultaneously tests two hypotheses: whether bottleneck-level genre modulation is preferable to input-level genre enrichment (against GenreProfile and GenreEmbed), and whether explicit sigmoid gating can approximate the implicit regularization achieved through the 2D weight-sharing mechanism of DAERec-GCA.

All experiments were conducted on the ML-100K dataset using a five-fold cross-validation protocol repeated five times to ensure statistical robustness and reproducibility. Only users with at least five interactions and at least one relevant item in the test set were included in the evaluation. Each model was trained for up to 200 epochs under identical experimental settings. Mean performance, standard deviation, and relative changes with respect to DAERec-GCA are reported on the test sets at cutoff values K ∈ {10, 20, 50, 100} in Table 6, across Precision@K, Recall@K, F1@K, HR@K, and NDCG@K.

Table 6. Ablation study results on the ML-100K dataset comparing DAERec-GCA with simplified and alternative genre-aware variants across top-N ranking metrics.

K	Model	Precision@K	Recall@K	F1@K	HR@K	NDCG@K
10	DAERec-GCA	0.2181 ± 0.0053	0.2509 ± 0.0084	0.1926 ± 0.0043	0.8334 ± 0.0121	0.3012 ± 0.0087
	ROnly	0.1997 ± 0.0046 (↓ 8.44%)	0.2377 ± 0.0067 (↓ 5.26%)	0.1790 ± 0.0035 (↓ 7.06%)	0.8194 ± 0.0069 (↓ 1.68%)	0.2750 ± 0.0055 (↓ 8.70%)
	Flat1D	0.1862 ± 0.0090 (↓ 14.63%)	0.2293 ± 0.0104 (↓ 8.61%)	0.1709 ± 0.0074 (↓ 11.27%)	0.8116 ± 0.0169 (↓ 2.62%)	0.2624 ± 0.0128 (↓ 12.88%)
	GenreProfile	0.1987 ± 0.0037 (↓ 8.90%)	0.2354 ± 0.0063 (↓ 6.18%)	0.1779 ± 0.0034 (↓ 7.63%)	0.8191 ± 0.0108 (↓ 1.72%)	0.2742 ± 0.0062 (↓ 8.96%)
	GenreEmbed	0.1989 ± 0.0049 (↓ 8.80%)	0.2352 ± 0.0066 (↓ 6.26%)	0.1777 ± 0.0038 (↓ 7.74%)	0.8165 ± 0.0107 (↓ 2.03%)	0.2737 ± 0.0077 (↓ 9.13%)
	GenreGated	0.2023 ± 0.0047 (↓ 7.24%)	0.2402 ± 0.0080 (↓ 4.26%)	0.1811 ± 0.0041 (↓ 5.97%)	0.8208 ± 0.0129 (↓ 1.51%)	0.2783 ± 0.0068 (↓ 7.60%)
20	DAERec-GCA	0.1734 ± 0.0038	0.3742 ± 0.0080	0.2002 ± 0.0037	0.9136 ± 0.0085	0.3267 ± 0.0079
	ROnly	0.1599 ± 0.0036 (↓ 7.79%)	0.3564 ± 0.0067 (↓ 4.76%)	0.1867 ± 0.0037 (↓ 6.74%)	0.9079 ± 0.0080 (↓ 0.62%)	0.3021 ± 0.0055 (↓ 7.53%)
	Flat1D	0.1481 ± 0.0061 (↓ 14.59%)	0.3432 ± 0.0115 (↓ 8.28%)	0.1762 ± 0.0064 (↓ 11.99%)	0.9036 ± 0.0093 (↓ 1.09%)	0.2893 ± 0.0120 (↓ 11.45%)
	GenreProfile	0.1590 ± 0.0026 (↓ 8.30%)	0.3532 ± 0.0065 (↓ 5.61%)	0.1855 ± 0.0030 (↓ 7.34%)	0.9065 ± 0.0090 (↓ 0.78%)	0.3005 ± 0.0053 (↓ 8.02%)
	GenreEmbed	0.1594 ± 0.0038 (↓ 8.07%)	0.3546 ± 0.0079 (↓ 5.24%)	0.1858 ± 0.0039 (↓ 7.19%)	0.9055 ± 0.0099 (↓ 0.89%)	0.3007 ± 0.0073 (↓ 7.96%)
	GenreGated	0.1626 ± 0.0031 (↓ 6.23%)	0.3621 ± 0.0068 (↓ 3.23%)	0.1896 ± 0.0033 (↓ 5.29%)	0.9095 ± 0.0095 (↓ 0.45%)	0.3060 ± 0.0060 (↓ 6.34%)
50	DAERec-GCA	0.1162 ± 0.0017	0.5763 ± 0.0073	0.1726 ± 0.0022	0.9699 ± 0.0055	0.3949 ± 0.0066
	ROnly	0.1078 ± 0.0018 (↓ 7.23%)	0.5467 ± 0.0075 (↓ 5.14%)	0.1609 ± 0.0023 (↓ 6.78%)	0.9658 ± 0.0052 (↓ 0.42%)	0.3672 ± 0.0047 (↓ 7.01%)
	Flat1D	0.1001 ± 0.0033 (↓ 13.86%)	0.5303 ± 0.0107 (↓ 7.98%)	0.1511 ± 0.0046 (↓ 12.46%)	0.9661 ± 0.0052 (↓ 0.39%)	0.3541 ± 0.0116 (↓ 10.33%)
	GenreProfile	0.1077 ± 0.0018 (↓ 7.31%)	0.5463 ± 0.0066 (↓ 5.21%)	0.1608 ± 0.0024 (↓ 6.84%)	0.9676 ± 0.0058 (↓ 0.24%)	0.3664 ± 0.0053 (↓ 7.22%)
	GenreEmbed	0.1077 ± 0.0022 (↓ 7.31%)	0.5472 ± 0.0086 (↓ 5.05%)	0.1608 ± 0.0029 (↓ 6.84%)	0.9665 ± 0.0062 (↓ 0.35%)	0.3665 ± 0.0067 (↓ 7.19%)
	GenreGated	0.1104 ± 0.0019 (↓ 4.99%)	0.5580 ± 0.0076 (↓ 3.18%)	0.1647 ± 0.0026 (↓ 4.58%)	0.9678 ± 0.0062 (↓ 0.22%)	0.3733 ± 0.0060 (↓ 5.47%)
100	DAERec-GCA	0.0784 ± 0.0012	0.7284 ± 0.0069	0.1316 ± 0.0018	0.9874 ± 0.0029	0.4499 ± 0.0065
	ROnly	0.0734 ± 0.0010 (↓ 6.38%)	0.6980 ± 0.0067 (↓ 4.17%)	0.1236 ± 0.0015 (↓ 6.08%)	0.9860 ± 0.0034 (↓ 0.14%)	0.4212 ± 0.0046 (↓ 6.38%)
	Flat1D	0.0688 ± 0.0017 (↓ 12.24%)	0.6774 ± 0.0110 (↓ 7.00%)	0.1164 ± 0.0028 (↓ 11.55%)	0.9860 ± 0.0039 (↓ 0.14%)	0.4065 ± 0.0113 (↓ 9.65%)
	GenreProfile	0.0734 ± 0.0011 (↓ 6.38%)	0.6984 ± 0.0049 (↓ 4.12%)	0.1237 ± 0.0017 (↓ 6.00%)	0.9873 ± 0.0028 (↓ 0.01%)	0.4207 ± 0.0049 (↓ 6.49%)
	GenreEmbed	0.0734 ± 0.0012 (↓ 6.38%)	0.6983 ± 0.0068 (↓ 4.13%)	0.1237 ± 0.0020 (↓ 6.00%)	0.9875 ± 0.0039 (↑ 0.01%)	0.4206 ± 0.0062 (↓ 6.51%)
	GenreGated	0.0750 ± 0.0011 (↓ 4.34%)	0.7102 ± 0.0052 (↓ 2.50%)	0.1262 ± 0.0017 (↓ 4.10%)	0.9876 ± 0.0038 (↑ 0.02%)	0.4278 ± 0.0054 (↓ 4.91%)

Bold indicates the best result; italic indicates the second-best result. The arrows (↓/↑) denote the relative change (%) compared with the complete DAERec-GCA model.

Table 6 shows that DAERec-GCA achieves the best performance across all cutoff values. Removing genre information (ROnly) leads to a consistent decrease in performance, while flattening the two-dimensional user–item–genre representation (Flat1D) results in the largest degradation, particularly for NDCG@K and F1@K. The genre-aware alternatives (GenreProfile, GenreEmbed, and GenreGated) perform better than the simpler ablations but remain below DAERec-GCA at all K values. These results suggest that both the use of genre information and its structured integration contribute to the observed gains.

Figure 6 is consistent with these findings, showing higher median NDCG@K values for DAERec-GCA across all cutoff levels, with GenreGated being the closest competitor. To verify whether these differences are statistically significant, a paired one-sided Wilcoxon signed-rank test was conducted with the null hypothesis $H_0$: ${\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}}_{\mathrm{DAERec}\text{-}\mathrm{GCA}}$ $\le {\mathrm{N}\mathrm{D}\mathrm{C}\mathrm{G}}_{\mathrm{Ablation}}$ for each variant. All comparisons were performed on paired results obtained under identical seed–fold configurations, ensuring a controlled evaluation. For all K ∈ {10, 20, 50, 100}, the test consistently rejected $H_0$, yielding p-values below $3\times {10}^{-8}$ for ROnly and Flat1D, and $5.96\times {10}^{-8}$ for GenreProfile, GenreEmbed, and GenreGated. These results confirm that the improvements observed are statistically significant and unlikely to be attributable to random variation.

Figure 6. Box plots of NDCG@K values for DAERec-GCA and its ablation variants across K levels: (a) K = 10, (b) K = 20, (c) K = 50, and (d) K = 100. Circles indicate outliers.

4.3. Recommendation Evaluation Results

To comprehensively assess the effectiveness and generalization capability of DAERec-GCA, experiments were conducted across datasets of varying scale and sparsity. Each dataset was evaluated using five independent repetitions of five-fold cross-validation, yielding 25 complete training and testing runs. All experiments were run for up to 200 epochs for ML-100K, ML-1M, and ML-10M, using the optimal hyperparameters identified in Section 4.1. The same set of random seeds was applied across all runs to preserve methodological integrity and control for stochastic variation. Results are summarized in Table 7.

Table 7. Performance summary of the proposed DAERec-GCA model across datasets and K values.

	K	Precision@K Mean ± Std [Min–Max]	Recall@K Mean ± Std [Min–Max]	F1@K Mean ± Std [Min–Max]	HitRatio@K Mean ± Std [Min–Max]	NDCG@K Mean ± Std [Min–Max]
100K	10	0.2181 ± 0.0053 [0.2087–0.2278]	0.2509 ± 0.0084 [0.2310–0.2685]	0.1926 ± 0.0043 [0.1872–0.2008]	0.8334 ± 0.0121 [0.8112–0.8573]	0.3012 ± 0.0087 [0.2867–0.3194]
	20	0.1734 ± 0.0038 [0.1653–0.1803]	0.3742 ± 0.0080 [0.3595–0.3876]	0.2002 ± 0.0037 [0.1927–0.2079]	0.9136 ± 0.0085 [0.8994–0.9305]	0.3267 ± 0.0079 [0.3144–0.3414]
	50	0.1162 ± 0.0017 [0.1128–0.1194]	0.5763 ± 0.0073 [0.5615–0.5917]	0.1726 ± 0.0022 [0.1688–0.1769]	0.9699 ± 0.0055 [0.9593–0.9829]	0.3949 ± 0.0066 [0.3842–0.4073]
	100	0.0784 ± 0.0012 [0.0755–0.0803]	0.7284 ± 0.0069 [0.7154–0.7477]	0.1316 ± 0.0018 [0.1272–0.1348]	0.9874 ± 0.0029 [0.9829–0.9936]	0.4499 ± 0.0065 [0.4410–0.4629]
1M	10	0.2473 ± 0.0047 [0.2338–0.2581]	0.1804 ± 0.0039 [0.1709–0.1877]	0.1717 ± 0.0035 [0.1619–0.1808]	0.8352 ± 0.0091 [0.8117–0.8567]	0.3013 ± 0.0062 [0.2828–0.3159]
	20	0.1997 ± 0.0034 [0.1904–0.2058]	0.2748 ± 0.0047 [0.2644–0.2809]	0.1902 ± 0.0033 [0.1817–0.1966]	0.9068 ± 0.0068 [0.8944–0.9251]	0.3054 ± 0.0057 [0.2884–0.3179]
	50	0.1385 ± 0.0019 [0.1345–0.1421]	0.4406 ± 0.0046 [0.4307–0.4464]	0.1799 ± 0.0024 [0.1750–0.1849]	0.9594 ± 0.0035 [0.9521–0.9679]	0.3488 ± 0.0053 [0.3342–0.3614]
	100	0.0975 ± 0.0011 [0.0957–0.0996]	0.5852 ± 0.0041 [0.5776–0.5927]	0.1490 ± 0.0016 [0.1461–0.1522]	0.9798 ± 0.0021 [0.9757–0.9839]	0.4010 ± 0.0051 [0.3877–0.4131]
10M	10	0.2414 ± 0.0054 [0.2295–0.2516]	0.2232 ± 0.0074 [0.2014–0.2326]	0.1811 ± 0.0052 [0.1671–0.1898]	0.7880 ± 0.0118 [0.7538–0.8041]	0.3166 ± 0.0078 [0.2958–0.3315]
	20	0.1901 ± 0.0040 [0.1811–0.1972]	0.3281 ± 0.0093 [0.2984–0.3412]	0.1884 ± 0.0049 [0.1757–0.1967]	0.8625 ± 0.0101 [0.8336–0.8759]	0.3282 ± 0.0083 [0.3041–0.3435]
	50	0.1264 ± 0.0023 [0.1210–0.1302]	0.4914 ± 0.0105 [0.4518–0.5074]	0.1650 ± 0.0034 [0.1562–0.1706]	0.9279 ± 0.0077 [0.9058–0.9378]	0.3682 ± 0.0088 [0.3401–0.3843]
	100	0.0865 ± 0.0014 [0.0833–0.0885]	0.6215 ± 0.0110 [0.5786–0.6358]	0.1311 ± 0.0023 [0.1256–0.1344]	0.9591 ± 0.0059 [0.9422–0.9666]	0.4100 ± 0.0087 [0.3808–0.4260]

To complement the quantitative findings in Table 7, Figure 7 presents box plots of NDCG@K scores across datasets and cutoff levels, providing a visual assessment of distributional characteristics and ranking stability.

Figure 7. Box plots of NDCG@K scores for the DAERec-GCA model across MovieLens 100K, 1M, and 10M datasets at different cutoff values: (a) K = 10, (b) K = 20, (c) K = 50, and (d) K = 100.

Figure 8 presents mean training loss curves with standard deviation bands from 25 independent runs on all three datasets. Across all settings, the optimization trajectories exhibit stable and monotonic convergence, with a pronounced loss reduction in the early epochs followed by gradual stabilization. The narrow dispersion bands indicate low variability across folds and random seeds, consistent with reliable training behavior. Although final loss values differ across datasets, the overall convergence profiles remain similar, supporting the scalability of the proposed architecture. The absence of oscillations or divergence throughout the 200-epoch training horizon further suggests that the genre-channel alignment and weight-sharing design provide effective implicit regularization.

Figure 8. Mean training loss convergence curves of the DAERec-GCA model for ML-100K, ML-1M, and ML-10M datasets.

In addition to the analyses above, DAERec-GCA was compared against a diverse set of representative baseline methods spanning multiple recommendation paradigms: linear models (EASE [28] and SLIMElastic [29]), a neighborhood-based method (ItemKNN [30]), a pairwise ranking model (BPR [31]), a neural collaborative filtering model (NeuMF [32]), and generative autoencoder-based models (MultiVAE [33] and CDAE [34]).

All methods were evaluated under a leave-one-out (LOO) protocol. For each user, the most recent relevant interaction was held out as the test instance, while the second most recent was reserved for validation (early stopping); the remaining interactions were used for training. Note that the validation item is used solely for model selection and does not constitute a test instance; the evaluation therefore follows a standard leave-one-out protocol. For both validation and test evaluation, user-specific candidate sets were constructed from one ground-truth positive item and 100 randomly sampled unseen items, with the same candidate sets used across all methods to ensure a controlled comparison. Relevance was defined using a threshold of 3.5, and a user-level k-core constraint of 5 interactions was applied during preprocessing. Evaluation was conducted at cutoff values K ∈ {5, 10, 20} using HR@K and NDCG@K. Trainable models were optimized for up to 200 epochs with early stopping based on validation NDCG@10 and a patience of 30 epochs. The learning rate was fixed at 1 × 10⁻³ across trainable methods, while regularization and training configurations followed the native implementation of each model. Specifically, DAERec-GCA used a shared-weight autoencoder with hidden dimensions (128, 64, 128), CELU activation, batch size of 256 users, weight decay of 1 × 10⁻⁴, and a weighted binary cross-entropy objective with positive weight = 1.0, negative weight = 1.0, and 2 sampled negatives per positive interaction. BPR was trained with embedding size 128, batch size 8192, and weight decay 1 × 10⁻⁶. NeuMF used embedding size 64, MLP dimensions (128, 64), batch size 8192, weight decay 1 × 10⁻⁶, and 3 negatives per positive instance. MultiVAE was configured with hidden dimension 600, latent dimension 200, dropout 0.5, batch size 256, anneal cap 0.2, and 200,000 annealing steps, whereas CDAE used hidden dimension 200, corruption rate 0.3, batch size 256, and weight decay 1 × 10⁻⁵. Among non-neural baselines, EASE was used with λ = 300, ItemKNN with topK = 200 and shrinkage = 100, and SLIMElastic with α = 1 × 10⁻², l1_ratio = 1 × 10⁻⁴, topK = 200, max_iter = 200, and tolerance = 1 × 10⁻⁴. All experiments were conducted using a fixed random seed of 42 to ensure deterministic behavior in data splitting, candidate generation, and model initialization. The comparative results are reported in Table 8.

Table 8. Performance comparison of DAERec-GCA and baseline methods on MovieLens datasets under the LOO protocol, reported in terms of HR@K and NDCG@K for K = 10 and 20.

	100K	1M	10M	100K	1M	10M	100K	1M	10M	100K	1M	10M
	NDCG@10			HR@10			NDCG@20			HR@20
DAERec-GCA	0.4222	0.4337	0.6253	0.6879	0.7105	0.8777	0.4617	0.4703	0.6442	0.8439	0.8541	0.9516
MultiVAE [33]	0.4209	0.4473	0.6654	0.6985	0.7295	0.9043	0.4578	0.4810	0.6807	0.8450	0.8619	0.9642
BPR [31]	0.4203	0.4533	0.5795	0.7028	0.7386	0.8526	0.4606	0.4884	0.6031	0.8620	0.8764	0.9447
EASE [28]	0.4170	0.4316	0.6165	0.6730	0.6894	0.8240	0.4552	0.4626	0.6302	0.8100	0.8466	0.8779
NeuMF [32]	0.4056	0.4260	0.6219	0.6667	0.7027	0.8824	0.4401	0.4636	0.6402	0.7813	0.8503	0.9540
SLIMElastic [29]	0.3897	0.4255	0.6309	0.6253	0.6846	0.8691	0.4364	0.4603	0.6472	0.8036	0.8446	0.9331
CDAE [34]	0.4154	0.3978	0.4589	0.6879	0.6581	0.7092	0.4428	0.4350	0.4947	0.8270	0.8049	0.8502
ItemKNN [30]	0.3078	0.3291	0.5432	0.5255	0.5808	0.8352	0.4014	0.3769	0.5641	0.7251	0.7707	0.9173

Bold indicates the best result.

DAERec-GCA achieves the highest NDCG values on ML-100K at both cutoff levels. On ML-1M and ML-10M, the top results are obtained by BPR and MultiVAE; however, DAERec-GCA consistently ranks among the leading methods across both HR and NDCG, demonstrating competitive performance across different data scales. To examine the relative ordering of the methods more directly, an average-rank analysis based on NDCG@10 is presented in Table 9.

Table 9. Ranking of the compared methods based on NDCG@10 across the MovieLens datasets.

	ML-100K	ML-1M	ML-10M	Avg. Rank *
MultiVAE [33]	2	2	1	1.67
DAERec-GCA	1	3	3	2.33
BPR [31]	3	1	6	3.33
EASE [28]	5	4	5	4.33
NeuMF [32]	6	5	4	5
SLIMElastic [29]	7	6	2	5
CDAE [34]	4	7	8	6.67
ItemKNN [30]	8	8	7	7.67

* Lower rank values indicate better performance and bold indicates the best result.

Table 9 shows that MultiVAE achieves the lowest average rank, followed by DAERec-GCA and BPR. The proposed model consistently places within the top three across all datasets, indicating stable and competitive performance without dominating uniformly across all settings.

A combined rank analysis was also performed by jointly considering all dataset–metric pairs from Table 8. Each model was ranked separately for every dataset–metric combination, and the overall ranking was obtained by averaging these individual ranks. The combined average ranks are presented in Table 10, and the corresponding critical difference (CD) diagram is shown in Figure 9 to visualize statistical groupings among the methods.

Table 10. Combined average ranks of the compared methods obtained by aggregating rankings across all dataset–metric pairs in Table 8.

Model	MultiVAE	BPR	DAERec-GCA	NeuMF	EASE	SLIMElastic	CDAE	ItemKNN
Rank	1.75	2.67	2.71	4.5	5.08	5.33	6.46	7.5

Figure 9. Critical difference (CD) diagram based on the combined average ranks.

Table 10 shows that MultiVAE achieves the lowest combined rank, followed closely by BPR and DAERec-GCA. As illustrated in Figure 9, methods connected by a horizontal bar do not exhibit statistically significant differences according to the Nemenyi test. The leading methods—MultiVAE, BPR, and DAERec-GCA—form a statistically indistinct group, while lower-ranked methods are more clearly separated. These results confirm that DAERec-GCA maintains competitive performance within the top-performing group across datasets and evaluation metrics.

5. Discussion

The experimental evaluation of DAERec-GCA consistently supports the efficacy of integrating side information through a genre-channel-aligned, weight-sharing design. The results validate the central hypothesis of this study: preserving the structural correspondence between user ratings and item genres enhances representation learning. Regarding experimental scope, this study deliberately focuses on vertical scalability within the well-standardized MovieLens benchmark. Rather than pursuing evaluation across heterogeneous domains such as e-commerce or point-of-interest recommendation, this controlled setting enables an isolation of the mathematical and architectural impact of the proposed two-dimensional structural alignment relative to conventional one-dimensional flattening. The vertical scaling results further demonstrate that the model does not merely memorize patterns in smaller datasets but preserves its structural learning behavior as data volume increases. The following subsections synthesize findings across three complementary dimensions: structural ablation, sparsity resilience, and computational scalability.

5.1. Structural Advantages of 2D Genre-Channel Alignment

The ablation study yields two critical insights. First, the performance gap between ROnly and DAERec-GCA confirms that genre information is necessary for mitigating data sparsity when collaborative overlap is limited. Second, the extended ablation results demonstrate that the structural manner in which genre information is embedded is as important as its mere presence. Three genre-aware flat autoencoder variants—GenreProfile, GenreEmbed, and GenreGated—were designed to test whether access to identical genre content is sufficient to replicate DAERec-GCA’s performance. Despite having access to the same genre information, all three consistently underperform DAERec-GCA across all metrics and cutoff values on ML-100K. Even GenreGated—the closest competitor, which introduces genre conditioning via a sigmoid gate at the bottleneck—yields an NDCG@10 degradation of 7.6%. These findings demonstrate that the performance gains arise not from genre content alone but specifically from the two-dimensional channel-aligned, weight-sharing design of DAERec-GCA. Traditional one-dimensional concatenation approaches may weaken the structural correspondence between user preferences and item-genre associations, potentially causing information dilution and undesirable parameter inflation in the hidden layers. By contrast, by treating each genre as an independent semantic channel, DAERec-GCA introduces a form of structural regularization: the weight-sharing mechanism enforces consistent transformations across all genre channels, promoting the learning of generalizable patterns.

5.2. Resilience to Data Sparsity

To quantify robustness under sparse supervision, a controlled train-side sparsity analysis was performed by reducing the number of observed training interactions per user to retention ratios $\rho \in \left\{\mathrm{0.25,0.50,0.75,1.00}\right\}$, while keeping the test set fixed across all $\left(\mathrm{seed},\mathrm{fold}\right)$ pairs. A warm-start five-fold cross-validation protocol was used to ensure that all compared models were evaluated on identical user populations and test interactions. A fixed base seed ($\mathrm{seed}=42$) was applied throughout to ensure consistency across folds and sparsity levels.

For each sparsity level, user-specific training histories were subsampled to approximately $\rho \times \mid I_u^{\mathrm{train}}\mid$ interactions, retaining at least one interaction per user, with the sampling process driven by a deterministic random number generator initialized per $\left(\mathrm{seed},\mathrm{fold},\rho \right)$ tuple. This design eliminates evaluation-order effects and ensures full reproducibility. Under each reduced training set, all variants were retrained from scratch using the same architecture family, optimization settings, and evaluation pipeline as in the ablation study, isolating the effect of reduced interaction density from other confounding factors. Performance is summarized using NDCG@10 in Table 11.

Table 11. Controlled sparsity analysis: NDCG@10 (mean ± std) for DAERec-GCA and ablation variants at training retention ratios $\rho$ ∈ {0.25, 0.50, 0.75, 1.00}.

		$\mathsf{\rho }$= 0.25 (Most Sparse)	$\mathsf{\rho }$= 0.50	$\mathsf{\rho }$= 0.75	$\mathsf{\rho }$= 1.00 (Full Data)
100K	DAERec-GCA	0.0898 ± 0.0049	0.1428 ± 0.0052	0.2019 ± 0.0072	0.3005 ± 0.0074
	ROnly	0.0788 ± 0.0038 (↓ 12.2%)	0.1338 ± 0.0044 (↓ 6.4%)	0.1892 ± 0.0066 (↓ 6.3%)	0.2721 ± 0.0065 (↓ 9.4%)
	Flat1D	0.0815 ± 0.0047 (↓ 9.3%)	0.1391 ± 0.0063 (↓ 2.6%)	0.1883 ± 0.0073 (↓ 6.7%)	0.2729 ± 0.0106 (↓ 9.2%)
	GenreProfile	0.0775 ± 0.0042 (↓ 13.7%)	0.1308 ± 0.0052 (↓ 8.4%)	0.1898 ± 0.0048 (↓ 6.0%)	0.2747 ± 0.0091 (↓ 8.6%)
	GenreEmbed	0.0783 ± 0.0047 (↓ 12.7%)	0.1322 ± 0.0054 (↓ 7.4%)	0.1875 ± 0.0058 (↓ 7.1%)	0.2746 ± 0.0069 (↓ 8.6%)
	GenreGated	0.0841 ± 0.0046 (↓ 6.3%)	0.1370 ± 0.0056 (↓ 4.1%)	0.1910 ± 0.0077 (↓ 5.4%)	0.2790 ± 0.0079 (↓ 7.1%)
1M	DAERec-GCA	0.0988 ± 0.0029	0.1456 ± 0.0036	0.2006 ± 0.0036	0.3007 ± 0.0045
	ROnly	0.0785 ± 0.0021 (↓ 20.6%)	0.1204 ± 0.0033 (↓ 17.3%)	0.1675 ± 0.0046 (↓ 16.5%)	0.2524 ± 0.0087 (↓ 16.1%)
	Flat1D	0.0862 ± 0.0025 (↓ 12.8%)	0.1259 ± 0.0036 (↓ 13.5%)	0.1770 ± 0.0048 (↓ 11.8%)	0.2654 ± 0.0080 (↓ 11.7%)
	GenreProfile	0.0775 ± 0.0018 (↓ 21.5%)	0.1201 ± 0.0028 (↓ 17.5%)	0.1654 ± 0.0043 (↓ 17.5%)	0.2487 ± 0.0074 (↓ 17.3%)
	GenreEmbed	0.0783 ± 0.0022 (↓ 20.8%)	0.1200 ± 0.0038 (↓ 17.6%)	0.1669 ± 0.0051 (↓ 16.8%)	0.2547 ± 0.0060 (↓ 15.3%)
	GenreGated	0.0822 ± 0.0024 (↓ 16.8%)	0.1200 ± 0.0030 (↓ 17.6%)	0.1715 ± 0.0048 (↓ 14.5%)	0.2607 ± 0.0058 (↓ 13.3%)
10M	DAERec-GCA	0.1263 ± 0.0089	0.1668 ± 0.0094	0.2209 ± 0.0111	0.3203 ± 0.0111
	ROnly	0.1139 ± 0.0063 (↓ 9.8%)	0.1648 ± 0.0059 (↓ 1.2%)	0.2235 ± 0.0096 (↑ 1.1%)	0.3251 ± 0.0134 (↑ 1.5%)
	Flat1D	0.1205 ± 0.0068 (↓ 4.6%)	0.1604 ± 0.0050 (↓ 3.8%)	0.2089 ± 0.0114 (↓ 5.4%)	0.2973 ± 0.0137 (↓ 7.2%)
	GenreProfile	0.1124 ± 0.0065 (↓ 11.0%)	0.1616 ± 0.0075 (↓ 3.1%)	0.2210 ± 0.0066 (↓ 0.0%)	0.3251 ± 0.0114 (↑ 1.5%)
	GenreEmbed	0.1124 ± 0.0084 (↓ 11.0%)	0.1656 ± 0.0079 (↓ 0.7%)	0.2233 ± 0.0110 (↑ 1.1%)	0.3256 ± 0.0113 (↑ 1.7%)
	GenreGated	0.1167 ± 0.0060 (↓ 7.6%)	0.1664 ± 0.0041 (↓ 0.2%)	0.2227 ± 0.0060 (↑ 0.8%)	0.3256 ± 0.0090 (↑ 1.7%)

Bold indicates the best result.

The controlled sparsity analysis provides direct evidence of how DAERec-GCA behaves as available training data diminishes. A consistent pattern in Table 11 is that DAERec-GCA achieves the best performance at the two most sparse levels ($\rho =0.25$ and $\rho =0.50$) across all three datasets, suggesting that the proposed architecture is particularly effective when user interaction histories are limited.

On ML-100K and ML-1M, this advantage is visible across all retention ratios, with the margin being largest under the sparsest conditions. At $\rho =0.25$, relative NDCG@10 decreases with respect to DAERec-GCA range from 12.2% to 13.7% on ML-100K and from 12.8% to 21.5% on ML-1M. As the retention ratio increases, the margin narrows, yet DAERec-GCA remains consistently ahead. A more nuanced picture emerges on ML-10M. While DAERec-GCA again ranks first at $\rho =0.25$ and $\rho =0.50$, the differences at $\rho =0.75$ and $\rho =1.00$ are considerably smaller—typically around 1% or less in relative terms—and several competing variants achieve comparable or marginally higher values. This pattern suggests that the advantage of the proposed design is most pronounced in sparse and moderately sparse settings, while alternative genre-aware formulations become increasingly competitive under denser training conditions. These findings are consistent with the intended design rationale of DAERec-GCA: its practical advantage is greatest precisely when user feedback is most limited—the setting in which auxiliary structural information is expected to carry the most value. These results are visually summarized in Figure 10.

Figure 10. Controlled sparsity analysis: NDCG@10 vs. training data retention ratio (ρ) for DAERec-GCA and ablation variants across (a) ML-100K, (b) ML-1M, and (c) ML-10M. Shaded bands represent ± one standard deviation.

5.3. Computational Scalability

To characterize computational scalability, training time, inference latency, and GPU memory consumption were profiled for all variants across ML-100K, ML-1M, and ML-10M using an NVIDIA GeForce RTX 3090 GPU (25.33 GB VRAM) under CUDA 11.8 and PyTorch 2.3.0. Results are summarized in Table 12.

Table 12. Computational scalability profiling of DAERec-GCA and ablation variants across MovieLens datasets. Hardware: NVIDIA GeForce RTX 3090 (25.33 GB), CUDA 11.8, PyTorch 2.3.0.

		Trainable Params	Epoch Time (s)	Total Train (s)	Infer/User (ms)	Peak GPU (MB)
100K	DAERec-GCA	448,978	0.144 ± 0.002	28.8 ± 0.4	0.052 ± 0.001	137.1 ± 2.4
	ROnly	448,978	0.144 ± 0.002	28.8 ± 0.4	0.052 ± 0.002	187.5 ± 0.4
	Flat1D	7,797,636	0.144 ± 0.001	28.8 ± 0.2	0.051 ± 0.001	231.0 ± 0.5
	GenreProfile	453,682	0.255 ± 0.002	51.0 ± 0.5	0.170 ± 0.003	117.3 ± 0.5
	GenreEmbed	453,650	0.143 ± 0.001	28.5 ± 0.3	0.054 ± 0.005	42.8 ± 0.3
	GenreGated	450,194	0.254 ± 0.002	50.8 ± 0.4	0.173 ± 0.009	42.9 ± 0.1
1M	DAERec-GCA	969,146	1.095 ± 0.010	219.0 ± 2.1	0.053 ± 0.001	259.9 ± 9.0
	ROnly	969,146	1.095 ± 0.011	219.1 ± 2.2	0.053 ± 0.000	363.7 ± 3.0
	Flat1D	17,160,660	1.110 ± 0.010	222.1 ± 2.1	0.053 ± 0.001	475.4 ± 1.8
	GenreProfile	973,850	1.797 ± 0.005	359.4 ± 1.0	0.168 ± 0.003	227.0 ± 1.3
	GenreEmbed	973,818	1.063 ± 0.004	212.6 ± 0.9	0.057 ± 0.010	68.7 ± 0.7
	GenreGated	970,362	1.785 ± 0.005	357.1 ± 0.9	0.171 ± 0.005	68.6 ± 1.0
10M	DAERec-GCA	2,760,693	18.85 ± 0.17	942.5 ± 8.3	0.057 ± 0.001	678.9 ± 31.4
	ROnly	2,760,693	19.02 ± 0.12	950.9 ± 5.9	0.060 ± 0.001	974.8 ± 77.3
	Flat1D	49,408,506	19.88 ± 0.12	993.9 ± 5.8	0.062 ± 0.001	1320.6 ± 77.4
	GenreProfile	2,765,397	26.20 ± 0.29	1310.2 ± 14.7	0.169 ± 0.005	602.4 ± 107.7
	GenreEmbed	2,765,365	17.86 ± 0.33	892.8 ± 16.7	0.052 ± 0.001	164.1 ± 18.7
	GenreGated	2,761,909	26.38 ± 0.12	1318.9 ± 6.1	0.175 ± 0.006	164.5 ± 19.5

Epoch Time: wall-clock with torch.cuda.synchronize(). Infer/User: ms per user over 100 users after one warm-up pass. Peak GPU: torch.cuda.max_memory_allocated() per epoch. ML-100K and ML-1M were profiled for 200 epochs, whereas ML-10M was profiled for 75. Hence, epoch time is the primary metric for cross-dataset scaling comparisons.

ML-100K and ML-1M were profiled for 200 epochs, while ML-10M was profiled for 75 epochs based on the convergence trend shown in Figure 8. Epoch time is therefore the more appropriate metric for cross-dataset scaling comparisons, while total training time should be interpreted with this difference in mind. Table 12 shows that DAERec-GCA is approximately 17–18 times more parameter-efficient than Flat1D across all dataset scales, while maintaining comparable epoch times and inference latency. This confirms that the shared-weight two-dimensional formulation controls parameter growth without introducing a proportional runtime overhead. Relative to the structurally matched ROnly baseline, DAERec-GCA yields nearly identical training and inference times but consistently lower peak GPU memory: from 187.5 MB to 137.1 MB on ML-100K, from 363.7 MB to 259.9 MB on ML-1M, and from 974.8 MB to 678.9 MB on ML-10M. The genre-aligned structure therefore does not increase memory consumption relative to the corresponding rating-only two-dimensional backbone.

As dataset size increases from ML-100K to ML-10M, epoch time rises from 0.144 s to 18.85 s and peak GPU memory from 137.1 MB to 678.9 MB, as expected. By contrast, per-user inference latency remains stable at 0.052–0.057 ms across all scales, indicating that scaling primarily affects offline training cost while online scoring remains essentially constant. Taken together, these findings support a measured interpretation: DAERec-GCA is not uniformly optimal under every computational metric, but it offers a favorable trade-off between parameter efficiency and computational cost—particularly relative to flattened genre-aware designs. The proposed framework is therefore best understood as a principled design alternative that balances structural expressiveness with controlled model capacity, rather than as a universally superior replacement for flat baselines.

6. Conclusions

This study presented DAERec-GCA, a deep autoencoder-based collaborative filtering framework that organizes user–item interaction signals and item-side genre information within a genre-channel-aligned two-dimensional representation. Rather than incorporating genre information through flat concatenation, the proposed framework aligns rating values with genre-specific channels and applies shared encoder–decoder weights across channels, with the objective of preserving the structural correspondence between user preferences and item attributes while controlling parameter growth.

The experimental evaluation, conducted on the MovieLens 100K, 1M, and 10M datasets under a warm-start five-fold cross-validation protocol, indicates that DAERec-GCA provides competitive recommendation performance across different data scales. Within this unified evaluation setting, the model achieved the highest NDCG values on the smaller-scale dataset and remained within the upper-performing group on the medium- and large-scale datasets. Rank-based analyses further confirm that the proposed model consistently maintains a favorable overall position across datasets and metrics, without uniformly dominating all competing approaches.

The ablation and sparsity analyses provide further insight into the sources of these performance characteristics. In particular, the results indicate that the observed gains are not solely attributable to the inclusion of genre information, but also to the way in which this information is structurally integrated. This is evidenced by the consistent performance gap between the genre-channel-aligned formulation and its flattened counterpart (Flat1D), where relative NDCG@10 decreases exceeding 12% were observed. Statistical analysis using the Wilcoxon signed-rank test confirms that these differences are significant across all evaluated cutoff values. The controlled train-side sparsity experiments further suggest that the advantage of DAERec-GCA becomes more pronounced as interaction density decreases. At a retention ratio of ρ = 0.25, relative NDCG@10 improvements reached 13.7% on ML-100K and 21.5% on ML-1M, while diminishing under denser training conditions. This behavior is consistent with the design rationale, indicating that genre-channel alignment is particularly beneficial when observed user feedback is limited and auxiliary structural information carries greater relative importance.

From a computational perspective, the profiling results show that the shared-weight architecture reduces the number of trainable parameters by approximately 17–18 times compared to the flattened formulation, while maintaining comparable epoch times and stable per-user inference latency (0.052–0.057 ms). These findings suggest that the proposed design provides a practical trade-off between structural expressiveness, parameter efficiency, and recommendation quality, although the channel-wise processing introduces additional arithmetic cost during forward computation. Under the leave-one-out evaluation protocol, DAERec-GCA achieved the highest performance on ML-100K and remained within the top three methods across all datasets, placing second overall in the combined average-rank analysis behind MultiVAE. Taken together, these results indicate that genre-channel alignment with shared-weight parameterization constitutes a viable and robust design alternative, particularly under sparse and moderately sparse interaction regimes.

Limitations: The evaluation was limited to the MovieLens benchmark family and conducted exclusively under a warm-start setting. As a result, the behavior of the proposed framework under explicit cold-start conditions was not assessed. In addition, the study focused solely on genre-based side information, and the applicability of the proposed structural alignment mechanism to other modalities such as textual, visual, or contextual features, remains to be investigated.

Future Work: Several directions remain for future investigation. Evaluating the proposed framework on heterogeneous benchmark datasets (e.g., Amazon product data or Yelp point-of-interest data) would provide broader evidence of generalizability. Extending the alignment mechanism to incorporate additional modalities, such as textual embeddings, visual features, or temporal interaction signals, represents another promising direction. Furthermore, examining the model under cold-start scenarios and exploring hybrid formulations that integrate graph-based mechanisms may provide additional insights into capturing cross-genre dependencies beyond implicit shared parameterization.