      fake_bgr = Lambda(lambda x: x[:, :, :, 1:])(fake_abgr)
      fake = alpha * fake_bgr + (1-alpha) * distorted
  
      def preprocess_vggface(var_x):
          var_x = (var_x + 1) / 2 * 255  # channel order: BGR
          var_x -= [91.4953, 103.8827, 131.0912]
          return var_x
  
      real_sz224 = tf.image.resize_images(real, [224, 224])
      real_sz224 = Lambda(preprocess_vggface)(real_sz224)
 
</s> remove def perceptual_loss(real, fake_abgr, distorted, mask_eyes, vggface_feats, **weights):
 </s> add def perceptual_loss(real, fake_abgr, distorted, vggface_feats, **weights): </s> remove     loss_g = 0
    loss_g += weights['w_recon'] * calc_loss(fake_bgr, real, "l1")
 </s> add     loss_g = weights['w_recon'] * calc_loss(fake_bgr, real, "l1") </s> remove     loss_g = 0
    loss_g += weights['w_edge'] * calc_loss(first_order(fake_bgr, axis=1),
                                            first_order(real, axis=1), "l1")
 </s> add     loss_g = weights['w_edge'] * calc_loss(first_order(fake_bgr, axis=1),
                                           first_order(real, axis=1), "l1") </s> remove 
    def diff_x(var_x):
        xleft = var_x[:, :, 1, :] - var_x[:, :, 0, :]
        xinner = tf.unstack(var_x[:, :, 2:, :] - var_x[:, :, :-2, :], axis=2)
        xright = var_x[:, :, -1, :] - var_x[:, :, -2, :]
        xout = [xleft] + xinner + [xright]
        xout = tf.stack(xout, axis=2)
        return xout * 0.5

    def diff_y(var_x):
        xtop = var_x[:, 1, :, :] - var_x[:, 0, :, :]
        xinner = tf.unstack(var_x[:, 2:, :, :] - var_x[:, :-2, :, :], axis=1)
        xbot = var_x[:, -1, :, :] - var_x[:, -2, :, :]
        xout = [xtop] + xinner + [xbot]
        xout = tf.stack(xout, axis=1)
        return xout * 0.5

    def diff_xx(var_x):
        xleft = var_x[:, :, 1, :] + var_x[:, :, 0, :]
        xinner = tf.unstack(var_x[:, :, 2:, :] + var_x[:, :, :-2, :], axis=2)
        xright = var_x[:, :, -1, :] + var_x[:, :, -2, :]
        xout = [xleft] + xinner + [xright]
        xout = tf.stack(xout, axis=2)
        return xout - 2.0 * var_x

    def diff_yy(var_x):
        xtop = var_x[:, 1, :, :] + var_x[:, 0, :, :]
        xinner = tf.unstack(var_x[:, 2:, :, :] + var_x[:, :-2, :, :], axis=1)
        xbot = var_x[:, -1, :, :] + var_x[:, -2, :, :]
        xout = [xtop] + xinner + [xbot]
        xout = tf.stack(xout, axis=1)
        return xout - 2.0 * var_x

    def diff_xy(var_x):
        # xout1
        top_left = var_x[:, 1, 1, :]+var_x[:, 0, 0, :]
        inner_left = tf.unstack(var_x[:, 2:, 1, :]+var_x[:, :-2, 0, :], axis=1)
        bot_left = var_x[:, -1, 1, :]+var_x[:, -2, 0, :]
        x_left = [top_left] + inner_left + [bot_left]
        x_left = tf.stack(x_left, axis=1)

        top_mid = var_x[:, 1, 2:, :]+var_x[:, 0, :-2, :]
        mid_mid = tf.unstack(var_x[:, 2:, 2:, :]+var_x[:, :-2, :-2, :], axis=1)
        bot_mid = var_x[:, -1, 2:, :]+var_x[:, -2, :-2, :]
        x_mid = [top_mid] + mid_mid + [bot_mid]
        x_mid = tf.stack(x_mid, axis=1)

        top_right = var_x[:, 1, -1, :]+var_x[:, 0, -2, :]
        inner_right = tf.unstack(var_x[:, 2:, -1, :]+var_x[:, :-2, -2, :], axis=1)
        bot_right = var_x[:, -1, -1, :]+var_x[:, -2, -2, :]
        x_right = [top_right] + inner_right + [bot_right]
        x_right = tf.stack(x_right, axis=1)

        x_mid = tf.unstack(x_mid, axis=2)
        xout1 = [x_left] + x_mid + [x_right]
        xout1 = tf.stack(xout1, axis=2)

        # xout2
        top_left = var_x[:, 0, 1, :]+var_x[:, 1, 0, :]
        inner_left = tf.unstack(var_x[:, :-2, 1, :]+var_x[:, 2:, 0, :], axis=1)
        bot_left = var_x[:, -2, 1, :]+var_x[:, -1, 0, :]
        x_left = [top_left] + inner_left + [bot_left]
        x_left = tf.stack(x_left, axis=1)

        top_mid = var_x[:, 0, 2:, :]+var_x[:, 1, :-2, :]
        mid_mid = tf.unstack(var_x[:, :-2, 2:, :]+var_x[:, 2:, :-2, :], axis=1)
        bot_mid = var_x[:, -2, 2:, :]+var_x[:, -1, :-2, :]
        x_mid = [top_mid] + mid_mid + [bot_mid]
        x_mid = tf.stack(x_mid, axis=1)

        top_right = var_x[:, 0, -1, :]+var_x[:, 1, -2, :]
        inner_right = tf.unstack(var_x[:, :-2, -1, :]+var_x[:, 2:, -2, :], axis=1)
        bot_right = var_x[:, -2, -1, :]+var_x[:, -1, -2, :]
        x_right = [top_right] + inner_right + [bot_right]
        x_right = tf.stack(x_right, axis=1)

        x_mid = tf.unstack(x_mid, axis=2)
        xout2 = [x_left] + x_mid + [x_right]
        xout2 = tf.stack(xout2, axis=2)

        return (xout1 - xout2) * 0.25

    loss += tv_weight * (generalized_loss_function(diff_x(y_true),
                                                   diff_x(y_pred),
                                                   var_a=1.999999) +
                         generalized_loss_function(diff_y(y_true),
                                                   diff_y(y_pred),
                                                   var_a=1.999999))

    loss += tv2_weight * (generalized_loss_function(diff_xx(y_true),
                                                    diff_xx(y_pred),
                                                    var_a=1.999999) +
                          generalized_loss_function(diff_yy(y_true),
                                                    diff_yy(y_pred),
                                                    var_a=1.999999) +
                          2.0 * generalized_loss_function(diff_xy(y_true),
                                                          diff_xy(y_pred),
                                                          var_a=1.999999))

    return loss / (tv_weight + tv2_weight)
 </s> add     loss += tv_weight * (generalized_loss(diff_x(y_true), diff_x(y_pred), alpha=1.9999) +
                         generalized_loss(diff_y(y_true), diff_y(y_pred), alpha=1.9999))
    loss += tv2_weight * (generalized_loss(diff_xx(y_true), diff_xx(y_pred), alpha=1.9999) +
                          generalized_loss(diff_yy(y_true), diff_yy(y_pred), alpha=1.9999) +
                          generalized_loss(diff_xy(y_true), diff_xy(y_pred), alpha=1.9999) * 2.)
    loss = loss / (tv_weight + tv2_weight)
    # TODO simplify to use MSE instead
    return loss </s> remove             _ssim_k1 = 0.01
            _ssim_k2 = 0.03

            c_1 = (_ssim_k1 * max_val) ** 2
            c_2 = (_ssim_k2 * max_val) ** 2
 </s> add             c_one = (0.01 * max_val) ** 2
            c_two = ((0.03 * max_val)) ** 2 * compensation
        var_x = (var_x + 1.) / 2. * 255.  # channel order: BGR
      fake_bgr = Lambda(lambda x: x[:, :, :, 1:])(fake_abgr)
      fake = alpha * fake_bgr + (1-alpha) * distorted
  
      def preprocess_vggface(var_x):
        var_x = (var_x + 1.) / 2. * 255.  # channel order: BGR
          var_x -= [91.4953, 103.8827, 131.0912]
          return var_x
  
      real_sz224 = tf.image.resize_images(real, [224, 224])
      real_sz224 = Lambda(preprocess_vggface)(real_sz224)
keep keep keep keep replace keep keep keep keep keep
 documentation, pep8, style, clarity updates  - Prep for Segmentation (#812)

* documentation, pep8, style, clarity updates

* Update cli.py

* Update _config.py

remove extra mask and coverage

mask type as dropdown

* Update training_data.py

move coverage / LR to global
cut down on loss description

style change
losses working in PR

* simpler logging

* legacy update 
lib/model/losses.py