add more ALS tests

recommend/tests/test_als.py

@@ -8,6 +8,8 @@
 else:
     import cPickle
 
+from numpy.testing import (assert_array_equal,
+                           assert_raises)
 from recommend.utils.datasets import make_ratings
 from recommend.utils.evaluation import RMSE
 from recommend.als import ALS
@@ -27,8 +29,8 @@ def setUp(self):
         self.seed = 0
 
     def test_als_with_random_data(self):
-        n_user = 1000
-        n_item = 2000
+        n_user = 100
+        n_item = 200
         n_feature = self.n_feature
         ratings = make_ratings(n_user, n_item, 20, 30, self.rating_choices, seed=self.seed)
 
@@ -47,10 +49,92 @@ def test_als_with_random_data(self):
                    max_rating=self.max_rat,
                    min_rating=self.min_rat)
 
-        als2.fit(ratings, n_iters=5)
+        als2.fit(ratings, n_iters=3)
         rmse_2 = RMSE(als2.predict(ratings[:, :2]), ratings[:, 2])
         self.assertTrue(rmse_1 > rmse_2)
 
+    def test_als_convergence(self):
+        n_user = 100
+        n_item = 200
+        n_feature = self.n_feature
+        ratings = make_ratings(n_user, n_item, 20, 30, self.rating_choices, seed=self.seed)
+
+        als1 = ALS(n_user, n_item, n_feature,
+                   reg=1e-2,
+                   seed=0,
+                   max_rating=self.max_rat,
+                   min_rating=self.min_rat,
+                   converge=1e-2)
+
+        als1.fit(ratings, n_iters=10)
+        rmse_1 = RMSE(als1.predict(ratings[:, :2]), ratings[:, 2])
+
+        als2 = ALS(n_user, n_item, n_feature,
+                   reg=1e-2,
+                   seed=0,
+                   max_rating=self.max_rat,
+                   min_rating=self.min_rat,
+                   converge=1e-1)
+
+        als2.fit(ratings, n_iters=10)
+        rmse_2 = RMSE(als2.predict(ratings[:, :2]), ratings[:, 2])
+        self.assertTrue(rmse_1 < rmse_2)
+
+    def test_als_seed(self):
+        n_user = 100
+        n_item = 200
+        n_feature = self.n_feature
+        ratings = make_ratings(n_user, n_item, 20, 30, self.rating_choices, seed=self.seed)
+
+        # seed 0
+        als1 = ALS(n_user, n_item, n_feature,
+                   reg=1e-2,
+                   seed=0,
+                   max_rating=self.max_rat,
+                   min_rating=self.min_rat)
+        als1.fit(ratings, n_iters=3)
+
+        als2 = ALS(n_user, n_item, n_feature,
+                   reg=1e-2,
+                   seed=0,
+                   max_rating=self.max_rat,
+                   min_rating=self.min_rat)
+        als2.fit(ratings, n_iters=3)
+        assert_array_equal(als1.user_features_, als2.user_features_)
+        assert_array_equal(als1.item_features_, als2.item_features_)
+
+        # seed 1
+        als3 = ALS(n_user, n_item, n_feature,
+                   reg=1e-2,
+                   seed=1,
+                   max_rating=self.max_rat,
+                   min_rating=self.min_rat)
+        als3.fit(ratings, n_iters=3)
+        assert_raises(AssertionError, assert_array_equal,
+                      als1.user_features_, als3.user_features_)
+        assert_raises(AssertionError, assert_array_equal,
+                      als1.item_features_, als3.item_features_)
+
+    def test_als_with_missing_data(self):
+        n_user = 10
+        n_item = 20
+        n_feature = self.n_feature
+        ratings = make_ratings(n_user - 1, n_item - 1, 5, 10, self.rating_choices, seed=self.seed)
+        als1 = ALS(n_user, n_item, n_feature,
+                   reg=1e-2,
+                   seed=0,
+                   max_rating=self.max_rat,
+                   min_rating=self.min_rat)
+
+        unuse_user_f_before = als1.user_features_[n_user - 1, :]
+        unuse_item_f_before = als1.item_features_[n_item - 1, :]
+        als1.fit(ratings, n_iters=1)
+        unuse_user_f_after = als1.user_features_[n_user - 1, :]
+        unuse_item_f_after = als1.item_features_[n_item - 1, :]
+        # last user/item feature should be unchanged since no rating data on them
+        assert_array_equal(unuse_user_f_before, unuse_user_f_after)
+        assert_array_equal(unuse_item_f_before, unuse_item_f_after)
+
     def test_als_not_fitted_err(self):
         with self.assertRaises(NotFittedError):
             ratings = make_ratings(10, 10, 1, 5, self.rating_choices, seed=self.seed)
@@ -95,6 +179,6 @@ def test_als_with_ml_100k_rating(self):
                   min_rating=1.,
                   seed=self.seed)
 
-        als.fit(ratings, n_iters=10)
+        als.fit(ratings, n_iters=5)
         rmse = RMSE(als.predict(ratings[:, :2]), ratings[:, 2])
         self.assertTrue(rmse < 0.8)