def main():
# Parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('model_path',
help='Path to the converted model parameters (.npy)')
parser.add_argument('val_gt',
help='Path to validation set ground truth (.txt)')
parser.add_argument('imagenet_data_dir',
help='ImageNet validation set images directory path')
parser.add_argument('--model',
default='GoogleNet',
help='The name of the model to evaluate')
args = parser.parse_args()
# Load the network
net = load_model(args.model)
if net is None:
exit(-1)
# Load the dataset
data_spec = models.get_data_spec(model_instance=net)
image_producer = dataset.ImageNetProducer(val_path=args.val_gt,
data_path=args.imagenet_data_dir,
data_spec=data_spec)
# Evaluate its performance on the ILSVRC12 validation set
validate(net, args.model_path, image_producer, args.model)
def eval_imagenet_q(net_name, param_pickle_path):
netparams = load.load_netparams_tf_q(param_pickle_path)
data_spec = networks.get_data_spec(net_name)
input_node = tf.placeholder(tf.float32,
shape=(None, data_spec.crop_size,
data_spec.crop_size,
data_spec.channels))
label_node = tf.placeholder(tf.int32)
if net_name == 'alexnet':
logits_ = networks.alexnet(input_node, netparams)
elif net_name == 'googlenet':
logits_ = networks.googlenet(input_node, netparams)
elif net_name == 'nin':
logits_ = networks.nin(input_node, netparams)
elif net_name == 'resnet18':
logits_ = networks.resnet18(input_node, netparams)
elif net_name == 'resnet50':
logits_ = networks.resnet50(input_node, netparams)
elif net_name == 'squeezenet':
logits_ = networks.squeezenet(input_node, netparams)
elif net_name == 'vgg16net':
logits_ = networks.vgg16net_noisy(input_node, netparams)
loss_op = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits_,
labels=label_node)) #
probs = softmax(logits_)
top_k_op = tf.nn.in_top_k(probs, label_node, 5)
optimizer = tf.train.AdamOptimizer(learning_rate=0.001, epsilon=0.1)
correct_pred = tf.equal(tf.argmax(probs, 1), tf.argmax(label_node, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
count = 0
correct = 0
cur_accuracy = 0
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
image_producer = dataset.ImageNetProducer(val_path=IMAGE_LABLE,
data_path=IMAGE_PATH,
data_spec=data_spec)
total = len(image_producer)
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess, coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
correct += np.sum(
sess.run(top_k_op,
feed_dict={
input_node: images,
label_node: labels
}))
count += len(labels)
cur_accuracy = float(correct) * 100 / count
#print('{:>6}/{:<6} {:>6.2f}%'.format(count, total, cur_accuracy))
print(cur_accuracy)
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
return cur_accuracy
def eval_imagenet(net_name, param_path, param_q_path, qbits, layer_index, layer_name, file_idx, shift_back, trainable=False, err_mean=None, err_stddev=None, train_vars=None, cost_factor=200., n_epoch=1):
"""all layers are trainable in the conventional retraining procedure"""
if '.ckpt' in param_path:
netparams = load.load_netparams_tf(param_path, trainable=True)
else:
netparams = load.load_netparams_tf_q(param_path, trainable=True)
data_spec = helper.get_data_spec(net_name)
input_node = tf.placeholder(tf.float32, shape=(None, data_spec.crop_size, data_spec.crop_size, data_spec.channels))
label_node = tf.placeholder(tf.int32)
if net_name == 'alexnet_noisy':
logits_, err_w, err_b, err_lyr = networks.alexnet_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'alexnet':
if trainable:
logits_ = alexnet.alexnet_q(input_node, netparams, qbits)
else:
logits_ = alexnet.alexnet(input_node, netparams)
elif net_name == 'alexnet_shift':
logits_ = networks.alexnet_shift(input_node, netparams)
elif net_name == 'googlenet':
logits_, err_w, err_b, err_lyr = networks.googlenet_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'nin':
logits_, err_w, err_b, err_lyr = networks.nin_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'resnet18':
logits_ = resnet18.resnet18(input_node, netparams)
#logits_, err_w, err_b, err_lyr = networks.resnet18_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'resnet18_shift':
logits_ = networks.resnet18_shift(input_node, netparams, shift_back)
elif net_name == 'resnet50':
logits_, err_w, err_b, err_lyr = networks.resnet50_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'squeezenet':
logits_, err_w, err_b, err_lyr = networks.squeezenet_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'vgg16net':
logits_, err_w, err_b, err_lyr = networks.vgg16net_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
#square = [tf.nn.l2_loss(err_w[layer]) for layer in err_w]
#square_sum = tf.reduce_sum(square)
#loss_op = tf.reduce_mean(tf.nn.oftmax_cross_entropy_with_logits(logits=logits_, labels=label_node)) + cost_factor / (1. + square_sum)
# ======== calculating the quantization error of a certain layer ==========
if trainable:
""" read the quantized weights (quantized version of the most recent retrained) """
w_q_pickle = param_q_path
with open(w_q_pickle, 'rb') as f:
params_quantized = pickle.load(f)
layer = layer_name
params_quantized_layer = tf.get_variable(name='params_quantized_layer', initializer=tf.constant(params_quantized[0][layer]), trainable=False)
q_diff = tf.subtract(params_quantized_layer, netparams['weights'][layer])
q_diff_cost = tf.nn.l2_loss(q_diff)
#loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_, labels=label_node)) + cost_factor*q_diff_cost
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_, labels=label_node))
probs = helper.softmax(logits_)
top_k_op = tf.nn.in_top_k(probs, label_node, 5)
#optimizer = tf.train.AdamOptimizer(learning_rate=0.0001, epsilon=0.1)
optimizer = tf.train.AdamOptimizer(learning_rate=0.01, beta1=0.9, beta2=0.999, epsilon=10-8)
if trainable:
train_op = optimizer.minimize(loss_op)
correct_pred = tf.equal(tf.argmax(probs, 1), tf.argmax(label_node, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
if trainable:
count = 0
correct = 0
cur_accuracy = 0
for i in range(0, n_epoch):
#if cur_accuracy >= NET_ACC[net_name]:
#break
#image_producer = dataset.ImageNetProducer(val_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_10K/val_10.txt', data_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_10K', data_spec=data_spec)
#path_train = '/home/ahmed/projects/NN_quant/imageNet_training'
path_train = '/home/ahmed/ILSVRC2012_img_train'
#image_producer = dataset.ImageNetProducer(val_path=path_train + '/train_shuf_'+str(file_idx)+'.txt', data_path=path_train, data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path=path_train + '/reward_20k.txt', data_path=path_train, data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path=path_train + '/train_50classes.txt', data_path=path_train, data_spec=data_spec)
image_producer = dataset.ImageNetProducer(val_path=path_train + '/train_shuf.txt', data_path=path_train, data_spec=data_spec)
total = len(image_producer) * n_epoch
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess, coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
one_hot_labels = np.zeros((len(labels), 1000))
for k in range(len(labels)):
one_hot_labels[k][labels[k]] = 1
sess.run(train_op, feed_dict={input_node: images, label_node: one_hot_labels})
# AHMED: debug
#netparams_tmp = sess.run(netparams)
#print('train = ', np.amax(netparams_tmp['weights']['conv2']))
#print('len set = ', len(set(np.array(netparams['weights']['conv2']))))
# ------------
#correct += np.sum(sess.run(top_k_op, feed_dict={input_node: images, label_node: labels}))
# AHMED: modify
#top, logits_tmp, loss_op_tmp = sess.run([top_k_op, logits_q, loss_op], feed_dict={input_node: images, label_node: labels})
#top, act_q_tmp, weights_fp_tmp, weights_q_tmp = sess.run([top_k_op, act_, weights_fp, weights_q], feed_dict={input_node: images, label_node: labels})
top = sess.run([top_k_op], feed_dict={input_node: images, label_node: labels})
correct += np.sum(top)
#print(np.amax(weights_q_tmp))
#print(len(set(weights_q_tmp.ravel())))
# --------
count += len(labels)
cur_accuracy = float(correct) * 100 / count
file_label = 'retrain_reward'
for i in range(len(qbits)):
file_label=file_label+'_'+str(qbits[i])
write_to_csv([count, total, cur_accuracy],file_label)
print('{:>6}/{:<6} {:>6.2f}%'.format(count, total, cur_accuracy))
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
#return sess.run(err_w), cur_accuracy
# "sess.run" returns the netparams as normal value (converts it from tf to normal python variable)
return cur_accuracy, sess.run(netparams)
else:
count = 0
correct = 0
cur_accuracy = 0
#path_val = './nn_quant_and_run_code_train/ILSVRC2012_img_val'
path_val = '/home/ahmed/ILSVRC2012_img_val'
image_producer = dataset.ImageNetProducer(val_path=path_val + '/val.txt', data_path=path_val, data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path=path_val + '/val_50classes.txt', data_path=path_val, data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path=path_val + '/val_reward_3k.txt', data_path=path_val, data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_40K/val_40.txt', data_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_40K', data_spec=data_spec)
total = len(image_producer)
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess, coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
one_hot_labels = np.zeros((len(labels), 1000))
for k in range(len(labels)):
one_hot_labels[k][labels[k]] = 1
#correct += np.sum(sess.run(top_k_op, feed_dict={input_node: images, label_node: labels}))
top = sess.run([top_k_op], feed_dict={input_node: images, label_node: labels})
correct += np.sum(top)
count += len(labels)
cur_accuracy = float(correct) * 100 / count
print('{:>6}/{:<6} {:>6.2f}%'.format(count, total, cur_accuracy))
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
return cur_accuracy, 0
def eval_imagenet(net_name,
param_path,
shift_back,
trainable=False,
err_mean=None,
err_stddev=None,
train_vars=None,
cost_factor=200.,
n_epoch=1):
if '.ckpt' in param_path:
netparams = load.load_netparams_tf(param_path, trainable=False)
else:
netparams = load.load_netparams_tf_q(param_path, trainable=False)
#print((len(netparams['biases'])))
data_spec = networks.get_data_spec(net_name)
input_node = tf.placeholder(tf.float32,
shape=(None, data_spec.crop_size,
data_spec.crop_size,
data_spec.channels))
label_node = tf.placeholder(tf.int32)
if net_name == 'alexnet_noisy':
logits_, err_w, err_b, err_lyr = networks.alexnet_noisy(
input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'alexnet':
logits_ = networks.alexnet(input_node, netparams)
elif net_name == 'alexnet_shift':
logits_ = networks.alexnet_shift(input_node, netparams)
elif net_name == 'googlenet':
logits_, err_w, err_b, err_lyr = networks.googlenet_noisy(
input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'nin':
logits_, err_w, err_b, err_lyr = networks.nin_noisy(
input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'resnet18':
logits_ = networks.resnet18(input_node, netparams)
#logits_, err_w, err_b, err_lyr = networks.resnet18_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'resnet18_shift':
logits_ = networks.resnet18_shift(input_node, netparams, shift_back)
elif net_name == 'resnet50':
logits_, err_w, err_b, err_lyr = networks.resnet50_noisy(
input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'squeezenet':
logits_, err_w, err_b, err_lyr = networks.squeezenet_noisy(
input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'vgg16net':
logits_, err_w, err_b, err_lyr = networks.vgg16net_noisy(
input_node, netparams, err_mean, err_stddev, train_vars)
#square = [tf.nn.l2_loss(err_w[layer]) for layer in err_w]
#square_sum = tf.reduce_sum(square)
#loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_, labels=label_node)) + cost_factor / (1. + square_sum)
# ======== calculating the quantization error of a certain layer
# here needs PARAM
w_q_pickle = '/home/behnam/results/quantized/resnet18/May12_resnet18_10_res2a_branch1_5_bits.pickle'
with open(w_q_pickle, 'r') as f:
params_quantized = pickle.load(f)
# here needs PARAM
layer = 'res2a_branch1'
params_quantized_layer = tf.get_variable(name='params_quantized_layer',
initializer=tf.constant(
params_quantized[0][layer]),
trainable=False)
q_diff = tf.subtract(params_quantized_layer, netparams['weights'][layer])
q_diff_cost = tf.nn.l2_loss(q_diff)
loss_op = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
logits=logits_, labels=label_node)) + cost_factor * q_diff_cost
#loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_, labels=label_node))
probs = softmax(logits_)
top_k_op = tf.nn.in_top_k(probs, label_node, 5)
optimizer = tf.train.AdamOptimizer(learning_rate=0.001, epsilon=0.1)
if trainable:
train_op = optimizer.minimize(loss_op)
correct_pred = tf.equal(tf.argmax(probs, 1), tf.argmax(label_node, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
if trainable:
count = 0
correct = 0
cur_accuracy = 0
for i in range(0, n_epoch):
#if cur_accuracy >= NET_ACC[net_name]:
#break
#image_producer = dataset.ImageNetProducer(val_path='/home/behnam/ILSVRC2012_img_val_40K/val_40.txt', data_path='/home/behnam/ILSVRC2012_img_val_40K', data_spec=data_spec)
path_train = '/home/behnam/ILSVRC2012_img_train'
image_producer = dataset.ImageNetProducer(
val_path=path_train + '/train_shuf_200k.txt',
data_path=path_train,
data_spec=data_spec)
total = len(image_producer) * n_epoch
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess,
coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
one_hot_labels = np.zeros((len(labels), 1000))
for k in range(len(labels)):
one_hot_labels[k][labels[k]] = 1
sess.run(train_op,
feed_dict={
input_node: images,
label_node: one_hot_labels
})
correct += np.sum(
sess.run(top_k_op,
feed_dict={
input_node: images,
label_node: labels
}))
count += len(labels)
cur_accuracy = float(correct) * 100 / count
print('{:>6}/{:<6} {:>6.2f}%'.format(
count, total, cur_accuracy))
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
#return sess.run(err_w), cur_accuracy
# "sess.run" returns the netparams as normal value (converts it from tf to normal python variable)
return cur_accuracy, sess.run(netparams)
else:
count = 0
correct = 0
cur_accuracy = 0
path_val = '/home/behnam/ILSVRC2012_img_val_40K'
image_producer = dataset.ImageNetProducer(val_path=path_val +
'/val_40.txt',
data_path=path_val,
data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path='/home/behnam/ILSVRC2012_img_val_40K/val_40.txt', data_path='/home/behnam/ILSVRC2012_img_val_40K', data_spec=data_spec)
total = len(image_producer)
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess,
coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
one_hot_labels = np.zeros((len(labels), 1000))
for k in range(len(labels)):
one_hot_labels[k][labels[k]] = 1
correct += np.sum(
sess.run(top_k_op,
feed_dict={
input_node: images,
label_node: labels
}))
count += len(labels)
cur_accuracy = float(correct) * 100 / count
print('{:>6}/{:<6} {:>6.2f}%'.format(count, total,
cur_accuracy))
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
return cur_accuracy, 0
checkpoint_file = os.path.join(FLAGS.checkpoint_path,
FLAGS.model_name + '.ckpt')
if not os.path.isfile(checkpoint_file):
print('Checkpoint file for the model does not exist')
sys.exit(0)
# Override the default graph
with tf.Graph().as_default() as g:
# Get the preprocessing function for the network
preprocess_fn = preprocessing_factory.get_preprocessing(FLAGS.model_name,
is_training=False)
# Create a producer from the imagenet dataset
image_producer = dataset.ImageNetProducer(FLAGS.val_ground_truth_labels,
FLAGS.dataset_dir,
FLAGS.batch_size, preprocess_fn,
im_height, im_width, im_channels)
# Get the function for constructing the network
network_fn = nets_factory.get_network_fn(FLAGS.model_name,
num_classes,
is_training=False)
with tf.Session() as sess:
coordinator = tf.train.Coordinator()
# Start the image processing workers
threads = image_producer.start(session=sess, coordinator=coordinator)
labels, images = image_producer.get(sess)
print labels
# Define the model
# Note: The network_fn itself constructs the newtork with the right
def eval_imagenet(net_name, param_path, shift_back, trainable=False, err_mean=None, err_stddev=None, train_vars=None, cost_factor=200., n_epoch=1):
if '.ckpt' in param_path:
netparams = load.load_netparams_tf(param_path, trainable=False)
else:
netparams = load.load_netparams_tf_q(param_path, trainable=False)
# AHMED: debug
print('input = ', np.amax(netparams['weights']['conv2']))
# ------------
network = 'alexnet'
param_path_fp = './rlbitwidth.tfmodels/caffe2tf/tfmodels/' + network +'/' + network +'.ckpt'
netparams_fp = load.load_netparams_tf(param_path_fp, trainable=False)
#print((len(netparams['biases'])))
data_spec = helper.get_data_spec(net_name)
input_node = tf.placeholder(tf.float32, shape=(None, data_spec.crop_size, data_spec.crop_size, data_spec.channels))
label_node = tf.placeholder(tf.int32)
if net_name == 'alexnet_noisy':
logits_, err_w, err_b, err_lyr = networks.alexnet_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'alexnet':
if trainable:
logits_, act_, weights_fp = alexnet.alexnet(input_node, netparams_fp)
act_q, weights_q = alexnet.alexnet_conv1_conv3(input_node, netparams)
else:
logits_ , _ , _ = alexnet.alexnet(input_node, netparams)
elif net_name == 'alexnet_shift':
logits_ = networks.alexnet_shift(input_node, netparams)
elif net_name == 'googlenet':
logits_, err_w, err_b, err_lyr = networks.googlenet_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'nin':
logits_, err_w, err_b, err_lyr = networks.nin_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'resnet18':
logits_ = resnet18.resnet18(input_node, netparams)
#logits_, err_w, err_b, err_lyr = networks.resnet18_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'resnet18_shift':
logits_ = networks.resnet18_shift(input_node, netparams, shift_back)
elif net_name == 'resnet50':
logits_, err_w, err_b, err_lyr = networks.resnet50_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'squeezenet':
logits_, err_w, err_b, err_lyr = networks.squeezenet_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
elif net_name == 'vgg16net':
logits_, err_w, err_b, err_lyr = networks.vgg16net_noisy(input_node, netparams, err_mean, err_stddev, train_vars)
#square = [tf.nn.l2_loss(err_w[layer]) for layer in err_w]
#square_sum = tf.reduce_sum(square)
#loss_op = tf.reduce_mean(tf.nn.oftmax_cross_entropy_with_logits(logits=logits_, labels=label_node)) + cost_factor / (1. + square_sum)
# ======== calculating the quantization error of a certain layer
# here needs PARAM
"""
if trainable:
w_q_pickle = '/home/ahmed/projects/NN_quant/results/quantized/resnet18/May12_resnet18_10_res2a_branch1_5_bits.pickle'
with open(w_q_pickle, 'r') as f:
params_quantized = pickle.load(f)
# here needs PARAM
layer = 'res2a_branch1'
params_quantized_layer = tf.get_variable(name='params_quantized_layer', initializer=tf.constant(params_quantized[0][layer]), trainable=False)
q_diff = tf.subtract(params_quantized_layer, netparams['weights'][layer])
q_diff_cost = tf.nn.l2_loss(q_diff)
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_, labels=label_node)) + cost_factor*q_diff_cost
"""
#loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_, labels=label_node))
# AHMED test: partial backprop
#logits_diff = tf.subtract(logits_.ravel(), logits_q.ravel())
probs = helper.softmax(logits_)
top_k_op = tf.nn.in_top_k(probs, label_node, 5)
if trainable:
"""trial#1"""
#act_diff = tf.subtract(tf.reshape(act_, [-1]), tf.reshape(act_q, [-1]))
#act_diff_cost_section1 = tf.nn.l2_loss(act_diff)
"""trial#2"""
#act_ = tf.nn.sigmoid(Z3)
#act_diff_cost_section1 = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=act_q, labels=tf.nn.sigmoid(act_)))
"""trial#3"""
act_diff_cost_section1 = tf.reduce_mean(tf.losses.mean_squared_error(predictions=act_q, labels=act_))
optimizer = tf.train.AdamOptimizer(learning_rate=0.00005, beta1=0.9, beta2=0.999, epsilon=10-8)
#train_op = optimizer.minimize(loss_op)
train_op = optimizer.minimize(act_diff_cost_section1)
correct_pred = tf.equal(tf.argmax(probs, 1), tf.argmax(label_node, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
if trainable:
count = 0
correct = 0
cur_accuracy = 0
for i in range(0, n_epoch):
#if cur_accuracy >= NET_ACC[net_name]:
#break
#image_producer = dataset.ImageNetProducer(val_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_10K/val_10.txt', data_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_10K', data_spec=data_spec)
path_train = '/home/ahmed/projects/NN_quant/imageNet_training'
image_producer = dataset.ImageNetProducer(val_path=path_train + '/train_shuf_100k.txt', data_path=path_train, data_spec=data_spec)
total = len(image_producer) * n_epoch
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess, coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
one_hot_labels = np.zeros((len(labels), 1000))
for k in range(len(labels)):
one_hot_labels[k][labels[k]] = 1
#sess.run(train_op, feed_dict={input_node: images, label_node: one_hot_labels})
_ , loss_op_tmp = sess.run([train_op, act_diff_cost_section1], feed_dict={input_node: images, label_node: one_hot_labels})
# AHMED: debug
netparams_tmp = sess.run(netparams)
#print('train = ', np.amax(netparams_tmp['weights']['conv2']))
#print('len set = ', len(set(np.array(netparams['weights']['conv2']))))
# ------------
#correct += np.sum(sess.run(top_k_op, feed_dict={input_node: images, label_node: labels}))
# AHMED: modify
#top, logits_tmp, loss_op_tmp = sess.run([top_k_op, logits_q, loss_op], feed_dict={input_node: images, label_node: labels})
#top, act_q_tmp, weights_fp_tmp, weights_q_tmp = sess.run([top_k_op, act_, weights_fp, weights_q], feed_dict={input_node: images, label_node: labels})
top, act_q_tmp, weights_q_tmp = sess.run([top_k_op, act_, weights_q], feed_dict={input_node: images, label_node: labels})
correct += np.sum(top)
#print(np.amax(weights_q_tmp))
#print(len(set(weights_q_tmp.ravel())))
# --------
count += len(labels)
cur_accuracy = float(correct) * 100 / count
#print('{:>6}/{:<6} {:>6.2f}%'.format(count, total, cur_accuracy))
print('{:>6}/{:<6} {:>6.2f} error'.format(count, total, loss_op_tmp))
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
#return sess.run(err_w), cur_accuracy
# "sess.run" returns the netparams as normal value (converts it from tf to normal python variable)
return cur_accuracy, sess.run(netparams)
else:
count = 0
correct = 0
cur_accuracy = 0
path_val = '../nn_quant_and_run_code/ILSVRC2012_img_val'
image_producer = dataset.ImageNetProducer(val_path=path_val + '/val.txt', data_path=path_val, data_spec=data_spec)
#image_producer = dataset.ImageNetProducer(val_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_40K/val_40.txt', data_path='/home/ahmed/projects/NN_quant/ILSVRC2012_img_val_40K', data_spec=data_spec)
total = len(image_producer)
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess, coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
one_hot_labels = np.zeros((len(labels), 1000))
for k in range(len(labels)):
one_hot_labels[k][labels[k]] = 1
#correct += np.sum(sess.run(top_k_op, feed_dict={input_node: images, label_node: labels}))
top = sess.run([top_k_op], feed_dict={input_node: images, label_node: labels})
correct += np.sum(top)
count += len(labels)
cur_accuracy = float(correct) * 100 / count
print('{:>6}/{:<6} {:>6.2f}%'.format(count, total, cur_accuracy))
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
return cur_accuracy, 0
def main():
# Parse arguments
parser = argparse.ArgumentParser(
description='Use Fast Gradient or Fast Gradient Sign method \
to generate adversarial examples.')
parser.add_argument('-i', '--input_dir', type=str, required=True,
help='Directory of dataset.')
parser.add_argument('-o', '--output_dir', type=str, required=True,
help='Directory of output image file.')
parser.add_argument('--model', type=str, required=True,
choices=['GoogleNet'],
help='Models to be evaluated.')
parser.add_argument('--file_list', type=str, required=False,
help='Evaluate a specific list of file in dataset.')
parser.add_argument('--num_iter', type=int, default=100)
parser.add_argument('--sign', dest='use_sign', action='store_true')
parser.add_argument('--target', type=str, default=None,
help='Target list of file in dataset.')
parser.add_argument('--noise_file', type=str, default=None)
parser.add_argument('-n', '--not_crop', dest='need_rescale',
action='store_false')
parser.set_defaults(num_images=sys.maxsize)
parser.set_defaults(use_sign=False)
parser.set_defaults(need_rescale=True)
args = parser.parse_args()
targets = None
if args.target is not None:
targets = {}
with open(args.target, 'r') as f:
for line in f:
key, value = line.strip().split()
targets[key] = int(value)
if os.path.exists(args.output_dir):
shutil.rmtree(args.output_dir)
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
data_spec = models.get_data_spec(model_name=args.model)
sesh = tf.Session()
if args.noise_file is None:
input_node = tf.placeholder(
tf.float32,
shape=(
None,
data_spec.crop_size,
data_spec.crop_size,
data_spec.channels))
probs_output, variable_list = models.get_model(
sesh, input_node, args.model)
image_producer = dataset.ImageNetProducer(
file_list=args.file_list,
data_path=args.input_dir,
num_images=args.num_images,
need_rescale=args.need_rescale,
data_spec=data_spec,
batch_size=1)
print 'Start compute gradients'
if args.noise_file is None:
gradients = calc_gradients(
sesh,
image_producer,
input_node,
probs_output,
data_spec,
args.use_sign,
targets)
else:
gradients = np.load(args.noise_file)
if args.use_sign:
gradients = np.sign(gradients)
print 'End compute gradients'
gradients /= np.sqrt(np.mean(np.square(gradients))) // Why there is a normalization?
print 'RMSE of gradients', np.sqrt(np.mean(np.square(gradients)))
for magnitude in range(1, args.num_iter + 1):
distance = save_file(sesh, image_producer,
os.path.join(args.output_dir, str(magnitude)),
gradients * magnitude / 255.0 *
(data_spec.rescale[1] - data_spec.rescale[0]),
data_spec)
# Load the dataset
data_spec = models.get_data_spec(model_instance=net)
return data_spec
# Arguements:
#val_path: the advantage of this dataset provider is that if want to select a part of the whole
# dataset or you have a dataset which is not named normally like ImageNet, you can generate
# your own your_dateset.txt reading:
# file_path label
# n01440764/n01440764_10026.JPEG 0
#when you have a new dataset, you don't have to modify codes of this dataset_provider. The only thing
#you need to do is that generate your own your_dateset.txt
image_producer = dataset.ImageNetProducer(
val_path='./train.txt',
data_path='/home/simon/imagenet-data/raw-data/train',
data_spec=get_spec())
# Evaluate its performance on the ILSVRC12 validation set
total = len(image_producer)
# Start a session
sesh = tf.Session()
coordinator = tf.train.Coordinator()
sesh.run(init)
threads = image_producer.start(session=sesh, coordinator=coordinator)
# Iterate over and classify mini-batches
for (labels, images) in image_producer.batches(sesh):
sesh.run(your_train, feed_dict={x: images, y: labels})
# Stop the worker threads
coordinator.request_stop()
elif layer_name.startswith('conv') or layer_name.startswith('fc'):
parameters[layer_name]['weights'] = np.load(
'%s/%s/weights.npy' % (pruned_weights_root, layer_name))
parameters[layer_name]['biases'] = np.load(
'%s/%s/biases.npy' % (pruned_weights_root, layer_name))
return parameters
# Load the network
net = load_model('ResNet50')
if net is None:
exit(-1)
exit(-1)
parameters = np.load('res50.npy')
# Place the pruned weights into a parameters
pruned_parameters = make_pruned_parameters(parameters, 'pruned_weights')
# Load the dataset
val_gt = 'val.txt'
# imagenet_data_dir = '../val_img/'
imagenet_data_dir = '/mnt/data/imagenet/ILSVRC2012_img_val'
# model_path = 'vgg16.npy'
data_spec = models.get_data_spec(model_instance=net)
image_producer = dataset.ImageNetProducer(val_path=val_gt,
data_path=imagenet_data_dir,
data_spec=data_spec)
# Evaluate its performance on the ILSVRC12 validation set
validate(net, pruned_parameters, image_producer)
def main():
# Parse arguments
parser = argparse.ArgumentParser(
description='Use Adam optimizer to generate adversarial examples.')
parser.add_argument('-i',
'--input_dir',
type=str,
required=True,
help='Directory of dataset.')
parser.add_argument('-o',
'--output_dir',
type=str,
required=True,
help='Directory of output image file.')
parser.add_argument('--model',
type=str,
required=True,
choices=['GoogleNet'],
help='Models to be evaluated.')
parser.add_argument('--num_images',
type=int,
default=sys.maxsize,
help='Max number of images to be evaluated.')
parser.add_argument('--file_list',
type=str,
default=None,
help='Evaluate a specific list of file in dataset.')
parser.add_argument('--noise_file',
type=str,
default=None,
help='Directory of the noise file.')
parser.add_argument('--num_iter',
type=int,
default=1000,
help='Number of iterations to generate attack.')
parser.add_argument('--save_freq',
type=int,
default=500,
help='Save .npy file when each save_freq iterations.')
parser.add_argument('--learning_rate',
type=float,
default=0.01,
help='Learning rate of each iteration.')
parser.add_argument('--target',
type=str,
default=None,
help='Target list of dataset.')
parser.add_argument('--weight_loss2',
type=float,
default=1.0,
help='Weight of distance penalty.')
parser.add_argument('--not_crop',
dest='use_crop',
action='store_false',
help='Not use crop in image producer.')
parser.set_defaults(use_crop=True)
args = parser.parse_args()
assert args.num_iter % args.save_freq == 0
data_spec = get_data_spec(model_name=args.model)
args.learning_rate = args.learning_rate / 255.0 * \
(data_spec.rescale[1] - data_spec.rescale[0])
image_producer = dataset.ImageNetProducer(file_list=args.file_list,
data_path=args.input_dir,
num_images=args.num_images,
data_spec=data_spec,
need_rescale=args.use_crop,
batch_size=1)
targets = None
if args.target is not None:
targets = {}
with open(args.target, 'r') as f:
for line in f:
key, value = line.strip().split()
targets[key] = int(value)
sesh = tf.Session()
gradients = calc_gradients(sesh, args.model, image_producer,
args.output_dir, args.num_iter, args.save_freq,
args.learning_rate, targets, args.weight_loss2,
data_spec, 1, args.noise_file)
save_file(sesh, image_producer, gradients, data_spec, args)
spec.channels))
# Construct and return the model
return NetClass({'data': data_node})
# Load the network
net = load_model('ResNet50')
# Load the dataset
ground_true = '../train_shuffle.txt' # Specify your imagenet groundtrue here
imagenet_data_dir = '/DATA4000A/imagenet/ILSVRC/Data/CLS-LOC/train' # Specify your imagenet dataset root here
model_path = 'res50.npy' # Specify your model parameters path here
data_spec = models.get_data_spec(model_instance=net)
image_producer = dataset.ImageNetProducer(val_path=ground_true,
data_path=imagenet_data_dir,
data_spec=data_spec)
layer_name_list = net.get_layer_inputs_op.keys()
# hessian = dict()
# layer_inputs = dict()
input_node = net.inputs['data']
# get_batch_hessian_op = net.get_batch_hessian_op
get_layer_inputs_op = net.get_layer_inputs_op
# In fact, L-OBS does not need all images to generate a good enough hessian, you can set n_batch
n_batch = 4000
def calculate_hessian_conv_tf(layer_inputs):
"""
This function calculates hessian for convolution layer, given a batch of layer inputs
