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 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 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 _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 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 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 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
