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