 TensorFlow.org पर देखें |  Google Colab में चलाएं |  GitHub पर स्रोत देखें |  नोटबुक डाउनलोड करें |
अवलोकन
आप TFL परतों का उपयोग करके मनमाने ढंग से मोनोटोनिक मॉडल बनाने के लिए कस्टम अनुमानकों का उपयोग कर सकते हैं। यह मार्गदर्शिका ऐसे अनुमानक बनाने के लिए आवश्यक कदमों की रूपरेखा तैयार करती है।
सेट अप
TF जाली पैकेज स्थापित करना:
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 Creating बनाना
किसी भी अन्य अनुमानक के लिए, आप प्रशिक्षण और मूल्यांकन के लिए मॉडल को डेटा फीड करने के लिए 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 कि पार्स इनपुट tensors पर एक Keras मॉडल कहता है। इनपुट सुविधाओं को पार्स करने के लिए, आप उपयोग कर सकते tf.feature_column.input_layer , tf.keras.layers.DenseFeatures , या tfl.estimators.transform_features । यदि आप बाद वाले का उपयोग करते हैं, तो आपको घने फीचर कॉलम के साथ श्रेणीबद्ध सुविधाओं को लपेटने की आवश्यकता नहीं होगी, और परिणामी टेंसर को संयोजित नहीं किया जाएगा, जिससे अंशांकन परतों में सुविधाओं का उपयोग करना आसान हो जाता है।
एक मॉडल बनाने के लिए, आप 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