You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@madlib.apache.org by ri...@apache.org on 2016/12/22 00:08:52 UTC

[2/3] incubator-madlib git commit: Elastic net: Add cross validation

http://git-wip-us.apache.org/repos/asf/incubator-madlib/blob/6939fd63/src/ports/postgres/modules/elastic_net/elastic_net_generate_result.py_in
----------------------------------------------------------------------
diff --git a/src/ports/postgres/modules/elastic_net/elastic_net_generate_result.py_in b/src/ports/postgres/modules/elastic_net/elastic_net_generate_result.py_in
index 8c00376..c48beca 100644
--- a/src/ports/postgres/modules/elastic_net/elastic_net_generate_result.py_in
+++ b/src/ports/postgres/modules/elastic_net/elastic_net_generate_result.py_in
@@ -1,82 +1,70 @@
-
 import plpy
-from elastic_net_utils import __process_results
-from elastic_net_utils import __compute_log_likelihood
-from utilities.utilities import __mad_version
-from utilities.utilities import _array_to_string
-from utilities.utilities import __mad_version
-from utilities.control import MinWarning
+from elastic_net_utils import _process_results
+from elastic_net_utils import _compute_log_likelihood
 from utilities.validate_args import get_cols_and_types
 
-version_wrapper = __mad_version()
-mad_vec = version_wrapper.select_vecfunc()
 
-def __elastic_net_generate_result (optimizer, iteration_run, **args):
+def _elastic_net_generate_result(optimizer, iteration_run, **args):
     """
     Generate result table for all optimizers
     """
     standardize_flag = "True" if args["normalization"] else "False"
     source_table = args["rel_source"]
     if optimizer == "fista":
-        result_func = "__gaussian_fista_result({col_grp_state})".format(col_grp_state=args["col_grp_state"])
+        result_func = "__gaussian_fista_result({0})".format(args["col_grp_state"])
     elif optimizer == "igd":
         result_func = """__gaussian_igd_result({col_grp_state},
             '{sq_str}'::double precision[],
             {threshold}::double precision,
             {tolerance}::double precision
             )
-        """.format(col_grp_state=args["col_grp_state"], 
-            tolerance=args["warmup_tolerance"],
-            threshold=args["threshold"],
-            sq_str=args["sq_str"])
+        """.format(col_grp_state=args["col_grp_state"],
+                   tolerance=args["warmup_tolerance"],
+                   threshold=args["threshold"],
+                   sq_str=args["sq_str"])
     tbl_state = "{rel_state}".format(rel_state=args["rel_state"])
 
     grouping_column = args['grouping_col']
-    grouping_str1 = ""
     if grouping_column:
         col_grp_key = args['col_grp_key']
         grouping_str = args['grouping_str']
-        groupby_str = "GROUP BY {grouping_col}, {col_grp_key}".format(
-            grouping_col=grouping_column, col_grp_key=col_grp_key)
         cols_types = dict(get_cols_and_types(args["tbl_source"]))
         grouping_str1 = grouping_column + ","
-        select_grouping_info = ','.join([grp_col.strip()+"\t" + cols_types[grp_col.strip()]
-            for grp_col in grouping_column.split(',')]) + ","
-        using_str = "USING ({col_grp_key})".format(col_grp_key=col_grp_key)
+        select_grouping_info = ','.join([grp_col.strip() + "\t" + cols_types[grp_col.strip()]
+                                         for grp_col in grouping_column.split(',')]) + ","
         out_table_qstr = """
-        SELECT
-            {grouping_str1}
-            (result).coefficients AS coef,
-            (result).intercept AS intercept
-        FROM (
-            SELECT {schema_madlib}.{result_func} AS result,
-            {col_grp_key}
-            FROM {tbl_state}
-            WHERE {col_grp_iteration} = {iteration_run}
-        ) t
-        JOIN
-        (
             SELECT
                 {grouping_str1}
-                array_to_string(ARRAY[{grouping_str}],
-                                ','
-                               ) AS {col_grp_key}
-            FROM {source_table}
-                {groupby_str}
-        ) n_tuples_including_nulls_subq
-        {using_str}
-        """.format(result_func = result_func, tbl_state = tbl_state,
-            col_grp_iteration = args["col_grp_iteration"],
-            iteration_run = iteration_run,
-            groupby_str=groupby_str,
-            grouping_str1=grouping_str1,
-            grouping_str=grouping_str,
-            using_str=using_str,
-            col_grp_key=col_grp_key,
-            source_table=source_table,
-            schema_madlib = args["schema_madlib"])
+                (result).coefficients AS coef,
+                (result).intercept AS intercept
+            FROM
+                (
+                    SELECT {schema_madlib}.{result_func} AS result, {col_grp_key}
+                    FROM {tbl_state}
+                    WHERE {col_grp_iteration} = {iteration_run}
+                ) t
+                JOIN
+                (
+                    SELECT
+                        {grouping_str1}
+                        array_to_string(ARRAY[{grouping_str}], ',') AS {col_grp_key}
+                    FROM {source_table}
+                    GROUP BY {grouping_col}, {col_grp_key}
+                ) n_tuples_including_nulls_subq
+                USING ({col_grp_key})
+            """.format(result_func=result_func,
+                       tbl_state=tbl_state,
+                       grouping_col=grouping_column,
+                       col_grp_iteration=args["col_grp_iteration"],
+                       iteration_run=iteration_run,
+                       grouping_str1=grouping_str1,
+                       grouping_str=grouping_str,
+                       col_grp_key=col_grp_key,
+                       source_table=source_table,
+                       schema_madlib=args["schema_madlib"])
     else:
-        ## Its a much simpler query when there is no grouping.
+        # It's a much simpler query when there is no grouping.
+        grouping_str1 = ""
         select_grouping_info = ""
         out_table_qstr = """
             SELECT
@@ -87,12 +75,12 @@ def __elastic_net_generate_result (optimizer, iteration_run, **args):
                 FROM {tbl_state}
                 WHERE {col_grp_iteration} = {iteration_run}
             ) t
-        """.format(result_func = result_func, tbl_state = tbl_state,
-            col_grp_iteration = args["col_grp_iteration"],
-            iteration_run = iteration_run,
-            schema_madlib = args["schema_madlib"])
+        """.format(result_func=result_func, tbl_state=tbl_state,
+                   col_grp_iteration=args["col_grp_iteration"],
+                   iteration_run=iteration_run,
+                   schema_madlib=args["schema_madlib"])
 
-    ## Create the output table
+    # Create the output table
     plpy.execute("""
              DROP TABLE IF EXISTS {tbl_result};
              CREATE TABLE {tbl_result} (
@@ -111,68 +99,77 @@ def __elastic_net_generate_result (optimizer, iteration_run, **args):
     result = plpy.execute(out_table_qstr)
     for res in result:
         build_output_table(res, grouping_column, grouping_str1,
-            standardize_flag, iteration_run, **args)
+                           standardize_flag, iteration_run, **args)
 
-    ## Create summary table, listing the grouping columns used.
-    summary_table = args["tbl_summary"]
+    # Create summary table, listing the grouping columns used.
     grouping_text = "NULL" if not grouping_column else grouping_column
+    failed_groups = plpy.execute("""
+        SELECT count(*) AS num_failed_groups FROM {0} WHERE coef_all IS NULL
+        """.format(args['tbl_result']))[0]
+    all_groups = plpy.execute("SELECT count(*) AS num_all_groups FROM {0} ".
+                              format(args['tbl_result']))[0]
+    args.update(failed_groups)
+    args.update(all_groups)
     plpy.execute("""
-        DROP TABLE IF EXISTS {summary_table};
-        CREATE TABLE {summary_table} (
-            grouping_col    text
-        )
-        """.format(summary_table=summary_table))
-    plpy.execute("""
-            INSERT INTO {summary_table} VALUES
-            ('{grouping_text}')
-        """.format(summary_table=summary_table, grouping_text=grouping_text))
+        CREATE TABLE {tbl_summary} AS
+        SELECT
+            'elastic_net'::varchar              AS method,
+            '{tbl_source}'::varchar             AS source_table,
+            '{tbl_result}'::varchar             AS out_table,
+            $madlib_super_quote${col_dep_var}$madlib_super_quote$::varchar
+                                                AS dependent_varname,
+            $madlib_super_quote${col_ind_var}$madlib_super_quote$::varchar
+                                                AS independent_varname,
+            '{family}'::varchar                 AS family,
+            {alpha}::float                      AS alpha,
+            {lambda_value}::float               AS lambda_value,
+            '{grouping_text}'::varchar          AS grouping_col,
+            {num_all_groups}::integer           AS num_all_groups,
+            {num_failed_groups}::integer        AS num_failed_groups
+        """.format(grouping_text=grouping_text,
+                   **args))
     return None
 
 
-def build_output_table(res, grouping_column, grouping_str1, 
-    standardize_flag, iteration_run, **args):
+def build_output_table(res, grouping_column, grouping_str1,
+                       standardize_flag, iteration_run, **args):
     """
     Insert model captured in "res" into the output table
     """
-    r_coef = mad_vec(res["coef"], text = False)
-    if args["normalization"]:
-        (coef, intercept) = __restore_scale(r_coef, res["intercept"], args)
-    else:
-        coef = r_coef
-        intercept = res["intercept"]
+    r_coef = res["coef"]
+    if r_coef:
+        if args["normalization"]:
+            (coef, intercept) = _restore_scale(r_coef, res["intercept"], args)
+        else:
+            coef = r_coef
+            intercept = res["intercept"]
 
-    (features, features_selected, dense_coef, sparse_coef) = __process_results(
-        coef, intercept, args["outstr_array"])
+        (features, features_selected, dense_coef, sparse_coef) = _process_results(
+            coef, intercept, args["outstr_array"])
 
-    # compute the likelihood
-    if args["normalization"]:
-        coef_str = _array_to_string(r_coef) # use un-restored coef
-    else:
-        coef_str = sparse_coef
+        log_likelihood = _compute_log_likelihood(r_coef, res["intercept"], **args)
+        if grouping_column:
+            grouping_info = ','.join([str(res[grp_col.strip()])
+                                      for grp_col in grouping_str1.split(',')
+                                      if grp_col.strip() in res.keys()]) + ","
+        else:
+            grouping_info = ""
+        fquery = """
+            INSERT INTO {tbl_result} VALUES
+                ({grouping_info} '{family}', '{features}'::text[], '{features_selected}'::text[],
+                '{dense_coef}'::double precision[], '{sparse_coef}'::double precision[],
+                {intercept}, {log_likelihood}, {standardize_flag}, {iteration})
+            """.format(features=features, features_selected=features_selected,
+                       dense_coef=dense_coef, sparse_coef=sparse_coef,
+                       intercept=intercept, log_likelihood=log_likelihood,
+                       grouping_info=grouping_info,
+                       standardize_flag=standardize_flag, iteration=iteration_run,
+                       **args)
+        plpy.execute(fquery)
+# ------------------------------------------------------------------------
 
-    log_likelihood = __compute_log_likelihood(r_coef, res["intercept"], **args)
-    if grouping_column:
-        grouping_info = ','.join([str(res[grp_col.strip()]) 
-            for grp_col in grouping_str1.split(',') 
-            if grp_col.strip() in res.keys()]) + ","
-    else:
-        grouping_info = ""
-    fquery = """
-        INSERT INTO {tbl_result} VALUES
-            ({grouping_info} '{family}', '{features}'::text[], '{features_selected}'::text[],
-            '{dense_coef}'::double precision[], '{sparse_coef}'::double precision[],
-            {intercept}, {log_likelihood}, {standardize_flag}, {iteration})
-        """.format(
-            features = features, features_selected = features_selected,
-            dense_coef = dense_coef, sparse_coef = sparse_coef,
-            intercept = intercept, log_likelihood = log_likelihood,
-            grouping_info=grouping_info,
-            standardize_flag = standardize_flag, iteration = iteration_run,
-            **args)
-    plpy.execute(fquery)
-# ========================================================================
 
-def __restore_scale (coef, intercept, args):
+def _restore_scale(coef, intercept, args):
     """
     Restore the original scales
     """

http://git-wip-us.apache.org/repos/asf/incubator-madlib/blob/6939fd63/src/ports/postgres/modules/elastic_net/elastic_net_models.py_in
----------------------------------------------------------------------
diff --git a/src/ports/postgres/modules/elastic_net/elastic_net_models.py_in b/src/ports/postgres/modules/elastic_net/elastic_net_models.py_in
index d27e766..b7ea016 100644
--- a/src/ports/postgres/modules/elastic_net/elastic_net_models.py_in
+++ b/src/ports/postgres/modules/elastic_net/elastic_net_models.py_in
@@ -1,88 +1,91 @@
-
-## Try to make every function has a useful return value !
-## Try to avoid any changes to function arguments !
-
+from elastic_net_optimizer_fista import _elastic_net_fista_train
+from elastic_net_optimizer_igd import _elastic_net_igd_train
 import plpy
-from elastic_net_optimizer_fista import __elastic_net_fista_train
-from elastic_net_optimizer_igd import __elastic_net_igd_train
 
 # ========================================================================
 
-def __elastic_net_gaussian_fista_train(schema_madlib, tbl_source, col_ind_var,
-                                       col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                       normalization, optimizer_params, max_iter,
-                                       tolerance, outstr_array, grouping_str,
-                                       grouping_col, **kwargs):
+
+def _elastic_net_gaussian_fista_train(schema_madlib, tbl_source, col_ind_var,
+                                      col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                                      normalization, optimizer_params, max_iter,
+                                      tolerance, outstr_array, grouping_str,
+                                      grouping_col, **kwargs):
     """
     Use FISTA to solve linear models
-    """    
-    return __elastic_net_fista_train(schema_madlib,
-                                     "__gaussian_fista_step",
-                                     "__gaussian_fista_state_diff",
-                                     "gaussian",
-                                     tbl_source, col_ind_var,
-                                     col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                     normalization, optimizer_params, max_iter,
-                                     tolerance, outstr_array, grouping_str,
-                                     grouping_col, **kwargs)
+    """
+    return _elastic_net_fista_train(schema_madlib,
+                                    "__gaussian_fista_step",
+                                    "__gaussian_fista_state_diff",
+                                    "gaussian",
+                                    tbl_source, col_ind_var,
+                                    col_dep_var, tbl_result, tbl_summary,
+                                    lambda_value, alpha,
+                                    normalization, optimizer_params, max_iter,
+                                    tolerance, outstr_array, grouping_str,
+                                    grouping_col, **kwargs)
 
 # ========================================================================
 
-def __elastic_net_gaussian_igd_train(schema_madlib, tbl_source, col_ind_var,
-                                     col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                     normalization, optimizer_params, max_iter,
-                                     tolerance, outstr_array, grouping_str,
-                                     grouping_col, **kwargs):
+
+def _elastic_net_gaussian_igd_train(schema_madlib, tbl_source, col_ind_var,
+                                    col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                                    normalization, optimizer_params, max_iter,
+                                    tolerance, outstr_array, grouping_str,
+                                    grouping_col, **kwargs):
     """
     Use IGD to solve linear models
     """
-    return __elastic_net_igd_train(schema_madlib,
-                                   "__gaussian_igd_step",
-                                   "__gaussian_igd_state_diff",
-                                   "gaussian",
-                                   tbl_source, col_ind_var,
-                                   col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                   normalization, optimizer_params, max_iter,
-                                   tolerance, outstr_array, grouping_str,
-                                   grouping_col, **kwargs)
+    return _elastic_net_igd_train(schema_madlib,
+                                  "__gaussian_igd_step",
+                                  "__gaussian_igd_state_diff",
+                                  "gaussian",
+                                  tbl_source, col_ind_var,
+                                  col_dep_var, tbl_result, tbl_summary,
+                                  lambda_value, alpha,
+                                  normalization, optimizer_params, max_iter,
+                                  tolerance, outstr_array, grouping_str,
+                                  grouping_col, **kwargs)
 
 # ========================================================================
 
-def __elastic_net_binomial_fista_train(schema_madlib, tbl_source, col_ind_var,
-                                       col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                       normalization, optimizer_params, max_iter,
-                                       tolerance, outstr_array, grouping_str,
-                                       grouping_col, **kwargs):
+
+def _elastic_net_binomial_fista_train(schema_madlib, tbl_source, col_ind_var,
+                                      col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                                      normalization, optimizer_params, max_iter,
+                                      tolerance, outstr_array, grouping_str,
+                                      grouping_col, **kwargs):
     """
     Use FISTA to solve linear models
-    """    
-    return __elastic_net_fista_train(schema_madlib,
-                                     "__binomial_fista_step",
-                                     "__binomial_fista_state_diff",
-                                     "binomial",
-                                     tbl_source, col_ind_var,
-                                     col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                     normalization, optimizer_params, max_iter,
-                                     tolerance, outstr_array, grouping_str,
-                                     grouping_col, **kwargs)
+    """
+    return _elastic_net_fista_train(schema_madlib,
+                                    "__binomial_fista_step",
+                                    "__binomial_fista_state_diff",
+                                    "binomial",
+                                    tbl_source, col_ind_var,
+                                    col_dep_var, tbl_result, tbl_summary,
+                                    lambda_value, alpha,
+                                    normalization, optimizer_params, max_iter,
+                                    tolerance, outstr_array, grouping_str,
+                                    grouping_col, **kwargs)
 
 # ========================================================================
 
-def __elastic_net_binomial_igd_train(schema_madlib, tbl_source, col_ind_var,
-                                     col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                     normalization, optimizer_params, max_iter,
-                                     tolerance, outstr_array, grouping_str,
-                                     grouping_col, **kwargs):
+
+def _elastic_net_binomial_igd_train(schema_madlib, tbl_source, col_ind_var,
+                                    col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                                    normalization, optimizer_params, max_iter,
+                                    tolerance, outstr_array, grouping_str,
+                                    grouping_col, **kwargs):
     """
     Use IGD to solve linear models
     """
-    return __elastic_net_igd_train(schema_madlib,
-                                   "__binomial_igd_step",
-                                   "__binomial_igd_state_diff",
-                                   "binomial",
-                                   tbl_source, col_ind_var,
-                                   col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                   normalization, optimizer_params, max_iter,
-                                   tolerance, outstr_array, grouping_str,
-                                   grouping_col, **kwargs)
-    
+    return _elastic_net_igd_train(schema_madlib,
+                                  "__binomial_igd_step",
+                                  "__binomial_igd_state_diff",
+                                  "binomial",
+                                  tbl_source, col_ind_var,
+                                  col_dep_var, tbl_result, tbl_summary,
+                                  lambda_value, alpha,
+                                  normalization, optimizer_params, max_iter,
+                                  tolerance, outstr_array, grouping_str,
+                                  grouping_col, **kwargs)

http://git-wip-us.apache.org/repos/asf/incubator-madlib/blob/6939fd63/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_fista.py_in
----------------------------------------------------------------------
diff --git a/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_fista.py_in b/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_fista.py_in
index 6cc1eab..8ac6819 100644
--- a/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_fista.py_in
+++ b/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_fista.py_in
@@ -1,145 +1,53 @@
-
-## Try to make every function has a useful return value !
-## Try to avoid any changes to function arguments !
-
 import plpy
-import math
-from elastic_net_utils import __normalize_data
-from elastic_net_utils import __compute_data_scales
-from elastic_net_utils import __compute_means
-from elastic_net_utils import __tbl_dimension_rownum
-from utilities.utilities import unique_string
-from utilities.in_mem_group_control import GroupIterationController
+from elastic_net_generate_result import _elastic_net_generate_result
+from elastic_net_utils import _normalize_data
+from elastic_net_utils import _tbl_dimension_rownum
+from elastic_net_utils import _elastic_net_validate_args
+from elastic_net_utils import _compute_average_sq
+from elastic_net_utils import _generate_warmup_lambda_sequence
+from elastic_net_utils import _process_warmup_lambdas
 from utilities.control import MinWarning
-from elastic_net_utils import __elastic_net_validate_args
-from utilities.utilities import _array_to_string
-from elastic_net_utils import __compute_average_sq
-from elastic_net_utils import __generate_warmup_lambda_sequence
-from elastic_net_utils import __process_warmup_lambdas
-from elastic_net_generate_result import __elastic_net_generate_result
-from utilities.utilities import __mad_version
-from utilities.utilities import preprocess_keyvalue_params
+from utilities.in_mem_group_control import GroupIterationController
+from utilities.utilities import unique_string
+from utilities.utilities import extract_keyvalue_params
 
-version_wrapper = __mad_version()
-mad_vec = version_wrapper.select_vecfunc()
 
-## ========================================================================
+# ------------------------------------------------------------------------
 
 
-def __fista_params_parser(optimizer_params, lambda_value, tolerance, schema_madlib):
+def _fista_params_parser(optimizer_params, lambda_value, tolerance, schema_madlib):
     """
     Parse fista parameters.
     """
-    allowed_params = set(["max_stepsize", "eta", "warmup", "warmup_lambdas",
-                          "warmup_lambda_no", "use_active_set", "random_stepsize",
-                          "activeset_tolerance", "warmup_tolerance"])
-    name_value = dict()
     # default values
-    name_value["max_stepsize"] = 2.
-    name_value["use_active_set"] = 0  # use of active set
-    name_value["eta"] = 1.2
-    name_value["warmup"] = False
-    name_value["warmup_lambdas"] = None
-    name_value["warmup_lambda_no"] = 15
-    name_value["random_stepsize"] = 0  # use random stepsize
-    name_value["activeset_tolerance"] = tolerance
-    name_value["warmup_tolerance"] = tolerance
-
-    warmup_lambdas = None
-    warmup_lambda_no = None
-
-    if optimizer_params is None or len(optimizer_params) == 0:
-        return name_value
-
-    for s in preprocess_keyvalue_params(optimizer_params):
-        items = s.split("=")
-        if (len(items) != 2):
-            plpy.error("Elastic Net error: Optimizer parameter list "
-                       "has incorrect format!")
-        param_name = items[0].strip(" \"").lower()
-        param_value = items[1].strip(" \"").lower()
-
-        if param_name not in allowed_params:
-            plpy.error(
-                """
-                Elastic Net error: {param_name} is not a valid parameter name for the FISTA optimizer.
-                Run:
-
-                SELECT {schema_madlib}.elastic_net_train('fista');
-
-                to see the parameters for FISTA algorithm.
-                """.format(param_name=param_name,
-                           schema_madlib=schema_madlib))
-
-        if param_name == "activeset_tolerance":
-            try:
-                name_value["activeset_tolerance"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: activeset_tolerance must be a "
-                           "float number!")
-
-        if param_name == "warmup_tolerance":
-            try:
-                name_value["warmup_tolerance"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: warmup_tolerance must be a "
-                           "float number!")
-
-        if param_name == "max_stepsize":
-            try:
-                name_value["max_stepsize"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: max_stepsize must be a "
-                           "float number!")
-
-        if param_name == "eta":
-            try:
-                name_value["eta"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: eta must be a float number!")
-
-        if param_name == "random_stepsize":
-            if param_value in ["true", "t", "yes", "y"]:
-                name_value["random_stepsize"] = 1
-            elif param_value in ["false", "f", "no", "n"]:
-                name_value["random_stepsize"] = 0
-            else:
-                plpy.error("Elastic Net error: Do you need to add some "
-                           "randomness to step size (True/False or yes/no) ?")
-
-        if param_name == "warmup":
-            if param_value in ["true", "t", "yes", "y"]:
-                name_value["warmup"] = True
-            elif param_value in ["false", "f", "no", "n"]:
-                name_value["warmup"] = False
-            else:
-                plpy.error("Elastic Net error: Do you need warmup "
-                           "(True/False or yes/no) ?")
-
-        if param_name == "warmup_lambdas" and param_value != "null":
-            warmup_lambdas = param_value
-
-        if param_name == "warmup_lambda_no":
-            warmup_lambda_no = param_value
-
-        if param_name == "use_active_set":
-            if param_value in ["true", "t", "yes", "y"]:
-                name_value["use_active_set"] = 1
-            elif param_value in ["false", "f", "no", "n"]:
-                name_value["use_active_set"] = 0
-            else:
-                plpy.error("Elastic Net error: Do you need warmup "
-                           "(True/False or yes/no) ?")
-
-    if name_value["warmup"]:
-        if warmup_lambdas is not None:
-            # errors are handled in __process_warmup_lambdas
-            name_value["warmup_lambdas"] = __process_warmup_lambdas(warmup_lambdas, lambda_value)
-        if warmup_lambda_no is not None:
-            try:
-                name_value["warmup_lambda_no"] = int(warmup_lambda_no)
-            except:
-                plpy.error("Elastic Net error: warmup_lambda_no must be an integer!")
+    defaults_and_types = {
+        "max_stepsize": (2., float),
+        "eta": (1.2, float),
+        "warmup": (False, bool),
+        "warmup_lambdas": (None, list),
+        "warmup_lambda_no": (15, int),
+        "use_active_set": (False, bool),
+        "random_stepsize": (False, bool),
+        "activeset_tolerance": (tolerance, float),
+        "warmup_tolerance": (tolerance, float)
+    }
+    param_defaults = dict([(k, v[0]) for k, v in defaults_and_types.items()])
+    param_types = dict([(k, v[1]) for k, v in defaults_and_types.items()])
+
+    if not optimizer_params:
+        return param_defaults
+
+    usage_str = ("Run:\n"
+                 "   SELECT {0}.elastic_net_train('fista');\n"
+                 "   to see the parameters for FISTA algorithm.".
+                 format(schema_madlib))
+    name_value = extract_keyvalue_params(optimizer_params, param_types,
+                                         param_defaults, usage_str=usage_str,
+                                         ignore_invalid=True)
+
+    if name_value["warmup"] and name_value['warmup_lambdas'] is not None:
+        # errors are handled in _process_warmup_lambdas
+        name_value['warmup_lambdas'] = _process_warmup_lambdas(name_value['warmup_lambdas'], lambda_value)
 
     # validate the parameters
     if name_value["max_stepsize"] <= 0:
@@ -162,9 +70,10 @@ def __fista_params_parser(optimizer_params, lambda_value, tolerance, schema_madl
         plpy.error("Elastic Net error: warmup_tolerance must be positive!")
 
     return name_value
-## ========================================================================
+# -------------------------------------------------------------------------
 
-def __fista_construct_dict(
+
+def _fista_construct_dict(
         schema_madlib, family, tbl_source, col_ind_var, col_dep_var,
         tbl_result, dimension, row_num, lambda_value, alpha,
         normalization, max_iter, tolerance, outstr_array, optimizer_params_dict):
@@ -193,8 +102,8 @@ def __fista_construct_dict(
     # Table names useful when normalizing the original data
     # Note: in order to be consistent with the calling convention
     # of the normalization functions, multiple elements of the dict
-    # actually have the same value. This is a price that one has to pay
-    # if he wants to save typing argument names by using **args as the
+    # actually have the same value. This is a price one has to pay
+    # to save typing argument names by using **args as the
     # function argument.
     tbl_ind_scales = unique_string(desp='temp_ind_scales')
     tbl_dep_scale = unique_string(desp='temp_dep_scales')
@@ -204,25 +113,18 @@ def __fista_construct_dict(
                 tbl_data_scaled=tbl_data_scaled)
 
     # Table names used in IGD iterations
-    args.update(tbl_fista_state=unique_string(),
-                tbl_fista_args=unique_string())
+    args.update(tbl_fista_state=unique_string(), tbl_fista_args=unique_string())
 
     # more, for args table
-    args["dimension_name"] = unique_string()
-    args["lambda_name"] = unique_string()
-    args["alpha_name"] = unique_string()
-    args["total_rows_name"] = unique_string()
-    args["max_iter_name"] = unique_string()
-    args["tolerance_name"] = unique_string()
-    args["max_stepsize_name"] = unique_string()
-    args["eta_name"] = unique_string()
-    args["activeset_name"] = unique_string()
-
+    for name in ('dimension_name', 'lambda_name', 'alpha_name',
+                 'total_rows_name', 'max_iter_name', 'tolerance_name',
+                 'max_stepsize_name', 'eta_name', 'activeset_name'):
+        args[name] = unique_string()
     return args
-## ========================================================================
+# ------------------------------------------------------------------------
 
 
-def __fista_cleanup_temp_tbls(**args):
+def _fista_cleanup_temp_tbls(**kwargs):
     """
     Drop all temporary tables used by FISTA optimizer,
     including tables used in the possible normalization
@@ -234,48 +136,49 @@ def __fista_cleanup_temp_tbls(**args):
                 drop table if exists {tbl_data_scaled};
                 drop table if exists {tbl_fista_args};
                 drop table if exists pg_temp.{tbl_fista_state};
-                """.format(**args))
+                """.format(**kwargs))
 
     return None
-## ========================================================================
+# ------------------------------------------------------------------------
 
 
-def __elastic_net_fista_train(schema_madlib, func_step_aggregate,
-                              func_state_diff, family,
-                              tbl_source, col_ind_var,
-                              col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                              normalization, optimizer_params, max_iter,
-                              tolerance, outstr_array, grouping_str,
-                              grouping_col, **kwargs):
+def _elastic_net_fista_train(schema_madlib, func_step_aggregate,
+                             func_state_diff, family,
+                             tbl_source, col_ind_var,
+                             col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                             normalization, optimizer_params, max_iter,
+                             tolerance, outstr_array, grouping_str,
+                             grouping_col, **kwargs):
     """
     func_step_aggregate is string, and it is the name of the step function
     """
-    __elastic_net_validate_args(tbl_source, col_ind_var, col_dep_var,
-                                tbl_result, tbl_summary, lambda_value, alpha,
-                                normalization, max_iter, tolerance)
-
-    return __elastic_net_fista_train_compute(schema_madlib,
-                                             func_step_aggregate,
-                                             func_state_diff,
-                                             family,
-                                             tbl_source, col_ind_var,
-                                             col_dep_var, tbl_result,
-                                             tbl_summary, lambda_value, alpha,
-                                             normalization,
-                                             optimizer_params, max_iter,
-                                             tolerance, outstr_array,
-                                             grouping_str, grouping_col,
-                                             **kwargs)
-## ========================================================================
-
-
-def __elastic_net_fista_train_compute(schema_madlib, func_step_aggregate,
-                                      func_state_diff, family,
-                                      tbl_source, col_ind_var,
-                                      col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                      normalization, optimizer_params, max_iter,
-                                      tolerance, outstr_array, grouping_str,
-                                      grouping_col, **kwargs):
+    _elastic_net_validate_args(tbl_source, col_ind_var, col_dep_var,
+                               tbl_result, tbl_summary, lambda_value, alpha,
+                               normalization, max_iter, tolerance)
+    return _elastic_net_fista_train_compute(schema_madlib,
+                                            func_step_aggregate,
+                                            func_state_diff,
+                                            family,
+                                            tbl_source,
+                                            col_ind_var, col_dep_var,
+                                            tbl_result, tbl_summary,
+                                            lambda_value, alpha,
+                                            normalization,
+                                            optimizer_params, max_iter,
+                                            tolerance, outstr_array,
+                                            grouping_str, grouping_col,
+                                            **kwargs)
+# ------------------------------------------------------------------------
+
+
+def _elastic_net_fista_train_compute(schema_madlib, func_step_aggregate,
+                                     func_state_diff, family,
+                                     tbl_source, col_ind_var,
+                                     col_dep_var, tbl_result, tbl_summary,
+                                     lambda_value, alpha,
+                                     normalization, optimizer_params, max_iter,
+                                     tolerance, outstr_array, grouping_str,
+                                     grouping_col, **kwargs):
     """
     Fit linear model with elastic net regularization using FISTA optimization.
 
@@ -292,124 +195,119 @@ def __elastic_net_fista_train_compute(schema_madlib, func_step_aggregate,
     @param optimizer_params  Parameters of the above optimizer, the format
                              is '{arg = value, ...}'::varchar[]
     """
-    old_msg_level = plpy.execute("""
-                                 select setting from pg_settings
-                                 where name='client_min_messages'
-                                 """)[0]['setting']
-    plpy.execute("set client_min_messages to error")
-
-    (dimension, row_num) = __tbl_dimension_rownum(schema_madlib, tbl_source, col_ind_var)
-
-    # generate a full dict to ease the following string format
-    # including several temporary table names
-    args = __fista_construct_dict(schema_madlib, family, tbl_source, col_ind_var,
-                                  col_dep_var, tbl_result,
-                                  dimension, row_num, lambda_value,
-                                  alpha, normalization,
-                                  max_iter, tolerance, outstr_array,
-                                  __fista_params_parser(optimizer_params,
-                                                        lambda_value,
-                                                        tolerance,
-                                                        schema_madlib))
-
-    args.update({'grouping_col': grouping_col})
-    # use normalized data or not
-    if normalization:
-        __normalize_data(args)
-        tbl_used = args["tbl_data_scaled"]
-        args["col_ind_var_new"] = args["col_ind_var_norm_new"]
-        args["col_dep_var_new"] = args["col_dep_var_norm_new"]
-    else:
-        #####__compute_data_scales(args)
-        tbl_used = tbl_source
-        args["col_ind_var_new"] = col_ind_var
-        args["col_dep_var_new"] = col_dep_var
-
-    args["tbl_used"] = tbl_used
-
-    if args["warmup_lambdas"] is not None:
-        args["warm_no"] = len(args["warmup_lambdas"])
-        args["warmup_lambdas"] = args["warmup_lambdas"]
-
-    if args["warmup"] and args["warmup_lambdas"] is None:
-        # average squares of each feature
-        # used to estimate the largest lambda value
-        args["sq"] = __compute_average_sq(**args)
-        args["warmup_lambdas"] = \
-            __generate_warmup_lambda_sequence(
-                tbl_used, args["col_ind_var_new"], args["col_dep_var_new"],
-                dimension, row_num, lambda_value, alpha,
-                args["warmup_lambda_no"], args["sq"])
-        args["warm_no"] = len(args["warmup_lambdas"])
-        args["warmup_lambdas"] = args["warmup_lambdas"]
-    elif args["warmup"] is False:
-        args["warm_no"] = 1
-        args["warmup_lambdas"] = [lambda_value]  # only one value
-
-    ## This update is needed in __elastic_net_generate_result() after
-    ## __compute_fista is run. Some of these variables are accessed there.
-    args.update({
-        'rel_state': args["tbl_fista_state"],
-        'col_grp_iteration': unique_string(desp='col_grp_iteration'),
-        'col_grp_state': unique_string(desp='col_grp_state'),
-        'col_grp_key': unique_string(desp='col_grp_key'),
-        'col_n_tuples': unique_string(desp='col_n_tuples'),
-        'lambda_count': 1,
-        'is_active': 0,
-        'state_type': "double precision[]",
-        'rel_source': tbl_used,
-        'grouping_str': grouping_str,
-        'tbl_source': tbl_source,
-        'tbl_summary': tbl_summary
+    with MinWarning('error'):
+        (dimension, row_num) = _tbl_dimension_rownum(schema_madlib, tbl_source, col_ind_var)
+
+        # generate a full dict to ease the following string format
+        # including several temporary table names
+        args = _fista_construct_dict(schema_madlib, family, tbl_source, col_ind_var,
+                                     col_dep_var, tbl_result,
+                                     dimension, row_num, lambda_value,
+                                     alpha, normalization,
+                                     max_iter, tolerance, outstr_array,
+                                     _fista_params_parser(optimizer_params,
+                                                          lambda_value,
+                                                          tolerance,
+                                                          schema_madlib))
+
+        args.update({'grouping_col': grouping_col})
+        # use normalized data or not
+        if normalization:
+            _normalize_data(args)
+            tbl_used = args["tbl_data_scaled"]
+            args["col_ind_var_new"] = args["col_ind_var_norm_new"]
+            args["col_dep_var_new"] = args["col_dep_var_norm_new"]
+        else:
+            tbl_used = tbl_source
+            args["col_ind_var_new"] = col_ind_var
+            args["col_dep_var_new"] = col_dep_var
+
+        args["tbl_used"] = tbl_used
+
+        if args["warmup_lambdas"] is not None:
+            args["warm_no"] = len(args["warmup_lambdas"])
+            args["warmup_lambdas"] = args["warmup_lambdas"]
+
+        if args["warmup"] and args["warmup_lambdas"] is None:
+            # average squares of each feature
+            # used to estimate the largest lambda value
+            args["sq"] = _compute_average_sq(**args)
+            args["warmup_lambdas"] = \
+                _generate_warmup_lambda_sequence(
+                    tbl_used, args["col_ind_var_new"], args["col_dep_var_new"],
+                    dimension, row_num, lambda_value, alpha,
+                    args["warmup_lambda_no"], args["sq"])
+            args["warm_no"] = len(args["warmup_lambdas"])
+            args["warmup_lambdas"] = args["warmup_lambdas"]
+        elif args["warmup"] is False:
+            args["warm_no"] = 1
+            args["warmup_lambdas"] = [lambda_value]  # only one value
+
+        # This update is needed in _elastic_net_generate_result() after
+        # _compute_fista is run. Some of these variables are accessed there.
+        args.update({
+            'rel_state': args["tbl_fista_state"],
+            'col_grp_iteration': unique_string(desp='col_grp_iteration'),
+            'col_grp_state': unique_string(desp='col_grp_state'),
+            'col_grp_key': unique_string(desp='col_grp_key'),
+            'col_n_tuples': unique_string(desp='col_n_tuples'),
+            'lambda_count': 1,
+            'is_active': 0,
+            'state_type': "double precision[]",
+            'rel_source': tbl_used,
+            'grouping_str': grouping_str,
+            'tbl_source': tbl_source,
+            'tbl_summary': tbl_summary
         })
 
-    # perform the actual calculation
-    iteration_run = __compute_fista(
-        schema_madlib, func_step_aggregate,
-        func_state_diff,
-        args["tbl_fista_args"],
-        args["tbl_fista_state"],
-        tbl_used,
-        args["col_ind_var_new"],
-        args["col_dep_var_new"],
-        grouping_str,
-        grouping_col,
-        tolerance,
-        start_iter=0,
-        lambda_name=args["warmup_lambdas"],
-        warmup_lambda_value = args.get('warmup_lambdas')[args["lambda_count"]-1],
-        activeset_tolerance=args["activeset_tolerance"],
-        warmup_tolerance=args["warmup_tolerance"],
-        max_iter=args["max_iter"],
-        warm_no=args["warm_no"],
-        random_stepsize=args["random_stepsize"],
-        use_active_set=args["use_active_set"],
-        alpha=args["alpha"],
-        row_num=args["row_num"],
-        dimension=args["dimension"],
-        max_stepsize=args["max_stepsize"],
-        eta=args["eta"],
-        rel_state= args["tbl_fista_state"],
-        col_grp_iteration= args["col_grp_iteration"],
-        col_grp_state= args["col_grp_state"],
-        col_grp_key= args["col_grp_key"],
-        col_n_tuples= args["col_n_tuples"],
-        lambda_count= args["lambda_count"],
-        is_active= args["is_active"],
-        state_type= args["state_type"],
-        rel_source= args["rel_source"])
-
-    __elastic_net_generate_result("fista", iteration_run, **args)
-
-    # cleanup
-    __fista_cleanup_temp_tbls(**args)
-    plpy.execute("set client_min_messages to " + old_msg_level)
+        # perform the actual calculation
+        iteration_run = _compute_fista(
+            schema_madlib, func_step_aggregate,
+            func_state_diff,
+            args["tbl_fista_args"],
+            args["tbl_fista_state"],
+            tbl_used,
+            args["col_ind_var_new"],
+            args["col_dep_var_new"],
+            grouping_str,
+            grouping_col,
+            tolerance,
+            start_iter=0,
+            lambda_name=args["warmup_lambdas"],
+            warmup_lambda_value=args.get('warmup_lambdas')[args["lambda_count"] - 1],
+            activeset_tolerance=args["activeset_tolerance"],
+            warmup_tolerance=args["warmup_tolerance"],
+            max_iter=args["max_iter"],
+            warm_no=args["warm_no"],
+            random_stepsize=args["random_stepsize"],
+            use_active_set=args["use_active_set"],
+            alpha=args["alpha"],
+            row_num=args["row_num"],
+            dimension=args["dimension"],
+            max_stepsize=args["max_stepsize"],
+            eta=args["eta"],
+            rel_state=args["tbl_fista_state"],
+            col_grp_iteration=args["col_grp_iteration"],
+            col_grp_state=args["col_grp_state"],
+            col_grp_key=args["col_grp_key"],
+            col_n_tuples=args["col_n_tuples"],
+            lambda_count=args["lambda_count"],
+            is_active=args["is_active"],
+            state_type=args["state_type"],
+            rel_source=args["rel_source"])
+
+        _elastic_net_generate_result("fista", iteration_run, **args)
+
+        # cleanup
+        _fista_cleanup_temp_tbls(**args)
     return None
-## ========================================================================
+# ------------------------------------------------------------------------
 
-def __compute_fista(schema_madlib, func_step_aggregate, func_state_diff,
-                    tbl_args, tbl_state, tbl_source, col_ind_var, 
-                    col_dep_var, grouping_str, grouping_col, tolerance, start_iter, **kwargs):
+
+def _compute_fista(schema_madlib, func_step_aggregate, func_state_diff,
+                   tbl_args, tbl_state, tbl_source, col_ind_var,
+                   col_dep_var, grouping_str, grouping_col, tolerance,
+                   start_iter, **kwargs):
     """
     Driver function for elastic net using FISTA
 
@@ -430,7 +328,7 @@ def __compute_fista(schema_madlib, func_step_aggregate, func_state_diff,
         result in \c tbl_state
     """
     args = locals()
-    
+
     for k, v in kwargs.iteritems():
         if k not in args:
             args.update({k: v})
@@ -441,23 +339,24 @@ def __compute_fista(schema_madlib, func_step_aggregate, func_state_diff,
             # manually add the intercept term
             if (it.kwargs["lambda_count"] > len(args.get('lambda_name'))):
                 break
-            it.kwargs["warmup_lambda_value"] = args.get('lambda_name')[it.kwargs["lambda_count"]-1]
+            it.kwargs["warmup_lambda_value"] = args.get('lambda_name')[it.kwargs["lambda_count"] - 1]
             it.update("""
-                  {schema_madlib}.{func_step_aggregate}(
-                      ({col_ind_var})::double precision[],
-                      ({col_dep_var}),
-                      {rel_state}.{col_grp_state},
-                      ({warmup_lambda_value})::double precision,
-                      ({alpha})::double precision,
-                      ({dimension})::integer,
-                      ({row_num})::integer,
-                      ({max_stepsize})::double precision,
-                      ({eta})::double precision,
-                      ({use_active_set})::integer,
-                      {is_active}::integer,
-                      {random_stepsize}::integer
-                  )
-            """)
+                    {schema_madlib}.{func_step_aggregate}(
+                        ({col_ind_var})::double precision[],
+                        ({col_dep_var}),
+                        {rel_state}.{col_grp_state},
+                        ({warmup_lambda_value})::double precision,
+                        ({alpha})::double precision,
+                        ({dimension})::integer,
+                        ({row_num})::integer,
+                        ({max_stepsize})::double precision,
+                        ({eta})::double precision,
+                        ({use_active_set})::integer,
+                        {is_active}::integer,
+                        {random_stepsize}::integer
+                    )
+                    """)
+
             if it.kwargs["is_active"] == 1:
                 it.kwargs["use_tolerance"] = it.kwargs["activeset_tolerance"]
             elif it.kwargs["lambda_count"] < it.kwargs["warm_no"]:
@@ -465,19 +364,21 @@ def __compute_fista(schema_madlib, func_step_aggregate, func_state_diff,
             else:
                 it.kwargs["use_tolerance"] = args["tolerance"]
 
-            if it.kwargs["use_active_set"] == 1:
+            if it.kwargs["use_active_set"]:
                 is_backtracking = it.are_last_state_value_zero()
-                if it.test(
-                    """
-                    {iteration} >= {max_iter}
-                    or
-                    {schema_madlib}.{func_state_diff}(
-                        _state_previous, _state_current) < {use_tolerance}
-                    """):
+                if it.test("""
+                        {iteration} >= {max_iter}
+                        or
+                        {schema_madlib}.{func_state_diff}(
+                            _state_previous, _state_current) < {use_tolerance}
+                        """):
                     if it.iteration < it.kwargs["max_iter"]:
                         if it.kwargs["is_active"] == 0:
                             if (it.kwargs["lambda_count"] < it.kwargs["warm_no"]):
                                 it.kwargs["lambda_count"] += 1
+                                if (len(args.get('lambda_name')) >=
+                                        it.kwargs["lambda_count"]):
+                                    break
                             else:
                                 break
                         else:
@@ -490,12 +391,12 @@ def __compute_fista(schema_madlib, func_step_aggregate, func_state_diff,
                         it.kwargs["is_active"] = 1
             else:
                 if it.test("""
-                    {iteration} >= {max_iter} or
-                    {schema_madlib}.{func_state_diff}(
-                        _state_previous, _state_current) < {tolerance}
-                    """):
+                        {iteration} >= {max_iter} or
+                        {schema_madlib}.{func_state_diff}(
+                            _state_previous, _state_current) < {tolerance}
+                        """):
                     if (it.iteration < it.kwargs["max_iter"] and
-                        it.kwargs["lambda_count"] < it.kwargs["warm_no"]):
+                            it.kwargs["lambda_count"] < it.kwargs["warm_no"]):
                         it.kwargs["lambda_count"] += 1
                     else:
                         break

http://git-wip-us.apache.org/repos/asf/incubator-madlib/blob/6939fd63/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_igd.py_in
----------------------------------------------------------------------
diff --git a/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_igd.py_in b/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_igd.py_in
index 187cc83..f652ba0 100644
--- a/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_igd.py_in
+++ b/src/ports/postgres/modules/elastic_net/elastic_net_optimizer_igd.py_in
@@ -1,126 +1,56 @@
 
 import plpy
-import math
 from utilities.utilities import unique_string
 from utilities.in_mem_group_control import GroupIterationController
-from elastic_net_utils import __compute_means
-from elastic_net_utils import __normalize_data
-from elastic_net_utils import __compute_data_scales
-from elastic_net_utils import __tbl_dimension_rownum
-from elastic_net_utils import __elastic_net_validate_args
+from elastic_net_utils import _compute_means
+from elastic_net_utils import _normalize_data
+from elastic_net_utils import _compute_data_scales
+from elastic_net_utils import _tbl_dimension_rownum
+from elastic_net_utils import _elastic_net_validate_args
 from utilities.utilities import _array_to_string
-from elastic_net_utils import __compute_average_sq
-from elastic_net_utils import __generate_warmup_lambda_sequence
-from elastic_net_utils import __process_warmup_lambdas
-from elastic_net_generate_result import __elastic_net_generate_result
-from utilities.utilities import __mad_version
-from utilities.utilities import preprocess_keyvalue_params
+from elastic_net_utils import _compute_average_sq
+from elastic_net_utils import _generate_warmup_lambda_sequence
+from elastic_net_utils import _process_warmup_lambdas
+from elastic_net_generate_result import _elastic_net_generate_result
+from utilities.utilities import extract_keyvalue_params
 from utilities.control import MinWarning
 
-version_wrapper = __mad_version()
-mad_vec = version_wrapper.select_vecfunc()
-## ========================================================================
+# ------------------------------------------------------------------------
 
 
-def __igd_params_parser(optimizer_params, lambda_value, tolerance, schema_madlib):
+def _igd_params_parser(optimizer_params, lambda_value, tolerance, schema_madlib):
     """
     Parse IGD parameters.
     """
-    allowed_params = set(["stepsize", "warmup", "warmup_lambdas",
-                          "warmup_lambda_no",
-                          "threshold", "parallel", "warmup_tolerance",
-                          "step_decay"])
-    name_value = dict()
     # default values
-    name_value["parallel"] = True
-    name_value["stepsize"] = 0.01
-    name_value["warmup"] = False
-    name_value["warmup_lambdas"] = None
-    name_value["warmup_lambda_no"] = 15
-    name_value["threshold"] = 1e-10
-    name_value["warmup_tolerance"] = tolerance
-    name_value["step_decay"] = 0
-
-    warmup_lambdas = None
-    warmup_lambda_no = None
-
-    if optimizer_params is None or len(optimizer_params) == 0:
-        return name_value
-
-    for s in preprocess_keyvalue_params(optimizer_params):
-        items = s.split("=")
-        if (len(items) != 2):
-            plpy.error("Elastic Net error: Optimizer parameter list has incorrect format!")
-        param_name = items[0].strip(" \"").lower()
-        param_value = items[1].strip(" \"").lower()
-
-        if param_name not in allowed_params:
-            plpy.error(
-                """
-                Elastic Net error: {param_name} is not a valid parameter name for the IGD optimizer.
-                Run:
-
-                SELECT {schema_madlib}.elastic_net_train('igd');
-
-                to see the parameters for IGD algorithm.
-                """.format(param_name=param_name,
-                           schema_madlib=schema_madlib))
-
-        if param_name == "step_decay":
-            try:
-                name_value["step_decay"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: Decay of step must be a float number!")
-
-        if param_name == "stepsize":
-            try:
-                name_value["stepsize"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: stepsize must be a float number!")
-
-        if param_name == "warmup_tolerance":
-            try:
-                name_value["warmup_tolerance"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: warmup_tolerance must be a float number!")
-
-        if param_name == "warmup":
-            if param_value in ["true", "t", "yes", "y"]:
-                name_value["warmup"] = True
-            elif param_value in ["false", "f", "no", "n"]:
-                name_value["warmup"] = False
-            else:
-                plpy.error("Elastic Net error: Do you need warmup (True/False or yes/no) ?")
-
-        if param_name == "warmup_lambdas" and param_value != "null":
-            warmup_lambdas = param_value
-
-        if param_name == "warmup_lambda_no":
-            warmup_lambda_no = param_value
-
-        if param_name == "threshold":
-            try:
-                name_value["threshold"] = float(param_value)
-            except:
-                plpy.error("Elastic Net error: threshold must be a float number!")
-
-        if param_name == "parallel":
-            if param_value in ["true", "t", "yes", "y"]:
-                name_value["parallel"] = True
-            elif param_value in ["false", "f", "no", "n"]:
-                name_value["parallel"] = False
-            else:
-                plpy.error("Elastic Net error: Do you need parallel (True/False or yes/no) ? IGD in parallel might be slower !")
-
-    if name_value["warmup"]:
-        if warmup_lambdas is not None:
-            # errors are handled in __process_warmup_lambdas
-            name_value["warmup_lambdas"] = __process_warmup_lambdas(warmup_lambdas, lambda_value)
-        if warmup_lambda_no is not None:
-            try:
-                name_value["warmup_lambda_no"] = int(warmup_lambda_no)
-            except:
-                plpy.error("Elastic Net error: warmup_lambda_no must be an integer!")
+    defaults_and_types = {
+        "stepsize": (0.01, float),
+        "warmup": (False, bool),
+        "warmup_lambdas": (None, list),
+        "warmup_lambda_no": (15, int),
+        "threshold": (1e-10, float),
+        "parallel": (True, bool),
+        "step_decay": (0.0, float),
+        "warmup_tolerance": (tolerance, float)
+    }
+    param_defaults = dict([(k, v[0]) for k, v in defaults_and_types.items()])
+    param_types = dict([(k, v[1]) for k, v in defaults_and_types.items()])
+
+    if not optimizer_params:
+        return param_defaults
+
+    usage_str = ("Run:\n"
+                 "   SELECT {0}.elastic_net_train('igd');\n"
+                 "   to see the parameters for FISTA algorithm.".
+                 format(schema_madlib))
+    name_value = extract_keyvalue_params(optimizer_params, param_types,
+                                         param_defaults,
+                                         usage_str=usage_str,
+                                         ignore_invalid=True)
+
+    if name_value["warmup"] and name_value['warmup_lambdas'] is not None:
+        # errors are handled in _process_warmup_lambdas
+        name_value['warmup_lambdas'] = _process_warmup_lambdas(name_value['warmup_lambdas'], lambda_value)
 
     # validate the parameters
     if name_value["step_decay"] < 0:
@@ -140,13 +70,14 @@ def __igd_params_parser(optimizer_params, lambda_value, tolerance, schema_madlib
         plpy.error("Elastic Net error: A positive threshold is needed to screen out tiny values around zero!")
 
     return name_value
-## ========================================================================
+# ------------------------------------------------------------------------
+
 
-def __igd_construct_dict(schema_madlib, family, tbl_source,
-                         col_ind_var, col_dep_var,
-                         tbl_result, dimension, row_num, lambda_value, alpha,
-                         normalization, max_iter, tolerance, outstr_array,
-                         optimizer_params_dict):
+def _igd_construct_dict(schema_madlib, family, tbl_source,
+                        col_ind_var, col_dep_var,
+                        tbl_result, dimension, row_num, lambda_value, alpha,
+                        normalization, max_iter, tolerance, outstr_array,
+                        optimizer_params_dict):
     """
     Construct the dict used by a series of SQL queries in IGD optimizer.
     """
@@ -198,10 +129,10 @@ def __igd_construct_dict(schema_madlib, family, tbl_source,
     args["ymean_name"] = unique_string()
 
     return args
-## ========================================================================
+# ------------------------------------------------------------------------
 
 
-def __igd_cleanup_temp_tbls(**args):
+def _igd_cleanup_temp_tbls(**args):
     """
     Drop all temporary tables used by IGD optimizer,
     including tables used in the possible normalization
@@ -215,36 +146,36 @@ def __igd_cleanup_temp_tbls(**args):
                  drop table if exists pg_temp.{tbl_igd_state};
                  """.format(**args))
     return None
-## ========================================================================
-
-
-def __elastic_net_igd_train(schema_madlib, func_step_aggregate,
-                            func_state_diff, family,
-                            tbl_source, col_ind_var,
-                            col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                            normalization, optimizer_params, max_iter,
-                            tolerance, outstr_array, grouping_str,
-                            grouping_col, **kwargs):
-    __elastic_net_validate_args(tbl_source, col_ind_var, col_dep_var, tbl_result, tbl_summary,
-                                lambda_value, alpha, normalization, max_iter, tolerance)
-
-    return __elastic_net_igd_train_compute(schema_madlib, func_step_aggregate,
-                                           func_state_diff, family,
-                                           tbl_source, col_ind_var,
-                                           col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                           normalization, optimizer_params, max_iter,
-                                           tolerance, outstr_array, grouping_str,
-                                           grouping_col, **kwargs)
-## ========================================================================
-
-
-def __elastic_net_igd_train_compute(schema_madlib, func_step_aggregate,
-                                    func_state_diff, family,
-                                    tbl_source, col_ind_var,
-                                    col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
-                                    normalization, optimizer_params, max_iter,
-                                    tolerance, outstr_array, grouping_str,
-                                    grouping_col, **kwargs):
+# ------------------------------------------------------------------------
+
+
+def _elastic_net_igd_train(schema_madlib, func_step_aggregate,
+                           func_state_diff, family,
+                           tbl_source, col_ind_var,
+                           col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                           normalization, optimizer_params, max_iter,
+                           tolerance, outstr_array, grouping_str,
+                           grouping_col, **kwargs):
+    _elastic_net_validate_args(tbl_source, col_ind_var, col_dep_var, tbl_result, tbl_summary,
+                               lambda_value, alpha, normalization, max_iter, tolerance)
+
+    return _elastic_net_igd_train_compute(schema_madlib, func_step_aggregate,
+                                          func_state_diff, family,
+                                          tbl_source, col_ind_var,
+                                          col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                                          normalization, optimizer_params, max_iter,
+                                          tolerance, outstr_array, grouping_str,
+                                          grouping_col, **kwargs)
+# ------------------------------------------------------------------------
+
+
+def _elastic_net_igd_train_compute(schema_madlib, func_step_aggregate,
+                                   func_state_diff, family,
+                                   tbl_source, col_ind_var,
+                                   col_dep_var, tbl_result, tbl_summary, lambda_value, alpha,
+                                   normalization, optimizer_params, max_iter,
+                                   tolerance, outstr_array, grouping_str,
+                                   grouping_col, **kwargs):
     """
     Fit linear model with elastic net regularization using IGD optimization.
 
@@ -261,128 +192,123 @@ def __elastic_net_igd_train_compute(schema_madlib, func_step_aggregate,
     @param optimizer_params  Parameters of the above optimizer, the format
                              is '{arg = value, ...}'::varchar[]
     """
-    old_msg_level = plpy.execute("""
-                                 select setting from pg_settings
-                                 where name='client_min_messages'
-                                 """)[0]['setting']
-    plpy.execute("set client_min_messages to error")
-
-    (dimension, row_num) = __tbl_dimension_rownum(schema_madlib, tbl_source, col_ind_var)
-
-    # generate a full dict to ease the following string format
-    # including several temporary table names
-    args = __igd_construct_dict(schema_madlib, family, tbl_source, col_ind_var,
-                                col_dep_var, tbl_result,
-                                dimension, row_num, lambda_value, alpha, normalization,
-                                max_iter, tolerance, outstr_array,
-                                __igd_params_parser(optimizer_params, lambda_value,
-                                                    tolerance, schema_madlib))
-
-    args.update({'grouping_col': grouping_col})
-    # use normalized data or not
-    if normalization:
-        __normalize_data(args)
-        tbl_used = args["tbl_data_scaled"]
-        args["col_ind_var_new"] = args["col_ind_var_norm_new"]
-        args["col_dep_var_new"] = args["col_dep_var_norm_new"]
-    else:
-        __compute_data_scales(args)
-        tbl_used = tbl_source
-        args["col_ind_var_new"] = col_ind_var
-        args["col_dep_var_new"] = col_dep_var
-
-    args["tbl_used"] = tbl_used
-
-    # average squares of each feature
-    # used to estimate the largest lambda value
-    # also used to screen out tiny values, so order is needed
-    args["sq"] = __compute_average_sq(**args)
-    args["sq_str"] = _array_to_string(args["sq"])
-
-    if args["warmup_lambdas"] is not None:
-        args["warm_no"] = len(args["warmup_lambdas"])
-        args["warmup_lambdas"] = args["warmup_lambdas"]
-
-    if args["warmup"] and args["warmup_lambdas"] is None:
-        args["warmup_lambdas"] = \
-        __generate_warmup_lambda_sequence(
-           args["tbl_used"], args["col_ind_var_new"], args["col_dep_var_new"],
-           dimension, row_num, lambda_value, alpha,
-           args["warmup_lambda_no"], args["sq"])
-        args["warm_no"] = len(args["warmup_lambdas"])
-        args["warmup_lambdas"] = args["warmup_lambdas"]
-    elif args["warmup"] is False:
-        args["warm_no"] = 1
-        args["warmup_lambdas"] = [lambda_value]  # only one value
-
-    # parameter values required by the IGD optimizer
-    (xmean, ymean) = __compute_means(**args)
-
-    args.update({
-        'rel_args': args["tbl_igd_args"],
-        'rel_state': args["tbl_igd_state"],
-        'col_grp_iteration': unique_string(desp='col_grp_iteration'),
-        'col_grp_state': unique_string(desp='col_grp_state'),
-        'col_grp_key': unique_string(desp='col_grp_key'),
-        'col_n_tuples': unique_string(desp='col_n_tuples'),
-        'lambda_count': 1,
-        'state_type': "double precision[]",
-        'rel_source': tbl_used,
-        'grouping_str': grouping_str,
-        'xmean_val': xmean,
-        'ymean_val': ymean,
-        'tbl_source': tbl_source,
-        'tbl_summary': tbl_summary
+    with MinWarning('error'):
+        (dimension, row_num) = _tbl_dimension_rownum(schema_madlib, tbl_source, col_ind_var)
+
+        # generate a full dict to ease the following string format
+        # including several temporary table names
+        args = _igd_construct_dict(schema_madlib, family, tbl_source, col_ind_var,
+                                   col_dep_var, tbl_result,
+                                   dimension, row_num, lambda_value, alpha, normalization,
+                                   max_iter, tolerance, outstr_array,
+                                   _igd_params_parser(optimizer_params, lambda_value,
+                                                      tolerance, schema_madlib))
+
+        args.update({'grouping_col': grouping_col})
+        # use normalized data or not
+        if normalization:
+            _normalize_data(args)
+            tbl_used = args["tbl_data_scaled"]
+            args["col_ind_var_new"] = args["col_ind_var_norm_new"]
+            args["col_dep_var_new"] = args["col_dep_var_norm_new"]
+        else:
+            _compute_data_scales(args)
+            tbl_used = tbl_source
+            args["col_ind_var_new"] = col_ind_var
+            args["col_dep_var_new"] = col_dep_var
+
+        args["tbl_used"] = tbl_used
+
+        # average squares of each feature
+        # used to estimate the largest lambda value
+        # also used to screen out tiny values, so order is needed
+        args["sq"] = _compute_average_sq(**args)
+        args["sq_str"] = _array_to_string(args["sq"])
+
+        if args["warmup_lambdas"] is not None:
+            args["warm_no"] = len(args["warmup_lambdas"])
+            args["warmup_lambdas"] = args["warmup_lambdas"]
+
+        if args["warmup"] and args["warmup_lambdas"] is None:
+            args["warmup_lambdas"] = \
+                _generate_warmup_lambda_sequence(
+                args["tbl_used"], args["col_ind_var_new"], args["col_dep_var_new"],
+                dimension, row_num, lambda_value, alpha,
+                args["warmup_lambda_no"], args["sq"])
+            args["warm_no"] = len(args["warmup_lambdas"])
+            args["warmup_lambdas"] = args["warmup_lambdas"]
+        elif args["warmup"] is False:
+            args["warm_no"] = 1
+            args["warmup_lambdas"] = [lambda_value]  # only one value
+
+        # parameter values required by the IGD optimizer
+        (xmean, ymean) = _compute_means(**args)
+
+        args.update({
+            'rel_args': args["tbl_igd_args"],
+            'rel_state': args["tbl_igd_state"],
+            'col_grp_iteration': unique_string(desp='col_grp_iteration'),
+            'col_grp_state': unique_string(desp='col_grp_state'),
+            'col_grp_key': unique_string(desp='col_grp_key'),
+            'col_n_tuples': unique_string(desp='col_n_tuples'),
+            'lambda_count': 0,
+            'state_type': "double precision[]",
+            'rel_source': tbl_used,
+            'grouping_str': grouping_str,
+            'xmean_val': xmean,
+            'ymean_val': ymean,
+            'tbl_source': tbl_source,
+            'tbl_summary': tbl_summary
         })
-    if not args.get('parallel'):
-        func_step_aggregate += "_single_seg"
-    # perform the actual calculation
-    iteration_run = __compute_igd(schema_madlib,
-                                  func_step_aggregate,
-                                  func_state_diff,
-                                  args["tbl_igd_args"],
-                                  args["tbl_igd_state"], 
-                                  tbl_used,
-                                  args["col_ind_var_new"], 
-                                  args["col_dep_var_new"],
-                                  grouping_str,
-                                  grouping_col,
-                                  start_iter=0,
-                                  max_iter= args["max_iter"],
-                                  tolerance= args["tolerance"],
-                                  warmup_tolerance= args["warmup_tolerance"],
-                                  warm_no= args["warm_no"],
-                                  step_decay= args["step_decay"],
-                                  dimension= args["dimension"],
-                                  stepsize= args["stepsize"],
-                                  lambda_name= args["warmup_lambdas"],
-                                  warmup_lambda_value = args.get('warmup_lambdas')[args["lambda_count"]-1],
-                                  alpha= args["alpha"],
-                                  row_num= args["row_num"],
-                                  xmean_val= args["xmean_val"],
-                                  ymean_val= args["ymean_val"],
-                                  lambda_count= args["lambda_count"],
-                                  rel_state= args["tbl_igd_state"],
-                                  col_grp_iteration= args["col_grp_iteration"],
-                                  col_grp_state= args["col_grp_state"],
-                                  col_grp_key= args["col_grp_key"],
-                                  col_n_tuples= args["col_n_tuples"],
-                                  rel_source= args["rel_source"],
-                                  state_type= args["state_type"],)
-
-    __elastic_net_generate_result("igd", iteration_run, **args)
-
-    # cleanup
-    __igd_cleanup_temp_tbls(**args)
-    plpy.execute("set client_min_messages to " + old_msg_level)
+        if not args.get('parallel'):
+            func_step_aggregate += "_single_seg"
+        # perform the actual calculation
+        iteration_run = _compute_igd(schema_madlib,
+                                     func_step_aggregate,
+                                     func_state_diff,
+                                     args["tbl_igd_args"],
+                                     args["tbl_igd_state"],
+                                     tbl_used,
+                                     args["col_ind_var_new"],
+                                     args["col_dep_var_new"],
+                                     grouping_str,
+                                     grouping_col,
+                                     start_iter=0,
+                                     max_iter=args["max_iter"],
+                                     tolerance=args["tolerance"],
+                                     warmup_tolerance=args["warmup_tolerance"],
+                                     warm_no=args["warm_no"],
+                                     step_decay=args["step_decay"],
+                                     dimension=args["dimension"],
+                                     stepsize=args["stepsize"],
+                                     lambda_name=args["warmup_lambdas"],
+                                     warmup_lambda_value=args.get('warmup_lambdas')[args["lambda_count"]],
+                                     alpha=args["alpha"],
+                                     row_num=args["row_num"],
+                                     xmean_val=args["xmean_val"],
+                                     ymean_val=args["ymean_val"],
+                                     lambda_count=args["lambda_count"],
+                                     rel_state=args["tbl_igd_state"],
+                                     col_grp_iteration=args["col_grp_iteration"],
+                                     col_grp_state=args["col_grp_state"],
+                                     col_grp_key=args["col_grp_key"],
+                                     col_n_tuples=args["col_n_tuples"],
+                                     rel_source=args["rel_source"],
+                                     state_type=args["state_type"],)
+
+        _elastic_net_generate_result("igd", iteration_run, **args)
+
+        # cleanup
+        _igd_cleanup_temp_tbls(**args)
     return None
 
-## ========================================================================
+# ------------------------------------------------------------------------
 
-def __compute_igd(schema_madlib, func_step_aggregate, func_state_diff,
-                  tbl_args, tbl_state, tbl_source,
-                  col_ind_var, col_dep_var, grouping_str, grouping_col, 
-                  start_iter, **kwargs):
+
+def _compute_igd(schema_madlib, func_step_aggregate, func_state_diff,
+                 tbl_args, tbl_state, tbl_source,
+                 col_ind_var, col_dep_var, grouping_str, grouping_col,
+                 start_iter, **kwargs):
     """
     Driver function for elastic net with Gaussian response using IGD
 
@@ -403,7 +329,7 @@ def __compute_igd(schema_madlib, func_step_aggregate, func_state_diff,
         result in \c tbl_state
     """
     args = locals()
-    
+
     for k, v in kwargs.iteritems():
         if k not in args:
             args.update({k: v})
@@ -414,7 +340,7 @@ def __compute_igd(schema_madlib, func_step_aggregate, func_state_diff,
             # manually add the intercept term
             if (it.kwargs["lambda_count"] > len(args.get('lambda_name'))):
                 break
-            it.kwargs["warmup_lambda_value"] = args.get('lambda_name')[it.kwargs["lambda_count"]-1]
+            it.kwargs["warmup_lambda_value"] = args.get('lambda_name')[it.kwargs["lambda_count"] - 1]
             it.update("""
                     {schema_madlib}.{func_step_aggregate}(
                         ({col_ind_var})::double precision[],