def test_bias_check_arguments(): # negative damping is not allowed with raises(ValueError): Bias(damping=-1) # negative user damping not allowed with raises(ValueError): Bias(damping=(-1, 5)) # negative user damping not allowed with raises(ValueError): Bias(damping=(5, -1))
def test_sweep_combine(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path, combine=False) ratings = ml_test.ratings sweep.add_datasets(lambda: xf.partition_users(ratings, 5, xf.SampleN(5)), name='ml-small') sweep.add_algorithms([Bias(damping=0), Bias(damping=5)], attrs=['damping']) sweep.add_algorithms(Popular()) sweep.persist_data() for i in range(1, 6): assert (work / 'ds{}-train.parquet'.format(i)).exists() assert (work / 'ds{}-test.parquet'.format(i)).exists() for ds, cf, dsa in sweep.datasets: assert isinstance(ds, tuple) train, test = ds assert isinstance(train, pathlib.Path) assert isinstance(test, pathlib.Path) assert sweep.run_count() == 5 * 3 try: sweep.run() finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert not (work / 'runs.csv').exists() assert not (work / 'runs.parquet').exists() assert not (work / 'predictions.parquet').exists() assert not (work / 'recommendations.parquet').exists() for i, (ds, a) in enumerate(sweep._flat_runs()): run = i + 1 assert (work / 'run-{}.json'.format(run)).exists() if isinstance(a.algorithm, Predictor): assert (work / 'predictions-{}.parquet'.format(run)).exists() assert (work / 'recommendations-{}.parquet'.format(run)).exists() sweep.collect_results() assert (work / 'runs.csv').exists() assert (work / 'runs.parquet').exists() assert (work / 'predictions.parquet').exists() assert (work / 'recommendations.parquet').exists() runs = pd.read_parquet(work / 'runs.parquet') assert len(runs) == 5 * 3
def test_bias_item_predict(): algo = Bias(users=False) algo.fit(simple_df) p = algo.predict_for_user(10, [1, 2, 3]) assert len(p) == 3 assert p.values == approx((algo.item_offsets_ + algo.mean_).values)
def test_sweep_nopreds(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path, eval_n_jobs=1) ratings = ml_test.ratings folds = [(train, test.drop(columns=['rating'])) for (train, test) in xf.partition_users(ratings, 5, xf.SampleN(5))] sweep.add_datasets(folds, DataSet='ml-small') sweep.add_algorithms(Popular()) sweep.add_algorithms(Bias(damping=0)) try: sweep.run() finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert (work / 'runs.csv').exists() assert (work / 'runs.parquet').exists() assert not (work / 'predictions.parquet').exists() assert (work / 'recommendations.parquet').exists() runs = pd.read_parquet(work / 'runs.parquet') # 2 algorithms by 5 partitions assert len(runs) == 10 assert all(np.sort(runs.AlgoClass.unique()) == ['Bias', 'Popular']) bias_runs = runs[runs.AlgoClass == 'Bias'] recs = pd.read_parquet(work / 'recommendations.parquet') assert all(recs.RunId.isin(runs.RunId)) assert recs['score'].dtype == np.float64
def test_sweep_norecs(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path, recommend=None) ratings = ml_test.ratings folds = xf.partition_users(ratings, 5, xf.SampleN(5)) sweep.add_datasets(folds, DataSet='ml-small') sweep.add_algorithms(Bias(damping=0)) sweep.add_algorithms(Popular()) try: sweep.run() finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert (work / 'runs.csv').exists() assert (work / 'runs.parquet').exists() assert (work / 'predictions.parquet').exists() assert not (work / 'recommendations.parquet').exists() runs = pd.read_parquet(work / 'runs.parquet') # 2 algorithms by 5 partitions assert len(runs) == 10 assert all(np.sort(runs.AlgoClass.unique()) == ['Bias', 'Popular']) bias_runs = runs[runs.AlgoClass == 'Bias'] preds = pd.read_parquet(work / 'predictions.parquet') assert all(preds.RunId.isin(bias_runs.RunId))
def test_sweep_save(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path) ratings = ml_test.ratings sweep.add_datasets(lambda: xf.partition_users(ratings, 5, xf.SampleN(5)), name='ml-small') sweep.add_algorithms(Bias(damping=5)) sweep.persist_data() pf = work / 'sweep.dat' with pf.open('wb') as f: pickle.dump(sweep, f) with pf.open('rb') as f: sweep = pickle.load(f) try: sweep.run() finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert (work / 'runs.csv').exists() assert (work / 'runs.parquet').exists() assert (work / 'predictions.parquet').exists() assert (work / 'recommendations.parquet').exists() runs = pd.read_parquet(work / 'runs.parquet') # 1 algorithms by 5 partitions assert len(runs) == 5
def test_fallback_train_one(): algo = basic.Fallback(Bias()) algo.fit(lktu.ml_test.ratings) assert len(algo.algorithms) == 1 assert isinstance(algo.algorithms[0], Bias) assert algo.algorithms[0].mean_ == approx( lktu.ml_test.ratings.rating.mean())
def test_sweep_oneshot(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path, combine=False) ratings = ml_test.ratings sweep.add_datasets(lambda: xf.partition_users(ratings, 5, xf.SampleN(5)), name='ml-small') sweep.add_algorithms(Bias(damping=5)) try: sweep.run(3) finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert not (work / 'runs.csv').exists() assert not (work / 'runs.parquet').exists() assert not (work / 'predictions.parquet').exists() assert not (work / 'recommendations.parquet').exists() assert (work / 'run-3.json').exists() assert (work / 'predictions-3.parquet').exists() assert (work / 'recommendations-3.parquet').exists() with (work / 'run-3.json').open() as f: run = json.load(f) assert run['RunId'] == 3
def test_bias_global_predict(): algo = Bias(items=False, users=False) algo.fit(simple_df) p = algo.predict_for_user(10, [1, 2, 3]) assert len(p) == 3 assert (p == algo.mean_).all() assert p.values == approx(algo.mean_)
def test_bias_batch_recommend(ml_folds: MLFolds, ncpus, isolate): algo = Bias(damping=5) algo = TopN(algo) ml_folds.isolate = isolate recs = ml_folds.eval_all(algo, n_jobs=ncpus) ml_folds.check_positive_ndcg(recs)
def test_bias_predict_unknown_user(): algo = Bias() algo.fit(simple_df) p = algo.predict_for_user(15, [1, 3]) assert len(p) == 2 assert p.values == approx((algo.item_offsets_.loc[[1, 3]] + algo.mean_).values)
def _build_predict(ratings, fold): algo = Fallback(knn.ItemItem(20), Bias(5)) train = ratings[ratings['partition'] != fold] algo.fit(train) test = ratings[ratings['partition'] == fold] preds = batch.predict(algo, test, n_jobs=1) return preds
def test_fallback_clone(): algo = basic.Fallback([basic.Memorized(simple_df), Bias()]) algo.fit(lktu.ml_test.ratings) assert len(algo.algorithms) == 2 clone = lku.clone(algo) assert clone is not algo for a1, a2 in zip(algo.algorithms, clone.algorithms): assert a1 is not a2 assert type(a2) == type(a1)
def test_fallback_list(): algo = basic.Fallback([basic.Memorized(simple_df), Bias()]) algo.fit(lktu.ml_test.ratings) assert len(algo.algorithms) == 2 params = algo.get_params() assert list(params.keys()) == ['algorithms'] assert len(params['algorithms']) == 2 assert isinstance(params['algorithms'][0], basic.Memorized) assert isinstance(params['algorithms'][1], Bias)
def test_bias_predict_unknown_item(): algo = Bias() algo.fit(simple_df) p = algo.predict_for_user(10, [1, 3, 4]) assert len(p) == 3 intended = algo.item_offsets_.loc[[1, 3]] + algo.mean_ + 0.25 assert p.loc[[1, 3]].values == approx(intended.values) assert p.loc[4] == approx(algo.mean_ + 0.25)
def test_bias_no_item(): algo = Bias(items=False) algo.fit(simple_df) assert algo.mean_ == approx(3.5) assert algo.item_offsets_ is None assert algo.user_offsets_ is not None assert algo.user_offsets_.index.name == 'user' assert set(algo.user_offsets_.index) == set([10, 12, 13]) assert algo.user_offsets_.loc[[10, 12, 13]].values == approx(np.array([1.0, -0.5, -1.5]))
def test_bias_transform(): algo = Bias() ratings = ml_test.ratings normed = algo.fit_transform(ratings) assert all(normed['user'] == ratings['user']) assert all(normed['item'] == ratings['item']) denorm = algo.inverse_transform(normed) assert approx(denorm['rating'] == ratings['rating'], 1.0e-6)
def test_bias_no_user(): algo = Bias(users=False) algo.fit(simple_df) assert algo.mean_ == approx(3.5) assert algo.item_offsets_ is not None assert algo.item_offsets_.index.name == 'item' assert set(algo.item_offsets_.index) == set([1, 2, 3]) assert algo.item_offsets_.loc[1:3].values == approx(np.array([0, 1.5, -1.5])) assert algo.user_offsets_ is None
def test_transform_user_without_user_bias(): user = 12 algo = Bias() algo.fit(simple_df) new_ratings = pd.Series([-0.5, 1.5], index=[2, 3]) # items as index and ratings as values v = algo.inverse_transform_user(user, new_ratings) assert v[2] == new_ratings[2] + algo.user_offsets_.loc[user] + algo.item_offsets_.loc[2] + algo.mean_ assert v[3] == new_ratings[3] + algo.user_offsets_.loc[user] + algo.item_offsets_.loc[3] + algo.mean_
def test_transform_user_with_user_bias(): algo = Bias() algo.fit(simple_df) new_ratings = pd.Series([4.0, 5.0], index=[1, 2]) # items as index and ratings as values ratings_with_bias, user_bias = algo.transform_user(new_ratings) # user: 13 result = algo.inverse_transform_user(13, ratings_with_bias, user_bias) assert new_ratings[1] == result[1] assert new_ratings[2] == result[2]
def test_bias_user_damp(): algo = Bias(items=False, damping=5) algo.fit(simple_df) assert algo.mean_ == approx(3.5) assert algo.item_offsets_ is None assert algo.user_offsets_ is not None assert algo.user_offsets_.index.name == 'user' assert set(algo.user_offsets_.index) == set([10, 12, 13]) assert algo.user_offsets_.loc[[10, 12, 13]].values == \ approx(np.array([0.2857, -0.08333, -0.25]), abs=1.0e-4)
def test_sweep_filenames(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path) ratings = ml_test.ratings folds = [] for part, (train, test) in enumerate(xf.partition_users(ratings, 2, xf.SampleN(5))): trfn = work / 'p{}-train.csv'.format(part) tefn = work / 'p{}-test.csv'.format(part) train.to_csv(trfn) test.to_csv(tefn) folds.append((trfn, tefn)) sweep.add_datasets(folds, DataSet='ml-small') sweep.add_algorithms( [Bias(damping=0), Bias(damping=5), Bias(damping=10)], attrs=['damping']) sweep.add_algorithms(Popular()) def progress(iter, total=None): assert total == len(folds) * 4 return iter try: sweep.run(progress=progress) finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert (work / 'runs.csv').exists() assert (work / 'runs.parquet').exists() assert (work / 'predictions.parquet').exists() assert (work / 'recommendations.parquet').exists() runs = pd.read_parquet(work / 'runs.parquet') # 4 algorithms by 2 partitions assert len(runs) == 8
def test_bias_clone(): algo = Bias() algo.fit(simple_df) params = algo.get_params() assert sorted(params.keys()) == ['damping', 'items', 'users'] a2 = lku.clone(algo) assert a2 is not algo assert getattr(a2, 'mean_', None) is None assert getattr(a2, 'item_offsets_', None) is None assert getattr(a2, 'user_offsets_', None) is None
def test_bias_user_predict(): algo = Bias(items=False) algo.fit(simple_df) p = algo.predict_for_user(10, [1, 2, 3]) assert len(p) == 3 assert p.values == approx(algo.mean_ + 1.0) p = algo.predict_for_user(12, [1, 3]) assert len(p) == 2 assert p.values == approx(algo.mean_ - 0.5)
def test_bias_transform_indexes(): algo = Bias() ratings = ml_test.ratings normed = algo.fit_transform(ratings, indexes=True) assert all(normed['user'] == ratings['user']) assert all(normed['item'] == ratings['item']) assert all(normed['uidx'] == algo.user_offsets_.index.get_indexer(ratings['user'])) assert all(normed['iidx'] == algo.item_offsets_.index.get_indexer(ratings['item'])) denorm = algo.inverse_transform(normed) assert approx(denorm['rating'] == ratings['rating'], 1.0e-6)
def test_sweep_bias(tmp_path): work = pathlib.Path(tmp_path) sweep = batch.MultiEval(tmp_path) ratings = ml_test.ratings folds = xf.partition_users(ratings, 5, xf.SampleN(5)) sweep.add_datasets(folds, DataSet='ml-small') sweep.add_algorithms(Popular()) sweep.add_algorithms( [Bias(damping=0), Bias(damping=5), Bias(damping=10)], attrs=['damping']) try: sweep.run() finally: if (work / 'runs.csv').exists(): runs = pd.read_csv(work / 'runs.csv') print(runs) assert (work / 'runs.csv').exists() assert (work / 'runs.parquet').exists() assert (work / 'predictions.parquet').exists() assert (work / 'recommendations.parquet').exists() runs = pd.read_parquet(work / 'runs.parquet') # 4 algorithms by 5 partitions assert len(runs) == 20 assert all(np.sort(runs.AlgoClass.unique()) == ['Bias', 'Popular']) bias_runs = runs[runs.AlgoClass == 'Bias'] assert all(bias_runs.damping.notna()) pop_runs = runs[runs.AlgoClass == 'Popular'] assert all(pop_runs.damping.isna()) preds = pd.read_parquet(work / 'predictions.parquet') assert all(preds.RunId.isin(bias_runs.RunId)) recs = pd.read_parquet(work / 'recommendations.parquet') assert all(recs.RunId.isin(runs.RunId)) assert recs['score'].dtype == np.float64
def test_train_isolate(): algo = Bias() algo = Recommender.adapt(algo) saved = train_isolated(algo, ml_test.ratings) try: trained = saved.get() assert isinstance(trained, TopN) recs = trained.recommend(10, 10) assert len(recs) == 10 del recs, trained finally: saved.close()
def test_bias_full(): algo = Bias() algo.fit(simple_df) assert algo.mean_ == approx(3.5) assert algo.item_offsets_ is not None assert algo.item_offsets_.index.name == 'item' assert set(algo.item_offsets_.index) == set([1, 2, 3]) assert algo.item_offsets_.loc[1:3].values == approx(np.array([0, 1.5, -1.5])) assert algo.user_offsets_ is not None assert algo.user_offsets_.index.name == 'user' assert set(algo.user_offsets_.index) == set([10, 12, 13]) assert algo.user_offsets_.loc[[10, 12, 13]].values == approx(np.array([0.25, -0.5, 0]))
def test_bias_new_user_predict(): algo = Bias() algo.fit(simple_df) ratings = pd.DataFrame({'item': [1, 2, 3], 'rating': [1.5, 2.5, 3.5]}) ratings = ratings.set_index('item').rating p = algo.predict_for_user(None, [1, 3], ratings=ratings) offs = ratings - algo.mean_ - algo.item_offsets_ umean = offs.mean() _log.info('user mean is %f', umean) assert len(p) == 2 assert p.values == approx((algo.mean_ + algo.item_offsets_ + umean).loc[[1, 3]].values)
def test_train_isolate_file(tmp_path): fn = tmp_path / 'saved.bpk' algo = Bias() algo = Recommender.adapt(algo) saved = train_isolated(algo, ml_test.ratings, file=fn) try: assert saved.path == fn trained = saved.get() assert isinstance(trained, TopN) recs = trained.recommend(10, 10) assert len(recs) == 10 del recs, trained finally: saved.close()