New! Use Simple ML for Sheets to apply machine learning to the data in your Google Sheets Read More

tfdf.keras.wrappers.CartModel

Cart learning algorithm.

Inherits From: CoreModel, InferenceCoreModel

tfdf.keras.wrappers.CartModel(
    task: Optional[TaskType] = core.Task.CLASSIFICATION,
    features: Optional[List[core.FeatureUsage]] = None,
    exclude_non_specified_features: Optional[bool] = False,
    preprocessing: Optional['tf_keras.models.Functional'] = None,
    postprocessing: Optional['tf_keras.models.Functional'] = None,
    training_preprocessing: Optional['tf_keras.models.Functional'] = None,
    ranking_group: Optional[str] = None,
    uplift_treatment: Optional[str] = None,
    temp_directory: Optional[str] = None,
    verbose: int = 1,
    hyperparameter_template: Optional[str] = None,
    advanced_arguments: Optional[tfdf.keras.AdvancedArguments] = None,
    num_threads: Optional[int] = None,
    name: Optional[str] = None,
    max_vocab_count: Optional[int] = 2000,
    try_resume_training: Optional[bool] = True,
    check_dataset: Optional[bool] = True,
    tuner: Optional[tfdf.tuner.Tuner] = None,
    discretize_numerical_features: bool = False,
    num_discretized_numerical_bins: int = 255,
    multitask: Optional[List[MultiTaskItem]] = None,
    allow_na_conditions: Optional[bool] = False,
    categorical_algorithm: Optional[str] = 'CART',
    categorical_set_split_greedy_sampling: Optional[float] = 0.1,
    categorical_set_split_max_num_items: Optional[int] = -1,
    categorical_set_split_min_item_frequency: Optional[int] = 1,
    growing_strategy: Optional[str] = 'LOCAL',
    honest: Optional[bool] = False,
    honest_fixed_separation: Optional[bool] = False,
    honest_ratio_leaf_examples: Optional[float] = 0.5,
    in_split_min_examples_check: Optional[bool] = True,
    keep_non_leaf_label_distribution: Optional[bool] = True,
    max_depth: Optional[int] = 16,
    max_num_nodes: Optional[int] = None,
    maximum_model_size_in_memory_in_bytes: Optional[float] = -1.0,
    maximum_training_duration_seconds: Optional[float] = -1.0,
    mhld_oblique_max_num_attributes: Optional[int] = None,
    mhld_oblique_sample_attributes: Optional[bool] = None,
    min_examples: Optional[int] = 5,
    missing_value_policy: Optional[str] = 'GLOBAL_IMPUTATION',
    num_candidate_attributes: Optional[int] = -1,
    num_candidate_attributes_ratio: Optional[float] = -1.0,
    pure_serving_model: Optional[bool] = False,
    random_seed: Optional[int] = 123456,
    sorting_strategy: Optional[str] = 'IN_NODE',
    sparse_oblique_max_num_projections: Optional[int] = None,
    sparse_oblique_normalization: Optional[str] = None,
    sparse_oblique_num_projections_exponent: Optional[float] = None,
    sparse_oblique_projection_density_factor: Optional[float] = None,
    sparse_oblique_weights: Optional[str] = None,
    split_axis: Optional[str] = 'AXIS_ALIGNED',
    uplift_min_examples_in_treatment: Optional[int] = 5,
    uplift_split_score: Optional[str] = 'KULLBACK_LEIBLER',
    validation_ratio: Optional[float] = 0.1,
    explicit_args: Optional[Set[str]] = None
)

A CART (Classification and Regression Trees) a decision tree. The non-leaf nodes contains conditions (also known as splits) while the leaf nodes contain prediction values. The training dataset is divided in two parts. The first is used to grow the tree while the second is used to prune the tree.

Usage example:

import tensorflow_decision_forests as tfdf
import pandas as pd

dataset = pd.read_csv("project/dataset.csv")
tf_dataset = tfdf.keras.pd_dataframe_to_tf_dataset(dataset, label="my_label")

model = tfdf.keras.CartModel()
model.fit(tf_dataset)

print(model.summary())

Hyper-parameter tuning:

import tensorflow_decision_forests as tfdf
import pandas as pd

dataset = pd.read_csv("project/dataset.csv")
tf_dataset = tfdf.keras.pd_dataframe_to_tf_dataset(dataset, label="my_label")

tuner = tfdf.tuner.RandomSearch(num_trials=20)

# Hyper-parameters to optimize.
tuner.discret("max_depth", [4, 5, 6, 7])

model = tfdf.keras.CartModel(tuner=tuner)
model.fit(tf_dataset)

print(model.summary())

Attributes
`task`	Task to solve (e.g. Task.CLASSIFICATION, Task.REGRESSION, Task.RANKING, Task.CATEGORICAL_UPLIFT, Task.NUMERICAL_UPLIFT).
`features`	Specify the list and semantic of the input features of the model. If not specified, all the available features will be used. If specified and if `exclude_non_specified_features=True`, only the features in `features` will be used by the model. If "preprocessing" is used, `features` corresponds to the output of the preprocessing. In this case, it is recommended for the preprocessing to return a dictionary of tensors.
`exclude_non_specified_features`	If true, only use the features specified in `features`.
`preprocessing`	Functional keras model or @tf.function to apply on the input feature before the model to train. This preprocessing model can consume and return tensors, list of tensors or dictionary of tensors. If specified, the model only "sees" the output of the preprocessing (and not the raw input). Can be used to prepare the features or to stack multiple models on top of each other. Unlike preprocessing done in the tf.dataset, the operation in "preprocessing" are serialized with the model.
`postprocessing`	Like "preprocessing" but applied on the model output.
`training_preprocessing`	Functional keras model or `@tf.function` to apply on the input feature, labels, and sample_weight before model training.
`ranking_group`	Only for `task=Task.RANKING`. Name of a tf.string feature that identifies queries in a query/document ranking task. The ranking group is not added automatically for the set of features if `exclude_non_specified_features=false`.
`uplift_treatment`	Only for task=Task.CATEGORICAL_UPLIFT or task=Task.NUMERICAL_UPLIFT. Name of an integer feature that identifies the treatment in an uplift problem. The value 0 is reserved for the control treatment.
`temp_directory`	Temporary directory used to store the model Assets after the training, and possibly as a work directory during the training. This temporary directory is necessary for the model to be exported after training e.g. `model.save(path)`. If not specified, `temp_directory` is set to a temporary directory using `tempfile.TemporaryDirectory`. This directory is deleted when the model python object is garbage-collected.
`verbose`	Verbosity mode. 0 = silent, 1 = small details, 2 = full details.
`hyperparameter_template`	Override the default value of the hyper-parameters. If None (default) the default parameters of the library are used. If set, `default_hyperparameter_template` refers to one of the following preconfigured hyper-parameter sets. Those sets outperforms the default hyper-parameters (either generally or in specific scenarios). You can omit the version (e.g. remove "@v5") to use the last version of the template. In this case, the hyper-parameter can change in between releases (not recommended for training in production).
`advanced_arguments`	Advanced control of the model that most users won't need to use. See `AdvancedArguments` for details.
`num_threads`	Number of threads used to train the model. Different learning algorithms use multi-threading differently and with different degree of efficiency. If `None`, `num_threads` will be automatically set to the number of processors (up to a maximum of 32; or set to 6 if the number of processors is not available). Making `num_threads` significantly larger than the number of processors can slow-down the training speed. The default value logic might change in the future.
`name`	The name of the model.
`max_vocab_count`	Default maximum size of the vocabulary for CATEGORICAL and CATEGORICAL_SET features stored as strings. If more unique values exist, only the most frequent values are kept, and the remaining values are considered as out-of-vocabulary. The value `max_vocab_count` defined in a `FeatureUsage` (if any) takes precedence.
`try_resume_training`	If true, the model training resumes from the checkpoint stored in the `temp_directory` directory. If `temp_directory` does not contain any model checkpoint, the training start from the beginning. Resuming training is useful in the following situations: (1) The training was interrupted by the user (e.g. ctrl+c or "stop" button in a notebook). (2) the training job was interrupted (e.g. rescheduling), ond (3) the hyper-parameter of the model were changed such that an initially completed training is now incomplete (e.g. increasing the number of trees). Note: Training can only be resumed if the training datasets is exactly the same (i.e. no reshuffle in the tf.data.Dataset).
`check_dataset`	If set to true, test if the dataset is well configured for the training: (1) Check if the dataset does contains any `repeat` operations, (2) Check if the dataset does contain a `batch` operation, (3) Check if the dataset has a large enough batch size (min 100 if the dataset contains more than 1k examples or if the number of examples is not available) If set to false, do not run any test.
`tuner`	If set, automatically optimize the hyperparameters of the model using this tuner. If the model is trained with distribution (i.e. the model definition is wrapper in a TF Distribution strategy, the tuning is distributed.
`discretize_numerical_features`	If true, discretize all the numerical features before training. Discretized numerical features are faster to train with, but they can have a negative impact on the model quality. Using discretize_numerical_features=True is equivalent as setting the feature semantic DISCRETIZED_NUMERICAL in the `feature` argument. See the definition of DISCRETIZED_NUMERICAL for more details.
`num_discretize_numerical_bins`	Number of bins used when disretizing numerical features. The value `num_discretized_numerical_bins` defined in a `FeatureUsage` (if any) takes precedence.
`multitask`	If set, train a multi-task model, that is a model with multiple outputs trained to predict different labels. If set, the tf.dataset label (i.e. the second selement of the dataset) should be a dictionary of label_key:label_values. Only one of `multitask` and `task` can be set.
`allow_na_conditions`	If true, the tree training evaluates conditions of the type `X is NA` i.e. `X is missing`. Default: False.
`categorical_algorithm`	How to learn splits on categorical attributes. `CART`: CART algorithm. Find categorical splits of the form "value \in mask". The solution is exact for binary classification, regression and ranking. It is approximated for multi-class classification. This is a good first algorithm to use. In case of overfitting (very small dataset, large dictionary), the "random" algorithm is a good alternative. `ONE_HOT`: One-hot encoding. Find the optimal categorical split of the form "attribute == param". This method is similar (but more efficient) than converting converting each possible categorical value into a boolean feature. This method is available for comparison purpose and generally performs worse than other alternatives. `RANDOM`: Best splits among a set of random candidate. Find the a categorical split of the form "value \in mask" using a random search. This solution can be seen as an approximation of the CART algorithm. This method is a strong alternative to CART. This algorithm is inspired from section "5.1 Categorical Variables" of "Random Forest", 2001. Default: "CART".
`categorical_set_split_greedy_sampling`	For categorical set splits e.g. texts. Probability for a categorical value to be a candidate for the positive set. The sampling is applied once per node (i.e. not at every step of the greedy optimization). Default: 0.1.
`categorical_set_split_max_num_items`	For categorical set splits e.g. texts. Maximum number of items (prior to the sampling). If more items are available, the least frequent items are ignored. Changing this value is similar to change the "max_vocab_count" before loading the dataset, with the following exception: With `max_vocab_count`, all the remaining items are grouped in a special Out-of-vocabulary item. With `max_num_items`, this is not the case. Default: -1.
`categorical_set_split_min_item_frequency`	For categorical set splits e.g. texts. Minimum number of occurrences of an item to be considered. Default: 1.
`growing_strategy`	How to grow the tree. `LOCAL`: Each node is split independently of the other nodes. In other words, as long as a node satisfy the splits "constraints (e.g. maximum depth, minimum number of observations), the node will be split. This is the "classical" way to grow decision trees. `BEST_FIRST_GLOBAL`: The node with the best loss reduction among all the nodes of the tree is selected for splitting. This method is also called "best first" or "leaf-wise growth". See "Best-first decision tree learning", Shi and "Additive logistic regression : A statistical view of boosting", Friedman for more details. Default: "LOCAL".
`honest`	In honest trees, different training examples are used to infer the structure and the leaf values. This regularization technique trades examples for bias estimates. It might increase or reduce the quality of the model. See "Generalized Random Forests", Athey et al. In this paper, Honest trees are trained with the Random Forest algorithm with a sampling without replacement. Default: False.
`honest_fixed_separation`	For honest trees only i.e. honest=true. If true, a new random separation is generated for each tree. If false, the same separation is used for all the trees (e.g., in Gradient Boosted Trees containing multiple trees). Default: False.
`honest_ratio_leaf_examples`	For honest trees only i.e. honest=true. Ratio of examples used to set the leaf values. Default: 0.5.
`in_split_min_examples_check`	Whether to check the `min_examples` constraint in the split search (i.e. splits leading to one child having less than `min_examples` examples are considered invalid) or before the split search (i.e. a node can be derived only if it contains more than `min_examples` examples). If false, there can be nodes with less than `min_examples` training examples. Default: True.
`keep_non_leaf_label_distribution`	Whether to keep the node value (i.e. the distribution of the labels of the training examples) of non-leaf nodes. This information is not used during serving, however it can be used for model interpretation as well as hyper parameter tuning. This can take lots of space, sometimes accounting for half of the model size. Default: True.
`max_depth`	Maximum depth of the tree. `max_depth=1` means that all trees will be roots. `max_depth=-1` means that tree depth is not restricted by this parameter. Values <= -2 will be ignored. Default: 16.
`max_num_nodes`	Maximum number of nodes in the tree. Set to -1 to disable this limit. Only available for `growing_strategy=BEST_FIRST_GLOBAL`. Default: None.
`maximum_model_size_in_memory_in_bytes`	Limit the size of the model when stored in ram. Different algorithms can enforce this limit differently. Note that when models are compiled into an inference, the size of the inference engine is generally much smaller than the original model. Default: -1.0.
`maximum_training_duration_seconds`	Maximum training duration of the model expressed in seconds. Each learning algorithm is free to use this parameter at it sees fit. Enabling maximum training duration makes the model training non-deterministic. Default: -1.0.
`mhld_oblique_max_num_attributes`	For MHLD oblique splits i.e. `split_axis=MHLD_OBLIQUE`. Maximum number of attributes in the projection. Increasing this value increases the training time. Decreasing this value acts as a regularization. The value should be in [2, num_numerical_features]. If the value is above the total number of numerical features, the value is capped automatically. The value 1 is allowed but results in ordinary (non-oblique) splits. Default: None.
`mhld_oblique_sample_attributes`	For MHLD oblique splits i.e. `split_axis=MHLD_OBLIQUE`. If true, applies the attribute sampling controlled by the "num_candidate_attributes" or "num_candidate_attributes_ratio" parameters. If false, all the attributes are tested. Default: None.
`min_examples`	Minimum number of examples in a node. Default: 5.
`missing_value_policy`	Method used to handle missing attribute values. `GLOBAL_IMPUTATION`: Missing attribute values are imputed, with the mean (in case of numerical attribute) or the most-frequent-item (in case of categorical attribute) computed on the entire dataset (i.e. the information contained in the data spec). `LOCAL_IMPUTATION`: Missing attribute values are imputed with the mean (numerical attribute) or most-frequent-item (in the case of categorical attribute) evaluated on the training examples in the current node. `RANDOM_LOCAL_IMPUTATION`: Missing attribute values are imputed from randomly sampled values from the training examples in the current node. This method was proposed by Clinic et al. in "Random Survival Forests" (https://projecteuclid.org/download/pdfview_1/euclid.aoas/1223908043). Default: "GLOBAL_IMPUTATION".
`num_candidate_attributes`	Number of unique valid attributes tested for each node. An attribute is valid if it has at least a valid split. If `num_candidate_attributes=0`, the value is set to the classical default value for Random Forest: `sqrt(number of input attributes)` in case of classification and `number_of_input_attributes / 3` in case of regression. If `num_candidate_attributes=-1`, all the attributes are tested. Default: -1.
`num_candidate_attributes_ratio`	Ratio of attributes tested at each node. If set, it is equivalent to `num_candidate_attributes = number_of_input_features x num_candidate_attributes_ratio`. The possible values are between ]0, and 1] as well as -1. If not set or equal to -1, the `num_candidate_attributes` is used. Default: -1.0.
`pure_serving_model`	Clear the model from any information that is not required for model serving. This includes debugging, model interpretation and other meta-data. The size of the serialized model can be reduced significatively (50% model size reduction is common). This parameter has no impact on the quality, serving speed or RAM usage of model serving. Default: False.
`random_seed`	Random seed for the training of the model. Learners are expected to be deterministic by the random seed. Default: 123456.
`sorting_strategy`	How are sorted the numerical features in order to find the splits AUTO: Selects the most efficient method among IN_NODE, FORCE_PRESORT, and LAYER. IN_NODE: The features are sorted just before being used in the node. This solution is slow but consumes little amount of memory. FORCE_PRESORT: The features are pre-sorted at the start of the training. This solution is faster but consumes much more memory than IN_NODE. PRESORT: Automatically choose between FORCE_PRESORT and IN_NODE. . Default: "IN_NODE".
`sparse_oblique_max_num_projections`	For sparse oblique splits i.e. `split_axis=SPARSE_OBLIQUE`. Maximum number of projections (applied after the num_projections_exponent). Oblique splits try out max(p^num_projections_exponent, max_num_projections) random projections for choosing a split, where p is the number of numerical features. Increasing "max_num_projections" increases the training time but not the inference time. In late stage model development, if every bit of accuracy if important, increase this value. The paper "Sparse Projection Oblique Random Forests" (Tomita et al, 2020) does not define this hyperparameter. Default: None.
`sparse_oblique_normalization`	For sparse oblique splits i.e. `split_axis=SPARSE_OBLIQUE`. Normalization applied on the features, before applying the sparse oblique projections. `NONE`: No normalization. `STANDARD_DEVIATION`: Normalize the feature by the estimated standard deviation on the entire train dataset. Also known as Z-Score normalization. `MIN_MAX`: Normalize the feature by the range (i.e. max-min) estimated on the entire train dataset. Default: None.
`sparse_oblique_num_projections_exponent`	For sparse oblique splits i.e. `split_axis=SPARSE_OBLIQUE`. Controls of the number of random projections to test at each node. Increasing this value very likely improves the quality of the model, drastically increases the training time, and doe not impact the inference time. Oblique splits try out max(p^num_projections_exponent, max_num_projections) random projections for choosing a split, where p is the number of numerical features. Therefore, increasing this `num_projections_exponent` and possibly `max_num_projections` may improve model quality, but will also significantly increase training time. Note that the complexity of (classic) Random Forests is roughly proportional to `num_projections_exponent=0.5`, since it considers sqrt(num_features) for a split. The complexity of (classic) GBDT is roughly proportional to `num_projections_exponent=1`, since it considers all features for a split. The paper "Sparse Projection Oblique Random Forests" (Tomita et al, 2020) recommends values in [1/4, 2]. Default: None.
`sparse_oblique_projection_density_factor`	Density of the projections as an exponent of the number of features. Independently for each projection, each feature has a probability "projection_density_factor / num_features" to be considered in the projection. The paper "Sparse Projection Oblique Random Forests" (Tomita et al, 2020) calls this parameter `lambda` and recommends values in [1, 5]. Increasing this value increases training and inference time (on average). This value is best tuned for each dataset. Default: None.
`sparse_oblique_weights`	For sparse oblique splits i.e. `split_axis=SPARSE_OBLIQUE`. Possible values: `BINARY`: The oblique weights are sampled in {-1,1} (default). `CONTINUOUS`: The oblique weights are be sampled in [-1,1]. Default: None.
`split_axis`	What structure of split to consider for numerical features. `AXIS_ALIGNED`: Axis aligned splits (i.e. one condition at a time). This is the "classical" way to train a tree. Default value. `SPARSE_OBLIQUE`: Sparse oblique splits (i.e. random splits on a small number of features) from "Sparse Projection Oblique Random Forests", Tomita et al., 2020. `MHLD_OBLIQUE`: Multi-class Hellinger Linear Discriminant splits from "Classification Based on Multivariate Contrast Patterns", Canete-Sifuentes et al., 2029 Default: "AXIS_ALIGNED".
`uplift_min_examples_in_treatment`	For uplift models only. Minimum number of examples per treatment in a node. Default: 5.
`uplift_split_score`	For uplift models only. Splitter score i.e. score optimized by the splitters. The scores are introduced in "Decision trees for uplift modeling with single and multiple treatments", Rzepakowski et al. Notation: `p` probability / average value of the positive outcome, `q` probability / average value in the control group. `KULLBACK_LEIBLER` or `KL`: - p log (p/q) `EUCLIDEAN_DISTANCE` or `ED`: (p-q)^2 `CHI_SQUARED` or `CS`: (p-q)^2/q Default: "KULLBACK_LEIBLER".
`validation_ratio`	Ratio of the training dataset used to create the validation dataset for pruning the tree. If set to 0, the entire dataset is used for training, and the tree is not pruned. Default: 0.1.
`activity_regularizer`	Optional regularizer function for the output of this layer.
`autotune_steps_per_execution`	Settable property to enable tuning for steps_per_execution
`compute_dtype`	The dtype of the layer's computations. This is equivalent to `Layer.dtype_policy.compute_dtype`. Unless mixed precision is used, this is the same as `Layer.dtype`, the dtype of the weights. Layers automatically cast their inputs to the compute dtype, which causes computations and the output to be in the compute dtype as well. This is done by the base Layer class in `Layer.call`, so you do not have to insert these casts if implementing your own layer. Layers often perform certain internal computations in higher precision when `compute_dtype` is float16 or bfloat16 for numeric stability. The output will still typically be float16 or bfloat16 in such cases.
`distribute_reduction_method`	The method employed to reduce per-replica values during training. Unless specified, the value "auto" will be assumed, indicating that the reduction strategy should be chosen based on the current running environment. See `reduce_per_replica` function for more details.
`distribute_strategy`	The `tf.distribute.Strategy` this model was created under.
`dtype`	The dtype of the layer weights. This is equivalent to `Layer.dtype_policy.variable_dtype`. Unless mixed precision is used, this is the same as `Layer.compute_dtype`, the dtype of the layer's computations.
`dtype_policy`	The dtype policy associated with this layer. This is an instance of a `tf.keras.mixed_precision.Policy`.
`dynamic`	Whether the layer is dynamic (eager-only); set in the constructor.
`input`	Retrieves the input tensor(s) of a layer. Only applicable if the layer has exactly one input, i.e. if it is connected to one incoming layer.
`input_spec`	`InputSpec` instance(s) describing the input format for this layer. When you create a layer subclass, you can set `self.input_spec` to enable the layer to run input compatibility checks when it is called. Consider a `Conv2D` layer: it can only be called on a single input tensor of rank 4. As such, you can set, in `__init__()`: `self.input_spec = tf.keras.layers.InputSpec(ndim=4)` Now, if you try to call the layer on an input that isn't rank 4 (for instance, an input of shape `(2,)`, it will raise a nicely-formatted error: `ValueError: Input 0 of layer conv2d is incompatible with the layer: expected ndim=4, found ndim=1. Full shape received: [2]` Input checks that can be specified via `input_spec` include: Structure (e.g. a single input, a list of 2 inputs, etc) Shape Rank (ndim) Dtype For more information, see `tf.keras.layers.InputSpec`.
`jit_compile`	Specify whether to compile the model with XLA. XLA is an optimizing compiler for machine learning. `jit_compile` is not enabled by default. Note that `jit_compile=True` may not necessarily work for all models. For more information on supported operations please refer to the XLA documentation. Also refer to known XLA issues for more details.
`layers`
`learner`	Name of the learning algorithm used to train the model.
`learner_params`	Gets the dictionary of hyper-parameters passed in the model constructor. Changing this dictionary will impact the training.
`losses`	List of losses added using the `add_loss()` API. Variable regularization tensors are created when this property is accessed, so it is eager safe: accessing `losses` under a `tf.GradientTape` will propagate gradients back to the corresponding variables. `class MyLayer(tf.keras.layers.Layer):` `def call(self, inputs):` `self.add_loss(tf.abs(tf.reduce_mean(inputs)))` `return inputs` `l = MyLayer()` `l(np.ones((10, 1)))` `l.losses` `[1.0]` `inputs = tf.keras.Input(shape=(10,))` `x = tf.keras.layers.Dense(10)(inputs)` `outputs = tf.keras.layers.Dense(1)(x)` `model = tf.keras.Model(inputs, outputs)` `# Activity regularization.` `len(model.losses)` `0` `model.add_loss(tf.abs(tf.reduce_mean(x)))` `len(model.losses)` `1` `inputs = tf.keras.Input(shape=(10,))` `d = tf.keras.layers.Dense(10, kernel_initializer='ones')` `x = d(inputs)` `outputs = tf.keras.layers.Dense(1)(x)` `model = tf.keras.Model(inputs, outputs)` `# Weight regularization.` `model.add_loss(lambda: tf.reduce_mean(d.kernel))` `model.losses` `[<tf.Tensor: shape=(), dtype=float32, numpy=1.0>]`
`metrics`	Return metrics added using `compile()` or `add_metric()`. Note: Metrics passed to `compile()` are available only after a `keras.Model` has been trained/evaluated on actual data. `inputs = tf.keras.layers.Input(shape=(3,))` `outputs = tf.keras.layers.Dense(2)(inputs)` `model = tf.keras.models.Model(inputs=inputs, outputs=outputs)` `model.compile(optimizer="Adam", loss="mse", metrics=["mae"])` `[m.name for m in model.metrics]` `[]` `x = np.random.random((2, 3))` `y = np.random.randint(0, 2, (2, 2))` `model.fit(x, y)` `[m.name for m in model.metrics]` `['loss', 'mae']` `inputs = tf.keras.layers.Input(shape=(3,))` `d = tf.keras.layers.Dense(2, name='out')` `output_1 = d(inputs)` `output_2 = d(inputs)` `model = tf.keras.models.Model(` `inputs=inputs, outputs=[output_1, output_2])` `model.add_metric(` `tf.reduce_sum(output_2), name='mean', aggregation='mean')` `model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"])` `model.fit(x, (y, y))` `[m.name for m in model.metrics]` `['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',` `'out_1_acc', 'mean']`
`metrics_names`	Returns the model's display labels for all outputs. Note: `metrics_names` are available only after a `keras.Model` has been trained/evaluated on actual data. `inputs = tf.keras.layers.Input(shape=(3,))` `outputs = tf.keras.layers.Dense(2)(inputs)` `model = tf.keras.models.Model(inputs=inputs, outputs=outputs)` `model.compile(optimizer="Adam", loss="mse", metrics=["mae"])` `model.metrics_names` `[]` `x = np.random.random((2, 3))` `y = np.random.randint(0, 2, (2, 2))` `model.fit(x, y)` `model.metrics_names` `['loss', 'mae']` `inputs = tf.keras.layers.Input(shape=(3,))` `d = tf.keras.layers.Dense(2, name='out')` `output_1 = d(inputs)` `output_2 = d(inputs)` `model = tf.keras.models.Model(` `inputs=inputs, outputs=[output_1, output_2])` `model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"])` `model.fit(x, (y, y))` `model.metrics_names` `['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',` `'out_1_acc']`
`name_scope`	Returns a `tf.name_scope` instance for this class.
`non_trainable_weights`	List of all non-trainable weights tracked by this layer. Non-trainable weights are not updated during training. They are expected to be updated manually in `call()`.
`num_training_examples`	Number of training examples.
`num_validation_examples`	Number of validation examples.
`output`	Retrieves the output tensor(s) of a layer. Only applicable if the layer has exactly one output, i.e. if it is connected to one incoming layer.
`run_eagerly`	Settable attribute indicating whether the model should run eagerly. Running eagerly means that your model will be run step by step, like Python code. Your model might run slower, but it should become easier for you to debug it by stepping into individual layer calls. By default, we will attempt to compile your model to a static graph to deliver the best execution performance.
`steps_per_execution`	Settable `steps_per_execution variable. Requires a compiled model. </td> </tr><tr> <td>`submodules`	Sequence of all sub-modules. Submodules are modules which are properties of this module, or found as properties of modules which are properties of this module (and so on). `a = tf.Module()` `b = tf.Module()` `c = tf.Module()` `a.b = b` `b.c = c` `list(a.submodules) == [b, c]` `True` `list(b.submodules) == [c]` `True` `list(c.submodules) == []` `True`
`supports_masking`	Whether this layer supports computing a mask using `compute_mask`.
`trainable`
`trainable_weights`	List of all trainable weights tracked by this layer. Trainable weights are updated via gradient descent during training.
`training_model_id`	Identifier of the model.
`variable_dtype`	Alias of `Layer.dtype`, the dtype of the weights.
`weights`	Returns the list of all layer variables/weights. Note: This will not track the weights of nested `tf.Modules` that are not themselves TF-Keras layers.

Methods

`add_loss`

add_loss(
    losses, **kwargs
)

Add loss tensor(s), potentially dependent on layer inputs.

Some losses (for instance, activity regularization losses) may be dependent on the inputs passed when calling a layer. Hence, when reusing the same layer on different inputs a and b, some entries in layer.losses may be dependent on a and some on b. This method automatically keeps track of dependencies.

This method can be used inside a subclassed layer or model's call function, in which case losses should be a Tensor or list of Tensors.

Example:

class MyLayer(tf.keras.layers.Layer):
  def call(self, inputs):
    self.add_loss(tf.abs(tf.reduce_mean(inputs)))
    return inputs

The same code works in distributed training: the input to add_loss() is treated like a regularization loss and averaged across replicas by the training loop (both built-in Model.fit() and compliant custom training loops).

The add_loss method can also be called directly on a Functional Model during construction. In this case, any loss Tensors passed to this Model must be symbolic and be able to be traced back to the model's Inputs. These losses become part of the model's topology and are tracked in get_config.

Example:

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Activity regularization.
model.add_loss(tf.abs(tf.reduce_mean(x)))

If this is not the case for your loss (if, for example, your loss references a Variable of one of the model's layers), you can wrap your loss in a zero-argument lambda. These losses are not tracked as part of the model's topology since they can't be serialized.

Example:

inputs = tf.keras.Input(shape=(10,))
d = tf.keras.layers.Dense(10)
x = d(inputs)
outputs = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs, outputs)
# Weight regularization.
model.add_loss(lambda: tf.reduce_mean(d.kernel))

Args
`losses`	Loss tensor, or list/tuple of tensors. Rather than tensors, losses may also be zero-argument callables which create a loss tensor.
`**kwargs`	Used for backwards compatibility only.

`build`

build(
    input_shape
)

Builds the model based on input shapes received.

This is to be used for subclassed models, which do not know at instantiation time what their inputs look like.

This method only exists for users who want to call model.build() in a standalone way (as a substitute for calling the model on real data to build it). It will never be called by the framework (and thus it will never throw unexpected errors in an unrelated workflow).

Args
`input_shape`	Single tuple, `TensorShape` instance, or list/dict of shapes, where shapes are tuples, integers, or `TensorShape` instances.

Raises

Raises
`ValueError`	In case of invalid user-provided data (not of type tuple, list, `TensorShape`, or dict). If the model requires call arguments that are agnostic to the input shapes (positional or keyword arg in call signature). If not all layers were properly built. If float type inputs are not supported within the layers. In each of these cases, the user should build their model by calling it on real tensor data.

ValueError

In case of invalid user-provided data (not of type tuple, list, TensorShape, or dict).
If the model requires call arguments that are agnostic to the input shapes (positional or keyword arg in call signature).
If not all layers were properly built.
If float type inputs are not supported within the layers.

In each of these cases, the user should build their model by calling it on real tensor data.

`build_from_config`

build_from_config(
    config
)

Builds the layer's states with the supplied config dict.

By default, this method calls the build(config["input_shape"]) method, which creates weights based on the layer's input shape in the supplied config. If your config contains other information needed to load the layer's state, you should override this method.

Args
`config`	Dict containing the input shape associated with this layer.

Args
`inputs`	Input tensors.
`training`	Is the model being trained. Always False.

Args
`metrics`	List of metrics to be evaluated by the model during training and testing.
`weighted_metrics`	List of metrics to be evaluated and weighted by `sample_weight` or `class_weight` during training and testing.
`**kwargs`	Other arguments passed to compile.

Args
`x`	Input data.
`y`	Target data.
`y_pred`	Predictions returned by the model (output of `model(x)`)
`sample_weight`	Sample weights for weighting the loss function.

Args
`inputs`	Tensor or list of tensors.
`mask`	Tensor or list of tensors.

Args
`x`	Input data. It could be: A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). A dict mapping input names to the corresponding array/tensors, if the model has named inputs. A `tf.data` dataset. Should return a tuple of either `(inputs, targets)` or `(inputs, targets, sample_weights)`. A generator or `keras.utils.Sequence` returning `(inputs, targets)` or `(inputs, targets, sample_weights)`. A more detailed description of unpacking behavior for iterator types (Dataset, generator, Sequence) is given in the `Unpacking behavior for iterator-like inputs` section of `Model.fit`.
`y`	Target data. Like the input data `x`, it could be either Numpy array(s) or TensorFlow tensor(s). It should be consistent with `x` (you cannot have Numpy inputs and tensor targets, or inversely). If `x` is a dataset, generator or `keras.utils.Sequence` instance, `y` should not be specified (since targets will be obtained from the iterator/dataset).
`batch_size`	Integer or `None`. Number of samples per batch of computation. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of a dataset, generators, or `keras.utils.Sequence` instances (since they generate batches).
`verbose`	`"auto"`, 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = single line. `"auto"` becomes 1 for most cases, and to 2 when used with `ParameterServerStrategy`. Note that the progress bar is not particularly useful when logged to a file, so `verbose=2` is recommended when not running interactively (e.g. in a production environment). Defaults to 'auto'.
`sample_weight`	Optional Numpy array of weights for the test samples, used for weighting the loss function. You can either pass a flat (1D) Numpy array with the same length as the input samples (1:1 mapping between weights and samples), or in the case of temporal data, you can pass a 2D array with shape `(samples, sequence_length)`, to apply a different weight to every timestep of every sample. This argument is not supported when `x` is a dataset, instead pass sample weights as the third element of `x`.
`steps`	Integer or `None`. Total number of steps (batches of samples) before declaring the evaluation round finished. Ignored with the default value of `None`. If x is a `tf.data` dataset and `steps` is None, 'evaluate' will run until the dataset is exhausted. This argument is not supported with array inputs.
`callbacks`	List of `keras.callbacks.Callback` instances. List of callbacks to apply during evaluation. See callbacks.
`max_queue_size`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum size for the generator queue. If unspecified, `max_queue_size` will default to 10.
`workers`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1.
`use_multiprocessing`	Boolean. Used for generator or `keras.utils.Sequence` input only. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-pickleable arguments to the generator as they can't be passed easily to children processes.
`return_dict`	If `True`, loss and metric results are returned as a dict, with each key being the name of the metric. If `False`, they are returned as a list.
`**kwargs`	Unused at this time.

Args
`x`	Training dataset (See details above for the supported formats).
`y`	Label of the training dataset. Only used if "x" does not contains the labels.
`callbacks`	Callbacks triggered during the training. The training runs in a single epoch, itself run in a single step. Therefore, callback logic can be called equivalently before/after the fit function.
`verbose`	Verbosity mode. 0 = silent, 1 = small details, 2 = full details.
`validation_steps`	Number of steps in the evaluation dataset when evaluating the trained model with `model.evaluate()`. If not specified, evaluates the model on the entire dataset (generally recommended; not yet supported for distributed datasets).
`validation_data`	Validation dataset. If specified, the learner might use this dataset to help training e.g. early stopping.
`sample_weight`	Training weights. Note: training weights can also be provided as the third output in a `tf.data.Dataset` e.g. (features, label, weights).
`steps_per_epoch`	[Parameter will be removed] Number of training batch to load before training the model. Currently, only supported for distributed training.
`class_weight`	For binary classification only. Mapping class indices (integers) to a weight (float) value. Only available for non-Distributed training. For maximum compatibility, feed example weights through the tf.data.Dataset or using the `weight` argument of `pd_dataframe_to_tf_dataset`.
`**kwargs`	Extra arguments passed to the core keras model's fit. Note that not all keras' model fit arguments are supported.

Args
`train_path`	Path to the training dataset. Supports comma separated files, shard and glob notation.
`label_key`	Name of the label column.
`weight_key`	Name of the weighing column.
`valid_path`	Path to the validation dataset. If not provided, or if the learning algorithm does not supports/needs a validation dataset, `valid_path` is ignored.
`dataset_format`	Format of the dataset. Should be one of the registered dataset format (see User Manual for more details). The format "csv" is always available but it is generally only suited for small datasets.
`max_num_scanned_rows_to_accumulate_statistics`	Maximum number of examples to scan to determine the statistics of the features (i.e. the dataspec, e.g. mean value, dictionaries). (Currently) the "first" examples of the dataset are scanned (e.g. the first examples of the dataset is a single file). Therefore, it is important that the sampled dataset is relatively uniformly sampled, notably the scanned examples should contains all the possible categorical values (otherwise the not seen value will be treated as out-of-vocabulary). If set to None, the entire dataset is scanned. This parameter has no effect if the dataset is stored in a format that already contains those values.
`try_resume_training`	If true, tries to resume training from the model checkpoint stored in the `temp_directory` directory. If `temp_directory` does not contain any model checkpoint, start the training from the start. Works in the following three situations: (1) The training was interrupted by the user (e.g. ctrl+c). (2) the training job was interrupted (e.g. rescheduling), ond (3) the hyper-parameter of the model were changed such that an initially completed training is now incomplete (e.g. increasing the number of trees).
`input_model_signature_fn`	A lambda that returns the (Dense,Sparse,Ragged)TensorSpec (or structure of TensorSpec e.g. dictionary, list) corresponding to input signature of the model. If not specified, the input model signature is created by `build_default_input_model_signature`. For example, specify `input_model_signature_fn` if an numerical input feature (which is consumed as DenseTensorSpec(float32) by default) will be feed differently (e.g. RaggedTensor(int64)).
`num_io_threads`	Number of threads to use for IO operations e.g. reading a dataset from disk. Increasing this value can speed-up IO operations when IO operations are either latency or cpu bounded.

Returns
A `dict` containing values of the metrics listed in `self.metrics`.
`Example`	`{'loss': 0.2, 'accuracy': 0.7}`.

Args
`*args`	Passed through to base `keras.Model` implemenation.
`**kwargs`	Passed through to base `keras.Model` implemenation.

Args
`x`	Input samples. It could be: A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). A `tf.data` dataset. A generator or `keras.utils.Sequence` instance. A more detailed description of unpacking behavior for iterator types (Dataset, generator, Sequence) is given in the `Unpacking behavior for iterator-like inputs` section of `Model.fit`.
`batch_size`	Integer or `None`. Number of samples per batch. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of dataset, generators, or `keras.utils.Sequence` instances (since they generate batches).
`verbose`	`"auto"`, 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = single line. `"auto"` becomes 1 for most cases, and to 2 when used with `ParameterServerStrategy`. Note that the progress bar is not particularly useful when logged to a file, so `verbose=2` is recommended when not running interactively (e.g. in a production environment). Defaults to 'auto'.
`steps`	Total number of steps (batches of samples) before declaring the prediction round finished. Ignored with the default value of `None`. If x is a `tf.data` dataset and `steps` is None, `predict()` will run until the input dataset is exhausted.
`callbacks`	List of `keras.callbacks.Callback` instances. List of callbacks to apply during prediction. See callbacks.
`max_queue_size`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum size for the generator queue. If unspecified, `max_queue_size` will default to 10.
`workers`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1.
`use_multiprocessing`	Boolean. Used for generator or `keras.utils.Sequence` input only. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-pickleable arguments to the generator as they can't be passed easily to children processes.

Raises
`RuntimeError`	If `model.predict` is wrapped in a `tf.function`.
`ValueError`	In case of mismatch between the provided input data and the model's expectations, or in case a stateful model receives a number of samples that is not a multiple of the batch size.

Args
`filepath`	Path to the output model.
`overwrite`	If true, override an already existing model. If false, raise an error if a model already exist.
`**kwargs`	Arguments passed to the core keras model's save.

Args
`filepath`	String or PathLike, path to the file to save the weights to. When saving in TensorFlow format, this is the prefix used for checkpoint files (multiple files are generated). Note that the '.h5' suffix causes weights to be saved in HDF5 format.
`overwrite`	Whether to silently overwrite any existing file at the target location, or provide the user with a manual prompt.
`save_format`	Either 'tf' or 'h5'. A `filepath` ending in '.h5' or '.keras' will default to HDF5 if `save_format` is `None`. Otherwise, `None` becomes 'tf'. Defaults to `None`.
`options`	Optional `tf.train.CheckpointOptions` object that specifies options for saving weights.

tfdf.keras.wrappers.CartModel

Usage example:

Attributes

Methods

add_loss

Example:

Example:

Example:

build

build_from_config

call

call_get_leaves

capabilities

collect_data_step

compile

compile_from_config

compute_loss

Example:

compute_mask

compute_metrics

Example:

compute_output_shape

count_params

evaluate

export

Example:

fit

Local training

Distributed training

fit_on_dataset_path

Local training

Distributed training

from_config

get_build_config

get_compile_config

get_config

get_layer

get_metrics_result

get_weight_paths

Example:

get_weights

load_own_variables

load_weights

make_inspector

Usage example:

make_predict_function

make_test_function

make_train_function

predefined_hyperparameters

predict

predict_get_leaves

predict_on_batch

predict_step

ranking_group

reset_metrics

Examples:

reset_states

save

save_own_variables

save_spec

save_weights

set_weights

summary

support_distributed_training

test_on_batch

test_step

to_json

to_yaml

train_on_batch

train_step

uplift_treatment

valid_step

with_name_scope

yggdrasil_model_path_tensor

yggdrasil_model_prefix

__call__

`add_loss`

`build`

`build_from_config`

`call`

`call_get_leaves`

`capabilities`

`collect_data_step`

`compile`

`compile_from_config`

`compute_loss`

`compute_mask`

`compute_metrics`

`compute_output_shape`

`count_params`

`evaluate`

`export`

`fit`

`fit_on_dataset_path`

`from_config`

`get_build_config`

`get_compile_config`

`get_config`

`get_layer`

`get_metrics_result`

`get_weight_paths`

`get_weights`

`load_own_variables`

`load_weights`

`make_inspector`

`make_predict_function`

`make_test_function`

`make_train_function`

`predefined_hyperparameters`

`predict`

`predict_get_leaves`

`predict_on_batch`

`predict_step`

`ranking_group`

`reset_metrics`

`reset_states`

`save`

`save_own_variables`

`save_spec`

`save_weights`

`set_weights`

`summary`

`support_distributed_training`

`test_on_batch`

`test_step`

`to_json`

`to_yaml`

`train_on_batch`

`train_step`

`uplift_treatment`

`valid_step`

`with_name_scope`

`yggdrasil_model_path_tensor`

`yggdrasil_model_prefix`

`call`