def create_regressor(config, hyper_params):
""" Create a DNNLinearCombinedRegressor based on the hyper_params object
Args:
config: used for model directory
hyper_params: dictionary of hyper-parameters
Returns:
DNNLinearCombinedRegressor
"""
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, wide_columns = featurizer.get_deep_and_wide_columns(
feature_columns)
linear_optimizer = tf.train.FtrlOptimizer(
learning_rate=hyper_params.learning_rate)
dnn_optimizer = tf.train.AdagradOptimizer(
learning_rate=hyper_params.learning_rate)
regressor = tf.estimator.DNNLinearCombinedRegressor(
linear_optimizer=linear_optimizer,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_optimizer=dnn_optimizer,
weight_column=metadata.WEIGHT_COLUMN_NAME,
dnn_hidden_units=construct_hidden_units(hyper_params),
dnn_activation_fn=tf.nn.relu,
dnn_dropout=hyper_params.dropout_prob,
config=config,
)
print("creating a regression model: {}".format(regressor))
return regressor
def generate_regression_model_fn(features, labels, mode, params):
"""Model function for Estimator with 1 hidden layer"""
hidden_units = list(map(int, params.hidden_units.split(',')))
hidden_layer_size = hidden_units[0]
output_layer_size = 1
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, _ = featurizer.get_deep_and_wide_columns(
feature_columns, embedding_size=parameters.HYPER_PARAMS.embedding_size)
# Create the input layers from the features
input_layer = tf.feature_column.input_layer(features, deep_columns)
# Connect the input layer to the hidden layer
hidden_layer = tf.layers.dense(input_layer,
hidden_layer_size,
activation=tf.nn.relu)
# Connect the output layer (logits) to the hidden layer (no activation fn)
logits = tf.layers.dense(hidden_layer, output_layer_size)
# Provide an estimator spec for `ModeKeys.PREDICT`.
if mode == tf.estimator.ModeKeys.PREDICT:
# Reshape output layer to 1-dim Tensor to return predictions
output = tf.reshape(logits, [-1])
predictions = {'scores': output}
export_outputs = {
'predictions': tf.estimator.export.PredictOutput(predictions)
}
return tf.estimator.EstimatorSpec(mode=mode,
predictions=predictions,
export_outputs=export_outputs)
# Calculate loss using mean squared error
loss = tf.losses.mean_squared_error(labels, logits)
# Create Optimiser
optimizer = tf.train.AdamOptimizer(learning_rate=params.learning_rate)
# Create training operation
train_op = optimizer.minimize(loss=loss,
global_step=tf.train.get_global_step())
# Calculate root mean squared error as additional eval metric
eval_metric_ops = {
"rmse": tf.metrics.root_mean_squared_error(labels, logits)
}
# Provide an estimator spec for `ModeKeys.EVAL` and `ModeKeys.TRAIN` modes.
estimator_spec = tf.estimator.EstimatorSpec(
mode=mode,
loss=loss,
train_op=train_op,
eval_metric_ops=eval_metric_ops)
return estimator_spec
def json_serving_input_fn():
feature_columns = featurizer.create_feature_columns()
input_feature_columns = [
feature_columns[feature_name]
for feature_name in metadata.FEATURE_NAMES
]
inputs = {}
for column in input_feature_columns:
inputs[column.name] = tf.placeholder(shape=[None], dtype=column.dtype)
features = {
key: tf.expand_dims(tensor, -1)
for key, tensor in inputs.items()
}
if metadata.TASK_TYPE == "custom":
return tf.estimator.export.ServingInputReceiver(
features=preprocess.process_features(features),
receiver_tensors=inputs)
return tf.contrib.learn.InputFnOps(preprocess.process_features(features),
None, inputs)
def create_classifier(config):
""" Create a DNNLinearCombinedClassifier based on the HYPER_PARAMS in the parameters module
Args:
config - used for model directory
Returns:
DNNLinearCombinedClassifier
"""
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, wide_columns = featurizer.get_deep_and_wide_columns(
feature_columns, embedding_size=parameters.HYPER_PARAMS.embedding_size)
linear_optimizer = tf.train.FtrlOptimizer(
learning_rate=parameters.HYPER_PARAMS.learning_rate)
dnn_optimizer = tf.train.AdagradOptimizer(
learning_rate=parameters.HYPER_PARAMS.learning_rate)
classifier = tf.contrib.learn.DNNLinearCombinedClassifier(
n_classes=len(metadata.TARGET_LABELS),
linear_optimizer=linear_optimizer,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_optimizer=dnn_optimizer,
dnn_hidden_units=construct_hidden_units(),
dnn_activation_fn=tf.nn.relu,
dnn_dropout=parameters.HYPER_PARAMS.dropout_prob,
fix_global_step_increment_bug=True,
config=config,
)
return classifier
def example_serving_input_fn():
feature_columns = featurizer.create_feature_columns()
input_feature_columns = [
feature_columns[feature_name]
for feature_name in metadata.FEATURE_NAMES
]
example_bytestring = tf.placeholder(
shape=[None],
dtype=tf.string,
)
feature_scalars = tf.parse_example(
example_bytestring,
tf.feature_column.make_parse_example_spec(input_feature_columns))
features = {
key: tf.expand_dims(tensor, -1)
for key, tensor in feature_scalars.iteritems()
}
if metadata.TASK_TYPE == "custom":
return tf.estimator.export.ServingInputReceiver(
features=preprocess.process_features(features),
receiver_tensors={'example_proto': example_bytestring})
return tf.contrib.learn.InputFnOps(
preprocess.process_features(features),
None, # labels
{'example_proto': example_bytestring})
def _inference(features):
""" Create the model structure and compute the logits """
hidden_units = construct_hidden_units()
output_layer_size = 1 # because it is a regression problem
feature_columns = list(featurizer.create_feature_columns().values())
# create the deep columns: dense + indicators
deep_columns, _ = featurizer.get_deep_and_wide_columns(
feature_columns
)
print(deep_columns)
# Create input layer based on features
input_layer = tf.feature_column.input_layer(features=features,
feature_columns=deep_columns)
# Create hidden layers (cnn, rnn, dropouts, etc.) given the input layer
hidden_layers = tf.contrib.layers.stack(inputs=input_layer,
layer=tf.contrib.layers.fully_connected,
stack_args=hidden_units,
activation_fn=tf.nn.relu,
weights_initializer=tf.contrib.layers.xavier_initializer())
# Create output (logits) layer given the hidden layers (usually without applying any activation functions)
logits = tf.layers.dense(inputs=hidden_layers,
units=output_layer_size,
activation=None)
return logits
def tfma_example_serving_input_fn():
"""Build everything needed to run tf-model-analysis when using examples as
input for the model.
Returns:
EvalInputReceiver function, which contains:
- Tensorflow graph which parses raw untranformed features, applies the
tf-transform preprocessing operators.
- Set of raw, untransformed features.
- Label against which predictions will be compared.
"""
feature_columns = featurizer.create_feature_columns()
input_feature_columns = [
feature_columns[feature_name]
for feature_name in metadata.INPUT_FEATURE_NAMES
]
example_bytestring = tf.placeholder(
shape=[None],
dtype=tf.string,
)
feature_scalars = tf.parse_example(
example_bytestring,
tf.feature_column.make_parse_example_spec(input_feature_columns))
features = {
key: tf.expand_dims(tensor, -1)
for key, tensor in feature_scalars.iteritems()
}
return tfma_export.EvalInputReceiver(
features=process_features(features),
# The key name MUST be 'examples'. See https://goo.gl/2SV7Ug
receiver_tensors={'examples': example_bytestring},
labels=features[metadata.TARGET_NAME])
def create_regressor(config):
""" Create a DNNLinearCombinedRegressor based on the HYPER_PARAMS in the task module
Args:
config - used for model directory
Returns:
DNNLinearCombinedRegressor
"""
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, wide_columns = featurizer.get_deep_and_wide_columns(
feature_columns)
linear_optimizer = tf.train.FtrlOptimizer(
learning_rate=task.HYPER_PARAMS.learning_rate)
dnn_optimizer = tf.train.AdagradOptimizer(
learning_rate=task.HYPER_PARAMS.learning_rate)
regressor = tf.estimator.DNNLinearCombinedRegressor(
linear_optimizer=linear_optimizer,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_optimizer=dnn_optimizer,
weight_column=metadata.WEIGHT_COLUMN_NAME,
dnn_hidden_units=construct_hidden_units(),
dnn_activation_fn=tf.nn.relu,
dnn_dropout=task.HYPER_PARAMS.dropout_prob,
config=config,
)
print("creating a regression model: {}".format(regressor))
return regressor
def premade_model_fn(optimizer='Adagrad', config=None):
feature_columns = list(featurizer.create_feature_columns().values())
estimator = tf.estimator.DNNClassifier(hidden_units=[10, 30],
feature_columns=feature_columns,
n_classes=len(
metadata.TARGET_LABELS),
optimizer=optimizer,
config=config)
return estimator
def create_classifier(config):
""" Create a DNNLinearCombinedClassifier based on the HYPER_PARAMS in task.py
Args:
config - used for model directory
Returns:
DNNLinearCombinedClassifier
"""
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, wide_columns = featurizer.get_deep_and_wide_columns(
feature_columns
)
# Change the optimisers for the wide and deep parts of the model if you wish
linear_optimizer = tf.train.FtrlOptimizer(learning_rate=task.HYPER_PARAMS.learning_rate)
dnn_optimizer = tf.train.AdagradOptimizer(learning_rate=task.HYPER_PARAMS.learning_rate)
estimator = tf.estimator.DNNLinearCombinedClassifier(
n_classes=len(metadata.TARGET_LABELS),
label_vocabulary=metadata.TARGET_LABELS,
linear_optimizer=linear_optimizer,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_optimizer=dnn_optimizer,
weight_column=metadata.WEIGHT_COLUMN_NAME,
dnn_hidden_units=construct_hidden_units(),
dnn_activation_fn=tf.nn.relu,
dnn_dropout=task.HYPER_PARAMS.dropout_prob,
config=config,
)
estimator = tf.contrib.estimator.add_metrics(estimator, metric_fn)
print("creating a classification model: {}".format(estimator))
return estimator
def json_serving_input_fn():
feature_columns = featurizer.create_feature_columns()
input_feature_columns = [
feature_columns[feature_name]
for feature_name in metadata.FEATURE_NAMES
]
inputs = {}
for column in input_feature_columns:
inputs[column.name] = tf.placeholder(shape=[None], dtype=column.dtype)
features = {
key: tf.expand_dims(tensor, -1)
for key, tensor in inputs.items()
}
return tf.contrib.learn.InputFnOps(preprocess.process_features(features),
None, inputs)
def json_serving_input_fn():
feature_columns = featurizer.create_feature_columns()
input_feature_columns = [feature_columns[feature_name] for feature_name in metadata.INPUT_FEATURE_NAMES]
inputs = {}
for column in input_feature_columns:
if column.name in metadata.INPUT_CATEGORICAL_FEATURE_NAMES_WITH_IDENTITY:
inputs[column.name] = tf.placeholder(shape=[None], dtype=tf.int32)
else:
inputs[column.name] = tf.placeholder(shape=[None], dtype=column.dtype)
features = {
key: tf.expand_dims(tensor, -1)
for key, tensor in inputs.items()
}
return tf.estimator.export.ServingInputReceiver(
features=input.process_features(features),
receiver_tensors=inputs
)
def example_serving_input_fn():
feature_columns = featurizer.create_feature_columns()
input_feature_columns = [feature_columns[feature_name] for feature_name in metadata.INPUT_FEATURE_NAMES]
example_bytestring = tf.placeholder(
shape=[None],
dtype=tf.string,
)
feature_scalars = tf.parse_example(
example_bytestring,
tf.feature_column.make_parse_example_spec(input_feature_columns)
)
features = {
key: tf.expand_dims(tensor, -1)
for key, tensor in feature_scalars.iteritems()
}
return tf.estimator.export.ServingInputReceiver(
features=input.process_features(features),
receiver_tensors={'example_proto': example_bytestring}
)
def create_classifier(config, hyper_params):
""" Create a DNNLinearCombinedClassifier based on the hyper_params
Args:
config: used for model directory
hyper_params: dictionary of hyper-parameters
Returns:
DNNLinearCombinedClassifier
"""
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, wide_columns = featurizer.get_deep_and_wide_columns(
feature_columns)
linear_optimizer = tf.train.FtrlOptimizer(
learning_rate=hyper_params.learning_rate)
dnn_optimizer = tf.train.AdagradOptimizer(
learning_rate=hyper_params.learning_rate)
classifier = tf.estimator.DNNLinearCombinedClassifier(
n_classes=len(metadata.TARGET_LABELS),
label_vocabulary=metadata.TARGET_LABELS,
linear_optimizer=linear_optimizer,
linear_feature_columns=wide_columns,
dnn_feature_columns=deep_columns,
dnn_optimizer=dnn_optimizer,
weight_column=metadata.WEIGHT_COLUMN_NAME,
dnn_hidden_units=construct_hidden_units(hyper_params),
dnn_activation_fn=tf.nn.relu,
dnn_dropout=hyper_params.dropout_prob,
config=config,
)
print("creating a classification model: {}".format(classifier))
return classifier
def generate_classification_model_fn(features, labels, mode, params):
"""Model function for Estimator with 1 hidden layer"""
hidden_units = list(map(int, params.hidden_units.split(',')))
hidden_layer_size = hidden_units[0]
output_layer_size = 1
feature_columns = list(featurizer.create_feature_columns().values())
deep_columns, _ = featurizer.get_deep_and_wide_columns(
feature_columns, embedding_size=parameters.HYPER_PARAMS.embedding_size)
# Create the input layers from the features
input_layer = tf.feature_column.input_layer(features, deep_columns)
# Connect the input layer to the hidden layer
hidden_layer = tf.layers.dense(input_layer,
hidden_layer_size,
activation=tf.nn.relu)
# Connect the output layer (logits) to the hidden layer (no activation fn)
logits = tf.layers.dense(hidden_layer, output_layer_size)
if mode == tf.estimator.ModeKeys.PREDICT:
probabilities = tf.nn.softmax(logits)
predicted_indices = tf.argmax(probabilities, 1)
# Convert predicted_indices back into strings
predictions = {
'classes': tf.gather(metadata.TARGET_LABELS, predicted_indices),
'scores': tf.reduce_max(probabilities, axis=1)
}
export_outputs = {
'prediction': tf.estimator.export.PredictOutput(predictions)
}
return tf.estimator.EstimatorSpec(mode,
predictions=predictions,
export_outputs=export_outputs)
loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,
labels=labels))
tf.summary.scalar('loss', loss)
if mode == tf.estimator.ModeKeys.TRAIN:
# Create Optimiser
optimizer = tf.train.AdamOptimizer(learning_rate=params.learning_rate)
# Create training operation
train_op = optimizer.minimize(loss=loss,
global_step=tf.train.get_global_step())
# Provide an estimator spec for `ModeKeys.TRAIN` modes.
estimator_spec = tf.estimator.EstimatorSpec(mode=mode,
loss=loss,
train_op=train_op)
return estimator_spec
if mode == tf.estimator.ModeKeys.EVAL:
probabilities = tf.nn.softmax(logits)
predicted_indices = tf.argmax(probabilities, 1)
# Return accuracy and area under ROC curve metrics
labels_one_hot = tf.one_hot(labels,
depth=metadata.TARGET_LABELS.shape[0],
on_value=True,
off_value=False,
dtype=tf.bool)
eval_metric_ops = {
'accuracy': tf.metrics.accuracy(labels, predicted_indices),
'auroc': tf.metrics.auc(labels_one_hot, probabilities)
}
return tf.estimator.EstimatorSpec(mode,
loss=loss,
eval_metric_ops=eval_metric_ops)
def _model_fn(features, labels, mode):
""" model function for the custom estimator"""
hidden_units = construct_hidden_units()
output_layer_size = 1 # because it is a regression problem
feature_columns = list(featurizer.create_feature_columns().values())
# create the deep columns: dense + indicators
deep_columns, _ = featurizer.get_deep_and_wide_columns(
feature_columns
)
# Create input layer based on features
input_layer = tf.feature_column.input_layer(features=features,
feature_columns=deep_columns)
# Create hidden layers (cnn, rnn, dropouts, etc.) given the input layer
hidden_layers = tf.contrib.layers.stack(inputs=input_layer,
layer=tf.contrib.layers.fully_connected,
stack_args=hidden_units,
activation_fn=tf.nn.relu,
weights_initializer=tf.contrib.layers.xavier_initializer())
# Create output (logits) layer given the hidden layers
logits = tf.layers.dense(inputs=hidden_layers,
units=output_layer_size,
activation=None)
# Reshape output layer to 1-dim Tensor to return predictions
output = tf.squeeze(logits)
# Specify the model output (i.e. predictions) given the output layer
predictions = {
'scores': output
}
# Specify the export output based on the predictions
export_outputs = {
'predictions': tf.estimator.export.PredictOutput(predictions)
}
loss = None
train_op = None
eval_metric_ops = None
if mode == tf.estimator.ModeKeys.TRAIN or mode == tf.estimator.ModeKeys.EVAL:
# Calculate loss using mean squared error
loss = tf.losses.mean_squared_error(labels, output)
if mode == tf.estimator.ModeKeys.TRAIN:
# Create Optimiser
optimizer = tf.train.AdamOptimizer(
learning_rate=task.HYPER_PARAMS.learning_rate)
# Create training operation
train_op = optimizer.minimize(
loss=loss, global_step=tf.train.get_global_step())
if mode == tf.estimator.ModeKeys.EVAL:
# Specify root mean squared error as additional eval metric
eval_metric_ops = {
"rmse": tf.metrics.root_mean_squared_error(labels, output)
}
# Provide an estimator spec
estimator_spec = tf.estimator.EstimatorSpec(mode=mode,
loss=loss,
train_op=train_op,
eval_metric_ops=eval_metric_ops,
predictions=predictions,
export_outputs=export_outputs
)
return estimator_spec
