symbolic_interval.py
from datetime import datetime
import json
import math
import os
import sys
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from model import Model
from pgd_attack import LinfPGDAttack
import numpy as np
tmp = tf.constant(0)
def tf_propagate1(center, error_range, equation, error_row, bias_row):
#(784,512)*(100,784,1)->(100,784,512)->(100,512)
l1 = tf.reduce_sum(tf.abs(equation)*\
tf.expand_dims(error_range, axis=-1), axis=1)
upper = center+l1+bias_row+tf.reduce_sum(error_row*\
tf.cast(tf.greater(error_row,0), tf.float32),axis=1)
lower = center-l1+bias_row+tf.reduce_sum(error_row*\
tf.cast(tf.less(error_row,0), tf.float32), axis=1)
appr_condition = tf.cast(tf.logical_and(tf.less(lower,0),\
tf.greater(upper,0)), tf.float32)
mask = appr_condition*((upper)/(upper-lower+0.000001))
mask = mask + 1 - appr_condition
mask = mask*tf.cast(tf.greater(upper, 0), tf.float32)
global tmp
tmp = mask
bias_row = bias_row*mask
center = center*mask
#center += bias_row
#mask=(100,1,512)
mask = tf.expand_dims(mask,axis=1)
#(784,512)*(100,1,512)
equation = equation*mask
#(1,512)*(100,1,512)
I = tf.eye(tf.shape(mask)[-1], dtype=tf.float32)
error_row = tf.concat([error_row,\
tf.expand_dims(tf.negative(lower), axis=1)*\
I*tf.expand_dims(appr_condition, axis=1)], axis=1)
error_row = error_row*mask
#zero_constant = tf.constant(0, dtype=tf.float32)
#bool_mask = tf.not_equal(tf.reduce_sum(tf.abs(error_row), axis=0), zero_constant)
#bool_mask = tf.expand_dims(bool_mask, axis=-1)
#tmp = bool_mask
#error_row = tf.boolean_mask(error_row, bool_mask, axis=1)
#tmp = error_row
return upper, lower, center, equation, error_row, bias_row
def conv1_graph(w_dict):
tf_x = tf.placeholder(tf.float32, shape = [None, 784])
tf_x = tf.reshape(tf_x, [-1, 28, 28, 1])
tf_conv1 = tf.nn.conv2d(tf_x, w_dict["w_conv1"],\
strides=[1,1,1,1], padding='SAME')+w_dict["b_conv1"]
tf_conv1 = tf.nn.relu(tf_conv1)
return tf_x, tf_conv1
def build_tf_graph_whole(w_dict, estep):
estep_decay = tf.placeholder('float', [])
tf_x1 = tf.placeholder(tf.float32, shape = [1, 784])
tf_y1 = tf.placeholder(tf.int64, shape = [None])
tf_mask1 = tf.placeholder(tf.bool, shape = [1,28,28,32])
tf_mask2 = tf.placeholder(tf.bool, shape = [1,14,14,64])
tf_mask_seq1 = tf.placeholder(tf.int64, shape = [6272])
tf_mask_seq2 = tf.placeholder(tf.int64, shape = [3136])
#tf_x1 = tf.reshape(tf_x1, [1, 28, 28, 1])
upper_input = tf.clip_by_value(tf_x1+estep*estep_decay, 0.0, 1.0)
lower_input = tf.clip_by_value(tf_x1-estep*estep_decay, 0.0, 1.0)
error_range = (upper_input-lower_input)/2.0
center = (lower_input+upper_input)/2
center = tf.reshape(center, [1, 28, 28, 1])
m = 1
equation = tf.eye(784, dtype=tf.float32)
equation = tf.reshape(equation, [784, 28,28,1])
bias_row = tf.zeros([1,28,28,1], dtype=tf.float32)
error_row = tf.zeros([1,28,28,1], dtype=tf.float32)
center = tf.nn.conv2d(center, w_dict["w_conv1"],\
strides=[1,1,1,1], padding='SAME')
equation = tf.nn.conv2d(equation, w_dict["w_conv1"], \
strides=[1,1,1,1], padding='SAME')
bias_row = tf.nn.conv2d(bias_row, w_dict["w_conv1"],\
strides=[1,1,1,1], padding='SAME')+w_dict["b_conv1"]
error_row = tf.nn.conv2d(error_row, w_dict["w_conv1"],\
strides=[1,1,1,1], padding='SAME')
center_shape = tf.shape(center)
equation_shape = tf.shape(equation)
bias_shape = tf.shape(bias_row)
error_shape = tf.shape(error_row)
n = center_shape[1]*center_shape[2]*center_shape[3]
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[784, n])
error_row = tf.reshape(error_row, [1, 1, n])
bias_row = tf.reshape(bias_row, [1, n])
upper, lower, center, equation, error_row, bias_row=\
tf_propagate1(center, error_range,\
equation, error_row, bias_row)
# batch_size, 14,14,16
center = tf.reshape(center, center_shape)
# batch_size * 784, 14,14,16
equation = tf.reshape(equation,[1*equation_shape[0],\
equation_shape[1], equation_shape[2], 32])
# batch_size, 14,14,16
bias_row = tf.reshape(bias_row, [1, bias_shape[1],\
bias_shape[2], 32])
# batch_size *(3136+1), 14,14,16
error_row = tf.reshape(error_row, [1*\
tf.shape(error_row)[1],error_shape[1],\
error_shape[2], 32])
# max1
zero_constant = tf.constant(0, dtype=tf.float32)
center = tf.boolean_mask(center, tf_mask1)
center = tf.gather(center, tf_mask_seq1)
center = tf.reshape(center, [1,14,14,32])
bias_row = tf.boolean_mask(bias_row, tf_mask1)
bias_row = tf.gather(bias_row, tf_mask_seq1)
bias_row = tf.reshape(bias_row, [1,14,14,32])
equation = tf.boolean_mask(equation,\
tf.reshape(tf_mask1, [28,28,32]), axis=1)
equation = tf.gather(equation, tf_mask_seq1, axis=1)
equation = tf.reshape(equation, [784,14,14,32])
error_n = tf.shape(error_row)[0]
error_row = tf.boolean_mask(error_row,\
tf.reshape(tf_mask1, [28,28,32]), axis=1)
error_row = tf.gather(error_row, tf_mask_seq1, axis=1)
error_row = tf.reshape(error_row, [error_n, 14,14,32])
# conv2_graph1
center = tf.nn.conv2d(center, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')
equation = tf.nn.conv2d(equation, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')
bias_row = tf.nn.conv2d(bias_row, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')+w_dict["b_conv2"]
error_row = tf.nn.conv2d(error_row, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')
center_shape = tf.shape(center)
equation_shape = tf.shape(equation)
bias_shape = tf.shape(bias_row)
error_shape = tf.shape(error_row)
n = center_shape[1]*center_shape[2]*center_shape[3]
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[784, n])
error_row = tf.reshape(error_row, [1, tf.cast(error_shape[0], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
upper, lower, center, equation, error_row, bias_row=\
tf_propagate1(center, error_range, equation, error_row, bias_row)
# batch_size, 14,14,16
center = tf.reshape(center, center_shape)
# batch_size * 784, 14,14,16
equation = tf.reshape(equation,[1*equation_shape[0],\
equation_shape[1], equation_shape[2], 64])
# batch_size, 14,14,16
bias_row = tf.reshape(bias_row, [1, bias_shape[1],\
bias_shape[2], 64])
# batch_size *(3136+1), 14,14,16
error_row = tf.reshape(error_row, [1*\
tf.shape(error_row)[1],error_shape[1],\
error_shape[2], 64])
#max2
center = tf.boolean_mask(center, tf_mask2)
center = tf.gather(center, tf_mask_seq2)
center = tf.reshape(center, [1,7,7,64])
bias_row = tf.boolean_mask(bias_row, tf_mask2)
bias_row = tf.gather(bias_row, tf_mask_seq2)
bias_row = tf.reshape(bias_row, [1,7,7,64])
equation = tf.boolean_mask(equation,\
tf.reshape(tf_mask2, [14,14,64]), axis=1)
equation = tf.gather(equation, tf_mask_seq2, axis=1)
equation = tf.reshape(equation, [784,7,7,64])
error_n = tf.shape(error_row)[0]
error_row = tf.boolean_mask(error_row,\
tf.reshape(tf_mask2, [14,14,64]), axis=1)
error_row = tf.gather(error_row, tf_mask_seq2, axis=1)
error_row = tf.reshape(error_row, [error_n, 7,7,64])
# fc layer
error_shape = tf.shape(error_row)
m = 1
n = 7*7*64
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[784, n])
error_row = tf.reshape(error_row,\
[tf.cast(error_shape[0], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
center = tf.matmul(center, w_dict["w_fc1"])
equation = tf.matmul(equation, w_dict["w_fc1"])
error_row = tf.matmul(error_row, w_dict["w_fc1"])
bias_row = tf.matmul(bias_row, w_dict["w_fc1"])+w_dict["b_fc1"]
n = 1024
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[1, 784, n])
error_row = tf.reshape(error_row,\
[1, tf.cast(error_shape[0], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
upper, lower, center, equation, error_row, bias_row=\
tf_propagate1(center, error_range,\
equation, error_row, bias_row)
error_shape = tf.shape(error_row)
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[784, n])
error_row = tf.reshape(error_row,\
[tf.cast(error_shape[1], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
center = tf.matmul(center, w_dict["w_fc2"])
equation = tf.matmul(equation, w_dict["w_fc2"])
error_row = tf.matmul(error_row, w_dict["w_fc2"])
bias_row = tf.matmul(bias_row, w_dict["w_fc2"])+w_dict["b_fc2"]
n = 10
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[1, 784, n])
error_row = tf.reshape(error_row,\
[1, tf.cast(error_shape[1], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
center_t = center[0:1, tf_y1[0]]
equation_t = equation[0:1,:,tf_y1[0]]
bias_row_t = bias_row[0:1, tf_y1[0]]
error_row_t = error_row[0:1, :, tf_y1[0]]
for i in range(1,1):
center_t = tf.concat([center_t,\
center[i:i+1, tf_y1[i]]], axis=0)
equation_t = tf.concat([equation_t,\
equation[i:i+1,:, tf_y1[i]]], axis=0)
bias_row_t = tf.concat([bias_row_t,\
bias_row[i:i+1, tf_y1[i]]], axis=0)
error_row_t = tf.concat([error_row_t,\
error_row[i:i+1,:, tf_y1[i]]], axis=0)
center = center-tf.expand_dims(center_t, axis=-1)
equation = equation-tf.expand_dims(equation_t, axis=-1)
bias_row = bias_row-tf.expand_dims(bias_row_t, axis=-1)
error_row = error_row-tf.expand_dims(error_row_t, axis=-1)
#tmp = center
upper, lower, center, equation, error_row, bias_row =\
tf_propagate1(center, error_range, equation,\
error_row, bias_row)
return tf_x1, tf_y1, tf_mask1, tf_mask2, tf_mask_seq1,\
tf_mask_seq2, estep_decay, upper, lower, center,\
equation, error_row, bias_row
def conv2_graph(w_dict):
tf_max1 = tf.placeholder(tf.float32, shape = [None, 14, 14, 32])
tf_conv2 = tf.nn.conv2d(tf_max1, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')+w_dict["b_conv2"]
tf_conv2 = tf.nn.relu(tf_conv2)
return tf_max1, tf_conv2
def conv2_graph1(w_dict, estep, error_range):
centeri = tf.placeholder(tf.float32, shape = [1, 14, 14, 32])
equationi = tf.placeholder(tf.float32, shape=[784, 14, 14, 32])
error_rowi = tf.placeholder(tf.float32, shape=[None, 14, 14, 32])
bias_rowi = tf.placeholder(tf.float32, shape=[1, 14, 14, 32])
center = tf.nn.conv2d(centeri, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')
equation = tf.nn.conv2d(equationi, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')
bias_row = tf.nn.conv2d(bias_rowi, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')+w_dict["b_conv2"]
error_row = tf.nn.conv2d(error_rowi, w_dict["w_conv2"],\
strides=[1,1,1,1], padding='SAME')
center_shape = tf.shape(center)
equation_shape = tf.shape(equation)
bias_shape = tf.shape(bias_row)
error_shape = tf.shape(error_row)
n = center_shape[1]*center_shape[2]*center_shape[3]
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[784, n])
error_row = tf.reshape(error_row, [1, tf.cast(error_shape[0], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
upper, lower, center, equation, error_row, bias_row=\
tf_propagate1(center, error_range, equation, error_row, bias_row)
# batch_size, 14,14,16
center = tf.reshape(center, center_shape)
# batch_size * 784, 14,14,16
equation = tf.reshape(equation,[1*equation_shape[0],\
equation_shape[1], equation_shape[2], 64])
# batch_size, 14,14,16
bias_row = tf.reshape(bias_row, [1, bias_shape[1],\
bias_shape[2], 64])
# batch_size *(3136+1), 14,14,16
error_row = tf.reshape(error_row, [1*\
tf.shape(error_row)[1],error_shape[1],\
error_shape[2], 64])
return upper, lower, center, equation,\
error_row, bias_row, centeri, equationi,\
error_rowi, bias_rowi
def tf_fc(w_dict):
tf_max2 = tf.placeholder(tf.float32, shape = [None, 7, 7, 64])
tf_fc1 = tf.reshape(tf_max2, [-1, 3136])
tf_fc1 = tf.nn.relu(tf.matmul(tf_fc1, w_dict["w_fc1"]) + w_dict["b_fc1"])
tf_pre_softmax = tf.matmul(tf_fc1, w_dict["w_fc2"]) + w_dict["b_fc2"]
return tf_max2, tf_pre_softmax
def tf_fc1(w_dict, estep, error_range):
centeri = tf.placeholder(tf.float32, shape = [1, 7, 7, 64])
equationi = tf.placeholder(tf.float32, shape=[784, 7, 7, 64])
error_rowi = tf.placeholder(tf.float32, shape=[None, 7, 7, 64])
bias_rowi = tf.placeholder(tf.float32, shape=[1, 7, 7, 64])
tf_y1 = tf.placeholder(tf.int64, shape = [None])
error_shape = tf.shape(error_rowi)
m = 1
n = 7*7*64
center = tf.reshape(centeri, [1, n])
equation = tf.reshape(equationi,[784, n])
error_row = tf.reshape(error_rowi,\
[tf.cast(error_shape[0], tf.int32), n])
bias_row = tf.reshape(bias_rowi, [1, n])
center = tf.matmul(center, w_dict["w_fc1"])
equation = tf.matmul(equation, w_dict["w_fc1"])
error_row = tf.matmul(error_row, w_dict["w_fc1"])
bias_row = tf.matmul(bias_row, w_dict["w_fc1"])+w_dict["b_fc1"]
n = 1024
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[1, 784, n])
error_row = tf.reshape(error_row, [1,\
tf.cast(error_shape[0], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
upper, lower, center, equation, error_row, bias_row=\
tf_propagate1(center, error_range,\
equation, error_row, bias_row)
error_shape = tf.shape(error_row)
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[784, n])
error_row = tf.reshape(error_row,\
[tf.cast(error_shape[1], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
center = tf.matmul(center, w_dict["w_fc2"])
equation = tf.matmul(equation, w_dict["w_fc2"])
error_row = tf.matmul(error_row, w_dict["w_fc2"])
bias_row = tf.matmul(bias_row, w_dict["w_fc2"])+w_dict["b_fc2"]
n = 10
center = tf.reshape(center, [1, n])
equation = tf.reshape(equation,[1, 784, n])
error_row = tf.reshape(error_row,\
[1, tf.cast(error_shape[1], tf.int32), n])
bias_row = tf.reshape(bias_row, [1, n])
center_t = center[0:1, tf_y1[0]]
equation_t = equation[0:1,:,tf_y1[0]]
bias_row_t = bias_row[0:1, tf_y1[0]]
error_row_t = error_row[0:1, :, tf_y1[0]]
for i in range(1,1):
center_t = tf.concat([center_t,\
center[i:i+1, tf_y1[i]]], axis=0)
equation_t = tf.concat([equation_t,\
equation[i:i+1,:, tf_y1[i]]], axis=0)
bias_row_t = tf.concat([bias_row_t,\
bias_row[i:i+1, tf_y1[i]]], axis=0)
error_row_t = tf.concat([error_row_t,\
error_row[i:i+1,:, tf_y1[i]]], axis=0)
center = center-tf.expand_dims(center_t, axis=-1)
equation = equation-tf.expand_dims(equation_t, axis=-1)
bias_row = bias_row-tf.expand_dims(bias_row_t, axis=-1)
error_row = error_row-tf.expand_dims(error_row_t, axis=-1)
#tmp = center
upper, lower, center, equation, error_row, bias_row =\
tf_propagate1(center, error_range,\
equation, error_row, bias_row)
return tf_y1, upper, lower, center, equation,\
error_row, bias_row, centeri, equationi,\
error_rowi, bias_rowi
def build_tf_graph(w_dict):
tf_x, tf_conv1 = conv1_graph(w_dict)
tf_max1, tf_conv2 = conv2_graph(w_dict)
tf_max2, tf_pre_softmax = tf_fc(w_dict)
return tf_x, tf_conv1, tf_max1, tf_conv2, tf_max2, tf_pre_softmax
def build_tf_graph1(w_dict, estep):
tf_x1, error_range, estep_decay, upper, lower, center,\
equation, error_row, bias_row =\
conv1_graph1(w_dict, estep)
param_conv1 = [center, equation, error_row, bias_row]
upper, lower, center_conv2, equation_conv2, error_row_conv2,\
bias_row_conv2, center_conv2_input, equation_conv2_input,\
error_row_conv2_input, bias_row_conv2_input =\
conv2_graph1(w_dict, estep, error_range)
param_conv2 = [center_conv2, equation_conv2,\
error_row_conv2, bias_row_conv2]
param_conv2_input = [center_conv2_input,\
equation_conv2_input, error_row_conv2_input,\
bias_row_conv2_input]
tf_y1, upper, lower, center_fc, equation_fc,\
error_row_fc, bias_row_fc, center_fc_input,\
equation_fc_input, error_row_fc_input,\
bias_row_fc_input = tf_fc1(w_dict, estep, error_range)
param_fc = [center_fc, equation_fc, error_row_fc, bias_row_fc]
param_fc_input = [center_fc_input, equation_fc_input,\
error_row_fc_input, bias_row_fc_input]
return tf_x1, tf_y1, error_range, estep_decay,\
upper, lower, param_conv1, param_conv2,\
param_conv2_input, param_fc, param_fc_input
def trasfer_index(a):
n = a.shape[0]
b = np.zeros(a.shape)
for ni in range(n):
b[a[ni]] = ni
return b
def np_max(maxi):
shape = maxi.shape
max_mask = np.zeros((shape))
row = shape[1]/2
col = shape[2]/2
channel = shape[3]
maxo = np.zeros((row,col,channel))
cnt = 1
'''
for c in range(channel):
for i in range(row):
for j in range(col):
'''
for i in range(row):
for j in range(col):
for c in range(channel):
m = -1000
iim = 0
jjm = 0
for ii in range(2):
for jj in range(2):
if(maxi[0,2*i+ii,2*j+jj,c]>m):
m = maxi[0,2*i+ii,2*j+jj,c]
iim = ii
jjm = jj
maxo[i,j,c] = maxi[0,2*i+iim,2*j+jjm,c]
#maxo[i,j,c] = np.max(maxi[0,2*i:2*i+2,2*j:2*j+2,c])
max_mask[0,2*i+iim,2*j+jjm,c] = cnt
cnt += 1
mask_seq = max_mask[np.nonzero(max_mask)].astype(np.int64)-1
mask_seq = trasfer_index(mask_seq.reshape(-1)).astype(np.int64)
'''
pool = maxi[max_mask!=0]
pool = pool[mask_seq].reshape(14,14,32)
print maxo[:,:,-1]
print pool[:,:,-1]
'''
return maxo.reshape(1, row, col, channel), max_mask!=0, mask_seq
def np_max2(maxi, equation, error_row, bias_row):
maxi += bias_row
shape = maxi.shape
row = shape[1]/2
col = shape[2]/2
channel = shape[3]
maxo = np.zeros((row,col,channel))
equationo = np.zeros((784,row,col,channel))
error_rowo = np.zeros((error_row.shape[0],row,col,channel))
bias_rowo = np.zeros((1,row,col,channel))
for c in range(channel):
for i in range(row):
for j in range(col):
m = -1000
iim = 0
jjm = 0
for ii in range(2):
for jj in range(2):
if(maxi[0,2*i+ii,2*j+jj,c]>m):
m = maxi[0,2*i+ii,2*j+jj,c]
iim = ii
jjm = jj
maxo[i,j,c] = maxi[0,2*i+iim,2*j+jjm,c]
equationo[:,i,j,c] = equation[:,2*i+iim,2*j+jjm,c]
error_rowo[:,i,j,c] = error_row[:,2*i+iim,2*j+jjm,c]
bias_rowo[:,i,j,c] = bias_row[:,2*i+iim,2*j+jjm,c]
centero = maxo-bias_rowo
return centero, equationo, error_rowo, bias_rowo
'''
def np_max1(maxi, upper, lower, center, equation, error_row, bias_row):
upper = np.reshape(maxi.shape)*(upper>0)
lower = np.reshape(maxi.shape)*(lower>0)
shape = maxi.shape
row = shape[1]/2
col = shape[2]/2
channel = shape[3]
maxo = np.zeros((row,col,channel))
equationo = np.zeros((784,row,col,channel))
centero = np.zeros((1,row,col,channel))
for c in range(channel):
for i in range(row):
for j in range(col):
u0 = upper[0,2*i,2*j,c]
l0 = lower[0,2*i,2*j,c]
u1 = upper[0,2*i+1,2*j,c]
l1 = lower[0,2*i+1,2*j,c]
u2 = upper[0,2*i,2*j+1,c]
l2 = lower[0,2*i,2*j+1,c]
u3 = upper[0,2*i+1,2*j+1,c]
l3 = lower[0,2*i+1,2*j+1,c]
gamma0 = (u0/(u0-l0)+u1/(u1-l1)+u2/(u2-l2)+u3/(u3-l3)-1)/(1/(u0-l0)+1/(u1-l1)+1/(u2-l2)+1/(u3-l3))
gamma = np.min(np.max(gamma0, np.max(l0,l1,l2,l3)), np.min(u0,u1,u2,u3))
g0 = (u0-gamma)/(u0-l0)
g1 = (u1-gamma)/(u1-l1)
g2 = (u2-gamma)/(u2-l2)
g3 = (u3-gamma)/(u3-l3)
G = g0+g1+g2+g3
if(G<1): eta=np.min(l0,l1,l2,l3)
elif(G==1): eta=gamma
else: eta=np.max(u0,u1,u2,u3)
for k in range(k):
equationo[k,i,j,c] = g0*equation[k,2*i,2*j,c]+g1*equation[k,2*i+1,2*j,c]+g2*equation[k,2*i,2*j+1,c]+g3*equation[k,2*i+1,2*j+1,c]
for k in range(error_row.shape[1]):
error_row[k,i,j,c] = g0*error_row[k,2*i,2*j,c]+g1*error_row[k,2*i+1,2*j,c]+g2*error_row[k,2*i,2*j+1,c]+g3*error_row[k,2*i+1,2*j+1,c]
maxo[i,j,c] = np.max(maxi[0,2*i:2*i+2,2*j:2*j+2,c])
centero[0,i,j,c] = g0*center[0,2*i,2*j,c]+g1*center[0,2*i+1,2*j,c]+g2*center[0,2*i,2*j+1,c]+g3*center[0,2*i+1,2*j+1,c]
bias_rowo[0,i,j,c] = g0*bias_rowo[0,2*i,2*j,c]+g1*bias_rowo[0,2*i+1,2*j,c]+g2*bias_rowo[0,2*i,2*j+1,c]+g3*bias_rowo[0,2*i+1,2*j+1,c]
return centero
'''
def propagate_whole(sess, w_dict, x, y,\
tf_graph_param_whole, naive_graph, ed):
o, mask1, mask2, mask_seq1, mask_seq2 =\
propagate(sess, w_dict, x, naive_graph)
#print np.sum(o)
tf_x1, tf_y1, tf_mask1, tf_mask2, tf_mask_seq1,\
tf_mask_seq2, estep_decay, upper, lower,\
center, equation, error_row, bias_row = tf_graph_param_whole
input_dict = {tf_x1:x, tf_y1:y, tf_mask1:mask1,\
tf_mask2:mask2, tf_mask_seq1:mask_seq1,\
tf_mask_seq2:mask_seq2, estep_decay:ed}
c, u, e, l, b = sess.run([center, upper, equation, lower, bias_row],\
feed_dict=input_dict)
return e, u, l
def propagate(sess, w_dict, x, naive_graph):
tf_x, tf_conv1, tf_max1, tf_conv2, tf_max2, tf_pre_softmax = naive_graph
x = x.reshape(-1,28,28,1)
conv1 = sess.run(tf_conv1, feed_dict={tf_x:x})
max1, mask1, mask_seq1 = np_max(conv1)
conv2 = sess.run(tf_conv2, feed_dict={tf_max1:max1})
max2, mask2, mask_seq2 = np_max(conv2)
o = sess.run(tf_pre_softmax, feed_dict={tf_max2:max2})
#print o, mask1, mask2
return o, mask1, mask2, mask_seq1, mask_seq2
def propagate1(sess, w_dict, x, y, tf_graph_param1, ed):
tf_x1, tf_y1, error_range, estep_decay, upper,\
lower, param_conv1, param_conv2, param_conv2_input,\
param_fc, param_fc_input = tf_graph_param1
#x = x.reshape(-1,28,28,1)
#o = sess.run(lower, feed_dict={tf_x1:x})
param = sess.run(param_conv1, feed_dict={tf_x1:x, estep_decay:ed})
param = np_max2(param[0],param[1],param[2],param[3])
conv2_dict = {tf_x1:x, estep_decay:ed,\
param_conv2_input[0]:param[0],\
param_conv2_input[1]:param[1],\
param_conv2_input[2]:param[2],\
param_conv2_input[3]:param[3]}
param = sess.run(param_conv2, feed_dict=conv2_dict)
param = np_max2(param[0],param[1],param[2],param[3])
fc_dict = {tf_x1:x, tf_y1:y, estep_decay:ed,\
param_fc_input[0]:param[0], param_fc_input[1]:param[1],\
param_fc_input[2]:param[2], param_fc_input[3]:param[3]}
param = sess.run(param_fc+[upper,lower], feed_dict=fc_dict)
return param[1], param[-2], param[-1]
if __name__ == '__main__':
with open('config.json') as config_file:
config = json.load(config_file)
num_eval_examples = config['num_eval_examples']
eval_batch_size = config['eval_batch_size']
eval_on_cpu = config['eval_on_cpu']
model_dir = config['model_dir']
# Set upd the data, hyperparameters, and the model
mnist = input_data.read_data_sets('MNIST_data', one_hot=False)
if eval_on_cpu:
with tf.device("/cpu:0"):
model = Model()
attack = LinfPGDAttack(model,
config['epsilon'],
config['k'],
config['a'],
config['random_start'],
config['loss_func'])
else:
model = Model()
attack = LinfPGDAttack(model,
config['epsilon'],
config['k'],
config['a'],
config['random_start'],
config['loss_func'])
global_step = tf.contrib.framework.get_or_create_global_step()
if not os.path.exists(model_dir):
os.makedirs(model_dir)
eval_dir = os.path.join(model_dir, 'eval')
if not os.path.exists(eval_dir):
os.makedirs(eval_dir)
last_checkpoint_filename = ''
already_seen_state = False
weights = tf.trainable_variables()
saver = tf.train.Saver()
filename = tf.train.latest_checkpoint(model_dir)
with tf.Session() as sess:
saver.restore(sess, filename)
x = mnist.test.images[:1, :]
y = mnist.test.labels[:1]
x_dict = {model.x_input: x,
model.y_input: y}
y_hat = sess.run(model.pre_softmax, feed_dict=x_dict)
print np.sum(y_hat), y_hat
w = sess.run(weights)
w_dict = {"w_conv1":w[0], "b_conv1":w[1],\
"w_conv2":w[2], "b_conv2":w[3],\
"w_fc1":w[4], "b_fc1":w[5],\
"w_fc2":w[6], "b_fc2":w[7]}
for wi in w:
print wi.shape
naive_graph = build_tf_graph(w_dict)
tf_graph_param_whole = build_tf_graph_whole(w_dict, 0)
print propagate_whole(sess, w_dict, x, y,\
tf_graph_param_whole, naive_graph, 1)
