#!/usr/bin/env python
# -*- encoding: utf-8 -*-
#
# This file is auto-generated by h2o-3/h2o-bindings/bin/gen_python.py
# Copyright 2016 H2O.ai; Apache License Version 2.0 (see LICENSE for details)
#
from __future__ import absolute_import, division, print_function, unicode_literals
import h2o
from h2o.estimators.estimator_base import H2OEstimator
from h2o.exceptions import H2OValueError
from h2o.frame import H2OFrame
from h2o.utils.typechecks import assert_is_type, Enum, numeric
[docs]class H2OGeneralizedLinearEstimator(H2OEstimator):
"""
Generalized Linear Modeling
Fits a generalized linear model, specified by a response variable, a set of predictors, and a
description of the error distribution.
A subclass of :class:`ModelBase` is returned. The specific subclass depends on the machine learning task
at hand (if it's binomial classification, then an H2OBinomialModel is returned, if it's regression then a
H2ORegressionModel is returned). The default print-out of the models is shown, but further GLM-specific
information can be queried out of the object. Upon completion of the GLM, the resulting object has
coefficients, normalized coefficients, residual/null deviance, aic, and a host of model metrics including
MSE, AUC (for logistic regression), degrees of freedom, and confusion matrices.
"""
algo = "glm"
param_names = {"model_id", "training_frame", "validation_frame", "nfolds", "seed", "keep_cross_validation_models",
"keep_cross_validation_predictions", "keep_cross_validation_fold_assignment", "fold_assignment",
"fold_column", "response_column", "ignored_columns", "random_columns", "ignore_const_cols",
"score_each_iteration", "offset_column", "weights_column", "family", "rand_family",
"tweedie_variance_power", "tweedie_link_power", "theta", "solver", "alpha", "lambda_",
"lambda_search", "early_stopping", "nlambdas", "standardize", "missing_values_handling",
"plug_values", "compute_p_values", "remove_collinear_columns", "intercept", "non_negative",
"max_iterations", "objective_epsilon", "beta_epsilon", "gradient_epsilon", "link", "rand_link",
"startval", "calc_like", "HGLM", "prior", "lambda_min_ratio", "beta_constraints",
"max_active_predictors", "interactions", "interaction_pairs", "obj_reg", "export_checkpoints_dir",
"balance_classes", "class_sampling_factors", "max_after_balance_size", "max_confusion_matrix_size",
"max_hit_ratio_k", "max_runtime_secs", "custom_metric_func"}
def __init__(self, **kwargs):
super(H2OGeneralizedLinearEstimator, self).__init__()
self._parms = {}
if "Lambda" in kwargs: kwargs["lambda_"] = kwargs.pop("Lambda")
for pname, pvalue in kwargs.items():
if pname == 'model_id':
self._id = pvalue
self._parms["model_id"] = pvalue
elif pname in self.param_names:
# Using setattr(...) will invoke type-checking of the arguments
setattr(self, pname, pvalue)
else:
raise H2OValueError("Unknown parameter %s = %r" % (pname, pvalue))
@property
def training_frame(self):
"""
Id of the training data frame.
Type: ``H2OFrame``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8],
... seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(seed=1234,
... family='binomial')
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.auc(train=True)
"""
return self._parms.get("training_frame")
@training_frame.setter
def training_frame(self, training_frame):
self._parms["training_frame"] = H2OFrame._validate(training_frame, 'training_frame')
@property
def validation_frame(self):
"""
Id of the validation data frame.
Type: ``H2OFrame``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(seed=1234,
... family='binomial')
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.auc(valid=True)
"""
return self._parms.get("validation_frame")
@validation_frame.setter
def validation_frame(self, validation_frame):
self._parms["validation_frame"] = H2OFrame._validate(validation_frame, 'validation_frame')
@property
def nfolds(self):
"""
Number of folds for K-fold cross-validation (0 to disable or >= 2).
Type: ``int`` (default: ``0``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> folds = 5
>>> cars_glm = H2OGeneralizedLinearEstimator(nfolds=folds,
... seed=1234,
... family='binomial')
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=cars)
>>> cars_glm.auc(xval=True)
"""
return self._parms.get("nfolds")
@nfolds.setter
def nfolds(self, nfolds):
assert_is_type(nfolds, None, int)
self._parms["nfolds"] = nfolds
@property
def seed(self):
"""
Seed for pseudo random number generator (if applicable)
Type: ``int`` (default: ``-1``).
:examples:
>>> airlines= h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip")
>>> airlines["Year"] = airlines["Year"].asfactor()
>>> airlines["Month"] = airlines["Month"].asfactor()
>>> airlines["DayOfWeek"] = airlines["DayOfWeek"].asfactor()
>>> airlines["Cancelled"] = airlines["Cancelled"].asfactor()
>>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()
>>> predictors = ["Origin", "Dest", "Year", "UniqueCarrier",
... "DayOfWeek", "Month", "Distance", "FlightNum"]
>>> response = "IsDepDelayed"
>>> train, valid = airlines.split_frame(ratios=[.8], seed=1234)
>>> glm_w_seed = H2OGeneralizedLinearEstimator(family='binomial',
... seed=1234)
>>> glm_w_seed.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(glm_w_seed_1.auc(valid=True))
"""
return self._parms.get("seed")
@seed.setter
def seed(self, seed):
assert_is_type(seed, None, int)
self._parms["seed"] = seed
@property
def keep_cross_validation_models(self):
"""
Whether to keep the cross-validation models.
Type: ``bool`` (default: ``True``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(keep_cross_validation_models=True,
... nfolds=5,
... seed=1234,
... family="binomial")
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train)
>>> cars_glm_cv_models = cars_glm.cross_validation_models()
>>> print(cars_glm.cross_validation_models())
"""
return self._parms.get("keep_cross_validation_models")
@keep_cross_validation_models.setter
def keep_cross_validation_models(self, keep_cross_validation_models):
assert_is_type(keep_cross_validation_models, None, bool)
self._parms["keep_cross_validation_models"] = keep_cross_validation_models
@property
def keep_cross_validation_predictions(self):
"""
Whether to keep the predictions of the cross-validation models.
Type: ``bool`` (default: ``False``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(keep_cross_validation_predictions=True,
... nfolds=5,
... seed=1234,
... family="binomial")
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train)
>>> cars_glm.cross_validation_predictions()
"""
return self._parms.get("keep_cross_validation_predictions")
@keep_cross_validation_predictions.setter
def keep_cross_validation_predictions(self, keep_cross_validation_predictions):
assert_is_type(keep_cross_validation_predictions, None, bool)
self._parms["keep_cross_validation_predictions"] = keep_cross_validation_predictions
@property
def keep_cross_validation_fold_assignment(self):
"""
Whether to keep the cross-validation fold assignment.
Type: ``bool`` (default: ``False``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(keep_cross_validation_fold_assignment=True,
... nfolds=5,
... seed=1234,
... family="binomial")
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train)
>>> cars_glm.cross_validation_fold_assignment()
"""
return self._parms.get("keep_cross_validation_fold_assignment")
@keep_cross_validation_fold_assignment.setter
def keep_cross_validation_fold_assignment(self, keep_cross_validation_fold_assignment):
assert_is_type(keep_cross_validation_fold_assignment, None, bool)
self._parms["keep_cross_validation_fold_assignment"] = keep_cross_validation_fold_assignment
@property
def fold_assignment(self):
"""
Cross-validation fold assignment scheme, if fold_column is not specified. The 'Stratified' option will stratify
the folds based on the response variable, for classification problems.
One of: ``"auto"``, ``"random"``, ``"modulo"``, ``"stratified"`` (default: ``"auto"``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> assignment_type = "Random"
>>> cars_gml = H2OGeneralizedLinearEstimator(fold_assignment=assignment_type,
... nfolds=5,
... family='binomial',
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=cars)
>>> cars_glm.auc(train=True)
"""
return self._parms.get("fold_assignment")
@fold_assignment.setter
def fold_assignment(self, fold_assignment):
assert_is_type(fold_assignment, None, Enum("auto", "random", "modulo", "stratified"))
self._parms["fold_assignment"] = fold_assignment
@property
def fold_column(self):
"""
Column with cross-validation fold index assignment per observation.
Type: ``str``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> fold_numbers = cars.kfold_column(n_folds=5, seed=1234)
>>> fold_numbers.set_names(["fold_numbers"])
>>> cars = cars.cbind(fold_numbers)
>>> print(cars['fold_numbers'])
>>> cars_glm = H2OGeneralizedLinearEstimator(seed=1234,
... family="binomial")
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=cars,
... fold_column="fold_numbers")
>>> cars_glm.auc(xval=True)
"""
return self._parms.get("fold_column")
@fold_column.setter
def fold_column(self, fold_column):
assert_is_type(fold_column, None, str)
self._parms["fold_column"] = fold_column
@property
def response_column(self):
"""
Response variable column.
Type: ``str``.
"""
return self._parms.get("response_column")
@response_column.setter
def response_column(self, response_column):
assert_is_type(response_column, None, str)
self._parms["response_column"] = response_column
@property
def ignored_columns(self):
"""
Names of columns to ignore for training.
Type: ``List[str]``.
"""
return self._parms.get("ignored_columns")
@ignored_columns.setter
def ignored_columns(self, ignored_columns):
assert_is_type(ignored_columns, None, [str])
self._parms["ignored_columns"] = ignored_columns
@property
def random_columns(self):
"""
random columns indices for HGLM.
Type: ``List[int]``.
"""
return self._parms.get("random_columns")
@random_columns.setter
def random_columns(self, random_columns):
assert_is_type(random_columns, None, [int])
self._parms["random_columns"] = random_columns
@property
def ignore_const_cols(self):
"""
Ignore constant columns.
Type: ``bool`` (default: ``True``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> cars["const_1"] = 6
>>> cars["const_2"] = 7
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(seed=1234,
... ignore_const_cols=True,
... family="binomial")
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.auc(valid=True)
"""
return self._parms.get("ignore_const_cols")
@ignore_const_cols.setter
def ignore_const_cols(self, ignore_const_cols):
assert_is_type(ignore_const_cols, None, bool)
self._parms["ignore_const_cols"] = ignore_const_cols
@property
def score_each_iteration(self):
"""
Whether to score during each iteration of model training.
Type: ``bool`` (default: ``False``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(score_each_iteration=True,
... seed=1234,
... family='binomial')
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.scoring_history()
"""
return self._parms.get("score_each_iteration")
@score_each_iteration.setter
def score_each_iteration(self, score_each_iteration):
assert_is_type(score_each_iteration, None, bool)
self._parms["score_each_iteration"] = score_each_iteration
@property
def offset_column(self):
"""
Offset column. This will be added to the combination of columns before applying the link function.
Type: ``str``.
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> boston["offset"] = boston["medv"].log()
>>> train, valid = boston.split_frame(ratios=[.8], seed=1234)
>>> boston_glm = H2OGeneralizedLinearEstimator(offset_column="offset",
... seed=1234)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse(valid=True)
"""
return self._parms.get("offset_column")
@offset_column.setter
def offset_column(self, offset_column):
assert_is_type(offset_column, None, str)
self._parms["offset_column"] = offset_column
@property
def weights_column(self):
"""
Column with observation weights. Giving some observation a weight of zero is equivalent to excluding it from the
dataset; giving an observation a relative weight of 2 is equivalent to repeating that row twice. Negative
weights are not allowed. Note: Weights are per-row observation weights and do not increase the size of the data
frame. This is typically the number of times a row is repeated, but non-integer values are supported as well.
During training, rows with higher weights matter more, due to the larger loss function pre-factor.
Type: ``str``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8], seed=1234)
>>> cars_glm = H2OGeneralizedLinearEstimator(seed=1234,
... family='binomial')
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid,
... weights_column="weight")
>>> cars_glm.auc(valid=True)
"""
return self._parms.get("weights_column")
@weights_column.setter
def weights_column(self, weights_column):
assert_is_type(weights_column, None, str)
self._parms["weights_column"] = weights_column
@property
def family(self):
"""
Family. Use binomial for classification with logistic regression, others are for regression problems.
One of: ``"gaussian"``, ``"binomial"``, ``"quasibinomial"``, ``"ordinal"``, ``"multinomial"``, ``"poisson"``,
``"gamma"``, ``"tweedie"``, ``"negativebinomial"`` (default: ``"gaussian"``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(family='binomial')
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.auc(valid = True)
"""
return self._parms.get("family")
@family.setter
def family(self, family):
assert_is_type(family, None, Enum("gaussian", "binomial", "quasibinomial", "ordinal", "multinomial", "poisson", "gamma", "tweedie", "negativebinomial"))
self._parms["family"] = family
@property
def rand_family(self):
"""
Random Component Family array. One for each random component. Only support gaussian for now.
Type: ``List[Enum["[gaussian]"]]``.
"""
return self._parms.get("rand_family")
@rand_family.setter
def rand_family(self, rand_family):
assert_is_type(rand_family, None, [Enum("[gaussian]")])
self._parms["rand_family"] = rand_family
@property
def tweedie_variance_power(self):
"""
Tweedie variance power
Type: ``float`` (default: ``0``).
:examples:
>>> auto = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/glm_test/auto.csv")
>>> predictors = auto.names
>>> predictors.remove('y')
>>> response = "y"
>>> train, valid = auto.split_frame(ratios=[.8])
>>> auto_glm = H2OGeneralizedLinearEstimator(family='tweedie',
... tweedie_variance_power=1)
>>> auto_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(auto_glm.mse(valid=True))
"""
return self._parms.get("tweedie_variance_power")
@tweedie_variance_power.setter
def tweedie_variance_power(self, tweedie_variance_power):
assert_is_type(tweedie_variance_power, None, numeric)
self._parms["tweedie_variance_power"] = tweedie_variance_power
@property
def tweedie_link_power(self):
"""
Tweedie link power
Type: ``float`` (default: ``1``).
:examples:
>>> auto = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/glm_test/auto.csv")
>>> predictors = auto.names
>>> predictors.remove('y')
>>> response = "y"
>>> train, valid = auto.split_frame(ratios=[.8])
>>> auto_glm = H2OGeneralizedLinearEstimator(family='tweedie',
... tweedie_link_power=1)
>>> auto_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(auto_glm.mse(valid=True))
"""
return self._parms.get("tweedie_link_power")
@tweedie_link_power.setter
def tweedie_link_power(self, tweedie_link_power):
assert_is_type(tweedie_link_power, None, numeric)
self._parms["tweedie_link_power"] = tweedie_link_power
@property
def theta(self):
"""
Theta
Type: ``float`` (default: ``1e-10``).
:examples:
>>> h2o_df = h2o.import_file("http://h2o-public-test-data.s3.amazonaws.com/smalldata/glm_test/Motor_insurance_sweden.txt")
>>> predictors = ["Payment", "Insured", "Kilometres", "Zone", "Bonus", "Make"]
>>> response = "Claims"
>>> negativebinomial_fit = H2OGeneralizedLinearEstimator(family="negativebinomial",
... link="identity",
... theta=0.5)
>>> negativebinomial_fit.train(x=predictors,
... y=response,
... training_frame=h2o_df)
>>> negativebinomial_fit.scoring_history()
"""
return self._parms.get("theta")
@theta.setter
def theta(self, theta):
assert_is_type(theta, None, numeric)
self._parms["theta"] = theta
@property
def solver(self):
"""
AUTO will set the solver based on given data and the other parameters. IRLSM is fast on on problems with small
number of predictors and for lambda-search with L1 penalty, L_BFGS scales better for datasets with many columns.
One of: ``"auto"``, ``"irlsm"``, ``"l_bfgs"``, ``"coordinate_descent_naive"``, ``"coordinate_descent"``,
``"gradient_descent_lh"``, ``"gradient_descent_sqerr"`` (default: ``"auto"``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(solver='irlsm')
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(boston_glm.mse(valid=True))
"""
return self._parms.get("solver")
@solver.setter
def solver(self, solver):
assert_is_type(solver, None, Enum("auto", "irlsm", "l_bfgs", "coordinate_descent_naive", "coordinate_descent", "gradient_descent_lh", "gradient_descent_sqerr"))
self._parms["solver"] = solver
@property
def alpha(self):
"""
Distribution of regularization between the L1 (Lasso) and L2 (Ridge) penalties. A value of 1 for alpha
represents Lasso regression, a value of 0 produces Ridge regression, and anything in between specifies the
amount of mixing between the two. Default value of alpha is 0 when SOLVER = 'L-BFGS'; 0.5 otherwise.
Type: ``List[float]``.
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(alpha=.25)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(boston_glm.mse(valid=True))
"""
return self._parms.get("alpha")
@alpha.setter
def alpha(self, alpha):
# For `alpha` and `lambda` the server reports type float[], while in practice simple floats are also ok
assert_is_type(alpha, None, numeric, [numeric])
self._parms["alpha"] = alpha
@property
def lambda_(self):
"""
Regularization strength
Type: ``List[float]``.
:examples:
>>> airlines= h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip")
>>> airlines["Year"] = airlines["Year"].asfactor()
>>> airlines["Month"] = airlines["Month"].asfactor()
>>> airlines["DayOfWeek"] = airlines["DayOfWeek"].asfactor()
>>> airlines["Cancelled"] = airlines["Cancelled"].asfactor()
>>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()
>>> predictors = ["Origin", "Dest", "Year", "UniqueCarrier",
... "DayOfWeek", "Month", "Distance", "FlightNum"]
>>> response = "IsDepDelayed"
>>> train, valid = airlines.split_frame(ratios=[.8])
>>> airlines_glm = H2OGeneralizedLinearEstimator(family='binomial',
... lambda_=.0001)
>>> airlines_glm.train(x=predictors,
... y=response
... trainig_frame=train,
... validation_frame=valid)
>>> print(airlines_glm.auc(valid=True))
"""
return self._parms.get("lambda")
@lambda_.setter
def lambda_(self, lambda_):
assert_is_type(lambda_, None, numeric, [numeric])
self._parms["lambda"] = lambda_
@property
def lambda_search(self):
"""
Use lambda search starting at lambda max, given lambda is then interpreted as lambda min
Type: ``bool`` (default: ``False``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(lambda_search=True)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(boston_glm.mse(valid=True))
"""
return self._parms.get("lambda_search")
@lambda_search.setter
def lambda_search(self, lambda_search):
assert_is_type(lambda_search, None, bool)
self._parms["lambda_search"] = lambda_search
@property
def early_stopping(self):
"""
Stop early when there is no more relative improvement on train or validation (if provided)
Type: ``bool`` (default: ``True``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(family='binomial',
... early_stopping=True)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.auc(valid=True)
"""
return self._parms.get("early_stopping")
@early_stopping.setter
def early_stopping(self, early_stopping):
assert_is_type(early_stopping, None, bool)
self._parms["early_stopping"] = early_stopping
@property
def nlambdas(self):
"""
Number of lambdas to be used in a search. Default indicates: If alpha is zero, with lambda search set to True,
the value of nlamdas is set to 30 (fewer lambdas are needed for ridge regression) otherwise it is set to 100.
Type: ``int`` (default: ``-1``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(lambda_search=True,
... nlambdas=50)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> print(boston_glm.mse(valid=True))
"""
return self._parms.get("nlambdas")
@nlambdas.setter
def nlambdas(self, nlambdas):
assert_is_type(nlambdas, None, int)
self._parms["nlambdas"] = nlambdas
@property
def standardize(self):
"""
Standardize numeric columns to have zero mean and unit variance
Type: ``bool`` (default: ``True``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(standardize=True)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse()
"""
return self._parms.get("standardize")
@standardize.setter
def standardize(self, standardize):
assert_is_type(standardize, None, bool)
self._parms["standardize"] = standardize
@property
def missing_values_handling(self):
"""
Handling of missing values. Either MeanImputation, Skip or PlugValues.
One of: ``"mean_imputation"``, ``"skip"``, ``"plug_values"`` (default: ``"mean_imputation"``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> boston.insert_missing_values()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(missing_values_handling="skip")
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse()
"""
return self._parms.get("missing_values_handling")
@missing_values_handling.setter
def missing_values_handling(self, missing_values_handling):
assert_is_type(missing_values_handling, None, Enum("mean_imputation", "skip", "plug_values"))
self._parms["missing_values_handling"] = missing_values_handling
@property
def plug_values(self):
"""
Plug Values (a single row frame containing values that will be used to impute missing values of the
training/validation frame, use with conjunction missing_values_handling = PlugValues)
Type: ``H2OFrame``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars = cars.drop(0)
>>> means = cars.mean()
>>> means = H2OFrame._expr(ExprNode("mean", cars, True, 0))
>>> glm_means = H2OGeneralizedLinearEstimator(seed=42)
>>> glm_means.train(training_frame=cars, y="cylinders")
>>> glm_plugs1 = H2OGeneralizedLinearEstimator(seed=42,
... missing_values_handling="PlugValues",
... plug_values=means)
>>> glm_plugs1.train(training_frame=cars, y="cylinders")
>>> glm_means.coef() == glm_plugs1.coef()
>>> not_means = 0.1 + (means * 0.5)
>>> glm_plugs2 = H2OGeneralizedLinearEstimator(seed=42,
... missing_values_handling="PlugValues",
... plug_values=not_means)
>>> glm_plugs2.train(training_frame=cars, y="cylinders")
>>> glm_means.coef() != glm_plugs2.coef()
"""
return self._parms.get("plug_values")
@plug_values.setter
def plug_values(self, plug_values):
self._parms["plug_values"] = H2OFrame._validate(plug_values, 'plug_values')
@property
def compute_p_values(self):
"""
Request p-values computation, p-values work only with IRLSM solver and no regularization
Type: ``bool`` (default: ``False``).
:examples:
>>> airlines= h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip")
>>> airlines["Year"] = airlines["Year"].asfactor()
>>> airlines["Month"] = airlines["Month"].asfactor()
>>> airlines["DayOfWeek"] = airlines["DayOfWeek"].asfactor()
>>> airlines["Cancelled"] = airlines["Cancelled"].asfactor()
>>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()
>>> predictors = ["Origin", "Dest", "Year", "UniqueCarrier",
... "DayOfWeek", "Month", "Distance", "FlightNum"]
>>> response = "IsDepDelayed"
>>> train, valid= airlines.split_frame(ratios=[.8])
>>> airlines_glm = H2OGeneralizedLinearEstimator(family='binomial',
... lambda_=0,
... remove_collinear_columns=True,
... compute_p_values=True)
>>> airlines_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> airlines_glm.mse()
"""
return self._parms.get("compute_p_values")
@compute_p_values.setter
def compute_p_values(self, compute_p_values):
assert_is_type(compute_p_values, None, bool)
self._parms["compute_p_values"] = compute_p_values
@property
def remove_collinear_columns(self):
"""
In case of linearly dependent columns, remove some of the dependent columns
Type: ``bool`` (default: ``False``).
:examples:
>>> airlines= h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip")
>>> airlines["Year"] = airlines["Year"].asfactor()
>>> airlines["Month"] = airlines["Month"].asfactor()
>>> airlines["DayOfWeek"] = airlines["DayOfWeek"].asfactor()
>>> airlines["Cancelled"] = airlines["Cancelled"].asfactor()
>>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()
>>> predictors = ["Origin", "Dest", "Year", "UniqueCarrier",
... "DayOfWeek", "Month", "Distance", "FlightNum"]
>>> response = "IsDepDelayed"
>>> train, valid = airlines.split_frame(ratios=[.8])
>>> airlines_glm = H2OGeneralizedLinearEstimator(family='binomial',
... lambda_=0,
... remove_collinear_columns=True)
>>> airlines_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> airlines_glm.auc()
"""
return self._parms.get("remove_collinear_columns")
@remove_collinear_columns.setter
def remove_collinear_columns(self, remove_collinear_columns):
assert_is_type(remove_collinear_columns, None, bool)
self._parms["remove_collinear_columns"] = remove_collinear_columns
@property
def intercept(self):
"""
Include constant term in the model
Type: ``bool`` (default: ``True``).
:examples:
>>> iris = h2o.import_file("http://h2o-public-test-data.s3.amazonaws.com/smalldata/iris/iris_wheader.csv")
>>> iris['class'] = iris['class'].asfactor()
>>> predictors = iris.columns[:-1]
>>> response = 'class'
>>> train, valid = iris.split_frame(ratios=[.8])
>>> iris_glm = H2OGeneralizedLinearEstimator(family='multinomial',
... intercept=True)
>>> iris_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> iris_glm.logloss(valid=True)
"""
return self._parms.get("intercept")
@intercept.setter
def intercept(self, intercept):
assert_is_type(intercept, None, bool)
self._parms["intercept"] = intercept
@property
def non_negative(self):
"""
Restrict coefficients (not intercept) to be non-negative
Type: ``bool`` (default: ``False``).
:examples:
>>> airlines = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip")
>>> airlines["Year"] = airlines["Year"].asfactor()
>>> airlines["Month"] = airlines["Month"].asfactor()
>>> airlines["DayOfWeek"] = airlines["DayOfWeek"].asfactor()
>>> airlines["Cancelled"] = airlines["Cancelled"].asfactor()
>>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()
>>> predictors = ["Origin", "Dest", "Year", "UniqueCarrier",
... "DayOfWeek", "Month", "Distance", "FlightNum"]
>>> response = "IsDepDelayed"
>>> train, valid= airlines.split_frame(ratios=[.8])
>>> airlines_glm = H2OGeneralizedLinearEstimator(family='binomial',
... non_negative=True)
>>> airlines_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> airlines_glm.auc()
"""
return self._parms.get("non_negative")
@non_negative.setter
def non_negative(self, non_negative):
assert_is_type(non_negative, None, bool)
self._parms["non_negative"] = non_negative
@property
def max_iterations(self):
"""
Maximum number of iterations
Type: ``int`` (default: ``-1``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(family='binomial',
... max_iterations=50)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("max_iterations")
@max_iterations.setter
def max_iterations(self, max_iterations):
assert_is_type(max_iterations, None, int)
self._parms["max_iterations"] = max_iterations
@property
def objective_epsilon(self):
"""
Converge if objective value changes less than this. Default indicates: If lambda_search is set to True the
value of objective_epsilon is set to .0001. If the lambda_search is set to False and lambda is equal to zero,
the value of objective_epsilon is set to .000001, for any other value of lambda the default value of
objective_epsilon is set to .0001.
Type: ``float`` (default: ``-1``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(objective_epsilon=1e-3)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse()
"""
return self._parms.get("objective_epsilon")
@objective_epsilon.setter
def objective_epsilon(self, objective_epsilon):
assert_is_type(objective_epsilon, None, numeric)
self._parms["objective_epsilon"] = objective_epsilon
@property
def beta_epsilon(self):
"""
Converge if beta changes less (using L-infinity norm) than beta esilon, ONLY applies to IRLSM solver
Type: ``float`` (default: ``0.0001``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(beta_epsilon=1e-3)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("beta_epsilon")
@beta_epsilon.setter
def beta_epsilon(self, beta_epsilon):
assert_is_type(beta_epsilon, None, numeric)
self._parms["beta_epsilon"] = beta_epsilon
@property
def gradient_epsilon(self):
"""
Converge if objective changes less (using L-infinity norm) than this, ONLY applies to L-BFGS solver. Default
indicates: If lambda_search is set to False and lambda is equal to zero, the default value of gradient_epsilon
is equal to .000001, otherwise the default value is .0001. If lambda_search is set to True, the conditional
values above are 1E-8 and 1E-6 respectively.
Type: ``float`` (default: ``-1``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(gradient_epsilon=1e-3)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse()
"""
return self._parms.get("gradient_epsilon")
@gradient_epsilon.setter
def gradient_epsilon(self, gradient_epsilon):
assert_is_type(gradient_epsilon, None, numeric)
self._parms["gradient_epsilon"] = gradient_epsilon
@property
def link(self):
"""
Link function.
One of: ``"family_default"``, ``"identity"``, ``"logit"``, ``"log"``, ``"inverse"``, ``"tweedie"``, ``"ologit"``
(default: ``"family_default"``).
:examples:
>>> iris = h2o.import_file("http://h2o-public-test-data.s3.amazonaws.com/smalldata/iris/iris_wheader.csv")
>>> iris['class'] = iris['class'].asfactor()
>>> predictors = iris.columns[:-1]
>>> response = 'class'
>>> train, valid = iris.split_frame(ratios=[.8])
>>> iris_glm = H2OGeneralizedLinearEstimator(family='multinomial',
... link='family_default')
>>> iris_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> iris_glm.logloss()
"""
return self._parms.get("link")
@link.setter
def link(self, link):
assert_is_type(link, None, Enum("family_default", "identity", "logit", "log", "inverse", "tweedie", "ologit"))
self._parms["link"] = link
@property
def rand_link(self):
"""
Link function array for random component in HGLM.
Type: ``List[Enum["[identity]", "[family_default]"]]``.
"""
return self._parms.get("rand_link")
@rand_link.setter
def rand_link(self, rand_link):
assert_is_type(rand_link, None, [Enum("[identity]", "[family_default]")])
self._parms["rand_link"] = rand_link
@property
def startval(self):
"""
double array to initialize fixed and random coefficients for HGLM.
Type: ``List[float]``.
"""
return self._parms.get("startval")
@startval.setter
def startval(self, startval):
assert_is_type(startval, None, [numeric])
self._parms["startval"] = startval
@property
def calc_like(self):
"""
if true, will return likelihood function value for HGLM.
Type: ``bool`` (default: ``False``).
"""
return self._parms.get("calc_like")
@calc_like.setter
def calc_like(self, calc_like):
assert_is_type(calc_like, None, bool)
self._parms["calc_like"] = calc_like
@property
def HGLM(self):
"""
If set to true, will return HGLM model. Otherwise, normal GLM model will be returned
Type: ``bool`` (default: ``False``).
"""
return self._parms.get("HGLM")
@HGLM.setter
def HGLM(self, HGLM):
assert_is_type(HGLM, None, bool)
self._parms["HGLM"] = HGLM
@property
def prior(self):
"""
Prior probability for y==1. To be used only for logistic regression iff the data has been sampled and the mean
of response does not reflect reality.
Type: ``float`` (default: ``-1``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm1 = H2OGeneralizedLinearEstimator(family='binomial', prior=0.5)
>>> cars_glm1.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm1.mse()
"""
return self._parms.get("prior")
@prior.setter
def prior(self, prior):
assert_is_type(prior, None, numeric)
self._parms["prior"] = prior
@property
def lambda_min_ratio(self):
"""
Minimum lambda used in lambda search, specified as a ratio of lambda_max (the smallest lambda that drives all
coefficients to zero). Default indicates: if the number of observations is greater than the number of variables,
then lambda_min_ratio is set to 0.0001; if the number of observations is less than the number of variables, then
lambda_min_ratio is set to 0.01.
Type: ``float`` (default: ``-1``).
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> boston_glm = H2OGeneralizedLinearEstimator(lambda_min_ratio=.0001)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse()
"""
return self._parms.get("lambda_min_ratio")
@lambda_min_ratio.setter
def lambda_min_ratio(self, lambda_min_ratio):
assert_is_type(lambda_min_ratio, None, numeric)
self._parms["lambda_min_ratio"] = lambda_min_ratio
@property
def beta_constraints(self):
"""
Beta constraints
Type: ``H2OFrame``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> n = len(predictors)
>>> constraints = h2o.H2OFrame({'names':predictors,
... 'lower_bounds': [-1000]*n,
... 'upper_bounds': [1000]*n,
... 'beta_given': [1]*n,
... 'rho': [0.2]*n})
>>> cars_glm = H2OGeneralizedLinearEstimator(standardize=True,
... beta_constraints=constraints)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("beta_constraints")
@beta_constraints.setter
def beta_constraints(self, beta_constraints):
self._parms["beta_constraints"] = H2OFrame._validate(beta_constraints, 'beta_constraints')
@property
def max_active_predictors(self):
"""
Maximum number of active predictors during computation. Use as a stopping criterion to prevent expensive model
building with many predictors. Default indicates: If the IRLSM solver is used, the value of
max_active_predictors is set to 5000 otherwise it is set to 100000000.
Type: ``int`` (default: ``-1``).
:examples:
>>> higgs= h2o.import_file("https://h2o-public-test-data.s3.amazonaws.com/smalldata/testng/higgs_train_5k.csv")
>>> predictors = higgs.names
>>> predictors.remove('response')
>>> response = "response"
>>> train, valid = higgs.split_frame(ratios=[.8])
>>> higgs_glm = H2OGeneralizedLinearEstimator(family='binomial',
... max_active_predictors=200)
>>> higgs_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> higgs_glm.auc()
"""
return self._parms.get("max_active_predictors")
@max_active_predictors.setter
def max_active_predictors(self, max_active_predictors):
assert_is_type(max_active_predictors, None, int)
self._parms["max_active_predictors"] = max_active_predictors
@property
def interactions(self):
"""
A list of predictor column indices to interact. All pairwise combinations will be computed for the list.
Type: ``List[str]``.
:examples:
>>> boston = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/BostonHousing.csv")
>>> predictors = boston.columns[:-1]
>>> response = "medv"
>>> boston['chas'] = boston['chas'].asfactor()
>>> train, valid = boston.split_frame(ratios=[.8])
>>> interactions_list = ['crim', 'dis']
>>> boston_glm = H2OGeneralizedLinearEstimator(interactions=interactions_list)
>>> boston_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> boston_glm.mse()
"""
return self._parms.get("interactions")
@interactions.setter
def interactions(self, interactions):
assert_is_type(interactions, None, [str])
self._parms["interactions"] = interactions
@property
def interaction_pairs(self):
"""
A list of pairwise (first order) column interactions.
Type: ``List[tuple]``.
:examples:
>>> df = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip")
>>> XY = [df.names[i-1] for i in [1,2,3,4,6,8,9,13,17,18,19,31]]
>>> interactions = [XY[i-1] for i in [5,7,9]]
>>> m = H2OGeneralizedLinearEstimator(lambda_search=True,
... family="binomial",
... interactions=interactions)
>>> m.train(x=XY[:len(XY)], y=XY[-1],training_frame=df)
>>> m._model_json['output']['coefficients_table']
>>> coef_m = m._model_json['output']['coefficients_table']
>>> interaction_pairs = [("CRSDepTime", "UniqueCarrier"),
... ("CRSDepTime", "Origin"),
... ("UniqueCarrier", "Origin")]
>>> mexp = H2OGeneralizedLinearEstimator(lambda_search=True,
... family="binomial",
... interaction_pairs=interaction_pairs)
>>> mexp.train(x=XY[:len(XY)], y=XY[-1],training_frame=df)
>>> mexp._model_json['output']['coefficients_table']
"""
return self._parms.get("interaction_pairs")
@interaction_pairs.setter
def interaction_pairs(self, interaction_pairs):
assert_is_type(interaction_pairs, None, [tuple])
self._parms["interaction_pairs"] = interaction_pairs
@property
def obj_reg(self):
"""
Likelihood divider in objective value computation, default is 1/nobs
Type: ``float`` (default: ``-1``).
:examples:
>>> df = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/bigdata/laptop/glm_ordinal_logit/ordinal_multinomial_training_set.csv")
>>> df["C11"] = df["C11"].asfactor()
>>> ordinal_fit = H2OGeneralizedLinearEstimator(family="ordinal",
... alpha=1.0,
... lambda_=0.000000001,
... obj_reg=0.00001,
... max_iterations=1000,
... beta_epsilon=1e-8,
... objective_epsilon=1e-10)
>>> ordinal_fit.train(x=list(range(0,10)),
... y="C11",
... training_frame=df)
>>> ordinal_fit.mse()
"""
return self._parms.get("obj_reg")
@obj_reg.setter
def obj_reg(self, obj_reg):
assert_is_type(obj_reg, None, numeric)
self._parms["obj_reg"] = obj_reg
@property
def export_checkpoints_dir(self):
"""
Automatically export generated models to this directory.
Type: ``str``.
:examples:
>>> import tempfile
>>> from os import listdir
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> checkpoints = tempfile.mkdtemp()
>>> cars_glm = H2OGeneralizedLinearEstimator(export_checkpoints_dir=checkpoints,
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
>>> len(listdir(checkpoints_dir))
"""
return self._parms.get("export_checkpoints_dir")
@export_checkpoints_dir.setter
def export_checkpoints_dir(self, export_checkpoints_dir):
assert_is_type(export_checkpoints_dir, None, str)
self._parms["export_checkpoints_dir"] = export_checkpoints_dir
@property
def balance_classes(self):
"""
Balance training data class counts via over/under-sampling (for imbalanced data).
Type: ``bool`` (default: ``False``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(balance_classes=True,
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("balance_classes")
@balance_classes.setter
def balance_classes(self, balance_classes):
assert_is_type(balance_classes, None, bool)
self._parms["balance_classes"] = balance_classes
@property
def class_sampling_factors(self):
"""
Desired over/under-sampling ratios per class (in lexicographic order). If not specified, sampling factors will
be automatically computed to obtain class balance during training. Requires balance_classes.
Type: ``List[float]``.
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> sample_factors = [1., 0.5, 1., 1., 1., 1., 1.]
>>> cars_glm = H2OGeneralizedLinearEstimator(balance_classes=True,
... class_sampling_factors=sample_factors,
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("class_sampling_factors")
@class_sampling_factors.setter
def class_sampling_factors(self, class_sampling_factors):
assert_is_type(class_sampling_factors, None, [float])
self._parms["class_sampling_factors"] = class_sampling_factors
@property
def max_after_balance_size(self):
"""
Maximum relative size of the training data after balancing class counts (can be less than 1.0). Requires
balance_classes.
Type: ``float`` (default: ``5``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> max = .85
>>> cars_glm = H2OGeneralizedLinearEstimator(balance_classes=True,
... max_after_balance_size=max,
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("max_after_balance_size")
@max_after_balance_size.setter
def max_after_balance_size(self, max_after_balance_size):
assert_is_type(max_after_balance_size, None, float)
self._parms["max_after_balance_size"] = max_after_balance_size
@property
def max_confusion_matrix_size(self):
"""
[Deprecated] Maximum size (# classes) for confusion matrices to be printed in the Logs
Type: ``int`` (default: ``20``).
"""
return self._parms.get("max_confusion_matrix_size")
@max_confusion_matrix_size.setter
def max_confusion_matrix_size(self, max_confusion_matrix_size):
assert_is_type(max_confusion_matrix_size, None, int)
self._parms["max_confusion_matrix_size"] = max_confusion_matrix_size
@property
def max_hit_ratio_k(self):
"""
Maximum number (top K) of predictions to use for hit ratio computation (for multi-class only, 0 to disable)
Type: ``int`` (default: ``0``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> predictors = ["displacement","power","weight","year"]
>>> response = "acceleration"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(max_hit_ratio_k=3,
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("max_hit_ratio_k")
@max_hit_ratio_k.setter
def max_hit_ratio_k(self, max_hit_ratio_k):
assert_is_type(max_hit_ratio_k, None, int)
self._parms["max_hit_ratio_k"] = max_hit_ratio_k
@property
def max_runtime_secs(self):
"""
Maximum allowed runtime in seconds for model training. Use 0 to disable.
Type: ``float`` (default: ``0``).
:examples:
>>> cars = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv")
>>> cars["economy_20mpg"] = cars["economy_20mpg"].asfactor()
>>> predictors = ["displacement","power","weight","acceleration","year"]
>>> response = "economy_20mpg"
>>> train, valid = cars.split_frame(ratios=[.8])
>>> cars_glm = H2OGeneralizedLinearEstimator(max_runtime_secs=10,
... seed=1234)
>>> cars_glm.train(x=predictors,
... y=response,
... training_frame=train,
... validation_frame=valid)
>>> cars_glm.mse()
"""
return self._parms.get("max_runtime_secs")
@max_runtime_secs.setter
def max_runtime_secs(self, max_runtime_secs):
assert_is_type(max_runtime_secs, None, numeric)
self._parms["max_runtime_secs"] = max_runtime_secs
@property
def custom_metric_func(self):
"""
Reference to custom evaluation function, format: `language:keyName=funcName`
Type: ``str``.
"""
return self._parms.get("custom_metric_func")
@custom_metric_func.setter
def custom_metric_func(self, custom_metric_func):
assert_is_type(custom_metric_func, None, str)
self._parms["custom_metric_func"] = custom_metric_func
@property
def Lambda(self):
"""DEPRECATED. Use ``self.lambda_`` instead"""
return self._parms["lambda"] if "lambda" in self._parms else None
@Lambda.setter
def Lambda(self, value):
self._parms["lambda"] = value
[docs] @staticmethod
def getGLMRegularizationPath(model):
"""
Extract full regularization path explored during lambda search from glm model.
:param model: source lambda search model
:examples:
>>> d = h2o.import_file("http://s3.amazonaws.com/h2o-public-test-data/smalldata/prostate/prostate.csv")
>>> m = H2OGeneralizedLinearEstimator(family = 'binomial',
... lambda_search = True,
... solver = 'COORDINATE_DESCENT')
>>> m.train(training_frame = d,
... x = [2,3,4,5,6,7,8],
... y = 1)
>>> r = H2OGeneralizedLinearEstimator.getGLMRegularizationPath(m)
>>> m2 = H2OGeneralizedLinearEstimator.makeGLMModel(model=m,
... coefs=r['coefficients'][10])
>>> dev1 = r['explained_deviance_train'][10]
>>> p = m2.model_performance(d)
>>> dev2 = 1-p.residual_deviance()/p.null_deviance()
>>> print(dev1, " =?= ", dev2)
"""
x = h2o.api("GET /3/GetGLMRegPath", data={"model": model._model_json["model_id"]["name"]})
ns = x.pop("coefficient_names")
res = {
"lambdas": x["lambdas"],
"explained_deviance_train": x["explained_deviance_train"],
"explained_deviance_valid": x["explained_deviance_valid"],
"coefficients": [dict(zip(ns, y)) for y in x["coefficients"]],
}
if "coefficients_std" in x:
res["coefficients_std"] = [dict(zip(ns, y)) for y in x["coefficients_std"]]
return res
[docs] @staticmethod
def makeGLMModel(model, coefs, threshold=.5):
"""
Create a custom GLM model using the given coefficients.
Needs to be passed source model trained on the dataset to extract the dataset information from.
:param model: source model, used for extracting dataset information
:param coefs: dictionary containing model coefficients
:param threshold: (optional, only for binomial) decision threshold used for classification
:examples:
>>> d = h2o.import_file("http://s3.amazonaws.com/h2o-public-test-data/smalldata/prostate/prostate.csv")
>>> m = H2OGeneralizedLinearEstimator(family='binomial',
... lambda_search=True,
... solver='COORDINATE_DESCENT')
>>> m.train(training_frame=d,
... x=[2,3,4,5,6,7,8],
... y=1)
>>> r = H2OGeneralizedLinearEstimator.getGLMRegularizationPath(m)
>>> m2 = H2OGeneralizedLinearEstimator.makeGLMModel(model=m,
... coefs=r['coefficients'][10])
>>> dev1 = r['explained_deviance_train'][10]
>>> p = m2.model_performance(d)
>>> dev2 = 1-p.residual_deviance()/p.null_deviance()
>>> print(dev1, " =?= ", dev2)
"""
model_json = h2o.api(
"POST /3/MakeGLMModel",
data={"model": model._model_json["model_id"]["name"],
"names": list(coefs.keys()),
"beta": list(coefs.values()),
"threshold": threshold}
)
m = H2OGeneralizedLinearEstimator()
m._resolve_model(model_json["model_id"]["name"], model_json)
return m