# gle properties #

![GLE node icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/images/glenodeicon.png)A GLE extends the linear model so that the target can have a non\-normal distribution, is linearly related to the factors and covariates via a specified link function, and so that the observations can be correlated\. Generalized linear mixed models cover a wide variety of models, from simple linear regression to complex multilevel models for non\-normal longitudinal data\.

<!-- <table "summary="gle properties" id="glenodeslots__table_utv_kw1_zs" class="defaultstyle" "> -->

gle properties  

Table 1\. gle properties

| `gle` Properties                  | Values                                                                                                                                                                                                                                                                                                       | Property description                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `custom_target`                   | *flag*                                                                                                                                                                                                                                                                                                       | Indicates whether to use target defined in upstream node (`false`) or custom target specified by `target_field` (`true`)\.                                                                                                                                                                                                                                                                                                                                                |
| `target_field`                    | *field*                                                                                                                                                                                                                                                                                                      | Field to use as target if `custom_target` is `true`\.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `use_trials`                      | *flag*                                                                                                                                                                                                                                                                                                       | Indicates whether additional field or value specifying number of trials is to be used when target response is a number of events occurring in a set of trials\. Default is `false`\.                                                                                                                                                                                                                                                                                      |
| `use_trials_field_or_value`       | `Field`  <br>`Value`                                                                                                                                                                                                                                                                                         | Indicates whether field (default) or value is used to specify number of trials\.                                                                                                                                                                                                                                                                                                                                                                                          |
| `trials_field`                    | *field*                                                                                                                                                                                                                                                                                                      | Field to use to specify number of trials\.                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `trials_value`                    | *integer*                                                                                                                                                                                                                                                                                                    | Value to use to specify number of trials\. If specified, minimum value is 1\.                                                                                                                                                                                                                                                                                                                                                                                             |
| `use_custom_target_reference`     | *flag*                                                                                                                                                                                                                                                                                                       | Indicates whether custom reference category is to be used for a categorical target\. Default is `false`\.                                                                                                                                                                                                                                                                                                                                                                 |
| `target_reference_value`          | *string*                                                                                                                                                                                                                                                                                                     | Reference category to use if `use_custom_target_reference` is `true`\.                                                                                                                                                                                                                                                                                                                                                                                                    |
| `dist_link_combination`           | `NormalIdentity`  <br>`GammaLog`  <br>`PoissonLog`  <br>`NegbinLog`  <br>`TweedieIdentity`  <br>`NominalLogit`  <br>`BinomialLogit`  <br>`BinomialProbit`  <br>`BinomialLogC`  <br>`CUSTOM`                                                                                                                  | Common models for distribution of values for target\. Choose `CUSTOM` to specify a distribution from the list provided by `target_distribution`\.                                                                                                                                                                                                                                                                                                                         |
| `target_distribution`             | `Normal`  <br>`Binomial`  <br>`Multinomial`  <br>`Gamma`  <br>`INVERSE_GAUSS`  <br>`NEG_BINOMIAL`  <br>`Poisson`  <br>`TWEEDIE`  <br>`UNKNOWN`                                                                                                                                                               | Distribution of values for target when `dist_link_combination` is `Custom`\.                                                                                                                                                                                                                                                                                                                                                                                              |
| `link_function_type`              | `UNKNOWN`  <br>`IDENTITY`  <br>`LOG`  <br>`LOGIT`  <br>`PROBIT`  <br>`COMPL_LOG_LOG`  <br>`POWER`  <br>`LOG_COMPL`  <br>`NEG_LOG_LOG`  <br>`ODDS_POWER`  <br>`NEG_BINOMIAL`  <br>`GEN_LOGIT`  <br>`CUMUL_LOGIT`  <br>`CUMUL_PROBIT`  <br>`CUMUL_COMPL_LOG_LOG`  <br>`CUMUL_NEG_LOG_LOG`  <br>`CUMUL_CAUCHIT` | Link function to relate target values to predictors\. If `target_distribution` is `Binomial` you can use:  <br><br>`UNKNOWN``IDENTITY``LOG``LOGIT``PROBIT``COMPL_LOG_LOG``POWER``LOG_COMPL``NEG_LOG_LOG``ODDS_POWER`<br><br>If `target_distribution` is `NEG_BINOMIAL` you can use:<br><br>`NEG_BINOMIAL`<br><br>If `target_distribution` is `UNKNOWN`, you can use:<br><br>`GEN_LOGIT``CUMUL_LOGIT``CUMUL_PROBIT``CUMUL_COMPL_LOG_LOG``CUMUL_NEG_LOG_LOG``CUMUL_CAUCHIT` |
| `link_function_param`             | *number*                                                                                                                                                                                                                                                                                                     | Tweedie parameter value to use\. Only applicable if `normal_link_function` or `link_function_type` is `POWER`\.                                                                                                                                                                                                                                                                                                                                                           |
| `tweedie_param`                   | *number*                                                                                                                                                                                                                                                                                                     | Link function parameter value to use\. Only applicable if `dist_link_combination` is set to `TweedieIdentity`, or `link_function_type` is `TWEEDIE`\.                                                                                                                                                                                                                                                                                                                     |
| `use_predefined_inputs`           | *flag*                                                                                                                                                                                                                                                                                                       | Indicates whether model effect fields are to be those defined upstream as input fields (`true`) or those from `fixed_effects_list` (`false`)\.                                                                                                                                                                                                                                                                                                                            |
| `model_effects_list`              | *structured*                                                                                                                                                                                                                                                                                                 | If `use_predefined_inputs` is `false`, specifies the input fields to use as model effect fields\.                                                                                                                                                                                                                                                                                                                                                                         |
| `use_intercept`                   | *flag*                                                                                                                                                                                                                                                                                                       | If `true` (default), includes the intercept in the model\.                                                                                                                                                                                                                                                                                                                                                                                                                |
| `regression_weight_field`         | *field*                                                                                                                                                                                                                                                                                                      | Field to use as analysis weight field\.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `use_offset`                      | `None`  <br>`Value`  <br>`Variable`                                                                                                                                                                                                                                                                          | Indicates how offset is specified\. Value `None` means no offset is used\.                                                                                                                                                                                                                                                                                                                                                                                                |
| `offset_value`                    | *number*                                                                                                                                                                                                                                                                                                     | Value to use for offset if `use_offset` is set to `offset_value`\.                                                                                                                                                                                                                                                                                                                                                                                                        |
| `offset_field`                    | *field*                                                                                                                                                                                                                                                                                                      | Field to use for offset value if `use_offset` is set to `offset_field`\.                                                                                                                                                                                                                                                                                                                                                                                                  |
| `target_category_order`           | `Ascending`  <br>`Descending`                                                                                                                                                                                                                                                                                | Sorting order for categorical targets\. Default is `Ascending`\.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `inputs_category_order`           | `Ascending`  <br>`Descending`                                                                                                                                                                                                                                                                                | Sorting order for categorical predictors\. Default is `Ascending`\.                                                                                                                                                                                                                                                                                                                                                                                                       |
| `max_iterations`                  | *integer*                                                                                                                                                                                                                                                                                                    | Maximum number of iterations the algorithm will perform\. A non\-negative integer; default is 100\.                                                                                                                                                                                                                                                                                                                                                                       |
| `confidence_level`                | *number*                                                                                                                                                                                                                                                                                                     | Confidence level used to compute interval estimates of the model coefficients\. A non\-negative integer; maximum is 100, default is 95\.                                                                                                                                                                                                                                                                                                                                  |
| `test_fixed_effects_coeffecients` | `Model`  <br>`Robust`                                                                                                                                                                                                                                                                                        | Method for computing the parameter estimates covariance matrix\.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `detect_outliers`                 | *flag*                                                                                                                                                                                                                                                                                                       | When true the algorithm finds influential outliers for all distributions except multinomial distribution\.                                                                                                                                                                                                                                                                                                                                                                |
| `conduct_trend_analysis`          | *flag*                                                                                                                                                                                                                                                                                                       | When true the algorithm conducts trend analysis for the scatter plot\.                                                                                                                                                                                                                                                                                                                                                                                                    |
| `estimation_method`               | `FISHER_SCORING`  <br>`NEWTON_RAPHSON`  <br>`HYBRID`                                                                                                                                                                                                                                                         | Specify the maximum likelihood estimation algorithm\.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `max_fisher_iterations`           | *integer*                                                                                                                                                                                                                                                                                                    | If using the `FISHER_SCORING``estimation_method`, the maximum number of iterations\. Minimum 0, maximum 20\.                                                                                                                                                                                                                                                                                                                                                              |
| `scale_parameter_method`          | `MLE`  <br>`FIXED`  <br>`DEVIANCE`  <br>`PEARSON_CHISQUARE`                                                                                                                                                                                                                                                  | Specify the method to be used for the estimation of the scale parameter\.                                                                                                                                                                                                                                                                                                                                                                                                 |
| `scale_value`                     | *number*                                                                                                                                                                                                                                                                                                     | Only available if `scale_parameter_method` is set to `Fixed`\.                                                                                                                                                                                                                                                                                                                                                                                                            |
| `negative_binomial_method`        | `MLE`  <br>`FIXED`                                                                                                                                                                                                                                                                                           | Specify the method to be for the estimation of the negative binomial ancillary parameter\.                                                                                                                                                                                                                                                                                                                                                                                |
| `negative_binomial_value`         | *number*                                                                                                                                                                                                                                                                                                     | Only available if `negative_binomial_method` is set to `Fixed`\.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `use_p_converge`                  | *flag*                                                                                                                                                                                                                                                                                                       | Option for parameter convergence\.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `p_converge`                      | *number*                                                                                                                                                                                                                                                                                                     | Blank, or any positive value\.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `p_converge_type`                 | *flag*                                                                                                                                                                                                                                                                                                       | True = Absolute, False = Relative                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `use_l_converge`                  | *flag*                                                                                                                                                                                                                                                                                                       | Option for log\-likelihood convergence\.                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `l_converge`                      | *number*                                                                                                                                                                                                                                                                                                     | Blank, or any positive value\.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `l_converge_type`                 | *flag*                                                                                                                                                                                                                                                                                                       | True = Absolute, False = Relative                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `use_h_converge`                  | *flag*                                                                                                                                                                                                                                                                                                       | Option for Hessian convergence\.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `h_converge`                      | *number*                                                                                                                                                                                                                                                                                                     | Blank, or any positive value\.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `h_converge_type`                 | *flag*                                                                                                                                                                                                                                                                                                       | True = Absolute, False = Relative                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `max_iterations`                  | *integer*                                                                                                                                                                                                                                                                                                    | Maximum number of iterations the algorithm will perform\. A non\-negative integer; default is 100\.                                                                                                                                                                                                                                                                                                                                                                       |
| `sing_tolerance`                  | *integer*                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `use_model_selection`             | *flag*                                                                                                                                                                                                                                                                                                       | Enables the parameter threshold and model selection method controls\.\.                                                                                                                                                                                                                                                                                                                                                                                                   |
| `method`                          | `LASSO`  <br>  <br>`ELASTIC_NET`  <br>  <br>`FORWARD_STEPWISE`  <br>`RIDGE`                                                                                                                                                                                                                                  | Determines the model selection method, or if using `Ridge` the regularization method, used\.                                                                                                                                                                                                                                                                                                                                                                              |
| `detect_two_way_interactions`     | *flag*                                                                                                                                                                                                                                                                                                       | When `True` the model will automatically detect two\-way interactions between input fields\. This control should only be enabled if the model is main effects only (that is, where the user has not created any higher order effects) and if the `method` selected is Forward Stepwise, Lasso, or Elastic Net\.                                                                                                                                                           |
| `automatic_penalty_params`        | *flag*                                                                                                                                                                                                                                                                                                       | Only available if model selection `method` is Lasso or Elastic Net\. Use this function to enter penalty parameters associated with either the Lasso or Elastic Net variable selection methods\. If `True`, default values are used\. If `False`, the penalty parameters are enabled custom values can be entered\.                                                                                                                                                        |
| `lasso_penalty_param`             | *number*                                                                                                                                                                                                                                                                                                     | Only available if model selection `method` is Lasso or Elastic Net and `automatic_penalty_params` is `False`\. Specify the penalty parameter value for Lasso\.                                                                                                                                                                                                                                                                                                            |
| `elastic_net_penalty_param1`      | *number*                                                                                                                                                                                                                                                                                                     | Only available if model selection `method` is Lasso or Elastic Net and `automatic_penalty_params` is `False`\. Specify the penalty parameter value for Elastic Net parameter 1\.                                                                                                                                                                                                                                                                                          |
| `elastic_net_penalty_param2`      | *number*                                                                                                                                                                                                                                                                                                     | Only available if model selection `method` is Lasso or Elastic Net and `automatic_penalty_params` is `False`\. Specify the penalty parameter value for Elastic Net parameter 2\.                                                                                                                                                                                                                                                                                          |
| `probability_entry`               | *number*                                                                                                                                                                                                                                                                                                     | Only available if the `method` selected is Forward Stepwise\. Specify the significance level of the f statistic criterion for effect inclusion\.                                                                                                                                                                                                                                                                                                                          |
| `probability_removal`             | *number*                                                                                                                                                                                                                                                                                                     | Only available if the `method` selected is Forward Stepwise\. Specify the significance level of the f statistic criterion for effect removal\.                                                                                                                                                                                                                                                                                                                            |
| `use_max_effects`                 | *flag*                                                                                                                                                                                                                                                                                                       | Only available if the `method` selected is Forward Stepwise\. Enables the `max_effects` control\. When `False` the default number of effects included should equal the total number of effects supplied to the model, minus the intercept\.                                                                                                                                                                                                                               |
| `max_effects`                     | *integer*                                                                                                                                                                                                                                                                                                    | Specify the maximum number of effects when using the forward stepwise building method\.                                                                                                                                                                                                                                                                                                                                                                                   |
| `use_max_steps`                   | *flag*                                                                                                                                                                                                                                                                                                       | Enables the `max_steps` control\. When `False` the default number of steps should equal three times the number of effects supplied to the model, excluding the intercept\.                                                                                                                                                                                                                                                                                                |
| `max_steps`                       | *integer*                                                                                                                                                                                                                                                                                                    | Specify the maximum number of steps to be taken when using the Forward Stepwise building `method`\.                                                                                                                                                                                                                                                                                                                                                                       |
| `use_model_name`                  | *flag*                                                                                                                                                                                                                                                                                                       | Indicates whether to specify a custom name for the model (`true`) or to use the system\-generated name (`false`)\. Default is `false`\.                                                                                                                                                                                                                                                                                                                                   |
| `model_name`                      | *string*                                                                                                                                                                                                                                                                                                     | If `use_model_name` is `true`, specifies the model name to use\.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `usePI`                           | *flag*                                                                                                                                                                                                                                                                                                       | If `true`, predictor importance is calculated\.\.                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `perform_model_effect_tests`      | *boolean*                                                                                                                                                                                                                                                                                                    | Whether to perform model effect tests\.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `non_neg_least_squares`           | *integer*                                                                                                                                                                                                                                                                                                    | Whether to perform non\-negative least squares\.                                                                                                                                                                                                                                                                                                                                                                                                                          |

<!-- </table "summary="gle properties" id="glenodeslots__table_utv_kw1_zs" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->