Merge pull request AustinRochford#12 from AustinRochford/_-private-functions

Prefix private functions with _

Author: AustinRochford

pycebox/ice.py

@@ -8,7 +8,7 @@
 import pandas as pd
 
 
-def get_grid_points(x, num_grid_points):
+def _get_grid_points(x, num_grid_points):
     if num_grid_points is None:
         return x.unique()
     else:
@@ -18,7 +18,7 @@ def get_grid_points(x, num_grid_points):
         return x.quantile(np.linspace(0, 1, num_grid_points)).unique()
 
 
-def get_point_x_ilocs(grid_index, data_index):
+def _get_point_x_ilocs(grid_index, data_index):
     data_level = 'data_{}'.format(grid_index.name)
 
     return (np.abs(np.subtract
@@ -27,7 +27,7 @@ def get_point_x_ilocs(grid_index, data_index):
               .argmin(axis=0))
 
 
-def get_quantiles(x):
+def _get_quantiles(x):
     return np.greater.outer(x, x).sum(axis=1) / x.size
 
 
@@ -41,8 +41,8 @@ def ice(data, column, predict, num_grid_points=None):
     If num_grid_points is None, column varies over its unique values in data.
     If num_grid_points is not None, column varies over num_grid_pts values, evenly spaced at its quantiles in data.
     """
-    x_s = get_grid_points(data[column], num_grid_points)
-    ice_data, orig_column = to_ice_data(data, column, x_s)
+    x_s = _get_grid_points(data[column], num_grid_points)
+    ice_data, orig_column = _to_ice_data(data, column, x_s)
     ice_data['ice_y'] = predict(ice_data.values)
     ice_data['data_{}'.format(column)] = orig_column
 
@@ -90,7 +90,7 @@ def ice_plot(ice_data, frac_to_plot=1.,
         ice_data = ice_data.sort_index()
 
     if centered:
-        quantiles = get_quantiles(ice_data.index)
+        quantiles = __get_quantiles(ice_data.index)
         centered_quantile_iloc = np.abs(quantiles - centered_quantile).argmin()
         ice_data = ice_data - ice_data.iloc[centered_quantile_iloc]
 
@@ -103,12 +103,12 @@ def ice_plot(ice_data, frac_to_plot=1.,
 
 
     if x_quantile:
-        x = get_quantiles(ice_data.index)
+        x = __get_quantiles(ice_data.index)
     else:
         x = ice_data.index
 
     if plot_points:
-        point_x_ilocs = get_point_x_ilocs(plot_ice_data.index, plot_ice_data.columns)
+        point_x_ilocs = _get_point_x_ilocs(plot_ice_data.index, plot_ice_data.columns)
         point_x = x[point_x_ilocs]
         point_y = plot_ice_data.values[point_x_ilocs, np.arange(point_x_ilocs.size)]
 
@@ -151,7 +151,7 @@ def pdp(ice_data):
     return ice_data.mean(axis=1)
 
 
-def to_ice_data(data, column, x_s):
+def _to_ice_data(data, column, x_s):
     """
     Create the DataFrame necessary for ICE calculations
     """

test/test.py

@@ -18,39 +18,39 @@ def compare_with_NaN(x, y):
 
 
 # tests
-def test_get_grid_points_num_grid_points():
+def test__get_grid_points_num_grid_points():
     x = pd.Series(np.array([0, 0, 1, 2, 3, 4, 5, 6, 7]))
     expected_grid_points = np.array([0, 1, 3, 5, 7])
 
-    assert (expected_grid_points == ice.get_grid_points(x, 5)).all()
+    assert (expected_grid_points == ice._get_grid_points(x, 5)).all()
 
 
-def test_get_grid_points_num_grid_points_too_many():
+def test__get_grid_points_num_grid_points_too_many():
     x = pd.Series(np.array([0, 0, 1]))
     expected_grid_points = np.array([0, 0.5, 1])
 
-    assert (expected_grid_points == ice.get_grid_points(x, 5)).all()
+    assert (expected_grid_points == ice._get_grid_points(x, 5)).all()
 
 
 @given(st.lists(st.floats()))
-def test_get_grid_points_num_grid_points_None(l):
+def test__get_grid_points_num_grid_points_None(l):
     x = pd.Series(l)
 
-    assert compare_with_NaN(x.unique(), ice.get_grid_points(x, None)).all()
+    assert compare_with_NaN(x.unique(), ice._get_grid_points(x, None)).all()
 
 
 @given((st.tuples(st.integers(min_value=2, max_value=10))
           .flatmap(lambda size: arrays(np.float64, size))),
        (st.tuples(st.integers(min_value=2, max_value=10))
           .flatmap(lambda size: arrays(np.float64, size))))
-def test_get_point_x_ilocs(grid, data):
+def test__get_point_x_ilocs(grid, data):
     assume(np.isfinite(grid).all())
     assume(np.isfinite(data).all())
 
     grid_index = pd.Float64Index(grid, name='x')
     data_index = pd.Float64Index(data, name='data_x')
 
-    point_x_ilocs = ice.get_point_x_ilocs(grid_index, data_index)
+    point_x_ilocs = ice._get_point_x_ilocs(grid_index, data_index)
 
     diffs = np.subtract.outer(grid, data)
 
@@ -118,14 +118,14 @@ def test_pdp(args):
     assert compare_with_NaN(pdp, pdp_expected).all()
 
 
-def test_to_ice_data():
+def test__to_ice_data():
     X = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
     data = pd.DataFrame(X, columns=['x1', 'x2', 'x3'])
     x_s = np.array([10, 11])
 
-    ice_data, orig_column = ice.to_ice_data(data, 'x3', x_s)
+    ice_data, orig_column = ice._to_ice_data(data, 'x3', x_s)
     ice_data_expected = pd.DataFrame(np.array([[1, 2, 10],
                                                [1, 2, 11],
                                                [4, 5, 10],
@@ -144,12 +144,12 @@ def test_to_ice_data():
           .flatmap(lambda size: arrays(np.float64, (1,) + size))),
        (st.tuples(st.integers(min_value=1, max_value=10))
           .flatmap(lambda shape: arrays(np.float64, shape))))
-def test_to_ice_data_one_sample(X, x_s):
+def test__to_ice_data_one_sample(X, x_s):
     n_cols = X.shape[1]
     columns = ['x{}'.format(i) for i in range(n_cols)]
     data = pd.DataFrame(X, columns=list(columns))
 
-    ice_data, orig_column = ice.to_ice_data(data, 'x1', x_s)
+    ice_data, orig_column = ice._to_ice_data(data, 'x1', x_s)
 
     ice_data_expected_values = np.repeat(X, x_s.size, axis=0)
     ice_data_expected_values[:, 1] = x_s
@@ -165,14 +165,14 @@ def test_to_ice_data_one_sample(X, x_s):
                   st.integers(min_value=2, max_value=10))
           .flatmap(lambda shape: arrays(np.float64, shape))),
        st.floats())
-def test_to_ice_data_one_test_point(l, x_s):
+def test__to_ice_data_one_test_point(l, x_s):
     X = np.array(l)
     n_cols = X.shape[1]
     columns = ['x{}'.format(i) for i in range(n_cols)]
     data = pd.DataFrame(X, columns=columns)
     x_s = np.array(x_s)
 
-    ice_data, orig_column = ice.to_ice_data(data, 'x0', x_s)
+    ice_data, orig_column = ice._to_ice_data(data, 'x0', x_s)
 
     ice_data_expected_values = X.copy()
     ice_data_expected_values[:, 0] = x_s