Terms¶

class
pygam.terms.
Term
(feature, lam=0.6, dtype='numerical', fit_linear=False, fit_splines=True, penalties='auto', constraints=None, verbose=False)¶ Bases:
pygam.core.Core

build_columns
(X, verbose=False)¶ construct the model matrix columns for the term
Parameters:  X (arraylike) – Input dataset with n rows
 verbose (bool) – whether to show warnings
Returns: Return type: scipy sparse array with n rows

build_constraints
(coef, constraint_lam, constraint_l2)¶ builds the GAM blockdiagonal constraint matrix in quadratic form out of constraint matrices specified for each feature.
behaves like a penalty, but with a very large lambda value, ie 1e6.
Parameters: Returns: C
Return type: sparse CSC matrix containing the model constraints in quadratic form

classmethod
build_from_info
(info)¶ build a Term instance from a dict
Parameters:  cls (class) –
 info (dict) – contains all information needed to build the term
Returns: Return type: Term instance

build_penalties
(verbose=False)¶ builds the GAM blockdiagonal penalty matrix in quadratic form out of penalty matrices specified for each feature.
each feature penalty matrix is multiplied by a lambda for that feature.
so for m features: P = block_diag[lam0 * P0, lam1 * P1, lam2 * P2, … , lamm * Pm]
Parameters: None – Returns: P Return type: sparse CSC matrix containing the model penalties in quadratic form

compile
(X, verbose=False)¶ method to validate and prepare datadependent parameters
Parameters:  X (arraylike) – Input dataset
 verbose (bool) – whether to show warnings
Returns: Return type:

hasconstraint
¶ bool, whether the term has any constraints

info
¶ get information about this term
Returns: Return type: dict containing information to duplicate this term

isintercept
¶

istensor
¶

n_coefs
¶ Number of coefficients contributed by the term to the model


class
pygam.terms.
LinearTerm
(feature, lam=0.6, penalties='auto', verbose=False)¶ Bases:
pygam.terms.Term

build_columns
(X, verbose=False)¶ construct the model matrix columns for the term
Parameters:  X (arraylike) – Input dataset with n rows
 verbose (bool) – whether to show warnings
Returns: Return type: scipy sparse array with n rows

build_constraints
(coef, constraint_lam, constraint_l2)¶ builds the GAM blockdiagonal constraint matrix in quadratic form out of constraint matrices specified for each feature.
behaves like a penalty, but with a very large lambda value, ie 1e6.
Parameters: Returns: C
Return type: sparse CSC matrix containing the model constraints in quadratic form

classmethod
build_from_info
(info)¶ build a Term instance from a dict
Parameters:  cls (class) –
 info (dict) – contains all information needed to build the term
Returns: Return type: Term instance

build_penalties
(verbose=False)¶ builds the GAM blockdiagonal penalty matrix in quadratic form out of penalty matrices specified for each feature.
each feature penalty matrix is multiplied by a lambda for that feature.
so for m features: P = block_diag[lam0 * P0, lam1 * P1, lam2 * P2, … , lamm * Pm]
Parameters: None – Returns: P Return type: sparse CSC matrix containing the model penalties in quadratic form

compile
(X, verbose=False)¶ method to validate and prepare datadependent parameters
Parameters:  X (arraylike) – Input dataset
 verbose (bool) – whether to show warnings
Returns: Return type:

get_params
(deep=False)¶ returns a dict of all of the object’s userfacing parameters
Parameters: deep (boolean, default: False) – when True, also gets nonuserfacing paramters Returns: Return type: dict

hasconstraint
¶ bool, whether the term has any constraints

info
¶ get information about this term
Returns: Return type: dict containing information to duplicate this term

isintercept
¶

istensor
¶

n_coefs
¶ Number of coefficients contributed by the term to the model

set_params
(deep=False, force=False, **parameters)¶ sets an object’s paramters
Parameters:  deep (boolean, default: False) – when True, also sets nonuserfacing paramters
 force (boolean, default: False) – when True, also sets parameters that the object does not already have
 **parameters (paramters to set) –
Returns: Return type: self


class
pygam.terms.
SplineTerm
(feature, n_splines=20, spline_order=3, lam=0.6, penalties='auto', constraints=None, dtype='numerical', basis='ps', by=None, edge_knots=None, verbose=False)¶ Bases:
pygam.terms.Term

build_columns
(X, verbose=False)¶ construct the model matrix columns for the term
Parameters:  X (arraylike) – Input dataset with n rows
 verbose (bool) – whether to show warnings
Returns: Return type: scipy sparse array with n rows

build_constraints
(coef, constraint_lam, constraint_l2)¶ builds the GAM blockdiagonal constraint matrix in quadratic form out of constraint matrices specified for each feature.
behaves like a penalty, but with a very large lambda value, ie 1e6.
Parameters: Returns: C
Return type: sparse CSC matrix containing the model constraints in quadratic form

classmethod
build_from_info
(info)¶ build a Term instance from a dict
Parameters:  cls (class) –
 info (dict) – contains all information needed to build the term
Returns: Return type: Term instance

build_penalties
(verbose=False)¶ builds the GAM blockdiagonal penalty matrix in quadratic form out of penalty matrices specified for each feature.
each feature penalty matrix is multiplied by a lambda for that feature.
so for m features: P = block_diag[lam0 * P0, lam1 * P1, lam2 * P2, … , lamm * Pm]
Parameters: None – Returns: P Return type: sparse CSC matrix containing the model penalties in quadratic form

compile
(X, verbose=False)¶ method to validate and prepare datadependent parameters
Parameters:  X (arraylike) – Input dataset
 verbose (bool) – whether to show warnings
Returns: Return type:

get_params
(deep=False)¶ returns a dict of all of the object’s userfacing parameters
Parameters: deep (boolean, default: False) – when True, also gets nonuserfacing paramters Returns: Return type: dict

hasconstraint
¶ bool, whether the term has any constraints

info
¶ get information about this term
Returns: Return type: dict containing information to duplicate this term

isintercept
¶

istensor
¶

n_coefs
¶ Number of coefficients contributed by the term to the model

set_params
(deep=False, force=False, **parameters)¶ sets an object’s paramters
Parameters:  deep (boolean, default: False) – when True, also sets nonuserfacing paramters
 force (boolean, default: False) – when True, also sets parameters that the object does not already have
 **parameters (paramters to set) –
Returns: Return type: self


class
pygam.terms.
FactorTerm
(feature, lam=0.6, penalties='auto', coding='onehot', verbose=False)¶ Bases:
pygam.terms.SplineTerm

build_columns
(X, verbose=False)¶ construct the model matrix columns for the term
Parameters:  X (arraylike) – Input dataset with n rows
 verbose (bool) – whether to show warnings
Returns: Return type: scipy sparse array with n rows

build_constraints
(coef, constraint_lam, constraint_l2)¶ builds the GAM blockdiagonal constraint matrix in quadratic form out of constraint matrices specified for each feature.
behaves like a penalty, but with a very large lambda value, ie 1e6.
Parameters: Returns: C
Return type: sparse CSC matrix containing the model constraints in quadratic form

classmethod
build_from_info
(info)¶ build a Term instance from a dict
Parameters:  cls (class) –
 info (dict) – contains all information needed to build the term
Returns: Return type: Term instance

build_penalties
(verbose=False)¶ builds the GAM blockdiagonal penalty matrix in quadratic form out of penalty matrices specified for each feature.
each feature penalty matrix is multiplied by a lambda for that feature.
so for m features: P = block_diag[lam0 * P0, lam1 * P1, lam2 * P2, … , lamm * Pm]
Parameters: None – Returns: P Return type: sparse CSC matrix containing the model penalties in quadratic form

compile
(X, verbose=False)¶ method to validate and prepare datadependent parameters
Parameters:  X (arraylike) – Input dataset
 verbose (bool) – whether to show warnings
Returns: Return type:

get_params
(deep=False)¶ returns a dict of all of the object’s userfacing parameters
Parameters: deep (boolean, default: False) – when True, also gets nonuserfacing paramters Returns: Return type: dict

hasconstraint
¶ bool, whether the term has any constraints

info
¶ get information about this term
Returns: Return type: dict containing information to duplicate this term

isintercept
¶

istensor
¶

n_coefs
¶ Number of coefficients contributed by the term to the model

set_params
(deep=False, force=False, **parameters)¶ sets an object’s paramters
Parameters:  deep (boolean, default: False) – when True, also sets nonuserfacing paramters
 force (boolean, default: False) – when True, also sets parameters that the object does not already have
 **parameters (paramters to set) –
Returns: Return type: self


class
pygam.terms.
TensorTerm
(*args, **kwargs)¶ Bases:
pygam.terms.SplineTerm
,pygam.terms.MetaTermMixin

build_columns
(X, verbose=False)¶ construct the model matrix columns for the term
Parameters:  X (arraylike) – Input dataset with n rows
 verbose (bool) – whether to show warnings
Returns: Return type: scipy sparse array with n rows

build_constraints
(coef, constraint_lam, constraint_l2)¶ builds the GAM blockdiagonal constraint matrix in quadratic form out of constraint matrices specified for each feature.
Parameters: Returns: C
Return type: sparse CSC matrix containing the model constraints in quadratic form

classmethod
build_from_info
(info)¶ build a TensorTerm instance from a dict
Parameters:  cls (class) –
 info (dict) – contains all information needed to build the term
Returns: Return type: TensorTerm instance

build_penalties
()¶ builds the GAM blockdiagonal penalty matrix in quadratic form out of penalty matrices specified for each feature.
each feature penalty matrix is multiplied by a lambda for that feature.
so for m features: P = block_diag[lam0 * P0, lam1 * P1, lam2 * P2, … , lamm * Pm]
Parameters: None – Returns: P Return type: sparse CSC matrix containing the model penalties in quadratic form

compile
(X, verbose=False)¶ method to validate and prepare datadependent parameters
Parameters:  X (arraylike) – Input dataset
 verbose (bool) – whether to show warnings
Returns: Return type:

get_params
(deep=False)¶ returns a dict of all of the object’s userfacing parameters
Parameters: deep (boolean, default: False) – when True, also gets nonuserfacing paramters Returns: Return type: dict

hasconstraint
¶ bool, whether the term has any constraints

info
¶ get information about this term
Returns: Return type: dict containing information to duplicate this term

isintercept
¶

istensor
¶

n_coefs
¶ Number of coefficients contributed by the term to the model

set_params
(deep=False, force=False, **parameters)¶ sets an object’s paramters
Parameters:  deep (boolean, default: False) – when True, also sets nonuserfacing paramters
 force (boolean, default: False) – when True, also sets parameters that the object does not already have
 **parameters (paramters to set) –
Returns: Return type: self


class
pygam.terms.
TermList
(*terms, **kwargs)¶ Bases:
pygam.core.Core
,pygam.terms.MetaTermMixin

build_columns
(X, term=1, verbose=False)¶ construct the model matrix columns for the term
Parameters:  X (arraylike) – Input dataset with n rows
 verbose (bool) – whether to show warnings
Returns: Return type: scipy sparse array with n rows

build_constraints
(coefs, constraint_lam, constraint_l2)¶ builds the GAM blockdiagonal constraint matrix in quadratic form out of constraint matrices specified for each feature.
behaves like a penalty, but with a very large lambda value, ie 1e6.
Parameters: Returns: C
Return type: sparse CSC matrix containing the model constraints in quadratic form

classmethod
build_from_info
(info)¶ build a TermList instance from a dict
Parameters:  cls (class) –
 info (dict) – contains all information needed to build the term
Returns: Return type: TermList instance

build_penalties
()¶ builds the GAM blockdiagonal penalty matrix in quadratic form out of penalty matrices specified for each feature.
each feature penalty matrix is multiplied by a lambda for that feature.
so for m features: P = block_diag[lam0 * P0, lam1 * P1, lam2 * P2, … , lamm * Pm]
Parameters: None – Returns: P Return type: sparse CSC matrix containing the model penalties in quadratic form

compile
(X, verbose=False)¶ method to validate and prepare datadependent parameters
Parameters:  X (arraylike) – Input dataset
 verbose (bool) – whether to show warnings
Returns: Return type:

get_coef_indices
(i=1)¶ get the indices for the coefficients of a term in the term list
Parameters: i (int) – by default int=1, meaning that coefficient indices are returned for all terms in the term list Returns: Return type: list of integers

get_params
(deep=False)¶ returns a dict of all of the object’s userfacing parameters
Parameters: deep (boolean, default: False) – when True, also gets nonuserfacing paramters Returns: Return type: dict

hasconstraint
¶ bool, whether the term has any constraints

info
¶ get information about the terms in the term list
Returns: Return type: dict containing information to duplicate the term list

n_coefs
¶ Total number of coefficients contributed by the terms in the model

pop
(i=None)¶ remove the ith term from the term list
Parameters: i (int, optional) – term to remove from term list
by default the last term is popped.
Returns: term Return type: Term

set_params
(deep=False, force=False, **parameters)¶ sets an object’s paramters
Parameters:  deep (boolean, default: False) – when True, also sets nonuserfacing paramters
 force (boolean, default: False) – when True, also sets parameters that the object does not already have
 **parameters (paramters to set) –
Returns: Return type: self
