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