changed init_conds to search_space because it's a flashier, more memorable, descriptive variable name

Author: pavelkomarov

pynumdiff/optimize/_optimize.py

@@ -14,7 +14,7 @@
 from ..kalman_smooth import constant_velocity, constant_acceleration, constant_jerk
 
 
-# Map from method -> (init_conds, bounds_low_hi)
+# Map from method -> (search_space, bounds_low_hi)
 method_params_and_bounds = {
     spectraldiff: ({'even_extension': True,
                    'pad_to_zero_dxdt': True,
@@ -87,7 +87,7 @@
     method_params_and_bounds[method] = method_params_and_bounds[constant_velocity]
 
 
-# This function to be at the top level for multiprocessing
+# This function has to be at the top level for multiprocessing
 def _objective_function(point, func, x, dt, singleton_params, search_space_types, dxdt_truth, metric,
     tvgamma, padding):
     """Function minimized by scipy.optimize.minimize, needs to have the form: (point, *args) -> float
@@ -119,14 +119,14 @@ def _objective_function(point, func, x, dt, singleton_params, search_space_types
         return rms_rec_x + tvgamma*evaluate.total_variation(dxdt_hat, padding=padding)
 
 
-def optimize(func, x, dt, init_conds={}, dxdt_truth=None, tvgamma=1e-2, padding='auto', metric='rmse',
+def optimize(func, x, dt, search_space={}, dxdt_truth=None, tvgamma=1e-2, padding='auto', metric='rmse',
     opt_method='Nelder-Mead', maxiter=10):
     """Find the optimal parameters for a given differentiation method.
 
     :param function func: differentiation method to optimize parameters for, e.g. linear_model.savgoldiff
     :param np.array[float]: data to differentiate
     :param float dt: step size
-    :param dict init_conds: function parameter settings to use as initial starting points in optimization,
+    :param dict search_space: function parameter settings to use as initial starting points in optimization,
                     structured as :code:`{param1:[values], param2:[values], param3:value, ...}`. The search space
                     is the Cartesian product. If left None, a default search space of initial values is used.
     :param np.array[float] dxdt_truth: actual time series of the derivative of x, if known
@@ -150,7 +150,7 @@ def optimize(func, x, dt, init_conds={}, dxdt_truth=None, tvgamma=1e-2, padding=
         raise ValueError('`metric` can only be `error_correlation` if `dxdt_truth` is given.')
 
     params, bounds = method_params_and_bounds[func]
-    params.update(init_conds) # for things not given, use defaults
+    params.update(search_space) # for things not given, use defaults
 
     # No need to optimize over singletons, just pass them through
     singleton_params = {k:v for k,v in params.items() if not isinstance(v, list)}
@@ -160,7 +160,7 @@ def optimize(func, x, dt, init_conds={}, dxdt_truth=None, tvgamma=1e-2, padding=
     if any(v not in [float, int, bool] for v in search_space_types.values()):
         raise ValueError("Optimization over categorical strings currently not supported")
     # If excluding string type, I can just cast ints and bools to floats, and we're good to go
-    search_space = product(*[np.array(params[k]).astype(float) for k in search_space_types])
+    cartesian_product = product(*[np.array(params[k]).astype(float) for k in search_space_types])
 
     bounds = [bounds[k] if k in bounds else # pass these to minimize(). It should respect them.
              (0, 1) if v == bool else
@@ -173,7 +173,7 @@ def optimize(func, x, dt, init_conds={}, dxdt_truth=None, tvgamma=1e-2, padding=
     _minimize = partial(scipy.optimize.minimize, _obj_fun, method=opt_method, bounds=bounds, options={'maxiter':maxiter})
 
     with Pool(initializer=filterwarnings, initargs=["ignore", '', UserWarning]) as pool: # The heavy lifting
-        results = pool.map(_minimize, search_space) # returns a bunch of OptimizeResult objects
+        results = pool.map(_minimize, cartesian_product) # returns a bunch of OptimizeResult objects
 
     opt_idx = np.nanargmin([r.fun for r in results])
     opt_point = results[opt_idx].x

pynumdiff/tests/test_optimize.py

@@ -24,32 +24,32 @@ def test_finite_difference():
     assert params2['num_iterations'] == 1
 
 def test_mediandiff():
-    params1, val1 = optimize(mediandiff, x, dt, init_conds={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
-    params2, val2 = optimize(mediandiff, x, dt, init_conds={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
+    params1, val1 = optimize(mediandiff, x, dt, search_space={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
+    params2, val2 = optimize(mediandiff, x, dt, search_space={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
     assert params1['window_size'] == 5
     assert params2['window_size'] == 1
 
 def test_meandiff():
-    params1, val1 = optimize(meandiff, x, dt, init_conds={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
-    params2, val2 = optimize(meandiff, x, dt, init_conds={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
+    params1, val1 = optimize(meandiff, x, dt, search_space={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
+    params2, val2 = optimize(meandiff, x, dt, search_space={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
     assert params1['window_size'] == 5
     assert params2['window_size'] == 1
 
 def test_gaussiandiff():
-    params1, val1 = optimize(gaussiandiff, x, dt, init_conds={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
-    params2, val2 = optimize(gaussiandiff, x, dt, init_conds={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
+    params1, val1 = optimize(gaussiandiff, x, dt, search_space={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
+    params2, val2 = optimize(gaussiandiff, x, dt, search_space={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
     assert params1['window_size'] == 9
     assert params2['window_size'] == 1
 
 def test_friedrichsdiff():
-    params1, val1 = optimize(friedrichsdiff, x, dt, init_conds={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
-    params2, val2 = optimize(friedrichsdiff, x, dt, init_conds={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
+    params1, val1 = optimize(friedrichsdiff, x, dt, search_space={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
+    params2, val2 = optimize(friedrichsdiff, x, dt, search_space={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
     assert params1['window_size'] == 9
     assert params2['window_size'] == 1
 
 def test_butterdiff():
-    params1, val1 = optimize(butterdiff, x, dt, init_conds={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth, maxiter=20)
-    params2, val2 = optimize(butterdiff, x, dt, init_conds={'num_iterations':1}, tvgamma=0, dxdt_truth=None, maxiter=20)
+    params1, val1 = optimize(butterdiff, x, dt, search_space={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth, maxiter=20)
+    params2, val2 = optimize(butterdiff, x, dt, search_space={'num_iterations':1}, tvgamma=0, dxdt_truth=None, maxiter=20)
 
     assert params1['filter_order'] == 8 or params1['filter_order'] == 9
     np.testing.assert_almost_equal(params1['cutoff_freq'], 0.161, decimal=3)
@@ -66,8 +66,8 @@ def test_splinediff():
     np.testing.assert_almost_equal(params2['s'], 0.01, decimal=3)
 
 def test_iterative_velocity():
-    params1, val1 = optimize(iterative_velocity, x, dt, init_conds={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
-    params2, val2 = optimize(iterative_velocity, x, dt, init_conds={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
+    params1, val1 = optimize(iterative_velocity, x, dt, search_space={'num_iterations':1}, tvgamma=tvgamma, dxdt_truth=dxdt_truth)
+    params2, val2 = optimize(iterative_velocity, x, dt, search_space={'num_iterations':1}, tvgamma=0, dxdt_truth=None)
 
     np.testing.assert_almost_equal(params1['gamma'], 0.0001, decimal=4)
     np.testing.assert_almost_equal(params2['gamma'], 0.0001, decimal=4)