Naive Bayes: Reimplement predict_storage to:

- avoid numpy warning about passing generator to sum
- loop over columns instead of over rows (usually better + more friendly to pandas sometime in the future)
- natively support sparse matrices

Author: janezd

Orange/classification/naive_bayes.py

@@ -1,4 +1,5 @@
 import numpy as np
+import scipy.sparse as sp
 
 from Orange.classification import Learner, Model
 from Orange.data import Instance, Storage
@@ -48,22 +49,62 @@ def __init__(self, log_cont_prob, class_prob, domain):
 
     def predict_storage(self, data):
         if isinstance(data, Instance):
-            data = [data]
-        if len(data.domain.attributes) == 0:
-            probs = np.tile(self.class_prob, (len(data), 1))
+            data = np.atleast_2d(data.x)
+        elif isinstance(data, Storage):
+            data = data.X
+
+        if not self.log_cont_prob:
+            probs = self._priors(data)
+        elif sp.issparse(data):
+            probs = self._sparse_probs(data)
         else:
-            isnan = np.isnan
-            probs = np.exp(
-                np.log(self.class_prob) +
-                np.array([np.zeros_like(self.class_prob)
-                          if isnan(ins.x).all() else
-                          np.sum(attr_prob[:, int(attr_val)]
-                                 for attr_val, attr_prob in zip(ins, self.log_cont_prob)
-                                 if not isnan(attr_val))
-                          for ins in data]))
+            probs = self._dense_probs(data)
+        probs = np.exp(probs)
         probs /= probs.sum(axis=1)[:, None]
         values = probs.argmax(axis=1)
         return values, probs
 
+    def _priors(self, data):
+        return np.tile(np.log(self.class_prob), (data.shape[0], 1))
+
+    def _dense_probs(self, data):
+        probs = self._priors(data)
+        zeros = np.zeros((1, probs.shape[1]))
+        for col, attr_prob in zip(data.T, self.log_cont_prob):
+            col = col.copy()
+            col[np.isnan(col)] = attr_prob.shape[1] - 1
+            col = col.astype(int)
+            probs0 = np.vstack((attr_prob.T, zeros))
+            probs += probs0[col]
+        return probs
+
+    def _sparse_probs(self, data):
+        probs = self._priors(data)
+
+        n_vals = max(p.shape[1] for p in self.log_cont_prob) + 1
+        log_prob = np.zeros((len(self.log_cont_prob),
+                             n_vals,
+                             self.log_cont_prob[0].shape[0]))
+        for i, p in enumerate(self.log_cont_prob):
+            p0 = p.T[0].copy()
+            probs[:] += p0
+            log_prob[i, :p.shape[1]] = p.T - p0
+
+        dat = data.data.copy()
+        dat[np.isnan(dat)] = n_vals - 1
+        dat = dat.astype(int)
+
+        if sp.isspmatrix_csr(data):
+            for row, start, end in zip(probs, data.indptr, data.indptr[1:]):
+                row += log_prob[data.indices[start:end],
+                                dat[start:end]].sum(axis=0)
+        else:
+            csc = data.tocsc()
+            for start, end, attr_prob in zip(csc.indptr, csc.indptr[1:],
+                                             log_prob):
+                probs[csc.indices[start:end]] += attr_prob[dat[start:end]]
+
+        return probs
+
 
 NaiveBayesLearner.__returns__ = NaiveBayesModel

Orange/tests/test_naive_bayes.py

@@ -3,6 +3,9 @@
 
 import unittest
 
+import numpy as np
+import scipy.sparse as sp
+
 from Orange.classification import NaiveBayesLearner
 from Orange.data import Table, Domain, DiscreteVariable, ContinuousVariable
 from Orange.evaluation import CrossValidation, CA
@@ -11,7 +14,7 @@
 class TestNaiveBayesLearner(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        data = Table('titanic')
+        cls.data = data = Table('titanic')
         cls.learner = NaiveBayesLearner()
         cls.model = cls.learner(data)
         cls.table = data[::20]
@@ -22,6 +25,10 @@ def test_NaiveBayes(self):
         self.assertGreater(ca, 0.7)
         self.assertLess(ca, 0.9)
 
+        results = CrossValidation(Table("iris"), [self.learner], k=10)
+        ca = CA(results)
+        self.assertGreater(ca, 0.7)
+
     def test_predict_single_instance(self):
         for ins in self.table:
             self.model(ins)
@@ -53,3 +60,12 @@ def test_allnan_cv(self):
         data = Table('voting')
         results = CrossValidation(data, [self.learner])
         self.assertFalse(any(results.failed))
+
+    def test_sparse(self):
+        _, dense_p = self.model.predict_storage(self.data.X)
+
+        _, csc_p = self.model.predict_storage(sp.csc_matrix(self.data.X))
+        np.testing.assert_almost_equal(dense_p, csc_p)
+
+        _, csr_p = self.model.predict_storage(sp.csr_matrix(self.data.X))
+        np.testing.assert_almost_equal(dense_p, csr_p)