Recommendation engines may soon need far less memory to decide what users should watch, read or buy, thanks to a new compression technique designed for the enormous catalogs behind modern digital platforms. Researchers have introduced URecJPQ, a machine-learning method that sharply reduces the storage and trainable-parameter demands of multimodal recommendation models while preserving much of their predictive accuracy. The approach targets a problem hidden behind seemingly instantaneous suggestions: every recommendation system must represent vast numbers of users and products as mathematical vectors, and those vectors can consume more memory than the hardware used to train them can provide.
The method, described by Giuseppe Spillo and colleagues in the Journal of Intelligent Information Systems, extends an earlier technique called RecJPQ, or Joint Product Quantization, from sequential recommendation to conventional top-k recommendation. In a top-k system, the algorithm ranks a large catalog and returns the most relevant k items for an individual user. Unlike sequential systems, which can often represent a user through a recent interaction sequence, top-k models generally maintain explicit embeddings for both users and items. URecJPQ compresses both sides of that equation, allowing a recommendation model to work with shared building blocks rather than one completely independent vector for every entity.
Recommendation models commonly translate each user and item ID into a dense numerical embedding. If a user is represented by a 64-dimensional vector, for example, the system learns 64 parameters—or more, depending on the precision and optimization state—for every individual user. The same applies to every item. During training, GPUs must store the embeddings, their gradients and additional optimizer information. At industrial scale, this can become the dominant cost. A catalog with tens of millions of users and items can require billions of parameters before the model has even processed images, text or other content associated with the items. The researchers note that state-of-the-art recommendation models can reach multiple terabytes, while high-bandwidth memory on current GPUs is typically measured in tens of gigabytes.
Multimodal recommendation intensifies the bottleneck. A product may be represented not only by its interaction history but also by a photograph, a product description or other signals. In the study, images were encoded with a Vision Transformer, or ViT, and text with MiniLM. These encoders were kept frozen, meaning their parameters were not updated during recommendation training. That choice was deliberate: training the encoders end to end could add tens or hundreds of millions of parameters, making it difficult to isolate the memory savings produced by compressing user and item IDs. The resulting system combines precomputed visual and textual features with compact, learnable ID representations.
URecJPQ is based on product quantization, a form of vector compression that divides a high-dimensional embedding into smaller, non-overlapping sub-embeddings. Each sub-embedding is represented by the index of a learned vector, or centroid, in a codebook. The full representation is reconstructed by concatenating the selected sub-embeddings. If a 64-dimensional vector is divided into 16 subspaces, each subspace contains a four-dimensional component. Rather than learning a unique 64-dimensional vector for every user or item, the model learns a shared codebook for each subspace and assigns each entity a sequence of compact codes.
The crucial difference is that URecJPQ does not first learn every full embedding and compress it afterward. Instead, the assignments to codebook entries are established before end-to-end model training, avoiding the need to maintain the original massive embedding tables. In the experiments, each codebook contained 256 entries, allowing a sub-ID to be represented in a single byte. The trainable parameters are therefore determined largely by the number of subspaces and the dimensions of their shared components, rather than by the total number of users and items. The reconstructed vectors still have the original dimensionality when the recommendation model needs them, but the learned tables and their gradients are dramatically smaller.
The scale of the reduction is illustrated by a Bayesian Personalized Ranking model tested on the Baby23 dataset, which contained about 143,000 users and 44,000 items in the cited example. A conventional 64-dimensional model required roughly 12 million user-and-item embedding parameters. With URecJPQ, 16 subspaces and four-dimensional sub-embeddings produced two 16,000-parameter codebooks—one for users and one for items—for a total of about 32,000 trainable parameters. That represents a reduction of approximately 99.7 percent. For the multimodal VBPR model, the corresponding reduction was from about 21 million parameters to 170,000.
The researchers evaluated the technique using MovieLens-1M, Baby23 and Sports23, covering films and two categories of Amazon products. The Amazon datasets were filtered so that users and items had at least 10 interactions, and only items with multimodal information were retained. Four recommendation architectures were tested: BPR, VBPR, SLMRec and MMGCL. The first two are ranking models, with VBPR incorporating visual information, while SLMRec and MMGCL use self-supervised or graph-based methods to model multimodal interactions. Models were assessed using Recall@20 and NDCG@20, metrics that measure whether relevant items appear among the first 20 recommendations and whether they are ranked near the top.
Across the experiments, URecJPQ reduced trainable parameters by as much as 98 to 99 percent and compressed model checkpoints by up to 86 to 98 percent, depending on the dataset and architecture. On Baby23, a VBPR checkpoint fell from 325 megabytes to 14 megabytes, while an MMGCL checkpoint dropped from nearly 500 megabytes to about 15 megabytes. Accuracy usually declined only modestly in the least favorable cases, with average reductions reported at about 8.5 percent for Recall and 16 percent for NDCG. Those averages conceal important variation: some quantized models matched or exceeded their full-embedding counterparts, including improvements of up to 85 percent in the baby-products domain under particular configurations.
The results also suggest that compression can act as a form of regularization rather than merely a storage trick. In machine learning, regularization limits a model’s ability to memorize idiosyncratic details, encouraging it to learn patterns that generalize. When the researchers projected user and item embeddings into two dimensions using principal component analysis, conventional BPR and VBPR representations spread into broad, crescent-shaped distributions. The URecJPQ representations were more compact and centered near the origin, with users in particular forming tighter clusters. Average distances between user sub-embeddings were 0.16 for BPR and 0.15 for VBPR, compared with item distances of 0.41 and 0.32, respectively. The authors interpret this compactness as evidence that shared sub-embeddings can group users with similar behavior and reduce overfitting.
The trade-off depends on the amount and quality of interaction data. On the relatively dense MovieLens-1M dataset, quantized models generally improved on the originals, with one reported exception involving SLMRec’s Recall. On the larger and sparser Sports23 dataset, performance more often declined slightly, although quantized VBPR improved in some comparisons. The researchers suggest that compression may help dense data by imposing useful structure, while sparse data provides fewer collaborative signals and can suffer when the representation is constrained. The number of subspaces also mattered: 32 was usually best for the smaller, denser dataset, whereas 64 often worked better for larger, sparser catalogs. Beyond that, dividing the latent space too finely could reduce performance.
How codes are assigned made a difference as well. One strategy assigns sub-IDs randomly, while another uses truncated singular-value decomposition of the user-item interaction matrix. In the SVD approach, the interaction matrix is approximated as the product of user factors, singular values and item factors. The resulting latent dimensions are divided into quantile bins, converting broad behavioral patterns into structured discrete codes. A small amount of random noise is added before discretization to prevent entities with identical interaction histories from receiving exactly the same assignment. Statistical testing found the two strategies equivalent within a predefined performance margin, but numerical patterns varied. Random assignment often benefited simpler BPR and VBPR models on sparse datasets, whereas more complex multimodal systems such as SLMRec and MMGCL were less sensitive and sometimes benefited from SVD-based structure.
URecJPQ does not make recommendation training universally faster, however. Because full-dimensional vectors are reconstructed when the forward and backward passes require them, the main savings come from storing and updating smaller codebooks, not from eliminating all computation involving the original vector size. The researchers therefore present the method primarily as a way to make large models fit within realistic memory budgets. They tested the approach on a system with an A5000 GPU and 24 gigabytes of RAM, and released code and processing scripts through a public repository. Future work will examine graph-based recommendation models, compression of the multimodal features themselves, theoretical bounds on joint quantization error, and effects on fairness, novelty, diversity and energy use. For platforms facing catalogs that grow faster than their hardware, the central promise is straightforward: recommendations may retain their personalization while the models behind them become small enough to train and deploy.
Subject of Research: Technology and Engineering
Subject of Research: Technology and Engineering
Article Title: URecJPQ: Memory-Efficient Multimodal Recommendation Models for Large-Scale Scenarios
Article References: Spillo, G., Yi, Z., Petrov, A. V., Musto, C., Macdonald, C., & Ounis, I. (2026). URecJPQ: memory-efficient multimodal recommendation models through RecJPQ in large-scale scenarios. Journal of Intelligent Information Systems. https://doi.org/10.1007/s10844-026-01088-x
Image Credits: AI Generated
DOI: 10.1007/s10844-026-01088-x
Keywords: efficient storage for recommendation engines, joint product quantization in recommender systems, large catalog recommendation system techniques, large-scale recommendation platforms, memory-efficient recommendation algorithms, multimodal data integration in recommendations, multimodal recommendation models, recommendation system memory compression, reducing trainable parameters in recommendation models, scalable machine learning for recommendations, top-k recommendation system optimization, vector representation optimization
Cite this news
APA
MLA
Chicago
SCIENMAG. (August 28, 2026). URecJPQ: Memory-Efficient Multimodal Recommendation Models for Large-Scale Scenarios. https://scienmag.com/urecjpq-memory-efficient-multimodal-recommendation-models-for-large-scale-scenarios/
SCIENMAG. “URecJPQ: Memory-Efficient Multimodal Recommendation Models for Large-Scale Scenarios.” Scienmag, 28 August 2026, https://scienmag.com/urecjpq-memory-efficient-multimodal-recommendation-models-for-large-scale-scenarios/. Accessed 28 August 2026.
SCIENMAG. “URecJPQ: Memory-Efficient Multimodal Recommendation Models for Large-Scale Scenarios.” Scienmag. August 28, 2026. https://scienmag.com/urecjpq-memory-efficient-multimodal-recommendation-models-for-large-scale-scenarios/
Copy citation
Download RIS
Tags: efficient large-scale recommendation system designefficient storage for recommendation enginesjoint product quantization in recommendation systemsjoint product quantization in recommender systemslarge catalog recommendation system techniqueslarge-scale digital platform recommendation algorithmslarge-scale recommendation platformsmemory-efficient machine learning for recommendationsmemory-efficient recommendation algorithmsmultimodal data integration in recommendation enginesmultimodal data integration in recommendationsmultimodal recommendation model compressionmultimodal recommendation modelsneural network compression for recommendation accuracyrecommendation system memory compressionrecommendation system memory optimizationreducing storage in recommendation modelsreducing trainable parameters in recommendation modelsscalable machine learning for recommendationsscalable recommendation engine architecturetop-k recommendation system optimizationtop-k recommendation system vector representationuser and item embedding compression techniquesvector representation optimization
