Seaborn Plots

composeml/label_maker.py

@@ -327,25 +327,19 @@ def search(self,
         progress_bar.update(n=total)
         progress_bar.close()
 
-        labels = LabelTimes(data=labels, name=name, target_entity=self.target_entity)
+        labels = LabelTimes(data=labels, name=name, target_entity=self.target_entity, label_type=label_type)
         labels = labels.rename_axis('id', axis=0)
 
         if labels.empty:
             return labels
 
-        if label_type is not None:
-            error = 'label type must be "continuous" or "categorical"'
-            assert label_type in ['continuous', 'categorical'], error
-
-            if label_type == 'categorical':
-                labels[labels.name] = labels[labels.name].astype('category')
-
-        else:
-            labels = labels.infer_type()
+        if labels.label_type == 'discrete':
+            labels[labels.name] = labels[labels.name].astype('category')
 
         labels.settings.update({
+            'labeling_function': name,
             'num_examples_per_instance': num_examples_per_instance,
-            'minimum_data': minimum_data or 0,
+            'minimum_data': str(minimum_data),
             'window_size': self.window_size,
             'gap': gap,
         })

composeml/label_plots.py

@@ -78,7 +78,7 @@ def distribution(self, **kwargs):
         """Plots the label distribution."""
         dist = self._label_times[self._label_times.name]
 
-        if self._label_times.is_categorical:
+        if self._label_times.label_type == 'discrete':
             ax = sns.countplot(dist, palette=COLOR, **kwargs)
         else:
             ax = sns.distplot(dist, kde=True, color=COLOR[1], **kwargs)

composeml/label_times.py

@@ -11,9 +11,17 @@ class LabelTimes(pd.DataFrame):
         target_entity
         transforms
     """
-    _metadata = ['name', 'target_entity', 'settings', 'transforms']
-
-    def __init__(self, data=None, name=None, target_entity=None, settings=None, transforms=None, *args, **kwargs):
+    _metadata = ['name', 'target_entity', 'settings', 'transforms', 'label_type']
+
+    def __init__(self,
+                 data=None,
+                 name=None,
+                 target_entity=None,
+                 settings=None,
+                 transforms=None,
+                 label_type=None,
+                 *args,
+                 **kwargs):
         super().__init__(data=data, *args, **kwargs)
 
         self.name = name
@@ -22,20 +30,44 @@ def __init__(self, data=None, name=None, target_entity=None, settings=None, tran
         self.transforms = transforms or []
         self.plot = LabelPlots(self)
 
+        if label_type is not None:
+            error = 'label type must be "continuous" or "discrete"'
+            assert label_type in ['continuous', 'discrete'], error
+
+        if label_type is None and name in self.columns:
+            label_type = self.infer_type()
+
+        self.label_type = label_type
+        self.settings['label_type'] = self.label_type
+
     @property
     def _constructor(self):
         return LabelTimes
 
     @property
-    def is_categorical(self):
-        """Whether labels are categorical."""
+    def is_discrete(self):
+        """Whether labels are discrete."""
         dtype = self[self.name].dtype
-        return pd.api.types.is_categorical_dtype(dtype)
+
+        is_discrete = pd.api.types.is_bool_dtype(dtype) \
+            or pd.api.types.is_categorical_dtype(dtype) \
+            or pd.api.types.is_object_dtype(dtype)
+
+        if is_discrete:
+            return True
+
+        labels = self[self.name].iloc[:100]
+        is_discrete = labels.nunique() / len(labels) <= .5
+
+        if is_discrete:
+            return True
+
+        return False
 
     @property
     def distribution(self):
         """Returns label distribution if labels are discrete."""
-        if self.is_categorical:
+        if self.label_type == 'discrete':
             labels = self.assign(count=1)
             labels = labels.groupby(self.name)
             distribution = labels['count'].count()
@@ -44,7 +76,7 @@ def distribution(self):
     @property
     def count_by_time(self):
         """Returns label count across cutoff times."""
-        if self.is_categorical:
+        if self.label_type == 'discrete':
             keys = ['cutoff_time', self.name]
             value = self.groupby(keys).cutoff_time.count()
             value = value.unstack(self.name).fillna(0)
@@ -58,7 +90,7 @@ def count_by_time(self):
 
     def describe(self):
         """Prints out label info with transform settings that reproduce labels."""
-        if self.is_categorical:
+        if self.label_type == 'discrete':
             print('Label Distribution\n' + '-' * 18, end='\n')
             distribution = self[self.name].value_counts()
             distribution.index = distribution.index.astype('str')
@@ -110,7 +142,9 @@ def threshold(self, value, inplace=False):
         """
         labels = self if inplace else self.copy()
         labels[self.name] = labels[self.name].gt(value)
-        labels.infer_type()
+
+        labels.label_type = 'discrete'
+        labels.settings['label_type'] = 'discrete'
 
         transform = {'__name__': 'threshold', 'value': value}
         labels.transforms.append(transform)
@@ -222,6 +256,7 @@ def bin(self, bins, quantiles=False, labels=None, right=True):
         }
 
         label_times.transforms.append(transform)
+        label_times.label_type = 'discrete'
         return label_times
 
     def sample(self, n=None, frac=None, random_state=None):
@@ -320,16 +355,9 @@ def infer_type(self):
         """Infer label type.
 
         Returns:
-            LabelTimes : Label Times as inferred type.
+            str : Inferred label type. Can be "continuous" or "discrete".
         """
-        if self.is_categorical:
-            return self
-
-        labels = self[self.name].iloc[:100]
-        is_category_like = pd.api.types.is_bool_dtype(labels.dtype) or pd.api.types.is_object_dtype(labels.dtype)
-
-        if is_category_like or labels.nunique() / len(labels) <= .5:
-            self[self.name] = self[self.name].astype('category')
-            return self
-
-        return self
+        if self.is_discrete:
+            return 'discrete'
+        else:
+            return 'continuous'

composeml/tests/test_label_maker.py

@@ -430,5 +430,5 @@ def test_slice_overlap(transactions):
 
 def test_label_type(transactions):
     lm = LabelMaker(target_entity='customer_id', time_index='time', labeling_function=total_spent)
-    lt = lm.search(transactions, num_examples_per_instance=1, label_type='categorical', verbose=False)
-    assert lt.is_categorical
+    lt = lm.search(transactions, num_examples_per_instance=1, label_type='discrete', verbose=False)
+    assert lt.label_type == 'discrete'

composeml/tests/test_label_times.py

@@ -70,5 +70,5 @@ def test_distribution_continous(total_spent):
 
 
 def test_infer_type(total_spent):
-    assert total_spent.threshold(5).is_categorical
-    assert total_spent.bin(2).infer_type().is_categorical
+    assert total_spent.threshold(5).is_discrete
+    assert total_spent.bin(2).is_discrete