 TensorFlow.org पर देखें |  Google Colab में चलाएं |  GitHub पर स्रोत देखें |  नोटबुक डाउनलोड करें |
अवलोकन
इस ट्यूटोरियल दर्शाता है कि कैसे TensorFlow जाली (टीएफएल) पुस्तकालय ट्रेन मॉडल है कि जिम्मेदारी से व्यवहार करने के लिए इस्तेमाल किया जा सकता है, और कुछ मान्यताओं कि नैतिक या निष्पक्ष हैं उल्लंघन नहीं करते। विशेष रूप से, हम दिष्टता की कमी का उपयोग कर कुछ विशेषताओं का अनुचित दण्डनीय ठहराए जाने से बचने के लिए पर ध्यान दिया जाएगा। इस ट्यूटोरियल कागज से प्रयोगों के प्रदर्शनों में शामिल हैं बंधनकारक आचार तक दिष्टता आकार प्रतिबन्ध सेरेना वांग और माया गुप्ता द्वारा प्रकाशित AISTATS 2020 ।
हम सार्वजनिक डेटासेट पर TFL डिब्बाबंद अनुमानकों का उपयोग करेंगे, लेकिन ध्यान दें कि इस ट्यूटोरियल में सब कुछ TFL Keras परतों से निर्मित मॉडल के साथ भी किया जा सकता है।
आगे बढ़ने से पहले, सुनिश्चित करें कि आपके रनटाइम में सभी आवश्यक पैकेज स्थापित हैं (जैसा कि नीचे दिए गए कोड सेल में आयात किया गया है)।
सेट अप
TF जाली पैकेज स्थापित करना:
pip install tensorflow-lattice seaborn
आवश्यक पैकेज आयात करना:
import tensorflow as tf
import logging
import matplotlib.pyplot as plt
import numpy as np
import os
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split
import sys
import tensorflow_lattice as tfl
logging.disable(sys.maxsize)
इस ट्यूटोरियल में उपयोग किए गए डिफ़ॉल्ट मान:
# List of learning rate hyperparameters to try.
# For a longer list of reasonable hyperparameters, try [0.001, 0.01, 0.1].
LEARNING_RATES = [0.01]
# Default number of training epochs and batch sizes.
NUM_EPOCHS = 1000
BATCH_SIZE = 1000
# Directory containing dataset files.
DATA_DIR = 'https://raw.githubusercontent.com/serenalwang/shape_constraints_for_ethics/master'
केस स्टडी #1: लॉ स्कूल में प्रवेश
इस ट्यूटोरियल के पहले भाग में, हम लॉ स्कूल एडमिशन काउंसिल (LSAC) से लॉ स्कूल एडमिशन डेटासेट का उपयोग करके केस स्टडी पर विचार करेंगे। हम एक क्लासिफायरियर को यह अनुमान लगाने के लिए प्रशिक्षित करेंगे कि कोई छात्र दो विशेषताओं का उपयोग करके बार पास करेगा या नहीं: छात्र का LSAT स्कोर और स्नातक GPA।
मान लीजिए कि क्लासिफायर के स्कोर का उपयोग लॉ स्कूल में प्रवेश या छात्रवृत्ति के मार्गदर्शन के लिए किया गया था। योग्यता-आधारित सामाजिक मानदंडों के अनुसार, हम उम्मीद करेंगे कि उच्च जीपीए और उच्च एलएसएटी स्कोर वाले छात्रों को क्लासिफायर से उच्च अंक प्राप्त करना चाहिए। हालांकि, हम देखेंगे कि मॉडल के लिए इन सहज मानदंडों का उल्लंघन करना आसान है, और कभी-कभी लोगों को उच्च GPA या LSAT स्कोर के लिए दंडित करना आसान होता है।
यह अनुचित दण्डनीय ठहराए जाने की समस्या का समाधान करने के लिए, हम दिष्टता की कमी ताकि एक मॉडल कभी नहीं penalizes उच्च जीपीए या उच्चतर LSAT स्कोर, और सब बराबर लागू कर सकते हैं। इस ट्यूटोरियल में, हम दिखाएंगे कि टीएफएल का उपयोग करके उन एकरसता बाधाओं को कैसे लागू किया जाए।
लॉ स्कूल डेटा लोड करें
# Load data file.
law_file_name = 'lsac.csv'
law_file_path = os.path.join(DATA_DIR, law_file_name)
raw_law_df = pd.read_csv(law_file_path, delimiter=',')
प्रीप्रोसेस डेटासेट:
# Define label column name.
LAW_LABEL = 'pass_bar'
def preprocess_law_data(input_df):
# Drop rows with where the label or features of interest are missing.
output_df = input_df[~input_df[LAW_LABEL].isna() & ~input_df['ugpa'].isna() &
(input_df['ugpa'] > 0) & ~input_df['lsat'].isna()]
return output_df
law_df = preprocess_law_data(raw_law_df)
डेटा को ट्रेन/सत्यापन/परीक्षण सेट में विभाजित करें
def split_dataset(input_df, random_state=888):
"""Splits an input dataset into train, val, and test sets."""
train_df, test_val_df = train_test_split(
input_df, test_size=0.3, random_state=random_state)
val_df, test_df = train_test_split(
test_val_df, test_size=0.66, random_state=random_state)
return train_df, val_df, test_df
law_train_df, law_val_df, law_test_df = split_dataset(law_df)
डेटा वितरण की कल्पना करें
पहले हम डेटा के वितरण की कल्पना करेंगे। हम बार पास करने वाले सभी छात्रों और बार पास नहीं करने वाले सभी छात्रों के लिए जीपीए और एलएसएटी स्कोर तैयार करेंगे।
def plot_dataset_contour(input_df, title):
plt.rcParams['font.family'] = ['serif']
g = sns.jointplot(
x='ugpa',
y='lsat',
data=input_df,
kind='kde',
xlim=[1.4, 4],
ylim=[0, 50])
g.plot_joint(plt.scatter, c='b', s=10, linewidth=1, marker='+')
g.ax_joint.collections[0].set_alpha(0)
g.set_axis_labels('Undergraduate GPA', 'LSAT score', fontsize=14)
g.fig.suptitle(title, fontsize=14)
# Adust plot so that the title fits.
plt.subplots_adjust(top=0.9)
plt.show()
law_df_pos = law_df[law_df[LAW_LABEL] == 1]
plot_dataset_contour(
law_df_pos, title='Distribution of students that passed the bar')
law_df_neg = law_df[law_df[LAW_LABEL] == 0]
plot_dataset_contour(
law_df_neg, title='Distribution of students that failed the bar')
बार परीक्षा मार्ग की भविष्यवाणी करने के लिए कैलिब्रेटेड रैखिक मॉडल को प्रशिक्षित करें
इसके बाद, हम टीएफएल से एक कैलिब्रेटेड रेखीय मॉडल को प्रशिक्षित भविष्यवाणी करने के लिए किया जाए या नहीं एक छात्र बार पारित करेंगे होगा। दो इनपुट विशेषताएं एलएसएटी स्कोर और स्नातक जीपीए होंगी, और प्रशिक्षण लेबल यह होगा कि छात्र ने बार पास किया है या नहीं।
हम पहले बिना किसी बाधा के कैलिब्रेटेड लीनियर मॉडल को प्रशिक्षित करेंगे। फिर, हम एकरूपता बाधाओं के साथ एक कैलिब्रेटेड रैखिक मॉडल को प्रशिक्षित करेंगे और मॉडल आउटपुट और सटीकता में अंतर का निरीक्षण करेंगे।
TFL कैलिब्रेटेड रैखिक अनुमानक के प्रशिक्षण के लिए सहायक कार्य
इन कार्यों का उपयोग इस लॉ स्कूल केस स्टडी के साथ-साथ नीचे क्रेडिट डिफॉल्ट केस स्टडी के लिए किया जाएगा।
def train_tfl_estimator(train_df, monotonicity, learning_rate, num_epochs,
batch_size, get_input_fn,
get_feature_columns_and_configs):
"""Trains a TFL calibrated linear estimator.
Args:
train_df: pandas dataframe containing training data.
monotonicity: if 0, then no monotonicity constraints. If 1, then all
features are constrained to be monotonically increasing.
learning_rate: learning rate of Adam optimizer for gradient descent.
num_epochs: number of training epochs.
batch_size: batch size for each epoch. None means the batch size is the full
dataset size.
get_input_fn: function that returns the input_fn for a TF estimator.
get_feature_columns_and_configs: function that returns TFL feature columns
and configs.
Returns:
estimator: a trained TFL calibrated linear estimator.
"""
feature_columns, feature_configs = get_feature_columns_and_configs(
monotonicity)
model_config = tfl.configs.CalibratedLinearConfig(
feature_configs=feature_configs, use_bias=False)
estimator = tfl.estimators.CannedClassifier(
feature_columns=feature_columns,
model_config=model_config,
feature_analysis_input_fn=get_input_fn(input_df=train_df, num_epochs=1),
optimizer=tf.keras.optimizers.Adam(learning_rate))
estimator.train(
input_fn=get_input_fn(
input_df=train_df, num_epochs=num_epochs, batch_size=batch_size))
return estimator
def optimize_learning_rates(
train_df,
val_df,
test_df,
monotonicity,
learning_rates,
num_epochs,
batch_size,
get_input_fn,
get_feature_columns_and_configs,
):
"""Optimizes learning rates for TFL estimators.
Args:
train_df: pandas dataframe containing training data.
val_df: pandas dataframe containing validation data.
test_df: pandas dataframe containing test data.
monotonicity: if 0, then no monotonicity constraints. If 1, then all
features are constrained to be monotonically increasing.
learning_rates: list of learning rates to try.
num_epochs: number of training epochs.
batch_size: batch size for each epoch. None means the batch size is the full
dataset size.
get_input_fn: function that returns the input_fn for a TF estimator.
get_feature_columns_and_configs: function that returns TFL feature columns
and configs.
Returns:
A single TFL estimator that achieved the best validation accuracy.
"""
estimators = []
train_accuracies = []
val_accuracies = []
test_accuracies = []
for lr in learning_rates:
estimator = train_tfl_estimator(
train_df=train_df,
monotonicity=monotonicity,
learning_rate=lr,
num_epochs=num_epochs,
batch_size=batch_size,
get_input_fn=get_input_fn,
get_feature_columns_and_configs=get_feature_columns_and_configs)
estimators.append(estimator)
train_acc = estimator.evaluate(
input_fn=get_input_fn(train_df, num_epochs=1))['accuracy']
val_acc = estimator.evaluate(
input_fn=get_input_fn(val_df, num_epochs=1))['accuracy']
test_acc = estimator.evaluate(
input_fn=get_input_fn(test_df, num_epochs=1))['accuracy']
print('accuracies for learning rate %f: train: %f, val: %f, test: %f' %
(lr, train_acc, val_acc, test_acc))
train_accuracies.append(train_acc)
val_accuracies.append(val_acc)
test_accuracies.append(test_acc)
max_index = val_accuracies.index(max(val_accuracies))
return estimators[max_index]
लॉ स्कूल डेटासेट सुविधाओं को कॉन्फ़िगर करने के लिए सहायक कार्य
ये सहायक कार्य लॉ स्कूल केस स्टडी के लिए विशिष्ट हैं।
def get_input_fn_law(input_df, num_epochs, batch_size=None):
"""Gets TF input_fn for law school models."""
return tf.compat.v1.estimator.inputs.pandas_input_fn(
x=input_df[['ugpa', 'lsat']],
y=input_df['pass_bar'],
num_epochs=num_epochs,
batch_size=batch_size or len(input_df),
shuffle=False)
def get_feature_columns_and_configs_law(monotonicity):
"""Gets TFL feature configs for law school models."""
feature_columns = [
tf.feature_column.numeric_column('ugpa'),
tf.feature_column.numeric_column('lsat'),
]
feature_configs = [
tfl.configs.FeatureConfig(
name='ugpa',
lattice_size=2,
pwl_calibration_num_keypoints=20,
monotonicity=monotonicity,
pwl_calibration_always_monotonic=False),
tfl.configs.FeatureConfig(
name='lsat',
lattice_size=2,
pwl_calibration_num_keypoints=20,
monotonicity=monotonicity,
pwl_calibration_always_monotonic=False),
]
return feature_columns, feature_configs
प्रशिक्षित मॉडल आउटपुट के विज़ुअलाइज़ेशन के लिए सहायक कार्य
def get_predicted_probabilities(estimator, input_df, get_input_fn):
predictions = estimator.predict(
input_fn=get_input_fn(input_df=input_df, num_epochs=1))
return [prediction['probabilities'][1] for prediction in predictions]
def plot_model_contour(estimator, input_df, num_keypoints=20):
x = np.linspace(min(input_df['ugpa']), max(input_df['ugpa']), num_keypoints)
y = np.linspace(min(input_df['lsat']), max(input_df['lsat']), num_keypoints)
x_grid, y_grid = np.meshgrid(x, y)
positions = np.vstack([x_grid.ravel(), y_grid.ravel()])
plot_df = pd.DataFrame(positions.T, columns=['ugpa', 'lsat'])
plot_df[LAW_LABEL] = np.ones(len(plot_df))
predictions = get_predicted_probabilities(
estimator=estimator, input_df=plot_df, get_input_fn=get_input_fn_law)
grid_predictions = np.reshape(predictions, x_grid.shape)
plt.rcParams['font.family'] = ['serif']
plt.contour(
x_grid,
y_grid,
grid_predictions,
colors=('k',),
levels=np.linspace(0, 1, 11))
plt.contourf(
x_grid,
y_grid,
grid_predictions,
cmap=plt.cm.bone,
levels=np.linspace(0, 1, 11)) # levels=np.linspace(0,1,8));
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
cbar = plt.colorbar()
cbar.ax.set_ylabel('Model score', fontsize=20)
cbar.ax.tick_params(labelsize=20)
plt.xlabel('Undergraduate GPA', fontsize=20)
plt.ylabel('LSAT score', fontsize=20)
ट्रेन अप्रतिबंधित (गैर-मोनोटोनिक) कैलिब्रेटेड रैखिक मॉडल
nomon_linear_estimator = optimize_learning_rates(
train_df=law_train_df,
val_df=law_val_df,
test_df=law_test_df,
monotonicity=0,
learning_rates=LEARNING_RATES,
batch_size=BATCH_SIZE,
num_epochs=NUM_EPOCHS,
get_input_fn=get_input_fn_law,
get_feature_columns_and_configs=get_feature_columns_and_configs_law)
2021-09-30 20:56:50.475180: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected accuracies for learning rate 0.010000: train: 0.949061, val: 0.945876, test: 0.951781
plot_model_contour(nomon_linear_estimator, input_df=law_df)
ट्रेन मोनोटोनिक कैलिब्रेटेड लीनियर मॉडल
mon_linear_estimator = optimize_learning_rates(
train_df=law_train_df,
val_df=law_val_df,
test_df=law_test_df,
monotonicity=1,
learning_rates=LEARNING_RATES,
batch_size=BATCH_SIZE,
num_epochs=NUM_EPOCHS,
get_input_fn=get_input_fn_law,
get_feature_columns_and_configs=get_feature_columns_and_configs_law)
accuracies for learning rate 0.010000: train: 0.949249, val: 0.945447, test: 0.951781
plot_model_contour(mon_linear_estimator, input_df=law_df)
अन्य अप्रतिबंधित मॉडलों को प्रशिक्षित करें
हमने दिखाया कि टीएफएल कैलिब्रेटेड लीनियर मॉडल को एलएसएटी स्कोर और जीपीए दोनों में मोनोटोनिक होने के लिए प्रशिक्षित किया जा सकता है, बिना सटीकता में बहुत बड़ा बलिदान किए।
लेकिन, कैलिब्रेटेड लीनियर मॉडल अन्य प्रकार के मॉडलों की तुलना कैसे करता है, जैसे डीप न्यूरल नेटवर्क (DNN) या ग्रेडिएंट बूस्टेड ट्री (GBTs)? क्या डीएनएन और जीबीटी के यथोचित रूप से उचित परिणाम प्रतीत होते हैं? इस प्रश्न का समाधान करने के लिए, हम अगली बार एक अप्रतिबंधित DNN और GBT को प्रशिक्षित करेंगे। वास्तव में, हम देखेंगे कि डीएनएन और जीबीटी दोनों आसानी से एलएसएटी स्कोर और स्नातक जीपीए में एकरसता का उल्लंघन करते हैं।
एक अनियंत्रित डीप न्यूरल नेटवर्क (डीएनएन) मॉडल को प्रशिक्षित करें
उच्च सत्यापन सटीकता प्राप्त करने के लिए वास्तुकला को पहले अनुकूलित किया गया था।
feature_names = ['ugpa', 'lsat']
dnn_estimator = tf.estimator.DNNClassifier(
feature_columns=[
tf.feature_column.numeric_column(feature) for feature in feature_names
],
hidden_units=[100, 100],
optimizer=tf.keras.optimizers.Adam(learning_rate=0.008),
activation_fn=tf.nn.relu)
dnn_estimator.train(
input_fn=get_input_fn_law(
law_train_df, batch_size=BATCH_SIZE, num_epochs=NUM_EPOCHS))
dnn_train_acc = dnn_estimator.evaluate(
input_fn=get_input_fn_law(law_train_df, num_epochs=1))['accuracy']
dnn_val_acc = dnn_estimator.evaluate(
input_fn=get_input_fn_law(law_val_df, num_epochs=1))['accuracy']
dnn_test_acc = dnn_estimator.evaluate(
input_fn=get_input_fn_law(law_test_df, num_epochs=1))['accuracy']
print('accuracies for DNN: train: %f, val: %f, test: %f' %
(dnn_train_acc, dnn_val_acc, dnn_test_acc))
accuracies for DNN: train: 0.948874, val: 0.946735, test: 0.951559
plot_model_contour(dnn_estimator, input_df=law_df)
एक अनियंत्रित ग्रैडिएंट बूस्टेड ट्रीज़ (GBT) मॉडल को प्रशिक्षित करें
उच्च सत्यापन सटीकता प्राप्त करने के लिए वृक्ष संरचना को पहले अनुकूलित किया गया था।
tree_estimator = tf.estimator.BoostedTreesClassifier(
feature_columns=[
tf.feature_column.numeric_column(feature) for feature in feature_names
],
n_batches_per_layer=2,
n_trees=20,
max_depth=4)
tree_estimator.train(
input_fn=get_input_fn_law(
law_train_df, num_epochs=NUM_EPOCHS, batch_size=BATCH_SIZE))
tree_train_acc = tree_estimator.evaluate(
input_fn=get_input_fn_law(law_train_df, num_epochs=1))['accuracy']
tree_val_acc = tree_estimator.evaluate(
input_fn=get_input_fn_law(law_val_df, num_epochs=1))['accuracy']
tree_test_acc = tree_estimator.evaluate(
input_fn=get_input_fn_law(law_test_df, num_epochs=1))['accuracy']
print('accuracies for GBT: train: %f, val: %f, test: %f' %
(tree_train_acc, tree_val_acc, tree_test_acc))
accuracies for GBT: train: 0.949249, val: 0.945017, test: 0.950896
plot_model_contour(tree_estimator, input_df=law_df)
केस स्टडी #2: क्रेडिट डिफॉल्ट
दूसरा केस स्टडी जिस पर हम इस ट्यूटोरियल में विचार करेंगे, वह है किसी व्यक्ति की क्रेडिट डिफॉल्ट संभावना की भविष्यवाणी करना। हम यूसीआई रिपोजिटरी से क्रेडिट कार्ड क्लाइंट के डिफ़ॉल्ट डेटासेट का उपयोग करेंगे। यह डेटा 30,000 ताइवानी क्रेडिट कार्ड उपयोगकर्ताओं से एकत्र किया गया था और इसमें एक बाइनरी लेबल होता है कि क्या उपयोगकर्ता ने समय विंडो में भुगतान पर चूक की है या नहीं। सुविधाओं में वैवाहिक स्थिति, लिंग, शिक्षा, और अप्रैल-सितंबर 2005 के प्रत्येक महीने के लिए उपयोगकर्ता अपने मौजूदा बिलों के भुगतान पर कितने समय से पीछे है।
जैसा कि हम पहले मामले का अध्ययन के साथ किया था, हम फिर दिष्टता की कमी का उपयोग कर अनुचित दण्डनीय ठहराए जाने से बचने के लिए उदाहरण देकर स्पष्ट करना: अगर मॉडल एक उपयोगकर्ता के क्रेडिट स्कोर का निर्धारण किया जा रहे थे, यह कई करने के लिए अनुचित महसूस कर सकता था अगर वे अपने बिलों का भुगतान जल्दी करने के लिए दंडित किया गया है, अन्य सभी बराबर। इस प्रकार, हम एक एकरसता बाधा लागू करते हैं जो मॉडल को शुरुआती भुगतानों को दंडित करने से रोकता है।
क्रेडिट डिफ़ॉल्ट डेटा लोड करें
# Load data file.
credit_file_name = 'credit_default.csv'
credit_file_path = os.path.join(DATA_DIR, credit_file_name)
credit_df = pd.read_csv(credit_file_path, delimiter=',')
# Define label column name.
CREDIT_LABEL = 'default'
डेटा को ट्रेन/सत्यापन/परीक्षण सेट में विभाजित करें
credit_train_df, credit_val_df, credit_test_df = split_dataset(credit_df)
डेटा वितरण की कल्पना करें
पहले हम डेटा के वितरण की कल्पना करेंगे। हम विभिन्न वैवाहिक स्थितियों और पुनर्भुगतान स्थितियों वाले लोगों के लिए मनाई गई डिफ़ॉल्ट दर की औसत और मानक त्रुटि की साजिश करेंगे। चुकौती की स्थिति यह दर्शाती है कि कोई व्यक्ति अपने ऋण का भुगतान करने में कितने महीने पीछे है (अप्रैल 2005 तक)।
def get_agg_data(df, x_col, y_col, bins=11):
xbins = pd.cut(df[x_col], bins=bins)
data = df[[x_col, y_col]].groupby(xbins).agg(['mean', 'sem'])
return data
def plot_2d_means_credit(input_df, x_col, y_col, x_label, y_label):
plt.rcParams['font.family'] = ['serif']
_, ax = plt.subplots(nrows=1, ncols=1)
plt.setp(ax.spines.values(), color='black', linewidth=1)
ax.tick_params(
direction='in', length=6, width=1, top=False, right=False, labelsize=18)
df_single = get_agg_data(input_df[input_df['MARRIAGE'] == 1], x_col, y_col)
df_married = get_agg_data(input_df[input_df['MARRIAGE'] == 2], x_col, y_col)
ax.errorbar(
df_single[(x_col, 'mean')],
df_single[(y_col, 'mean')],
xerr=df_single[(x_col, 'sem')],
yerr=df_single[(y_col, 'sem')],
color='orange',
marker='s',
capsize=3,
capthick=1,
label='Single',
markersize=10,
linestyle='')
ax.errorbar(
df_married[(x_col, 'mean')],
df_married[(y_col, 'mean')],
xerr=df_married[(x_col, 'sem')],
yerr=df_married[(y_col, 'sem')],
color='b',
marker='^',
capsize=3,
capthick=1,
label='Married',
markersize=10,
linestyle='')
leg = ax.legend(loc='upper left', fontsize=18, frameon=True, numpoints=1)
ax.set_xlabel(x_label, fontsize=18)
ax.set_ylabel(y_label, fontsize=18)
ax.set_ylim(0, 1.1)
ax.set_xlim(-2, 8.5)
ax.patch.set_facecolor('white')
leg.get_frame().set_edgecolor('black')
leg.get_frame().set_facecolor('white')
leg.get_frame().set_linewidth(1)
plt.show()
plot_2d_means_credit(credit_train_df, 'PAY_0', 'default',
'Repayment Status (April)', 'Observed default rate')
क्रेडिट डिफॉल्ट दर का अनुमान लगाने के लिए कैलिब्रेटेड लीनियर मॉडल को प्रशिक्षित करें
इसके बाद, हम टीएफएल से एक कैलिब्रेटेड रेखीय मॉडल को प्रशिक्षित भविष्यवाणी करने के लिए किया जाए या नहीं एक व्यक्ति एक ऋण पर डिफ़ॉल्ट जाएगा। दो इनपुट विशेषताएं व्यक्ति की वैवाहिक स्थिति और अप्रैल में अपने ऋणों का भुगतान करने में व्यक्ति कितने महीने पीछे है (चुकौती स्थिति)। प्रशिक्षण लेबल यह होगा कि व्यक्ति ने ऋण पर चूक की है या नहीं।
हम पहले बिना किसी बाधा के कैलिब्रेटेड लीनियर मॉडल को प्रशिक्षित करेंगे। फिर, हम एकरूपता बाधाओं के साथ एक कैलिब्रेटेड रैखिक मॉडल को प्रशिक्षित करेंगे और मॉडल आउटपुट और सटीकता में अंतर का निरीक्षण करेंगे।
क्रेडिट डिफ़ॉल्ट डेटासेट सुविधाओं को कॉन्फ़िगर करने के लिए सहायक कार्य
ये सहायक कार्य क्रेडिट डिफॉल्ट केस स्टडी के लिए विशिष्ट हैं।
def get_input_fn_credit(input_df, num_epochs, batch_size=None):
"""Gets TF input_fn for credit default models."""
return tf.compat.v1.estimator.inputs.pandas_input_fn(
x=input_df[['MARRIAGE', 'PAY_0']],
y=input_df['default'],
num_epochs=num_epochs,
batch_size=batch_size or len(input_df),
shuffle=False)
def get_feature_columns_and_configs_credit(monotonicity):
"""Gets TFL feature configs for credit default models."""
feature_columns = [
tf.feature_column.numeric_column('MARRIAGE'),
tf.feature_column.numeric_column('PAY_0'),
]
feature_configs = [
tfl.configs.FeatureConfig(
name='MARRIAGE',
lattice_size=2,
pwl_calibration_num_keypoints=3,
monotonicity=monotonicity,
pwl_calibration_always_monotonic=False),
tfl.configs.FeatureConfig(
name='PAY_0',
lattice_size=2,
pwl_calibration_num_keypoints=10,
monotonicity=monotonicity,
pwl_calibration_always_monotonic=False),
]
return feature_columns, feature_configs
प्रशिक्षित मॉडल आउटपुट के विज़ुअलाइज़ेशन के लिए सहायक कार्य
def plot_predictions_credit(input_df,
estimator,
x_col,
x_label='Repayment Status (April)',
y_label='Predicted default probability'):
predictions = get_predicted_probabilities(
estimator=estimator, input_df=input_df, get_input_fn=get_input_fn_credit)
new_df = input_df.copy()
new_df.loc[:, 'predictions'] = predictions
plot_2d_means_credit(new_df, x_col, 'predictions', x_label, y_label)
ट्रेन अप्रतिबंधित (गैर-मोनोटोनिक) कैलिब्रेटेड रैखिक मॉडल
nomon_linear_estimator = optimize_learning_rates(
train_df=credit_train_df,
val_df=credit_val_df,
test_df=credit_test_df,
monotonicity=0,
learning_rates=LEARNING_RATES,
batch_size=BATCH_SIZE,
num_epochs=NUM_EPOCHS,
get_input_fn=get_input_fn_credit,
get_feature_columns_and_configs=get_feature_columns_and_configs_credit)
accuracies for learning rate 0.010000: train: 0.818762, val: 0.830065, test: 0.817172
plot_predictions_credit(credit_train_df, nomon_linear_estimator, 'PAY_0')
ट्रेन मोनोटोनिक कैलिब्रेटेड लीनियर मॉडल
mon_linear_estimator = optimize_learning_rates(
train_df=credit_train_df,
val_df=credit_val_df,
test_df=credit_test_df,
monotonicity=1,
learning_rates=LEARNING_RATES,
batch_size=BATCH_SIZE,
num_epochs=NUM_EPOCHS,
get_input_fn=get_input_fn_credit,
get_feature_columns_and_configs=get_feature_columns_and_configs_credit)
accuracies for learning rate 0.010000: train: 0.818762, val: 0.830065, test: 0.817172
plot_predictions_credit(credit_train_df, mon_linear_estimator, 'PAY_0')
