def construct_finetune_label()

in ebm_sandbox.py [0:0]

• 49 lines of code
• 9 McCabe index (conditional complexity)

def construct_finetune_label(weight, X, Y, Y_GT, model, target_vars):
    l1_norm = tf.placeholder(shape=(), dtype=tf.float32)
    l2_norm = tf.placeholder(shape=(), dtype=tf.float32)

    def compute_logit(X, stop_grad=False, num_steps=0):
        batch_size = tf.shape(X)[0]
        X = tf.reshape(X, (batch_size, 1, 32, 32, 3))
        X = tf.reshape(tf.tile(X, (1, 10, 1, 1, 1)), (batch_size * 10, 32, 32, 3))
        Y_new = tf.reshape(Y, (batch_size*10, 10))

        X_min = X - 8 / 255.
        X_max = X + 8 / 255.

        for i in range(num_steps):
            X = X + tf.random_normal(tf.shape(X), mean=0.0, stddev=0.005)

            energy_noise = model.forward(X, weights, label=Y, reuse=True)
            x_grad = tf.gradients(energy_noise, [X])[0]


            if FLAGS.proj_norm != 0.0:
                x_grad = tf.clip_by_value(x_grad, -FLAGS.proj_norm, FLAGS.proj_norm)

            X = X - FLAGS.step_lr * x_grad
            X = tf.maximum(tf.minimum(X, X_max), X_min)

        energy = model.forward(X, weight, label=Y_new)
        energy = -tf.reshape(energy, (batch_size, 10))

        if stop_grad:
            energy = tf.stop_gradient(energy)

        return energy

    for i in range(FLAGS.pgd):
        if FLAGS.train:
            break

        print("Constructed loop {} of pgd attack".format(i))
        X_init = X
        if i == 0:
            X = X + tf.to_float(tf.random_uniform(tf.shape(X), minval=-8, maxval=9, dtype=tf.int32)) / 255.

        logit = compute_logit(X)
        loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y_GT, logits=logit)

        x_grad = tf.sign(tf.gradients(loss, [X])[0]) / 255.
        X = X + 2 * x_grad

        if FLAGS.lnorm == -1:
            X = tf.maximum(tf.minimum(X, X_max), X_min)
        elif FLAGS.lnorm == 2:
            X = X_init + tf.clip_by_norm(X - X_init, l2_norm / 255., axes=[1, 2, 3])


    energy = compute_logit(X, num_steps=0)
    logits = energy
    labels = tf.argmax(Y_GT, axis=1)
    loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y_GT, logits=logits)


    optimizer = tf.train.AdamOptimizer(1e-3)
    train_op = optimizer.minimize(loss)
    accuracy = tf.contrib.metrics.accuracy(tf.argmax(logits, axis=1), labels)

    target_vars['accuracy'] = accuracy
    target_vars['train_op'] = train_op
    target_vars['l1_norm'] = l1_norm
    target_vars['l2_norm'] = l2_norm