def _model_fn(features, labels, mode): """Model function.""" assert labels is None, labels (all_scores, model_predictions, losses, training_op) = clustering_ops.KMeans( self._parse_tensor_or_dict(features), self._num_clusters, self._training_initial_clusters, self._distance_metric, self._use_mini_batch, random_seed=self._random_seed, kmeans_plus_plus_num_retries=self. _kmeans_plus_plus_num_retries).training_graph() incr_step = state_ops.assign_add(variables.get_global_step(), 1) loss = math_ops.reduce_sum(losses, name=KMeansClustering.LOSS_OP_NAME) logging_ops.scalar_summary('loss/raw', loss) training_op = with_dependencies([training_op, incr_step], loss) predictions = { KMeansClustering.ALL_SCORES: all_scores[0], KMeansClustering.CLUSTER_IDX: model_predictions[0], } eval_metric_ops = {KMeansClustering.SCORES: loss,} return ModelFnOps( mode=mode, predictions=predictions, eval_metric_ops=eval_metric_ops, loss=loss, train_op=training_op)
def kmeans_cluster_model_fn(features, labels, mode, params, config): """Model function for KMeansClustering estimator.""" # https://wiki.python.org/moin/UsingAssertionsEffectively assert labels is None, "labels are not needed: " + labels # clustering_ops.KMeans 是重要的算法实现过程 # https://github.com/tensorflow/tensorflow/blob/master/tensorflow # /contrib/factorization/python/ops/clustering_ops.py (all_scores, model_predictions, losses, is_initialized, cluster_centers_var, init_op, training_op) = \ clustering_ops.KMeans( _parse_tensor_or_dict(features), params.get('num_clusters'), initial_clusters=clustering_ops.RANDOM_INIT, distance_metric=clustering_ops.SQUARED_EUCLIDEAN_DISTANCE, use_mini_batch=False, mini_batch_steps_per_iteration=1, # use_mini_batch = params.get('use_mini_batch'), # mini_batch_steps_per_iteration=params.get( # 'mini_batch_steps_per_iteration'), random_seed=params.get('random_seed'), kmeans_plus_plus_num_retries=params.get( 'kmeans_plus_plus_num_retries')).training_graph() incr_step = state_ops.assign_add(variables.get_global_step(), 1) loss = math_ops.reduce_sum(losses, name='kmeans_loss') # Outputs a Summary protocol buffer containing a single scalar value. # Used for visualizing in TensorBoard summary.scalar('loss/raw', loss) # https://github.com/tensorflow/tensorflow/blob/master/tensorflow # /python/ops/control_flow_ops.py # with_dependencies(dependencies, output_tensor, name=None): # Produces the content of `output_tensor` only after `dependencies`. training_op = with_dependencies([training_op, incr_step], loss) predictions = { 'all_scores': all_scores[0], 'cluster_idx': model_predictions[0], } eval_metric_ops = {'scores': loss} # Hook for monitor training_hooks = [ _InitializeClustersHook(init_op, is_initialized, config.is_chief) ] relative_tolerance = params.get('relative_tolerance') if relative_tolerance is not None: training_hooks.append(_LossRelativeChangeHook(relative_tolerance)) return ModelFnOps(mode=mode, predictions=predictions, eval_metric_ops=eval_metric_ops, loss=loss, train_op=training_op, training_hooks=training_hooks)
def _kmeans_clustering_model_fn(features, labels, mode, params, config): """Model function for KMeansClustering estimator.""" assert labels is None, labels (all_scores, model_predictions, losses, is_initialized, init_op, training_op) = clustering_ops.KMeans( _parse_tensor_or_dict(features), params.get('num_clusters'), initial_clusters=params.get('training_initial_clusters'), distance_metric=params.get('distance_metric'), use_mini_batch=params.get('use_mini_batch'), mini_batch_steps_per_iteration=params.get( 'mini_batch_steps_per_iteration'), random_seed=params.get('random_seed'), kmeans_plus_plus_num_retries=params.get( 'kmeans_plus_plus_num_retries')).training_graph() incr_step = state_ops.assign_add(variables.get_global_step(), 1) loss = math_ops.reduce_sum(losses, name=KMeansClustering.LOSS_OP_NAME) summary.scalar('loss/raw', loss) training_op = with_dependencies([training_op, incr_step], loss) predictions = { KMeansClustering.ALL_SCORES: all_scores[0], KMeansClustering.CLUSTER_IDX: model_predictions[0], } eval_metric_ops = {KMeansClustering.SCORES: loss} training_hooks = [ _InitializeClustersHook(init_op, is_initialized, config.is_chief) ] relative_tolerance = params.get('relative_tolerance') if relative_tolerance is not None: training_hooks.append(_LossRelativeChangeHook(relative_tolerance)) return ModelFnOps(mode=mode, predictions=predictions, eval_metric_ops=eval_metric_ops, loss=loss, train_op=training_op, training_hooks=training_hooks)
def embed_lestm_model_fn(features, labels, mode, params): inputs = features["inputs"] with tf.name_scope("Embedding"): embeddings = tf.get_variable( name="embeddings", shape=[params["vocabulary_size"], params["embedding_size"]], initializer=tf.random_uniform_initializer(minval=-1, maxval=1)) embedding_lookup = tf.nn.embedding_lookup(params=embeddings, ids=inputs) with tf.name_scope("LSTM"): if params["use_gru"]: cell = tf.contrib.rnn.GRUCell(num_units=params["lstm_units"]) else: cell = tf.contrib.rnn.LSTMCell(num_units=params["lstm_units"], num_proj=params["lstm_projection"], activation=tf.tanh) cell = tf.contrib.rnn.MultiRNNCell(cells=[cell] * params["lstm_cell_count"]) lstm_output, lstm_state = tf.nn.dynamic_rnn(cell=cell, inputs=embedding_lookup, dtype=tf.float32) lstm_output = tf.reshape( tensor=lstm_output, shape=[-1, params["lstm_projection"] * params["max_inputs_len"]]) with tf.name_scope("Fully_connected"): fc_layer = lstm_output for fc_layer_size in params["fc_layers_size"]: fc_layer = tf.layers.dense( inputs=fc_layer, units=fc_layer_size, activation=tf.nn.relu, use_bias=True, kernel_initializer=tf.truncated_normal_initializer(mean=0, stddev=0.1), bias_initializer=tf.constant_initializer(value=0)) dropout = tf.layers.dropout(inputs=fc_layer, rate=params["dropout"], training=mode == learn.ModeKeys.TRAIN) logits = tf.layers.dense( inputs=dropout, units=params["nb_classes"], activation=tf.identity, use_bias=True, kernel_initializer=tf.truncated_normal_initializer(mean=0, stddev=0.1), bias_initializer=tf.constant_initializer(value=0)) predictions = \ { "classes" : tf.argmax(input = logits, axis = 1), "probabilities" : tf.nn.softmax(logits = logits) } loss = None train_op = None eval_metric_ops = None if mode != learn.ModeKeys.INFER: cross_entropy = tf.nn.softmax_cross_entropy_with_logits( logits=logits, labels=tf.one_hot(labels, params["nb_classes"])) loss = tf.reduce_mean(cross_entropy, name="loss") 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=params["optimizer"]) if mode == learn.ModeKeys.EVAL: eval_metric_ops = { "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"]) } return ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops)
def cldnn_model_fn(features, labels, mode, params): inputs = tf.cast(features["mfcc"], tf.float32) inputs_lengths = features["mfcc_lengths"] #with tf.name_scope("Convolution"): # input_layer = tf.reshape(inputs, shape = [-1, params["max_timesteps"], params["mfcc_features_count"], 1]) # conv_layer1 = tf.layers.conv2d( # inputs = input_layer, # filters = params["conv1_features_count"], # kernel_size = [params["conv1_kernel_size1"], params["conv1_kernel_size2"]], # padding = "same", # activation = tf.nn.relu) # pool_layer = tf.layers.max_pooling2d( # inputs = conv_layer1, # pool_size = [1, params["max_pooling_size"]], # strides = [1, params["max_pooling_size"]]) # conv_layer2 = tf.layers.conv2d( # inputs = pool_layer, # filters = params["conv2_features_count"], # kernel_size = [params["conv2_kernel_size1"], params["conv2_kernel_size2"]], # padding = "same", # activation = tf.nn.relu) # pool_output_freq_size = int(params["mfcc_features_count"] / params["max_pooling_size"]) # conv_layer2_flat = tf.reshape( # conv_layer2, # shape = [-1, params["max_timesteps"] * pool_output_freq_size * params["conv2_features_count"]] # ) #with tf.name_scope("Dimension_reduction"): # dim_reduction_layer = tf.layers.dense( # inputs = conv_layer2_flat, # units = params["max_timesteps"] *params["dimension_reduction_size"], # activation = tf.nn.relu) #dim_reduction_layer = tf.reshape( # tensor = dim_reduction_layer, # shape = [-1, params["max_timesteps"], params["dimension_reduction_size"]]) #with tf.name_scope("Concatenation"): # inputs = tf.reshape( # tensor = inputs, # shape = [-1, params["max_timesteps"], params["mfcc_features_count"]]) # concatenation_layer = tf.concat( # values = [inputs, dim_reduction_layer], # axis = 2) with tf.name_scope("Recurrent"): inputs_reshape = tf.reshape( tensor=inputs, shape=[-1, params["max_timesteps"], params["mfcc_features_count"]]) inputs_reshape = tf.transpose(inputs_reshape, [0, 2, 1]) lstm_cell = tf.contrib.rnn.LSTMCell(num_units=params["lstm_units"], num_proj=params["lstm_projection"], activation=tf.tanh) lstm_cell = tf.contrib.rnn.MultiRNNCell(cells=[lstm_cell] * params["lstm_cell_count"]) lstm_output, lstm_state = tf.nn.dynamic_rnn( cell=lstm_cell, inputs=inputs_reshape, sequence_length=inputs_lengths, dtype=tf.float32) lstm_output = tf.reshape( tensor=lstm_output, #shape = [-1, params["max_timesteps"] * params["lstm_projection"]]) shape=[ -1, params["lstm_projection"] * params["mfcc_features_count"] ]) with tf.name_scope("Fully_connected"): dense_layer = lstm_output if params["fully_connected_sizes"] is not None: for size in params["fully_connected_sizes"]: dense_layer = tf.layers.dense( inputs=dense_layer, units=size, activation=tf.nn.relu, use_bias=True, kernel_initializer=tf.truncated_normal_initializer( stddev=0.2, mean=0), bias_initializer=tf.constant_initializer(value=0.01)) dropout = tf.layers.dropout(inputs=dense_layer, rate=0.4, training=mode == learn.ModeKeys.TRAIN) with tf.name_scope("Logits"): logits_flat = tf.layers.dense( inputs=dropout, units=params["labels_class_count"], use_bias=True, kernel_initializer=tf.truncated_normal_initializer(stddev=0.2, mean=0), bias_initializer=tf.constant_initializer(value=0)) logits = tf.reshape(logits_flat, shape=[-1, params["labels_class_count"]]) predictions = \ { "classes" : tf.argmax(input = logits, axis = 1), "probabilities" : tf.nn.softmax(logits, name = "softmax_tensor"), } loss = None train_op = None eval_metric_ops = None if mode != learn.ModeKeys.INFER: cross_entropy = tf.nn.softmax_cross_entropy_with_logits( logits=logits, labels=tf.one_hot(labels, params["labels_class_count"])) loss = tf.reduce_mean(cross_entropy) 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=params["optimizer"]) if mode == learn.ModeKeys.EVAL: batch_size = int(logits.get_shape()[0]) eval_metric_ops = { "accuracy": tf.metrics.accuracy(labels=labels, predictions=tf.argmax(input=logits, axis=1)) } return ModelFnOps(mode=mode, predictions=predictions, loss=loss, train_op=train_op, eval_metric_ops=eval_metric_ops)