Pith. sign in

REVIEW 4 major objections 5 minor 31 references

A Language-Driven Framework for Improving Personalized Recommendations: Merging LLMs with Traditional Algorithms

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Adding an LLM similarity-scoring layer to SVD and SVD++ improves MovieLens hit rates up to ~6x and lifts NDCG by about 74 to 77 percent.

desk verdict Plausible LLM re-ranking framework with a real hit-rate result, but the ranking-metric comparison is under-specified enough that the headline NDCG/MAP gains may be inflated by test-item leakage. read the letter →

arxiv 2507.07251 v1 pith:32UUEQAR submitted 2025-07-09 cs.IR cs.CLcs.LG

Aaron Goldstein , Ayan Dutta This is my paper
classification cs.IRcs.CLcs.LG
keywords recommendersystemslargelanguagemodelspersonalizedrecommendationsre-rankingmovierecommendationuserpreferenceprofilesSVD++Lens
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish that a traditional matrix-factorization recommender can be made more personalized by re-ranking its top-N output with an LLM scoring layer. The framework builds a short natural-language preference profile for each user—automatically from favorite movies or manually from typed text—and asks the LLM to score each candidate movie's description against that profile. On the MovieLens-Latest-Small dataset, the authors report that the LLM-enhanced versions of SVD and SVD++ outperform the base algorithms on every metric they test, including up to about 6x cumulative hit rate and roughly 74 to 77 percent higher NDCG@10. The gain costs added compute: roughly 23 seconds per user with a locally running model. If the result holds, platforms could let users state preferences in words and improve rankings without retraining their collaborative-filtering model.

What carries the argument

The load-bearing component is the similarity-scoring prompt: a few-shot prompt that gives the LLM the user's natural-language preference profile, favorite movies, preferred release-date range, and conditional rating and popularity signals, and asks it to return a number between -1 and 1 for each candidate movie. This score is the re-ranking key, since candidates from SVD or SVD++ are sorted by it so that the LLM's judgment, rather than the latent-factor ranking, determines the final list. Supporting machinery includes an automatic preference-profile generator built from favorite movies, description retrieval with LLM fuzzy matching when identifiers break, and LLM-generated movie descriptions when retrieval fails.

What would settle it

Run the automatic pipeline with the free-text "user input" sentence removed from the similarity prompt while keeping favorite movies, ratings, popularity scores, and release-date ranges; if hit-rate and ranking gains over base SVD and SVD++ remain similar, the reported benefit comes from the structured signals rather than from natural-language understanding.

Watch

Extended reading notes

Core claim

The central claim is that the final ranking, not the latent-factor predictions, is the bottleneck in traditional recommenders, and that an LLM can repair that ranking by judging each candidate's fit to a user's expressed and inferred tastes. SVD or SVD++ first generates a candidate pool (a search count of 100 in the experiments), and the LLM assigns each movie a similarity score between -1.0 and 1.0 based on the user's preference profile, favorite movies, preferred release-date range, rating metadata, and normalized popularity. The top-N movies by similarity score are returned as the final recommendations. With preference profiles generated automatically for all users in MovieLens-Latest-Small, the paper reports that the enhanced algorithms beat their base versions on hit rate, cumulative hit rate, NDCG, MAP, precision, and recall, with the largest relative gains at N@1 (about 5x to 6x) and about 74 to 77 percent higher NDCG@10.

Load-bearing premise

The load-bearing premise is that the automatically generated user preference profile—built from a user's favorite movies and simple templated lines such as "I prefer movies with high IMDb ratings"—faithfully represents what that user would say in natural language, and the paper does not show how the richer free-text "user input" line is produced in the automated pipeline.

Editorial extensions

If this is right

  • Platforms could add a language-driven re-ranking step to an already-trained collaborative-filtering model, letting users phrase preferences in natural language without retraining.
  • The automatic profile generation means the benefit can in principle reach the whole user base, not only users who manually type preferences.
  • Because the LLM judges each candidate independently, position bias among the top-100 candidates is reduced relative to prompting for a full ranked list.
  • The user pays for these gains in compute, roughly 23 seconds per user on the tested local setup, so deployment would weigh personalization quality against latency and cost.
  • The reported improvements on both hit-rate and ranking metrics suggest the added layer helps with the relevance part of recommendation, not just matching previously interacted items.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • We infer that the relative improvements are partly a small-base effect: the base SVD and SVD++ hit rates are under 1 percent at N@1, so a 5x multiplier still represents a modest absolute gain, and users would likely notice the ranking-quality difference more than the hit-rate difference.
  • We infer that the templated profile generation means the LLM is mostly combining popularity, rating-level, and release-date priors with genre-level description matching, so the framework may not be testing true open-ended language understanding.
  • We infer that the same re-ranking layer could be attached to any base recommender that emits a top-N list, with the size of the gain depending on whether that recommender's candidate pool already contains relevant items; the paper only tests SVD and SVD++.
  • We infer that a stronger test of the language claim would compare automated profiles against detailed manual profiles written by real users, since if manual profiles produce materially larger gains, the profiling step rather than the LLM scoring is the bottleneck.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes a framework that combines traditional collaborative-filtering recommenders (SVD and SVD++, implemented with the Surprise library) with a large language model that re-ranks the top-N base recommendations using similarity scores between a user preference profile and movie descriptions. The framework supports both manually specified and automatically generated preference profiles, and the LLM is also used for movie-description generation and fuzzy matching of outdated IMDb IDs. Experiments on MovieLens-Latest-Small compare the LLM-enhanced versions with the base SVD/SVD++ algorithms using leave-one-out hit rates and cumulative hit rates, and using NDCG, MAP, Precision, and Recall on an item-based stratified 0.75/0.25 split. The reported tables show consistent improvements of the LLM-enhanced methods over the base algorithms on all metrics.

Significance. If the central empirical claim holds, the framework is a simple and practical way to inject natural-language user preferences into established matrix-factorization recommenders, and the paper's explicit exclusion of the left-out movie from the favorite-movie list in the hit-rate experiment shows methodological care. The framework is clearly described at a high level, and the anonymous code release is a positive step for reproducibility. However, the evaluation has several load-bearing gaps: the ranking-metric experiment does not specify how preference profiles are constructed relative to the train/test split, the automatic natural-language profile generation is not described, and no uncertainty quantification is provided. These gaps currently prevent the reader from accepting the 'overwhelmingly surpassed' claim at face value.

major comments (4)
  1. [Section 3.3 / Table 5] The ranking-metric evaluation never states whether the user preference profile, including the 'User's favorite movies' list shown in Figure 3, is built from the training portion of the 0.75/0.25 split or from the full user history. This matters because Section 3.2 explicitly excludes the left-out test movie from the favorite-movie list in the hit-rate experiment, showing the authors are aware of this leakage mode. If any held-out test item appears in the profile used for the ranking experiment, the LLM scorer will see the item it is supposed to rank, inflating NDCG, MAP, Precision, and Recall relative to the SVD/SVD++ baselines, which do not have access to the profile. The authors must state exactly how the profiles are constructed in the Section 3.3 experiment and, if test items can appear, rerun the evaluation with test items excluded from profiles.
  2. [Section 2.2 / Figure 3] The automatic generation of the free-text 'user input' statement (e.g., 'I am drawn to science fiction and fantasy stories that are well written') is not described anywhere in the paper. The authors specify only the hand-set thresholds for the conditional rating and popularity preference statements (average IMDb rating of favorites >= 7.0 and normalized popularity >= 80), which are also not justified. Without a concrete description of how the natural-language sentence is produced, the central claim that language-driven preferences drive the improvements is not fully supported, because the profile may in practice reduce to popularity and rating signals plus release-date filtering.
  3. [Section 3.3 / Tables 1-5] No confidence intervals, standard deviations, or significance tests are reported for any metric, and the LLM component is stochastic (quantization, sampling, retry mechanisms). Given the very small absolute hit rates (e.g., 0.008 at N@1) and the modest NDCG values, the claim of 'overwhelming' improvement needs uncertainty quantification. At least a small number of repeated runs or a bootstrap over users should be reported to establish that the improvements are not within the noise of the evaluation protocol.
  4. [Table 5 / Section 3.3] The comparison to 'FastAI's recommendation system [2]' is not reproducible as reported. Reference [2] is a website rather than a published model or evaluation protocol, and the paper gives no details on how the FastAI numbers were produced on MovieLens-Latest-Small. The statement that the framework surpasses a state-of-the-art system is therefore unsupported and should either be removed or replaced with a properly described baseline (with hyperparameters, training procedure, and metric definitions).
minor comments (5)
  1. [Introduction, paragraph 4] The phrase 'base SVM and SVD++ recommendations' should read 'base SVD and SVD++ recommendations'; SVM is not used anywhere in the paper.
  2. [Section 3.1] The text says the local model exposes an 'OpenAPI-compatible API'; this should be 'OpenAI-compatible API'.
  3. [References] Reference [19] is listed only as an OpenReview entry with no venue or publication status; please provide the full citation if it has appeared in a venue.
  4. [Section 3.2] The leave-one-out hit-rate experiment does not specify the hyperparameters used to train SVD and SVD++ (e.g., number of factors, regularization, number of epochs), which are needed for reproducibility.
  5. [Section 2.2] The tuning factors T and M are described only through a single example; a brief formal statement of the search-count formula (e.g., search_count = N * T * 10^M) would improve clarity.

Circularity Check

1 steps flagged · score 6.0 of 10

Ranking-metric 'predictions' can include held-out movies in the LLM prompt, making the reported NDCG/MAP gains a label-leakage artifact rather than an independent result.

  1. self definitional [Section 3.2 (hit-rate exclusion statement) vs. Section 3.3 (ranking metrics, item-based split; Tables 1-5)]
    "It is key to mention that we ensure we do not include the left out test set movie as a favorite movie for each user in their user preference profile that is provided to the LLM, as we felt this might be unfair when asking the LLM to rate the similarity of that movie to the user."

    This sentence shows the authors' default protocol: the LLM prompt lists the user's favorite movies, so a held-out movie would otherwise appear as an input feature. In the ranking-metric experiment (Section 3.3; abstract: 'rating and ranking metrics with an item-based stratified 0.75 train, 0.25 test split') no analogous exclusion is stated, and profiles are still generated 'based on their favorite movies' (Section 3.2). With an item-based split every test movie is also in the training item set and can be among a user's highly rated favorites.

full rationale

The framework's core derivation, LLM similarity re-ranking of SVD outputs, is not circular in the leave-one-out hit-rate experiment because the authors explicitly exclude the left-out movie from the profile. The automatic preference profile and thresholds are hand-set heuristics, not fitted parameters, and the LLM is not trained on test labels, so those are correctness risks rather than circularity. The ranking-metric evaluation (Section 3.3), however, is the central claim's weakest link: profiles are built from favorite movies, and the only stated test-item exclusion is for hit rate. Under the item-based 0.75/0.25 split, test items can appear as favorite movies in the LLM prompt, making the LLM score a direct function of the known answer. The ablation study reports that explicitly listed favorite movies add <1% NDCG/MAP, weakening the practical impact but not removing the protocol gap. No load-bearing self-citation or imported uniqueness theorem is present. Score 6 reflects partial circularity: the ranking 'predictions' reduce by construction if test items are not excluded, while hit-rate results remain independent.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The framework relies on hand-set thresholds for activating preference statements, a specific LLM choice, and the assumption that LLM similarity scores and IMDb metadata capture user preferences. No new physical or conceptual entities are introduced.

free parameters (5)
  • Rating preference threshold = 7.0 (average IMDb rating of user's favorite movies)
    Enables the statement 'I prefer movies with high IMDb ratings' in the prompt; value chosen without stated justification (Section 2.2).
  • Popularity preference threshold = 80 (average normalized popularity score)
    Enables the statement 'I prefer popular/trending movies'; chosen without stated justification (Section 2.2).
  • Search-count tuning factors T and M = T=0.2, M=2 (search count = 100)
    Used to compute the number of base recommendations to re-rank; chosen for testing, not justified (Section 2.2).
  • Popularity normalization scale = 1,000,000 votes maps to 100
    Linear interpolation for normalized popularity score (Eq. 1); arbitrary scale.
  • LLM model and quantization = Phi-4 Q6_K
    Model choice affects similarity scores; a design decision rather than a fitted parameter, but it directly influences results (Section 2.1).
assumptions (5)
  • standard math SVD and SVD++ matrix factorization as implemented in the Surprise library correctly model user-item interactions.
    Used without derivation as the base algorithm (Section 2.1).
  • domain assumption MovieLens-Latest-Small is a valid benchmark for evaluating personalized movie recommendations.
    The dataset is small (100k ratings) and from 2018; conclusions may not generalize to larger or more recent data (Section 2.1).
  • domain assumption IMDb metadata (ratings, vote counts) is a valid signal for user preferences.
    The framework includes IMDb rating and popularity in the LLM prompt, assuming they improve alignment with user tastes (Section 2.2).
  • ad hoc to paper The LLM similarity score between a user profile and a movie description is a valid proxy for user preference.
    No validation that the LLM's scores correlate with actual user satisfaction; this is the central mechanism of the framework (Section 2.2).
  • ad hoc to paper The free-text user input in the automated pipeline accurately represents user preferences.
    The paper does not describe how this text is generated in the automated experiments, making the language-driven claim hard to verify (Section 2.2, Figure 3).

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Language-Driven Framework for Improving Personalized Recommendations: Merging LLMs with Traditional Algorithms." pith.science (2026). https://pith.science/paper/32UUEQAR

@misc{pith2026250707251,
  author       = {Pith},
  title        = {Pith review of: A Language-Driven Framework for Improving Personalized Recommendations: Merging LLMs with Traditional Algorithms},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/32UUEQAR}},
  note         = {Machine review of arXiv:2507.07251}
}
read the original abstract

Traditional recommendation algorithms are not designed to provide personalized recommendations based on user preferences provided through text, e.g., "I enjoy light-hearted comedies with a lot of humor". Large Language Models (LLMs) have emerged as one of the most promising tools for natural language processing in recent years. This research proposes a novel framework that mimics how a close friend would recommend items based on their knowledge of an individual's tastes. We leverage LLMs to enhance movie recommendation systems by refining traditional algorithm outputs and integrating them with language-based user preference inputs. We employ Singular Value Decomposition (SVD) or SVD++ algorithms to generate initial movie recommendations, implemented using the Surprise Python library and trained on the MovieLens-Latest-Small dataset. We compare the performance of the base algorithms with our LLM-enhanced versions using leave-one-out validation hit rates and cumulative hit rates. Additionally, to compare the performance of our framework against the current state-of-the-art recommendation systems, we use rating and ranking metrics with an item-based stratified 0.75 train, 0.25 test split. Our framework can generate preference profiles automatically based on users' favorite movies or allow manual preference specification for more personalized results. Using an automated approach, our framework overwhelmingly surpassed SVD and SVD++ on every evaluation metric used (e.g., improvements of up to ~6x in cumulative hit rate, ~3.7x in NDCG, etc.), albeit at the cost of a slight increase in computational overhead.

Figures

Figures reproduced from arXiv: 2507.07251 by the authors.

Figure 1
Figure 1. Framework Architecture Flowchart showing data generation and recommendation paths [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. A sample description generation prompt with few-shot example descriptions retrieved from IMDb [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Similarity Scoring Prompt with preference statements, preferred release range, favorite movies, IMDb ratings and [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

31 extracted references · 24 canonical work pages

  1. [2]

    https://www.fast.ai/

    fast.ai—Making neural nets uncool again – fast.ai — fast.ai. https://www.fast.ai/. [Accessed 04-04-2025]

    work page 2025

  2. [1]

    https://anonymous.4open

    Anonymous Github — anonymous.4open.science. https://anonymous.4open. science/r/Recommendation-Systems-Research-5FB0/README.md. [Accessed 08-04-2025]

    work page 2025

  3. [3]

    J., Javaheripi, M., Kauffmann, P., et al

    Abdin, M., Aneja, J., Behl, H., Bubeck, S., Eldan, R., Gunasekar, S., Harrison, M., Hewett, R. J., Javaheripi, M., Kauffmann, P., et al. Phi-4 technical report. arXiv preprint arXiv:2412.08905 (2024)

    arXiv 2024

  4. [4]

    Llm based generation of item-description for recommendation system

    Acharya, A., Singh, B., and Onoe, N. Llm based generation of item-description for recommendation system. In Proceedings of the 17th ACM Conference on Recommender Systems (New York, NY, USA, 2023), RecSys ’23, Association for Computing Machinery, p. 1204–1207

    work page 2023

  5. [5]

    L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al

    Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F. L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

    arXiv 2023

  6. [6]

    C., and Aggarwal, C

    Aggarwal, C. C., and Aggarwal, C. C. An introduction to recommender systems. Recommender systems: The textbook (2016), 1–28

    work page 2016

  7. [7]

    D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al

    Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. Language models are few-shot learners. Advances in neural information processing systems 33 (2020), 1877–1901

    work page 2020

  8. [8]

    Recommender system literature review 2019–2023

    Chiang, J. Recommender system literature review 2019–2023. https://jchiang1225.medium.com/recommender-system-literature-review- 2019-2023-2b481bd39c0c, 2024. Accessed: 2024-07-22

    work page 2019

Show all 31 references
  1. [9]

    Uncovering chatgpt’s capabilities in recommender systems

    Dai, S., Shao, N., Zhao, H., Yu, W., Si, Z., Xu, C., Sun, Z., Zhang, X., and Xu, J. Uncovering chatgpt’s capabilities in recommender systems. In Proceedings of the 17th ACM Conference on Recommender Systems (2023), pp. 1126–1132

    2023

  2. [10]

    M., and Konstan, J

    Harper, F. M., and Konstan, J. A. The movielens datasets: History and context. Acm transactions on interactive intelligent systems (tiis) 5 , 4 (2015), 1–19

    2015

  3. [11]

    Hou, Y., Zhang, J., Lin, Z., Lu, H., Xie, R., McAuley, J., and Zhao, W. X. Large language models are zero-shot rankers for recommender systems. In European Conference on Information Retrieval (2024), Springer, pp. 364–381

    2024

  4. [12]

    Surprise: A python library for recommender systems

    Hug, N. Surprise: A python library for recommender systems. Journal of Open Source Software 5, 52 (2020), 2174

    2020

  5. [13]

    M., Bommarito, M

    Katz, D. M., Bommarito, M. J., Gao, S., and Arredondo, P. Gpt-4 passes the bar exam. Philosophical Transactions of the Royal Society A 382 , 2270 (2024), 20230254

    2024

  6. [14]

    Factorization meets the neighborhood: a multifaceted collaborative filtering model

    Koren, Y. Factorization meets the neighborhood: a multifaceted collaborative filtering model. In Proceedings of the 14th ACM SIGKDD international conference on Knowledge discovery and data mining (2008), pp. 426–434

    2008

  7. [15]

    Matrix factorization techniques for recom- mender systems

    Koren, Y., Bell, R., and Volinsky, C. Matrix factorization techniques for recom- mender systems. Computer 42, 8 (2009), 30–37

    2009

  8. [16]

    M., Buchholz, A., and Schwöbel, P

    Lichtenberg, J. M., Buchholz, A., and Schwöbel, P. Large language models as recommender systems: A study of popularity bias, 2024

    2024

  9. [17]

    Is chatgpt a good recommender? a preliminary study

    Liu, J., Liu, C., Zhou, P., Lv, R., Zhou, K., and Zhang, Y. Is chatgpt a good recommender? a preliminary study. arXiv preprint arXiv:2304.10149 (2023)

    2023 arXiv

  10. [18]

    Once: Boosting content-based recommendation with both open-and closed-source large language models

    Liu, Q., Chen, N., Sakai, T., and Wu, X.-M. Once: Boosting content-based recommendation with both open-and closed-source large language models. In Proceedings of the 17th ACM International Conference on Web Search and Data Mining (2024), pp. 452–461

    2024

  11. [19]

    Y., Morishetti, L., Giahi, R., Nag, K., Xu, J., Cho, J., Korpeoglu, E., Kumar, S., and Achan, K

    Maragheh, R. Y., Morishetti, L., Giahi, R., Nag, K., Xu, J., Cho, J., Korpeoglu, E., Kumar, S., and Achan, K. Llm-based aspect augmentations for recommenda- tion systems. In OpenReview (2024)

    2024

  12. [20]

    M., Carignan, D., and Horvitz, E

    Nori, H., King, N., McKinney, S. M., Carignan, D., and Horvitz, E. Capabilities of gpt-4 on medical challenge problems. arXiv preprint arXiv:2303.13375 (2023)

    2023 arXiv

  13. [21]

    Representation learning with large language models for recommendation

    Ren, X., Wei, W., Xia, L., Su, L., Cheng, S., W ang, J., Yin, D., and Huang, C. Representation learning with large language models for recommendation. In Proceedings of the ACM Web Conference 2024 (2024), pp. 3464–3475

    2024

  14. [22]

    Resnick, P., and V arian, H. R. Recommender systems. Communications of the ACM 40, 3 (1997), 56–58

    1997

  15. [23]

    A systematic review and research perspective on recommender systems

    Roy, D., and Dutta, M. A systematic review and research perspective on recommender systems. Journal of Big Data 9 , 59 (2022), 36

    2022

  16. [24]

    Large language models are competitive near cold-start recommenders for language-and item- based preferences

    Sanner, S., Balog, K., Radlinski, F., Wedin, B., and Dixon, L. Large language models are competitive near cold-start recommenders for language-and item- based preferences. In Proceedings of the 17th ACM conference on recommender systems (2023), pp. 890–896

    2023

  17. [25]

    Zero-shot next-item recommendation using large pretrained language models

    W ang, L., and Lim, E.-P. Zero-shot next-item recommendation using large pretrained language models. arXiv preprint arXiv:2304.03153 (2023)

    2023 arXiv

  18. [26]

    X., W ang, J., and Wen, J.-R

    W ang, X., Tang, X., Zhao, W. X., W ang, J., and Wen, J.-R. Rethinking the evaluation for conversational recommendation in the era of large language models. arXiv preprint arXiv:2305.13112 (2023)

    2023 arXiv

  19. [27]

    Llmrec: Large language models with graph augmentation for rec- ommendation

    Wei, W., Ren, X., Tang, J., W ang, Q., Su, L., Cheng, S., W ang, J., Yin, D., and Huang, C. Llmrec: Large language models with graph augmentation for rec- ommendation. In Proceedings of the 17th ACM International Conference on Web Search and Data Mining (2024), pp. 806–815

    2024

  20. [28]

    Empowering news recommendation with pre-trained language models

    Wu, C., Wu, F., Qi, T., and Huang, Y. Empowering news recommendation with pre-trained language models. In Proceedings of the 44th international ACM SIGIR conference on research and development in information retrieval (2021), pp. 1652–1656

    2021

  21. [29]

    A survey on large language models for recommendation

    Wu, L., Zheng, Z., Qiu, Z., W ang, H., Gu, H., Shen, T., Qin, C., Zhu, C., Zhu, H., Liu, Q., et al. A survey on large language models for recommendation. World Wide Web 27, 5 (2024), 60

    2024

  22. [30]

    Evaluating recommender systems: survey and framework

    Zangerle, E., and Bauer, C. Evaluating recommender systems: survey and framework. ACM computing surveys 55, 8 (2022), 1–38

    2022

  23. [31]

    Llmtreerec: Unleashing the power of large language models for cold-start recommendations

    Zhang, W., Wu, C., Li, X., W ang, Y., Dong, K., W ang, Y., Dai, X., Zhao, X., Guo, H., and Tang, R. Llmtreerec: Unleashing the power of large language models for cold-start recommendations. arXiv preprint arXiv:2404.00702 (2024)

    2024 arXiv

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.