Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

TF Lattice Konserve Tahmin Ediciler

TensorFlow.org'da görüntüleyin Google Colab'de çalıştırın Kaynağı GitHub'da görüntüleyin Defteri indirin

Genel Bakış

Hazır tahmin ediciler, tipik kullanım durumları için TFL modellerini eğitmenin hızlı ve kolay yollarıdır. Bu kılavuz, bir TFL hazır tahmin edicisi oluşturmak için gereken adımları özetlemektedir.

Kurmak

TF Lattice paketinin kurulması:

pip install -q tensorflow-lattice

Gerekli paketleri içe aktarma:

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)

UCI Statlog (Heart) veri kümesini indirme:

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()

Bu kılavuzda eğitim için kullanılan varsayılan değerleri ayarlama:

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

Özellik Sütunları

Diğer TF tahmin edicilerinde olduğu gibi, verilerin tahmin ediciye, tipik olarak bir input_fn yoluyla ve FeatureColumns kullanılarak ayrıştırılması gerekir.

# 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 hazır tahmin ediciler, ne tür kalibrasyon katmanının kullanılacağına karar vermek için özellik sütununun türünü kullanır. Biz kullanmak tfl.layers.PWLCalibration sayısal özellik sütunları için katman ve bir tfl.layers.CategoricalCalibration kategorik özellik sütunlar için katmanı.

Kategorik unsur sütunlarının bir gömme unsuru sütunu tarafından sarılmadığını unutmayın. Tahminciye doğrudan beslenirler.

İnput_fn oluşturuluyor

Diğer tahmin edicilerde olduğu gibi, eğitim ve değerlendirme için modele veri beslemek için bir input_fn kullanabilirsiniz. TFL tahmin edicileri, özelliklerin niceliklerini otomatik olarak hesaplayabilir ve bunları PWL kalibrasyon katmanı için giriş anahtar noktaları olarak kullanabilir. Bunu yapmak için, eğitim input_fn'ye benzer, ancak tek bir epoch veya verilerin bir alt örneğine sahip bir feature_analysis_input_fn geçmeleri gerekir.

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)))

Özellik Yapılandırmaları

Özellik kalibrasyonu ve özellik başına yapılandırmalar tfl.configs.FeatureConfig kullanılarak tfl.configs.FeatureConfig . Özellik yapılandırmaları, monotonluk kısıtlamalarını, özellik başına düzenleme (bkz. tfl.configs.RegularizerConfig ) ve kafes modelleri için kafes boyutlarını içerir.

Bir giriş özelliği için herhangi bir yapılandırma tanımlanmadıysa, tfl.config.FeatureConfig varsayılan yapılandırma kullanılır.

# 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')],
    ),
]

Kalibre Edilmiş Doğrusal Model

Bir TFL hazır tahminci oluşturmak için, tfl.configs bir model yapılandırması tfl.configs . tfl.configs.CalibratedLinearConfig kullanılarak kalibre edilmiş bir doğrusal model tfl.configs.CalibratedLinearConfig . Girdi özelliklerine parçalı doğrusal ve kategorik kalibrasyon uygular, ardından doğrusal bir kombinasyon ve isteğe bağlı bir parçalı doğrusal kalibrasyon çıktı. Çıktı kalibrasyonu kullanılırken veya çıktı sınırları belirtildiğinde, doğrusal katman, kalibre edilmiş girdilere ağırlıklı ortalama uygulayacaktır.

Bu örnek, ilk 5 özellik üzerinde kalibre edilmiş bir doğrusal model oluşturur. Model grafiğini kalibratör grafikleriyle çizmek için tfl.visualization kullanırız.

# 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

Kalibre Edilmiş Kafes Modeli

Kalibre edilmiş bir kafes modeli tfl.configs.CalibratedLatticeConfig kullanılarak tfl.configs.CalibratedLatticeConfig . Kalibre edilmiş bir kafes modeli, girdi özelliklerinde parçalı doğrusal ve kategorik kalibrasyon uygular, ardından bir kafes modeli ve isteğe bağlı bir parçalı doğrusal kalibrasyon çıktı.

Bu örnek, ilk 5 unsurda kalibre edilmiş bir kafes modeli oluşturur.

# 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

Kalibre Edilmiş Kafes Topluluk

Özelliklerin sayısı büyük olduğunda, özelliklerin alt kümeleri için birden çok küçük kafes oluşturan ve tek bir büyük kafes oluşturmak yerine çıktılarının ortalamasını alan bir topluluk modeli kullanabilirsiniz. Ensemble lattice modelleri tfl.configs.CalibratedLatticeEnsembleConfig kullanılarak tfl.configs.CalibratedLatticeEnsembleConfig . Kalibre edilmiş bir kafes topluluk modeli, giriş özelliğine parçalı doğrusal ve kategorik kalibrasyon uygular, ardından bir kafes modelleri topluluğu ve isteğe bağlı bir parça parça doğrusal kalibrasyon çıkışı izler.

Random Lattice Ensemble

Aşağıdaki model yapılandırması, her kafes için rastgele bir özellik alt kümesi kullanır.

# 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

Aşağıdaki model yapılandırması, her kafes için rastgele bir özellik alt kümesi kullanan bir tfl.layers.RTL katmanı kullanır. tfl.layers.RTL yalnızca monotonluk kısıtlamalarını desteklediğini ve tüm özellikler için aynı kafes boyutuna sahip olması ve özellik başına düzenleme olmaması gerektiğini not ediyoruz. Bir tfl.layers.RTL katmanı kullanmanın, ayrı tfl.layers.Lattice örnekleri kullanmaktan çok daha büyük topluluklara ölçeklendirmenize izin tfl.layers.RTL unutmayın.

# 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 Kafes Ensemble

TFL ayrıca Crystals adı verilen sezgisel bir özellik düzenleme algoritması sağlar. Crystals algoritması ilk olarak, ikili özellik etkileşimlerini tahmin eden bir uygun model eğitir. Daha sonra, son topluluğu daha doğrusal olmayan etkileşimleri olan özellikler aynı kafeslerde olacak şekilde düzenler.

Crystals modelleri için, yukarıda açıklandığı gibi önceden uydurma modelini eğitmek için kullanılan bir prefitting_input_fn sağlamanız da gerekecektir. Uygun modelin tam olarak eğitilmesi gerekmez, bu nedenle birkaç dönem yeterli olmalıdır.

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)

Daha sonra model yapılandırmasında lattice='crystals' ayarlayarak bir Kristal modeli oluşturabilirsiniz.

# 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

tfl.visualization modülünü kullanarak özellik kalibratörlerini daha fazla ayrıntıyla tfl.visualization .

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

png

png