Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

TF Lattice Canned Estimators

Ansicht auf TensorFlow.org Führen Sie in Google Colab aus Quelle auf GitHub anzeigen Notizbuch herunterladen

Überblick

Eingemachte Schätzer sind eine schnelle und einfache Möglichkeit, TFL-Modelle für typische Anwendungsfälle zu trainieren. In diesem Handbuch werden die Schritte beschrieben, die zum Erstellen eines TFL-Schätzers in Dosen erforderlich sind.

Konfiguration

Installieren des TF-Gitterpakets:


!pip install -q tensorflow-lattice

Erforderliche Pakete importieren:

import tensorflow as tf

import copy
import logging
import numpy as np
import pandas as pd
import sys
import tensorflow_lattice as tfl
from tensorflow import feature_column as fc
logging.disable(sys.maxsize)

Herunterladen des UCI Statlog (Heart) -Datensatzes:

csv_file = tf.keras.utils.get_file(
    'heart.csv', 'http://storage.googleapis.com/applied-dl/heart.csv')
df = pd.read_csv(csv_file)
target = df.pop('target')
train_size = int(len(df) * 0.8)
train_x = df[:train_size]
train_y = target[:train_size]
test_x = df[train_size:]
test_y = target[train_size:]
df.head()

Festlegen der Standardwerte für das Training in diesem Handbuch:

LEARNING_RATE = 0.01
BATCH_SIZE = 128
NUM_EPOCHS = 500
PREFITTING_NUM_EPOCHS = 10

Feature-Spalten

Wie bei jedem anderen TF-Schätzer müssen Daten an den Schätzer übergeben werden . Dies erfolgt normalerweise über ein input_fn und wird mithilfe von FeatureColumns analysiert.

# Feature columns.
# - age
# - sex
# - cp        chest pain type (4 values)
# - trestbps  resting blood pressure
# - chol      serum cholestoral in mg/dl
# - fbs       fasting blood sugar > 120 mg/dl
# - restecg   resting electrocardiographic results (values 0,1,2)
# - thalach   maximum heart rate achieved
# - exang     exercise induced angina
# - oldpeak   ST depression induced by exercise relative to rest
# - slope     the slope of the peak exercise ST segment
# - ca        number of major vessels (0-3) colored by flourosopy
# - thal      3 = normal; 6 = fixed defect; 7 = reversable defect
feature_columns = [
    fc.numeric_column('age', default_value=-1),
    fc.categorical_column_with_vocabulary_list('sex', [0, 1]),
    fc.numeric_column('cp'),
    fc.numeric_column('trestbps', default_value=-1),
    fc.numeric_column('chol'),
    fc.categorical_column_with_vocabulary_list('fbs', [0, 1]),
    fc.categorical_column_with_vocabulary_list('restecg', [0, 1, 2]),
    fc.numeric_column('thalach'),
    fc.categorical_column_with_vocabulary_list('exang', [0, 1]),
    fc.numeric_column('oldpeak'),
    fc.categorical_column_with_vocabulary_list('slope', [0, 1, 2]),
    fc.numeric_column('ca'),
    fc.categorical_column_with_vocabulary_list(
        'thal', ['normal', 'fixed', 'reversible']),
]

TFL-Schätzer in Dosen verwenden den Typ der Feature-Spalte, um zu entscheiden, welche Art von Kalibrierungsschicht verwendet werden soll. Wir verwenden eine tfl.layers.PWLCalibration Ebene für numerische Feature-Spalten und eine tfl.layers.CategoricalCalibration Ebene für kategoriale Feature-Spalten.

Beachten Sie, dass kategoriale Feature-Spalten nicht von einer eingebetteten Feature-Spalte umschlossen werden. Sie werden direkt in den Schätzer eingespeist.

Input_fn erstellen

Wie bei jedem anderen Schätzer können Sie einen input_fn verwenden, um dem Modell Daten für Training und Bewertung zuzuführen. TFL-Schätzer können Quantile der Merkmale automatisch berechnen und als Eingabe-Schlüsselpunkte für die PWL-Kalibrierungsschicht verwenden. Dazu müssen sie ein feature_analysis_input_fn , das dem Training input_fn ähnelt, jedoch eine einzelne Epoche oder eine Teilstichprobe der Daten enthält.

train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    num_epochs=NUM_EPOCHS,
    num_threads=1)

# feature_analysis_input_fn is used to collect statistics about the input.
feature_analysis_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    # Note that we only need one pass over the data.
    num_epochs=1,
    num_threads=1)

test_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=test_x,
    y=test_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    num_epochs=1,
    num_threads=1)

# Serving input fn is used to create saved models.
serving_input_fn = (
    tf.estimator.export.build_parsing_serving_input_receiver_fn(
        feature_spec=fc.make_parse_example_spec(feature_columns)))

Funktionskonfigurationen

Die Feature-Kalibrierung und die Konfiguration pro Feature werden mit tfl.configs.FeatureConfig . Zu den Feature-Konfigurationen gehören Monotonieeinschränkungen, Regularisierung pro Feature (siehe tfl.configs.RegularizerConfig ) und tfl.configs.RegularizerConfig für Gittermodelle.

Wenn für eine Eingabefunktion keine Konfiguration definiert ist, wird die Standardkonfiguration in tfl.config.FeatureConfig verwendet.

# Feature configs are used to specify how each feature is calibrated and used.
feature_configs = [
    tfl.configs.FeatureConfig(
        name='age',
        lattice_size=3,
        # By default, input keypoints of pwl are quantiles of the feature.
        pwl_calibration_num_keypoints=5,
        monotonicity='increasing',
        pwl_calibration_clip_max=100,
        # Per feature regularization.
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name='calib_wrinkle', l2=0.1),
        ],
    ),
    tfl.configs.FeatureConfig(
        name='cp',
        pwl_calibration_num_keypoints=4,
        # Keypoints can be uniformly spaced.
        pwl_calibration_input_keypoints='uniform',
        monotonicity='increasing',
    ),
    tfl.configs.FeatureConfig(
        name='chol',
        # Explicit input keypoint initialization.
        pwl_calibration_input_keypoints=[126.0, 210.0, 247.0, 286.0, 564.0],
        monotonicity='increasing',
        # Calibration can be forced to span the full output range by clamping.
        pwl_calibration_clamp_min=True,
        pwl_calibration_clamp_max=True,
        # Per feature regularization.
        regularizer_configs=[
            tfl.configs.RegularizerConfig(name='calib_hessian', l2=1e-4),
        ],
    ),
    tfl.configs.FeatureConfig(
        name='fbs',
        # Partial monotonicity: output(0) <= output(1)
        monotonicity=[(0, 1)],
    ),
    tfl.configs.FeatureConfig(
        name='trestbps',
        pwl_calibration_num_keypoints=5,
        monotonicity='decreasing',
    ),
    tfl.configs.FeatureConfig(
        name='thalach',
        pwl_calibration_num_keypoints=5,
        monotonicity='decreasing',
    ),
    tfl.configs.FeatureConfig(
        name='restecg',
        # Partial monotonicity: output(0) <= output(1), output(0) <= output(2)
        monotonicity=[(0, 1), (0, 2)],
    ),
    tfl.configs.FeatureConfig(
        name='exang',
        # Partial monotonicity: output(0) <= output(1)
        monotonicity=[(0, 1)],
    ),
    tfl.configs.FeatureConfig(
        name='oldpeak',
        pwl_calibration_num_keypoints=5,
        monotonicity='increasing',
    ),
    tfl.configs.FeatureConfig(
        name='slope',
        # Partial monotonicity: output(0) <= output(1), output(1) <= output(2)
        monotonicity=[(0, 1), (1, 2)],
    ),
    tfl.configs.FeatureConfig(
        name='ca',
        pwl_calibration_num_keypoints=4,
        monotonicity='increasing',
    ),
    tfl.configs.FeatureConfig(
        name='thal',
        # Partial monotonicity:
        # output(normal) <= output(fixed)
        # output(normal) <= output(reversible)        
        monotonicity=[('normal', 'fixed'), ('normal', 'reversible')],
    ),
]

Kalibriertes lineares Modell

tfl.configs eine Modellkonfiguration aus tfl.configs , um einen tfl.configs TFL-Schätzer zu tfl.configs . Ein kalibriertes lineares Modell wird mit tfl.configs.CalibratedLinearConfig . Es wendet eine stückweise lineare und kategoriale Kalibrierung auf die Eingabemerkmale an, gefolgt von einer linearen Kombination und einer optionalen stückweise linearen Ausgabekalibrierung. Bei Verwendung der Ausgabekalibrierung oder bei Angabe von Ausgabegrenzen wendet die lineare Ebene eine gewichtete Mittelung auf kalibrierte Eingaben an.

In diesem Beispiel wird ein kalibriertes lineares Modell für die ersten 5 Features erstellt. Wir verwenden tfl.visualization , um das tfl.visualization mit den Kalibratorplots zu zeichnen.

# Model config defines the model structure for the estimator.
model_config = tfl.configs.CalibratedLinearConfig(
    feature_configs=feature_configs,
    use_bias=True,
    output_calibration=True,
    regularizer_configs=[
        # Regularizer for the output calibrator.
        tfl.configs.RegularizerConfig(name='output_calib_hessian', l2=1e-4),
    ])
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns[:5],
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Calibrated linear test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph)
Calibrated linear test AUC: 0.834586501121521

png

Kalibriertes Gittermodell

Ein kalibriertes Gittermodell wird mit tfl.configs.CalibratedLatticeConfig . Ein kalibriertes Gittermodell wendet eine stückweise lineare und kategoriale Kalibrierung auf die Eingabemerkmale an, gefolgt von einem Gittermodell und einer optionalen stückweise linearen Ausgabekalibrierung.

In diesem Beispiel wird ein kalibriertes Gittermodell für die ersten 5 Features erstellt.

# This is calibrated lattice model: Inputs are calibrated, then combined
# non-linearly using a lattice layer.
model_config = tfl.configs.CalibratedLatticeConfig(
    feature_configs=feature_configs,
    regularizer_configs=[
        # Torsion regularizer applied to the lattice to make it more linear.
        tfl.configs.RegularizerConfig(name='torsion', l2=1e-4),
        # Globally defined calibration regularizer is applied to all features.
        tfl.configs.RegularizerConfig(name='calib_hessian', l2=1e-4),
    ])
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns[:5],
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Calibrated lattice test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph)
Calibrated lattice test AUC: 0.8433583974838257

png

Kalibriertes Gitterensemble

Wenn die Anzahl der Features groß ist, können Sie ein Ensemble-Modell verwenden, das mehrere kleinere Gitter für Teilmengen der Features erstellt und deren Ausgabe mittelt, anstatt nur ein einziges großes Gitter zu erstellen. Ensemble-Gittermodelle werden mit tfl.configs.CalibratedLatticeEnsembleConfig . Ein kalibriertes Gitterensemble-Modell wendet eine stückweise lineare und kategoriale Kalibrierung auf die Eingabefunktion an, gefolgt von einem Ensemble von Gittermodellen und einer optionalen stückweise linearen Ausgabekalibrierung.

Zufälliges Gitterensemble

Die folgende Modellkonfiguration verwendet eine zufällige Teilmenge von Merkmalen für jedes Gitter.

# This is random lattice ensemble model with separate calibration:
# model output is the average output of separately calibrated lattices.
model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    num_lattices=5,
    lattice_rank=3)
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns,
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Random ensemble test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph, calibrator_dpi=15)
Random ensemble test AUC: 0.8991228342056274

png

RTL Layer Random Lattice Ensemble

Die folgende Modellkonfiguration verwendet eine tfl.layers.RTL Ebene, die eine zufällige Teilmenge von Features für jedes Gitter verwendet. Wir stellen fest, dass tfl.layers.RTL nur Monotonieeinschränkungen unterstützt und für alle Features dieselbe tfl.layers.RTL und keine Regularisierung pro Feature haben muss. Beachten Sie, dass Sie mit einer tfl.layers.RTL Ebene auf viel größere Ensembles tfl.layers.Lattice als mit separaten tfl.layers.Lattice Instanzen.

# Make sure our feature configs have the same lattice size, no per-feature
# regularization, and only monotonicity constraints.
rtl_layer_feature_configs = copy.deepcopy(feature_configs)
for feature_config in rtl_layer_feature_configs:
  feature_config.lattice_size = 2
  feature_config.unimodality = 'none'
  feature_config.reflects_trust_in = None
  feature_config.dominates = None
  feature_config.regularizer_configs = None
# This is RTL layer ensemble model with separate calibration:
# model output is the average output of separately calibrated lattices.
model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    lattices='rtl_layer',
    feature_configs=rtl_layer_feature_configs,
    num_lattices=5,
    lattice_rank=3)
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns,
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Random ensemble test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph, calibrator_dpi=15)
Random ensemble test AUC: 0.9241854548454285

png

Crystals Lattice Ensemble

TFL bietet auch einen heuristischen Algorithmus zur Anordnung von Merkmalen, der als Kristalle bezeichnet wird . Der Crystals-Algorithmus trainiert zunächst ein Voranpassungsmodell , das paarweise Merkmalsinteraktionen schätzt. Anschließend wird das endgültige Ensemble so angeordnet, dass Merkmale mit mehr nichtlinearen Wechselwirkungen in denselben Gittern liegen.

Für Crystals-Modelle müssen Sie außerdem ein prefitting_input_fn , mit dem das Prefitting-Modell wie oben beschrieben trainiert wird. Das Voranpassungsmodell muss nicht vollständig trainiert sein, daher sollten einige Epochen ausreichen.

prefitting_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=False,
    batch_size=BATCH_SIZE,
    num_epochs=PREFITTING_NUM_EPOCHS,
    num_threads=1)

Sie können dann ein Kristallmodell erstellen, indem Sie in der Modellkonfiguration gitter lattice='crystals' .

# This is Crystals ensemble model with separate calibration: model output is
# the average output of separately calibrated lattices.
model_config = tfl.configs.CalibratedLatticeEnsembleConfig(
    feature_configs=feature_configs,
    lattices='crystals',
    num_lattices=5,
    lattice_rank=3)
# A CannedClassifier is constructed from the given model config.
estimator = tfl.estimators.CannedClassifier(
    feature_columns=feature_columns,
    model_config=model_config,
    feature_analysis_input_fn=feature_analysis_input_fn,
    # prefitting_input_fn is required to train the prefitting model.
    prefitting_input_fn=prefitting_input_fn,
    optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    prefitting_optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
    config=tf.estimator.RunConfig(tf_random_seed=42))
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('Crystals ensemble test AUC: {}'.format(results['auc']))
saved_model_path = estimator.export_saved_model(estimator.model_dir,
                                                serving_input_fn)
model_graph = tfl.estimators.get_model_graph(saved_model_path)
tfl.visualization.draw_model_graph(model_graph, calibrator_dpi=15)
Crystals ensemble test AUC: 0.8853383660316467

png

Mit dem Modul tfl.visualization können Sie Feature-Kalibratoren mit mehr Details tfl.visualization .

_ = tfl.visualization.plot_feature_calibrator(model_graph, "age")
_ = tfl.visualization.plot_feature_calibrator(model_graph, "restecg")

png

png