Fixing ShapWrapper predcit_proba method and adding tests

Author: mmerce

bigml/model.py

@@ -450,7 +450,6 @@ def __init__(self, model, api=None, fields=None, cache_get=None,
                 else:
                     self.tree_type = CLASSIFICATION
                     self.offsets = c.OFFSETS[str(self.weighted)]
-
             else:
                 raise Exception("Cannot create the Model instance."
                                 " Only correctly finished models can be"

bigml/shapwrapper.py

@@ -42,6 +42,7 @@ def __init__(self, model, api=None, cache_get=None,
         objective_id = getattr(self.local_model, "objective_id", None)
         self.fields = Fields(self.local_model.fields,
                              objective_field=objective_id)
+        self.objective_categories = self.local_model.objective_categories
         self.x_headers = [self.fields.field_name(field_id) for field_id in
                           self.fields.sorted_field_ids()]
         self.y_header = self.fields.field_name(self.fields.objective_field)
@@ -64,8 +65,10 @@ def predict_proba(self, x_test):
             raise ValueError("This method is only available for classification"
                              " models.")
         input_data_list = self.fields.from_numpy(x_test)
-        predictions = np.ndarray([])
-        for input_data in inner_data_list:
-            prediction = self.predict_probability(input_data, compact=True)
-            np.append(predictions, np.ndarray(prediction))
-        return predictions
+        np_list = np.empty(shape=(len(input_data_list),
+                                  len(self.objective_categories)))
+        for index, input_data in enumerate(input_data_list):
+            prediction = self.local_model.predict_probability(
+                input_data, compact=True)
+            np_list[index] = np.asarray([prediction])
+        return np_list

bigml/supervised.py

@@ -139,6 +139,8 @@ def __init__(self, model, api=None, cache_get=None,
         self.local_model = local_model
         self.regression = resource_type == "linearregression" or \
             self.local_model.regression
+        if not self.regression:
+            self.objective_categories = self.local_model.objective_categories
         self.name = self.local_model.name
         self.description = self.local_model.description
 

bigml/tests/compare_predictions_steps.py

@@ -34,6 +34,7 @@
 from bigml.local_model import LocalModel
 from bigml.fusion import Fusion
 from bigml.pca import PCA
+from bigml.shapwrapper import ShapWrapper
 
 
 from .create_prediction_steps import check_prediction
@@ -94,6 +95,11 @@ def i_create_a_local_supervised_model_from_file(step, model_file):
     step.bigml["local_model"] = SupervisedModel(res_filename(model_file))
 
 
+def i_create_a_local_shap_wrapper_from_file(step, model_file):
+    """Step: I create a local ShapWrapper from a <model_file> file"""
+    step.bigml["local_model"] = ShapWrapper(res_filename(model_file))
+
+
 def i_create_a_local_model(step, pre_model=False):
     """Step: I create a local model"""
     step.bigml["local_model"] = Model(world.model)
@@ -148,6 +154,7 @@ def the_local_bigml_prediction_is(step, value, prediction_type=None, key=None,
     eq_(value, prediction, precision=precision)
 
 
+
 def i_create_a_local_prediction_with_confidence(step, data=None,
                                                 pre_model=None):
     """Step: I create a local prediction for <data> with confidence"""
@@ -160,6 +167,14 @@ def i_create_a_local_prediction_with_confidence(step, data=None,
         input_data, full=True)
 
 
+def i_create_a_shap_local_prediction(step, data=None):
+    """Step: I create a local prediction for <numpy_input>"""
+    if data is None:
+        data = "[]"
+    step.bigml["local_prediction"] = step.bigml["local_model"].predict(
+        data).tolist()[0]
+
+
 def i_create_a_local_prediction(step, data=None, pre_model=None):
     """Step: I create a local prediction for <data>"""
     if data is None:
@@ -213,6 +228,13 @@ def i_create_local_probabilities(step, data=None):
         data, compact=True)
 
 
+def i_create_shap_local_probabilities(step, data=None):
+    """Step: I create shap local probabilities for <data>"""
+    model = step.bigml["local_model"]
+    step.bigml["local_probabilities"] = model.predict_proba(
+        data).tolist()[0]
+
+
 def i_create_a_local_ensemble_prediction(step, data=None):
     """Step: I create a local ensemble prediction for <data>"""
     if data is None:
@@ -452,6 +474,14 @@ def the_local_probabilities_are(step, prediction):
         approx_(local, expected, precision=4)
 
 
+def the_local_proba_prediction_is(step, proba_prediction):
+    """Step: the local probabilities prediction is <proba_prediction>"""
+    local_probabilities = step.bigml["local_probabilities"]
+
+    for local, expected in zip(local_probabilities, proba_prediction):
+        approx_(local, expected, precision=4)
+
+
 def the_local_ensemble_prediction_is(step, prediction):
     """Step: the local ensemble prediction is <prediction>"""
     if isinstance(step.bigml["local_prediction"], (list, tuple)):

bigml/tests/test_03_local_prediction.py

@@ -175,7 +175,10 @@ def test_scenario5(self):
         examples = [
             ['data/imgs_deepnet.zip', "data/images/cats/pexels-pixabay-33358.jpg",
              {"region_score_threshold": 0.7},
-             '{"prediction": [{"box": [0.68164, 0.30469, 0.79688, 0.36979], "label": "eye", "score": 0.79633}, {"box": [0.38086, 0.27865, 0.50391, 0.36068], "label": "eye", "score": 0.74563}]}']]
+             ('{"prediction": [{"box": [0.68164, 0.30469, 0.79688, 0.36979], '
+              '"label": "eye", "score": 0.79633}, '
+              '{"box": [0.38086, 0.27865, 0.50391, 0.36068], '
+              '"label": "eye", "score": 0.74563}]}')]]
         for example in examples:
             example = dict(zip(headers, example))
             show_method(self, self.bigml["method"], example)
@@ -186,3 +189,32 @@ def test_scenario5(self):
                 self, example["input_data"])
             prediction_compare.the_local_regions_prediction_is(
                 self, example["prediction"])
+
+    def test_scenario6(self):
+        """
+        Scenario 6: Successfully creating a prediction from a ShapWrapper of a model in a json file:
+            Given I create a local model using ShapWrapper from a "<model>" file
+            When I create a local prediction for "<numpy_input>"
+            Then the local prediction is "<prediction>"
+            When I create a local probabilities prediction for "<numpy_input>"
+            Then the local probabilities prediction is "<proba_prediction>"
+        """
+        import numpy as np
+        show_doc(self.test_scenario6)
+        headers = ["file_path", "numpy_input", "prediction", "proba_prediction"]
+        examples = [
+            ['data/iris_model.json', np.asarray([np.asarray([0.5,1.0,1.0])]),
+             0., [0.9818, 0.00921, 0.00899]]]
+        for example in examples:
+            example = dict(zip(headers, example))
+            show_method(self, self.bigml["method"], example)
+            prediction_compare.i_create_a_local_shap_wrapper_from_file(
+                self, example["file_path"])
+            prediction_compare.i_create_a_shap_local_prediction(
+                self, example["numpy_input"])
+            prediction_compare.the_local_prediction_is(
+                self, example["prediction"])
+            prediction_compare.i_create_shap_local_probabilities(
+                self, example["numpy_input"])
+            prediction_compare.the_local_proba_prediction_is(
+                self, example["proba_prediction"])