Merge pull request #9 from davidwarshaw/empty-fit-bug

Fixed empty DM on fit bug. Conform to pep8.

Author: davidwarshaw

hmc/__init__.py

@@ -4,12 +4,15 @@
 from .datasets import load_shades_class_hierachy
 from .datasets import load_shades_data
 from .metrics import accuracy_score
+from .exceptions import *
+
 
 __all__ = ["ClassHierarchy",
-    "DecisionTreeHierarchicalClassifier",
-    "load_shades_class_hierachy",
-    "load_shades_data",
-    "accuracy_score",
-    "precision_score_ancestors", "recall_score_ancestors",
-    "precision_score_descendants", "recall_score_descendants",
-    "f1_score_ancestors", "f1_score_descendants"]
+           "DecisionTreeHierarchicalClassifier",
+           "load_shades_class_hierachy",
+           "load_shades_data",
+           "accuracy_score",
+           "precision_score_ancestors", "recall_score_ancestors",
+           "precision_score_descendants", "recall_score_descendants",
+           "f1_score_ancestors", "f1_score_descendants",
+           "NoSamplesForStageWarning", "StageNotFitWarning", "ClassifierNotFitError"]

hmc/datasets.py

@@ -10,29 +10,30 @@
 from hmc import DecisionTreeHierarchicalClassifier
 
 seeds = [
-    {"node":"dark",
-        "mu_1":0, "mu_2":10, "mu_3":0,
-        "sigma_1":4, "sigma_2":4, "sigma_3":4},
-    {"node":"black",
-        "mu_1":1, "mu_2":9, "mu_3":1,
-        "sigma_1":3, "sigma_2":3, "sigma_3":3},
-    {"node":"gray",
-        "mu_1":2, "mu_2":8, "mu_3":2,
-        "sigma_1":2, "sigma_2":2, "sigma_3":2},
-    {"node":"ash",
-        "mu_1":3, "mu_2":7, "mu_3":3,
-        "sigma_1":1, "sigma_2":1, "sigma_3":1},
-    {"node":"slate",
-        "mu_1":4, "mu_2":8, "mu_3":2,
-        "sigma_1":1, "sigma_2":1, "sigma_3":1},
-    {"node":"light",
-        "mu_1":10, "mu_2":0, "mu_3":10,
-        "sigma_1":4, "sigma_2":4, "sigma_3":4},
-    {"node":"white",
-        "mu_1":9, "mu_2":1, "mu_3":9,
-        "sigma_1":3, "sigma_2":3, "sigma_3":3},
+    {"node":  "dark",
+        "mu_1": 0, "mu_2": 10, "mu_3": 0,
+        "sigma_1": 4, "sigma_2": 4, "sigma_3": 4},
+    {"node": "black",
+        "mu_1": 1, "mu_2": 9, "mu_3": 1,
+        "sigma_1": 3, "sigma_2": 3, "sigma_3": 3},
+    {"node": "gray",
+        "mu_1": 2, "mu_2": 8, "mu_3": 2,
+        "sigma_1": 2, "sigma_2": 2, "sigma_3": 2},
+    {"node": "ash",
+        "mu_1": 3, "mu_2": 7, "mu_3": 3,
+        "sigma_1": 1, "sigma_2": 1, "sigma_3": 1},
+    {"node": "slate",
+        "mu_1": 4, "mu_2": 8, "mu_3": 2,
+        "sigma_1": 1, "sigma_2": 1, "sigma_3": 1},
+    {"node": "light",
+        "mu_1": 10, "mu_2": 0, "mu_3": 10,
+        "sigma_1": 4, "sigma_2": 4, "sigma_3": 4},
+    {"node": "white",
+        "mu_1": 9, "mu_2": 1, "mu_3": 9,
+        "sigma_1": 3, "sigma_2": 3, "sigma_3": 3},
 ]
 
+
 def load_shades_class_hierachy():
     ch = ClassHierarchy("colors")
     ch.add_node("light", "colors")
@@ -44,10 +45,11 @@ def load_shades_class_hierachy():
     ch.add_node("ash", "gray")
     return ch
 
+
 def load_shades_data(random_seed=1):
     random.seed(random_seed)
     data_rows = []
-    label_rows =[]
+    label_rows = []
     for seed in seeds:
         for i in range(0, int(100 + 100 * random.random())):
             data_row = {}

hmc/exceptions.py

@@ -0,0 +1,28 @@
+"""
+Exceptions and warnings particular to hierachical multi-classification.
+"""
+
+__all__ = ["NoSamplesForStageWarning", "StageNotFitWarning", "ClassifierNotFitError"]
+
+
+class NoSamplesForStageWarning(UserWarning):
+    """Warning used to notify that classification stage has no eligible samples.
+    This warning happens when no samples in the input set (the design matrix) are eligible for
+    classification at the current stage. This can happen during training or prediction if no
+    samples are in, or descend from, the class in the class hierarchy corresponding to the stage.
+    """
+
+
+class StageNotFitWarning(UserWarning):
+    """Warning used to notify that no estimator was fit for the classification stage.
+    This warning happens when samples are eligible for prediction at a classification stage that
+    was not fit when the hierachical classifier was fit. This can happen if the training set used
+    to fit the hierachical classifier had no samples in, or descending from, the class in the
+    class hierarchy corresponding to the stage.
+    """
+
+
+class ClassifierNotFitError(ValueError):
+    """Warning used to notify that no estimators were fit for the hierachical classifier.
+    This warning happens when the hierachical classifier is exploited without first being fit.
+    """

hmc/hmc.py

@@ -5,19 +5,23 @@
 from __future__ import print_function
 from __future__ import division
 
+import warnings
+
 from sklearn import tree
 
 import numpy as np
 import pandas as pd
 
 import metrics
+from exceptions import *
 
 __all__ = ["ClassHierarchy", "DecisionTreeHierarchicalClassifier"]
 
 # =============================================================================
 # Class Hierarchy
 # =============================================================================
 
+
 class ClassHierarchy:
     """
     Class for class heirarchy.
@@ -40,7 +44,8 @@ def _get_parent(self, child):
 
     def _get_children(self, parent):
         # Return a list of children nodes in alpha order
-        return sorted([child for child, childs_parent in self.nodes.iteritems() if childs_parent == parent])
+        return sorted([child for child, childs_parent in
+                       self.nodes.iteritems() if childs_parent == parent])
 
     def _get_ancestors(self, child):
         # Return a list of the ancestors of this node
@@ -97,7 +102,8 @@ def add_node(self, child, parent):
             raise ValueError('The hierarchy root: ' + str(child) + ' is not a valid child node.')
         if child in self.nodes.keys():
             if self.nodes[child] != parent:
-                raise ValueError('Node: ' + str(child) + ' has already been assigned parnet: ' + str(child) )
+                raise ValueError('Node: ' + str(child) + ' has already been assigned parent: ' +
+                                 str(child))
             else:
                 return
         self.nodes[child] = parent
@@ -126,6 +132,7 @@ def print_(self):
 # Decision Tree Hierarchical Classifier
 # =============================================================================
 
+
 class DecisionTreeHierarchicalClassifier:
 
     def __init__(self, class_hierarchy):
@@ -145,7 +152,8 @@ def _depth_first_class_prob(self, tree, node, indent, last, hand):
             indent += u"\u2502   "
         print(hand + " " + str(node))
         for k, count in enumerate(tree.tree_.value[node][0]):
-            print(indent + str(tree.classes_[k]) + ":" + str(stage(count / tree.tree_.n_node_samples[node], 2)))
+            print(indent + str(tree.classes_[k]) + ":" +
+                  str(stage(count / tree.tree_.n_node_samples[node], 2)))
         self._depth_first_class_prob(tree, tree.tree_.children_right[node], indent, False, "R")
         self._depth_first_class_prob(tree, tree.tree_.children_left[node], indent, True, "L")
 
@@ -183,8 +191,7 @@ def _prep_data(self, X, y):
         for stage_number, stage in enumerate(self.stages):
             df[stage['target']] = pd.DataFrame.apply(
                 df[[target]],
-                lambda row: self._recode_label(stage['classes'],
-                row[target]),
+                lambda row: self._recode_label(stage['classes'], row[target]),
                 axis=1)
         return df, dm_cols
 
@@ -196,27 +203,41 @@ def fit(self, X, y):
         df, dm_cols = self._prep_data(X, y)
         # Fit each stage
         for stage_number, stage in enumerate(self.stages):
+            dm = df[df[stage['target']].isin(stage['classes'])][dm_cols]
+            y_stage = df[df[stage['target']].isin(stage['classes'])][[stage['target']]]
             stage['tree'] = tree.DecisionTreeClassifier()
-            stage['tree'] = stage['tree'].fit(
-                df[df[stage['target']].isin(stage['classes'])][dm_cols],
-                df[df[stage['target']].isin(stage['classes'])][[stage['target']]])
+            if dm.empty:
+                warnings.warn('No samples to fit for stage ' + str(stage['stage']),
+                              NoSamplesForStageWarning)
+                continue
+            stage['tree'] = stage['tree'].fit(dm, y_stage)
         return self
 
     def _check_fit(self):
         for stage in self.stages:
             if 'tree' not in stage.keys():
-                raise ValueError('Estimators not fitted, call `fit` before exploiting the model.')
+                raise ClassifierNotFitError(
+                    'Estimators not fitted, call `fit` before exploiting the model.')
 
     def _predict_stages(self, X):
         # Score each stage
         for stage_number, stage in enumerate(self.stages):
             if stage_number == 0:
-                y_hat = pd.DataFrame([self.class_hierarchy.root] * len(X), columns=[self.class_hierarchy.root], index=X.index)
+                y_hat = pd.DataFrame(
+                    [self.class_hierarchy.root] * len(X),
+                    columns=[self.class_hierarchy.root],
+                    index=X.index)
             else:
                 y_hat[stage['stage']] = y_hat[self.stages[stage_number - 1]['stage']]
             dm = X[y_hat[stage['stage']].isin([stage['stage']])]
             # Skip empty matrices
             if dm.empty:
+                warnings.warn('No samples to predict for stage ' + str(stage['stage']),
+                              NoSamplesForStageWarning)
+                continue
+            if not stage['tree'].tree_:
+                warnings.warn('No tree was fit for stage ' + str(stage['stage']),
+                              StageNotFitWarning)
                 continue
             # combine_first reorders DataFrames, so we have to do this the ugly way
             y_hat_stage = pd.DataFrame(stage['tree'].predict(dm), index=dm.index)

hmc/metrics.py

@@ -16,6 +16,7 @@
 import numpy as np
 import pandas as pd
 
+
 def _check_targets_hmc(y_true, y_pred):
     check_consistent_length(y_true, y_pred)
     y_type = set([type_of_target(y_true), type_of_target(y_pred)])
@@ -27,13 +28,15 @@ def _check_targets_hmc(y_true, y_pred):
     y_pred = column_or_1d(y_pred)
     return y_true, y_pred
 
-## General Scores
+
+# General Scores
 # Average accuracy
 def accuracy_score(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
     return skmetrics.accuracy_score(y_true, y_pred)
 
-## Hierarchy Precision / Recall
+
+# Hierarchy Precision / Recall
 def _aggregate_class_sets(set_function, y_true, y_pred):
     intersection_sum = 0
     true_sum = 0
@@ -46,32 +49,41 @@ def _aggregate_class_sets(set_function, y_true, y_pred):
         predicted_sum += len(pred_set)
     return (true_sum, predicted_sum, intersection_sum)
 
+
 # Ancestors Scores (Super Class)
 # Precision
 def precision_score_ancestors(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
-    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(class_hierarchy._get_ancestors, y_true, y_pred)
+    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(
+        class_hierarchy._get_ancestors, y_true, y_pred)
     return intersection_sum / predicted_sum
 
+
 # Recall
 def recall_score_ancestors(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
-    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(class_hierarchy._get_ancestors, y_true, y_pred)
+    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(
+        class_hierarchy._get_ancestors, y_true, y_pred)
     return intersection_sum / true_sum
 
+
 # Descendants Scores (Sub Class)
 # Precision
 def precision_score_descendants(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
-    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(class_hierarchy._get_descendants, y_true, y_pred)
+    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(
+        class_hierarchy._get_descendants, y_true, y_pred)
     return intersection_sum / predicted_sum
 
+
 # Recall
 def recall_score_descendants(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
-    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(class_hierarchy._get_descendants, y_true, y_pred)
+    true_sum, predicted_sum, intersection_sum = _aggregate_class_sets(
+        class_hierarchy._get_descendants, y_true, y_pred)
     return intersection_sum / true_sum
 
+
 # Hierarchy Fscore
 def _fbeta_score_class_sets(set_function, y_true, y_pred, beta=1):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
@@ -80,10 +92,12 @@ def _fbeta_score_class_sets(set_function, y_true, y_pred, beta=1):
     recall = intersection_sum / true_sum
     return ((beta ** 2 + 1) * precision * recall) / ((beta ** 2 * precision) + recall)
 
+
 def f1_score_ancestors(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
     return _fbeta_score_class_sets(class_hierarchy._get_ancestors, y_true, y_pred)
 
+
 def f1_score_descendants(class_hierarchy, y_true, y_pred):
     y_true, y_pred = _check_targets_hmc(y_true, y_pred)
     return _fbeta_score_class_sets(class_hierarchy._get_descendants, y_true, y_pred)

setup.py

@@ -3,10 +3,10 @@
 from setuptools import setup
 
 setup(name='hmc',
-      version='0.2',
+      version='0.3',
       description='Decision tree based hierachical multi-classifier',
       url='https://github.com/davidwarshaw/hmc',
       author='David Warshaw',
       author_email='[email protected]',
-      py_modules=['hmc.hmc', 'hmc.datasets', 'hmc.metrics'],
+      py_modules=['hmc.hmc', 'hmc.datasets', 'hmc.metrics', 'hmc.exceptions'],
       requires=['sklearn', 'numpy', 'pandas'])

tests/test_hmc.py

@@ -10,6 +10,8 @@
 from sklearn.cross_validation import train_test_split
 
 import hmc
+from hmc.exceptions import *
+
 
 class TestClassHierarchy(unittest.TestCase):
 
@@ -66,6 +68,7 @@ def test_add_dag_node(self):
         # Adding a child with a new parent should throw an exception
         self.assertRaises(ValueError, ch.add_node, "slate", "light")
 
+
 class TestDecisionTreeHierarchicalClassifier(unittest.TestCase):
 
     def test_fit(self):
@@ -103,15 +106,15 @@ def row_is_hierarchical(row):
             return is_hierarchical
 
         stage_predictions = dt._predict_stages(X)
-        stage_predictions['Hierarchical'] = stage_predictions.apply(lambda row: row_is_hierarchical(row), axis=1)
+        stage_predictions['Hierarchical'] = stage_predictions.apply(
+            lambda row: row_is_hierarchical(row), axis=1)
         # Each stage of classification should descend from the previous class
         self.assertEqual(len(stage_predictions[stage_predictions['Hierarchical'] != True]), 0)
 
     def test_score(self):
         ch = hmc.load_shades_class_hierachy()
         X, y = hmc.load_shades_data()
-        X_train, X_test, y_train, y_test = train_test_split(X, y,
-            test_size = 0.50, random_state = 0)
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.50, random_state=0)
         dt = hmc.DecisionTreeHierarchicalClassifier(ch)
         dt_nonh = tree.DecisionTreeClassifier()
         dt = dt.fit(X_train, y_train)
@@ -126,7 +129,8 @@ def test_score_before_fit(self):
         X, y = hmc.load_shades_data()
         dt = hmc.DecisionTreeHierarchicalClassifier(ch)
         # Scoring without fitting should raise exception
-        self.assertRaises(ValueError, dt.score, X, y)
+        self.assertRaises(ClassifierNotFitError, dt.score, X, y)
+
 
 if __name__ == '__main__':
     unittest.main()