TF Lattice กำหนดเองประมาณการ

ดูบน TensorFlow.org

ทำงานใน Google Colab

ดูแหล่งที่มาบน GitHub

ดาวน์โหลดโน๊ตบุ๊ค

ภาพรวม

คุณสามารถใช้ตัวประมาณการแบบกำหนดเองเพื่อสร้างแบบจำลองแบบโมโนโทนิกตามอำเภอใจได้โดยใช้เลเยอร์ TFL คู่มือนี้สรุปขั้นตอนที่จำเป็นในการสร้างตัวประมาณดังกล่าว

ติดตั้ง

การติดตั้งแพ็คเกจ TF Lattice:

pip install 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 (หัวใจ):

csv_file = tf.keras.utils.get_file(
    'heart.csv', 'http://storage.googleapis.com/download.tensorflow.org/data/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 ที่เรียกรุ่น Keras ในการป้อนข้อมูลแจงเทนเซอร์ ที่จะแยกคุณลักษณะการป้อนข้อมูลที่คุณสามารถใช้ tf.feature_column.input_layer , tf.keras.layers.DenseFeatures หรือ tfl.estimators.transform_features หากคุณใช้ส่วนหลัง คุณไม่จำเป็นต้องห่อคุณลักษณะตามหมวดหมู่ด้วยคอลัมน์คุณลักษณะที่หนาแน่น และเมตริกซ์ที่เป็นผลลัพธ์จะไม่ถูกต่อกัน ซึ่งทำให้ใช้งานคุณลักษณะในเลเยอร์การปรับเทียบได้ง่ายขึ้น

ในการสร้างแบบจำลอง คุณสามารถผสมและจับคู่เลเยอร์ TFL หรือเลเยอร์ Keras อื่นๆ ได้ ที่นี่ เราสร้างแบบจำลอง Keras แลตทิซที่ปรับเทียบแล้วจากเลเยอร์ TFL และกำหนดข้อจำกัดความซ้ำซากจำเจหลายข้อ จากนั้นเราใช้โมเดล 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']))

2021-09-30 20:51:11.094402: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
AUC: 0.5946115255355835