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