이 페이지는 Cloud Translation API를 통해 번역되었습니다.
Switch to English

TF Lattice 커스텀 에스티 메이터

TensorFlow.org에서보기 Google Colab에서 실행 GitHub에서 소스보기 노트북 다운로드

개요

사용자 지정 추정기를 사용하여 TFL 레이어를 사용하여 임의로 단조로운 모델을 만들 수 있습니다. 이 가이드는 그러한 추정치를 만드는 데 필요한 단계를 설명합니다.

설정

TF Lattice 패키지 설치 :


pip install -q tensorflow-lattice

필수 패키지 가져 오기 :

import tensorflow as tf

import logging
import numpy as np
import pandas as pd
import sys
import tensorflow_lattice as tfl
from tensorflow import feature_column as fc

from tensorflow_estimator.python.estimator.canned import optimizers
from tensorflow_estimator.python.estimator.head import binary_class_head
logging.disable(sys.maxsize)

UCI Statlog (Heart) 데이터 세트 다운로드 :

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

이 가이드에서 학습에 사용되는 기본값 설정 :

LEARNING_RATE = 0.1
BATCH_SIZE = 128
NUM_EPOCHS = 1000

기능 열

다른 TF 추정기와 마찬가지로 데이터는 일반적으로 input_fn을 통해 추정기로 전달되어야하며 FeatureColumns를 사용하여 구문 분석됩니다.

# Feature columns.
# - age
# - sex
# - 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('ca'),
    fc.categorical_column_with_vocabulary_list(
        'thal', ['normal', 'fixed', 'reversible']),
]

tfl.laysers.CategoricalCalibration 레이어는 카테고리 인덱스를 직접 소비 할 수 있으므로 범주 형 특성은 조밀 한 특성 열로 래핑 할 필요가 없습니다.

input_fn 생성

다른 추정기와 마찬가지로 input_fn을 사용하여 훈련 및 평가를 위해 모델에 데이터를 공급할 수 있습니다.

train_input_fn = tf.compat.v1.estimator.inputs.pandas_input_fn(
    x=train_x,
    y=train_y,
    shuffle=True,
    batch_size=BATCH_SIZE,
    num_epochs=NUM_EPOCHS,
    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)

model_fn 생성

사용자 지정 추정기를 만드는 방법에는 여러 가지가 있습니다. 여기서 우리는 파싱 된 입력 텐서에서 model_fn 모델을 호출하는 model_fn 을 생성 할 것입니다. 입력 특성을 구문 분석하려면 tf.feature_column.input_layer , tf.keras.layers.DenseFeatures 또는 tfl.estimators.transform_features 사용할 수 있습니다. 후자를 사용하면 조밀 한 특성 열로 범주 형 특성을 래핑 할 필요가 없으며 결과 텐서가 연결되지 않으므로 보정 레이어에서 특성을 더 쉽게 사용할 수 있습니다.

모델을 구성하기 위해 TFL 레이어 또는 다른 Keras 레이어를 혼합하고 일치시킬 수 있습니다. 여기에서 TFL 레이어에서 보정 된 격자 Keras 모델을 만들고 몇 가지 단조로운 제약 조건을 적용합니다. 그런 다음 Keras 모델을 사용하여 사용자 지정 추정기를 만듭니다.

def model_fn(features, labels, mode, config):
  """model_fn for the custom estimator."""
  del config
  input_tensors = tfl.estimators.transform_features(features, feature_columns)
  inputs = {
      key: tf.keras.layers.Input(shape=(1,), name=key) for key in input_tensors
  }

  lattice_sizes = [3, 2, 2, 2]
  lattice_monotonicities = ['increasing', 'none', 'increasing', 'increasing']
  lattice_input = tf.keras.layers.Concatenate(axis=1)([
      tfl.layers.PWLCalibration(
          input_keypoints=np.linspace(10, 100, num=8, dtype=np.float32),
          # The output range of the calibrator should be the input range of
          # the following lattice dimension.
          output_min=0.0,
          output_max=lattice_sizes[0] - 1.0,
          monotonicity='increasing',
      )(inputs['age']),
      tfl.layers.CategoricalCalibration(
          # Number of categories including any missing/default category.
          num_buckets=2,
          output_min=0.0,
          output_max=lattice_sizes[1] - 1.0,
      )(inputs['sex']),
      tfl.layers.PWLCalibration(
          input_keypoints=[0.0, 1.0, 2.0, 3.0],
          output_min=0.0,
          output_max=lattice_sizes[0] - 1.0,
          # You can specify TFL regularizers as tuple
          # ('regularizer name', l1, l2).
          kernel_regularizer=('hessian', 0.0, 1e-4),
          monotonicity='increasing',
      )(inputs['ca']),
      tfl.layers.CategoricalCalibration(
          num_buckets=3,
          output_min=0.0,
          output_max=lattice_sizes[1] - 1.0,
          # Categorical monotonicity can be partial order.
          # (i, j) indicates that we must have output(i) <= output(j).
          # Make sure to set the lattice monotonicity to 'increasing' for this
          # dimension.
          monotonicities=[(0, 1), (0, 2)],
      )(inputs['thal']),
  ])
  output = tfl.layers.Lattice(
      lattice_sizes=lattice_sizes, monotonicities=lattice_monotonicities)(
          lattice_input)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  model = tf.keras.Model(inputs=inputs, outputs=output)
  logits = model(input_tensors, training=training)

  if training:
    optimizer = optimizers.get_optimizer_instance_v2('Adagrad', LEARNING_RATE)
  else:
    optimizer = None

  head = binary_class_head.BinaryClassHead()
  return head.create_estimator_spec(
      features=features,
      mode=mode,
      labels=labels,
      optimizer=optimizer,
      logits=logits,
      trainable_variables=model.trainable_variables,
      update_ops=model.updates)

훈련 및 추정기

model_fn 을 사용하여 추정기를 만들고 훈련시킬 수 있습니다.

estimator = tf.estimator.Estimator(model_fn=model_fn)
estimator.train(input_fn=train_input_fn)
results = estimator.evaluate(input_fn=test_input_fn)
print('AUC: {}'.format(results['auc']))
AUC: 0.3659147620201111