recommenders-team/recommenders
55.1
Adequate · 16 November 2026
27k
lines of production code
Python
primary language
5
measurements over time
What this system is
Features
Add Databricks installation and operationalization tool
Introduces a new \tools/databricks\_install.py\ script that automates the installation of the Recommenders package onto Databricks clusters. The tool handles prerequisite PyPI package installation, optional MMLSpark Maven library setup, and operationalization steps such as downloading and uploading specific CosmosDB Spark JARs to DBFS based on the cluster's Spark version.
tools · high confidence
Add GeoIMC model for matrix completion with side information
Introduces the GeoIMC (Geometric Matrix Completion) model, which leverages row and column side features to improve recommendation accuracy. The implementation includes data handling for datasets like MovieLens-100K, a core optimization algorithm using Pymanopt on Stiefel and Symmetric Positive Definite manifolds, and an inference module supporting dot-product similarity with mean or top-k transformations.
recommenders/models/geoimc · high confidence
Add ImplicitCF data processing class for GCN models
Introduces the ImplicitCF class in the DataModel module to handle data processing for Graph Convolutional Network (GCN) models using implicit feedback. This new component manages the initialization of training and test sets, reindexes user and item IDs, filters records based on ratings, and generates normalized adjacency matrices for model training.
recommenders/models/deeprec/DataModel · high confidence
Add KDD 2020 tutorial utility scripts for Microsoft Academic Graph data processing
Added utility modules (PandasMagClass, data\_helper, general, task\_helper) to the KDD 2020 tutorial example. These scripts provide helper functions for loading and parsing Microsoft Academic Graph (MAG) datasets, including reading tab-separated stream files into Pandas DataFrames, mapping entities and relations to indices, and generating feature files for tutorial notebooks.
_examples/07\tutorials/KDD2020-tutorial/utils · high confidence
Add NNI integration scripts for NCF and SVD model tuning
New files in recommenders/tuning/nni provide the training and utility scripts required to integrate Neural Collaborative Filtering (NCF) and Surprise SVD models with the Neural Network Intelligence (NNI) hyperparameter tuning framework. The ncf\_training.py and svd\_training.py modules handle data loading, model fitting, metric evaluation, and reporting results back to NNI, while nni\_utils.py and ncf\_utils.py supply helper functions for managing the NNI experiment lifecycle and computing test metrics.
recommenders/tuning/nni · high confidence
Add PyTorch implementation of xDeepFM model
Users can now use the xDeepFM (eXtreme Deep Factorization Machine) model within the PyTorch framework. This new module includes the full xDeepFM architecture, featuring a Compressed Interaction Network (CIN) for explicit feature interactions, alongside configurable linear, factorization machine (FM), and deep neural network (DNN) components. The implementation also introduces a shared \FcnNet\ scoring head, allowing models to reduce feature vectors to a single logit with customizable activation, dropout, and batch normalization settings. Also in this area: 6 commits (1 fix) modifying recommenders.
recommenders/models/deeprec/models/pytorch · medium confidence · unverified
Add operationalization examples for Azure ML, AKS, and Databricks
The \examples/05\_operationalize\ directory now includes three notebooks demonstrating how to build, evaluate, and deploy recommendation systems on Azure. The \als\_movie\_o16n\ notebook provides an end-to-end example of a Spark ALS movie recommender using Azure Databricks, Cosmos DB, and Azure Kubernetes Service (AKS). The \lightgbm\_criteo\_o16n\ notebook shows how to deploy a content-based personalization model (LightGBM) for ad click prediction using Azure ML and AKS. Additionally, the \aks\_locust\_load\_test\ notebook demonstrates how to perform load testing on a deployed AKS service using Locust.
_examples/05\operationalize · high confidence
Add parameter sweep utility for hyperparameter tuning
The \recommenders/tuning\ module now includes a \parameter\_sweep.py\ file that provides a \generate\_param\_grid\ function. This utility allows users to convert a dictionary of parameter options into a list of parameter combinations, facilitating automated hyperparameter tuning by generating all necessary keyword argument sets for model builders.
recommenders/tuning · high confidence
Add pysarplus\_dummy package to support Spark 3.x packaging
The contrib/sarplus/scala/python area now includes a new dummy Python package (pysarplus\_dummy) and its setup configuration. This package is designed to trigger Spark packaging processes, ensuring compatibility with Spark 3.x as indicated by the upgrade context. The package reads its version from a shared VERSION file and includes the standard MIT license header.
contrib/sarplus/scala/python · high confidence
Add sequential recommendation models (A2SVD, Caser, GRU, NextItNet, SUM)
New sequential recommendation models are now available in the \recommenders\ library, including A2SVD (Attentive Asynchronous Singular Value Decomposition), Caser (Convolutional Sequence Embedding), GRU, NextItNet (Dilated CNN with residual blocks), and SUM (Sequential User Matrix). These models extend the \SequentialBaseModel\ and support item and category history embeddings, allowing users to leverage sequence-aware architectures for personalized recommendations.
recommenders/models/deeprec/models/sequential · high confidence
Added Cornac model wrappers and utility functions for recommendation and ranking
This change introduces new Python modules in the \recommenders/models/cornac\ directory to integrate the Cornac library with the Recommenders framework. It adds a custom \BPR\ class that extends Cornac's base BPR model with a \recommend\_k\_items\ method, enabling top-k item recommendations per user with an option to exclude previously seen items. Additionally, it provides \cornac\_utils.py\ containing helper functions \predict\ for computing individual rating predictions and \predict\_ranking\ for generating full user-item score matrices, both designed to facilitate the calculation of ranking metrics like NDCG.
recommenders/models/cornac · high confidence
Added utility functions for integrating Surprise library with pandas DataFrames
This change introduces the \recommenders/models/surprise\ module, providing helper utilities to bridge the Surprise recommendation library with pandas. It adds \surprise\_trainset\_to\_df\ to convert Surprise training sets into DataFrames, and \predict\ and \compute\_ranking\_predictions\ to generate rating and ranking predictions (with optional removal of seen items) from Surprise algorithms, enabling users to compute metrics like RMSE and NDCG more easily.
recommenders/models/surprise · high confidence
Initial release of SARplus recommendation library
Adds the SARplus project to the contrib directory, providing a scalable, neighborhood-based recommendation algorithm for Spark. The package includes a Python API (pysarplus) with a C++ backend for fast predictions, alongside a Scala formatter for efficient memory mapping. The release is version 0.6.6 and includes documentation for usage on Databricks and Azure Synapse, as well as specific support for Spark 3.2+ via a separate Maven artifact.
contrib/sarplus · high confidence
Initial repository structure and documentation added
The repository is initialized with core documentation files including AUTHORS.md (listing maintainers and contributors), CODE\_OF\_CONDUCT.md (adopting the LF AI & Data standard), CONTRIBUTING.md (defining the staging-branch workflow and coding guidelines), GLOSSARY.md (defining recommendation system terminology), LICENSE (MIT), MANIFEST.in, and NEWS.md (recording the project's history from pre-release to the 1.2.1 update and 20,000-star milestone). The README.md provides an overview of the project's objective to support recommendation system prototyping, lists available algorithms (e.g., SAR, ALS, Deep Learning models), and details installation instructions using uv and pip, including environment extras for GPU, Spark, and development.
(repo-wide) · high confidence
Introduce RLRMC matrix completion model
Added the RLRMC (Robust Low-Rank Matrix Completion) algorithm, which performs matrix completion using a Riemannian conjugate gradient optimizer from the pymanopt library. The implementation includes dataset preprocessing to handle user/item reindexing and sparse matrix construction, as well as a custom conjugate gradient solver with line search capabilities for efficient optimization on Stiefel and symmetric positive definite manifolds.
recommenders/models/rlrmc · high confidence
Introduce SAR+ recommendation library for PySpark
Adds the \pysarplus\ package, providing a SAR (Similarity of Active Users) recommendation implementation for PySpark. The library includes a \SARPlus\ class for training models with configurable similarity metrics (cooccurrence, jaccard, lift) and optional time-decay formulas, and a \SARModel\ class that loads pre-trained models from \.sar\ files to perform fast predictions using a C++ backend.
contrib/sarplus/python/pysarplus · high confidence
Introduce SARplus Python package and Scala cache writer for Spark
This change adds the SARplus Python package (pysarplus) to the contrib/sarplus/python directory, providing a PySpark-compatible implementation of the SAR recommendation algorithm backed by a C++ extension for efficient memory-mapped model loading and prediction. It also introduces the Scala-side SARCacheOutputWriter and related components that enable writing SAR model caches in a binary format optimized for Spark 3.x, along with corresponding tests to validate the cache writing logic.
contrib/sarplus/python · high confidence
Introduce new dataset loaders and splitters for MovieLens, Criteo, MIND, and Amazon Reviews
This change adds a comprehensive set of new dataset utilities to the \recommenders/datasets\ module. It introduces dedicated loaders for the MovieLens, Criteo DAC, MIND, and Amazon Reviews datasets, including support for both Pandas and PySpark DataFrames where applicable. The Criteo loader now uses Hugging Face URLs and specifies explicit data types to reduce memory usage. Additionally, it provides Python and Spark-based data splitters (random, chronological, and stratified) with configurable ratios, seeds, and minimum rating filters, along with utility functions for downloading, extracting, and validating data files.
recommenders/datasets · high confidence
Introduce recommenders/utils package with system, GPU, and notebook utilities
The new recommenders/utils package provides a collection of helper modules for system resource monitoring, GPU management, and Jupyter notebook execution. general\_utils adds functions to retrieve physical memory and processor counts. gpu\_utils replaces previous implementations with a PyTorch-only approach to detect GPU count, retrieve device information, and check CUDA/cuDNN versions. notebook\_utils introduces programmatic notebook execution with parameter injection and metadata storage, while notebook\_memory\_management enables interactive memory profiling within IPython sessions. k8s\_utils offers estimation functions for scaling replicas based on QPS, processing time, and node cores. Additional modules include constants for default column names, plot helpers for line graphs, and python\_utils for similarity metrics (Jaccard, Lift, Cosine) and top-K extraction.
recommenders/utils · high confidence
Introduction of collaborative filtering deep dive notebooks
The examples/02\_model\_collaborative\_filtering directory now includes a comprehensive set of Jupyter notebooks providing deep dives into various collaborative filtering algorithms. The collection covers Spark-based ALS, baseline performance estimation, and models from the Cornac library such as BiVAE and BPR. It also includes implementations for Factorization Machines (FM), LightFM, LightGCN, Multi-VAE, Neural Collaborative Filtering (NCF), Restricted Boltzmann Machines (RBM), SAR, Standard VAE, and Surprise SVD. A README file documents each notebook, specifying the required environment (e.g., PySpark, Python CPU/GPU) and providing a description of the algorithm and implementation details.
_examples/02\_model\_collaborative\filtering · high confidence
New Azure ML Designer modules for SAR model training, scoring, and evaluation metrics
Added entry-point scripts for the Azure ML Designer to support the Sequential Auto-Recommender (SAR) model and related evaluation metrics. Users can now train SAR models using the \train\_sar\_entry\ module, generate item recommendations or rating predictions via \score\_sar\_entry\, and evaluate model performance using new modules for MAP, nDCG, Precision@K, and Recall@K. Additionally, a \stratified\_splitter\_entry\ module is included to facilitate data splitting for training and testing.
_contrib/azureml\_designer\modules/entries · high confidence
New AzureML notebook submission example and notebook template
Added a new \run\_notebook\_on\_azureml.ipynb\ example that allows users to submit existing Jupyter notebooks directly to Azure Machine Learning compute targets without rewriting training scripts, and introduced a \template.ipynb\ to standardize notebook structure and metadata handling for the examples directory.
examples · high confidence
New LightFM utility functions for evaluation and similarity
Added \lightfm\_utils.py\ to the LightFM model package, introducing helper functions for tracking model performance metrics (\track\_model\_metrics\), plotting results (\model\_perf\_plots\, \compare\_metric\), and finding similar users or items (\similar\_users\, \similar\_items\) using cosine similarity. These utilities simplify the evaluation and analysis workflow for LightFM-based recommenders.
recommenders/models/lightfm · high confidence
New LightGBM utility module for feature engineering
Added a new \lightgbm\_utils.py\ module containing the \NumEncoder\ class and \unpackbits\ helper function. This utility provides automated feature engineering for LightGBM models, specifically handling categorical and numerical data through sequential label encoding, count encoding, binary encoding, and target encoding (mean and count). It also includes logic for filtering low-frequency categories and handling missing values, allowing users to preprocess dataframes into the numerical format required by LightGBM.
recommenders/models/lightgbm · high confidence
New MIND data iterators for news recommendation models
Added MINDAllIterator and MINDIterator classes in the recommenders.models.newsrec.io module to handle data loading for the NAML model. These iterators process MIND dataset formats, parsing news titles, abstracts, and user behavior logs into feature tensors, with support for negative sampling and efficient mini-batch processing without loading entire datasets into memory.
recommenders/models/newsrec/io · high confidence
New Python and Spark evaluation modules for recommender metrics
The \recommenders/evaluation\ package now provides dedicated Python (\python\_evaluation.py\) and Spark (\spark\_evaluation.py\) modules for computing recommendation metrics. The Python module offers functions for rating metrics (RMSE, MAE, R², explained variance, ROC-AUC, log-loss) and ranking metrics (Precision@K, Recall@K, NDCG@K, MAP, R-Precision) with built-in column validation and caching. The Spark module introduces \SparkRatingEvaluation\ and \SparkRankingEvaluation\ classes that leverage PySpark DataFrames, including a fix for explained variance to avoid values \> 1 by using variance calculations instead of the buggy Spark MLLib implementation.
recommenders/evaluation · high confidence
New content-based filtering deep-dive notebooks for DKN, LightGBM, and Vowpal Wabbit
This location now provides three new Jupyter notebooks that offer detailed, step-by-step guides for implementing content-based recommendation algorithms. The \dkn\_deep\_dive.ipynb\ notebook demonstrates the Deep Knowledge-Aware Network (DKN) for news recommendation using the MIND dataset and TensorFlow. The \mmlspark\_lightgbm\_criteo.ipynb\ notebook shows how to train a LightGBM model for CTR prediction on the Criteo dataset using MMLSpark and PySpark. The \vowpal\_wabbit\_deep\_dive.ipynb\ notebook provides a comprehensive look at using Vowpal Wabbit for regression and matrix factorization on the MovieLens dataset, including explicit parameter tuning for learning rate and regularization. These notebooks serve as practical examples for users looking to apply these specific models in their recommendation systems.
_examples/02\_model\_content\_based\filtering · high confidence
New data iterators and PyTorch loaders for DKN, NextItNet, and FFM formats
This change introduces new data-loading components in the \recommenders/models/deeprec/io\ package. It adds \DKNTextIterator\ and \DKNItem2itemTextIterator\ for loading news recommendation data for the DKN model, including item-to-item variants. It also adds \NextItNetIterator\ for sequential recommendation data. Additionally, it introduces \FFMDataset\ as a PyTorch-compatible loader for FFM-format input used by xDeepFM, and \SequentialDataset\ as a PyTorch port of the existing \SequentialIterator\ for sequential recommendation models like SLi-Rec. These loaders handle parsing, batching, and feature preparation for their respective model architectures.
recommenders/models/deeprec/io · high confidence
New data preparation notebooks for splitting, transformation, and knowledge graphs
The \examples/01\_prepare\_data\ directory now includes a set of documentation notebooks to guide users through common data preparation tasks. The \data\_split\ notebook demonstrates random, chronological, and stratified splitting strategies for both Spark and pandas DataFrames using the MovieLens dataset. The \data\_transform\ notebook covers techniques for handling explicit and implicit feedback in collaborative filtering scenarios. Additionally, \mind\_utils\ provides examples for generating dictionaries and embeddings for the MIND news recommendation dataset, while \wikidata\_knowledge\_graph\ shows how to extract and construct knowledge graphs from Wikidata for algorithms like DKN and RippleNet.
_examples/01\_prepare\data · high confidence
New evaluation example notebooks for accuracy and diversity metrics
Added \evaluation.ipynb\ and \als\_movielens\_diversity\_metrics.ipynb\ to the \examples/03\_evaluate\ directory, along with a \README.md\ to document them. The \evaluation\ notebook demonstrates how to calculate standard rating metrics (RMSE, MAE, R²), ranking metrics (Precision, Recall, NDCG, MAP), and classification metrics (AUC, Logloss) using both Python/CPU and PySpark evaluation classes. The \als\_movielens\_diversity\_metrics\ notebook illustrates non-accuracy metrics—specifically catalog and distributional coverage, novelty, diversity, and serendipity—by comparing an ALS recommender against a random baseline in a PySpark environment.
_examples/03\evaluate · high confidence
New hyperparameter tuning examples for Spark ALS, AzureML SVD, and NNI
Added new notebooks in the \examples/04\_model\_select\_and\_optimize\ directory to demonstrate hyperparameter tuning for recommender models. The \tuning\_spark\_als.ipynb\ notebook shows how to tune Spark ALS using Spark native constructs and the \hyperopt\ package. The \azureml\_hyperdrive\_surprise\_svd.ipynb\ notebook provides a quickstart for tuning Surprise SVD using Azure Machine Learning HyperDrive. Additionally, \nni\_surprise\_svd.ipynb\ and \nni\_ncf.ipynb\ demonstrate using the Neural Network Intelligence (NNI) toolkit to tune Surprise SVD and Neural Collaborative Filtering (NCF) models, respectively. A supporting training script \train\_scripts/svd\_training.py\ is also included to facilitate the NNI and AzureML experiments.
_examples/04\_model\_select\_and\optimize · high confidence
New quick-start notebooks for GeoIMC, EmbeddingDotBias, and LightGBM LambdaRank
The quick-start directory now includes three new algorithm demonstrations: Geometry Aware Inductive Matrix Completion (GeoIMC) for movie ratings using Pymanopt, EmbeddingDotBias for collaborative filtering using PyTorch, and LightGBM LambdaRank for learning-to-rank on MovieLens. These notebooks are also listed in the updated README alongside existing examples for ALS, DKN, and others, providing users with additional end-to-end pipelines for data preparation, model building, and evaluation.
_examples/00\_quick\start · high confidence
PyTorch port of the SLi-Rec sequential recommender model
A new PyTorch implementation of the SLi-Rec model is now available in the sequential recommenders module. This port introduces a time-aware LSTM cell (Time4LSTMCell) that modulates cell-state updates using scalar time features, alongside shared building blocks like a long-term ASVD attention mechanism and an MLP prediction head. The model fuses long-term history attention with short-term time-aware LSTM outputs, enabling users to run the SLi-Rec algorithm using PyTorch instead of the previous TensorFlow backend.
recommenders/models/deeprec/models/sequential/pytorch · high confidence
TF-IDF Recommender now supports BERT and SciBERT tokenization
The TF-IDF recommender in the recommenders package has been enhanced to support advanced tokenization methods beyond basic NLTK stemming or no tokenization. Users can now specify 'bert' or 'scibert' as the tokenization method, which utilizes pre-trained Hugging Face transformers (bert-base-cased or allenai/scibert\_scivocab\_cased) to tokenize text before TF-IDF vectorization. This allows for more nuanced content-based recommendations by leveraging contextual embeddings from these models, in addition to the existing 'nltk' and 'none' options.
recommenders/models/tfidf · high confidence
Behavioural changes
Add Spark 3.2.x compatibility macro for OutputWriter.path
A new Scala macro annotation, @since3p2defvisible, has been added to the compatibility layer to handle API differences in Spark 3.2.x. This annotation conditionally exposes methods based on the presence of the 'path' member in the OutputWriter class, ensuring that code using this compatibility module works correctly across different Spark versions without runtime errors.
contrib/sarplus/scala/compat · high confidence
Added configuration validation for NewsRec models
The newsrec module now includes a utility script that validates configuration parameters for neural news recommendation models (NRMS, NAML, LSTUR, NPA). This change ensures that users receive clear errors if required parameters are missing or if parameter types (int, float, str, list, bool) do not match expectations, improving the robustness of model initialization.
recommenders/models/newsrec · high confidence
DeepRec models migrated to TensorFlow 2.x compatibility
The deep learning recommendation models (DKN, XDeepFM, and their variants) have been updated to run on TensorFlow 2.x. This change replaces deprecated TensorFlow 1.x APIs with their \tf.compat.v1\ equivalents, disables eager execution to maintain the existing graph-based logic, and removes dependencies on removed libraries such as \tf.contrib.training.HParams\ and \tf.addons\. Users will see no change in model architecture or output, but the code is now compatible with modern TensorFlow versions.
recommenders/models/deeprec/models · high confidence
Introduce PyTorch-based EmbeddingDotBias collaborative filtering model
Added a new PyTorch implementation of the EmbeddingDotBias model for collaborative filtering, replacing the previous fastai dependency. This change introduces a new data loading pipeline (RecoDataset and RecoDataLoader) that handles user/item ID mapping and train/validation splitting, a core model class using embedding layers and bias terms for rating prediction, and a dedicated Trainer class for training and validation loops. Utility functions for scoring recommendations and computing Cartesian products are also included to support the new model's inference workflow.
recommenders/models/embdotbias · high confidence
Introduce structured benchmarking utilities and notebook for collaborative filtering algorithms
Users can now run a standardized comparison of collaborative filtering algorithms (such as Spark ALS, SAR, LightGCN, and EmbDotBias) on the MovieLens dataset using the new \benchmark\_utils.py\ module and the \movielens.ipynb\ notebook. This change replaces previous ad-hoc benchmarking scripts with a unified framework that handles data preparation, model training, and evaluation across CPU, GPU, and Spark environments, while also correcting metric calculations (e.g., using \map\_at\_k\ instead of \map\ and filtering test sets for BPR) to ensure accurate performance reporting.
_examples/06\benchmarks · high confidence
KDD 2020 tutorial migrated to uv and updated data sources
The KDD 2020 tutorial example has been updated to use \uv\ for environment and dependency management instead of conda, with setup instructions now referencing \uv venv\ and \uv pip install\. The tutorial data is now downloaded from a Hugging Face dataset repository (\Recommenders/kdd2020\) rather than the previous storage location. Additionally, the tutorial notebooks have been refactored to use the new \recommenders\ package structure and updated utility modules (e.g., \utils\ instead of \common\), while model configuration files for DKN and LightGCN have been added to support the hands-on experiments.
_examples/07\tutorials/KDD2020-tutorial · high confidence
LightGCN model migrated to PyTorch
The LightGCN recommendation model has been rewritten from TensorFlow to PyTorch, introducing a new \LightGCN\ class that manages user and item embeddings via \nn.Embedding\ and performs graph propagation using sparse matrix multiplication. This change updates the underlying framework for this specific graph-based recommender, affecting how the model is instantiated, trained, and evaluated within the \recommenders\ library.
recommenders/models/deeprec/models/graphrec · high confidence
Migrate VAE models from TensorFlow to PyTorch
The Variational Autoencoder (VAE) implementations in the recommenders library have been rewritten in PyTorch, replacing the previous TensorFlow versions. This change introduces new \StandardVAE\ and \MultVAE\ classes in \recommenders/models/vae/\, which now utilize PyTorch's \nn.Module\ for model architecture, \torch.optim.Adam\ for optimization, and native PyTorch operations for loss calculation (binary cross-entropy for standard VAE, multinomial log-likelihood for MultVAE). Users should expect potential differences in numerical results due to the framework switch and different default initializations, although the API surface remains largely consistent for training and inference.
recommenders/models/vae · high confidence
NewsRec models migrated to TensorFlow 1.x compatibility layer
The NewsRec model implementations (LSTUR, NAML, NPA, NRMS) and their shared base class and layers have been updated to use the \tensorflow.compat.v1\ API. This change switches the underlying framework usage from native TensorFlow 2.x to the TensorFlow 1.x compatibility layer, which alters how sessions, graphs, and Keras layers are initialized and executed within these models.
recommenders/models/newsrec/models · high confidence
RBM model ported from TensorFlow to PyTorch
The Restricted Boltzmann Machine (RBM) implementation in \recommenders/models/rbm\ has been migrated from TensorFlow to PyTorch. This change replaces the underlying framework, updating the model class to inherit from \torch.nn.Module\ and utilizing PyTorch tensors and operations for parameter initialization, one-hot encoding, and training logic. Users should expect the model to now require PyTorch dependencies and may see differences in performance characteristics or numerical precision compared to the previous TensorFlow version.
recommenders/models/ncf, recommenders/models/rbm · high confidence
Recommenders package renamed and version bumped to 1.2.1
The package has been renamed from \reco\_utils\ to \recommenders\, requiring users to install and import using the new name. The version has been updated to 1.2.1, and the \recommenders/models\ submodule has been initialized to support the new package structure.
recommenders · high confidence
Renamed deeprec module to recommenders
The \deeprec\ module has been renamed to \recommenders\ to align with the broader project rebranding. This change updates the package structure and internal references, ensuring that users importing from \recommenders.models.deeprec\ will now find the utilities and models under the new \recommenders\ namespace. The core functionality, including configuration validation and utility functions for deep learning models, remains intact but is now accessible via the updated path.
recommenders/models/deeprec · high confidence
SAR model refactored with new similarity metrics and NumPy 2 compatibility
The SAR (Simple Algorithm for Recommendations) implementation has been updated to support multiple item similarity metrics, including cooccurrence, cosine, inclusion index, jaccard, lexicographers mutual information, lift, and mutual information. The code has been refactored to ensure compatibility with NumPy 2 by replacing deprecated \np.NaN\ with \np.nan\. Additionally, the model now handles duplicate user-item pairs by raising an error during fitting and computes user frequencies separately to improve accuracy and performance.
recommenders/models/sar · high confidence
SASRec and SSEPT models ported to PyTorch
The SASRec and SSEPT recommendation models in the \recommenders/models/sasrec\ package have been rewritten from TensorFlow to PyTorch. This change introduces new model implementations (\model.py\, \ssept.py\) using PyTorch modules for multi-head attention and feed-forward layers, along with a PyTorch-compatible data sampler (\sampler.py\) and dataset utility (\util.py\) for handling user-item interactions and train/validation/test splits.
recommenders/models/sasrec · high confidence
Updated build infrastructure for SAR+ Scala packaging
The build configuration for the SAR+ Scala component has been updated to support Spark 3.x and improve the packaging process. The sbt version is upgraded to 1.6.2, and build plugins for code coverage (sbt-scoverage 1.9.3) and PGP signing (sbt-pgp 2.1.2) are added. A new utility function is introduced to correctly classify and name JAR artifacts for Spark 3.2 and later versions, ensuring compatibility with newer Spark releases.
contrib/sarplus/scala/project · high confidence
Vowpal Wabbit model wrapper refactored with parallel scoring and explicit parameters
The Vowpal Wabbit model implementation has been rewritten to use the native \vowpalwabbit\ Python bindings directly, replacing the previous subprocess-based approach. This change introduces parallel prediction scoring via \ProcessPoolExecutor\ (controlled by the new \n\_jobs\ parameter) for improved performance, moves training hyperparameters like epochs and learning rate into the \fit()\ method, and makes the logistic binarization threshold an explicit constructor argument. The model now supports saving and loading, and includes a \recommend\_k\_items\ method for generating recommendations.
_recommenders/models/vowpal\wabbit · high confidence
Wide & Deep model implementation migrated to PyTorch
The Wide & Deep recommendation model in the recommenders library has been rewritten from TensorFlow to PyTorch. This change introduces a new \WideDeepModel\ class that defines the wide (linear sparse features) and deep (DNN embeddings) components using native PyTorch layers, along with a complete training and inference API (\fit\, \predict\, \recommend\_k\_items\) built on PyTorch's \Dataset\ and \DataLoader\ utilities.
_recommenders/models/wide\deep · high confidence
Test coverage
Add GPU, PySpark, and Python smoke tests for example notebooks; Add functional tests for example notebooks; Add unit tests for example notebooks across Python, GPU, and PySpark environments; Added \_\init\\.py files to test directories; Added \\init\\_.py to enable AzureML test execution; Added data validation tests for recommender datasets; Added init file for AzureML integration tests; Added integration tests for Kubernetes utility functions; Added performance benchmarks for Python evaluation metrics; Added privacy validation tests for Criteo and Movielens datasets; Added regression tests for TensorFlow compatibility; Added smoke tests for deep learning recommender models and utilities; Added test package initialization for AzureML data validation; Added tests for MIND and Wikidata data validation notebooks; Added tests for dependency security versions; Added unit tests for Python and Spark recommender evaluation metrics; Added unit tests for dataset utilities and splitting logic; Added unit tests for recommender tuning utilities; Added unit tests for recommenders utils; Initial test suite for PySARPlus; Introduce comprehensive test infrastructure and documentation; New unit tests for recommenders models.
Dependencies
Add build and dependency manifests for SARplus and documentation
This change introduces build configuration files for the SARplus library and the project documentation. For SARplus, a Python \pyproject.toml\ defines build requirements including \setuptools\>=58.0.0\ and \wheel\, while a Scala \build.sbt\ configures dependencies for Spark (defaulting to 3.2.1) and Hadoop, and implements support for Scala 2.13+ by switching from the \paradise\ plugin to \-Ymacro-annotations\. Additionally, a root \pyproject.toml\ establishes build dependencies (\setuptools\, \wheel\, \numpy\) and registers custom pytest markers (e.g., \experimental\, \gpu\), and \docs/requirements-doc.txt\ specifies \jupyter-book\>=1.0.0\ for documentation generation.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 56.9 → 55.1 (-1.8)
- Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 54.0 → 49.3 (-4.7)
- Architecture 92.9 → 94.0 (+1.1)
- Maturity 56.7 → 61.8 (+5.1)
- Readiness 53.6 → 51.8 (-1.8)
- Security 67.3 → 67.3 (0.0)
Resolved (13)
- Duplicated block (14 lines × 2) (recommenders/models/newsrec/io/mind_all_iterator.py)
- Duplicated block (16 lines × 2) (recommenders/models/sasrec/model.py)
- Duplicated block (19–25 lines × 2) (recommenders/models/deeprec/deeprec_utils.py)
- Duplicated block (35–36 lines × 2) (recommenders/models/deeprec/io/sequential_dataset.py)
- Duplicated block (35–37 lines × 2) (recommenders/models/deeprec/io/sequential_dataset.py)
- Duplicated block (6 lines × 2) (recommenders/tuning/nni/ncf_training.py)
- Further sole-owners (lower concentration)
- Near-duplicate member pair (118 shared lines) (recommenders/models/deeprec/io/sequential_dataset.py)
- Near-duplicate member pair (26 shared lines) (recommenders/tuning/nni/ncf_training.py)
- Near-duplicate member pair (70 shared lines) (recommenders/models/deeprec/io/sequential_dataset.py)
- Off-boarding risk: anonymized user #1
- Off-boarding risk: anonymized user #2
- Projects may be oversized for their cohesion
New (45)
- Edited copies of one member (3 members, 17+ corresponding lines) (examples/07_tutorials/KDD2020-tutorial/utils/data_helper.py)
- Edited copies of one member (3 members, 19+ corresponding lines) (recommenders/utils/python_utils.py)
- Edited copies of one member (3 members, 27+ corresponding lines) (recommenders/models/newsrec/io/mind_all_iterator.py)
- Edited copy of a member (10 corresponding lines) (examples/06_benchmarks/benchmark_utils.py)
- Edited copy of a member (10 corresponding lines) (recommenders/datasets/amazon_reviews.py)
- Edited copy of a member (10 corresponding lines) (recommenders/models/deeprec/models/sequential/caser.py)
- Edited copy of a member (104 corresponding lines) (recommenders/models/deeprec/io/sequential_dataset.py)
- Edited copy of a member (11 corresponding lines) (recommenders/models/deeprec/models/graphrec/lightgcn.py)
- Edited copy of a member (12 corresponding lines) (recommenders/models/vae/multinomial_vae.py)
- Edited copy of a member (13 corresponding lines) (recommenders/models/deeprec/models/pytorch/dkn.py)
- Edited copy of a member (13 corresponding lines) (recommenders/models/newsrec/models/base_model.py)
- Edited copy of a member (14 corresponding lines) (recommenders/models/deeprec/models/base_model.py)
- Edited copy of a member (18 corresponding lines) (contrib/sarplus/scala/src/main/scala/com/microsoft/sarplus/SARCacheOutputWriter.scala)
- Edited copy of a member (18 corresponding lines) (recommenders/models/deeprec/deeprec_utils.py)
- Edited copy of a member (20 corresponding lines) (recommenders/models/deeprec/models/base_model.py)
- Edited copy of a member (20 corresponding lines) (recommenders/models/deeprec/models/pytorch/dkn.py)
- Edited copy of a member (20 corresponding lines) (recommenders/models/deeprec/models/sequential/gru.py)
- Edited copy of a member (20 corresponding lines) (recommenders/models/newsrec/models/nrms.py)
- Edited copy of a member (21 corresponding lines) (examples/07_tutorials/KDD2020-tutorial/utils/task_helper.py)
- Edited copy of a member (21 corresponding lines) (recommenders/models/deeprec/models/base_model.py)
- …and 25 more
Changes since last survey
- 2 commits — 0 feature/other, 2 fixes
By area
- (repo) — 2 commits
Notable commits
- fix: Merge branch 'main' into fix/issue-2387-bug-get-top-k-scored-items-returns-all-i
- fix: Merge pull request #2405 from ShryukGrandhi/fix/issue-2387-bug-get-top-k-scored-items-returns-all-i
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
recommenders-team/recommenders was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit cc47866b0599721f8544d1cc850a5a1db091acb3 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.84+preprod-d645ca9bbedd.