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[],