ibm-research/WatsonxDocsQARetrieval huggingface dataset:
# settoflagnode properties #

![SetToFlag node icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/images/settoflagnodeicon.png)The SetToFlag node derives multiple flag fields based on the categorical values defined for one or more nominal fields\.

<!-- <table "summary="settoflagnode properties" id="settoflagnodeslots__table_agr_lwy_ddb" class="defaultstyle" "> -->

settoflagnode properties  

Table 1\. settoflagnode properties

| `settoflagnode` properties | Data type                              | Property description                                                                                                |
| -------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `fields_from`              | \[*category category category*\] `all` |                                                                                                                     |
| `true_value`               | *string*                               | Specifies the true value used by the node when setting a flag\. The default is `T`\.                                |
| `false_value`              | *string*                               | Specifies the false value used by the node when setting a flag\. The default is `F`\.                               |
| `use_extension`            | *flag*                                 | Use an extension as a suffix or prefix to the new flag field\.                                                      |
| `extension`                | *string*                               |                                                                                                                     |
| `add_as`                   | `Suffix``Prefix`                       | Specifies whether the extension is added as a suffix or prefix\.                                                    |
| `aggregate`                | *flag*                                 | Groups records together based on key fields\. All flag fields in a group are enabled if any record is set to true\. |
| `keys`                     | *list*                                 | Key fields\.                                                                                                        |

<!-- </table "summary="settoflagnode properties" id="settoflagnodeslots__table_agr_lwy_ddb" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# simfitnode properties #

![Sim Fit node icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/images/simfitnodeicon.png)The Simulation Fitting (Sim Fit) node examines the statistical distribution of the data in each field and generates (or updates) a Simulation Generate node, with the best fitting distribution assigned to each field\. The Simulation Generate node can then be used to generate simulated data\.

<!-- <table "summary="simfitnode properties" class="defaultstyle" "> -->

simfitnode properties  

Table 1\. simfitnode properties

| `simfitnode` properties  | Data type | Property description                                                                                                                                                        |
| ------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `custom_gen_node_name`   | *boolean* | You can generate the name of the generated (or updated) Simulation Generate node automatically by selecting Auto\.                                                          |
| `gen_node_name`          | *string*  | Specify a custom name for the generated (or updated) node\.                                                                                                                 |
| `used_cases_type`        | *string*  | Specifies the number of cases to use when fitting distributions to the fields in the data set\. Use `AllCases` or `FirstNCases`\.                                           |
| `used_cases`             | *integer* | The number of cases                                                                                                                                                         |
| `good_fit_type`          | *string*  | For continuous fields, specify either the `AnderDarling` test or the `KolmogSmirn` test of goodness of fit to rank distributions when fitting distributions to the fields\. |
| `bins`                   | *integer* | For continuous fields, the Empirical distribution is the cumulative distribution function of the historical data\.                                                          |
| `frequency_weight_field` | *field*   | Specify the weight field if your data set contains one\. The weight field is then excluded from the distribution fitting process\.                                          |

<!-- </table "summary="simfitnode properties" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# simgennode properties #

![Sim Gen node icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/images/simgennodeicon.png) The Simulation Generate (Sim Gen) node provides an easy way to generate simulated data—either from scratch using user specified statistical distributions or automatically using the distributions obtained from running a Simulation Fitting (Sim Fit) node on existing historical data\. This is useful when you want to evaluate the outcome of a predictive model in the presence of uncertainty in the model inputs\.

<!-- <table "summary="simgennode properties" class="defaultstyle" "> -->

simgennode properties  

Table 1\. simgennode properties

| `simgennode` properties  | Data type           | Property description                                  |
| ------------------------ | ------------------- | ----------------------------------------------------- |
| `fields`                 | Structured property | See example                                           |
| `correlations`           | Structured property | See example                                           |
| `keep_min_max_setting`   | *boolean*           |                                                       |
| `refit_correlations`     | *boolean*           |                                                       |
| `max_cases`              | *integer*           | Minimum value is 1000, maximum value is 2,147,483,647 |
| `create_iteration_field` | *boolean*           |                                                       |
| `iteration_field_name`   | *string*            |                                                       |
| `replicate_results`      | *boolean*           |                                                       |
| `random_seed`            | *integer*           |                                                       |
| `parameter_xml`          | *string*            | Returns the parameter Xml as a string                 |

<!-- </table "summary="simgennode properties" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# Node and flow property examples #

You can use node and flow properties in a variety of ways with SPSS Modeler\. They're most commonly used as part of a script: either a standalone script, used to automate multiple flows or operations, or a flow script, used to automate processes within a single flow\. You can also specify node parameters by using the node properties within the SuperNode\. At the most basic level, properties can also be used as a command line option for starting SPSS Modeler\. Using the `-p` argument as part of command line invocation, you can use a flow property to change a setting in the flow\.

<!-- <table "summary="Node and flow property examples" class="defaultstyle" "> -->

Node and flow property examples  

Table 1\. Node and flow property examples

| Property                | Meaning                                                                                                         |
| ----------------------- | --------------------------------------------------------------------------------------------------------------- |
| `s.max_size`            | Refers to the property `max_size` of the node named `s`\.                                                       |
| `s:samplenode.max_size` | Refers to the property `max_size` of the node named `s`, which must be a Sample node\.                          |
| `:samplenode.max_size`  | Refers to the property `max_size` of the Sample node in the current flow (there must be only one Sample node)\. |
| `s:sample.max_size`     | Refers to the property `max_size` of the node named `s`, which must be a Sample node\.                          |
| `t.direction.Age`       | Refers to the role of the field `Age` in the Type node `t`\.                                                    |
| `:.max_size`            | \*\*\* NOT LEGAL \*\*\* You must specify either the node name or the node type\.                                |

<!-- </table "summary="Node and flow property examples" class="defaultstyle" "> -->

The example `s:sample.max_size` illustrates that you don't need to spell out node types in full\.

The example `t.direction.Age` illustrates that some slot names can themselves be structured—in cases where the attributes of a node are more complex than simply individual slots with individual values\. Such slots are called structured or complex properties\.

<!-- </article "role="article" "> -->
# Syntax for properties #

You can set properties using the following syntax:

    OBJECT.setPropertyValue(PROPERTY, VALUE)

or:

    OBJECT.setKeyedPropertyValue(PROPERTY, KEY, VALUE)

You can retrieve the value of properties using the following syntax:

    VARIABLE = OBJECT.getPropertyValue(PROPERTY)

or:

    VARIABLE = OBJECT.getKeyedPropertyValue(PROPERTY, KEY)

where `OBJECT` is a node or output, `PROPERTY` is the name of the node property that your expression refers to, and `KEY` is the key value for keyed properties\. For example, the following syntax finds the Filter node and then sets the default to include all fields and filter the `Age` field from downstream data:

    filternode = modeler.script.stream().findByType("filter", None)
    filternode.setPropertyValue("default_include", True)
    filternode.setKeyedPropertyValue("include", "Age", False)

All nodes used in SPSS Modeler can be located using the flow function `findByType(TYPE, LABEL)`\. At least one of `TYPE` or `LABEL` must be specified\.

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

Standard abbreviations are used throughout the syntax for node properties\. Learning the abbreviations is helpful in constructing scripts\.

<!-- <table "summary="Standard abbreviations used throughout the syntax" id="slot_parameters_abbreviations__table_fw3_qwy_ddb" class="defaultstyle" "> -->

Standard abbreviations used throughout the syntax  

Table 1\. Standard abbreviations used throughout the syntax

| Abbreviation | Meaning                                |
| ------------ | -------------------------------------- |
| abs          | Absolute value                         |
| len          | Length                                 |
| min          | Minimum                                |
| max          | Maximum                                |
| correl       | Correlation                            |
| covar        | Covariance                             |
| num          | Number or numeric                      |
| pct          | Percent or percentage                  |
| transp       | Transparency                           |
| xval         | Cross\-validation                      |
| var          | Variance or variable (in source nodes) |

<!-- </table "summary="Standard abbreviations used throughout the syntax" id="slot_parameters_abbreviations__table_fw3_qwy_ddb" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# Model nugget node properties #

Refer to this section for a list of available properties for Model nuggets\.

Model nugget nodes share the same common properties as other nodes\. See [Common node properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/slot_parameters_common.html#slot_parameters_common) for more information\.

<!-- </article "role="article" "> -->
# Properties reference overview #

You can specify a number of different properties for nodes, flows, projects, and SuperNodes\. Some properties are common to all nodes, such as name, annotation, and ToolTip, while others are specific to certain types of nodes\. Other properties refer to high\-level flow operations, such as caching or SuperNode behavior\. Properties can be accessed through the standard user interface (for example, when you open the properties for a node) and can also be used in a number of other ways\.

<!-- <ul> -->

 *  Properties can be modified through scripts, as described in this section\. For more information, see [Syntax for properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/slot_parameter_syntax.html)\.
 *  Node properties can be used in SuperNode parameters\.

<!-- </ul> -->

In the context of scripting within SPSS Modeler, node and flow properties are often called slot parameters\. In this documentation, they are referred to as node properties or flow properties\.

For more information about the scripting language, see [The scripting language](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/jython/clementine/python_language_overview.html)\.

<!-- </article "role="article" "> -->
# sortnode properties #

![Sort node icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/images/sortnodeicon.png) The Sort node sorts records into ascending or descending order based on the values of one or more fields\.

<!-- <table "summary="sortnode properties" id="sortnodeslots__table_d4z_vwy_ddb" class="defaultstyle" "> -->

sortnode properties  

Table 1\. sortnode properties

| `sortnode` properties | Data type                     | Property description                                                                                                                    |
| --------------------- | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| `keys`                | *list*                        | Specifies the fields you want to sort against\. If no direction is specified, the default is used\.                                     |
| `default_ascending`   | *flag*                        | Specifies the default sort order\.                                                                                                      |
| `use_existing_keys`   | *flag*                        | Specifies whether sorting is optimized by using the previous sort order for fields that are already sorted\.                            |
| `existing_keys`       |                               | Specifies the fields that are already sorted and the direction in which they are sorted\. Uses the same format as the `keys` property\. |
| `default_sort_order`  | `Ascending`  <br>`Descending` | Specify whether, by default, records are sorted in ascending or descending order of the sort key values\.                               |

<!-- </table "summary="sortnode properties" id="sortnodeslots__table_d4z_vwy_ddb" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# Flow scripts #

You can use scripts to customize operations within a particular flow, and they're saved with that flow\. You can specify a particular execution order for the terminal nodes within a flow\. You use the flow script settings to edit the script that's saved with the current flow\.

To access the flow script settings:

<!-- <ol> -->

1.  Click the  Flow Properties icon on the toolbar\.
2.  Open the  Scripting section to work with scripts for the current flow\. You can also launch the Expression Builder from here by clicking the calculator icon\. ![Expression Builder icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/images/expressionbuilder.png)

<!-- </ol> -->

You can specify whether a script does or doesn't run when the flow runs\. To run the script each time the flow runs, respecting the execution order of the script, select  Run the script\. This setting provides automation at the flow level for quicker model building\. However, the default setting is to ignore this script during flow execution ( Run all terminal nodes\.

<!-- </article "role="article" "> -->
# Jython code size limits #

Jython compiles each script to Java bytecode, which the Java Virtual Machine (JVM) then runs\. However, Java imposes a limit on the size of a single bytecode file\. So when Jython attempts to load the bytecode, it can cause the JVM to crash\.  SPSS Modeler is unable to prevent this from happening\.

Ensure that you write your Jython scripts using good coding practices (such as minimizing duplicated code by using variables or functions to compute common intermediate values)\. If necessary, you may need to split your code over several source files or define it using modules as these are compiled into separate bytecode files\.

<!-- </article "role="article" "> -->
# applysvmnode properties #

You can use SVM modeling nodes to generate an SVM model nugget\. The scripting name of this model nugget is *applysvmnode*\. For more information on scripting the modeling node itself, see [svmnode properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/svmnodeslots.html#svmnodeslots)\.

<!-- <table "summary="applysvmnode properties" id="svmnuggetnodeslots__table_ax1_hyy_ddb" class="defaultstyle" "> -->

applysvmnode properties  

Table 1\. applysvmnode properties

| `applysvmnode` Properties         | Values                | Property description                                                                                                                             |
| --------------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `all_probabilities`               | *flag*                |                                                                                                                                                  |
| `calculate_raw_propensities`      | *flag*                |                                                                                                                                                  |
| `calculate_adjusted_propensities` | *flag*                |                                                                                                                                                  |
| `enable_sql_generation`           | `false`  <br>`native` | When using data from a database, SQL code can be pushed back to the database for execution, providing superior performance for many operations\. |

<!-- </table "summary="applysvmnode properties" id="svmnuggetnodeslots__table_ax1_hyy_ddb" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# applytcmnode properties #

You can use Temporal Causal Modeling (TCM) modeling nodes to generate a TCM model nugget\. The scripting name of this model nugget is *applytcmnode*\. For more information on scripting the modeling node itself, see [tcmnode properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/tcmnodeslots.html#tcmnodeslots)\.

<!-- <table "summary="applytcmnode properties" class="defaultstyle" "> -->

applytcmnode properties  

Table 1\. applytcmnode properties

| `applytcmnode` Properties | Values    | Property description |
| ------------------------- | --------- | -------------------- |
| `ext_future`              | *boolean* |                      |
| `ext_future_num`          | *integer* |                      |
| `noise_res`               | *boolean* |                      |
| `conf_limits`             | *boolean* |                      |
| `target_fields`           | *list*    |                      |
| `target_series`           | *list*    |                      |

<!-- </table "summary="applytcmnode properties" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# applyts properties #

You can use the Time Series modeling node to generate a Time Series model nugget\. The scripting name of this model nugget is *applyts*\. For more information on scripting the modeling node itself, see [ts properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/timeser_as_nodeslots.html#timeser_as_nodeslots)\.

<!-- <table "summary="applyts properties" class="defaultstyle" "> -->

applyts properties  

Table 1\. applyts properties

| `applyts` Properties          | Values    | Property description |
| ----------------------------- | --------- | -------------------- |
| `extend_records_into_future`  | *Boolean* |                      |
| `ext_future_num`              | *integer* |                      |
| `compute_future_values_input` | *Boolean* |                      |
| `forecastperiods`             | *integer* |                      |
| `noise_res`                   | *boolean* |                      |
| `conf_limits`                 | *boolean* |                      |
| `target_fields`               | *list*    |                      |
| `target_series`               | *list*    |                      |
| `includeTargets`              | *field*   |                      |

<!-- </table "summary="applyts properties" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# applytreeas properties #

You can use Tree\-AS modeling nodes to generate a Tree\-AS model nugget\. The scripting name of this model nugget is *applytreenas*\. For more information on scripting the modeling node itself, see [treeas properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/treeASnodeslots.html#treeASnodeslots)\.

<!-- <table "summary="applytreeas properties" class="defaultstyle" "> -->

applytreeas properties  

Table 1\. applytreeas properties

| `applytreeas` Properties | Values          | Property description                                                                                                                             |
| ------------------------ | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `calculate_conf`         | *flag*          | This property includes confidence calculations in the generated tree\.                                                                           |
| `display_rule_id`        | *flag*          | Adds a field in the scoring output that indicates the ID for the terminal node to which each record is assigned\.                                |
| `enable_sql_generation`  | `false``native` | When using data from a database, SQL code can be pushed back to the database for execution, providing superior performance for many operations\. |

<!-- </table "summary="applytreeas properties" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# applytwostepAS properties #

You can use TwoStep\-AS modeling nodes to generate a TwoStep\-AS model nugget\. The scripting name of this model nugget is *applytwostepAS*\. For more information on scripting the modeling node itself, see [twostepAS properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/twostep_as_nodeslots.html#twostep_as_nodeslots)\.

<!-- <table "summary="applytwostepAS Properties" id="twostep_as_nuggetnodeslots__table_m5f_l1l_s5" class="defaultstyle" "> -->

applytwostepAS Properties  

Table 1\. applytwostepAS Properties

| `applytwostepAS` Properties | Values                            | Property description                                                                                                                             |
| --------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `enable_sql_generation`     | `false`  <br>`true`  <br>`native` | When using data from a database, SQL code can be pushed back to the database for execution, providing superior performance for many operations\. |

<!-- </table "summary="applytwostepAS Properties" id="twostep_as_nuggetnodeslots__table_m5f_l1l_s5" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# applytwostepnode properties #

You can use TwoStep modeling nodes to generate a TwoStep model nugget\. The scripting name of this model nugget is *applytwostepnode*\. For more information on scripting the modeling node itself, see [twostepnode properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/twostepnodeslots.html#twostepnodeslots)\.

<!-- <table "summary="applytwostepnode properties" id="twostepnuggetnodeslots__table_czt_2wy_ddb" class="defaultstyle" "> -->

applytwostepnode properties  

Table 1\. applytwostepnode properties

| `applytwostepnode` Properties | Values              | Property description                                                                                                                             |
| ----------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `enable_sql_generation`       | `udf`  <br>`native` | When using data from a database, SQL code can be pushed back to the database for execution, providing superior performance for many operations\. |

<!-- </table "summary="applytwostepnode properties" id="twostepnuggetnodeslots__table_czt_2wy_ddb" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# Scripting overview #

This section provides high\-level descriptions and examples of flow\-level scripts and standalone scripts in the SPSS Modeler interface\. More information on scripting language, syntax, and commands is provided in the sections that follow\.

Notes:

<!-- <ul> -->

 *  Some of the properties and features described in this scripting and automation guide aren't available in  Watsonx\.ai\.
 *  You can't import and run scripts created in SPSS Statistics\.

<!-- </ul> -->

<!-- </article "role="article" "> -->
# applyxgboostlinearnode properties #

XGBoost Linear nodes can be used to generate an XGBoost Linear model nugget\. The scripting name of this model nugget is *applyxgboostlinearnode*\. No other properties exist for this model nugget\. For more information on scripting the modeling node itself, see [xgboostlinearnode properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/xgboostlinearnodeslots.html#xboostlinearnodeslots)\.

<!-- </article "role="article" "> -->
# applyxgboosttreenode properties #

You can use the XGBoost Tree node to generate an XGBoost Tree model nugget\. The scripting name of this model nugget is *applyxgboosttreenode*\. For more information on scripting the modeling node itself, see [xgboosttreenode properties](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/scripting_guide/clementine/xgboosttreenodeslots.html#xboosttreenodeslots)\.

<!-- <table "summary="applyxgboosttreenode properties" id="kmeansnuggetnodeslots__table_r3k_5bw_tz" class="defaultstyle" "> -->

applyxgboosttreenode properties  

Table 1\. applyxgboosttreenode properties

| `applyxgboosttreenode` properties | Data type | Property description |
| --------------------------------- | --------- | -------------------- |
| `use_model_name`                  |           |                      |
| `model_name`                      |           |                      |

<!-- </table "summary="applyxgboosttreenode properties" id="kmeansnuggetnodeslots__table_r3k_5bw_tz" class="defaultstyle" "> -->

<!-- </article "role="article" "> -->
# Select node #

You can use Select nodes to select or discard a subset of records from the data stream based on a specific condition, such as BP (blood pressure) = "HIGH"\.

Mode\. Specifies whether records that meet the condition will be included or excluded from the data stream\.

<!-- <ul> -->

 *  Include\. Select to include records that meet the selection condition\.
 *  Discard\. Select to exclude records that meet the selection condition\.

<!-- </ul> -->

Condition\. Displays the selection condition that will be used to test each record, which you specify using a CLEM expression\. Either enter an expression in the window or use the Expression Builder by clicking the calculator (Expression Builder) button\.

If you choose to discard records based on a condition, such as the following:

    (var1='value1' and var2='value2')

the Select node by default also discards records having null values for all selection fields\. To avoid this, append the following condition to the original one:

    and not(@NULL(var1) and @NULL(var2))

Select nodes are also used to choose a proportion of records\. Typically, you would use a different node, the Sample node, for this operation\. However, if the condition you want to specify is more complex than the parameters provided, you can create your own condition using the Select node\. For example, you can create a condition such as:

    BP = "HIGH" and random(10) <= 4

This will select approximately 40% of the records showing high blood pressure and pass those records downstream for further analysis\.

<!-- </article "role="article" "> -->
# Sequence node #

The Sequence node discovers patterns in sequential or time\-oriented data, in the format `bread -> cheese`\. The elements of a sequence are item sets that constitute a single transaction\.

For example, if a person goes to the store and purchases bread and milk and then a few days later returns to the store and purchases some cheese, that person's buying activity can be represented as two item sets\. The first item set contains bread and milk, and the second one contains cheese\. A sequence is a list of item sets that tend to occur in a predictable order\. The Sequence node detects frequent sequences and creates a generated model node that can be used to make predictions\.

Requirements\. To create a Sequence rule set, you need to specify an ID field, an optional time field, and one or more content fields\. Note that these settings must be made on the Fields tab of the modeling node; they cannot be read from an upstream Type node\. The ID field can have any role or measurement level\. If you specify a time field, it can have any role but its storage must be numeric, date, time, or timestamp\. If you do not specify a time field, the Sequence node will use an implied timestamp, in effect using row numbers as time values\. Content fields can have any measurement level and role, but all content fields must be of the same type\. If they are numeric, they must be integer ranges (not real ranges)\.

Strengths\. The Sequence node is based on the CARMA association rules algorithm, which uses an efficient two\-pass method for finding sequences\. In addition, the generated model node created by a Sequence node can be inserted into a data stream to create predictions\. The generated model node can also generate supernodes for detecting and counting specific sequences and for making predictions based on specific sequences\.

<!-- </article "role="article" "> -->
# Set to Flag node #

Use the Set to Flag node to derive flag fields based on the categorical values defined for one or more nominal fields\.

For example, your dataset might contain a nominal field, `BP` (blood pressure), with the values `High`, `Normal`, and `Low`\. For easier data manipulation, you might create a flag field for high blood pressure, which indicates whether or not the patient has high blood pressure\.

<!-- </article "role="article" "> -->
# Sim Eval node #

The Simulation Evaluation (Sim Eval) node is a terminal node that evaluates a specified field, provides a distribution of the field, and produces charts of distributions and correlations\.

This node is primarily used to evaluate continuous fields\. It therefore compliments the evaluation chart, which is generated by an Evaluation node and is useful for evaluating discrete fields\. Another difference is that the Sim Eval node evaluates a single prediction across several iterations, whereas the Evaluation node evaluates multiple predictions each with a single iteration\. Iterations are generated when more than one value is specified for a distribution parameter in the Sim Gen node\.

The Sim Eval node is designed to be used with data that was obtained from the Sim Fit and Sim Gen nodes\. The node can, however, be used with any other node\. Any number of processing steps can be placed between the Sim Gen node and the Sim Eval node\.

Important: The Sim Eval node requires a minimum of 1000 records with valid values for the target field\.
<!-- </article "role="article" "> -->
# Sim Fit node #

The Simulation Fitting node fits a set of candidate statistical distributions to each field in the data\. The fit of each distribution to a field is assessed using a goodness of fit criterion\. When a Simulation Fitting node runs, a Simulation Generate node is built (or an existing node is updated)\. Each field is assigned its best fitting distribution\. The Simulation Generate node can then be used to generate simulated data for each field\.

Although the Simulation Fitting node is a terminal node, it does not add output to the Outputs panel, or export data\.

Note: If the historical data is sparse (that is, there are many missing values), it may be difficult for the fitting component to find enough valid values to fit distributions to the data\. In cases where the data is sparse, before fitting you should either remove the sparse fields if they are not required, or impute the missing values\. Using the  QUALITY options in the Data Audit node, you can view the number of complete records, identify which fields are sparse, and select an imputation method\. If there are an insufficient number of records for distribution fitting, you can use a Balance node to increase the number of records\.
<!-- </article "role="article" "> -->
# SLRM node #

Use the Self\-Learning Response Model (SLRM) node to build a model that you can continually update, or reestimate, as a dataset grows without having to rebuild the model every time using the complete dataset\. For example, this is useful when you have several products and you want to identify which one a customer is most likely to buy if you offer it to them\. This model allows you to predict which offers are most appropriate for customers and the probability of the offers being accepted\.

Initially, you can build the model using a small dataset with randomly made offers and the responses to those offers\. As the dataset grows, the model can be updated and therefore becomes more able to predict the most suitable offers for customers and the probability of their acceptance based upon other input fields such as age, gender, job, and income\. You can change the offers available by adding or removing them from within the node, instead of having to change the target field of the dataset\.

Before running an SLRM node, you must specify both the target and target response fields in the node properties\. The target field must have string storage, not numeric\. The target response field must be a flag\. The true value of the flag indicates offer acceptance and the false value indicates offer refusal\.

Example\. A financial institution wants to achieve more profitable results by matching the offer that is most likely to be accepted to each customer\. You can use a self\-learning model to identify the characteristics of customers most likely to respond favorably based on previous promotions and to update the model in real time based on the latest customer responses\.

<!-- </article "role="article" "> -->
# SMOTE node #

The Synthetic Minority Over\-sampling Technique (SMOTE) node provides an over\-sampling algorithm to deal with imbalanced data sets\. It provides an advanced method for balancing data\. The SMOTE node in  watsonx\.ai is implemented in Python and requires the  imbalanced\-learn© Python library\.

For details about the imbalanced\-learn library, see [imbalanced\-learn documentation](https://imbalanced-learn.org/stable/index.html)^1^\.

The Modeling tab on the nodes palette contains the SMOTE node and other Python nodes\.

^1^Lemaître, Nogueira, Aridas\. "Imbalanced\-learn: A Python Toolbox to Tackle the Curse of Imbalanced Datasets in Machine Learning\." *Journal of Machine Learning Research*, vol\. 18, no\. 17, 2017, pp\. 1\-5\. (http://jmlr\.org/papers/v18/16\-365\.html)

<!-- </article "role="article" "> -->
# Sort node #

You can use Sort nodes to sort records into ascending or descending order based on the values of one or more fields\. For example, Sort nodes are frequently used to view and select records with the most common data values\. Typically, you would first aggregate the data using the Aggregate node and then use the Sort node to sort the aggregated data into descending order of record counts\. Displaying these results in a table will allow you to explore the data and to make decisions, such as selecting the records of the 10 best customers\.

The following settings are available for the Sort node

Sort by\. All fields selected to use as sort keys are displayed in a table\. A key field works best for sorting when it is numeric\.

<!-- <ul> -->

 *  Add fields to this list using the Field Chooser button\.
 *  Select an order by clicking the  Ascending or  Descending arrow in the table's *Order* column\.
 *  Delete fields using the red delete button\.
 *  Sort directives using the arrow buttons\.

<!-- </ul> -->

Default sort order\. Select either  Ascending or  Descending to use as the default sort order when new fields are added\.

Note: The Sort node is not applied if there is a Distinct node down the model flow\. For information about the Distinct node, see [Distinct node](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/distinct.html#distinct)\.
<!-- </article "role="article" "> -->
# Streaming TCM node #

You can use this node to build and score temporal causal models in one step\.

After adding a Streaming TCM node to your flow canvas, double\-click it to open the node properties\. To see information about the properties, hover over the tool\-tip icons\. For more information about temporal causal modeling, see [TCM node](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/tcm.html)\.

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

One of the reasons the  SPSS Modeler visual interface is so easy to learn is that each node has a clearly defined function\. However, for complex processing, a long sequence of nodes may be necessary\. Eventually, this may clutter your flow canvas and make it difficult to follow flow diagrams\.

There are two ways to avoid the clutter of a long and complex flow:

<!-- <ul> -->

 *  You can split a processing sequence into several flows\. The first flow, for example, creates a data file that the second uses as input\. The second creates a file that the third uses as input, and so on\. However, this requires you to manage multiple flows\.
 *  You can create a **SuperNode** as a more streamlined alternative when working with complex flow processes\. SuperNodes group multiple nodes into a single node by encapsulating sections of flow\. This provides benefits to the data miner:
    
    <!-- <ul> -->
    
     *  Grouping nodes results in a neater and more manageable flow.
     *  Nodes can be combined into a business-specific SuperNode.
    
    <!-- </ul> -->
    
<!-- </ul> -->

To group nodes into a SuperNode:

<!-- <ol> -->

1.  *Ctrl \+ click* to select the nodes you want to group\.
2.  Right\-click and select  Create supernode\. The nodes are grouped into a single SuperNode with a special star icon\.
    
    Figure 1. SuperNode icon
    
    ![SuperNode icon](https://dataplatform.cloud.ibm.com/docs/content/wsd/images/supernodes.png)

<!-- </ol> -->

<!-- </article "role="article" "> -->
# SVM node #

The SVM node uses a support vector machine to classify data\. SVM is particularly suited for use with wide datasets, that is, those with a large number of predictor fields\. You can use the default settings on the node to produce a basic model relatively quickly, or you can use the Expert settings to experiment with different types of SVM models\.

After the model is built, you can:

<!-- <ul> -->

 *  Browse the model nugget to display the relative importance of the input fields in building the model\.
 *  Append a Table node to the model nugget to view the model output\.

<!-- </ul> -->

Example\. A medical researcher has obtained a dataset containing characteristics of a number of human cell samples extracted from patients who were believed to be at risk of developing cancer\. Analysis of the original data showed that many of the characteristics differed significantly between benign and malignant samples\. The researcher wants to develop an SVM model that can use the values of similar cell characteristics in samples from other patients to give an early indication of whether their samples might be benign or malignant\.

<!-- </article "role="article" "> -->
# Reusing custom category sets #

You can customize a category set in Text Analytics Workbench and then download it to use in other SPSS Modeler flows\.

## Procedure ##

<!-- <ol> -->

1.  Optional:  Customize the category set\.
    
    <!-- <ol> -->
    
    1.  Select a category to customize.
    2.  To add descriptors, click the  Descriptors tab and then drag-and-drop from the  Descriptors tab into categories to add them.
    
    <!-- </ol> -->
    
2.  Download the customized category set\.
    
    <!-- <ol> -->
    
    1.  From the Text Analytics Workbench, go to the  Categories tab.
    2.  Click the  Options icon and select  Download category set.
    3.  Give the category set a name and click  Download.
    
    <!-- </ol> -->
    
3.  Add the category set to another Text Mining node\.
    
    <!-- <ol> -->
    
    1.  In a different flow session, go to the  Categories tab in the Text Analytics Workbench.
    2.  Click the  Options icon and select  Add category set.
    3.  Browse to or drag-and-drop your category set.
    4.  Choose whether to replace the existing category set in the Text Mining node or to append your category set to the existing one. You can preview the final category set based on your choices.
    5.  Click  Create.
    
    <!-- </ol> -->
    
<!-- </ol> -->

<!-- </article "role="article" "> -->
# Reusing a project asset in Resource editor #

From the Text Analytics Workbench, you can save a template or library as a project asset\. You can then use the template or library in other Text Mining nodes by loading it in the Resource editor\.

## Procedure ##

<!-- <ol> -->

1.  Save a library or template in Text Analytics Workbench\.
    
    <!-- <ol> -->
    
    1.  On the  Resource Editor tab, select the template or library to save.
    2.  Click the  Options icon and select  Save as project asset.
    3.  Enter details about the asset, and click  Submit. 
    
    <!-- </ol> -->
    
2.  Load a library or template in a different Text Analytics Workbench\.
    
    <!-- <ol> -->
    
    1.  On the  Resource Editor tab, open the toolbar menu for your current template or library.
    2.  Click the  Options icon and select  Load library or  Change template.
    3.  Find your library or template and select it. 
    4.  Click  Apply. 
    
    <!-- </ol> -->
    
<!-- </ol> -->

<!-- </article "role="article" "> -->
# Uploading a custom asset in a Text Mining node #

You can add a custom text analysis package (TAP) or template directly in the Text Mining node\. When your SPSS Modeler flow runs, it will use your custom asset\.

## Procedure ##

<!-- <ol> -->

1.  If you want to download a TAP, save it locally\.
    
    <!-- <ol> -->
    
    1.  Click  Text analysis package while in the Text Analytics Workbench.
    2.  Enter details about the asset, and then click  Submit. The text analysis package is saved locally as a  .tap file.
    
    <!-- </ol> -->
    
2.  If you want to download a template, see [Linguistic resources](https://dataplatform.cloud.ibm.com/docs/content/wsd/nodes/tmwb-linguistic-resource.html#tmwb-templates-intro__DownloadAssetsSteps)\.
3.  Add the TAP or template file to another Text Mining node\.
    
    <!-- <ol> -->
    
    1.  In the Text Mining node, click  Select resources.
    2.  Click the  Text analysis package  or  Resource template tab depending on the asset you want.
    3.  Click  Import , and then browse to or drag-and-drop your TAP or template.
    4.  Enter details about the asset, and then click  Add. You can now see the uploaded TAP in the list of resources. It is also saved to your project as a project asset.
    5.  Click  Ok.
    
    <!-- </ol> -->
    
<!-- </ol> -->

<!-- </article "role="article" "> -->
# Table node #

The Table node creates a table that lists the values in your data\. All fields and all values in the stream are included, making this an easy way to inspect your data values or export them in an easily readable form\. Optionally, you can highlight records that meet a certain condition\.

Note: Unless you are working with small datasets, we recommend that you select a subset of the data to pass into the Table node\. The Table node cannot display properly when the number of records surpasses a size that can be contained in the display structure (for example, 100 million rows)\.
<!-- </article "role="article" "> -->
# TCM node #

Use this node to create a temporal causal model (TCM)\.

Temporal causal modeling attempts to discover key causal relationships in time series data\. In temporal causal modeling, you specify a set of target series and a set of candidate inputs to those targets\. The procedure then builds an autoregressive time series model for each target and includes only those inputs that have a causal relationship with the target\. This approach differs from traditional time series modeling where you must explicitly specify the predictors for a target series\. Since temporal causal modeling typically involves building models for multiple related time series, the result is referred to as a model system\.

In the context of temporal causal modeling, the term causal refers to Granger causality\. A time series X is said to "Granger cause" another time series Y if regressing for Y in terms of past values of both X and Y results in a better model for Y than regressing only on past values of Y\.

Note: To build a temporal causal model, you need enough data points\. The product uses the constraint:

    m>(L + KL + 1)

where `m` is the number of data points, `L` is the number of lags, and `K` is the number of predictors\. Make sure your data set is big enough so that the number of data points (`m`) satisfies the condition\.
<!-- </article "role="article" "> -->