ENMF

This is our implementation of Efficient Neural Matrix Factorization, which is a basic model of the paper:

Chong Chen, Min Zhang, Chenyang Wang, Weizhi Ma, Minming Li, Yiqun Liu and Shaoping Ma. 2019. An Efficient Adaptive Transfer Neural Network for Social-aware Recommendation. In SIGIR'19.

This is also the codes of the TOIS paper:

Chong Chen, Min Zhang, Yongfeng Zhang, Yiqun Liu and Shaoping Ma. 2020. Efficient Neural Matrix Factorization without Sampling for Recommendation. In TOIS Vol. 38, No. 2, Article 14.

The slides of this work has been uploaded. A chinese version instruction can be found at Blog, and the video presentation can be found at Demo.

Please cite our SIGIR'19 paper or TOIS paper if you use our codes. Thanks!

@inproceedings{chen2019efficient,
  title={An Efficient Adaptive Transfer Neural Network for Social-aware Recommendation},
  author={Chen, Chong and Zhang, Min and Wang, Chenyang and Ma, Weizhi and Li, Minming and Liu, Yiqun and Ma, Shaoping},
  booktitle={Proceedings of the 42nd International ACM SIGIR Conference on Research and Development in Information Retrieval},
  pages={225--234},
  year={2019},
  organization={ACM}
}

@article{10.1145/3373807, 
author = {Chen, Chong and Zhang, Min and Zhang, Yongfeng and Liu, Yiqun and Ma, Shaoping}, 
title = {Efficient Neural Matrix Factorization without Sampling for Recommendation}, 
year = {2020}, 
issue_date = {January 2020}, 
publisher = {Association for Computing Machinery}, 
volume = {38}, 
number = {2}, 
issn = {1046-8188}, 
url = {https://doi.org/10.1145/3373807}, 
doi = {10.1145/3373807}, 
journal = {ACM Trans. Inf. Syst.}, 
month = jan, 
articleno = {Article 14}, 
numpages = {28}
}

Author: Chong Chen ([email protected])

Environments

• python
• Tensorflow
• numpy
• pandas

Example to run the codes

Train and evaluate the model:

python ENMF.py

Suggestions for parameters

Two important parameters need to be tuned for different datasets, which are:

parser.add_argument('--dropout', type=float, default=0.7,
                        help='dropout keep_prob')
parser.add_argument('--negative_weight', type=float, default=0.1,
                        help='weight of non-observed data')

Specifically, we suggest to tune "negative_weight" among [0.001,0.005,0.01,0.02,0.05,0.1,0.2,0.5]. Generally, this parameter is related to the sparsity of dataset. If the dataset is more sparse, then a small value of negative_weight may lead to a better performance.

Generally, the performance of our ENMF is better than existing state-of-the-art recommendation models like NCF, CovNCF, CMN, and NGCF. You can also contact us if you can not tune the parameters properly.

Comparison with the most recent methods （updating）

Do the "state-of-the-art" recommendation models really perform well? If you want to see more comparison between our ENMF and any "state-of-the-art" recommendation models, feel free to propose an issue.

1. LightGCN (SIGIR 2020) LightGCN: Simplifying and Powering Graph Convolution Network for Recommendation.

To be consistent with LightGCN, we use the same evaluation metrics (i.e., Recall@K and NDCG@K), use the same data Yelp2018 released in LightGCN (https://github.com/kuandeng/LightGCN).

The parameters of our ENMF on Yelp2018 are as follows:

parser.add_argument('--dropout', type=float, default=0.7,
                        help='dropout keep_prob')
parser.add_argument('--negative_weight', type=float, default=0.05,
                        help='weight of non-observed data')

Dataset: Yelp2018

2. NBPO (SIGIR 2020) Sampler Design for Implicit Feedback Data by Noisy-label Robust Learning.

This paper designs an adaptive sampler based on noisy-label robust learning for implicit feedback data. To be consistent with NBPO, we use the same evaluation metrics (i.e., F1@K, NDCG@K), use the same data Amazon-14core released in NBPO (https://github.com/Wenhui-Yu/NBPO). For fair comparison, we also set the embedding size as 50, which is utilized in the NBPO work.

The parameters of our ENMF on Amazon-14core are as follows:

parser.add_argument('--dropout', type=float, default=0.2,
                        help='dropout keep_prob')
parser.add_argument('--negative_weight', type=float, default=0.2,
                        help='weight of non-observed data')

Dataset: Amazon-14core

3. LCFN (ICML 2020)Graph Convolutional Network for Recommendation with Low-pass Collaborative Filters

To be consistent with LCFN, we use the same evaluation metrics (i.e., F1@K, NDCG@K), use the same data Movlelens-1m released in LCFN (https://github.com/Wenhui-Yu/LCFN). For fair comparison, we also set the embedding size as 128, which is utilized in the LCFN work.

The parameters of our ENMF on Movielens-1m (ml-lcfn) are as follows:

parser.add_argument('--dropout', type=float, default=0.5,
                        help='dropout keep_prob')
parser.add_argument('--negative_weight', type=float, default=0.5,
                        help='weight of non-observed data')

Dataset: Movielens-1m (ml-lcfn)

4. DHCF (KDD 2020)Dual Channel Hypergraph Collaborative Filtering

To be consistent with DHCF, we use the same evaluation metrics (i.e., Precision@K, Recall@K), use the same data CiteUlike-A (thanks for the authors of DHCF who kindly provide the dataset). For fair comparison, we also set the embedding size as 64, which is utilized in the DHCF work.

The parameters of our ENMF on CiteUlike-A are as follows:

parser.add_argument('--dropout', type=float, default=0.5,
                        help='dropout keep_prob')
parser.add_argument('--negative_weight', type=float, default=0.02,
                        help='weight of non-observed data')

Dataset: CiteUlike-A

5. SRNS (NeurIPS 2020)Simplify and Robustify Negative Sampling for Implicit Collaborative Filtering

This work proposes a simplified and robust negative sampling approach SRNS for implicit CF. The authors have compared their SRNS method with our ENMF in the original paper. However, we reran the experiment and got some different results.

To be consistent with SRNS, we use the same evaluation metrics (i.e., NDCG@K, Recall@K), use the same data Movlelens-1m released in SRNS (https://github.com/dingjingtao/SRNS). For fair comparison, we also set the embedding size as 32, which is utilized in the SRNS work.

The parameters of our ENMF on Movielens-1m(ml-srns) are as follows:

parser.add_argument('--dropout', type=float, default=0.9,
                        help='dropout keep_prob')
parser.add_argument('--negative_weight', type=float, default=0.3,
                        help='weight of non-observed data')

Dataset: Movielens-1m (ml-srns)