python类optimize_loss()的实例源码

def autoencoder_model(feature, target, mode, params):
  """Autoencodes sequence model."""
  vocab_size = params.get('vocab_size')
  embed_dim = params.get('embed_dim')

  tf.identity(feature[0], name='feature')
  embed_feature = sequence.embed_features(
    feature, vocab_size=vocab_size, embed_dim=embed_dim)
  output, _ = sequence.sequence_autoencoder_discriminator(
    embed_feature, length=FLAGS.max_doc_length, hidden_size=embed_dim)
  logits, predictions = sequence.outbed_generated(output)

  # Loss and training.
  loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, feature)
  loss = tf.reduce_mean(tf.reduce_sum(loss, axis=1))
  train_op = layers.optimize_loss(
      loss, tf.train.get_global_step(),
      learning_rate=params['learning_rate'],
      optimizer=params.get('optimizer', 'Adam'))
  return predictions, loss, train_op

def autoencoder_model(feature, target, mode, params):
  """Autoencodes features with given function."""
  autoencoder_fn = params.get('autoencoder_fn')
  feature_processor = params.get('feature_processor', lambda f: f)
  generated_postprocess = params.get('generated_postprocess', lambda f: f)

  # Process features.
  feature = feature_processor(feature)

  # Auto-encode.
  generated, _ = autoencoder_fn(feature)

  # Loss and training.
  loss = tf.contrib.losses.mean_squared_error(feature, generated)
  train_op = layers.optimize_loss(
      loss, tf.train.get_global_step(),
      learning_rate=params['learning_rate'],
      optimizer=params.get('optimizer', 'Adam'))

  # Post process generated.
  prediction = generated_postprocess(generated)
  prediction = tf.identity(prediction, name='generated')
  return prediction, loss, train_op

def build_train_graph(loss, learning_rate=0.001, clip_norm=5.0):
    """
    builds training graph
    """
    train_args = {"learning_rate": learning_rate, "clip_norm": clip_norm}
    logger.debug("building training graph: %s.", train_args)

    learning_rate = tf.placeholder_with_default(learning_rate, [], "learning_rate")
    global_step = tf.Variable(0, name='global_step', trainable=False)
    train_op = layers.optimize_loss(loss, global_step, learning_rate, "Adam",
                                    clip_gradients=clip_norm)

    model = {"global_step": global_step, "train_op": train_op,
             "learning_rate": learning_rate, "train_args": train_args}
    return model

def _get_model_fn(self, model_fn):
    """Backward compatibility way of adding class weight and IS_TRAINING.

    TODO(ipolosukhin): Remove this function after new layers are available.
    Specifically:
     * dropout and batch norm should work via update ops.
     * class weights should be retrieved from weights column or hparams.

    Args:
      model_fn: Core model function.

    Returns:
      Model function.
    """
    def _model_fn(features, targets, mode):
      """Model function."""
      ops.get_default_graph().add_to_collection('IS_TRAINING', mode == 'train')
      if self.class_weight is not None:
        constant_op.constant(self.class_weight, name='class_weight')
      predictions, loss = model_fn(features, targets)
      if isinstance(self.learning_rate, types.FunctionType):
        learning_rate = self.learning_rate(contrib_framework.get_global_step())
      else:
        learning_rate = self.learning_rate
      if isinstance(self.optimizer, types.FunctionType):
        optimizer = self.optimizer(learning_rate)
      else:
        optimizer = self.optimizer
      train_op = layers.optimize_loss(
          loss,
          contrib_framework.get_global_step(),
          learning_rate=learning_rate,
          optimizer=optimizer,
          clip_gradients=self.clip_gradients)
      return predictions, loss, train_op
    return _model_fn

def conv_learn(X, y, mode):
    # Ensure our images are 2d 
    X = tf.reshape(X, [-1, 36, 36, 1])
    # We'll need these in one-hot format
    y = tf.one_hot(tf.cast(y, tf.int32), 5, 1, 0)

    # conv layer will compute 4 kernels for each 5x5 patch
    with tf.variable_scope('conv_layer'):
        # 5x5 convolution, pad with zeros on edges
        h1 = layers.convolution2d(X, num_outputs=4,
                kernel_size=[5, 5], 
                activation_fn=tf.nn.relu)
        # 2x2 Max pooling, no padding on edges
        p1 = tf.nn.max_pool(h1, ksize=[1, 2, 2, 1],
                strides=[1, 2, 2, 1], padding='VALID')

        # Need to flatten conv output for use in dense layer
    p1_size = np.product(
              [s.value for s in p1.get_shape()[1:]])
    p1f = tf.reshape(p1, [-1, p1_size ])

    # densely connected layer with 32 neurons and dropout
    h_fc1 = layers.fully_connected(p1f,
             5,
             activation_fn=tf.nn.relu)
    drop = layers.dropout(h_fc1, keep_prob=0.5, is_training=mode == tf.contrib.learn.ModeKeys.TRAIN)

    logits = layers.fully_connected(drop, 5, activation_fn=None)
    loss = tf.losses.softmax_cross_entropy(y, logits)
    # Setup the training function manually
    train_op = layers.optimize_loss(
        loss,
        tf.contrib.framework.get_global_step(),
        optimizer='Adam',
        learning_rate=0.01)
    return tf.argmax(logits, 1), loss, train_op
# Use generic estimator with our function

def conv_learn(X, y, mode):
    # Ensure our images are 2d 
    X = tf.reshape(X, [-1, 36, 36, 1])
    # We'll need these in one-hot format
    y = tf.one_hot(tf.cast(y, tf.int32), 5, 1, 0)

    # conv layer will compute 4 kernels for each 5x5 patch
    with tf.variable_scope('conv_layer'):
        # 5x5 convolution, pad with zeros on edges
        h1 = layers.convolution2d(X, num_outputs=4,
                kernel_size=[5, 5], 
                activation_fn=tf.nn.relu)
        # 2x2 Max pooling, no padding on edges
        p1 = tf.nn.max_pool(h1, ksize=[1, 2, 2, 1],
                strides=[1, 2, 2, 1], padding='VALID')

        # Need to flatten conv output for use in dense layer
    p1_size = np.product(
              [s.value for s in p1.get_shape()[1:]])
    p1f = tf.reshape(p1, [-1, p1_size ])

    # densely connected layer with 32 neurons and dropout
    h_fc1 = layers.fully_connected(p1f,
             5,
             activation_fn=tf.nn.relu)
    drop = layers.dropout(h_fc1, keep_prob=0.5, is_training=mode == tf.contrib.learn.ModeKeys.TRAIN)

    logits = layers.fully_connected(drop, 5, activation_fn=None)
    loss = tf.losses.softmax_cross_entropy(y, logits)
    # Setup the training function manually
    train_op = layers.optimize_loss(
        loss,
        tf.contrib.framework.get_global_step(),
        optimizer='Adam',
        learning_rate=0.01)
    return tf.argmax(logits, 1), loss, train_op
# Use generic estimator with our function

def rnn_segment(features, targets, mode, params):
    seq_feature = features['seq_feature']
    seq_length = features['seq_length']
    with tf.variable_scope("emb"):
        embeddings = tf.get_variable("char_emb", shape=[params['num_char'], params['emb_size']])
    seq_emb = tf.nn.embedding_lookup(embeddings, seq_feature)
    batch_size = tf.shape(seq_feature)[0]
    time_step = tf.shape(seq_feature)[1]
    flat_seq_emb = tf.reshape(seq_emb, shape=[batch_size, time_step, (params['k'] + 1) * params['emb_size']])
    cell = rnn.LSTMCell(params['rnn_units'])
    if mode == ModeKeys.TRAIN:
        cell = rnn.DropoutWrapper(cell, params['input_keep_prob'], params['output_keep_prob'])
    projection_cell = rnn.OutputProjectionWrapper(cell, params['num_class'])
    logits, _ = tf.nn.dynamic_rnn(projection_cell, flat_seq_emb, sequence_length=seq_length, dtype=tf.float32)
    weight_mask = tf.to_float(tf.sequence_mask(seq_length))
    loss = seq2seq.sequence_loss(logits, targets, weights=weight_mask)
    train_op = layers.optimize_loss(
        loss=loss,
        global_step=tf.contrib.framework.get_global_step(),
        learning_rate=params["learning_rate"],
        optimizer=tf.train.AdamOptimizer,
        clip_gradients=params['grad_clip'],
        summaries=[
            "learning_rate",
            "loss",
            "gradients",
            "gradient_norm",
        ])
    pred_classes = tf.to_int32(tf.argmax(input=logits, axis=2))
    pred_words = tf.logical_or(tf.equal(pred_classes, 0), tf.equal(pred_classes, 3))
    target_words = tf.logical_or(tf.equal(targets, 0), tf.equal(targets, 3))
    precision = metrics.streaming_precision(pred_words, target_words, weights=weight_mask)
    recall = metrics.streaming_recall(pred_words, target_words, weights=weight_mask)
    predictions = {
        "classes": pred_classes
    }
    eval_metric_ops = {
        "precision": precision,
        "recall": recall
    }
    return learn.ModelFnOps(mode, predictions, loss, train_op, eval_metric_ops=eval_metric_ops)

def build(self):
        self.output = self._generator(self.input, name='gene')
        self.content_loss = tf.reduce_mean(tf.multiply(tf.log1p(self.output),\
                tf.abs(tf.subtract(self.target, self.output))))
        assert ten_sh(self.output) == ten_sh(self.target)
        self.concat_output  = tf.concat(1, (self.input, self.output))
        self.concat_target  = tf.concat(1, (self.input, self.target))
        self.fake_em = self._critic(self.concat_output, name='critic')
        self.true_em = self._critic(self.concat_target, name='critic', reuse=True)
        self.c_loss = tf.reduce_mean(self.fake_em - self.true_em, name='c_loss')
        self.g_loss = tf.reduce_mean(-self.fake_em, name='g_loss')


        ####summary####
        conntent_loss_sum = tf.summary.scalar('content_loss', self.content_loss)
        c_loss_sum = tf.summary.scalar('c_loss', self.c_loss)
        g_loss_sum = tf.summary.scalar('g_loss', self.g_loss)
        img_sum = tf.summary.image('gene_img', self.concat_output, max_outputs=1)
        img_sum = tf.summary.image('tar_img', self.concat_target, max_outputs=1)
        self.summary = tf.summary.merge_all()
        ##############

        theta_g = tf.get_collection(
                         tf.GraphKeys.TRAINABLE_VARIABLES, scope='gene')
        theta_c = tf.get_collection(
                          tf.GraphKeys.TRAINABLE_VARIABLES, scope='critic')
        counter_g = tf.Variable(trainable=False, initial_value=0, dtype=tf.int32)
        counter_c = tf.Variable(trainable=False, initial_value=0, dtype=tf.int32)
        self.c_opt = ly.optimize_loss(loss=self.c_loss, learning_rate=self.c_lr,\
                optimizer=tf.train.RMSPropOptimizer,\
                variables=theta_c,\
                global_step=counter_c)
        self.g_opt = ly.optimize_loss(loss=self.g_loss, learning_rate=self.g_lr,\
                optimizer=tf.train.RMSPropOptimizer,\
                variables=theta_g,\
                global_step=counter_g)
        self.content_opt = ly.optimize_loss(loss=self.content_loss, learning_rate=self.g_lr,\
                optimizer=tf.train.RMSPropOptimizer,\
                variables=theta_g,\
                global_step=counter_g)
        clipped_c_var = [tf.assign(var, tf.clip_by_value(var, self.clamp_lower, self.clamp_upper)) \
                for var in theta_c]
        with tf.control_dependencies([self.c_opt]):
            self.c_opt = tf.tuple(clipped_c_var)

def build(self):
        self.output = self._generator(self.input, name='gene')
        self.content_loss = tf.reduce_mean(tf.multiply(tf.log1p(self.output),\
                tf.abs(tf.subtract(self.target, self.output))))
        assert ten_sh(self.output) == ten_sh(self.target)
        self.eva_op = tf.concat(1, \
            (tf.exp(self.input*12.0)-1, tf.exp(self.output*8.0)-1), name='eva_op')
        self.concat_output  = tf.exp(tf.concat(1, (self.input, self.output)))
        self.concat_target  = tf.exp(tf.concat(1, (self.input, self.target)))
        self.fake_em = self._critic(self.concat_output, name='critic')
        self.true_em = self._critic(self.concat_target, name='critic', reuse=True)
        self.c_loss = tf.reduce_mean(self.fake_em - self.true_em, name='c_loss')
        self.g_loss = tf.reduce_mean(-self.fake_em, name='g_loss')


        ####summary####
        conntent_loss_sum = tf.summary.scalar('content_loss', self.content_loss)
        c_loss_sum = tf.summary.scalar('c_loss', self.c_loss)
        g_loss_sum = tf.summary.scalar('g_loss', self.g_loss)
        img_sum = tf.summary.image('gene_img', self.concat_output, max_outputs=1)
        img_sum = tf.summary.image('tar_img', self.concat_target, max_outputs=1)
        self.summary = tf.summary.merge_all()
        ##############

        theta_g = tf.get_collection(
                         tf.GraphKeys.TRAINABLE_VARIABLES, scope='gene')
        theta_c = tf.get_collection(
                          tf.GraphKeys.TRAINABLE_VARIABLES, scope='critic')
        counter_g = tf.Variable(trainable=False, initial_value=0, dtype=tf.int32)
        counter_c = tf.Variable(trainable=False, initial_value=0, dtype=tf.int32)
        self.c_opt = ly.optimize_loss(loss=self.c_loss, learning_rate=self.c_lr,\
                optimizer=tf.train.RMSPropOptimizer,\
                variables=theta_c,\
                global_step=counter_c)
        self.g_opt = ly.optimize_loss(self.g_loss, learning_rate=self.g_lr,\
                optimizer=tf.train.RMSPropOptimizer,\
                variables=theta_g,\
                global_step=counter_g)
        self.content_opt = ly.optimize_loss(self.content_loss, learning_rate=self.g_lr,\
                optimizer=tf.train.RMSPropOptimizer,\
                variables=theta_g,\
                global_step=counter_g)
        clipped_c_var = [tf.assign(var, tf.clip_by_value(var, self.clamp_lower, self.clamp_upper)) \
                for var in theta_c]
        with tf.control_dependencies([self.c_opt]):
            self.c_opt = tf.tuple(clipped_c_var)