diff --git a/.gitignore b/.gitignore index 21b735d..a7213ec 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ *.pyc polara.egg-info/ examples/.ipynb_checkpoints/ +.ipynb_checkpoints/ diff --git a/README.md b/README.md index 27d4438..f1292b4 100644 --- a/README.md +++ b/README.md @@ -2,16 +2,15 @@ Polara is the first recommendation framework that allows a deeper analysis of recommender systems performance, based on the idea of feedback polarity (by analogy with sentiment polarity in NLP). In addition to standard question of "how good a recommender system is at recommending relevant items", it allows assessing the ability of a recommender system to **avoid irrelevant recommendations** (thus, less likely to disappoint a user). You can read more about this idea in a research paper [Fifty Shades of Ratings: How to Benefit from a Negative Feedback in Top-N Recommendations Tasks](http://arxiv.org/abs/1607.04228). The research results can be easily reproduced with this framework, visit a "fixed state" version of the code at https://github.com/Evfro/fifty-shades (there're also many usage examples). - -The framework also features efficient tensor-based implementation of an algorithm, proposed in the paper, that takes full advantage of the polarity-based formulation. Currently, there is an [online demo](http://coremodel.azurewebsites.net) (for test purposes only), that demonstrates the effect of taking into account feedback polarity. +The framework also features efficient tensor-based implementation of an algorithm, proposed in the paper, that takes full advantage of the polarity-based formulation. ## Prerequisites Current version of Polara supports both Python 2 and Python 3 environments. Future versions are likely to drop support of Python 2 to make a better use of Python 3 features. -The framework heavily depends on `Pandas, Numpy, Scipy` and `Numba` packages. Better performance can be achieved with `mkl` (optional). It's also recommended to use `jupyter notebook` for experimentation. Visualization of results can be done with help of `matplotlib` and optionally `seaborn`. The easiest way to get all those at once is to use the latest [Anaconda distribution](https://www.continuum.io/downloads). +The framework heavily depends on `Pandas, Numpy, Scipy` and `Numba` packages. Better performance can be achieved with `mkl` (optional). It's also recommended to use `jupyter notebook` for experimentation. Visualization of results can be done with help of `matplotlib`. The easiest way to get all those at once is to use the latest [Anaconda distribution](https://www.continuum.io/downloads). -If you use a separate `conda` environment for testing, the following command can be used to ensure that all required dependencies are in place (see [this](http://conda.pydata.org/docs/commands/conda-install.html) for more info): +If you use a separate `conda` environment for testing, the following command can be issued to ensure that all required dependencies are in place (see [this](http://conda.pydata.org/docs/commands/conda-install.html) for more info): `conda install --file conda_req.txt` @@ -98,30 +97,26 @@ random = RandomModel(data_model) models = [i2i, svd, popular, random] metrics = ['ranking', 'relevance'] # metrics for evaluation: NDGC, Precision, Recall, etc. -folds = [1, 2, 3, 4, 5] # use all 5 folds for cross-validation +folds = [1, 2, 3, 4, 5] # use all 5 folds for cross-validation (default) topk_values = [1, 5, 10, 20, 50] # values of k to experiment with -# run experiment -topk_result = {} -for fold in folds: - data_model.test_fold = fold - topk_result[fold] = ee.topk_test(models, topk_list=topk_values, metrics=metrics) - -# rearrange results into a more friendly representation -# this is just a dictionary of Pandas Dataframes -result = ee.consolidate_folds(topk_result, folds, metrics) -result.keys() # outputs ['ranking', 'relevance'] +# run 5-fold CV experiment +result = ee.run_cv_experiment(models, folds, metrics, + fold_experiment=ee.topk_test, + topk_list=topk_values) # calculate average values across all folds for e.g. relevance metrics -result['relevance'].mean(axis=0).unstack() # use .std instead of .mean for standard deviation +scores = result.mean(axis=0, level=['top-n', 'model']) # use .std instead of .mean for standard deviation +scores.xs('recall', level='metric', axis=1).unstack('model') ``` which results in something like: -| metric/model |item-to-item | SVD | mostpopular | random | +| **model** | **MP** | **PureSVD** | **RND** | **item-to-item** | | ---: |:---:|:---:|:---:|:---:| -| *precision* | 0.348212 | 0.600066 | 0.411126 | 0.016159 | -| *recall* | 0.147969 | 0.304338 | 0.182472 | 0.005486 | -| *miss_rate* | 0.852031 | 0.695662 | 0.817528 | 0.994514 | +| **top-n** | +| **1** | 0.017828 | 0.079428 | 0.000055 | 0.024673 | +| **5** | 0.086604 | 0.219408 | 0.001104 | 0.126013 | +| **10** | 0.138546 | 0.300658 | 0.001987 | 0.202134 | | ... | ... | ... | ... | ... | ## Custom pipelines @@ -137,7 +132,7 @@ Now you are ready to build your models (as in examples above) and export them to ### Warm-start and known-user scenarios By default polara makes testset and trainset disjoint by users, which allows to evaluate models against *user warm-start*. -However in some situations (for example, when polara is used within a larger pipeline) you might want to implement strictly a *known user* scenario to assess the quality of your recommender system on the unseen (held-out) items for the known users. The change between these two scenarios as controlled by setting `data_model.warm_start` attribute to `True` or `False`. See [Warm-start and standard scenarios](examples/Warm-start and standard scenarios.ipynb) Jupyter notebook as an example. +However in some situations (for example, when polara is used within a larger pipeline) you might want to implement strictly a *known user* scenario to assess the quality of your recommender system on the unseen (held-out) items for the known users. The change between these two scenarios as controlled by setting `data_model.warm_start` attribute to `True` or `False`. See [Warm-start and standard scenarios](examples/Warm_start_and_standard_scenarios.ipynb) Jupyter notebook as an example. ### Externally provided test data If you don't want polara to perform data splitting (for example, when your test data is already provided), you can use the `set_test_data` method of a `RecommenderData` instance. It has a number of input arguments that cover all major cases of externally provided data. For example, assuming that you have new users' preferences encoded in the `unseen_data` dataframe and the corresponding held-out preferences in the `holdout` dataframe, the following command allows to include them into the data model: @@ -150,4 +145,7 @@ svd.build() svd.evaluate() ``` In this case the recommendations are generated based on the testset and evaluated against the holdout. -See more usage examples in the [Custom evaluation](examples/Custom evaluation.ipynb) notebook. +See more usage examples in the [Custom evaluation](examples/Custom_evaluation.ipynb) notebook. + +### Reproducing others work +Polara offers even more options to highly customize experimentation pipeline and tailor it to specific needs. See, for example, [Reproducing EIGENREC results](examples/Reproducing_EIGENREC_results.ipynb) notebook to learn how Polara can be used to reproduce experiments from the *"[EIGENREC: generalizing PureSVD for effective and efficient top-N recommendations](https://arxiv.org/abs/1511.06033)"* paper. diff --git a/conda_req.txt b/conda_req.txt index 1f6c8c3..de0900b 100644 --- a/conda_req.txt +++ b/conda_req.txt @@ -1,6 +1,7 @@ # This file may be used to create an environment using: # $ conda create --name --file +python>=3.6 jupyter>=1.0.0 numba>=0.21.0 numpy>=1.10.1 @@ -8,4 +9,3 @@ matplotlib>=1.4.3 pandas>=0.17.1 requests>=2.7.0 scipy>=0.16.0 -seaborn>=0.6.0 diff --git a/examples/Custom evaluation.ipynb b/examples/Custom_evaluation.ipynb similarity index 96% rename from examples/Custom evaluation.ipynb rename to examples/Custom_evaluation.ipynb index c907f76..f769d37 100644 --- a/examples/Custom evaluation.ipynb +++ b/examples/Custom_evaluation.ipynb @@ -45,7 +45,6 @@ "metadata": {}, "outputs": [], "source": [ - "from __future__ import print_function\n", "import numpy as np\n", "from polara.datasets.movielens import get_movielens_data" ] @@ -178,7 +177,8 @@ "output_type": "stream", "text": [ "Preparing data...\n", - "Done.\n" + "Done.\n", + "There are 766928 events in the training and 0 events in the holdout.\n" ] } ], @@ -466,7 +466,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "PureSVD training time: 0.0981479023320091s\n" + "PureSVD training time: 0.128s\n" ] } ], @@ -563,7 +563,10 @@ { "data": { "text/plain": [ - "Hits(true_positive=4443, false_positive=1131, true_negative=15870, false_negative=19081)" + "[Relevance(precision=0.4671998676068703, recall=0.18790260795025798, fallout=0.0587545652398142, specifity=0.7075255418074651, miss_rate=0.7362722359391265),\n", + " Ranking(nDCG=0.16791941496631102, nDCL=0.07078245692187013),\n", + " Experience(coverage=0.14883215643671918),\n", + " Hits(true_positive=4443, false_positive=1131, true_negative=15870, false_negative=19081)]" ] }, "execution_count": 19, @@ -770,47 +773,47 @@ " \n", " \n", " \n", - " new\n", " old\n", + " new\n", " \n", " \n", " \n", " \n", " 775\n", - " 775\n", " 776\n", + " 775\n", " \n", " \n", " 1965\n", - " 1965\n", " 1966\n", + " 1965\n", " \n", " \n", " 4137\n", - " 4137\n", " 4138\n", + " 4137\n", " \n", " \n", " 4422\n", - " 4422\n", " 4423\n", + " 4422\n", " \n", " \n", " 4746\n", - " 4746\n", " 4747\n", + " 4746\n", " \n", " \n", "\n", "" ], "text/plain": [ - " new old\n", - "775 775 776\n", - "1965 1965 1966\n", - "4137 4137 4138\n", - "4422 4422 4423\n", - "4746 4746 4747" + " old new\n", + "775 776 775\n", + "1965 1966 1965\n", + "4137 4138 4137\n", + "4422 4423 4422\n", + "4746 4747 4746" ] }, "execution_count": 27, @@ -1102,47 +1105,47 @@ " \n", " \n", " \n", - " new\n", " old\n", + " new\n", " \n", " \n", " \n", " \n", " 0\n", - " 0\n", " 4833\n", + " 0\n", " \n", " \n", " 1\n", - " 1\n", " 4834\n", + " 1\n", " \n", " \n", " 2\n", - " 2\n", " 4835\n", + " 2\n", " \n", " \n", " 3\n", - " 3\n", " 4836\n", + " 3\n", " \n", " \n", " 4\n", - " 4\n", " 4837\n", + " 4\n", " \n", " \n", "\n", "" ], "text/plain": [ - " new old\n", - "0 0 4833\n", - "1 1 4834\n", - "2 2 4835\n", - "3 3 4836\n", - "4 4 4837" + " old new\n", + "0 4833 0\n", + "1 4834 1\n", + "2 4835 2\n", + "3 4836 3\n", + "4 4837 4" ] }, "execution_count": 35, @@ -1180,47 +1183,47 @@ " \n", " \n", " \n", - " new\n", " old\n", + " new\n", " \n", " \n", " \n", " \n", " 0\n", - " 0\n", " 1\n", + " 0\n", " \n", " \n", " 1\n", - " 1\n", " 2\n", + " 1\n", " \n", " \n", " 2\n", - " 2\n", " 3\n", + " 2\n", " \n", " \n", " 3\n", - " 3\n", " 4\n", + " 3\n", " \n", " \n", " 4\n", - " 4\n", " 5\n", + " 4\n", " \n", " \n", "\n", "" ], "text/plain": [ - " new old\n", - "0 0 1\n", - "1 1 2\n", - "2 2 3\n", - "3 3 4\n", - "4 4 5" + " old new\n", + "0 1 0\n", + "1 2 1\n", + "2 3 2\n", + "3 4 3\n", + "4 5 4" ] }, "execution_count": 36, @@ -1603,7 +1606,10 @@ { "data": { "text/plain": [ - "Hits(true_positive=1063, false_positive=245, true_negative=3505, false_negative=4666)" + "[Relevance(precision=0.48771352650892064, recall=0.1962177724147278, fallout=0.05871125477406844, specifity=0.6808813050133541, miss_rate=0.741780456106087),\n", + " Ranking(nDCG=0.17149113058615703, nDCL=0.06967069219097612),\n", + " Experience(coverage=0.10999456816947312),\n", + " Hits(true_positive=1063, false_positive=245, true_negative=3505, false_negative=4666)]" ] }, "execution_count": 41, @@ -1655,6 +1661,13 @@ "source": [ "svd.evaluate('relevance')" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/Example_ML1M.ipynb b/examples/Example_ML1M.ipynb index bd79d5f..ca4b16f 100644 --- a/examples/Example_ML1M.ipynb +++ b/examples/Example_ML1M.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:18:07.398000", @@ -32,9 +32,6 @@ }, "outputs": [], "source": [ - "# python 2/3 interoperability\n", - "from __future__ import print_function\n", - "\n", "import sys\n", "\n", "import numpy as np\n", @@ -43,11 +40,10 @@ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", - "from polara.recommender.data import RecommenderData\n", - "from polara.recommender.models import SVDModel, CoffeeModel, PopularityModel, RandomModel\n", + "from polara import (SVDModel, PopularityModel, RandomModel,\n", + " RecommenderData, get_movielens_data)\n", + "from polara.recommender.models import CoffeeModel\n", "from polara.evaluation import evaluation_engine as ee\n", - "from polara.recommender.external.mymedialite.mmlwrapper import MyMediaLiteWrapper\n", - "from polara.datasets.movielens import get_movielens_data\n", "from polara.tools.preprocessing import filter_sessions_by_length\n", "from polara.evaluation.plotting import show_hit_rates, show_precision_recall, show_ranking" ] @@ -75,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:18:09.900000", @@ -85,39 +81,11 @@ "outputs": [], "source": [ "DATA_NAME = 'ml-1m'\n", - "DATA_FILE = '/{}.zip'.format(DATA_NAME)#path to Movielens-1M zip-file\n", + "DATA_FILE = 'D:/datasets/recsys/movielens/{}.zip'.format(DATA_NAME)#path to Movielens-1M zip-file\n", " #set it to None to automatically download data from Grouplens\n", "SESS_SIZE = 20" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### MyMediaLite" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2017-01-19T00:18:10.726000", - "start_time": "2017-01-19T00:18:10.721000" - } - }, - "outputs": [], - "source": [ - "#set path to MyMediaLite binaries\n", - "if sys.platform == 'win32':\n", - " LIB_PATH = 'MyMediaLite-3.11/lib/mymedialite' \n", - "else:\n", - " LIB_PATH = 'MyMediaLite-3.11/bin'\n", - "\n", - "MML_DATA = 'MyMediaLiteData' #folder to store MyMediLite data (models, data mappings, etc.)\n", - " # the folder must exist!" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -127,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:18:14.527000", @@ -141,14 +109,7 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:18:16.284000", @@ -157,32 +118,31 @@ }, "outputs": [], "source": [ - "ml_data = filter_sessions_by_length(ml_data)\n", - "data_model = RecommenderData(ml_data, 'userid', 'movieid', 'rating')\n", - "data_model.name = DATA_NAME\n", - "data_model.seed = 0" + "ml_data = filter_sessions_by_length(ml_data, min_session_length=SESS_SIZE)\n", + "data_model = RecommenderData(ml_data, 'userid', 'movieid', 'rating', seed = 0)\n", + "data_model.name = DATA_NAME" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'holdout_size': 3,\n", - " 'negative_prediction': False,\n", - " 'permute_tops': False,\n", + "{'test_ratio': 0.2,\n", + " 'test_sample': None,\n", " 'random_holdout': False,\n", + " 'permute_tops': False,\n", + " 'negative_prediction': False,\n", " 'shuffle_data': False,\n", + " 'warm_start': True,\n", " 'test_fold': 5,\n", - " 'test_ratio': 0.2,\n", - " 'test_sample': None,\n", - " 'warm_start': True}" + " 'holdout_size': 3}" ] }, - "execution_count": 9, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -200,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:18:20.954000", @@ -209,8 +169,6 @@ }, "outputs": [], "source": [ - "# bpr = MyMediaLiteWrapper(LIB_PATH, MML_DATA, 'BPRMF', data_model)\n", - "# wrmf = MyMediaLiteWrapper(LIB_PATH, MML_DATA, 'WRMF', data_model)\n", "svd = SVDModel(data_model)\n", "popular = PopularityModel(data_model)\n", "random = RandomModel(data_model, seed=0)\n", @@ -219,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:37.710000", @@ -233,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:40.427000", @@ -247,7 +205,7 @@ "['PureSVD', 'CoFFee', 'MP', 'RND']" ] }, - "execution_count": 12, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -255,13 +213,12 @@ "source": [ "models = [svd, coffee, popular, random]\n", "model_names = [model.method for model in models]\n", - "metrics = ['ranking', 'relevance']\n", "model_names" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:41.991000", @@ -276,33 +233,7 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2017-01-19T00:19:42.483000", - "start_time": "2017-01-19T00:19:42.478000" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PureSVD 4\n", - "CoFFee 4\n", - "MP 4\n", - "RND 4\n" - ] - } - ], - "source": [ - "for model in models:\n", - " print(model.method, model.switch_positive)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:43.197000", @@ -340,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:46.148000", @@ -349,14 +280,15 @@ }, "outputs": [], "source": [ + "metrics = ['ranking', 'relevance', 'experience']\n", "topk_list = [1, 2, 3, 5, 10, 15, 20, 30, 50, 70, 100]\n", - "test_samples = [0,]\n", + "test_samples = [0, -1]\n", "folds = [1, 2, 3, 4, 5]" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:51.117000", @@ -378,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:57.864000", @@ -391,80 +323,111 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "\n", - "========= Test sample: 0 =========\n", - "\n", - "\n", - "============ Fold: 1 =============\n", "Preparing data...\n", "23 unique movieid's within 27 testset interactions were filtered. Reason: not in the training data.\n", "1 unique movieid's within 1 holdout interactions were filtered. Reason: not in the training data.\n", - "1 of 1208 userid's were filtered out from holdout. Reason: not enough items.\n", + "1 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", "1 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", "Done.\n", - "PureSVD training time: 0.10657037373075795s\n", - "CoFFee training time: 1.5177289084482908s\n", - "100 70 50 30 20 15 10 5 3 2 1 \n", - "============ Fold: 2 =============\n", + "There are 803312 events in the training and 12070 events in the holdout.\n", + "PureSVD training time: 0.104s\n", + "CoFFee training time: 3.544s\n", "Preparing data...\n", "47 unique movieid's within 56 testset interactions were filtered. Reason: not in the training data.\n", "2 unique movieid's within 2 holdout interactions were filtered. Reason: not in the training data.\n", - "2 of 1208 userid's were filtered out from holdout. Reason: not enough items.\n", + "2 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", "2 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", "Done.\n", - "PureSVD training time: 0.12100629132648777s\n", - "CoFFee training time: 2.135373650530159s\n", - "100 70 50 30 20 15 10 5 3 2 1 \n", - "============ Fold: 3 =============\n", + "There are 792890 events in the training and 12060 events in the holdout.\n", + "PureSVD training time: 0.112s\n", + "CoFFee training time: 1.299s\n", "Preparing data...\n", "16 unique movieid's within 18 testset interactions were filtered. Reason: not in the training data.\n", "4 unique movieid's within 4 holdout interactions were filtered. Reason: not in the training data.\n", - "4 of 1208 userid's were filtered out from holdout. Reason: not enough items.\n", + "4 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", "4 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", "Done.\n", - "PureSVD training time: 0.0964248257231084s\n", - "CoFFee training time: 1.3818089788154566s\n", - "100 70 50 30 20 15 10 5 3 2 1 \n", - "============ Fold: 4 =============\n", + "There are 808443 events in the training and 12040 events in the holdout.\n", + "PureSVD training time: 0.121s\n", + "CoFFee training time: 1.186s\n", "Preparing data...\n", "28 unique movieid's within 39 testset interactions were filtered. Reason: not in the training data.\n", "2 unique movieid's within 2 holdout interactions were filtered. Reason: not in the training data.\n", - "2 of 1208 userid's were filtered out from holdout. Reason: not enough items.\n", + "2 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", "2 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", "Done.\n", - "PureSVD training time: 0.09338965818536238s\n", - "CoFFee training time: 2.131201799438987s\n", - "100 70 50 30 20 15 10 5 3 2 1 \n", - "============ Fold: 5 =============\n", + "There are 788733 events in the training and 12060 events in the holdout.\n", + "PureSVD training time: 0.121s\n", + "CoFFee training time: 1.305s\n", "Preparing data...\n", "18 unique movieid's within 25 testset interactions were filtered. Reason: not in the training data.\n", "2 unique movieid's within 2 holdout interactions were filtered. Reason: not in the training data.\n", - "2 of 1208 userid's were filtered out from holdout. Reason: not enough items.\n", + "2 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", "2 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", "Done.\n", - "PureSVD training time: 0.11019193432397856s\n", - "CoFFee training time: 1.4080982047912087s\n", - "100 70 50 30 20 15 10 5 3 2 1 " + "There are 807458 events in the training and 12060 events in the holdout.\n", + "PureSVD training time: 0.111s\n", + "CoFFee training time: 1.648s\n", + "Preparing data...\n", + "1 unique movieid's within 1 holdout interactions were filtered. Reason: not in the training data.\n", + "1 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", + "1 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", + "Done.\n", + "There are 803312 events in the training and 12070 events in the holdout.\n", + "PureSVD training time: 0.122s\n", + "CoFFee training time: 1.188s\n", + "Preparing data...\n", + "1 unique movieid's within 1 testset interactions were filtered. Reason: not in the training data.\n", + "2 unique movieid's within 2 holdout interactions were filtered. Reason: not in the training data.\n", + "2 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", + "1 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", + "Done.\n", + "There are 792890 events in the training and 12060 events in the holdout.\n", + "PureSVD training time: 0.098s\n", + "CoFFee training time: 2.081s\n", + "Preparing data...\n", + "1 unique movieid's within 1 testset interactions were filtered. Reason: not in the training data.\n", + "4 unique movieid's within 4 holdout interactions were filtered. Reason: not in the training data.\n", + "4 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", + "1 userid's were filtered out from holdout. Reason: inconsistent with testset.\n", + "4 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", + "Done.\n", + "There are 808443 events in the training and 12030 events in the holdout.\n", + "PureSVD training time: 0.095s\n", + "CoFFee training time: 1.178s\n", + "Preparing data...\n", + "2 unique movieid's within 2 holdout interactions were filtered. Reason: not in the training data.\n", + "2 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", + "2 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", + "Done.\n", + "There are 788733 events in the training and 12060 events in the holdout.\n", + "PureSVD training time: 0.114s\n", + "CoFFee training time: 1.314s\n", + "Preparing data...\n", + "2 unique movieid's within 2 holdout interactions were filtered. Reason: not in the training data.\n", + "2 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", + "2 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", + "Done.\n", + "There are 807458 events in the training and 12060 events in the holdout.\n", + "PureSVD training time: 0.117s\n", + "CoFFee training time: 1.416s\n" ] } ], "source": [ "result = {}\n", - "topk_result = {}\n", "for test_sample in test_samples:\n", " data_model.test_sample = test_sample\n", - " print('\\n\\n========= Test sample: {} =========\\n'.format(test_sample))\n", - " for fold in folds:\n", - " print('\\n============ Fold: {} ============='.format(fold))\n", - " data_model.test_fold = fold\n", - " topk_result[fold] = ee.topk_test(models, topk_list=topk_list, metrics=metrics)\n", - " result[test_sample] = ee.consolidate_folds(topk_result, folds, metrics)" + " result[test_sample] = ee.run_cv_experiment(models,\n", + " folds,\n", + " metrics,\n", + " fold_experiment=ee.topk_test,\n", + " topk_list=topk_list)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2017-01-19T00:19:57.868000", @@ -478,89 +441,17 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "scores = {}\n", - "deviation = {}\n", - "scores['ranking'] = result[test_sample]['ranking'].mean(axis=0, level=1)\n", - "deviation['ranking'] = result[test_sample]['ranking'].std(axis=0, level=1)\n", - "scores['relevance'] = result[test_sample]['relevance'].mean(axis=0, level=1)\n", - "deviation['relevance'] = result[test_sample]['relevance'].std(axis=0, level=1)" - ] - }, - { - "cell_type": "markdown", + "execution_count": 15, "metadata": {}, - "source": [ - "# Visualize results" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2017-01-19T00:18:13.045000", - "start_time": "2017-01-19T00:18:13.042000" - } - }, "outputs": [], "source": [ - "ERR_ALPHA = 0.1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Predictions for \"known\" user" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "show_hit_rates(scores, errors=deviation, err_alpha=ERR_ALPHA)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "show_precision_recall(scores, errors=deviation, err_alpha=ERR_ALPHA)" + "scores = result[test_sample].mean(axis=0, level=['top-n', 'model'])\n", + "deviation = result[test_sample].std(axis=0, level=['top-n', 'model'])" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -587,25 +478,19 @@ "\n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", " \n", - " \n", - " \n", " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -623,178 +508,246 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", "
nDCGnDCLnDCGnDCLnDCGnDCLnDCGnDCLmetricnDCGnDCL
PureSVDPureSVDmodelCoFFeeCoFFeeMPMPPureSVDRNDCoFFeeMPPureSVDRND
10.0772200.0269730.0669210.0189230.0705320.0340490.0772200.0004630.0196870.0219760.0006270.0016240.0269730.001412
20.1113420.0402390.0959190.0276860.0998470.0492840.1113420.0008050.0301070.0311090.0008430.0021430.0402390.001739
30.1326010.0519710.1145970.0361120.1183880.0577950.1326010.0009890.0384990.0375490.0009550.0028530.0519710.002081
50.1596410.0694810.1398220.0480290.1438420.0703350.1596410.0013980.0507860.0484990.0013350.0033350.0694810.002621
100.1975280.1011780.1756710.0701280.1798790.0913560.1975280.0022690.0741320.0649220.0022060.0046830.1011780.004211
150.2193480.1222170.1958070.0875830.2010910.1056110.2193480.0029400.0903310.0773870.0028300.0060750.1222170.005838
200.2349710.1395440.2112160.1005030.2163140.1166230.2349710.0035730.1046980.0866740.0033680.0068310.1395440.006509
300.2569970.1669810.2328620.1224390.2383730.1308440.2569970.0044530.1272630.1012820.0045460.0089240.1669810.008315
500.2847660.2050270.2600170.1520730.2656250.1515010.2847660.0063080.1583590.1251260.0062360.0125020.2050270.011740
700.3022960.2306140.2773400.1769850.2826390.1649050.3022960.0079020.1824790.1432220.0077070.0150670.2306140.014341
1000.3198250.2624070.2946390.2029100.3003520.1803640.3198250.0102400.2089540.1658740.0096020.0190540.2624070.018518
\n", "" ], "text/plain": [ - " nDCG nDCL nDCG nDCL nDCG nDCL nDCG \\\n", - " PureSVD PureSVD CoFFee CoFFee MP MP RND \n", - "top-n \n", - "1 0.077220 0.026973 0.066921 0.018923 0.034049 0.021976 0.000627 \n", - "2 0.111342 0.040239 0.095919 0.027686 0.049284 0.031109 0.000843 \n", - "3 0.132601 0.051971 0.114597 0.036112 0.057795 0.037549 0.000955 \n", - "5 0.159641 0.069481 0.139822 0.048029 0.070335 0.048499 0.001335 \n", - "10 0.197528 0.101178 0.175671 0.070128 0.091356 0.064922 0.002206 \n", - "15 0.219348 0.122217 0.195807 0.087583 0.105611 0.077387 0.002830 \n", - "20 0.234971 0.139544 0.211216 0.100503 0.116623 0.086674 0.003368 \n", - "30 0.256997 0.166981 0.232862 0.122439 0.130844 0.101282 0.004546 \n", - "50 0.284766 0.205027 0.260017 0.152073 0.151501 0.125126 0.006236 \n", - "70 0.302296 0.230614 0.277340 0.176985 0.164905 0.143222 0.007707 \n", - "100 0.319825 0.262407 0.294639 0.202910 0.180364 0.165874 0.009602 \n", + "metric nDCG nDCL \\\n", + "model CoFFee MP PureSVD RND CoFFee MP PureSVD \n", + "top-n \n", + "1 0.070532 0.034049 0.077220 0.000463 0.019687 0.021976 0.026973 \n", + "2 0.099847 0.049284 0.111342 0.000805 0.030107 0.031109 0.040239 \n", + "3 0.118388 0.057795 0.132601 0.000989 0.038499 0.037549 0.051971 \n", + "5 0.143842 0.070335 0.159641 0.001398 0.050786 0.048499 0.069481 \n", + "10 0.179879 0.091356 0.197528 0.002269 0.074132 0.064922 0.101178 \n", + "15 0.201091 0.105611 0.219348 0.002940 0.090331 0.077387 0.122217 \n", + "20 0.216314 0.116623 0.234971 0.003573 0.104698 0.086674 0.139544 \n", + "30 0.238373 0.130844 0.256997 0.004453 0.127263 0.101282 0.166981 \n", + "50 0.265625 0.151501 0.284766 0.006308 0.158359 0.125126 0.205027 \n", + "70 0.282639 0.164905 0.302296 0.007902 0.182479 0.143222 0.230614 \n", + "100 0.300352 0.180364 0.319825 0.010240 0.208954 0.165874 0.262407 \n", "\n", - " nDCL \n", - " RND \n", - "top-n \n", - "1 0.001624 \n", - "2 0.002143 \n", - "3 0.002853 \n", - "5 0.003335 \n", - "10 0.004683 \n", - "15 0.006075 \n", - "20 0.006831 \n", - "30 0.008924 \n", - "50 0.012502 \n", - "70 0.015067 \n", - "100 0.019054 " + "metric \n", + "model RND \n", + "top-n \n", + "1 0.001412 \n", + "2 0.001739 \n", + "3 0.002081 \n", + "5 0.002621 \n", + "10 0.004211 \n", + "15 0.005838 \n", + "20 0.006509 \n", + "30 0.008315 \n", + "50 0.011740 \n", + "70 0.014341 \n", + "100 0.018518 " ] }, - "execution_count": 24, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "scores['ranking']" + "scores['ranking'].unstack('model')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize results" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2017-01-19T00:18:13.045000", + "start_time": "2017-01-19T00:18:13.042000" + } + }, + "outputs": [], + "source": [ + "ERR_ALPHA = 0.1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predictions for \"known\" user" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_hit_rates(scores, errors=deviation, err_alpha=ERR_ALPHA)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_precision_recall(scores, errors=deviation, err_alpha=ERR_ALPHA)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -816,7 +769,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 21, "metadata": { "collapsed": true }, @@ -827,30 +780,24 @@ }, { "cell_type": "code", - "execution_count": 49, - "metadata": { - "collapsed": true - }, + "execution_count": 22, + "metadata": {}, "outputs": [], "source": [ - "scores = {}\n", - "deviation = {}\n", - "scores['ranking'] = result[test_sample]['ranking'].mean(axis=0, level=1)\n", - "deviation['ranking'] = result[test_sample]['ranking'].std(axis=0, level=1)\n", - "scores['relevance'] = result[test_sample]['relevance'].mean(axis=0, level=1)\n", - "deviation['relevance'] = result[test_sample]['relevance'].std(axis=0, level=1)" + "scores = result[test_sample].mean(axis=0, level=['top-n', 'model'])\n", + "deviation = result[test_sample].std(axis=0, level=['top-n', 'model'])" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl8AAAFACAYAAACC1xnOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -863,14 +810,14 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAFACAYAAACPyWmJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niEgQKGSJiIiIBIFCloiIiEgQ/D9sFm+9X1CVbQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -883,14 +830,14 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABCIAAAFACAYAAABp1d2lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n+f+ETh/iz0XqjwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -934,5 +881,5 @@ } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 2 } diff --git a/examples/Reproducing EIGENREC results.ipynb b/examples/Reproducing_EIGENREC_results.ipynb similarity index 97% rename from examples/Reproducing EIGENREC results.ipynb rename to examples/Reproducing_EIGENREC_results.ipynb index e0a96fa..11da8d3 100644 --- a/examples/Reproducing EIGENREC results.ipynb +++ b/examples/Reproducing_EIGENREC_results.ipynb @@ -613,7 +613,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "ScaledSVD training time: 0.5471807377243749s\n" + "ScaledSVD training time: 0.534s\n" ] } ], @@ -846,11 +846,32 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "100%\n", + "21/21\n", + "[37:36<01:44, 107.45s/it]
" + ], + "text/plain": [ + "\u001b[A\u001b[2K\r", + " [████████████████████████████████████████████████████████████] 21/21 [37:36<01:44, 107.45s/it]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "from tqdm import tqdm_notebook\n", + "try:\n", + " from ipypb import track\n", + "except ImportError:\n", + " from tqdm import tqdm_notebook as track\n", "%matplotlib inline\n", "\n", "svd_mrr_flat = {} # will stor results here\n", @@ -860,7 +881,7 @@ "scaling_params = np.arange(-20, 21, 2) / 10 # values of d from -2 to 2 with step 0.2\n", "svd_ranks = range(10, max_rank+1, 10) # ranks from 10 to max_ranks with step 10\n", "\n", - "for scaling in tqdm_notebook(scaling_params):\n", + "for scaling in track(scaling_params):\n", " svd.col_scaling = scaling\n", " svd.rank = max_rank\n", " svd.build()\n", @@ -889,9 +910,20 @@ }, { "cell_type": "code", - "execution_count": 167, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(0.4, 120)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "result_flat = pd.Series(svd_mrr_flat)\n", "best_d, best_rank = result_flat.idxmax()\n", @@ -900,12 +932,12 @@ }, { "cell_type": "code", - "execution_count": 199, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARgAAACcCAYAAACk2LT2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAHDlJREFUeJzt3Xl8VfWd//HXJztkI4SwBkhACBAWgYDgBigiVgEr4oZaK8pIdX52rOMyrcV2xplabR0toGhVRFFaxLZo5YcLiVQFgciiEMIStrBlgaxkz2f+SKAQEnKBe3Nu7v08H488vOeeb875nHh537N9v0dUFWOM8YQApwswxvguCxhjjMdYwBhjPMYCxhjjMRYwxhiPsYAxxniMBYwxxmMsYIxLRGSPiFSKSIcG728UERWRBBFZUN+mRESOisinItLvlLb3iEhN/fwiEdkkIje0/NaYlmIBY87FbuD2ExMiMgho06DNb1U1AugGHABebzB/df38dsA8YLGItPNcycZJFjDmXLwN3H3K9I+AhY01VNUy4M/AxU3Mr61fXjjQx71lGm9hAWPOxRogSkT6i0ggcCvwTmMNRSScur2dnU3MDwR+DFQBez1TrnFakNMFmFbnxF7MF8A26g6DTvWoiDwERFEXHFMazB8lIgXU7blUA3eqao5nSzZOsT0Yc67eBu4A7qHxw6PnVbUdkACUAUkN5q+pnx8DLAOu8FilxnEWMOacqOpe6k72/gD44Czt9gEPAy+KSMMTwahqCfAT4C4RGeqhco3DLGDM+ZgBXKWqpWdrpKqfAgeBmU3Mzwf+CPzS7RUar2ABY86Zqu5S1fUuNn8OeExEQpuY/7/AD0RksHuqM95EbMApY4yn2B6MMcZjLGCMMR5jAWOM8RgLGGOMx1jAGGM8xrGuAu3atdOLLrrIqdW3uNLSUsLDw50uo8XY9vq29PT0PFWNa66dYwHTqVMn1q939VaK1i8tLY2xY8c6XUaLse31bSLiUgdVO0QyxniMBYwxxmNsuAbTapRX1ZBxqIjvDhQSFBDAVf060jk6zOmyzFl4VcBUVVWRnZ1NeXm506W4XXR0NBkZGS2+3rCwMOLj4wkODm7xdV+I6ppaduSUsDm7gE3ZhWzOLiDzcDFVNad3bRnULZrx/TtxzYBO9O8SiYg4VLFpjFcFTHZ2NpGRkSQkJPjcB6W4uJjIyMgWXaeqkp+fT3Z2NomJiS267nOhquzJP14XJvvrwmTLwSLKqmoAiAwLYnB8NPdd0Ysh8dEMim/H8YpqPs04wmdbj/C/n2/nhc+2061dG8b378j4AZ24JDGWkCA7A+A0rwqY8vJynwwXp4gIsbGx5ObmOl1Ko1SV1MwcfrN8G9uPlAAQFhxActdobhvZnSHx7RgcH01CbDgBAWd+Jvp0iuQnYy8it7iC1G05fJpxhD+t389bq/cSGRrEmKQ4rhnQibF9OxLdtnXtwfkKrwoYwMLFzbz17/n9gUKe+XsGq7PySYhty3/dOJBhPWLo2ymCoMBz2/OIiwzllhHduWVEd8qravhyRx6fZRzhs4wcPtp8iKAAYeqweP77pkEENhJUxnNcChgRmQi8CAQCf1TV3zSY/wDwIFADlAAzVXWrm2ttES+99BIvv/wyw4YN49Zbb2Xr1q088cQTF7zcLl26UFJS4oYKT/f0008TERHBo48+6vZle0L2seP87pPt/GXDAdqHh/CrycnccUkPgs8xVJoSFhzI+AGdGD+gE7W1yqbsAj749gBvr9lLYKDwzI0DvTZ0fVGzAVM/+vtc4BogG1gnIssaBMi7qvpKffvJwO+BiR6o1+PmzZvH8uXLT56zmDx5cousV1VRVQICfPO8QWFZFfPSdvLmV3sQYNbY3swa25uoMM8dugQECEN7xDC0RwwRYUG8nLaLDhGhPHJNX4+t05zOlU/zSGCnqmapaiWwmAYjxatq0SmT4UCrHMXqgQceICsri8mTJ/PCCy+wYMECHnroIQCmTJnCwoV1Y1zPnz+f6dOnA7Br1y4mTpzI8OHDueKKK9i2bRsAu3fvZvTo0YwYMYKnnnqq0fXt2bOH/v3785Of/IRhw4axf/9+Zs2aRUpKCsnJycyePftk24SEBGbPns2wYcMYNGjQyfWc6rXXXuO6666jrKzMrX+XC1FZXcsbX+5m7HOpvLoqixsGdyH10bE8PrGfR8OloceuTeKWlHhe+nwHb6/e02Lr9Xsnvjmb+gFupu6w6MT0XcCcRto9COwC9gN9mltu3759taGtW7ee8V5L69mzp+bm5qqq6ptvvqkPPvigqqoePnxYe/furatWrdI+ffpofn6+qqpeddVVun37dlVVXbNmjY4bN05VVSdNmqRvvfWWqqrOmTNHw8PDz1jX7t27VUR09erVJ987sdzq6modM2aMbtq06WRdL730kqqqzp07V2fMmKGqqrNnz9bnnntO//CHP+ikSZO0vLz8jPU48XdduXKlfrTpoF7525Xa8/GP9I7XVut32QUtXsepqqprdMaCdZrwxEf64aYDbl12amqqW5fn7YD12sy/cVV16RxMYwesZ+yhqOpcYK6I3AH8grqn/p2+IJGZ1A8AHRcXR1pa2mnzo6OjKS4uBuDZT3ax7Yh7z1n06xTB4xN6n7WNqlJSUkJoaCjl5eVUVlZSXFxM27ZtefLJJxk3bhzvvvsuwcHBHDp0iK+//pqpU6ee/P2KigqKi4v58ssvWbBgAcXFxdx44408/vjjJ7fthJKSEnr06EFycvLJeQsXLmTBggVUV1dz+PBh0tPTSUxMRFWZMGECxcXF9OvXjyVLllBcXExFRQVLly6la9euvPfee1RWVlJZWXnaesrLy8/4W3vS3qIaFnxXxu7ib4mPEB4ZHsqgDmXk7dhA2o4WK6NRt8Qr+w4H8PB7G9i3I4MBsYFuWW5JSUmL/o1bC1cCJhvofsp0PHUjxTdlMfByYzNU9VXgVYCkpCRt2DksIyPj5L0iwSHBBAa653/+CcEhwc3eiyIiREREEBkZSVhYGCEhISd/Z+fOncTGxnLs2DEiIyNRVdq1a8fmzZsbXU5UVBRBQUEn9vDOWHdERMTJdUHdYdWcOXNYt24dMTEx3HPPPYgIkZGRJy85R0ZGEhUVhaoSGRlJaGgogwcPZuPGjRQWFjZ6v0tYWBhDh7bMk0F255Xy8NyvoDaAZ6cO5Obh3b3uys0lo6u4Zf5q5m46zuKZKQyKj77gZfpbZ0dXuRIw64A+IpJI3VP8bqPuwVsniUgfVT3x3XQ9cMHfU7MnJV/oItxq7dq1LF++nA0bNjBmzBgmTJhAYmIiiYmJLFmyhGnTpqGqbN68mSFDhnDZZZexePFi7rzzThYtWuTSOoqKiggPDyc6OpojR46wfPlylz60Q4cOZdasWUyePJkVK1bQtWvXC9za81NUXsX9C9cTIPDkJWHcMqKHI3U0J7ptMAtnjOSmeV9zz5treX/WpSR28J+hFlpSsyd5VbUaeAhYAWQAf1bVLSLy6/orRgAPicgWEdkIPEIjh0etWUVFBffffz9vvPEGXbt25Xe/+x333nsvqsqiRYt4/fXXGTJkCMnJyfztb38D4MUXX2Tu3LmMGDGCwsJCl9YzZMgQhg4dSnJyMvfeey+XXXaZyzVefvnlPP/881x//fXk5eWd13ZeiJpa5eH3NrAnr5R504fTsa13Xw3rFBXG2zNGosBdr39DTpHvdU/xCq6cqPHEj7ee5PWUoqIix9bdEn/X//77Vu35+Ef69uo9qtp6Tnpu3HdM+z+1XK994QstOF553stpLdvrLrh4kte7v2ZMq7A0PZv5q7K4c1QP7hzV0+lyzsmQ7u2Yf9dwduWWcP/C9ZTX938y7mEBYy7It/uO8eQH3zG6V6zXnTdz1RV94nh+2hDW7j7K/3tvA9U1tU6X5DMsYMx5O1RYxr+8nU7n6DDmTR/mttv9nTDl4m7MnjSAT7Ye4Rd//f7klT9zYbyus6OqWl8RN/LUP5SyyhpmLkzneEU1i+67hJjwEI+spyX9+LJE8koqmJta16Xg0WuTnC6p1fOqgAkLCyM/P5/Y2FgLGTfQ+vFgwsLcO+qbqvLY0s18f7CQ1+5KoW+nlh3nxpMenZBEfkklc1J3EhMewozLvXccndbAqwImPj6e7Oxsrx2/5EKUl5e7/R+6K06MaOdO89J28eGmgzw2MYnxAzq5ddlOExGe+eEgCo5X8Z8fbaVdm2CmDnfv38+feFXABAcHe/XIaxciLS2txe6m9aRPthzmuRWZ3HhxV2aNOXu3i9YqMEB48faLuXfBOh5bupmoNsFc42NB2lJa71k50+K2HS7ip3/ayJD4aH4zdbBPH8aGBgUy/64UBnaN4sF3v2VNVr7TJbVKFjDGJUdLK7nvrfVEhAYx/64UwoLd20/MG0WEBvHmj0fSo31b7n9rPd8fcO2ObPNPFjCmWZXVtcx6J52c4gpevTvFrx4V0j48hLdnjCSqTTA/emMtWbnuH5XQl1nAmGY9/0km3+w+ynM3D+bi7u2cLqfFdYluw8IZIwG46/W1HCr0ngG9vJ0FjDmr4vIq3lmzl5uGdmPKxd2cLscxveMiWPDjkRSWVXH362s5VlrZ/C8ZCxhzdn/deJDjlTXcfWmC06U4blB8NK/dncLeo8f58YJ1lFZUO12S17OAMU1SVRat2Uty1yiGuGFQJl8wuncsc24fyubsAh54J52KausceTYWMKZJG/YXsO1wMdMv6enTl6TP1YTkzjw7dTD/2JHHI3/aRE2t9VtqilfdaGe8y6I1+wgPCWTyxc6MkOfNpqV0p7Csiv/6ewZRbYKZEGMh0xgLGNOowuNVfLT5IDcPjyci1D4mjbnvil4cLa1kXtoujnQPYsSl1fa3asAOkUyjln6bTUV1LdMvaV0DSLW0f782iRmXJ7JyfzVXPZ/G++nZ1Noh00kWMOYMqsqib/Zycfd2DOga5XQ5Xk1EeOqGATw1Koyu7drw6JJN/HDeV6TvPeZ0aV7BAsac4ZvdR9mVW8r0S7zzqQDeqHe7QD6YdSm/v2UIh4vKmfry1/x08Qa/vynPAsac4d1v9hEZFsQNg+3k7rkICBBuGhbPyp+N5aFxF/Hx94e56vkvePGzHZRV+uflbAsYc5q8kgqWf3+IqcPiaRPi+x0aPSE8NIhHr03i80fGMK5fHC98tp3xv/+CDzcd9LuhOC1gzGneT8+mqkbt8MgNurdvy7zpw1k8cxRRbYL51/c2cMv81X7VK9ulgBGRiSKSKSI7ReSJRuY/IiJbRWSziHwuInbpoRWqrVXeW7uPkQnt6eNDw2A6bVSvWD7618v5n5sGkZVbyqQ5X/LInzay40hx87/cyjUbMCISCMwFrgMGALeLyIAGzTYAKao6GHgf+K27CzWe99WuPPbmH2f6KNt7cbfAAOH2kT1I/fex3H9FLz7+/hDXvLCK+95ax/o9R50uz2Nc2YMZCexU1SxVraTu4fZTTm2gqqmqerx+cg1gg5i2Qu9+s4/24SFMHNjZ6VJ8VlRYMP/xg/58/cTVPHx1H9bvPcbNr6xm2itf83nGEZ+7h8aVgOkG7D9lOrv+vabMAJZfSFGm5R0pKueTrUe4eXg8oUF2ctfT2oeH8G/X9OXrJ65i9qQBHCwoZ8Zb65n44iqWpmdT5SMPf3PlvubGerk1GrMicieQAoxpYv5MYCZAXFwcaWlprlXpA0pKSrx6e5ftqqSmVumlh0hLO3LBy/P27XW3C9neROBXI4W1h0P5OKuUny3ZxDMfbubahGDGxAcRFtR6O5pKc5fNRGQ08LSqXls//SSAqv5Pg3bjgT8AY1Q1p7kVJyUlaWZm5vnW3eqkpaUxduxYp8toVE2tcuVvU0nsEM47913ilmV68/Z6gru2V1VJy8zl5bRdrN1zlOg2wfxodE/uvjSBDhGhF16om4hIuqqmNNfOlT2YdUAfEUkEDgC3AXc0WNlQYD4w0ZVwMd7li+05HCgo4+fX93e6FL8nIozr15Fx/TqSvvcYr3yxi5dW7uTlL3Zxdb9O3DIiniv7xBHUSh7T22zAqGq1iDwErAACgTdUdYuI/BpYr6rLgOeACGBJ/bgh+1R1sgfrNm60aM0+4iJD7dk/XmZ4zxheuzuFnTklLF67j79sOMD/33KYjpGh3DQsnmkp8fSOi3C6zLNyqW+5qn4MfNzgvV+e8nq8m+syLeRAQRmpmTnMGtu7VT+83pdd1DGCX9wwgMcm9mPlthzeT9/Pa//I4pUvdpHSM4ZpKfFcP7irVw4V4X0VmRb1p7X7UOC2EXbvi7cLCQpg4sDOTBzYmZyicj7YcIA/r9/P40u/4+llW7l+cBemDY9nZGJ7rxmB0ALGj1XV1LJ43X7G9o2je/u2TpdjzkHHqDAeGNObf7myF9/uK2DJ+v18uOkg76dnkxDblvH9O9G7YwS9OoSTGBdOXESoI6FjAePHPs/IIae4gmdsUKlWS0QY3jOG4T1j+OWkASz/7jBL0vezcM1eKqv/eS9NZGgQiXHhdYHTIYJeceH0igsnsUM4bUM8FwMWMH5s0Td76RIdxrikOKdLMW7QNiSIqcPjmTo8nppa5WBBGVl5pezOLan7b14p6/Yc468bD572e12iw+jXOZKUhPaMTGzPoG7Rbns0sAWMn9qbX8o/duTxb+P7tppLnsZ1gQFC9/Zt6d6+LWP6nv4FUlZZw578usDJyi0hK7eUzQcKSa2/Ly0kMIDB8dGMSGzPiIQYhvdsT3Sb4POqwwLGT723dj+BAcKtI7o7XYppYW1CAunfJYr+XU4fDvVoaSXr9xxl/d5jrN19lNdWZfFymiICSZ0iSUmIYURCe0YktHd5XRYwfqiiuoYl6/dzdb+OfvUge3N27cNDmJDcmQnJdZ1dyypr2Li/gHV7jrJuz1H+8u0B3lmz75yWaQHjh1ZsOUJ+aSXTR9nJXdO0NiGBjO4dy+jesQBU19Sy7XAxa3cfZcazri3DAsYPLU3PJj6mDVdc1MHpUkwrEhQYwMBu0QzsFs0MF3/Hzu75meOV1azOymdicmcCArzjZizjuyxg/MzqXflUVtcyrl9Hp0sxfsACxs+s3JZDeEggKQkxTpdi/IAFjB85MdbIZRd1sFHrTIuwgPEjO3JKOFBQZodHpsVYwPiR1G11Y4GNta4BpoVYwPiR1Mwc+nWOpEt0G6dLMX7CAsZPFJVXsX7PMTs8Mi3KAsZPfLUjj+paZVySBYxpORYwfiI1M4eosCCG9WjndCnGj1jA+AFVJTUzlyv7tp7R6I1vsE+bH9hysIjc4go7PDItzgLGD6Rl1l2eHmOXp00Ls4DxAyu35TAkPtqrngxo/INLASMiE0UkU0R2isgTjcy/UkS+FZFqEbnZ/WWa83W0tJIN+wsYa4dHxgHNBoyIBAJzgeuAAcDtIjKgQbN9wD3Au+4u0FyYf+zIRRW7/8U4wpUBp0YCO1U1C0BEFgNTgK0nGqjqnvp5tY0twDgndVsOseEhDO4W7XQpxg+5cojUDdh/ynR2/XvGy9XUKl9sz2VM3zgbXMo4wpU9mMY+mXo+KxORmcBMgLi4ONLS0s5nMa1SSUlJi2/vzoIajh2vomNtXouv24ntdZK/ba+rXAmYbODUZ1vEAwebaHtWqvoq8CpAUlKSjh079nwW0yqlpaXR0tv77SeZBMhOHphyJe3ahrToup3YXif52/a6ypVDpHVAHxFJFJEQ4DZgmWfLMu6QmpnL8J4xLR4uxpzQbMCoajXwELACyAD+rKpbROTXIjIZQERGiEg2MA2YLyJbPFm0aV5OcTnfHSi0y9PGUS49tkRVPwY+bvDeL095vY66QyfjJb7IzAWw7gHGUXYnr49Ky8ylU1Qo/btEOl2K8WMWMD6oqqaWVdtzGZfUERG7PG2cYwHjg9L3HqO4otrOvxjHWcD4oNTMHIIDhcsuinW6FOPnLGB8UNq2XEYktCcyLNjpUoyfs4DxMQcKysg8UmxXj4xXsIDxMScGlxrXzwaXMs6zgPExqdtyiY9pQ++4CKdLMcYCxpdUVNfw1c48rupnl6eNd7CA8SFrdx+lrKrGzr8Yr2EB40NSt+USGhTAqF52edp4BwsYH5KWmcPo3rG0CQl0uhRjAAsYn7Enr5SsvFI7PDJexQLGR6SeuDxtAWO8iAWMj0jNzKVXXDg9Yts6XYoxJ1nA+IDjldWsycq3vRfjdSxgfMDqXflUVtdawBivYwHTypVWVLPom320DQlkRGKM0+UYcxqXhsw03umTLYd5etkWDhaW88g1fQkNssvTxrtYwLRCBwrKeHrZFj7deoR+nSP5wx3DGN7T9l6M97GAaUWqa2p586s9vPDZdlThyev6ce/liQQH2pGu8U4WMK3Ehn3H+I+/fE/GoSKu7teRX01JJj7GLkkb72YB4+UKy6p4bsU2Fn2zj06RYbxy5zCuTe5svaVNq+BSwIjIROBFIBD4o6r+psH8UGAhMBzIB25V1T3uLdW/qCofbj7Ef360lfySCu65NIGfTUgiItS+E0zr0eynVUQCgbnANdQ9p3qdiCxT1a2nNJsBHFPVi0TkNuBZ4FZPFOyLqmpqKSqrorD+p+B4FW98tZt/7MhjcHw0b94zgoHdop0u05hz5srX4Uhgp6pmAYjIYmAKcGrATAGern/9PjBHRERVtamFllYpf9t44LyKdkXDNSt69vl6ot2J6X820DNeQK0qNarU1io1tUqNUvda66ZPvK6tf39HVgUf5W46GSJF9T+FZVWUVtacUX9EaBC/mpzMnaN6Ehhgh0OmdXIlYLoB+0+ZzgYuaaqNqlaLSCEQC+Q1tdDcMuXhxRvPrdpWKkAgOADaF+QR3SaYqDbBdG/flqiwYKLbnPgJIrrtP6d7x0XYQ+tNq+dKwDT29dlwz8SVNojITGBm/WTF3mdv+N6F9fuKDpwlcH2Qba9vS3KlkSsBkw10P2U6HjjYRJtsEQkCooGjDRekqq8CrwKIyHpVTXGlSF9g2+vb/HF7XWnnyh1a64A+IpIoIiHAbcCyBm2WAT+qf30zsPJs51+MMf6h2T2Y+nMqDwErqLtM/YaqbhGRXwPrVXUZ8DrwtojspG7P5TZPFm2MaR1cuqlCVT8GPm7w3i9PeV0OTDvHdb96ju1bO9te32bb2wixIxljjKdYLzljjMc4GjAi8pyIbBORzSLyFxFp52Q9niYi00Rki4jUiojPXnEQkYkikikiO0XkCafr8SQReUNEckTEL265EJHuIpIqIhn1n+WHz9be6T2YT4GBqjoY2A486XA9nvY9cBOwyulCPOWUriXXAQOA20VkgLNVedQCYKLTRbSgauBnqtofGAU8eLb/v44GjKp+oqrV9ZNrqLvHxmepaoaqZjpdh4ed7FqiqpXAia4lPklVV9HIPV++SlUPqeq39a+LgQzq7uRvlNN7MKe6F1judBHmgjXWtaTJD6BpvUQkARgKfNNUG4/3/ReRz4DOjcz6uar+rb7Nz6nb9Vrk6Xo8zZXt9XEudRsxrZuIRABLgZ+qalFT7TweMKo6/mzzReRHwA3A1b5w929z2+sHXOlaYloxEQmmLlwWqeoHZ2vr9FWkicDjwGRVPe5kLcZtXOlaYlopqRtK8XUgQ1V/31x7p8/BzAEigU9FZKOIvOJwPR4lIj8UkWxgNPB3EVnhdE3uVn/S/kTXkgzgz6q6xdmqPEdE3gNWA0kiki0iM5yuycMuA+4Crqr/N7tRRH7QVGO7k9cY4zFO78EYY3yYBYwxxmMsYIwxHmMBY4zxGAsYY4zHWMAYYzzGAsYY4zEWMMYYj/k/VvcswVEIIkkAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -928,7 +960,7 @@ }, { "cell_type": "code", - "execution_count": 170, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -942,7 +974,7 @@ "dtype: float64" ] }, - "execution_count": 170, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -967,12 +999,12 @@ }, { "cell_type": "code", - "execution_count": 200, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -996,12 +1028,12 @@ }, { "cell_type": "code", - "execution_count": 202, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/examples/Warm-start and standard scenarios.ipynb b/examples/Warm_start_and_standard_scenarios.ipynb similarity index 83% rename from examples/Warm-start and standard scenarios.ipynb rename to examples/Warm_start_and_standard_scenarios.ipynb index 6864fef..c210865 100644 --- a/examples/Warm-start and standard scenarios.ipynb +++ b/examples/Warm_start_and_standard_scenarios.ipynb @@ -151,15 +151,15 @@ { "data": { "text/plain": [ - "{'holdout_size': 3,\n", - " 'negative_prediction': False,\n", - " 'permute_tops': False,\n", - " 'random_holdout': False,\n", + "{'permute_tops': False,\n", + " 'warm_start': True,\n", + " 'holdout_size': 3,\n", + " 'test_sample': None,\n", " 'shuffle_data': False,\n", + " 'random_holdout': False,\n", + " 'negative_prediction': False,\n", " 'test_fold': 5,\n", - " 'test_ratio': 0.2,\n", - " 'test_sample': None,\n", - " 'warm_start': True}" + " 'test_ratio': 0.2}" ] }, "execution_count": 4, @@ -189,7 +189,8 @@ "output_type": "stream", "text": [ "Preparing data...\n", - "Done.\n" + "Done.\n", + "There are 996585 events in the training and 3624 events in the holdout.\n" ] } ], @@ -251,13 +252,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "PureSVD training time: 0.12987111022293263s\n" + "PureSVD training time: 0.149s\n" ] }, { "data": { "text/plain": [ - "Hits(true_positive=512, false_positive=112, true_negative=1164, false_negative=1836)" + "[Relevance(precision=0.34864790286975716, recall=0.2008830022075055, fallout=0.05601545253863134, specifity=0.6227924944812362, miss_rate=0.7287527593818984),\n", + " Ranking(nDCG=0.1426077960282924, nDCL=0.04915993850533),\n", + " Experience(coverage=0.12169454937938479),\n", + " Hits(true_positive=512, false_positive=112, true_negative=1164, false_negative=1836)]" ] }, "execution_count": 8, @@ -294,17 +298,27 @@ "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Intel MKL BLAS detected. Its highly recommend to set the environment variable 'export MKL_NUM_THREADS=1' to disable its internal multithreading\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "iALS training time: 1.5761851485s\n" + "iALS training time: 1.837s\n" ] }, { "data": { "text/plain": [ - "Hits(true_positive=514, false_positive=116, true_negative=1160, false_negative=1834)" + "[Relevance(precision=0.34864790286975716, recall=0.2015728476821192, fallout=0.06084437086092715, specifity=0.6179635761589404, miss_rate=0.7280629139072847),\n", + " Ranking(nDCG=0.14200497688853128, nDCL=0.055115784933481085),\n", + " Experience(coverage=0.14813815434430652),\n", + " Hits(true_positive=514, false_positive=118, true_negative=1158, false_negative=1834)]" ] }, "execution_count": 10, @@ -388,7 +402,7 @@ { "data": { "text/plain": [ - "Relevance(precision=0.3536147902869757, recall=0.20516004415011035, fallout=0.06070640176600441, specifity=0.6181015452538631, miss_rate=0.7244757174392936)" + "Relevance(precision=0.34864790286975716, recall=0.2015728476821192, fallout=0.06084437086092715, specifity=0.6179635761589404, miss_rate=0.7280629139072847)" ] }, "execution_count": 13, @@ -426,9 +440,10 @@ "Preparing data...\n", "19 unique movieid's within 26 testset interactions were filtered. Reason: not in the training data.\n", "1 unique movieid's within 1 holdout interactions were filtered. Reason: not in the training data.\n", - "1 of 1208 userid's were filtered out from holdout. Reason: not enough items.\n", + "1 of 1208 userid's were filtered out from holdout. Reason: incompatible number of items.\n", "1 userid's were filtered out from testset. Reason: inconsistent with holdout.\n", - "Done.\n" + "Done.\n", + "There are 807458 events in the training and 3621 events in the holdout.\n" ] } ], @@ -489,13 +504,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "PureSVD training time: 0.10033848882716256s\n" + "PureSVD training time: 0.107s\n" ] }, { "data": { "text/plain": [ - "Hits(true_positive=515, false_positive=111, true_negative=1164, false_negative=1831)" + "[Relevance(precision=0.34907484120408727, recall=0.2020160176746755, fallout=0.05661419497376415, specifity=0.6219276442971554, miss_rate=0.7275614471140569),\n", + " Ranking(nDCG=0.1425979962160517, nDCL=0.04954089721828449),\n", + " Experience(coverage=0.12042310821806347),\n", + " Hits(true_positive=515, false_positive=111, true_negative=1164, false_negative=1831)]" ] }, "execution_count": 16, @@ -528,18 +546,28 @@ "execution_count": 17, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Intel MKL BLAS detected. Its highly recommend to set the environment variable 'export MKL_NUM_THREADS=1' to disable its internal multithreading\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ "iALS model is not ready. Rebuilding.\n", - "iALS training time: 1.25310956069s\n" + "iALS training time: 1.615s\n" ] }, { "data": { "text/plain": [ - "Hits(true_positive=509, false_positive=117, true_negative=1158, false_negative=1837)" + "[Relevance(precision=0.35183650925158794, recall=0.19994476663904998, fallout=0.05979011322838994, specifity=0.6187517260425297, miss_rate=0.7296326981496823),\n", + " Ranking(nDCG=0.1389285485663426, nDCL=0.05443458388828408),\n", + " Experience(coverage=0.14591809058855437),\n", + " Hits(true_positive=510, false_positive=117, true_negative=1158, false_negative=1836)]" ] }, "execution_count": 17, @@ -593,7 +621,7 @@ { "data": { "text/plain": [ - "Relevance(precision=0.34907484120408727, recall=0.2020160176746755, fallout=0.056614194973764152, specifity=0.62192764429715541, miss_rate=0.7275614471140569)" + "Relevance(precision=0.34907484120408727, recall=0.2020160176746755, fallout=0.05661419497376415, specifity=0.6219276442971554, miss_rate=0.7275614471140569)" ] }, "execution_count": 19, @@ -613,7 +641,7 @@ { "data": { "text/plain": [ - "Relevance(precision=0.34727975697321178, recall=0.19884009942004971, fallout=0.059375863021264838, specifity=0.61916597624965475, miss_rate=0.73073736536868272)" + "Relevance(precision=0.35183650925158794, recall=0.19994476663904998, fallout=0.05979011322838994, specifity=0.6187517260425297, miss_rate=0.7296326981496823)" ] }, "execution_count": 20, diff --git a/polara/__init__.py b/polara/__init__.py index 2503109..407deba 100644 --- a/polara/__init__.py +++ b/polara/__init__.py @@ -1,12 +1,16 @@ # import standard baseline models -from polara.recommender.models import RecommenderModel -from polara.recommender.models import SVDModel -from polara.recommender.models import CooccurrenceModel -from polara.recommender.models import RandomModel -from polara.recommender.models import PopularityModel +from polara.recommender.models import (RecommenderModel, + SVDModel, + ScaledSVD, + CooccurrenceModel, + RandomModel, + PopularityModel) + # import data model from polara.recommender.data import RecommenderData + # import data management routines from polara.datasets.movielens import get_movielens_data -from polara.datasets.bookcrossing import get_bx_data +from polara.datasets.bookcrossing import get_bookcrossing_data from polara.datasets.netflix import get_netflix_data +from polara.datasets.amazon import get_amazon_data diff --git a/polara/datasets/amazon.py b/polara/datasets/amazon.py new file mode 100644 index 0000000..09eb6a7 --- /dev/null +++ b/polara/datasets/amazon.py @@ -0,0 +1,25 @@ +from ast import literal_eval +import gzip +import pandas as pd + + +def parse_meta(path): + with gzip.open(path, 'rt') as gz: + for line in gz: + yield literal_eval(line) + + +def get_amazon_data(path=None, meta_path=None, nrows=None): + res = [] + if path: + data = pd.read_csv(path, header=None, + names=['userid', 'asin', 'rating', 'timestamp'], + usecols=['userid', 'asin', 'rating'], + nrows=nrows) + res.append(data) + if meta_path: + meta = pd.DataFrame.from_records(parse_meta(meta_path), nrows=nrows) + res.append(meta) + if len(res) == 1: + res = res[0] + return res diff --git a/polara/datasets/bookcrossing.py b/polara/datasets/bookcrossing.py index 8a24bba..2c0190e 100644 --- a/polara/datasets/bookcrossing.py +++ b/polara/datasets/bookcrossing.py @@ -7,7 +7,7 @@ from zipfile import ZipFile -def get_bx_data(local_file=None, get_ratings=True, get_users=False, get_books=False): +def get_bookcrossing_data(local_file=None, get_ratings=True, get_users=False, get_books=False): if not local_file: # downloading data from requests import get diff --git a/polara/datasets/epinions.py b/polara/datasets/epinions.py new file mode 100644 index 0000000..ff24901 --- /dev/null +++ b/polara/datasets/epinions.py @@ -0,0 +1,51 @@ +import numpy as np +import scipy as sp +import pandas as pd + + +def compute_graph_laplacian(edges, index): + all_edges = set() + for a, b in edges: + try: + a = index.get_loc(a) + b = index.get_loc(b) + except KeyError: + continue + if a == b: # exclude self links + continue + # make graph undirectional + all_edges.add((a, b)) + all_edges.add((b, a)) + + sp_edges = sp.sparse.csr_matrix((np.ones(len(all_edges)), zip(*all_edges))) + assert (sp_edges.diagonal() == 0).all() + return sp.sparse.csgraph.laplacian(sp_edges).tocsr(), sp_edges + + +def get_epinions_data(ratings_path=None, trust_data_path=None): + res = [] + if ratings_path: + ratings = pd.read_csv(ratings_path, + delim_whitespace=True, + skiprows=[0], + skipfooter=1, + engine='python', + header=None, + skipinitialspace=True, + names=['user', 'film', 'rating'], + usecols=['user', 'film', 'rating']) + res.append(ratings) + + if trust_data_path: + edges = pd.read_table(trust_data_path, + delim_whitespace=True, + skiprows=[0], + skipfooter=1, + engine='python', + header=None, + skipinitialspace=True, + usecols=[0, 1]) + res.append(edges) + + if len(res)==1: res = res[0] + return res diff --git a/polara/datasets/movielens.py b/polara/datasets/movielens.py index f376179..57c77cf 100644 --- a/polara/datasets/movielens.py +++ b/polara/datasets/movielens.py @@ -81,10 +81,14 @@ def get_movielens_data(local_file=None, get_ratings=True, get_genres=False, def get_split_genres(genres_data): - genres_data.index.name = 'movie_idx' - genres_stacked = genres_data.genres.str.split('|', expand=True).stack().to_frame('genreid') - ml_genres = genres_data[['movieid', 'movienm']].join(genres_stacked).reset_index(drop=True) - return ml_genres + return (genres_data[['movieid', 'movienm']] + .join(pd.DataFrame([(i, x) + for i, g in enumerate(genres_data['genres']) + for x in g.split('|') + ], columns=['index', 'genreid'] + ).set_index('index')) + .reset_index(drop=True)) + def filter_short_head(data, threshold=0.01): diff --git a/polara/datasets/netflix.py b/polara/datasets/netflix.py index 3d122e8..66a90ac 100644 --- a/polara/datasets/netflix.py +++ b/polara/datasets/netflix.py @@ -2,22 +2,45 @@ import tarfile -def get_netflix_data(gz_file): +def get_netflix_data(gz_file, get_ratings=True, get_probe=False): movie_data = [] - movie_name = [] + movie_inds = [] with tarfile.open(gz_file) as tar: - training_data = tar.getmember('download/training_set.tar') - with tarfile.open(fileobj=tar.extractfile(training_data)) as inner: - for item in inner.getmembers(): - if item.isfile(): - f = inner.extractfile(item.name) - df = pd.read_csv(f) - movieid = df.columns[0] - movie_name.append(movieid) - movie_data.append(df[movieid]) + if get_ratings: + training_data = tar.getmember('download/training_set.tar') + # maybe try with threads, e.g. + # https://stackoverflow.com/questions/43727520/speed-up-json-to-dataframe-w-a-lot-of-data-manipulation + with tarfile.open(fileobj=tar.extractfile(training_data)) as inner: + for item in inner.getmembers(): + if item.isfile(): + f = inner.extractfile(item.name) + df = pd.read_csv(f) + movieid = df.columns[0] + movie_inds.append(int(movieid[:-1])) + movie_data.append(df[movieid]) - data = pd.concat(movie_data, keys=movie_name) - data = data.reset_index().iloc[:, :3].rename(columns={'level_0': 'movieid', - 'level_1': 'userid', - 'level_2': 'rating'}) + if get_probe: + probe_data = tar.getmember('download/probe.txt') + probe_file = tar.extractfile(probe_data) + probe = [] + for line in probe_file: + line = line.strip() + if line.endswith(b':'): + movieid = int(line[:-1]) + else: + userid = int(line) + probe.append((movieid, userid)) + + data = None + if movie_data: + data = pd.concat(movie_data, keys=movie_inds) + data = data.reset_index().iloc[:, :3].rename(columns={'level_0': 'movieid', + 'level_1': 'userid', + 'level_2': 'rating'}) + if get_probe: + probe = pd.DataFrame.from_records(probe, columns=['movieid', 'userid']) + if data is not None: + data = (data, probe) + else: + data = probe return data diff --git a/polara/evaluation/evaluation_engine.py b/polara/evaluation/evaluation_engine.py index d5476eb..190db10 100644 --- a/polara/evaluation/evaluation_engine.py +++ b/polara/evaluation/evaluation_engine.py @@ -12,6 +12,9 @@ def sample_ci(df, coef=2.776, level=None): # 95% CI for sample under Student's t-test # http://www.stat.yale.edu/Courses/1997-98/101/confint.htm # example from http://onlinestatbook.com/2/estimation/mean.html + if isinstance(level, str): + level = df.index.names.index(level) + nlevels = df.index.nlevels if (nlevels == 1) & (level is None): n = df.shape[0] @@ -46,16 +49,22 @@ def average_results(scores): return averaged, errors -def evaluate_models(models, metrics, topk=None): - metric_scores = [] - for metric in metrics: - model_scores = [] - for model in models: - # print('model {}'.format(model.method)) - scores = model.evaluate(method=metric, topk=topk) - model_scores.append(scores) - metric_scores.append(pd.DataFrame(model_scores, index=[model.method for model in models]).T) - return metric_scores +def evaluate_models(models, metrics, **kwargs): + scores = [] + for model in models: + model_scores = model.evaluate(metric_type=metrics, **kwargs) + # ensure correct format + model_scores = model_scores if isinstance(model_scores, list) else [model_scores] + # concatenate all scores + name = [model.method] + metric_types = [s.__class__.__name__.lower() for s in model_scores] + scores_df = pd.concat([pd.DataFrame([s], index=name) for s in model_scores], + keys=metric_types, axis=1) + scores.append(scores_df) + res = pd.concat(scores, axis=0) + res.columns.names = ['type', 'metric'] + res.index.names = ['model'] + return res def set_topk(models, topk): @@ -69,69 +78,59 @@ def build_models(models, force=True): model.build() -def consolidate(scores, params, metrics): - res = {} - for i, metric in enumerate(metrics): - res[metric] = pd.concat([scores[j][i] for j in range(len(params))], - keys=params).unstack().swaplevel(0, 1, 1).sort_index() - return res - - -def consolidate_folds(scores, folds, metrics, index_names=['fold', 'top-n']): - res = {} - for metric in metrics: - data = pd.concat([scores[j][metric] for j in folds], keys=folds) - data.index.names = index_names - res[metric] = data - return res - - -def holdout_test_pair(model1, model2, holdout_sizes=[1], metrics=['hits']): - holdout_scores = [] - models = [model1, model2] - - data1 = model1.data - data2 = model2.data - for i in holdout_sizes: - print(i, end=' ') - data1.holdout_size = i - data1.update() - data2.holdout_size = i - data2.update() - - metric_scores = evaluate_models(models, metrics) - holdout_scores.append(metric_scores) - - return consolidate(holdout_scores, holdout_sizes, metrics) +def consolidate(scores, level_name=None, level_keys=None): + level_names = [level_name] + scores[0].index.names + return pd.concat(scores, axis=0, keys=level_keys, names=level_names) -def holdout_test(models, holdout_sizes=[1], metrics=['hits'], force_build=True): +def holdout_test(models, holdout_sizes=[1], metrics='all'): holdout_scores = [] data = models[0].data assert all([model.data is data for model in models[1:]]) #check that data is shared across models - build_models(models, force_build) for i in holdout_sizes: data.holdout_size = i data.update() - metric_scores = evaluate_models(models, metrics) holdout_scores.append(metric_scores) - - return consolidate(holdout_scores, holdout_sizes, metrics) + return consolidate(holdout_scores, level_name='hsize', level_keys=holdout_sizes) -def topk_test(models, topk_list=[10], metrics=['hits'], force_build=True): +def topk_test(models, **kwargs): + metrics = kwargs.pop('metrics', None) or 'all' + topk_list = kwargs.pop('topk_list', [10]) topk_scores = [] data = models[0].data - assert all([model.data is data for model in models[1:]]) #check that data is shared across models + assert all([model.data is data for model in models[1:]]) # check that data is shared across models - data.update() - topk_list = list(reversed(sorted(topk_list))) #start from max topk and rollback + topk_list_sorted = list(reversed(sorted(topk_list))) # start from max topk and rollback - build_models(models, force_build) - for topk in topk_list: - metric_scores = evaluate_models(models, metrics, topk) + for topk in topk_list_sorted: + kwargs['topk'] = topk + metric_scores = evaluate_models(models, metrics, **kwargs) topk_scores.append(metric_scores) - return consolidate(topk_scores, topk_list, metrics) + level_name = 'top-n' + res = consolidate(topk_scores, level_name=level_name, level_keys=topk_list_sorted) + return res.sort_index(level=level_name, sort_remaining=False) + + +def run_cv_experiment(models, folds=None, metrics='all', fold_experiment=evaluate_models, + force_build=True, iterator=lambda x: x, **kwargs): + if not isinstance(models, (list, tuple)): + models = [models] + + data = models[0].data + assert all([model.data is data for model in models[1:]]) # check that data is shared across models + + if folds is None: + folds = range(1, int(1/data.test_ratio) + 1) + + fold_results = [] + for fold in iterator(folds): + data.test_fold = fold + data.update() + build_models(models, force_build) + fold_result = fold_experiment(models, metrics=metrics, **kwargs) + fold_results.append(fold_result) + return consolidate(fold_results, level_name='fold', level_keys=folds) diff --git a/polara/evaluation/pipelines.py b/polara/evaluation/pipelines.py index a3ba713..ad372d8 100644 --- a/polara/evaluation/pipelines.py +++ b/polara/evaluation/pipelines.py @@ -2,8 +2,8 @@ from operator import mul as mul_op from functools import reduce -from itertools import product from random import choice +import pandas as pd def random_chooser(): @@ -12,28 +12,176 @@ def random_chooser(): yield choice(values) -def random_grid(params, n=60, grid_cache=None): +def random_grid(params, n=60, grid_cache=None, skip_config=None): if not isinstance(n, int): raise TypeError('n must be an integer, not {}'.format(type(n))) if n < 0: raise ValueError('n should be >= 0') - - grid = grid_cache or set() - max_n = reduce(mul_op, [len(vals) for vals in params.values()]) + # fix names and order of parameters + param_names, param_values = zip(*params.items()) + grid = set(grid_cache) if grid_cache is not None else set() + max_n = reduce(mul_op, [len(vals) for vals in param_values]) n = min(n if n > 0 else max_n, max_n) + + skipped = set() + if skip_config is None: + def never_skip(config): return False + skip_config = never_skip + param_chooser = random_chooser() try: - while len(grid) < n: + while len(grid) < (n-len(skipped)): level_choice = [] - for v in params.values(): + for param_val in param_values: next(param_chooser) - level_choice.append(param_chooser.send(v)) - grid.add(tuple(level_choice)) + level_choice.append(param_chooser.send(param_val)) + level_choice = tuple(level_choice) + if skip_config(level_choice): + skipped.add(level_choice) + continue + grid.add(level_choice) except KeyboardInterrupt: print('Interrupted by user. Providing current results.') - return grid + return grid, param_names def set_config(model, attributes, values): for name, value in zip(attributes, values): setattr(model, name, value) + + +def evaluate_models(models, target_metric='precision', metric_type='all', **kwargs): + if not isinstance(models, (list, tuple)): + models = [models] + + model_scores = {} + for model in models: + scores = model.evaluate(metric_type, **kwargs) + scores = [scores] if not isinstance(scores, list) else scores + scores_df = pd.concat([pd.DataFrame([s]) for s in scores], axis=1) + if isinstance(target_metric, str): + model_scores[model.method] = scores_df[target_metric].squeeze() + elif callable(target_metric): + model_scores[model.method] = scores_df.apply(target_metric, axis=1).squeeze() + else: + raise NotImplementedError + return model_scores + + +def find_optimal_svd_rank(model, ranks, target_metric, return_scores=False, + protect_factors=True, config=None, verbose=False, + evaluator=None, iterator=lambda x: x, **kwargs): + evaluator = evaluator or evaluate_models + model_verbose = model.verbose + if config: + set_config(model, *zip(*config.items())) + + model.rank = svd_rank = max(max(ranks), model.rank) + if not model._is_ready: + model.verbose = verbose + model.build() + + if protect_factors: + svd_factors = dict(**model.factors) # avoid accidental overwrites + + res = {} + try: + for rank in iterator(list(reversed(sorted(ranks)))): + model.rank = rank + res[rank] = evaluator(model, target_metric, **kwargs)[model.method] + # prevent previous scores caching when assigning svd_rank + model._recommendations = None + finally: + if protect_factors: + model._rank = svd_rank + model.factors = svd_factors + model.verbose = model_verbose + + scores = pd.Series(res) + best_rank = scores.idxmax() + if return_scores: + scores.index.name = 'rank' + scores.name = model.method + return best_rank, scores.loc[ranks] + return best_rank + + +def find_optimal_tucker_ranks(model, tucker_ranks, target_metric, return_scores=False, + config=None, verbose=False, same_space=False, + evaluator=None, iterator=lambda x: x, **kwargs): + evaluator = evaluator or evaluate_models + model_verbose = model.verbose + if config: + set_config(model, *zip(*config.items())) + + model.mlrank = tuple([max(mode_ranks) for mode_ranks in tucker_ranks]) + + if not model._is_ready: + model.verbose = verbose + model.build() + + factors = dict(**model.factors) + tucker_rank = model.mlrank + + res_score = {} + for r1 in iterator(tucker_ranks[0]): + for r2 in tucker_ranks[1]: + if same_space and (r2 != r1): + continue + for r3 in tucker_ranks[2]: + if (r1*r2 < r3) or (r1*r3 < r2) or (r2*r3 < r1): + continue + try: + model.mlrank = mlrank = (r1, r2, r3) + res_score[mlrank] = evaluator(model, target_metric, **kwargs)[model.method] + # prevent previous scores caching when assigning tucker_rank + model._recommendations = None + finally: + model._mlrank = tucker_rank + model.factors = dict(**factors) + model.verbose = model_verbose + + scores = pd.Series(res_score).sort_index() + best_mlrank = scores.idxmax() + if return_scores: + scores.index.names = ['r1', 'r2', 'r3'] + scores.name = model.method + return best_mlrank, scores + return best_mlrank + + +def find_optimal_config(model, param_grid, param_names, target_metric, return_scores=False, + init_config=None, reset_config=None, verbose=False, force_build=True, + evaluator=None, iterator=lambda x: x, **kwargs): + evaluator = evaluator or evaluate_models + model_verbose = model.verbose + if init_config: + set_config(model, *zip(*init_config.items())) + + model.verbose = verbose + grid_results = {} + for params in iterator(param_grid): + try: + set_config(model, param_names, params) + if not model._is_ready or force_build: + model.build() + grid_results[params] = evaluator(model, target_metric, **kwargs)[model.method] + finally: + if reset_config is not None: + if isinstance(reset_config, dict): + set_config(model, *zip(*reset_config.items())) + elif callable(reset_config): + reset_config(model) + else: + raise NotImplementedError + + model.verbose = model_verbose + # workaround non-orderable configs (otherwise pandas raises error) + scores = pd.Series(**dict(zip(('index', 'data'), + (zip(*grid_results.items()))))) + best_config = scores.idxmax() + if return_scores: + scores.index.names = param_names + scores.name = model.method + return best_config, scores + return best_config diff --git a/polara/evaluation/plotting.py b/polara/evaluation/plotting.py index f4710aa..ea889e9 100644 --- a/polara/evaluation/plotting.py +++ b/polara/evaluation/plotting.py @@ -8,6 +8,9 @@ def _plot_pair(scores, keys, titles=None, errors=None, err_alpha=0.2, figsize=(1 else: show_legend = False + if 'model' in scores.index.names: + scores = scores.unstack('model') + left, right = keys left_title, right_title = titles or keys @@ -18,6 +21,8 @@ def _plot_pair(scores, keys, titles=None, errors=None, err_alpha=0.2, figsize=(1 plt.legend(loc='center left', bbox_to_anchor=(1.0, 0.5)) if errors is not None: + if 'model' in errors.index.names: + errors = errors.unstack('model') errG = errors[left] errL = errors[right] for method in errL.columns: @@ -39,7 +44,7 @@ def _plot_pair(scores, keys, titles=None, errors=None, err_alpha=0.2, figsize=(1 def show_hits(all_scores, **kwargs): - scores = all_scores['hits'] + scores = all_scores['hits'] if 'hits' in all_scores else all_scores keys = ['true_positive', 'false_positive'] kwargs['titles'] = ['True Positive Hits @$n$', 'False Positive Hits @$n$'] kwargs['errors'] = kwargs['errors']['hits'] if kwargs.get('errors', None) is not None else None @@ -47,7 +52,7 @@ def show_hits(all_scores, **kwargs): def show_ranking(all_scores, **kwargs): - scores = all_scores['ranking'] + scores = all_scores['ranking'] if 'ranking' in all_scores else all_scores keys = ['nDCG', 'nDCL'] kwargs['titles'] = ['nDCG@$n$', 'nDCL@$n$'] kwargs['errors'] = kwargs['errors']['ranking'] if kwargs.get('errors', None) is not None else None @@ -62,6 +67,9 @@ def _cross_plot(scores, keys, titles=None, errors=None, err_alpha=0.2, ROC_middl else: show_legend = False + if 'model' in scores.index.names: + scores = scores.unstack('model') + methods = scores.columns.levels[1] x, y = keys for method in methods: @@ -72,6 +80,8 @@ def _cross_plot(scores, keys, titles=None, errors=None, err_alpha=0.2, ROC_middl plt.legend(loc='center left', bbox_to_anchor=(1.0, 0.5)) if errors is not None: + if 'model' in errors.index.names: + errors = errors.unstack('model') for method in methods: plot_data = scores.xs(method, 1, 1).sort_values(x) error = errors.xs(method, 1, 1).sort_values(x) @@ -97,7 +107,7 @@ def _cross_plot(scores, keys, titles=None, errors=None, err_alpha=0.2, ROC_middl def show_hit_rates(all_scores, **kwargs): - scores = all_scores['relevance'] + scores = all_scores['relevance'] if 'relevance' in all_scores else all_scores keys = ['fallout', 'recall'] kwargs['titles'] = ['False Positive Rate', 'True Positive Rate'] kwargs['errors'] = kwargs['errors']['relevance'] if kwargs.get('errors', None) is not None else None @@ -107,7 +117,7 @@ def show_hit_rates(all_scores, **kwargs): def show_ranking_positivity(all_scores, **kwargs): - scores = all_scores['ranking'] + scores = all_scores['ranking'] if 'ranking' in all_scores else all_scores keys = ['nDCL', 'nDCG'] kwargs['titles'] = ['Negative Ranking', 'Positive Ranking'] kwargs['errors'] = kwargs['errors']['ranking'] if kwargs.get('errors', None) is not None else None @@ -117,7 +127,7 @@ def show_ranking_positivity(all_scores, **kwargs): def show_precision_recall(all_scores, limit=False, ignore_field_limit=None, **kwargs): - scores = all_scores['relevance'] + scores = all_scores['relevance'] if 'relevance' in all_scores else all_scores keys = ['recall', 'precision'] kwargs['titles'] = ['Recall', 'Precision'] kwargs['errors'] = kwargs['errors']['relevance'] if kwargs.get('errors', None) is not None else None diff --git a/polara/lib/optimize.py b/polara/lib/optimize.py index 7942f4b..f9eb8ff 100644 --- a/polara/lib/optimize.py +++ b/polara/lib/optimize.py @@ -1,8 +1,13 @@ +from math import sqrt import numpy as np -from numba import njit +from numba import jit, njit, prange + +from polara.tools.timing import track_time + @njit(nogil=True) -def sgd_step(users_idx, items_idx, feedbacks, P, Q, eta, lambd): +def mf_sgd_sweep(users_idx, items_idx, feedbacks, P, Q, eta, lambd, *args, + adjust_gradient, adjustment_params): cum_error = 0 for k, a in enumerate(feedbacks): i = users_idx[k] @@ -11,19 +16,25 @@ def sgd_step(users_idx, items_idx, feedbacks, P, Q, eta, lambd): pi = P[i, :] qj = Q[j, :] - e = a - np.dot(pi, qj) + err = a - pi @ qj - new_pi = pi + eta * (e*qj - lambd*pi) - new_qj = qj + eta * (e*pi - lambd*qj) + ngrad_p = err*qj - lambd*pi + adjusted_ngrad_p = adjust_gradient(ngrad_p, i, *adjustment_params[0]) + new_pi = pi + eta * adjusted_ngrad_p + + ngrad_q = err*pi - lambd*qj + adjusted_ngrad_q = adjust_gradient(ngrad_q, j, *adjustment_params[1]) + new_qj = qj + eta * adjusted_ngrad_q P[i, :] = new_pi Q[j, :] = new_qj - cum_error += e*e + cum_error += err*err return cum_error @njit(nogil=True) -def sgd_step_biased(users_idx, items_idx, feedbacks, P, Q, b_user, b_item, mu, eta, lambd): +def mf_sgd_sweep_biased(users_idx, items_idx, feedbacks, P, Q, eta, lambd, + b_user, b_item, mu, *args): cum_error = 0 for k, a in enumerate(feedbacks): i = users_idx[k] @@ -34,7 +45,7 @@ def sgd_step_biased(users_idx, items_idx, feedbacks, P, Q, b_user, b_item, mu, e bi = b_user[i] bj = b_item[j] - e = a - (np.dot(pi, qj) + bi + bj + mu) + e = a - (pi @ qj + bi + bj + mu) new_pi = pi + eta * (e*qj - lambd*pi) new_qj = qj + eta * (e*pi - lambd*qj) @@ -50,3 +61,240 @@ def sgd_step_biased(users_idx, items_idx, feedbacks, P, Q, b_user, b_item, mu, e cum_error += e*e return cum_error + + + +@njit(nogil=True) +def identity(x, *args): # used to fall back to standard SGD + return x + + +@njit(nogil=True) +def adagrad(grad, m, cum_sq_grad, smoothing=1e-6): + cum_sq_grad_update = cum_sq_grad[m, :] + grad * grad + cum_sq_grad[m, :] = cum_sq_grad_update + adjusted_grad = grad / (smoothing + np.sqrt(cum_sq_grad_update)) + return adjusted_grad + + +@njit(nogil=True) +def rmsprop(grad, m, cum_sq_grad, gamma=0.9, smoothing=1e-6): + cum_sq_grad_update = gamma * cum_sq_grad[m, :] + (1 - gamma) * (grad * grad) + cum_sq_grad[m, :] = cum_sq_grad_update + adjusted_grad = grad / (smoothing + np.sqrt(cum_sq_grad_update)) + return adjusted_grad + + +@njit(nogil=True) +def adam(grad, m, cum_grad, cum_sq_grad, step, beta1=0.9, beta2=0.999, smoothing=1e-6): + cum_grad_update = beta1 * cum_grad[m, :] + (1 - beta1) * grad + cum_grad[m, :] = cum_grad_update + cum_sq_grad_update = beta2 * cum_sq_grad[m, :] + (1 - beta2) * (grad * grad) + cum_sq_grad[m, :] = cum_sq_grad_update + step[m] = t = step[m] + 1 + db1 = 1 - beta1**t + db2 = 1 - beta2**t + adjusted_grad = cum_grad_update/db1 / (smoothing + np.sqrt(cum_sq_grad_update/db2)) + return adjusted_grad + + +@njit(nogil=True) +def adanorm(grad, m, smoothing=1e-6): + gnorm2 = grad @ grad + adjusted_grad = grad / sqrt(smoothing + gnorm2) + return adjusted_grad + +@njit(nogil=True) +def gnprop(grad, m, cum_sq_norm, gamma=0.99, smoothing=1e-6): + cum_sq_norm_update = gamma * cum_sq_norm[m] + (1 - gamma) * (grad @ grad) + cum_sq_norm[m] = cum_sq_norm_update + adjusted_grad = grad / sqrt(smoothing + cum_sq_norm_update) + return adjusted_grad + +@njit(nogil=True) +def gnpropz(grad, m, cum_sq_norm, smoothing=1e-6): + cum_sq_norm_update = cum_sq_norm[m] + grad @ grad + cum_sq_norm[m] = cum_sq_norm_update + adjusted_grad = grad / sqrt(smoothing + cum_sq_norm_update) + return adjusted_grad + + +@njit(nogil=True, parallel=False) +def generalized_sgd_sweep(row_idx, col_idx, values, P, Q, + eta, lambd, row_nnz, col_nnz, + transform, transform_params, + adjust_gradient, adjustment_params): + cum_error = 0 + for k, val in enumerate(values): + m = row_idx[k] + n = col_idx[k] + + pm = P[m, :] + qn = Q[n, :] + + err = val - pm @ qn + row_lambda = lambd / row_nnz[m] + col_lambda = lambd / col_nnz[n] + + kpm = transform(pm, P, m, *transform_params[0]) + ngrad_p = err * qn - kpm * row_lambda + sqn = transform(qn, Q, n, *transform_params[1]) + ngrad_q = err * pm - sqn * col_lambda + + adjusted_ngrad_p = adjust_gradient(ngrad_p, m, *adjustment_params[0]) + new_pm = pm + eta * adjusted_ngrad_p + adjusted_ngrad_q = adjust_gradient(ngrad_q, n, *adjustment_params[1]) + new_qn = qn + eta * adjusted_ngrad_q + + P[m, :] = new_pm + Q[n, :] = new_qn + + cum_error += err*err + return cum_error + + +# @jit +def mf_sgd_boilerplate(interactions, shape, nonzero_count, rank, + lrate, lambd, num_epochs, tol, + sgd_sweep_func=None, + transform=None, transform_params=None, + adjust_gradient=None, adjustment_params=None, + seed=None, verbose=False, + iter_errors=None, iter_time=None): + assert isinstance(interactions, tuple) # required by numba + assert isinstance(nonzero_count, tuple) # required by numba + + nrows, ncols = shape + row_shp = (nrows, rank) + col_shp = (ncols, rank) + + rnds = np.random if seed is None else np.random.RandomState(seed) + row_factors = rnds.normal(scale=0.1, size=row_shp) + col_factors = rnds.normal(scale=0.1, size=col_shp) + + sgd_sweep_func = sgd_sweep_func or generalized_sgd_sweep + transform = transform or identity + transform_params = transform_params or ((), ()) + adjust_gradient = adjust_gradient or identity + adjustment_params = adjustment_params or ((), ()) + + nnz = len(interactions[-1]) + last_err = np.finfo('f8').max + training_time = [] + for epoch in range(num_epochs): + if adjust_gradient in [adagrad, rmsprop]: + adjustment_params = ((np.zeros(row_shp, dtype='f8'),), + (np.zeros(col_shp, dtype='f8'),) + ) + if adjust_gradient is gnprop: + adjustment_params = ((np.zeros(nrows, dtype='f8'),), + (np.zeros(ncols, dtype='f8'),) + ) + if adjust_gradient is adam: + adjustment_params = ((np.zeros(row_shp, dtype='f8'), + np.zeros(row_shp, dtype='f8'), + np.zeros(nrows, dtype='intp')), + (np.zeros(col_shp, dtype='f8'), + np.zeros(col_shp, dtype='f8'), + np.zeros(ncols, dtype='intp')) + ) + + with track_time(training_time, verbose=False): + new_err = sgd_sweep_func(*interactions, row_factors, col_factors, + lrate, lambd, *nonzero_count, + transform, transform_params, + adjust_gradient, adjustment_params) + + refined = abs(last_err - new_err) / last_err + last_err = new_err + rmse = sqrt(new_err / nnz) + if iter_errors is not None: + iter_errors.append(rmse) + if verbose: + print('Epoch: {}. RMSE: {}'.format(epoch, rmse)) + if refined < tol: + break + if iter_time is not None: + iter_time.extend(training_time) + return row_factors, col_factors + + +def simple_mf_sgd(interactions, shape, nonzero_count, rank, + lrate, lambd, num_epochs, tol, + adjust_gradient=None, adjustment_params=None, + seed=None, verbose=False, + iter_errors=None, iter_time=None): + #nonzero_count = ((), ()) + nonzero_count = (np.ones(shape[0]), np.ones(shape[1])) + return mf_sgd_boilerplate(interactions, shape, nonzero_count, rank, + lrate, lambd, num_epochs, tol, + adjust_gradient=adjust_gradient, + adjustment_params=adjustment_params, + sgd_sweep_func=generalized_sgd_sweep, + seed=seed, verbose=verbose, + iter_errors=iter_errors, iter_time=iter_time) + + +def simple_pmf_sgd(interactions, shape, nonzero_count, rank, + lrate, sigma, num_epochs, tol, + adjust_gradient=None, adjustment_params=None, + seed=None, verbose=False, + iter_errors=None, iter_time=None): + lambd = 0.5 * sigma**2 + return mf_sgd_boilerplate(interactions, shape, nonzero_count, rank, + lrate, lambd, num_epochs, tol, + adjust_gradient=adjust_gradient, + adjustment_params=adjustment_params, + seed=seed, verbose=verbose, + iter_errors=iter_errors, iter_time=iter_time) + + +def sp_kernel_update(pm, P, m, K): + k = K.getrow(m) + kp = k.dot(P).squeeze() + return kp + k[0, m] * pm + +@njit(nogil=True, parallel=False) +def sparse_kernel_update(pm, P, m, kernel_ptr, kernel_ind, kernel_data): + lead_idx = kernel_ptr[m] + stop_idx = kernel_ptr[m+1] + + kernel_update = np.zeros_like(pm) + + for i in range(lead_idx, stop_idx): + index = kernel_ind[i] + value = kernel_data[i] + p_row = P[index, :] + if index == m: # diagonal value + p_row = p_row + pm # avoid rewriting original data + kernel_update += value * p_row + return kernel_update + + +def kernelized_pmf_sgd(interactions, shape, nonzero_count, rank, + lrate, sigma, num_epochs, tol, + kernel_matrices, kernel_update=None, sparse_kernel_format=True, + adjust_gradient=None, adjustment_params=None, + seed=None, verbose=False, iter_errors=None, iter_time=None): + kernel_update = kernel_update or sparse_kernel_update + + row_kernel, col_kernel = kernel_matrices + if sparse_kernel_format: + row_kernel_data = (row_kernel.indptr, row_kernel.indices, row_kernel.data) + col_kernel_data = (col_kernel.indptr, col_kernel.indices, col_kernel.data) + else: + row_kernel_data = (row_kernel,) + col_kernel_data = (col_kernel,) + + kernel_params = (row_kernel_data, col_kernel_data) + + lambd = 0.5 * sigma**2 + return mf_sgd_boilerplate(interactions, shape, nonzero_count, rank, + lrate, lambd, num_epochs, tol, + sgd_sweep_func=generalized_sgd_sweep, + transform=kernel_update, + transform_params=kernel_params, + adjust_gradient=adjust_gradient, + adjustment_params=adjustment_params, + seed=seed, verbose=verbose, + iter_errors=iter_errors, iter_time=iter_time) diff --git a/polara/lib/similarity.py b/polara/lib/similarity.py index 8449f0f..3b83d9f 100644 --- a/polara/lib/similarity.py +++ b/polara/lib/similarity.py @@ -47,9 +47,10 @@ def set_diagonal_values(mat, val=1): def safe_inverse_root(d, dtype=None): - if (d < 0).any(): - raise ValueError - return np.power(d, -0.5, where=d>0, dtype=dtype) + pos_d = d > 0 + res = np.zeros(len(d), dtype=dtype) + np.power(d, -0.5, where=pos_d, dtype=dtype, out=res) + return res def normalize_binary_features(feature_mat, dtype=None): @@ -251,13 +252,25 @@ def build_indicator_matrix(labels, max_items=None): return csr_matrix((data, indices, indprt), shape=shape) -def feature2sparse(feature_data, ranking=None, deduplicate=True): +def feature2sparse(feature_data, ranking=None, deduplicate=True, labels=None): if deduplicate: feature_data = feature_data.apply(uniquify_ordered if ranking else set) - feature_lbl = defaultdict(lambda: len(feature_lbl)) - indices = [feature_lbl[item] for items in feature_data for item in items] - indptr = np.r_[0, feature_data.apply(len).cumsum().values] + if labels: + feature_lbl = labels + indices = [] + indlens = [] + for items in feature_data: + # wiil also remove unknown items to ensure index consistency + inds = [feature_lbl[item] for item in items if item in feature_lbl] + indices.extend(inds) + indlens.append(len(inds)) + else: + feature_lbl = defaultdict(lambda: len(feature_lbl)) + indices = [feature_lbl[item] for items in feature_data for item in items] + indlens = feature_data.apply(len).values + + indptr = np.r_[0, np.cumsum(indlens)] if ranking: if ranking is True: @@ -285,7 +298,7 @@ def feature2sparse(feature_data, ranking=None, deduplicate=True): return feature_mat, dict(feature_lbl) -def get_features_data(meta_data, ranking=None, deduplicate=True): +def get_features_data(meta_data, ranking=None, deduplicate=True, labels=None): feature_mats = OrderedDict() feature_lbls = OrderedDict() features = meta_data.columns @@ -303,13 +316,16 @@ def get_features_data(meta_data, ranking=None, deduplicate=True): for feature in features: feature_data = meta_data[feature] - mat, lbl = feature2sparse(feature_data, ranking=ranking.get(feature, None), deduplicate=deduplicate) + mat, lbl = feature2sparse(feature_data, + ranking=ranking.get(feature, None), + deduplicate=deduplicate, + labels=labels[feature] if labels else None) feature_mats[feature], feature_lbls[feature] = mat, lbl return feature_mats, feature_lbls -def stack_features(features, add_identity=False, normalize=True, dtype=None, **kwargs): - feature_mats, feature_lbls = get_features_data(features, **kwargs) +def stack_features(features, add_identity=False, normalize=True, dtype=None, labels=None, stacked_index=False, **kwargs): + feature_mats, feature_lbls = get_features_data(features, labels=labels, **kwargs) all_matrices = list(feature_mats.values()) if add_identity: @@ -320,9 +336,15 @@ def stack_features(features, add_identity=False, normalize=True, dtype=None, **k if normalize: norm = stacked_features.getnnz(axis=1) + norm = norm.astype(np.promote_types(norm.dtype, 'f4')) scaling = np.power(norm, -1, where=norm>0, dtype=dtype) stacked_features = sp.sparse.diags(scaling).dot(stacked_features) + if stacked_index: + index_shift = identity.shape[1] if add_identity else 0 + for feature, lbls in feature_lbls.items(): + feature_lbls[feature] = {k:v+index_shift for k, v in lbls.items()} + index_shift += feature_mats[feature].shape[1] return stacked_features, feature_lbls diff --git a/polara/lib/sparse.py b/polara/lib/sparse.py index 54ab043..352685c 100644 --- a/polara/lib/sparse.py +++ b/polara/lib/sparse.py @@ -1,19 +1,84 @@ -# python 2/3 interoperability -try: - range = xrange -except NameError: - pass - +import sys from concurrent.futures import ThreadPoolExecutor from concurrent.futures import as_completed import numpy as np +from numpy import power from scipy.sparse import csr_matrix +from scipy.sparse import diags +from scipy.sparse.linalg import norm as spnorm + from numba import jit, njit, guvectorize, prange from numba import float64 as f8 from numba import intp as ip from polara.recommender import defaults + +tuplsize = sys.getsizeof(()) +itemsize = np.dtype(np.intp).itemsize +pntrsize = sys.getsizeof(1.0) +# size of list of tuples of indices - to estimate when to convert sparse matrix to dense +# based on http://stackoverflow.com/questions/15641344/python-memory-consumption-dict-vs-list-of-tuples +# and https://code.tutsplus.com/tutorials/understand-how-much-memory-your-python-objects-use--cms-25609 +def get_nnz_max(): + return int(defaults.memory_hard_limit * (1024**3) / (tuplsize + 2*(pntrsize + itemsize))) + + +def check_sparsity(matrix, nnz_coef=0.5, tocsr=False): + if matrix.nnz > nnz_coef * matrix.shape[0] * matrix.shape[1]: + return matrix.toarray(order='C') + if tocsr: + return matrix.tocsr() + return matrix + + +def sparse_dot(left_mat, right_mat, dense_output=False, tocsr=False): + # scipy always returns sparse result, even if dot product is dense + # this function offers solution to this problem + # it also takes care on sparse result w.r.t. to further processing + if dense_output: # calculate dense result directly + # TODO matmat multiplication instead of iteration with matvec + res_type = np.result_type(right_mat.dtype, left_mat.dtype) + result = np.empty((left_mat.shape[0], right_mat.shape[1]), dtype=res_type) + for i in range(left_mat.shape[0]): + v = left_mat.getrow(i) + result[i, :] = csc_matvec(right_mat, v, dense_output=True, dtype=res_type) + else: + result = left_mat.dot(right_mat.T) + # NOTE even though not neccessary for symmetric i2i matrix, + # transpose helps to avoid expensive conversion to CSR (performed by scipy) + if result.nnz > get_nnz_max(): + # too many nnz lead to undesired memory overhead in downvote_seen_items + result = result.toarray() # not using order='C' as it may consume memory + else: + result = check_sparsity(result, tocsr=tocsr) + return result + + +def rescale_matrix(matrix, scaling, axis, binary=True, return_scaling_values=False): + '''Function to scale either rows or columns of the sparse rating matrix''' + scaling_values = None + if scaling == 1: # no scaling (standard SVD case) + result = matrix + + if binary: + norm = np.sqrt(matrix.getnnz(axis=axis)) # compute Euclidean norm as if values are binary + else: + norm = spnorm(matrix, axis=axis, ord=2) # compute Euclidean norm + + scaling_values = power(norm, scaling-1, where=norm != 0) + scaling_matrix = diags(scaling_values) + + if axis == 0: # scale columns + result = matrix.dot(scaling_matrix) + if axis == 1: # scale rows + result = scaling_matrix.dot(matrix) + + if return_scaling_values: + result = (result, scaling_values) + return result + + # matvec implementation is based on # http://stackoverflow.com/questions/18595981/improving-performance-of-multiplication-of-scipy-sparse-matrices @njit(nogil=True) @@ -161,7 +226,8 @@ def dttm_par(idx, val, mat1, mat2, mode1, mode2, unqs, inds, res): res[i0, j1, j2] += vp * mat1[i1, j1] * mat2[i2, j2] -@jit(parallel=True) +# @jit(parallel=True) # numba up to v0.41.dev only supports the 1st argument +# https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html def arrange_index(array): unqs, unq_inv, unq_cnt = np.unique(array, return_inverse=True, return_counts=True) inds = np.split(np.argsort(unq_inv), np.cumsum(unq_cnt[:-1])) diff --git a/polara/lib/tensor.py b/polara/lib/tensor.py index 56c34ac..99d5ba1 100644 --- a/polara/lib/tensor.py +++ b/polara/lib/tensor.py @@ -34,7 +34,8 @@ def ttm3d_par(idx, val, shape, U, V, modes, unqs, inds, dtype=None): return res -def hooi(idx, val, shape, core_shape, num_iters=25, parallel_ttm=False, growth_tol=0.01, verbose=False, seed=None): +def hooi(idx, val, shape, core_shape, return_core=True, num_iters=25, + parallel_ttm=False, growth_tol=0.01, verbose=False, seed=None): ''' Compute Tucker decomposition of a sparse tensor in COO format with the help of HOOI algorithm. Usage: @@ -62,19 +63,20 @@ def log_status(msg): u2 = np.linalg.qr(u2, mode='reduced')[0] g_norm_old = 0 + return_core_vectors = True if return_core else 'u' for i in range(num_iters): log_status('Step %i of %i' % (i+1, num_iters)) u0 = ttm[0](*tensor_data, u2, u1, ((2, 0), (1, 0)), *index_data[0]).reshape(shape[0], r1*r2) - uu = svds(u0, k=r0, return_singular_vectors='u')[0] + uu, ss, _ = svds(u0, k=r0, return_singular_vectors='u') u0 = np.ascontiguousarray(uu[:, ::-1]) u1 = ttm[1](*tensor_data, u2, u0, ((2, 0), (0, 0)), *index_data[1]).reshape(shape[1], r0*r2) - uu = svds(u1, k=r1, return_singular_vectors='u')[0] + uu, ss, _ = svds(u1, k=r1, return_singular_vectors='u') u1 = np.ascontiguousarray(uu[:, ::-1]) u2 = ttm[2](*tensor_data, u1, u0, ((1, 0), (0, 0)), *index_data[2]).reshape(shape[2], r0*r1) - uu, ss, vv = svds(u2, k=r2) + uu, ss, vv = svds(u2, k=r2, return_singular_vectors=return_core_vectors) u2 = np.ascontiguousarray(uu[:, ::-1]) g_norm_new = np.linalg.norm(ss) @@ -85,7 +87,10 @@ def log_status(msg): log_status('Core is no longer growing. Norm of the core: %f' % g_norm_old) break - g = np.ascontiguousarray((ss[:, np.newaxis] * vv)[::-1, :]) - g = g.reshape(r2, r1, r0).transpose(2, 1, 0) + if return_core: + g = np.ascontiguousarray((ss[:, np.newaxis] * vv)[::-1, :]) + g = g.reshape(r2, r1, r0).transpose(2, 1, 0) + else: + g = None log_status('Done') return u0, u1, u2, g diff --git a/polara/recommender/coldstart/data.py b/polara/recommender/coldstart/data.py index 7f0dee4..1ff2a3d 100644 --- a/polara/recommender/coldstart/data.py +++ b/polara/recommender/coldstart/data.py @@ -1,9 +1,10 @@ from collections import namedtuple, defaultdict import numpy as np -import pandas as pd -from scipy.sparse import issparse + from polara.recommender.data import RecommenderData from polara.lib.similarity import build_indicator_matrix +from polara.recommender.hybrid.data import (IdentityDiagonalMixin, + SideRelationsMixin) class ItemColdStartData(RecommenderData): @@ -150,11 +151,7 @@ def _verify_cold_items_features(self): return if self.meta_data.shape[1] > 1: - try: # agg is supported only starting from pandas v.0.20.0 - features_melted = self.meta_data.agg('sum', axis=1) - except AttributeError: # fall back to much slower but more general option - features_melted = (self.meta_data.apply(lambda x: [x.sum()], axis=1) - .apply(lambda x: x[0])) + features_melted = self.meta_data.agg(lambda x: [f for l in x for f in l], axis=1) else: features_melted = self.meta_data.iloc[:, 0] @@ -207,67 +204,6 @@ def _sort_by_cold_items(self): holdout.sort_values(itemid_cold, inplace=True) - -class FeatureSimilarityMixin(object): - def __init__(self, sim_mat, sim_idx, *args, **kwargs): - super(FeatureSimilarityMixin, self).__init__(*args, **kwargs) - - entities = [self.fields.userid, self.fields.itemid] - self._sim_idx = {entity: pd.Series(index=idx, data=np.arange(len(idx)), copy=False) - if idx is not None else None - for entity, idx in sim_idx.items() - if entity in entities} - self._sim_mat = {entity: mat for entity, mat in sim_mat.items() if entity in entities} - self._similarity = dict.fromkeys(entities) - - self.subscribe(self.on_change_event, self._clean_similarity) - - def _clean_similarity(self): - self._similarity = dict.fromkeys(self._similarity.keys()) - - @property - def item_similarity(self): - entity = self.fields.itemid - return self.get_similarity_matrix(entity) - - @property - def user_similarity(self): - entity = self.fields.userid - return self.get_similarity_matrix(entity) - - def get_similarity_matrix(self, entity): - similarity = self._similarity.get(entity, None) - if similarity is None: - self._update_similarity(entity) - return self._similarity[entity] - - def _update_similarity(self, entity): - sim_mat = self._sim_mat[entity] - if sim_mat is None: - self._similarity[entity] = None - else: - if self.verbose: - print('Updating {} similarity matrix'.format(entity)) - - entity_type = self.fields._fields[self.fields.index(entity)] - index_data = getattr(self.index, entity_type) - - try: # check whether custom index is introduced - entity_idx = index_data.training['old'] - except AttributeError: # fall back to standard case - entity_idx = index_data['old'] - - sim_idx = entity_idx.map(self._sim_idx[entity]).values - sim_mat = self._sim_mat[entity][:, sim_idx][sim_idx, :] - - if issparse(sim_mat): - sim_mat.setdiag(1) - else: - np.fill_diagonal(sim_mat, 1) - self._similarity[entity] = sim_mat - - - class ColdSimilarityMixin(object): @property def cold_items_similarity(self): @@ -280,7 +216,7 @@ def cold_users_similarity(self): return self.get_cold_similarity(userid) def get_cold_similarity(self, entity): - sim_mat = self._sim_mat[entity] + sim_mat = self._rel_mat[entity] if sim_mat is None: return None @@ -289,11 +225,14 @@ def get_cold_similarity(self, entity): entity_type = fields._fields[fields.index(entity)] index_data = getattr(self.index, entity_type) - similarity_index = self._sim_idx[entity] + similarity_index = self._rel_idx[entity] seen_idx = index_data.training['old'].map(similarity_index).values cold_idx = index_data.cold_start['old'].map(similarity_index).values return sim_mat[:, seen_idx][cold_idx, :] -class ColdStartSimilarityDataModel(ColdSimilarityMixin, FeatureSimilarityMixin, ItemColdStartData): pass +class ColdStartSimilarityDataModel(ColdSimilarityMixin, + IdentityDiagonalMixin, + SideRelationsMixin, + ItemColdStartData): pass diff --git a/polara/recommender/coldstart/models.py b/polara/recommender/coldstart/models.py index a2b3f6a..2c278f9 100644 --- a/polara/recommender/coldstart/models.py +++ b/polara/recommender/coldstart/models.py @@ -1,14 +1,72 @@ import numpy as np -from polara.recommender.models import RecommenderModel +from polara import SVDModel +from polara.recommender.models import RecommenderModel, ScaledSVD +from polara.lib.similarity import stack_features +from polara.lib.sparse import sparse_dot -class ContentBasedColdStart(RecommenderModel): + +class ItemColdStartEvaluationMixin: def __init__(self, *args, **kwargs): - super(ContentBasedColdStart, self).__init__(*args, **kwargs) - self.method = 'CB' + super().__init__(*args, **kwargs) + self.filter_seen = False # there are no seen entities in cold start self._prediction_key = '{}_cold'.format(self.data.fields.itemid) self._prediction_target = self.data.fields.userid + +class RandomModelItemColdStart(ItemColdStartEvaluationMixin, RecommenderModel): + def __init__(self, *args, **kwargs): + self.seed = kwargs.pop('seed', None) + super().__init__(*args, **kwargs) + self.method = 'RND(cs)' + + def build(self): + seed = self.seed + self._random_state = np.random.RandomState(seed) if seed is not None else np.random + + def get_recommendations(self): + repr_users = self.data.representative_users + if repr_users is None: + repr_users = self.data.index.userid.training + repr_users = repr_users.new.values + n_cold_items = self.data.index.itemid.cold_start.shape[0] + shape = (n_cold_items, len(repr_users)) + users_matrix = np.lib.stride_tricks.as_strided(repr_users, shape, + (0, repr_users.itemsize)) + random_users = np.apply_along_axis(self._random_state.choice, 1, + users_matrix, self.topk, replace=False) + return random_users + + +class PopularityModelItemColdStart(ItemColdStartEvaluationMixin, RecommenderModel): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.method = 'MP(cs)' + + def build(self): + userid = self.data.fields.userid + user_activity = self.data.training[userid].value_counts(sort=False) + repr_users = self.data.representative_users + if repr_users is not None: + user_activity = user_activity.reindex(repr_users.new.values) + self.user_scores = user_activity.sort_values(ascending=False) + + def get_recommendations(self): + topk = self.topk + shape = (self.data.index.itemid.cold_start.shape[0], topk) + top_users = self.user_scores.index[:topk].values + top_users_array = np.lib.stride_tricks.as_strided(top_users, shape, + (0, top_users.itemsize)) + return top_users_array + + +class SimilarityAggregationItemColdStart(ItemColdStartEvaluationMixin, RecommenderModel): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.method = 'SIM(cs)' + self.implicit = False + self.dense_output = False + def build(self): pass @@ -16,8 +74,53 @@ def get_recommendations(self): item_similarity_scores = self.data.cold_items_similarity user_item_matrix = self.get_training_matrix() - user_item_matrix.data = np.ones_like(user_item_matrix.data) + if self.implicit: + user_item_matrix.data = np.ones_like(user_item_matrix.data) + scores = sparse_dot(item_similarity_scores, user_item_matrix, self.dense_output, True) + top_similar_users = self.get_topk_elements(scores).astype(np.intp) + return top_similar_users - scores = item_similarity_scores.dot(user_item_matrix.T).tocsr() + +class SVDModelItemColdStart(ItemColdStartEvaluationMixin, SVDModel): + def __init__(self, *args, item_features=None, **kwargs): + super().__init__(*args, **kwargs) + self.method = 'PureSVD(cs)' + self.item_features = item_features + self.use_raw_features = item_features is not None + + def build(self, *args, **kwargs): + super().build(*args, return_factors=True, **kwargs) + + def get_recommendations(self): + userid = self.data.fields.userid + itemid = self.data.fields.itemid + + u = self.factors[userid] + v = self.factors[itemid] + s = self.factors['singular_values'] + + if self.use_raw_features: + item_info = self.item_features.reindex(self.data.index.itemid.training.old.values, + fill_value=[]) + item_features, feature_labels = stack_features(item_info, normalize=False) + w = item_features.T.dot(v).T + wwt_inv = np.linalg.pinv(w @ w.T) + + cold_info = self.item_features.reindex(self.data.index.itemid.cold_start.old.values, + fill_value=[]) + cold_item_features, _ = stack_features(cold_info, labels=feature_labels, normalize=False) + else: + w = self.data.item_relations.T.dot(v).T + wwt_inv = np.linalg.pinv(w @ w.T) + cold_item_features = self.data.cold_items_similarity + + cold_items_factors = cold_item_features.dot(w.T) @ wwt_inv + scores = cold_items_factors @ (u * s[None, :]).T top_similar_users = self.get_topk_elements(scores).astype(np.intp) return top_similar_users + + +class ScaledSVDItemColdStart(ScaledSVD, SVDModelItemColdStart): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.method = 'PureSVDs(cs)' diff --git a/polara/recommender/contextual/data.py b/polara/recommender/contextual/data.py new file mode 100644 index 0000000..b446768 --- /dev/null +++ b/polara/recommender/contextual/data.py @@ -0,0 +1,58 @@ +from polara.recommender.data import RecommenderData + + +class ItemPostFilteringData(RecommenderData): + def __init__(self, *args, item_context_mapping=None, **kwargs): + super().__init__(*args, **kwargs) + userid = self.fields.userid + itemid = self.fields.itemid + self.item_context_mapping = dict(**item_context_mapping) + self.context_data = {context: dict.fromkeys([userid, itemid]) + for context in item_context_mapping.keys()} + + def map_context_data(self, context): + if context is None: + return + + userid = self.fields.userid + itemid = self.fields.itemid + + context_mapping = self.item_context_mapping[context] + index_mapping = self.index.itemid.set_index('old').new + mapped_index = {itemid: lambda x: x[itemid].map(index_mapping)} + item_data = (context_mapping.loc[lambda x: x[itemid].isin(index_mapping.index)] + .assign(**mapped_index) + .groupby(context)[itemid] + .apply(list)) + holdout = self.test.holdout + try: + user_data = holdout.set_index(userid)[context] + except AttributeError: + print(f'Unable to map {context}: holdout data is not recognized') + return + except KeyError: + print(f'Unable to map {context}: not present in holdout') + return + # deal with mesmiatch between user and item data + item_data = item_data.reindex(user_data.drop_duplicates().values, fill_value=[]) + + self.context_data[context][userid] = user_data + self.context_data[context][itemid] = item_data + + def update_contextual_data(self): + holdout = self.test.holdout + if holdout is not None: + # assuming that for each user in holdout we have only 1 item + assert holdout.shape[0] == holdout[self.fields.userid].nunique() + + for context in self.item_context_mapping.keys(): + self.map_context_data(context) + + def prepare(self, *args, **kwargs): + super().prepare(*args, **kwargs) + self.update_contextual_data() + + + def set_test_data(self, *args, **kwargs): + super().set_test_data(*args, **kwargs) + self.update_contextual_data() diff --git a/polara/recommender/contextual/models.py b/polara/recommender/contextual/models.py new file mode 100644 index 0000000..241dc6c --- /dev/null +++ b/polara/recommender/contextual/models.py @@ -0,0 +1,32 @@ +import numpy as np + + +class ItemPostFilteringMixin: + def upvote_context_items(self, context, scores, test_users): + if context is None: + return + + userid = self.data.fields.userid + itemid = self.data.fields.itemid + context_data = self.data.context_data[context] + try: + upvote_items = context_data[userid].loc[test_users].map(context_data[itemid]) + except: + print(f'Unable to upvote items in context "{context}"') + return + upvote_index = zip(*[(i, el) for i, l in enumerate(upvote_items) for el in l]) + + context_idx_flat = np.ravel_multi_index(list(upvote_index), scores.shape) + context_scores = scores.flat[context_idx_flat] + + upscored = scores.max() + context_scores + 1 + scores.flat[context_idx_flat] = upscored + + def upvote_relevant_items(self, scores, test_users): + for context in self.data.context_data.keys(): + self.upvote_context_items(context, scores, test_users) + + def slice_recommendations(self, test_data, test_shape, start, stop, test_users): + scores, slice_data = super().slice_recommendations(test_data, test_shape, start, stop, test_users) + self.upvote_relevant_items(scores, test_users[start:stop]) + return scores, slice_data diff --git a/polara/recommender/data.py b/polara/recommender/data.py index 98791f2..ca5c8ec 100644 --- a/polara/recommender/data.py +++ b/polara/recommender/data.py @@ -110,15 +110,17 @@ def __init__(self, data, userid, itemid, feedback=None, custom_order=None, seed= if data is None: cols = fields + [custom_order] - self._data = data = pd.DataFrame(columns=[c for c in cols if c]) - else: - self._data = data + data = pd.DataFrame(columns=[c for c in cols if c]) if data.duplicated(subset=[f for f in fields if f]).any(): # unstable in pandas v. 17.0, only works in <> v.17.0 # rely on deduplicated data in many places - makes data processing more efficient raise NotImplementedError('Data has duplicate values') + if not data.index.is_unique: + data = data.reset_index(drop=True) + + self._data = data self._custom_order = custom_order self.fields = namedtuple('Fields', self._std_fields) self.fields = self.fields(**dict(zip(self._std_fields, fields))) @@ -199,9 +201,12 @@ def _verified_data_property(self, data_property): return getattr(self, data_property) - def update(self): + def update(self, training_only=False): if self._change_properties: - self.prepare() + if training_only: + self.prepare_training_only() + else: + self.prepare() def prepare(self): @@ -592,6 +597,16 @@ def _reindex_train_items(self): items_index = self.reindex(self._training, itemid) self.index = self.index._replace(itemid=items_index) + def get_entity_index(self, entity, index_id='training'): + entity_type = self.fields._fields[self.fields.index(entity)] + index_data = getattr(self.index, entity_type) + + try: # check whether custom index is introduced (as in e.g. coldstart) + entity_idx = getattr(index_data, index_id) + except AttributeError: # fall back to standard case + entity_idx = index_data + return entity_idx + def _reindex_feedback(self): self.index = self.index._replace(feedback=None) diff --git a/polara/recommender/defaults.py b/polara/recommender/defaults.py index a44bf4d..42a3d71 100644 --- a/polara/recommender/defaults.py +++ b/polara/recommender/defaults.py @@ -48,7 +48,11 @@ #COMPUTATION test_chunk_size = 1000 #to split tensor decompositions into smaller pieces in memory max_test_workers = None # to compute recommendations in parallel for groups of test users - +memory_hard_limit = 1 # in gigabytes, default=1, depends on hardware +# varying this value may significantly impact performance +# setting it to None or large value typically reduces performance, +# as iterating over a smaller number of huge arrays takes longer +# than over a higher number of smaller arrays def get_config(params): this = sys.modules[__name__] diff --git a/polara/recommender/evaluation.py b/polara/recommender/evaluation.py index 3d3e245..ce125af 100644 --- a/polara/recommender/evaluation.py +++ b/polara/recommender/evaluation.py @@ -14,6 +14,13 @@ def no_copy_csr_matrix(data, indices, indptr, shape, dtype): return matrix +def safe_divide(a, b, mask=None, dtype=None): + pos = mask if mask is not None else a > 0 + res = np.zeros(len(a), dtype=dtype) + np.divide(a, b, where=pos, out=res) + return res + + def build_rank_matrix(recommendations, shape): # handle singletone case for a single user recommendations = np.array(recommendations, copy=False, ndmin=2) @@ -80,11 +87,11 @@ def generate_hits_data(rank_matrix, eval_matrix_hits, eval_matrix_miss=None): return hits_rank, miss_rank -def assemble_scoring_matrices(recommendations, eval_data, key, target, is_positive, feedback=None): +def assemble_scoring_matrices(recommendations, holdout, key, target, is_positive, feedback=None): # handle singletone case for a single user recommendations = np.array(recommendations, copy=False, ndmin=2) - shape = (recommendations.shape[0], max(recommendations.max(), eval_data[target].max())+1) - eval_matrix = matrix_from_observations(eval_data, key, target, shape, feedback=feedback) + shape = (recommendations.shape[0], max(recommendations.max(), holdout[target].max())+1) + eval_matrix = matrix_from_observations(holdout, key, target, shape, feedback=feedback) eval_matrix_hits, eval_matrix_miss = split_positive(eval_matrix, is_positive) rank_matrix = build_rank_matrix(recommendations, shape) hits_rank, miss_rank = generate_hits_data(rank_matrix, eval_matrix_hits, eval_matrix_miss) @@ -128,13 +135,9 @@ def get_ndcr_score(eval_matrix, discounts_matrix, ideal_discounts, alternative=F relevance = eval_matrix._with_data(np.exp2(eval_matrix.data)-1, copy=False) else: relevance = eval_matrix - - dcr = relevance.multiply(discounts_matrix).sum(axis=1) - idcr = relevance.multiply(ideal_discounts).sum(axis=1) - - with np.errstate(invalid='ignore'): - score = np.nansum(dcr/idcr) / relevance.shape[0] - return score + dcr = np.array(relevance.multiply(discounts_matrix).sum(axis=1), copy=False).squeeze() + idcr = np.array(relevance.multiply(ideal_discounts).sum(axis=1), copy=False).squeeze() + return safe_divide(dcr, idcr).mean() def get_ndcg_score(eval_matrix, discounts_matrix, ideal_discounts, alternative=False): @@ -193,30 +196,26 @@ def get_relevance_scores(rank_matrix, hits_rank, miss_rank, eval_matrix, eval_ma true_negative, false_negative] = get_relevance_data(rank_matrix, hits_rank, miss_rank, eval_matrix, eval_matrix_hits, eval_matrix_miss, not_rated_penalty, True) + # non-zero mask for safe division + tpnz = true_positive > 0 + fnnz = false_negative > 0 + # true positive rate + precision = safe_divide(true_positive, true_positive + false_positive, tpnz).mean() + # sensitivity + recall = safe_divide(true_positive, true_positive + false_negative, tpnz).mean() + # false negative rate + miss_rate = safe_divide(false_negative, false_negative + true_positive, fnnz).mean() - with np.errstate(invalid='ignore'): - # true positive rate - precision = true_positive / (true_positive + false_positive) - # sensitivity - recall = true_positive / (true_positive + false_negative) - # false negative rate - miss_rate = false_negative / (false_negative + true_positive) - if true_negative is not None: - # false positive rate - fallout = false_positive / (false_positive + true_negative) - # true negative rate - specifity = true_negative / (false_positive + true_negative) - else: - fallout = specifity = None - - n_keys = hits_rank.shape[0] - # average over all users - precision = np.nansum(precision) / n_keys - recall = np.nansum(recall) / n_keys - miss_rate = np.nansum(miss_rate) / n_keys if true_negative is not None: - specifity = np.nansum(specifity) / n_keys - fallout = np.nansum(fallout) / n_keys + # non-zero mask for safe division + fpnz = false_positive > 0 + tnnz = true_negative > 0 + # false positive rate + fallout = safe_divide(false_positive, false_positive + true_negative, fpnz).mean() + # true negative rate + specifity = safe_divide(true_negative, false_positive + true_negative, tnnz).mean() + else: + fallout = specifity = None scores = namedtuple('Relevance', ['precision', 'recall', 'fallout', 'specifity', 'miss_rate']) scores = scores._make([precision, recall, fallout, specifity, miss_rate]) diff --git a/polara/recommender/external/implicit/ialswrapper.py b/polara/recommender/external/implicit/ialswrapper.py index e5cc011..7c8a6cb 100644 --- a/polara/recommender/external/implicit/ialswrapper.py +++ b/polara/recommender/external/implicit/ialswrapper.py @@ -7,7 +7,7 @@ import numpy as np import implicit from polara.recommender.models import RecommenderModel -from polara.tools.timing import Timer +from polara.tools.timing import track_time class ImplicitALS(RecommenderModel): @@ -55,7 +55,7 @@ def build(self): matrix.data = self.confidence(matrix.data, alpha=self.alpha, weight=self.weight_func, epsilon=self.epsilon) - with Timer(self.method, verbose=self.verbose): + with track_time(self.training_time, verbose=self.verbose, model=self.method): # build the model # implicit takes item_by_user matrix as input, need to transpose self._model.fit(matrix.T) diff --git a/polara/recommender/external/lightfm/lightfmwrapper.py b/polara/recommender/external/lightfm/lightfmwrapper.py index 80aa31b..2c16a3f 100644 --- a/polara/recommender/external/lightfm/lightfmwrapper.py +++ b/polara/recommender/external/lightfm/lightfmwrapper.py @@ -2,10 +2,11 @@ from __future__ import print_function import numpy as np +from numpy.lib.stride_tricks import as_strided from lightfm import LightFM from polara.recommender.models import RecommenderModel from polara.lib.similarity import stack_features -from polara.tools.timing import Timer +from polara.tools.timing import track_time class LightFMWrapper(RecommenderModel): @@ -62,19 +63,27 @@ def build(self): normalize=True, dtype='f4') - with Timer(self.method, verbose=self.verbose): + with track_time(self.training_time, verbose=self.verbose, model=self.method): fit(matrix, item_features=self._item_features_csr, user_features=self._user_features_csr) def slice_recommendations(self, test_data, shape, start, stop, test_users=None): if self.data.warm_start: raise NotImplementedError - else: - slice_data = self._slice_test_data(test_data, start, stop) - all_items = self.data.index.itemid.new.values - n_users = stop - start - n_items = len(all_items) - scores = self._model.predict(np.repeat(test_users[start:stop], n_items), - np.tile(all_items, n_users), - item_features=self._item_features_csr).reshape(n_users, n_items) + + slice_data = self._slice_test_data(test_data, start, stop) + all_items = self.data.index.itemid.new.values + n_users = stop - start + n_items = len(all_items) + # use stride tricks to avoid unnecessary copies of repeated indices + # have to conform with LightFM's dtype to avoid additional copies + itemsize = np.dtype('i4').itemsize + useridx = as_strided(test_users[start:stop].astype('i4', copy=False), + (n_users, n_items), (itemsize, 0)) + itemidx = as_strided(all_items.astype('i4', copy=False), + (n_users, n_items), (0, itemsize)) + scores = self._model.predict(useridx.ravel(), itemidx.ravel(), + user_features=self._user_features_csr, + item_features=self._item_features_csr + ).reshape(n_users, n_items) return scores, slice_data diff --git a/polara/recommender/external/graphlab/__init__.py b/polara/recommender/external/turi/__init__.py similarity index 100% rename from polara/recommender/external/graphlab/__init__.py rename to polara/recommender/external/turi/__init__.py diff --git a/polara/recommender/external/graphlab/glwrapper.py b/polara/recommender/external/turi/turiwrapper.py similarity index 65% rename from polara/recommender/external/graphlab/glwrapper.py rename to polara/recommender/external/turi/turiwrapper.py index ada8a26..a8558a2 100644 --- a/polara/recommender/external/graphlab/glwrapper.py +++ b/polara/recommender/external/turi/turiwrapper.py @@ -1,42 +1,44 @@ -# python 2/3 interoperability -from __future__ import print_function - import numpy as np -from polara.recommender.models import RecommenderModel -import graphlab as gl +import turicreate as tc +from polara import RecommenderModel -class GraphlabFactorization(RecommenderModel): +class TuriFactorizationRecommender(RecommenderModel): def __init__(self, *args, **kwargs): self.item_side_info = kwargs.pop('item_side_info', None) self.user_side_info = kwargs.pop('user_side_info', None) - super(GraphlabFactorization, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) + self.tc_model = None self._rank = 10 - self.method = 'GLF' + self.method = 'TCF' # side data self._item_data = None self._user_data = None + self.side_data_factorization = True # randomization self.seed = 61 # optimization self.binary_target = False self.solver = 'auto' - self.max_iterations = 30 - # reglarization + self.max_iterations = 25 + # regularization self.regularization = 1e-10 self.linear_regularization = 1e-10 + # adagrad + self.adagrad_momentum_weighting = 0.9 # sgd self.sgd_step_size = 0 # ranking self.ranking_optimization = False self.ranking_regularization = 0.25 self.unobserved_rating_value = None - self.num_sampled_negative_examples = None + self.num_sampled_negative_examples = 4 # other parameters - self.other_gl_params = {} + self.with_data_feedback = True + self.other_tc_params = {} + self.data.subscribe(self.data.on_change_event, self._clean_metadata) - def _on_change(self): - super(GraphlabFactorization, self)._on_change() + def _clean_metadata(self): self._item_data = None self._user_data = None @@ -71,7 +73,7 @@ def item_data(self): .reset_index()) side_features[itemid] = side_features[itemid].map(index_map) - self._item_data = gl.SFrame(side_features) + self._item_data = tc.SFrame(side_features) else: self._item_data = None return self._item_data @@ -94,7 +96,7 @@ def user_data(self): .reset_index()) side_features[userid] = side_features[userid].map(index_map) - self._user_data = gl.SFrame(side_features) + self._user_data = tc.SFrame(side_features) else: self._user_data = None return self._user_data @@ -102,10 +104,9 @@ def user_data(self): def build(self): item_data = self.item_data user_data = self.user_data - side_fact = (item_data is not None) or (user_data is not None) params = dict(item_data=item_data, user_data=user_data, - side_data_factorization=side_fact, + side_data_factorization=self.side_data_factorization, num_factors=self.rank, binary_target=self.binary_target, verbose=self.verbose, @@ -115,75 +116,88 @@ def build(self): # optimization solver=self.solver, max_iterations=self.max_iterations, + # adagrad + adagrad_momentum_weighting=self.adagrad_momentum_weighting, # sgd sgd_step_size=self.sgd_step_size, # regularization regularization=self.regularization, linear_regularization=self.linear_regularization, # other parameters - **self.other_gl_params) + **self.other_tc_params) if self.ranking_optimization: - build_model = gl.ranking_factorization_recommender.create + build_model = tc.recommender.ranking_factorization_recommender.create params.update(ranking_regularization=self.ranking_regularization, num_sampled_negative_examples=self.num_sampled_negative_examples) if self.unobserved_rating_value is not None: params.update(unobserved_rating_value=self.unobserved_rating_value) else: - build_model = gl.factorization_recommender.create + build_model = tc.factorization_recommender.create - self.gl_model = build_model(gl.SFrame(self.data.training), + target = self.data.fields.feedback if self.with_data_feedback else None + self.tc_model = build_model(tc.SFrame(self.data.training), user_id=self.data.fields.userid, item_id=self.data.fields.itemid, - target=self.data.fields.feedback, + target=target, **params) + if self.training_time is not None: + self.training_time.append(self.tc_model.training_time) if self.verbose: - print('{} training time: {}s'.format(self.method, self.gl_model.training_time)) + print(f'{self.method} training time: {self.tc_model.training_time}s') def get_recommendations(self): + if self.data.warm_start: + raise NotImplementedError + userid = self.data.fields.userid test_users = self.data.test.holdout[userid].drop_duplicates().values - recommend = self.gl_model.recommend - top_recs = recommend(users=test_users, - k=self.topk, - exclude_known=self.filter_seen, - verbose=self.verbose) + top_recs = self.tc_model.recommend(users=test_users, + k=self.topk, + exclude_known=self.filter_seen, + verbose=self.verbose) itemid = self.data.fields.itemid top_recs = top_recs[itemid].to_numpy().reshape(-1, self.topk) return top_recs def evaluate_rmse(self): + if self.data.warm_start: + raise NotImplementedError feedback = self.data.fields.feedback - holdout = gl.SFrame(self.data.test.holdout) - return self.gl_model.evaluate_rmse(holdout, feedback)['rmse_overall'] + holdout = tc.SFrame(self.data.test.holdout) + return self.tc_model.evaluate_rmse(holdout, feedback)['rmse_overall'] -class WarmStartRecommendationsMixin(object): +class WarmStartRecommendationsMixin: def get_recommendations(self): pass -class ColdStartRecommendationsMixin(object): +class ColdStartRecommendationsMixin: def get_recommendations(self): userid = self.data.fields.userid itemid = self.data.fields.itemid + data_index = self.data.index - cold_items_index = self.data.index.itemid.cold_start.old - lower_index = self.data.index.itemid.training.new.max() + 1 + cold_items_index = data_index.itemid.cold_start.old.values + lower_index = data_index.itemid.training.new.max() + 1 upper_index = lower_index + len(cold_items_index) # prevent intersecting cold items index with known items unseen_items_idx = np.arange(lower_index, upper_index) - new_item_data = gl.SFrame(self.item_side_info.loc[cold_items_index] + new_item_data = tc.SFrame(self.item_side_info.loc[cold_items_index] .reset_index() .assign(**{itemid: unseen_items_idx})) - - repr_users = self.data.representative_users.new.values + repr_users = self.data.representative_users + try: + repr_users = repr_users.new.values + except AttributeError: + repr_users = data_index.userid.training.new.values observation_idx = [a.flat for a in np.broadcast_arrays(repr_users, unseen_items_idx[:, None])] - new_observation = gl.SFrame(dict(zip([userid, itemid], observation_idx))) + new_observation = tc.SFrame(dict(zip([userid, itemid], observation_idx))) - scores = self.gl_model.predict(new_observation, new_item_data=new_item_data).to_numpy() - top_similar_idx = self.get_topk_items(scores.reshape(-1, len(repr_users))) + scores = self.tc_model.predict(new_observation, new_item_data=new_item_data).to_numpy() + top_similar_idx = self.get_topk_elements(scores.reshape(-1, len(repr_users))) top_similar_users = repr_users[top_similar_idx.ravel()].reshape(top_similar_idx.shape) return top_similar_users diff --git a/polara/recommender/hybrid/data.py b/polara/recommender/hybrid/data.py new file mode 100644 index 0000000..960a868 --- /dev/null +++ b/polara/recommender/hybrid/data.py @@ -0,0 +1,69 @@ +import numpy as np +import pandas as pd +from scipy.sparse import issparse + +from polara.recommender.data import RecommenderData + + +class SideRelationsMixin: + def __init__(self, rel_mat, rel_idx, *args, **kwargs): + super().__init__(*args, **kwargs) + + entities = [self.fields.userid, self.fields.itemid] + self._rel_idx = {entity: pd.Series(index=idx, data=np.arange(len(idx)), copy=False) + if idx is not None else None + for entity, idx in rel_idx.items() + if entity in entities} + self._rel_mat = {entity: mat for entity, mat in rel_mat.items() if entity in entities} + self._relations = dict.fromkeys(entities) + + self.subscribe(self.on_change_event, self._clean_relations) + + def _clean_relations(self): + self._relations = dict.fromkeys(self._relations.keys()) + + @property + def item_relations(self): + entity = self.fields.itemid + return self.get_relations_matrix(entity) + + @property + def user_relations(self): + entity = self.fields.userid + return self.get_relations_matrix(entity) + + def get_relations_matrix(self, entity): + relations = self._relations.get(entity, None) + if relations is None: + self._update_relations(entity) + return self._relations[entity] + + def _update_relations(self, entity): + rel_mat = self._rel_mat[entity] + if rel_mat is None: + self._relations[entity] = None + else: + if self.verbose: + print(f'Updating {entity} relations matrix') + + index_data = self.get_entity_index(entity) + entity_idx = index_data['old'] + + rel_idx = entity_idx.map(self._rel_idx[entity]).values + rel_mat = self._rel_mat[entity][:, rel_idx][rel_idx, :] + + self._relations[entity] = rel_mat + + +class IdentityDiagonalMixin: + def _update_relations(self, *args, **kwargs): + super()._update_relations(*args, **kwargs) + for rel_mat in self._relations.values(): + if rel_mat is not None: + if issparse(rel_mat): + rel_mat.setdiag(1) + else: + np.fill_diagonal(rel_mat, 1) + + +class SimilarityDataModel(IdentityDiagonalMixin, SideRelationsMixin, RecommenderData): pass diff --git a/polara/recommender/hybrid/models.py b/polara/recommender/hybrid/models.py new file mode 100644 index 0000000..37560ae --- /dev/null +++ b/polara/recommender/hybrid/models.py @@ -0,0 +1,102 @@ +import scipy as sp +import numpy as np + +from polara.recommender.models import RecommenderModel, ProbabilisticMF +from polara.lib.optimize import kernelized_pmf_sgd +from polara.lib.sparse import sparse_dot +from polara.tools.timing import track_time + + +class SimilarityAggregation(RecommenderModel): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.method = 'SIM' + self.implicit = False + self.dense_output = False + self.item_similarity_matrix = False + + def build(self): + # use copy to prevent contaminating original data + self.item_similarity_matrix = self.data.item_relations.copy() + self.item_similarity_matrix.setdiag(0) # exclude self-links + self.item_similarity_matrix.eliminate_zeros() + + def slice_recommendations(self, test_data, shape, start, stop, test_users=None): + test_matrix, slice_data = self.get_test_matrix(test_data, shape, (start, stop)) + if self.implicit: + test_matrix.data = np.ones_like(test_matrix.data) + scores = sparse_dot(test_matrix, self.item_similarity_matrix, self.dense_output, True) + return scores, slice_data + + +class KernelizedRecommenderMixin: + '''Based on the work: + Kernelized Probabilistic Matrix Factorization: Exploiting Graphs and Side Information + http://people.ee.duke.edu/~lcarin/kpmf_sdm_final.pdf + ''' + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.kernel_type = 'reg' + self.beta = 0.01 + self.gamma = 0.1 + self.sigma = 1 + self.kernel_update = None # will use default kernel update method + self.sparse_kernel_format = True + + entities = [self.data.fields.userid, self.data.fields.itemid] + self.factor_sigma = dict.fromkeys(entities, 1) + self._kernel_matrices = dict.fromkeys(entities) + + self.data.subscribe(self.data.on_change_event, self._clean_kernel_data) + + def _compute_kernel(self, laplacian, kernel_type=None): + kernel_type = kernel_type or self.kernel_type + if kernel_type == 'dif': # diffusion + return sp.sparse.linalg.expm(self.beta * laplacian) # dense matrix + elif kernel_type == 'reg': # regularized laplacian + n_entities = laplacian.shape[0] + return sp.sparse.eye(n_entities).tocsr() + self.gamma * laplacian # sparse matrix + else: + raise ValueError + + def _update_kernel_matrices(self, entity): + laplacian = self.data.get_relations_matrix(entity) + if laplacian is None: + sigma = self.factor_sigma[entity] + n_entities = self.data.get_entity_index(entity).shape[0] + kernel_matrix = (sigma**2) * sp.sparse.eye(n_entities).tocsr() + else: + kernel_matrix = self._compute_kernel(laplacian) + self._kernel_matrices[entity] = kernel_matrix + + def _clean_kernel_data(self): + self._kernel_matrices = dict.fromkeys(self._kernel_matrices.keys()) + + @property + def item_kernel_matrix(self): + entity = self.data.fields.itemid + return self.get_kernel_matrix(entity) + + @property + def user_kernel_matrix(self): + entity = self.data.fields.userid + return self.get_kernel_matrix(entity) + + def get_kernel_matrix(self, entity): + kernel_matrix = self._kernel_matrices.get(entity, None) + if kernel_matrix is None: + self._update_kernel_matrices(entity) + return self._kernel_matrices[entity] + + +class KernelizedPMF(KernelizedRecommenderMixin, ProbabilisticMF): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.optimizer = kernelized_pmf_sgd + self.method = 'KPMF' + + def build(self, *args, **kwargs): + kernel_matrices = (self.user_kernel_matrix, self.item_kernel_matrix) + kernel_config = dict(kernel_update=self.kernel_update, + sparse_kernel_format=self.sparse_kernel_format) + super().build(kernel_matrices, *args, **kernel_config, **kwargs) diff --git a/polara/recommender/models.py b/polara/recommender/models.py index 4100ec9..d1b1763 100644 --- a/polara/recommender/models.py +++ b/polara/recommender/models.py @@ -1,10 +1,3 @@ -# python 2/3 interoperability -from __future__ import print_function -try: - range = xrange -except NameError: - pass - from functools import wraps from collections import namedtuple import warnings @@ -22,12 +15,13 @@ from polara.recommender.evaluation import get_hits, get_relevance_scores, get_ranking_scores, get_experience_scores from polara.recommender.evaluation import get_hr_score, get_mrr_score from polara.recommender.evaluation import assemble_scoring_matrices -from polara.recommender.utils import array_split, get_nnz_max +from polara.recommender.utils import array_split +from polara.lib.optimize import simple_pmf_sgd from polara.lib.tensor import hooi -from polara.lib.sparse import csc_matvec, inverse_permutation +from polara.lib.sparse import sparse_dot, inverse_permutation, rescale_matrix from polara.lib.sparse import unfold_tensor_coordinates, tensor_outer_at -from polara.tools.timing import Timer +from polara.tools.timing import track_time def get_default(name): return defaults.get_config([name])[name] @@ -93,6 +87,7 @@ def __init__(self, recommender_data, feedback_threshold=None): self._is_ready = False self.verbose = True + self.training_time = [] # setting to None will prevent storing time self.data.subscribe(self.data.on_change_event, self._renew_model) self.data.subscribe(self.data.on_update_event, self._refresh_model) @@ -158,16 +153,27 @@ def build(self): raise NotImplementedError('This must be implemented in subclasses') - def get_training_matrix(self, feedback_threshold=None, dtype=None): + def get_training_matrix(self, feedback_threshold=None, ignore_feedback=False, + sparse_format='csr', dtype=None): threshold = feedback_threshold or self.feedback_threshold - idx, val, shp = self.data.to_coo(tensor_mode=False, feedback_threshold=threshold) + # the line below also updates data if needed and triggers notifier + idx, val, shp = self.data.to_coo(tensor_mode=False, + feedback_threshold=threshold) dtype = dtype or val.dtype - matrix = csr_matrix((val, (idx[:, 0], idx[:, 1])), + if ignore_feedback: # for compatibility with non-numeric tensor feedback data + val = np.ones_like(val, dtype=dtype) + matrix = coo_matrix((val, (idx[:, 0], idx[:, 1])), shape=shp, dtype=dtype) - return matrix + if sparse_format == 'csr': + return matrix.tocsr() + elif sparse_format == 'csc': + return matrix.tocsc() + elif sparse_format == 'coo': + matrix.sum_duplicates() + return matrix - def get_test_matrix(self, test_data=None, shape=None, user_slice=None): + def get_test_matrix(self, test_data=None, shape=None, user_slice=None, dtype=None, ignore_feedback=False): if test_data is None: test_data, shape, _ = self._get_test_data() elif shape is None: @@ -190,10 +196,14 @@ def get_test_matrix(self, test_data=None, shape=None, user_slice=None): item_coo = item_coo[valid_fdbk] fdbk_coo = fdbk_coo[valid_fdbk] + dtype = dtype or fdbk_coo.dtype + if ignore_feedback: # for compatibility with non-numeric tensor feedback data + fdbk_coo = np.ones_like(fdbk_coo, dtype=dtype) + num_items = shape[1] test_matrix = csr_matrix((fdbk_coo, (user_coo, item_coo)), shape=(num_users, num_items), - dtype=fdbk_coo.dtype) + dtype=dtype) return test_matrix, coo_data @@ -392,16 +402,31 @@ def get_recommendations(self): return top_recs - def evaluate(self, method='hits', topk=None, not_rated_penalty=None, on_feedback_level=None, ignore_feedback=False, simple_rates=False): - feedback = self.data.fields.feedback + def evaluate(self, metric_type='all', topk=None, not_rated_penalty=None, + switch_positive=None, ignore_feedback=False, simple_rates=False, + on_feedback_level=None): + if metric_type == 'all': + metric_type = ['hits', 'relevance', 'ranking', 'experience'] + + if metric_type == 'main': + metric_type = ['relevance', 'ranking'] + + if not isinstance(metric_type, (list, tuple)): + metric_type = [metric_type] + + # support rolling back scenario for @k calculations if int(topk or 0) > self.topk: self.topk = topk # will also flush old recommendations - # support rolling back scenario for @k calculations + # ORDER OF CALLS MATTERS!!! + # make sure to call holdout before getting recommendations + # this will ensure that model is renewed if data has changed + holdout = self.data.test.holdout # <-- call before getting recs recommendations = self.recommendations[:, :topk] # will recalculate if empty - eval_data = self.data.test.holdout - if (self.switch_positive is None) or (feedback is None): + switch_positive = switch_positive or self.switch_positive + feedback = self.data.fields.feedback + if (switch_positive is None) or (feedback is None): # all recommendations are considered positive predictions # this is a proper setting for binary data problems (implicit feedback) # in this case all unrated items, recommended by an algorithm @@ -415,33 +440,49 @@ def evaluate(self, method='hits', topk=None, not_rated_penalty=None, on_feedback # the defualt setting in this case is to ignore such items at all # by setting penalty to 0, however, it is adjustable not_rated_penalty = not_rated_penalty or 0 - is_positive = (eval_data[feedback] >= self.switch_positive).values + is_positive = (holdout[feedback] >= switch_positive).values feedback = None if ignore_feedback else feedback - scoring_data = assemble_scoring_matrices(recommendations, eval_data, + scoring_data = assemble_scoring_matrices(recommendations, holdout, self._prediction_key, self._prediction_target, is_positive, feedback=feedback) - if method == 'relevance': # no need for feedback + scores = [] + if 'relevance' in metric_type: # no need for feedback if (self.data.holdout_size == 1) or simple_rates: - scores = get_hr_score(scoring_data[1]) + scores.append(get_hr_score(scoring_data[1])) else: - scores = get_relevance_scores(*scoring_data, not_rated_penalty=not_rated_penalty) - elif method == 'ranking': + scores.append(get_relevance_scores(*scoring_data, not_rated_penalty=not_rated_penalty)) + + if 'ranking' in metric_type: if (self.data.holdout_size == 1) or simple_rates: - scores = get_mrr_score(scoring_data[1]) + scores.append(get_mrr_score(scoring_data[1])) else: ndcg_alternative = get_default('ndcg_alternative') topk = recommendations.shape[1] # handle topk=None case # topk has to be passed explicitly, otherwise it's unclear how to # estimate ideal ranking for NDCG and NDCL metrics in get_ndcr_discounts - scores = get_ranking_scores(*scoring_data, switch_positive=self.switch_positive, topk=topk, alternative=ndcg_alternative) - elif method == 'hits': # no need for feedback - scores = get_hits(*scoring_data, not_rated_penalty=not_rated_penalty) - elif method == 'experience': # no need for feedback - scores = get_experience_scores(recommendations, self.data.index.itemid.shape[0]) - else: + scores.append(get_ranking_scores(*scoring_data, switch_positive=switch_positive, topk=topk, alternative=ndcg_alternative)) + + if 'experience' in metric_type: # no need for feedback + fields = self.data.fields + # support custom scenarios, e.g. coldstart + entity_type = fields._fields[fields.index(self._prediction_target)] + entity_index = getattr(self.data.index, entity_type) + try: + n_entities = entity_index.shape[0] + except AttributeError: + n_entities = entity_index.training.shape[0] + scores.append(get_experience_scores(recommendations, n_entities)) + + if 'hits' in metric_type: # no need for feedback + scores.append(get_hits(*scoring_data, not_rated_penalty=not_rated_penalty)) + + if not scores: raise NotImplementedError + + if len(scores) == 1: + scores = scores[0] return scores @@ -640,7 +681,8 @@ def build(self): except AttributeError: index_data = self.data.index.itemid self.n_items = index_data.shape[0] - self._random_state = np.random.RandomState(self.seed) if self.seed else np.random + seed = self.seed + self._random_state = np.random.RandomState(seed) if seed is not None else np.random def slice_recommendations(self, test_data, shape, start, stop, test_users=None): slice_data = self._slice_test_data(test_data, start, stop) @@ -664,7 +706,7 @@ def build(self): # np.sign allows for negative values as well user_item_matrix.data = np.sign(user_item_matrix.data) - with Timer(self.method, verbose=self.verbose): + with track_time(self.training_time, verbose=self.verbose, model=self.method): i2i_matrix = user_item_matrix.T.dot(user_item_matrix) # gives CSC format i2i_matrix.setdiag(0) # exclude "self-links" i2i_matrix.eliminate_zeros() @@ -672,27 +714,6 @@ def build(self): self._i2i_matrix = i2i_matrix - def _sparse_dot(self, tst_mat, i2i_mat): - # scipy always returns sparse result, even if dot product is dense - # this function offers solution to this problem - # it also takes care on sparse result w.r.t. to further processing - if self.dense_output: # calculate dense result directly - # TODO matmat multiplication instead of iteration with matvec - res_type = np.result_type(i2i_mat.dtype, tst_mat.dtype) - scores = np.empty((tst_mat.shape[0], i2i_mat.shape[1]), dtype=res_type) - for i in range(tst_mat.shape[0]): - v = tst_mat.getrow(i) - scores[i, :] = csc_matvec(i2i_mat, v, dense_output=True, dtype=res_type) - else: - scores = tst_mat.dot(i2i_mat.T) - # NOTE even though not neccessary for symmetric i2i matrix, - # transpose helps to avoid expensive conversion to CSR (performed by scipy) - if scores.nnz > get_nnz_max(): - # too many nnz lead to undesired memory overhead in downvote_seen_items - scores = scores.toarray(order='C') - return scores - - def slice_recommendations(self, test_data, shape, start, stop, test_users=None): test_matrix, slice_data = self.get_test_matrix(test_data, shape, (start, stop)) # NOTE CSR format is mandatory for proper handling of signle user @@ -701,7 +722,69 @@ def slice_recommendations(self, test_data, shape, start, stop, test_users=None): if self.implicit: test_matrix.data = np.sign(test_matrix.data) - scores = self._sparse_dot(test_matrix, self._i2i_matrix) + scores = sparse_dot(test_matrix, self._i2i_matrix, self.dense_output, True) + return scores, slice_data + + +class ProbabilisticMF(RecommenderModel): + def __init__(self, *args, **kwargs): + self.seed = kwargs.pop('seed', None) + super().__init__(*args, **kwargs) + self.method = 'PMF' + self.optimizer = simple_pmf_sgd + self.learn_rate = 0.005 + self.sigma = 1 + self.num_epochs = 25 + self.rank = 10 + self.tolerance = 1e-4 + self.factors = {} + self.rmse_history = None + self.show_rmse = False + self.iterations_time = None + + def build(self, *args, **kwargs): + matrix = self.get_training_matrix(sparse_format='coo', dtype='f8') + user_idx, item_idx = matrix.nonzero() + interactions = (user_idx, item_idx, matrix.data) + nonzero_count = (matrix.getnnz(axis=1), matrix.getnnz(axis=0)) + rank = self.rank + lrate = self.learn_rate + sigma = self.sigma + num_epochs = self.num_epochs + tol = self.tolerance + self.rmse_history = [] + self.iterations_time = [] + + general_config = dict(seed=self.seed, + verbose=self.show_rmse, + iter_errors=self.rmse_history, + iter_time=self.iterations_time) + + with track_time(self.training_time, verbose=self.verbose, model=self.method): + P, Q = self.optimizer(interactions, matrix.shape, nonzero_count, rank, + lrate, sigma, num_epochs, tol, + *args, + **kwargs, + **general_config) + + self.factors[self.data.fields.userid] = P + self.factors[self.data.fields.itemid] = Q + + def get_recommendations(self): + if self.data.warm_start: + raise NotImplementedError + else: + return super().get_recommendations() + + + def slice_recommendations(self, test_data, shape, start, stop, test_users=None): + userid = self.data.fields.userid + itemid = self.data.fields.itemid + slice_data = self._slice_test_data(test_data, start, stop) + + user_factors = self.factors[userid][test_users[start:stop], :] + item_factors = self.factors[itemid] + scores = user_factors.dot(item_factors.T) return scores, slice_data @@ -734,6 +817,8 @@ def _check_reduced_rank(self, rank): self.factors = dict.fromkeys(self.factors.keys()) break else: + # avoid accidental overwrites if factors backup exists + self.factors = dict(**self.factors) # ellipsis allows to handle 1d array of singular values self.factors[entity] = factor[..., :rank] @@ -746,7 +831,7 @@ def build(self, operator=None, return_factors='vh'): svd_params = dict(k=self.rank, return_singular_vectors=return_factors) - with Timer(self.method, verbose=self.verbose): + with track_time(self.training_time, verbose=self.verbose, model=self.method): user_factors, sigma, item_factors = svds(svd_matrix, **svd_params) if user_factors is not None: @@ -767,6 +852,43 @@ def slice_recommendations(self, test_data, shape, start, stop, test_users=None): return scores, slice_data +class ScaledMatrixMixin: + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._col_scaling = 0.4 + self._row_scaling = 1 + self.method = f'{self.method}-s' + + @property + def col_scaling(self): + return self._col_scaling + + @property + def row_scaling(self): + return self._row_scaling + + @col_scaling.setter + def col_scaling(self, new_value): + if new_value != self._col_scaling: + self._col_scaling = new_value + self._recommendations = None + + @row_scaling.setter + def row_scaling(self, new_value): + if new_value != self._row_scaling: + self._row_scaling = new_value + self._recommendations = None + + def get_training_matrix(self, *args, **kwargs): + scaled_matrix = super().get_training_matrix(*args, **kwargs) + scaled_matrix = rescale_matrix(scaled_matrix, self.row_scaling, 1) + scaled_matrix = rescale_matrix(scaled_matrix, self.col_scaling, 0) + return scaled_matrix + + +class ScaledSVD(ScaledMatrixMixin, SVDModel): pass + + class CoffeeModel(RecommenderModel): def __init__(self, *args, **kwargs): @@ -829,6 +951,8 @@ def _check_reduced_rank(self, mlrank): elif factor.shape[1] == rank: continue else: + # avoid accidental overwrites if factors backup exists + self.factors = dict(**self.factors) rfactor, new_core = self.round_core(self.factors['core'], mode, rank) self.factors[entity] = factor.dot(rfactor) self.factors['core'] = new_core @@ -876,7 +1000,7 @@ def flatten_scores(tensor_scores, flattener=None): def build(self): idx, val, shp = self.data.to_coo(tensor_mode=True) - with Timer(self.method, verbose=self.verbose): + with track_time(self.training_time, verbose=self.verbose, model=self.method): (users_factors, items_factors, feedback_factors, core) = hooi(idx, val, shp, self.mlrank, growth_tol=self.growth_tol, @@ -920,36 +1044,40 @@ def slice_recommendations(self, test_data, shape, start, stop, test_users=None): scores = np.tensordot(scores, wt_flat, axes=(2, 0)).dot(v.T) return scores, slice_idx - # additional functionality: rating pediction def get_holdout_slice(self, start, stop): userid = self.data.fields.userid itemid = self.data.fields.itemid - eval_data = self.data.test.holdout + holdout = self.data.test.holdout - user_sel = (eval_data[userid] >= start) & (eval_data[userid] < stop) - holdout_users = eval_data.loc[user_sel, userid].values.astype(np.int64) - start - holdout_items = eval_data.loc[user_sel, itemid].values.astype(np.int64) + user_sel = (holdout[userid] >= start) & (holdout[userid] < stop) + holdout_users = holdout.loc[user_sel, userid].values.astype(np.int64) - start + holdout_items = holdout.loc[user_sel, itemid].values.astype(np.int64) return (holdout_users, holdout_items) + # additional functionality: rating pediction def predict_feedback(self): - flattener_old = self.flattener - self.flattener = 'argmax' # this will be applied along feedback axis - feedback_idx = self.data.index.feedback.set_index('new') + if self.data.warm_start: + raise NotImplementedError - test_data, test_shape, _ = self._get_test_data() - holdout_size = self.data.holdout_size - dtype = feedback_idx.old.dtype - predicted_feedback = np.empty((test_shape[0], holdout_size), dtype=dtype) - - user_slices = self._get_slices_idx(test_shape, result_width=holdout_size) - start = user_slices[0] - for i in user_slices[1:]: - stop = i - predicted, _ = self.slice_recommendations(test_data, test_shape, start, stop) - holdout_idx = self.get_holdout_slice(start, stop) - feedback_values = feedback_idx.loc[predicted[holdout_idx], 'old'].values - predicted_feedback[start:stop, :] = feedback_values.reshape(-1, holdout_size) - start = stop - self.flattener = flattener_old + userid = self.data.fields.userid + itemid = self.data.fields.itemid + feedback = self.data.fields.feedback + + holdout = self.data.test.holdout + holdout_users = holdout[userid].values.astype(np.int64) + holdout_items = holdout[itemid].values.astype(np.int64) + + u = self.factors[userid] + v = self.factors[itemid] + w = self.factors[feedback] + g = self.factors['core'] + + gv = np.tensordot(g, v[holdout_items, :], (1, 1)) + gu = (gv * u[holdout_users, None, :].T).sum(axis=0) + scores = w.dot(gu).T + predictions = np.argmax(scores, axis=-1) + + feedback_idx = self.data.index.feedback.set_index('new') + predicted_feedback = feedback_idx.loc[predictions, 'old'].values return predicted_feedback diff --git a/polara/recommender/utils.py b/polara/recommender/utils.py index c403048..6646e67 100644 --- a/polara/recommender/utils.py +++ b/polara/recommender/utils.py @@ -1,24 +1,7 @@ from __future__ import division -import sys import numpy as np from polara.tools.systools import get_available_memory - - -MEMORY_HARD_LIMIT = 1 # in gigbytes, default=1, depends on hardware -# varying this value may significantly impact performance -# setting it to None or large value typically reduces performance, -# as iterating over a smaller number of huge arrays takes longer -# than over a higher number of smaller arrays - -tuplsize = sys.getsizeof(()) -itemsize = np.dtype(np.intp).itemsize -pntrsize = sys.getsizeof(1.0) -# size of list of tuples of indices - to estimate when to convert sparse matrix to dense -# based on http://stackoverflow.com/questions/15641344/python-memory-consumption-dict-vs-list-of-tuples -# and https://code.tutsplus.com/tutorials/understand-how-much-memory-your-python-objects-use--cms-25609 -def get_nnz_max(): - return int(MEMORY_HARD_LIMIT * (1024**3) / (tuplsize + 2*(pntrsize + itemsize))) - +from polara.recommender import defaults def range_division(length, fit_size): # based on np.array_split @@ -47,9 +30,9 @@ def get_chunk_size(shp, result_width, scores_multiplier, dtypes=None): # take no more than 80% of available memory memory_limit = 0.8 * get_available_memory() - if MEMORY_HARD_LIMIT: + if defaults.memory_hard_limit: # too large arrays create significant overhead (with dot or tensordot) - memory_limit = min(memory_limit, MEMORY_HARD_LIMIT) + memory_limit = min(memory_limit, defaults.memory_hard_limit) required_memory = scores_memory + result_memory # memory at peak usage if required_memory > memory_limit: chunk_size = min(int((memory_limit - result_memory) / diff --git a/polara/tools/display.py b/polara/tools/display.py index a3e90aa..006cf25 100644 --- a/polara/tools/display.py +++ b/polara/tools/display.py @@ -1,5 +1,5 @@ from IPython.display import HTML -from contextlib import contextmanager +from contextlib import contextmanager, redirect_stdout import sys, os @@ -20,13 +20,11 @@ def print_frames(dataframes): return HTML(table) -# from http://thesmithfam.org/blog/2012/10/25/temporarily-suppress-console-output-in-python/# @contextmanager -def suppress_stdout(): - with open(os.devnull, "w") as devnull: - old_stdout = sys.stdout - sys.stdout = devnull - try: - yield - finally: - sys.stdout = old_stdout +def suppress_stdout(on=True): + if on: + with open(os.devnull, "w") as target: + with redirect_stdout(target): + yield + else: + yield diff --git a/polara/tools/timing.py b/polara/tools/timing.py index 7395138..c19b381 100644 --- a/polara/tools/timing.py +++ b/polara/tools/timing.py @@ -1,18 +1,34 @@ +from contextlib import contextmanager from timeit import default_timer as timer +from string import Template -class Timer(object): - def __init__(self, model_name='Model', verbose=True, msg=None): - self.model_name = model_name - self.message = msg or '{} training time: {}s' - self.elapsed_time = [] - self.verbose = verbose +training_time_message = Template('$model training time: $time') - def __enter__(self): - self.start = timer() - return self.elapsed_time - def __exit__(self, type, value, traceback): - self.elapsed_time.append(timer() - self.start) - if self.verbose: - print(self.message.format(self.model_name, self.elapsed_time[-1])) +def format_elapsed_time(seconds_total): + minutes, seconds = divmod(seconds_total, 60) + hours, minutes = divmod(minutes, 60) + + if hours == 0: + if minutes == 0: + return f'{seconds:.3f}s' + return f'{minutes:>02.0f}m:{seconds:>02.0f}s' + return f'{hours:.0f}h:{minutes:>02.0f}m:{seconds:>02.0f}s' + + +@contextmanager +def track_time(time_container=None, verbose=False, message=None, **kwargs): + if time_container is None: + time_container = [] + start = timer() + try: + yield time_container + finally: + stop = timer() + elapsed = stop - start + time_container.append(elapsed) + if verbose: + message = message or training_time_message + elapsed_time = format_elapsed_time(elapsed) + print(message.safe_substitute(kwargs, time=elapsed_time)) diff --git a/setup.py b/setup.py index 68c3181..08bb324 100644 --- a/setup.py +++ b/setup.py @@ -3,14 +3,16 @@ _packages = ["polara", "polara/recommender", - "polara/recommender/coldstart", "polara/evaluation", "polara/datasets", "polara/lib", "polara/tools", + "polara/recommender/coldstart", + "polara/recommender/hybrid", + "polara/recommender/contextual", "polara/recommender/external", "polara/recommender/external/mymedialite", - "polara/recommender/external/graphlab", + "polara/recommender/external/turi", "polara/recommender/external/implicit", "polara/recommender/external/lightfm"] @@ -18,15 +20,13 @@ opts = dict(name="polara", description="Fast and flexible recommender system framework", keywords = "recommender system", - version = "0.6.2.dev", + version = "0.6.4", license="MIT", author="Evgeny Frolov", platforms=["any"], packages=_packages) -extras = dict(install_requires=['futures; python_version=="2.7"']) - -opts.update(extras) +# opts.update(extras) if __name__ == '__main__': setup(**opts)