def model_fn(features_map, targets, mode): if mode == tf.contrib.learn.ModeKeys.TRAIN: predictions, loss = model_impl(hparams, mode, features_map, targets) if hparams.l1_reg > 0. or hparams.l2_reg > 0.: # apply regularization with tf.variable_scope("reg") as vs: all_regularize = [] if hparams.l1_reg > 0.: all_regularize.append( tf.contrib.layers.l1_regularizer(hparams.l1_reg)) if hparams.l2_reg > 0.: all_regularize.append( tf.contrib.layers.l2_regularizer(hparams.l2_reg)) regularizer = fu.sum_regularizer(all_regularize, scope=vs) regularization_penalty = tf.contrib.layers.apply_regularization( regularizer) loss += regularization_penalty train_op = create_train_op(loss, hparams) return model_fn_lib.ModelFnOps(mode=mode, predictions={ 'predictions': predictions, 'features': features_map['features'], 'targets': targets }, loss=loss, train_op=train_op) if mode == tf.contrib.learn.ModeKeys.INFER: predictions, loss = model_impl(hparams, mode, features_map, None) return model_fn_lib.ModelFnOps(mode=mode, predictions={ 'predictions': predictions, 'features': features_map['features'], 'targets': features_map['targets'] }) if mode == tf.contrib.learn.ModeKeys.EVAL: predictions, loss = model_impl(hparams, mode, features_map, targets) return model_fn_lib.ModelFnOps(mode=mode, predictions={ 'predictions': predictions, 'features': features_map['features'], 'targets': targets }, loss=loss)
def model_fn(features, targets, mode, params): # Features are board[81] + liberty[81] + group[81] + valid_move[81] + last_move[1] + ko[2]. # Note that turn and ko info are set to valid_move map. board_features, _, _ = tf.split(features, [81 * 4, 1, 2], axis=1) board = tf.reshape(board_features, [-1, 9, 9, 4]) # No relu, input includes negative. 4x25x64 = 6400 conv_in = tf.layers.conv2d(inputs=board, filters=64, kernel_size=[5, 5], padding="same") conv1 = tf.layers.conv2d(inputs=conv_in, filters=16, kernel_size=[3, 3], padding="same") # 64*9*16 = 9216 conv2 = tf.layers.conv2d(inputs=conv1, filters=16, kernel_size=[3, 3], padding="same") # 16*9*16 = 2304 conv_out = tf.layers.conv2d(inputs=conv2, filters=1, kernel_size=[1, 1], padding="same") # To reduce size # Flattens conv2d output and attaches last_move info. conv_flat = tf.reshape(conv_out, [-1, 9 * 9 * 1]) # Dense layer and output. # 81*64 = 5184 dense = tf.layers.dense(inputs=conv_flat, units=64) output_layer = tf.contrib.layers.linear(dense, 1) predictions = tf.reshape(output_layer, [-1]) # For predict mode. if targets == None: return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions) # For modes with targets. loss = tf.losses.mean_squared_error(targets, predictions) eval_metric_ops = { "rmse": tf.metrics.root_mean_squared_error(tf.cast(targets, tf.float32), predictions) } train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=params["learning_rate"], optimizer="SGD") return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops)
def model_fn(features, labels, params, mode): #get inputs, targets from features, labels source_tokens = tf.placeholder_with_default( features["source_tokens"], shape=[None, None], name='sentence_inputs') source_tokens_length = tf.placeholder_with_default( features["source_len"], shape=[None], name='source_tokens_length') if labels != None: target_tokens = tf.placeholder_with_default( labels["target_tokens"], shape=[None, None], name='targets') target_tokens_length = tf.placeholder_with_default( labels["target_len"], shape=[None], name='targets_token_length') else: target_tokens = None target_tokens_length = None # add placeholders self._add_placeholders(source_tokens, source_tokens_length, target_tokens, target_tokens_length, mode) # set input_ids, target_ids, max_target_len self._set_variables(mode) # add an encoder to computation graph self._add_encoder() # add a decoder self._add_decoder(mode) if mode == tf.contrib.learn.ModeKeys.TRAIN: # train return model_fn_lib.ModelFnOps( mode=mode, predictions={'predictions': self.predictions}, loss=self.loss, train_op=self.train_op) else: return model_fn_lib.ModelFnOps( mode=mode, predictions={ 'predictions': self.target_id_to_vocab.lookup( tf.to_int64(self.predictions)), 'source_tokens': self.source_tokens }, loss=self.loss)
def _model_fn(features, labels, mode): """Creates the prediction and its loss. Args: features: A dictionary of tensors keyed by the feature name. labels: A tensor representing the labels. mode: The execution mode, as defined in tf.contrib.learn.ModeKeys. Returns: A tuple consisting of the prediction, loss, and train_op. """ # Generate one embedding per sparse feature column and concatenate them. concat_embeddings = tf.contrib.layers.input_from_feature_columns( columns_to_tensors=features, feature_columns=_get_feature_columns(include_target_column=False)) # Add one hidden layer. hidden_layer_0 = tf.contrib.layers.relu(concat_embeddings, FLAGS.hidden_units) # Output and logistic loss. logits = tf.contrib.layers.linear(hidden_layer_0, FLAGS.num_classes) predictions = tf.contrib.layers.softmax(logits) if mode == tf.contrib.learn.ModeKeys.INFER: predictions = { tf.contrib.learn.PredictionKey.PROBABILITIES: predictions, PREDICTION_KEY: features[PREDICTION_KEY] } output_alternatives = { DEFAULT_OUTPUT_ALTERNATIVE: (tf.contrib.learn.ProblemType.UNSPECIFIED, predictions) } return model_fn.ModelFnOps(mode=mode, predictions=predictions, output_alternatives=output_alternatives) target_one_hot = tf.one_hot(labels, FLAGS.num_classes) target_one_hot = tf.reduce_sum(input_tensor=target_one_hot, reduction_indices=[1]) loss = tf.losses.softmax_cross_entropy(target_one_hot, logits) if mode == tf.contrib.learn.ModeKeys.EVAL: return predictions, loss, None opt = tf.train.MomentumOptimizer(FLAGS.learning_rate, FLAGS.momentum) train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=FLAGS.learning_rate, optimizer=opt) return model_fn.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def _model_fn(self, features, labels, mode): x_reshaped = tf.reshape(features, [-1, 28, 28, 1]) h1 = tf.layers.conv2d(x_reshaped, 32, [5, 5], padding="same", activation=tf.nn.relu) h2 = tf.layers.max_pooling2d(h1, 2, 2, padding="same") h3 = tf.layers.conv2d(h2, 64, [5, 5], padding="same", activation=tf.nn.relu) h4 = tf.layers.max_pooling2d(h3, 2, 2, padding="same") h5 = tf.layers.dense(tf.reshape(h4, [-1, 7 * 7 * 64]), 1024, activation=tf.nn.relu) h6 = tf.layers.dropout(h5, rate=0.3, training=(mode == learn.ModeKeys.TRAIN)) ypred = tf.layers.dense(h6, 10) predictions = { "classes": tf.argmax(ypred, axis=1), "probabilities": tf.nn.softmax(ypred, dim=1), "logits": ypred } loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=ypred, labels=tf.one_hot( labels, depth=10))) train_op = None if mode == learn.ModeKeys.TRAIN: train_op = tf.train.AdamOptimizer(1e-4).minimize(loss) return model_fn_lib.ModelFnOps(predictions=predictions, loss=loss, train_op=train_op, mode=mode)
def gmm_cluster_model_fn(features, labels, mode, params, config=None): """Model function.""" assert labels is None, labels update_params = '' for i in ["w", "m", 'c']: if i in params["update_params"]: update_params += i (all_scores, model_predictions, losses, training_op) = gmm_ops.gmm(parse_tensor_or_dict(features), "random", params["num_clusters"], params["random_seed"], params["covariance_type"], update_params, ) incr_step = state_ops.assign_add(variables.get_global_step(), 1) loss = math_ops.reduce_sum(losses) training_op = with_dependencies([training_op, incr_step], loss) predictions = { 'all_scores': all_scores[0], 'assignments': model_predictions[0][0], } eval_metric_ops = { 'scores': streaming_sum(loss), } return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, eval_metric_ops=eval_metric_ops, loss=loss, train_op=training_op)
def _model_fn(features, labels, mode, config): """Model function.""" assert labels is None, labels (loss, scores, model_predictions, training_op, init_op, is_initialized) = gmm_ops.gmm(self._parse_tensor_or_dict(features), self._training_initial_clusters, self._num_clusters, self._random_seed, self._covariance_type, self._params) incr_step = state_ops.assign_add(training_util.get_global_step(), 1) training_op = with_dependencies([training_op, incr_step], loss) training_hooks = [_InitializeClustersHook( init_op, is_initialized, config.is_chief)] predictions = { GMM.ASSIGNMENTS: model_predictions[0][0], } eval_metric_ops = { GMM.SCORES: scores, GMM.LOG_LIKELIHOOD: _streaming_sum(loss), } return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, eval_metric_ops=eval_metric_ops, loss=loss, train_op=training_op, training_hooks=training_hooks)
def model_fn(features, targets, mode, params): """Model function for Estimator.""" first_hidden_layer = tf.contrib.layers.relu(features, 10) second_hidden_layer = tf.contrib.layers.relu(first_hidden_layer, 10) output_layer = tf.contrib.layers.linear(second_hidden_layer, 1) predictions = tf.reshape(output_layer, [-1]) predictions_dict = {"ages": predictions} loss = tf.losses.mean_squared_error(targets, predictions) eval_metric_ops = { "rmse": tf.metrics.root_mean_squared_error(tf.cast(targets, tf.float64), predictions) } train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=params["learning_rate"], optimizer="SGD") return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions_dict, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops)
def test_build_all_signature_defs_legacy_input_fn_not_supported(self): """Tests that legacy input_fn returning (features, labels) raises error. serving_input_fn must return InputFnOps including a default input alternative. """ input_features = constant_op.constant(["10"]) input_ops = ({"features": input_features}, None) input_alternatives, _ = ( saved_model_export_utils.get_input_alternatives(input_ops)) output_1 = constant_op.constant(["1"]) output_2 = constant_op.constant(["2"]) output_3 = constant_op.constant(["3"]) provided_output_alternatives = { "head-1": (constants.ProblemType.LINEAR_REGRESSION, { "some_output_1": output_1 }), "head-2": (constants.ProblemType.CLASSIFICATION, { "some_output_2": output_2 }), "head-3": (constants.ProblemType.UNSPECIFIED, { "some_output_3": output_3 }), } model_fn_ops = model_fn.ModelFnOps( model_fn.ModeKeys.INFER, predictions={"some_output": constant_op.constant(["4"])}, output_alternatives=provided_output_alternatives) output_alternatives, _ = (saved_model_export_utils.get_output_alternatives( model_fn_ops, "head-1")) with self.assertRaisesRegexp( ValueError, "A default input_alternative must be provided"): saved_model_export_utils.build_all_signature_defs( input_alternatives, output_alternatives, "head-1")
def fnn_model_fn(features, labels, mode): print(features) print(labels) # output_labels = tf.reshape(labels,[-1,1]) dense = tf.layers.dense(features, units=nhidden, activation=tf.nn.relu, use_bias=True) print(dense) logits = tf.layers.dense(dense, units=1, use_bias=True) print(logits) onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=1) if mode != learn.ModeKeys.EVAL: # loss = tf.losses.sigmoid_cross_entropy(output_labels,logits) # loss = tf.losses.mean_squared_error(labels=output_labels,predictions=logits) loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=logits) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=learning_rate, optimizer="SGD") predictions = { "classes": tf.round(logits), "probabilities": tf.nn.softmax(logits, name="softmax_tensor") } return model_fn.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def model_fn(features, targets, mode, params): learning_rate = 0.001 keep_prob = tf.placeholder(tf.float32) # dropout (keep probability) # Construct model pred = cnn_model_tfp(features, params, keep_prob) pred_dict = { "classes": tf.argmax(input=pred, axis=1), "probabilities": tf.nn.softmax(pred, name="softmax_tensor") } loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=targets)) correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(targets, 1)) eval_metric_ops = { "accuracy": tf.reduce_mean(tf.cast(correct_pred, tf.float32)), "model_loss": loss } train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=learning_rate, optimizer="Adam") print("Got model fn fxn. params:", params) return model_fn_lib.ModelFnOps(mode=mode, loss=loss, train_op=train_op, predictions=pred_dict, eval_metric_ops=eval_metric_ops)
def _cnn_model_fn(features, labels, mode): x = features['data'] layer1 = tf.layers.dense(x, 10) layer2 = tf.layers.dense(layer1, 10) layer3 = tf.layers.dense(layer2, 10) logits = tf.layers.dense(layer3, 1) loss = None train_op = None # Calculate Loss (for both TRAIN and EVAL modes) if mode != learn.ModeKeys.INFER: loss = tf.losses.sigmoid_cross_entropy(labels, logits) # Configure the Training Op (for TRAIN mode) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=0.001, optimizer="Adam") # Generate Predictions predictions = { "classes": tf.argmax(input=logits, axis=1), "probabilities": tf.nn.sigmoid(logits) } # Return a ModelFnOps object return model_fn_lib.ModelFnOps(mode=mode, loss=loss, train_op=train_op, predictions=predictions)
def model_fn(features, targets, mode, params): logits = Dense(10, input_dim=784)(features["x"]) loss = tf.losses.softmax_cross_entropy( onehot_labels=targets, logits=logits) train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=params["learning_rate"], optimizer="SGD") predictions = { "classes": tf.argmax(input=logits, axis=1), "probabilities": tf.nn.softmax(logits) } eval_metric_ops = { "accuracy": tf.metrics.accuracy( tf.argmax(input=logits, axis=1), tf.argmax(input=targets, axis=1)) } return model_fn_lib.ModelFnOps( mode=mode, predictions=predictions, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops)
def head_ops(self, features, labels, mode, train_op_fn, logits=None, logits_input=None): """See `_Head`.""" _check_mode_valid(mode) _check_logits_input_not_supported(logits, logits_input) predictions = self._predictions(logits) if (mode == model_fn.ModeKeys.INFER) or (labels is None): loss = None train_op = None eval_metric_ops = None else: loss = self._training_loss(features, labels, logits) train_op = (None if train_op_fn is None or mode == model_fn.ModeKeys.EVAL else self._train_op( features, labels, train_op_fn, logits)) eval_metric_ops = self._eval_metric_ops(features, labels, logits) signature_fn = self._signature_fn() return model_fn.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops, signature_fn=signature_fn)
def model(features, labels, mode): input_layer = tf.reshape(features, [-1, 999]) input_layer = tf.one_hot(input_layer, 1000) layer_1 = layers.fully_connected(inputs=input_layer, num_outputs=4) output_layer = layers.fully_connected(inputs=layer_1, num_outputs=1, activation_fn=None) cross_entropy = None optimizer = None if mode != learn.ModeKeys.INFER: cross_entropy = tf.losses.sigmoid_cross_entropy( multi_class_labels=tf.reshape(labels, [-1]), logits=tf.reshape(output_layer, [-1])) if mode == learn.ModeKeys.TRAIN: optimizer = tf.contrib.layers.optimize_loss( loss=cross_entropy, global_step=tf.contrib.framework.get_global_step(), learning_rate=0.001, optimizer="SGD") activated = tf.sigmoid(output_layer, name='sigmoid_tensor') predictions = {"classes": tf.round(activated), "probabilities": activated} return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, loss=cross_entropy, train_op=optimizer)
def _lstm_model(features, targets): cell = tf.contrib.rnn.DropoutWrapper( tf.contrib.rnn.BasicLSTMCell(5, state_is_tuple=True), 0.9) stacked_lstm = tf.contrib.rnn.MultiRNNCell([cell for _ in range(1)], state_is_tuple=True) features = tf.unstack(features, axis=1, num=10) output, layers = tf.contrib.rnn.static_rnn(stacked_lstm, features, dtype=dtypes.float32) output = dnn_layers(output[-1], [10, 10]) prediction, loss = tflearn.models.linear_regression(output, targets) train_op = tf.contrib.layers.optimize_loss( loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad', learning_rate=params["learning_rate"]) eval_metric_ops = { "rmse": tf.metrics.root_mean_squared_error(tf.cast(targets, tf.float32), prediction) } predictions_dict = {"classes": prediction} return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions_dict, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops)
def test_build_all_signature_defs(self): input_features = constant_op.constant(["10"]) input_example = constant_op.constant(["11"]) input_ops = input_fn_utils.InputFnOps({"features": input_features}, None, {"default input": input_example}) input_alternatives, _ = ( saved_model_export_utils.get_input_alternatives(input_ops)) output_1 = constant_op.constant(["1"]) output_2 = constant_op.constant(["2"]) output_3 = constant_op.constant(["3"]) provided_output_alternatives = { "head-1": (constants.ProblemType.LINEAR_REGRESSION, { "some_output_1": output_1 }), "head-2": (constants.ProblemType.CLASSIFICATION, { "some_output_2": output_2 }), "head-3": (constants.ProblemType.UNSPECIFIED, { "some_output_3": output_3 }), } model_fn_ops = model_fn.ModelFnOps( model_fn.ModeKeys.INFER, predictions={"some_output": constant_op.constant(["4"])}, output_alternatives=provided_output_alternatives) output_alternatives, _ = ( saved_model_export_utils.get_output_alternatives( model_fn_ops, "head-1")) signature_defs = saved_model_export_utils.build_all_signature_defs( input_alternatives, output_alternatives, "head-1") expected_signature_defs = { "serving_default": signature_def_utils.regression_signature_def( input_example, output_1), "default_input_alternative:head-1": signature_def_utils.regression_signature_def( input_example, output_1), "default_input_alternative:head-2": signature_def_utils.classification_signature_def( input_example, output_2, None), "default_input_alternative:head-3": signature_def_utils.predict_signature_def({"input": input_example}, {"output": output_3}), # "features_input_alternative:head-1": # signature_def_utils.regression_signature_def(input_features, # output_1), # "features_input_alternative:head-2": # signature_def_utils.classification_signature_def(input_features, # output_2, None), # "features_input_alternative:head-3": # signature_def_utils.predict_signature_def({ # "input": input_features # }, {"output": output_3}), } self.assertDictEqual(expected_signature_defs, signature_defs)
def _model_fn_scaffold(features, labels, mode): _, _ = features, labels return model_fn.ModelFnOps( mode=mode, predictions=tf.constant(0.), loss=tf.constant(0.), train_op=tf.constant(0.), training_scaffold=tf.train.Scaffold(init_fn=_init_fn))
def _model_fn_scaffold(features, labels, mode): _, _ = features, labels return model_fn.ModelFnOps( mode=mode, predictions=constant_op.constant(0.), loss=constant_op.constant(0.), train_op=constant_op.constant(0.), scaffold=monitored_session.Scaffold(init_fn=_init_fn))
def cnn_model_fn(features, labels, mode): input_layer = tf.reshape(features, [-1, 28, 28, 1]) conv1 = tf.layers.conv2d(inputs=input_layer, filters=20, kernel_size=[5, 5], padding='valid', activation=tf.nn.relu) print conv1.get_shape() pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2) print pool1.get_shape() conv2 = tf.layers.conv2d(inputs=pool1, filters=40, kernel_size=[5, 5], padding='valid', activation=tf.nn.relu) print conv2.get_shape() pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2) print pool2.get_shape() # Dense Layer pool2_flat = tf.reshape(pool2, [-1, 4 * 4 * 40]) dense = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu) dropout = tf.layers.dropout(inputs=dense, rate=0.5, training=mode == learn.ModeKeys.TRAIN) # Logits Layer logits = tf.layers.dense(inputs=dropout, units=10) loss = None train_op = None if mode != learn.ModeKeys.INFER: onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=10) loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=logits) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=0.005, optimizer='SGD') # Generate Predictions predictions = { "classes": tf.argmax(input=logits, axis=1), "probabilities": tf.nn.softmax(logits, name="softmax_tensor") } return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def lenet_model_fn(features, labels, mode): # input layer input_layer = tf.reshape(features, [-1, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS]) conv1 = tf.layers.conv2d(inputs=input_layer, filters=32, kernel_size=[5, 5], padding='same', activation=tf.nn.relu) pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2) conv2 = tf.layers.conv2d(inputs=pool1, filters=64, kernel_size=[5, 5], padding='same', activation=tf.nn.relu) pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2) pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64]) dense = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu) dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=(mode == learn.ModeKeys.TRAIN)) logits = tf.layers.dense(inputs=dropout, units=10) loss = None train_op = None if mode != learn.ModeKeys.INFER: onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=10) loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=logits) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=0.001, optimizer='SGD') predictions = { "classes": tf.argmax(input=logits, axis=1), "probabilities": tf.nn.softmax(logits, name="softmax_tensor") } return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def cnn_model_fn(features, labels, mode, params): """Model function for CNN.""" # Input Layer input_layer = tf.reshape(features, [-1, IMG_SIZE, IMG_SIZE, COL_CHANNELS]) # Convolutional Layer #1 conv1 = tf.layers.conv2d(inputs=input_layer, filters=32, kernel_size=[5, 5], padding="same", activation=tf.nn.relu, strides=2) # Pooling Layer #1 pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2) # Convolutional Layer #2 and Pooling Layer #2 conv2 = tf.layers.conv2d(inputs=pool1, filters=64, kernel_size=[5, 5], padding="same", activation=tf.nn.relu, strides=2) pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2) # Dense Layer height = int(pool2.get_shape()[1]) width = int(pool2.get_shape()[2]) pool2_flat = tf.reshape(pool2, [-1, width * height * 64]) dense = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu) dropout = tf.layers.dropout(inputs=dense, rate=params["dropout"], training=mode == learn.ModeKeys.TRAIN) # Logits Layer logits = tf.layers.dense(inputs=dropout, units=10) loss = None train_op = None # Calculate Loss (for both TRAIN and EVAL modes) if mode != learn.ModeKeys.INFER: onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=10) loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=logits) # Configure the Training Op (for TRAIN mode) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=params["learnrate"], optimizer=params["optimizer"]) # Generate Predictions predictions = {"classes": tf.argmax(input=logits, axis=1), "probabilities": tf.nn.softmax(logits, name="softmax_tensor")} # Return a ModelFnOps object return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def tof_net_func(x, y, mode): # it reverse engineer the kinect x_shape = [-1, 384, 512, 9] y_shape = [-1, 384, 512, 18] l = 2 lr = 1e-5 # convert to the default data type msks = tf.tile(x[:, :, :, 9::], [1, 1, 1, 2]) msks = tf.cast(msks, dtype) x = tf.cast(x[:, :, :, 0:9], dtype) v = dnnOpticalFlow(x) # v = v * msks # loss = None train_op = None # compute loss (for TRAIN and EVAL modes) if mode != learn.ModeKeys.INFER: y = tf.cast(y, dtype) v_true = y loss = (tf.reduce_mean(\ tf.abs(\ (v-v_true)\ )**l) )**(1/l) # loss1 = tf.reduce_sum((inten0 * inten1))/tf.reduce_sum(tf.sqrt(inten0**2*inten1**2)) # loss2 = tf.reduce_sum((inten2 * inten1))/tf.reduce_sum(tf.sqrt(inten2**2*inten1**2)) loss = tf.identity(loss, name="loss") # configure the training op (for TRAIN mode) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss(\ loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=lr, optimizer="Adam" ) # generate predictions predictions = { "v": v, } # output intermediate things # ms = tf.identity(ms, name='ms') # x_tilde = tf.identity(x_tilde, name='x_tilde') tensors = [] for tensor in tensors: predictions[tensor.name] = tensor # return a ModelFnOps object return model_fn_lib.ModelFnOps( mode=mode, predictions=predictions, loss=loss, train_op=train_op, )
def cnn_model_fn(features, labels, mode, params): nn = cnn(features, labels, mode, params['rank'], params['is_riemannian']) # Return a ModelFnOps object model = model_fn_lib.ModelFnOps(mode=mode, predictions=nn['predictions'], loss=nn['loss'], train_op=nn['train_op']) return model
def model_fn(features, targets, mode, params): """Model function for Estimator.""" # 1. Configure the model via TensorFlow operations # First, build all the model, a good idea is using Keras or tf.layers # since these are high-level API's conv1 = Conv2D(32, (5, 5), activation='relu', input_shape=(28, 28, 1))(features) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(64, (5, 5), activation='relu')(pool1) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) flat = Flatten()(pool2) dense = Dense(1024, activation='relu')(flat) preds = Dense(10, activation='softmax')(dense) # 2. Define the loss function for training/evaluation loss = None train_op = None # Calculate Loss (for both TRAIN and EVAL modes) if mode != learn.ModeKeys.INFER: loss = tf.losses.softmax_cross_entropy(onehot_labels=targets, logits=preds) # 3. Define the training operation/optimizer # Configure the Training Op (for TRAIN mode) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=params["learning_rate"], optimizer="Adam", ) # 4. Generate predictions predictions_dict = { "classes": tf.argmax(input=preds, axis=1), "probabilities": tf.nn.softmax(preds, name="softmax_tensor") } # 5. Define how you want to evaluate the model metrics = { "accuracy": tf.metrics.accuracy(tf.argmax(input=preds, axis=1), tf.argmax(input=targets, axis=1)) } # 6. Return predictions/loss/train_op/eval_metric_ops in ModelFnOps object return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions_dict, loss=loss, train_op=train_op, eval_metric_ops=metrics)
def linear_model_fn_with_model_fn_ops(features, labels, mode): """Same as linear_model_fn, but returns `ModelFnOps`.""" assert mode in (model_fn.ModeKeys.TRAIN, model_fn.ModeKeys.EVAL, model_fn.ModeKeys.INFER) prediction, loss = (models.linear_regression_zero_init(features, labels)) train_op = optimizers.optimize_loss( loss, variables.get_global_step(), optimizer='Adagrad', learning_rate=0.1) return model_fn.ModelFnOps( mode=mode, predictions=prediction, loss=loss, train_op=train_op)
def _model_fn(features, labels, mode): """Function that returns predictions, training loss, and training op.""" weights = None if weights_name and weights_name in features: weights = features.pop(weights_name) graph_builder = graph_builder_class(params, device_assigner=device_assigner) inference = {} if (mode == model_fn_lib.ModeKeys.EVAL or mode == model_fn_lib.ModeKeys.INFER): inference[eval_metrics.INFERENCE_PROB_NAME] = ( graph_builder.inference_graph(features)) if not params.regression: inference[eval_metrics.INFERENCE_PRED_NAME] = math_ops.argmax( inference[eval_metrics.INFERENCE_PROB_NAME], 1) # labels might be None if we're doing prediction (which brings up the # question of why we force everything to adhere to a single model_fn). loss_deps = [] training_graph = None if labels is not None and mode == model_fn_lib.ModeKeys.TRAIN: training_graph = control_flow_ops.group( graph_builder.training_graph(features, labels, input_weights=weights, num_trainers=num_trainers, trainer_id=trainer_id), state_ops.assign_add(contrib_framework.get_global_step(), 1)) loss_deps.append(training_graph) training_loss = None if (mode == model_fn_lib.ModeKeys.EVAL or mode == model_fn_lib.ModeKeys.TRAIN): with ops.control_dependencies(loss_deps): training_loss = graph_builder.training_loss(features, labels, name=LOSS_NAME) if report_feature_importances and mode == model_fn_lib.ModeKeys.EVAL: training_loss = logging_ops.Print( training_loss, [graph_builder.feature_importances()], summarize=1000) # Put weights back in if weights is not None: features[weights_name] = weights training_hooks = [] if early_stopping_rounds: training_hooks.append(TensorForestLossHook(early_stopping_rounds)) return model_fn_lib.ModelFnOps(mode=mode, predictions=inference, loss=training_loss, train_op=training_graph, training_hooks=training_hooks)
def estimator_spec_to_model_fn_ops(estimator_spec): alternatives = _export_outputs_to_output_alternatives( estimator_spec.export_outputs) return model_fn.ModelFnOps(mode=_core_mode_to_contrib_mode( estimator_spec.mode), predictions=estimator_spec.predictions, loss=estimator_spec.loss, train_op=estimator_spec.train_op, eval_metric_ops=estimator_spec.eval_metric_ops, output_alternatives=alternatives)
def cnn_model_fn(features, labels, mode): #features = features.astype(dtype=np.float32) # Input Layer input_layer = tf.reshape(features, [batch_size, 121, 195, 1]) input_layer = tf.to_float(input_layer) # Modèle simplifié avec un seul CNN # Conv Layer conv1 = tf.layers.conv2d( inputs=input_layer, filters=16, strides=(10,10), kernel_size=[10, 10], padding="same", activation=tf.nn.relu) # Dense Layer conv1_flat = tf.reshape(conv1, [batch_size, 4160]) dense = tf.layers.dense(inputs=conv1_flat, units=1024, activation=tf.nn.relu) dropout = tf.layers.dropout( inputs=dense, rate=0.4, training=mode == learn.ModeKeys.TRAIN) # Logits Layer logits = tf.layers.dense(inputs=dropout, units=5) loss = None train_op = None # Calculate Loss (for both TRAIN and EVAL modes) if mode != learn.ModeKeys.INFER: onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=5) loss = tf.losses.softmax_cross_entropy( onehot_labels=onehot_labels, logits=logits) # Configure the Training Op (for TRAIN mode) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=0.001, optimizer="SGD") # Generate Predictions predictions = { "classes": tf.argmax( input=logits, axis=1), "probabilities": tf.nn.softmax( logits, name="softmax_tensor") } # Return a ModelFnOps object return model_fn_lib.ModelFnOps( mode=mode, predictions=predictions, loss=loss, train_op=train_op)
def cnn_model_fn(features, labels, mode): """Model function for CNN.""" input_one_hot = tf.one_hot(indices=tf.cast(features, tf.int32), depth=3000) input_one_hot = tf.reshape(input_one_hot, [-1, 128, 1, 3000]) conv1a = tf.layers.conv2d(inputs=input_one_hot, filters=1000, kernel_size=[3, 1], padding="same", activation=tf.nn.relu) conv1b = tf.layers.conv2d(inputs=input_one_hot, filters=1000, kernel_size=[2, 1], padding="same", activation=tf.nn.relu) conv1 = tf.concat([conv1a, conv1b], 1) pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 1], strides=2) pool1_flat = tf.reshape(pool1, [-1, 128 * 1 * 1000]) dense = tf.layers.dense(inputs=pool1_flat, units=1024, activation=tf.nn.relu) dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == learn.ModeKeys.TRAIN) ratings = tf.layers.dense(inputs=dropout, units=1, activation=tf.nn.relu6) loss = None train_op = None # Calculate Loss (for both TRAIN and EVAL modes) if mode != learn.ModeKeys.INFER: labels = tf.reshape(labels, [-1, 1]) loss = tf.losses.mean_squared_error(labels=labels, predictions=ratings) def f(lr, gs): return tf.train.exponential_decay(lr, gs, 100, 0.85) # Configure the Training Op (for TRAIN mode) if mode == learn.ModeKeys.TRAIN: train_op = tf.contrib.layers.optimize_loss( loss=loss, global_step=tf.contrib.framework.get_global_step(), learning_rate=0.001, learning_rate_decay_fn=f, optimizer="SGD") # Generate Predictions predictions = {"ratings": ratings} # Return a ModelFnOps object return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op)