💻 computer science

HPG-Rec: Hybrid Popularity-Guided Recommendation with Large Language Models

This paper introduces HPG-Rec, a novel, training-free framework that effectively addresses data sparsity and the semantic gap in recommender systems by combining controlled LLM candidate generation, rank-aware semantic scoring, dual popularity modeling, and MLP-based fusion to achieve significant performance improvements over state-of-the-art baselines.

Original authors: Harshad Kubade, Tausif Diwan

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Harshad Kubade, Tausif Diwan

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you're trying to find the perfect movie to watch tonight. You have a long list of things you've liked before, but the library is so huge that the usual "people who liked this also liked that" advice gets messy and confused. Sometimes, you're a new user with no history, and the system just guesses wildly. This is the nightmare of modern recommendation systems: they are often too sparse (missing too many connections), too cold (stuck on new users), or too noisy (confused by too much data).

Enter HPG-Rec, a new framework that acts like a super-smart, hybrid personal shopper. It doesn't just guess; it combines four different superpowers to find exactly what you want, even when the data is tricky.

The Four Superpowers of HPG-Rec

Think of HPG-Rec as a team of four experts working together in a control room:

The "Big Brain" Scout (The LLM): This is a Large Language Model, a super-smart AI that reads your history and suggests a short list of movies it thinks you'll love. But here's the trick: instead of just saying "Yes, this is good" or "No, this is bad," it keeps the ranking. It knows that the #1 suggestion is much better than the #10 suggestion. The system uses a special "logarithmic decay" score to respect this order, giving the top picks a big boost and the lower ones a smaller one, rather than treating them all the same.
The "Trend Watcher" (Dual Popularity): This expert looks at two things: what's popular right now in your specific neighborhood (Local Popularity) and what's generally famous across the whole world (Global Popularity). This helps the system know what to recommend to new users who haven't left a trail yet.
The "Similarity Detective" (Content Matching): This part looks at the actual details of the movies—the titles, genres, and descriptions. It asks, "If you liked Action Movie A, do you also like Action Movie B because they sound alike?" This is great for finding new items the system has never seen before.
The "Mixmaster" (Non-Linear Fusion): This is the most important part. Instead of just adding up the scores from the other three experts (which is like making a salad and just dumping the dressing on top), this Mixmaster uses a complex neural network (an MLP) to figure out how these signals interact. It learns that sometimes a popular movie is great, but sometimes a niche, similar movie is even better, depending on the context. It weighs the ingredients dynamically.

What HPG-Rec Says "No" To

The authors are very clear about what doesn't work well, and HPG-Rec is built to avoid those pitfalls:

No "Fine-Tuning" the Giant Brain: Many other methods try to retrain the massive Large Language Model (LLM) to make it better. The paper argues this is too expensive and slow. HPG-Rec says "No" to this. It uses the LLM exactly as it is (training-free), just asking it to generate a list, and then the system does the heavy lifting of learning the weights.
No "Binary" Thinking: Old methods often ask the LLM, "Is this item relevant? Yes or No?" The paper argues this throws away valuable information. If the LLM ranks an item #1 and another #50, that difference matters! HPG-Rec rejects the idea of turning these rankings into simple "Yes/No" buttons.
No "Linear" Mixing: You can't just add the popularity score to the similarity score and call it a day. The paper shows that the relationship between these signals is complex and non-linear. A simple addition misses the nuance.

The Proof: How Well Does It Work?

The researchers tested this system on the MovieLens-1M dataset, which contains over 1,000,209 ratings from 6,040 users across 3,706 movies. This is a "moderately dense" environment, meaning there's a lot of data, but it's still 95.54% sparse (most users haven't rated most movies).

In these tests, HPG-Rec didn't just do okay; it crushed the competition.

It improved the Hit Rate (how often the right movie was in the top 10) by 7.0% compared to the next best method (LLM2Rec).
It improved the NDCG (a measure of how well the top items are ranked) by 7.7%.

The paper suggests that these improvements are statistically significant (with a p-value of less than 0.01), meaning it's highly unlikely these results happened by chance.

Why It Matters (and What It Can't Do Yet)

The paper suggests that this hybrid approach is a "new paradigm." It proves that you can get the best of both worlds: the deep understanding of a Large Language Model and the hard data of user interactions, without needing to retrain the giant AI or wait for slow API calls.

However, the authors are honest about the limits. This system relies on having movie titles and categories (metadata) to work its magic. If a movie has no description, the system struggles. Also, they didn't test it against hackers trying to trick the system, and they haven't run it in a real-world "live" store yet. They also didn't use graph-based models (which map complex connections between users and items) in this specific version, though they suggest that could be a future upgrade.

In short, HPG-Rec is a clever, efficient way to build a recommendation engine that listens to the AI's ranking, watches the trends, checks the details, and mixes it all together perfectly—without needing to spend a fortune training the AI first. It's a solid step forward, especially for those tricky moments when data is scarce or users are brand new.

Technical Summary: HPG-Rec

Problem Statement

Recommender systems face persistent challenges including extreme data sparsity, the cold-start problem (where users or items lack interaction history), and the semantic gap between observed interaction signals and actual user intent. Traditional collaborative filtering (e.g., matrix factorization, NeuMF) relies heavily on co-occurrence statistics, failing when interactions are rare. Sequential models (e.g., SASRec, BERT4Rec) require long interaction histories to capture temporal dynamics, limiting their utility for users with sparse data. Content-based methods offer semantic generalization but lack collaborative signals necessary for fine-grained personalization.

While Large Language Models (LLMs) possess strong semantic reasoning capabilities, current LLM-based recommenders suffer from significant limitations:

Computational Cost: They often require expensive fine-tuning of billion-parameter models.
Loss of Ranking Information: Many approaches reduce LLM-generated candidate lists to binary indicators or embedding vectors, discarding the inherent ranking order which contains valuable relevance signals.
Scalability: Inference-only pipelines often ignore collaborative signals, while fine-tuned models struggle with real-time inference latency and costs.
Integration Gaps: Existing hybrid systems typically mix at most two signal types or use linear aggregation, failing to capture non-linear interactions between collaborative, sequential, semantic, and popularity-based signals.

Methodology: HPG-Rec Framework

The authors propose HPG-Rec (Hybrid Popularity-Guided Recommendation with Large Language Models), a training-free, hybrid framework designed to integrate four distinct signal sources into a single architecture without fine-tuning the underlying LLM.

1. Core Components

Controlled LLM Candidate Generation: The framework utilizes a pre-trained LLM (e.g., LLaMA2) in a zero-shot setting to generate a ranked list of candidate items based on user history. To ensure scalability and consistency, explicit constraints are applied:
- The candidate set size is capped (e.g., $|Cand_u| \le 50$ ).
- The prompt enforces strict formatting (item names only, no duplicates, no previously interacted items).
- A fallback mechanism (fuzzy matching, popularity filling) ensures the candidate list is complete.
Rank-Aware Semantic Scoring: Instead of converting LLM outputs into binary relevance flags, HPG-Rec preserves the ordering information. A logarithmic decay function assigns scores based on the rank position $r$ of an item in the LLM's output:
$s_{llm}(u, i) = \frac{1}{\log_2(rank_u(i) + 1)}$
This ensures that higher-ranked items receive significantly higher scores, capturing the marginal utility of top positions.
Dual Popularity Modeling: To address both sparsity and cold-start scenarios, the model incorporates two popularity signals:
- Local Popularity: Calculated as the ratio of users interacting with an item within the specific dataset.
- Global Popularity: A prior based on item ratings (or a default value of 0.5 if unavailable), providing a baseline for items with no local history.
Non-Linear MLP Fusion: A Multilayer Perceptron (MLP) acts as the fusion engine. It takes a feature vector comprising local popularity, global popularity, content-based semantic similarity (via Sentence-BERT), and the rank-aware LLM score. The MLP learns non-linear weights to combine these heterogeneous signals contextually, rather than relying on linear aggregation.

2. User and Item Representation

Users: Represented by a combination of static preferences (mean pooling of historical item embeddings) and sequential dynamics (GRU-based encoding of the interaction sequence).
Items: Represented by collaborative embeddings and semantic embeddings (Sentence-BERT).

3. Training Strategy

The framework is optimized using Bayesian Personalized Ranking (BPR) loss on implicit feedback data.

Negative Sampling: A hybrid strategy is employed where 50% of negative samples are drawn from globally popular items (to prevent popularity bias) and 50% are sampled uniformly at random.
Efficiency: The LLM is not fine-tuned. Only the lightweight embedding layers and the fusion MLP are trained, significantly reducing computational overhead compared to end-to-end LLM training.

Key Contributions

Training-Free LLM Integration: HPG-Rec demonstrates that LLMs can be effectively integrated into recommender systems without fine-tuning, utilizing them solely for semantic candidate generation and ranking.
Rank Preservation: The paper introduces a novel rank-aware scoring mechanism that explicitly utilizes the ordering information generated by LLMs, addressing a critical gap where previous methods discarded this signal.
Hybrid Non-Linear Fusion: Unlike linear aggregation methods, HPG-Rec uses an MLP to learn complex, non-linear interactions between collaborative, semantic, and popularity signals.
Dual Popularity Modeling: The framework effectively handles both sparse data regimes and cold-start scenarios by distinguishing between local dataset trends and global priors.

Experimental Results

Experiments were conducted on the MovieLens-1M dataset (moderately dense, ~95.5% sparsity) and other regimes (sparse/cold-start).

Performance: HPG-Rec outperformed state-of-the-art baselines, including collaborative filtering models (BPR-MF, NeuMF), sequential models (SASRec, BERT4Rec), and LLM-based methods (LLM2Rec, GPT-4 zero-shot).
- On MovieLens-1M, HPG-Rec achieved a 7.0% improvement in Hit Rate@10 and a 7.7% improvement in NDCG@10 over the best baseline (LLM2Rec).
Ablation Studies: Removing individual components confirmed their necessity:
- Removing the LLM module caused a ~9.6% drop in HR@10.
- Replacing rank-aware scoring with binary indicators resulted in a ~4.0% drop.
- Replacing the non-linear MLP with a linear model caused a ~6.6% drop.
- Removing popularity signals or history-based similarity also led to significant performance degradation.
Robustness: The framework showed consistent gains across sparse, cold-start, and dense regimes, proving its ability to generalize without dataset-specific tuning.

Significance and Claims

The paper claims that HPG-Rec represents a new paradigm for LLM-powered recommendation systems. Its significance lies in achieving a balance between accuracy, efficiency, and robustness:

It solves the multi-source integration problem by unifying collaborative, semantic, and popularity signals in a single non-linear architecture.
It addresses the rank preservation issue, demonstrating that LLM ordering is a valuable signal that should not be discarded.
It offers computational efficiency by avoiding the fine-tuning of massive models, making it feasible for practical deployment.
It provides cross-regime robustness, performing well in both data-sparse and data-dense environments without relying on cross-domain knowledge bases.

The authors conclude that while limitations exist (such as dependency on item metadata for semantic embeddings and the lack of graph-based modeling), HPG-Rec offers a viable, effective, and scalable solution for modern recommendation challenges.