# Pengukur Kaleng TF Lattice

## Ringkasan

Penaksir kalengan adalah cara cepat dan mudah untuk melatih model TFL untuk kasus penggunaan umum. Panduan ini menguraikan langkah-langkah yang diperlukan untuk membuat estimator kalengan TFL.

## Mempersiapkan

Menginstal paket TF Lattice:

````pip install tensorflow-lattice`
```

Mengimpor paket yang dibutuhkan:

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

Mengunduh kumpulan data UCI Statlog (Hati):

``````csv_file = tf.keras.utils.get_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:]
``````

Menyetel nilai default yang digunakan untuk pelatihan dalam panduan ini:

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

## Kolom Fitur

Adapun setiap estimator TF lain, kebutuhan data yang akan diteruskan ke estimator, yang biasanya melalui input_fn dan diurai menggunakan FeatureColumns .

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

Penaksir kalengan TFL menggunakan jenis kolom fitur untuk memutuskan jenis lapisan kalibrasi yang akan digunakan. Kami menggunakan `tfl.layers.PWLCalibration` lapisan untuk kolom fitur numerik dan `tfl.layers.CategoricalCalibration` lapisan untuk kolom fitur kategoris.

Perhatikan bahwa kolom fitur kategorikal tidak dibungkus oleh kolom fitur penyematan. Mereka langsung dimasukkan ke dalam estimator.

## Membuat input_fn

Untuk estimator lainnya, Anda dapat menggunakan input_fn untuk memasukkan data ke model untuk pelatihan dan evaluasi. Penaksir TFL dapat secara otomatis menghitung kuantil fitur dan menggunakannya sebagai titik kunci input untuk lapisan kalibrasi PWL. Untuk melakukannya, mereka membutuhkan melewati `feature_analysis_input_fn` , yang mirip dengan pelatihan input_fn tetapi dengan zaman tunggal atau sub-sampel data.

``````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,

# 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,

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,

# Serving input fn is used to create saved models.
serving_input_fn = (
feature_spec=fc.make_parse_example_spec(feature_columns)))
``````

## Konfigurasi Fitur

Fitur kalibrasi dan konfigurasi per-fitur diatur menggunakan `tfl.configs.FeatureConfig` . Konfigurasi fitur termasuk kendala monotonisitas, regularisasi per-fitur (lihat `tfl.configs.RegularizerConfig` ), dan ukuran kisi untuk model kisi.

Jika tidak ada konfigurasi didefinisikan untuk fitur masukan, konfigurasi default di `tfl.config.FeatureConfig` digunakan.

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

## Model Linier Terkalibrasi

Untuk membangun sebuah TFL kalengan estimator, membangun sebuah konfigurasi Model dari `tfl.configs` . Sebuah model linear dikalibrasi dibangun menggunakan `tfl.configs.CalibratedLinearConfig` . Ini menerapkan kalibrasi piecewise-linear dan kategoris pada fitur input, diikuti dengan kombinasi linear dan kalibrasi piecewise-linear output opsional. Saat menggunakan kalibrasi keluaran atau ketika batas keluaran ditentukan, lapisan linier akan menerapkan rata-rata tertimbang pada masukan yang dikalibrasi.

Contoh ini membuat model linier terkalibrasi pada 5 fitur pertama. Kami menggunakan `tfl.visualization` untuk plot grafik model dengan plot kalibrator.

``````# 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,
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)
``````
```2021-09-30 20:54:06.660239: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
Calibrated linear test AUC: 0.834586501121521
```

## Model Kisi Terkalibrasi

Sebuah model kisi dikalibrasi dibangun menggunakan `tfl.configs.CalibratedLatticeConfig` . Model kisi yang dikalibrasi menerapkan kalibrasi linier sepotong-sepotong dan kategoris pada fitur input, diikuti oleh model kisi dan kalibrasi linier sepotong-sepotong keluaran opsional.

Contoh ini membuat model kisi yang dikalibrasi pada 5 fitur pertama.

``````# 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,
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.8427318930625916
```

## Ensemble Kisi Terkalibrasi

Ketika jumlah fitur besar, Anda dapat menggunakan model ensemble, yang membuat beberapa kisi yang lebih kecil untuk subset fitur dan rata-rata outputnya alih-alih membuat hanya satu kisi besar. Model kisi Ensemble dibangun menggunakan `tfl.configs.CalibratedLatticeEnsembleConfig` . Model ansambel kisi yang dikalibrasi menerapkan kalibrasi linier-sepotong dan kategoris pada fitur input, diikuti oleh ansambel model kisi dan kalibrasi linier-sepotong output opsional.

### Ensemble Kisi Acak

Konfigurasi model berikut menggunakan subset fitur acak untuk setiap kisi.

``````# 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,
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.9003759026527405
```

### Ensemble Kisi Acak Lapisan RTL

Model berikut konfigurasi menggunakan `tfl.layers.RTL` lapisan yang menggunakan subset acak fitur untuk setiap kisi. Kami mencatat bahwa `tfl.layers.RTL` hanya mendukung kendala monotonisitas dan harus memiliki ukuran kisi yang sama untuk semua fitur dan tidak ada regularisasi per-fitur. Perhatikan bahwa menggunakan `tfl.layers.RTL` lapisan memungkinkan Anda skala untuk ansambel jauh lebih besar daripada menggunakan terpisah `tfl.layers.Lattice` contoh.

``````# 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,
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.8903509378433228
```

### Ansambel Kisi Kristal

TFL juga menyediakan algoritma pengaturan fitur heuristik, yang disebut Kristal . Kristal algoritma kereta api pertama model prefitting bahwa perkiraan berpasangan interaksi fitur. Kemudian mengatur ansambel akhir sedemikian rupa sehingga fitur dengan lebih banyak interaksi non-linier berada dalam kisi yang sama.

Untuk model Kristal, Anda juga akan perlu memberikan `prefitting_input_fn` yang digunakan untuk melatih model prefitting, seperti dijelaskan di atas. Model prefitting tidak perlu dilatih sepenuhnya, jadi beberapa epoch sudah cukup.

``````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,
``````

Anda kemudian dapat membuat model kristal dengan menetapkan `lattice='crystals'` dalam model konfigurasi.

``````# 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,
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.8840851783752441
```

Anda dapat merencanakan kalibrator fitur dengan rincian lainnya menggunakan `tfl.visualization` modul.

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

[{ "type": "thumb-down", "id": "missingTheInformationINeed", "label":"Missing the information I need" },{ "type": "thumb-down", "id": "tooComplicatedTooManySteps", "label":"Too complicated / too many steps" },{ "type": "thumb-down", "id": "outOfDate", "label":"Out of date" },{ "type": "thumb-down", "id": "translationIssue", "label":"Translation issue" },{ "type": "thumb-down", "id": "samplesCodeIssue", "label":"Masalah kode / contoh" },{ "type": "thumb-down", "id": "otherDown", "label":"Other" }]
[{ "type": "thumb-up", "id": "easyToUnderstand", "label":"Easy to understand" },{ "type": "thumb-up", "id": "solvedMyProblem", "label":"Solved my problem" },{ "type": "thumb-up", "id": "otherUp", "label":"Other" }]