Extending LocalModel class to handle Time Series too

Author: mmerce

HISTORY.rst

@@ -3,6 +3,12 @@
 History
 -------
 
+9.4.0 (2023-06-14)
+------------------
+
+- Extending LocalModel class to handle Time Series locally.
+
+
 9.3.0 (2023-06-09)
 ------------------
 

bigml/bigmlconnection.py

@@ -765,10 +765,6 @@ def _download(self, url, filename=None, wait_time=10, retries=10,
                 return file_object
         try:
             code = response.status_code
-            print("*** response headers ****", response.headers)
-            print("***")
-            print("*** request ")
-            print(response.request.__dict__)
             if code == HTTP_OK:
                 # starting the dataset export procedure
                 if response.headers.get("content-type") == JSON_TYPE:

bigml/cluster.py

@@ -648,12 +648,12 @@ def summarize(self, out=sys.stdout):
 
     def predict(self, input_data, full=False):
         """Method to homogeneize the local models interface for all BigML
-        models. It returns the centroid method result. The full parameter has
-        no effect in this case because the original centroid information is
-        already a complete dictionary. Is kept to mimic the interface of the
-        general method.
+        models. It returns the centroid method result.
         """
-        return self.centroid(input_data)
+        centroid = self.centroid(input_data)
+        if not full:
+            return {"centroid_name": centroid["name"]}
+        return centroid
 
     def batch_predict(self, input_data_list, outputs=None, **kwargs):
         """Creates a batch centroid for a list of inputs using the local

bigml/deepnet.py

@@ -213,6 +213,7 @@ def __init__(self, deepnet, api=None, cache_get=None,
                 else:
                     settings = None
 
+                #pylint: disable=locally-disabled,broad-except
                 if not self.using_laminar:
                     try:
                         self.deepnet = create_model(deepnet,

bigml/local_model.py

@@ -57,6 +57,7 @@
 from bigml.cluster import Cluster
 from bigml.anomaly import Anomaly
 from bigml.association import Association
+from bigml.timeseries import TimeSeries
 try:
     from bigml.topicmodel import TopicModel
     TOPIC_ENABLED = True
@@ -83,9 +84,11 @@
     "cluster": Cluster,
     "anomaly": Anomaly,
     "association": Association,
-    "topicmodel": TopicModel,
-    "pca": PCA}
+    "pca": PCA,
+    "timeseries": TimeSeries}
 MODEL_CLASSES.update(SUPERVISED_CLASSES)
+if TOPIC_ENABLED:
+    MODEL_CLASSES.update({"topicmodel": TopicModel})
 
 
 def extract_id(model, api):
@@ -139,7 +142,7 @@ def extract_id(model, api):
 class LocalModel(BaseModel):
     """ A lightweight wrapper around any BigML model.
 
-    Uses any BigML remote supervised model to build a local version
+    Uses any BigML remote model to build a local version
     that can be used to generate predictions locally.
 
     """
@@ -179,7 +182,7 @@ def data_transformations(self):
 
     def batch_predict(self, input_data_list, outputs=None, **kwargs):
         """Creates a batch prediction for a list of inputs using the local
-        supervised model. Allows to define some output settings to
+        BigML model. Allows to define some output settings to
         decide the fields to be added to the input_data (prediction,
         probability, etc.) and the name that we want to assign to these new
         fields. The outputs argument accepts a dictionary with keys
@@ -196,8 +199,9 @@ def batch_predict(self, input_data_list, outputs=None, **kwargs):
         :rtype: list or Panda's dataframe depending on the input type in
                 input_data_list
         """
-        if isinstance(self.local_model, Association):
-            raise("The method is not available for Associations.")
+        if isinstance(self.local_model, (Association, TimeSeries)):
+            raise ValueError("The method is not available for Associations or "
+                  "TimeSeries.")
         if self.supervised:
             if outputs is None:
                 outputs = {}
@@ -220,9 +224,8 @@ def batch_predict(self, input_data_list, outputs=None, **kwargs):
             if data_format != INTERNAL:
                 return format_data(inner_data_list, out_format=data_format)
             return inner_data_list
-        else:
-            return self.local_model.batch_predict(input_data_list,
-                outputs=outputs, **kwargs)
+        return self.local_model.batch_predict(input_data_list,
+            outputs=outputs, **kwargs)
 
     #pylint: disable=locally-disabled,arguments-differ
     def dump(self, **kwargs):

bigml/tests/compare_predictions_steps.py

@@ -140,6 +140,8 @@ def i_create_a_local_bigml_model_prediction(step, data=None,
 
 def the_local_bigml_prediction_is(step, value, prediction_type=None, key=None,
     precision=None):
+    """Step: the local BigML model prediction is
+    """
     prediction = step.bigml["local_%s" % prediction_type]
     if key is not None:
         prediction = prediction[key]

bigml/tests/test_34_time_series.py

@@ -20,12 +20,15 @@
 """ Creating time series forecasts
 
 """
+import json
+
 from .world import world, setup_module, teardown_module, show_doc, \
     show_method
 from . import create_source_steps as source_create
 from . import create_dataset_steps as dataset_create
 from . import create_time_series_steps as time_series_create
 from . import create_forecast_steps as forecast_create
+from . import compare_predictions_steps as prediction_compare
 
 
 class TestTimeSeries:
@@ -91,3 +94,10 @@ def test_scenario1(self):
             forecast_create.i_create_a_forecast(
                 self, example["input_data"])
             forecast_create.the_forecast_is(self, example["forecast_points"])
+            prediction_compare.i_create_a_local_bigml_model(self,
+                model_type="time_series")
+            prediction_compare.i_create_a_local_bigml_model_prediction(
+                self, example["input_data"], prediction_type="forecast")
+            forecast_points = json.loads(example["forecast_points"])
+            prediction_compare.the_local_bigml_prediction_is(
+                self, {"forecast": forecast_points}, prediction_type="forecast")

bigml/tests/world.py

@@ -124,6 +124,17 @@ def flatten_shared():
     return ids_list
 
 
+def sort_dict(item):
+    """
+    Sort nested dict
+    """
+    if isinstance(item, list):
+        return [sort_dict(v) for v in item]
+    if not isinstance(item, dict):
+        return item
+    return {k: sort_dict(v) for k, v in sorted(item.items())}
+
+
 def eq_(*args, msg=None, precision=None):
     """Wrapper to assert. If precision is set, previous rounding"""
     new_args = list(args)
@@ -133,15 +144,26 @@ def eq_(*args, msg=None, precision=None):
             new_args[index] = list(dict(sorted(arg.items())).values())
     if precision is not None:
         if isinstance(new_args[0], list):
+            if msg is None:
+                msg = "Comparing: %s" % new_args
             assert all(len(new_args[0]) == len(b) for b in new_args[1:]), msg
             pairs = zip(new_args[0], new_args[1])
+            if msg is None:
+                msg = "Comparing: %s" % new_args
             assert all(float_round(a, precision) == float_round(b, precision)
                 for a, b in pairs), msg
         else:
             for index, arg in enumerate(new_args):
                 new_args[index] = float_round(arg, precision)
+            if msg is None:
+                msg = "Comparing: %s" % new_args
             assert all(new_args[0] == b for b in new_args[1:]), msg
     else:
+        if isinstance(new_args[0], (dict, list)):
+            for index, arg in enumerate(new_args):
+                new_args[index] = sort_dict(new_args[index])
+        if msg is None:
+            msg = "expected: %s, got: %s" % (new_args[0], new_args[1])
         assert new_args[0] == new_args[1], msg
 
 

bigml/timeseries.py

@@ -49,6 +49,7 @@
 from bigml.util import utf8, use_cache, load
 from bigml.basemodel import get_resource_dict, extract_objective
 from bigml.modelfields import ModelFields
+from bigml.constants import DECIMALS
 from bigml.tssubmodels import SUBMODELS
 from bigml.tsoutconstants import SUBMODELS_CODE, TRIVIAL_MODEL, \
     SEASONAL_CODE, FORECAST_FUNCTION, USAGE_DOC
@@ -78,7 +79,8 @@ def compute_forecasts(submodels, horizon):
 
         forecasts.append( \
             {"model": name,
-             "point_forecast": SUBMODELS[trend](*args)})
+             "point_forecast": [round(value, DECIMALS) for value in
+                                SUBMODELS[trend](*args)]})
     return forecasts
 
 
@@ -258,6 +260,15 @@ def forecast(self, input_data=None):
 
         return forecasts
 
+    def predict(self, input_data, full=False):
+        """Method to homogeneize the local models interface for all BigML
+        models. It returns the forecast method result.
+        """
+        forecast = self.forecast(input_data)
+        if full:
+            return {"forecast": forecast}
+        return forecast
+
     def filter_objectives(self, input_data,
                           full=False):
         """Filters the keys given in input_data checking against the

bigml/topicmodel.py

@@ -401,6 +401,9 @@ def infer(self, list_of_indices):
                 for k in range(self.ntopics)]
 
     def predict(self, input_data, full=False):
+        """Method to homogeneize the local models interface for all BigML
+        models. It returns the distribution method result.
+        """
         distribution = self.distribution(input_data)
         if full:
             return distribution_to_dict(distribution)