# Copyright 2019 Google LLC

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

"""TFL model configuration library for canned estimators.

To construct a TFL canned estimator, construct a model configuration and pass

it to the canned estimator constructor:

```python

feature_columns = ...

model_config = tfl.configs.CalibratedLatticeConfig(...)

feature_analysis_input_fn = create_input_fn(num_epochs=1, ...)

train_input_fn = create_input_fn(num_epochs=100, ...)

estimator = tfl.estimators.CannedClassifier(

feature_columns=feature_columns,

model_config=model_config,

feature_analysis_input_fn=feature_analysis_input_fn)

estimator.train(input_fn=train_input_fn)

```

Supported models are:

* **Calibrated linear model**: Constructed using

`tfl.configs.CalibratedLinearConfig`.

A calibrated linear model that applies piecewise-linear and categorical

calibration on the input feature, followed by a linear combination and an

optional output piecewise-linear calibration. When using output calibration

or when output bounds are specified, the linear layer will apply weighted

averaging on calibrated inputs.

* **Calibrated lattice model**: Constructed using

`tfl.configs.CalibratedLatticeConfig`.

A calibrated lattice model applies piecewise-linear and categorical

calibration on the input feature, followed by a lattice model and an

optional output piecewise-linear calibration.

* **Calibrated lattice ensemble model**: Constructed using

`tfl.configs.CalibratedLatticeEnsembleConfig`.

A calibrated lattice ensemble model applies piecewise-linear and categorical

calibration on the input feature, followed by an ensemble of lattice models

and an optional output piecewise-linear calibration.

Feature calibration and per-feature configurations are set using

`tfl.configs.FeatureConfig`. Feature configurations include monotonicity

constraints, per-feature regularization (see `tfl.configs.RegularizerConfig`),

and lattice sizes for lattice models.

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import collections

import copy

from absl import logging

import tensorflow as tf

# pylint: disable=g-import-not-at-top

# Use Keras 2.

version_fn = getattr(tf.keras, "version", None)

if version_fn and version_fn().startswith("3."):

import tf_keras as keras

else:

keras = tf.keras

_HPARAM_FEATURE_PREFIX = 'feature'

_HPARAM_REGULARIZER_PREFIX = 'regularizer'

class _Config(object):

return config

class _HasFeatureConfigs(object):

return feature_config

class _HasRegularizerConfigs(object):

return regularizer_config

# pylint: disable=unused-argument

class CalibratedLatticeEnsembleConfig(_Config, _HasFeatureConfigs,

config, custom_objects=custom_objects))

class CalibratedLatticeConfig(_Config, _HasFeatureConfigs,

config, custom_objects=custom_objects))

class CalibratedLinearConfig(_Config, _HasFeatureConfigs,

config, custom_objects=custom_objects))

# TODO: add option for different pre-aggregation model (linear/ensemble)

class AggregateFunctionConfig(_Config, _HasFeatureConfigs,

config, custom_objects=custom_objects))

class FeatureConfig(_Config, _HasRegularizerConfigs):

config, custom_objects=custom_objects))

class RegularizerConfig(_Config):

config, custom_objects=custom_objects))

class TrustConfig(_Config):