Rewrote all modules to conform to PEP 8

Author: panchoop

src/DGCG.py

@@ -73,6 +73,7 @@ def set_model_parameters(alpha, beta, time_samples, H_dimensions,
     operators.test_func = test_func
     operators.grad_test_func = grad_test_func
 
+
 def solve(data, **kwargs):
     """Method to solve the given dynamic inverse problem for input data.
 
@@ -148,9 +149,7 @@ def solve(data, **kwargs):
     # Set the parameters
     if not params['use_ffmpeg']:
         print("WARNING: ffmpeg disabled. Videos of animations cannot be saved")
-        misc.use_ffmpeg = params['use_ffmpeg']
-    else:
-        misc.use_ffmpeg = True
+        config.use_ffmpeg = params['use_ffmpeg']
     if params['insertion_max_restarts'] < params['insertion_min_restarts']:
         raise Exception("insertion_max_restarts < insertion_min_restarts." +
                         "The execution is aborted")
@@ -202,21 +201,21 @@ def solve(data, **kwargs):
     return current_measure, (0, 'FAILURE: unable to reach a solution')
 
 
-
-
 def test_func_check(func):
     """Tests if the dimensions of the given test function φ fit the model.
     """
     # <+to_implement+>
     return True
 
+
 def test_grad_func_check(grad_func):
     """Tests if the dimensions of the given test function gradient ∇φ fit.
     """
     # <+to_implement+>
     return True
 
-if __name__=='__main__':
+
+if __name__ == ' __main__':
     pass
 
 

src/config.py

@@ -72,13 +72,121 @@
     declare that there are no available crossovers and then will propose a
     random curve for descent.
 crossover_child_F_threshold : numpy.float, default 0.8
-    
-
-
-    
-
-Extensive description of each parameter of this module
-
+    Obtained crossover curves will be proposed for descensen only if their
+    energy F(γ) is close to the best known stationary curve. How close it has
+    to be is modulated by this parameter, it must satisfy
+    F(crossover_child) < crossover_child_F_threshold * F(best_curve),
+    remember that the energies are negative.
+crossover_max_distance: numpy.float, default 0.05
+    Childs from two curves can be obtained only if at some point in time they
+    get close one to another, this parameter indicates how close they need to
+    get in H^1 norm for a crossover to happen.
+insertion_eps : numpy.float, defaylt 1e-10
+    This is the tolenrance value to stop the algorithm. If the dual gap drops
+    below it, the algorithm exits.
+insertion_max_restarts : int, default 20
+    The maximum number of restarts of the multistart algorithm.
+insertion_min_restarts : int, default 15
+    The minimum number of restarts of the multistart algorithm. This
+    parameter is useful only in the case an early stop criteria is set
+    via the `multistart_early_stop` parameter.
+multistart_inter_iteration_checkup : int, default 50
+    While descending a single curve during the multistart gradient descent,
+    the code will routinely check if curve being descended is close to the any
+    element of the stationary point set. If so, the descense is stopped
+    and the curve is discarded. This parameter regulates how often this
+    check is done. Precaution: The algorithm also is coded to "omit" the curves
+    that got too fast too close to the stationary point set. By "omiting", we
+    mean that such a descented curve will not count towards the number of
+    descented curves; "too fast" means that the curve got too close to the
+    statonary set before the first checkup. A consequence of this is that if
+    this checkup number is set too high, and there are a few stationary points,
+    then  (almost) all the descended curves will converge faster than the first
+    checkup and as such, they will not count towards the number of attempted
+    tries. Heavily slowing down the algorithm.
+multistart_max_discarded_tries : int, default 30
+    If more than multistart_max_discarded_tries curves are discarded
+    consecutively. Then the algorithm will issue a warning to set
+    `multistart_inter_iteration_checkup` higher and will add a counter
+    to the number of restarts. This is a failsafe against a `while true` loop.
+multistart_taboo_dist : numpy.float, default 0.01
+    The distance, in H^1 norm, of a curve to an element of the stationary
+    set to be discarded.
+multistart_energy_dist : numpy.float, default 0.01
+    Acceleration parameter to measure the distance between the descended curve
+    with those of the stationary set. The stationary point set is ordered by
+    their F(γ) value, which is also readily available in a list. Therefore by
+    computing the F(γ) value of the descended curve, one can just compare the
+    current curve with those around that value, this parameter defines that
+    radius.
+multistart_early_stop : lambda function, default constant equal to infinite
+    This parameter allows to pass an early stop criteria to the multistart
+    algorithm. The input is a two variable function whose first input is
+    the number of attempted restarts, and the second parameter is the number
+    of found stationary point. The multistart gradient descent will stop once
+    it either reaches the `insertion_max_restart` value, or the value given by
+    this function.
+multistart_proposition_max_iter : int, default 10000
+    Each proposed curve must start with negative energy, if it does not, it
+    is discarded and another curve is proposed. This parameter sets a limit on
+    how many attempts will be done.
+multistart_descent_max_iter : int, default 16000
+    This parameter limits the number of gradient descent steps that will be
+    done on each descended curve.
+multistart_descent_soft_max_iter : int, default 5000
+    This is a soft maximum number of iterations. If the currently descended
+    curve has done more than this number of iterations, and simultaneously its
+    energy is not "good enough", then the descense will be stopped.
+multistart_descent_soft_max_threshold : numpy.float, default 0.8
+    Sets the threshold to discard the current descended curve, the current
+    descended curve has to be at least this ratio closer to the best known
+    stationary curve.
+multistart_descent_init_step : numpy.float, default 1
+    The gradient descent uses an Armijo with backtracking descent. This
+    parameter sets the intiial stepsize/
+multistart_descent_limit_stepsize : numpy.float, default 1e-20
+    The gradient descent stops when the stepsize becomes smaller than this
+    value.
+H1_tolerance : numpy.float, default 1e-5
+    The quadratic optimization step will attempt to merge curves that are
+    closer than this distance in H1 norm.
+curves_list_length_lim : int, default 1000
+    The quadratic optimization step will take at most this number of stationary
+    point found in the insertion step.
+curves_list_length_min : int, default 10,
+    In the optimization step after the insertion step, the inserted curves are
+    the union of the already known curves, together with those found in the
+    multistart descent. This parameter sets least number of stationary curves
+    from the mutlistart descent that have to be added for optimization.
+CVXOPT_TOL : numpy_float, default 1e-25
+    CVXOPT is the used solver to tackle the quadratic optimization step. This
+    parameter defines the considered tolerance value for both the relative and
+    absolute errors.
+g_flow_opt_max_iter : int, default 100000
+    During the sliding step, this parameter modules the maximum number of
+    iterations to execute.
+g_flow_opt_in_between_iters : int, default 100
+    During the sliding step, in between iterations, the weights of the measure
+    are optomized via the optimization step. This parameter regulates how often
+    this is done.
+g_flow_init_step : numpy.float, default 1
+    The initial stepsize of the Armijo with Backtracking gradient descent
+    for the Sliding step.
+g_flow_limit_stepsize : numpy.float, defaylt 1e-20
+    During the sliding step, the descent stops once the stepsize reaches this
+    size.
+log_output : boolean, default False
+    Switch to log the convergence information into a .txt file into the
+    `results` folder. WARNING: requires rework, too many useless lines are
+    saved.
+save_output_each_N : int, default 1000
+    How often the saved logs will be saved. This parameter consider the number
+    of lines of the file.
+log_maximal_line_size : int, default 10000,
+    Maximum size of the logfile. If exceeded, the file is discarded.
+use_ffmpeg : Boolean, default True
+    Switch to use the ffmpeg library. This is required to save the obtained
+    curves and measures as videos.
 """
 # Standard imports
 import pickle
@@ -118,6 +226,7 @@ def self_pickle(filename):
 beta = 0.1
 # Problem data
 f_t = None
+multistart_max_discarded_tries = 30
 
 # Measures parameters
 measure_coefficient_too_low = 1e-18
@@ -135,7 +244,7 @@ def self_pickle(filename):
 crossover_consecutive_inserts = 30
 crossover_search_attempts = 1000
 crossover_child_F_threshold = 0.8
-switching_max_distance = 0.05
+crossover_max_distance = 0.05
 
 # Insertions step
 insertion_eps = 1e-10
@@ -144,11 +253,11 @@ def self_pickle(filename):
 insertion_max_restarts = 20
 insertion_min_restarts = 15
 multistart_inter_iteration_checkup = 50
+multistart_max_discarded_tries = 30
 multistart_taboo_dist = 0.01
 multistart_energy_dist = 0.01
 multistart_early_stop = lambda num_tries, num_found: np.inf
 multistart_proposition_max_iter = 10000
-multistart_max_discarded_tries = 30
 
 # multistart gradient descent parameters
 multistart_descent_max_iter = 16000
@@ -174,59 +283,5 @@ def self_pickle(filename):
 save_output_each_N = 1000
 log_maximal_line_size = 10000
 
-""" PARAMETER EXPLANATION GUIDE:
-
-* Problem coefficients
-alpha, beta > 0, are the regularization parameters of the underlying problem.
-
-* Curve and measures parameters
-curves_times_samples: the considered time discretization for the considered
-time-continuous curves in the time-continuous version of the problem
-measure_coefficient_too_low > 0, if a coefficient associated to some of the
-curves is too small, we consider the particular coefficient to be zero instead.
-
-* Whole algorithm parameters
-full_max_iteration. A complete iteration consists of an insertion step,
-merging step and flowing step. This number limits the number of complete
-iterations of the algorithm.
-
-* Max_curve parameters
-max_curve_x_res > 0 stands for the spatial resolution of the max_curve. The max
-curve is a curve that passes for each time through the maximum of the function
-w_t. Since afterwards the algorithm procedes to do a gradient descent, this
-maximum values can be chosen in a "less precise" way, therefore, instead of
-expensively finding the maximum at each step, a predefined spatial resolution
-is chosen and then the function w_t is discreetly sampled on a spatial grid
-with width defined by the max_curve_x_res parameter.
-
-* Step3 tabu search iteration parameters
-- step3_min_attempts_to_find_better_curve,
-- step3_max_attempts_to_find_better_curve
-At the step3, we need to find a curve that minimizes the target step3_energy.
-The problem is smooth but not convex. Therefore, the proposed approach is to
-shoot some curves and then descend them. By doing so, we are able to find local
-minima of the target functional. Empirically, it seems that it is not required
-to have the precise minimum of the functional, so these parameters basically
-allow to accelerate the algorithm trade-offing some sloppyness.
-step3_min_attempts_to_find_better_curve stands for the minimum number of
-attempts taken by the algorithm to find an acceptable curve to insert.
-If the algorithm does not find an acceptable curve to insert after this minimum
-number of tries, it will keep trying to find better candidates until reaching
-step3_max_attempts_to_find_better_curve. If this number is reached and no
-acceptable curve was found, the algorithm considers the true minimum to be
-already visited, and therefore the algorithm stops.
-- step3_tabu_in_between_iteration_condition_checkup
-- step3_tabu_dist
-The tabu search has an optimization step in which no all curves are descended
-to the fullest, as it is clear that they are descending to an already known
-local minimum. To do it so, the H1 norm is evaluated from the current curve
-candidate and those in the tabu set, the threshold in which to decide that the
-curve will descent to any already known local minimum curve is step3_tabu_dist.
-step3_tabu_in_between_iteration_condition_checkup is a parameter indicating
-after how many iterations to check if the current curve is close to someone
-on the Tabu set. (a low value implies a lot of wasted resources checking
-against all the curves in the Tabu set, a high value implies wasting too much
-resources descending a curve that clearly is converging to one in the tabu
-set).
-
-"""
+# Miscelaneous
+use_ffmpeg = True

src/curves.py

@@ -233,7 +233,8 @@ def add(self, new_curve, new_intensity):
     def __add__(self, measure2):
         new_measure = copy.deepcopy(self)
         new_measure.curves.extend(copy.deepcopy(measure2.curves))
-        new_measure.energies = np.append(new_measure.energies, measure2.energies)
+        new_measure.energies = np.append(new_measure.energies,
+                                         measure2.energies)
         new_measure.intensities = np.append(new_measure.intensities,
                                             measure2.intensities)
         new_measure.main_energy = None

src/insertion_mod.py

@@ -27,6 +27,7 @@ class ordered_list_of_lists:
     # appending in a sorted manner.
     def __init__(self):
         self.data = []
+
     def add_empty_element_in_index(self, i):
         # Insert an empty list of lists in the desired location
         num_after_elements = len(self.data) - i
@@ -35,9 +36,11 @@ def add_empty_element_in_index(self, i):
         # Update all the past lists
         for j in range(i):
             self.data[j].insert(i-j-1, [])
+
     def GET(self, i, j):
         # Find the information hold for the pair i,j, with i < j
         return self.data[i][j-i-1]
+
     def POST(self, i, j, val):
         # Insert information in target location
         self.data[i][j-i-1] = val
@@ -185,7 +188,7 @@ def rejection_sampling(t, w_t):
         else:
             # reject
             iter_index = iter_index+1
-    sys.exit(('The rejection_sampling algorithm failed to find sample in {} '+
+    sys.exit(('The rejection_sampling algorithm failed to find sample in {} ' +
              'iterations').format(iter_index))
 
 def curve_smoother(curve):
@@ -201,13 +204,13 @@ def curve_smoother(curve):
     return curves.curve(curve.t, new_points)
 
 def switch_at(curve1, curve2, idx):
-    # Method that given a particular time index, produces the two curves obtained
-    # by switching at that position
+    # Method that given a particular time index, produces the two curves
+    # obtained by switching at that position
     intermediate_loc = (curve1.x[idx] + curve2.x[idx]).reshape(1, -1)/2
     tail_x1 = curve1.x[:idx, :]
     tail_x2 = curve2.x[:idx, :]
     head_x1 = curve1.x[idx+1:, :]
-    head_x2 = curve2.x[idx+1:,  :]
+    head_x2 = curve2.x[idx+1:, :]
     new_x1 = np.vstack((tail_x1, intermediate_loc, head_x2))
     new_x2 = np.vstack((tail_x2, intermediate_loc, head_x1))
     new_curve1 = curves.curve(curve1.t, new_x1)
@@ -223,14 +226,14 @@ def crossover(curve1, curve2):
     # Then recognize the jumps: 1 if they were apart and got close
     #                           -1 if they were close and got far apart
     #                           0 if nothing happened
-    jumps = np.diff((norms <= config.switching_max_distance).astype(int))
+    jumps = np.diff((norms <= config.crossover_max_distance).astype(int))
     if len(jumps) == 0:
         # if there are no jumps, do not return
         return []
     # We want the indexes with 1s
     jump_idx = np.where(jumps == 1)[0] + 1
     # And we need to discard the last one if they stayed close until the end
-    if norms[-1] <= config.switching_max_distance:
+    if norms[-1] <= config.crossover_max_distance:
         jump_idx = jump_idx[:-1]
     # We have the index locations for the switchings
     curve_descendants = []

src/insertion_step.py

@@ -43,7 +43,7 @@ def insertion_step(current_measure):
     insertion_eps = config.insertion_eps
     if dual_gap < 0:
         print('Somehow dual gap negative, something must be wrong')
-        import code; code.interact(local=dict(globals(), **locals()))
+        print('Likely the TOL value is too small these are rounding errors')
     if dual_gap < insertion_eps:
         logger.status([1, 2, 4])
         exit_flag = 0  # the algorithm stops
@@ -135,10 +135,10 @@ def multistart_descent(current_measure):
         #
         while descent_iters < descent_max_iter and stepsize > lim_stepsize:
             # This while-loop applies the gradient descent on curves,
-            # while simultaneously it checks in intermediates steps if 
+            # while simultaneously it checks in intermediates steps if
             # certain conditions are satisfied. These are the possible cases:
             # case 1: A stationary point is found. This is captured when the
-            #         stepsize goes below lim_stepsize. 
+            #         stepsize goes below lim_stepsize.
             # case 2: The descended curve got at some point close to the
             #         stationary set. The while breaks.
             # case 2.2: If this curve gets too close before the first check,
@@ -147,7 +147,8 @@ def multistart_descent(current_measure):
             #         while not getting close enough to the taboo set.
             #         (this is if descent_soft_max_iter is reached)
             # case 3.1: If the value F(γ) is 0.9 close to the best known case,
-            #           the descent continuous up to descent_max_iter is reached.
+            #           the descent continuous up to descent_max_iter is
+            #           reached.
             # case 3.2: If the value F(γ) is not close enought to the best
             #           known case, the while loop is ended.
             close_to_known_set = False