def test_walking_mask_layer(options, test_set): assert (options.network_mode == Net_Mode.BACKDOOR_DEF) assert (options.build_level == Build_Level.MASK) ld_paths = dict() root_folder = '/home/tdteach/data/mask_test_solid_rd_1000_from_10/' # dirs = os.walk(root_folder) dirs = os.listdir(root_folder) for d in dirs: tgt_id = int(d.split('_')[0]) f_p = os.path.join(root_folder, d, 'checkpoint') with open(f_p, 'r') as f: for li in f: ckpt_name = li.split('"')[-2] ld_p = os.path.join(root_folder, d, ckpt_name) ld_paths[tgt_id] = ld_p break print(ld_paths) img_producer = dataset.ImageProducer(options, test_set) loader, img_op, lb_op, out_op, aux_out_op = builder.build_model( img_producer, options) config = tf.ConfigProto() config.gpu_options.allow_growth = True mask_abs = dict() init_op = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init_op) for k, v in ld_paths.items(): print(v) loader.restore(sess, v) masks, patterns = sess.run([out_op, aux_out_op]) mask = masks[0] pattern = (patterns[0] + 1.) / 2. mask_abs[k] = np.sum(np.abs(mask)) img_producer.stop() vs = list(mask_abs.values()) import statistics me = statistics.median(vs) abvs = abs(vs - me) mad = statistics.median(abvs) rvs = abvs / (mad * 1.4826) print(mask_abs) print(rvs) x_arr = [i for i in range(len(mask_abs))] import matplotlib.pyplot as plt plt.figure() plt.boxplot(rvs) plt.show()
def test_prediction(options, test_set): assert (options.build_level == Build_Level.LOGITS) img_producer = dataset.ImageProducer(options, test_set) loader, img_op, lb_op, out_op, aux_out_op = builder.build_model( img_producer, options) config = tf.ConfigProto() config.gpu_options.allow_growth = True acc = 0 n_test_examples = int(300) e_per_iter = options.batch_size * options.num_gpus init_op = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init_op) if options.model_path is not None: loader.restore(sess, options.model_path) for k in range(n_test_examples // e_per_iter): a, lbs = sess.run([out_op, lb_op]) # lbs = np.zeros(lbs.shape) pds = np.argmax(a, axis=1) print(pds[1:10]) print(lbs[1:10]) acc += sum(np.equal(pds, lbs)) print(k) img_producer.stop() print("acc: %.2f%%" % (acc * 100.0 / n_test_examples))
def classify(model_data_path, image_paths): '''Classify the given images using GoogleNet.''' # Get the data specifications for the GoogleNet model spec = models.get_data_spec(model_class=models.GoogleNet) # Create a placeholder for the input image input_node = tf.placeholder(tf.float32, shape=(None, spec.crop_size, spec.crop_size, spec.channels)) # Construct the network net = models.GoogleNet({'data': input_node}) # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) with tf.Session() as sesh: # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sesh, coordinator=coordinator) # Load the converted parameters print('Loading the model') net.load(model_data_path, sesh) # Load the input image print('Loading the images') indices, input_images = image_producer.get(sesh) # Perform a forward pass through the network to get the class probabilities print('Classifying') # probs = sesh.run(net.get_output(), feed_dict={input_node: input_images}) # display_results([image_paths[i] for i in indices], probs) # # //////////////////////////////////////////////////////////////////////////////////// feature_tensor = sesh.graph.get_tensor_by_name('pool5_7x7_s1:0') features = sesh.run(feature_tensor, feed_dict={input_node: input_images}) features = np.squeeze(features) for i, j in enumerate(indices): video_feature[image_paths[j]] = features[i] # print features.shape # print features # //////////////////////////////////////////////////////////////////////////////////// # Stop the worker threads coordinator.request_stop() coordinator.join(threads, stop_grace_period_secs=2)
def MIRC_resnet_baseline(num_layers=50): im_ext = '.JPEG' im_size = [224,224] model_data_path = resnet_weight_path + 'resnet_' + str(num_layers) + '_data.npy' #Prepare network net, spec = interpret_resnet(num_layers) #Images _,_,test_names = prepare_testing_images(test_im_dir,im_size,im_ext,grayscale=False,apply_preprocess=True) syn, skeys = get_synkeys() gt,gt_ids = get_labels(test_names,syn,skeys,syn_file) image_paths = sorted(glob(test_im_dir + '/*' + im_ext)) # Create a placeholder for the input image input_node = tf.placeholder(tf.float32, shape=(None, spec.crop_size, spec.crop_size, spec.channels)) # Construct the network net = net({'data': input_node}) # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec, batch_size=len(image_paths)) #Work through all batches with tf.Session() as sesh: # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sesh, coordinator=coordinator) # Load the converted parameters print('Loading the model') net.load(model_data_path, sesh) # Load the input image print('Loading the images') indices, input_images = image_producer.get(sesh) sorted_indices = np.argsort(indices) # Perform a forward pass through the network to get the class probabilities print('Classifying') prob = sesh.run(net.get_output(), feed_dict={input_node: input_images}) prob = prob[sorted_indices,:] # Stop the worker threads coordinator.request_stop() coordinator.join(threads, stop_grace_period_secs=2) class_accuracy, t1_preds, t5_preds, t1_true_acc, t5_true_acc = evaluate_model(gt,gt_ids,prob,test_names,im_ext,full_syn) t1_p = 100 t5_p = 100 return class_accuracy, t1_true_acc, t5_true_acc, t1_preds, t5_preds, t1_p, t5_p
def load_image_tensorflow(image_paths,spec): with tf.Session() as sesh: # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sesh, coordinator=coordinator) indices, input_images = image_producer.get(sesh) # Stop the worker threads coordinator.request_stop() coordinator.join(threads, stop_grace_period_secs=2) return input_images
def test_backdoor_defence(options, test_set): assert (options.net_mode == Net_Mode.BACKDOOR_DEF) img_producer = dataset.ImageProducer(options, test_set) loader, img_op, lb_op, out_op, aux_out_op = builder.build_model( img_producer, options) print(out_op) print(aux_out_op) print("------------debug------------------") config = tf.ConfigProto() config.gpu_options.allow_growth = True init_op = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init_op) if options.model_path is not None: loader.restore(sess, options.model_path) if options.build_level == Build_Level.MASK: masks, patterns = sess.run([out_op, aux_out_op]) mask = masks[0] pattern = (patterns[0] + 1.) / 2. print(mask.shape) print(np.sum(np.abs(mask))) print(pattern.shape) import cv2 cv2.imshow('mask', mask) cv2.imshow('pattern', pattern) cv2.waitKey() elif options.build_level == Build_Level.LOGITS: e_per_iter = options.batch_size * options.num_gpus n_iters = test_set.num_examples // e_per_iter n_iters = min(10, n_iters) total_e = 0 acc_e = 0 t_lb = options.model_path.split("_") t_lb = int(t_lb[-2]) for k in range(n_iters): logits, masks = sess.run([out_op, aux_out_op]) total_e = total_e + e_per_iter tmp = np.argmax(logits, axis=1) acc_e += sum(tmp == t_lb) print('iter %d acc: %f' % (k, acc_e / total_e)) img_producer.stop()
def classify(model_data_path, image_paths): '''Classify the given images using GoogleNet.''' # Get the data specifications for the GoogleNet model spec = models.get_data_spec(model_class=models.GoogleNet) # Create a placeholder for the input image input_node = tf.placeholder(tf.float32, shape=(None, spec.crop_size, spec.crop_size, spec.channels)) # Construct the network net = models.GoogleNet({'data': input_node}) # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) with tf.Session() as sesh: # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sesh, coordinator=coordinator) # Load the converted parameters print('Loading the model') net.load(model_data_path, sesh) # Load the input image print('Loading the images') indices, input_images = image_producer.get(sesh) # Perform a forward pass through the network to get the class probabilities print('Timing in seconds :') start_time = time.time() probs = sesh.run(net.get_output(), feed_dict={input_node: input_images}) duration = time.time() - start_time print(duration) display_results([image_paths[i] for i in indices], probs) # Stop the worker threads coordinator.request_stop() coordinator.join(threads, stop_grace_period_secs=2)
def test_in_MF_format(options, test_set): img_producer = dataset.ImageProducer(options, test_set) loader, img_op, lb_op, out_op, aux_out_op = builder.build_model( img_producer, options) header_len = len(options.image_folders[0]) im_pts = copy.deepcopy(test_set.filenames) for i in range(len(im_pts)): im_pts[i] = im_pts[i][header_len:] config = tf.ConfigProto() config.gpu_options.allow_growth = True n_test_examples = test_set.num_examples out_folder = '/home/tdteach/data/MF/results/try/FaceScrub/' name_ending = '_resnet101_128x128.bin' init_op = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init_op) if options.model_path is not None: loader.restore(sess, options.model_path) z = 0 for k in range(math.ceil(n_test_examples / options.batch_size)): st_t = time.time() a, lbs = sess.run([out_op, lb_op]) ed_t = time.time() print(ed_t - st_t) if z + options.batch_size > n_test_examples: z = n_test_examples - options.batch_size for j in range(options.batch_size): save_to_bin(a[j], out_folder + im_pts[z + j] + name_ending) z = z + options.batch_size print(k) img_producer.stop()
def gen_data_matrix(): from config import Options import dataset import builder import tensorflow as tf options = Options() my_set = dataset.MegafaceDataset(options) img_producer = dataset.ImageProducer(options, my_set) loader, img_op, lb_op, out_op = builder.build_model(img_producer,output_level=2) rst_image = [] rst_predict = [] t_label = 7707 sess_config = tf.ConfigProto() sess_config.gpu_options.allow_growth = True init_op = tf.global_variables_initializer() with tf.Session(config=sess_config) as sess: sess.run(init_op) loader.restore(sess, "/home/tdteach/data/benchmark/21-wedge") print(options.num_examples_per_epoch) for i in range(100): print(i) lgs, ims, lbs = sess.run([out_op,img_op,lb_op]) for j in range(ims.shape[0]): rst_predict.append(lgs[j][t_label]) rst_image.append(np.reshape(ims[j], 128*128*3)) img_producer.stop() ii = np.array(rst_image) ip = np.array(rst_predict) print(ii.shape) print(ip.shape) np.save('img_matrix',ii) np.save('prd_matrix',ip)
def classify(model_data_path, image_paths): '''Classify the given images using GoogleNet.''' # Get the data specifications for the GoogleNet model #spec = models.get_data_spec(model_class=models.GoogleNet) spec = models.get_data_spec(model_class=models.VGG_ILSVRC_16_layer) # Create a placeholder for the input image input_node = tf.placeholder(tf.float32, shape=(None, spec.crop_size, spec.crop_size, spec.channels)) # Construct the network #net = models.GoogleNet({'data': input_node}) net = models.VGG_ILSVRC_16_layer({'data': input_node}) def load_image(image_path, data_spec): # Read the file file_data = tf.read_file(image_path) # Decode the image data img = tf.image.decode_jpeg(file_data, channels=data_spec.channels) if data_spec.expects_bgr: # Convert from RGB channel ordering to BGR # This matches, for instance, how OpenCV orders the channels. img = tf.reverse(img, [2, 1, 0]) return img # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) with tf.Session() as sesh: # Start the image processing workers #coordinator = tf.train.Coordinator() #threads = image_producer.start(session=sesh, coordinator=coordinator) # Load the converted parameters print('Loading the model') net.load(model_data_path, sesh) # Load the input image print('Loading the images') is_jpeg = True probs = [] for image_path in image_paths: input_image = load_image(image_path, image_producer.data_spec) processed_img = dataset.process_image( img=input_image, scale=image_producer.data_spec.scale_size, isotropic=image_producer.data_spec.isotropic, crop=image_producer.data_spec.crop_size, mean=image_producer.data_spec.mean) #print('Classifying') prob = sesh.run(net.get_output(), feed_dict={ input_node: np.reshape(processed_img.eval(), (1, 224, 224, 3)) }) probs.extend(prob) #indices, input_images = image_producer.get(sesh) indices = range(len(image_paths)) # Perform a forward pass through the network to get the class probabilities display_results([image_paths[i] for i in indices], probs)
img_name = osp.basename(image_path) class_name = class_labels[class_indices[img_idx]] confidence = round(probs[img_idx, class_indices[img_idx]] * 100, 2) print('{:20} {:30} {} %'.format(img_name, class_name, confidence)) spec = DataSpec() input_node = tf.placeholder(tf.float32, [None, 227, 227, 3]) net = AlexNet({"data": input_node}) # image = (imread(r"tank_1.jpg")[:, :, :3]).astype(np.float32) # image -= np.mean(image) # image = imresize(image, (227, 227, 3)) image_paths = [r"tank_1.jpg"] image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) with tf.Session() as sess: # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sess, coordinator=coordinator) # Load the converted parameters print('Loading the model') net.load(r"../AlexNet.npy", sess, encoding="latin1") # Load the input image print('Loading the images') indices, input_images = image_producer.get(sess) # Perform a forward pass through the network to get the class probabilities
def test_embeddings(options, test_set): assert (options.build_level == Build_Level.EMBEDDING) img_producer = dataset.ImageProducer(options, test_set) loader, img_op, lb_op, out_op, aux_out_op = builder.build_model( img_producer, options) config = tf.ConfigProto() config.gpu_options.allow_growth = True rst_matrix = None rst_labels = None n_examples_per_iter = options.batch_size * options.num_gpus n_iters = options.num_examples_per_epoch // n_examples_per_iter # n_test_examples = int(3000) init_op = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init_op) if options.model_path is not None: loader.restore(sess, options.model_path) for k in range(n_iters): st_t = time.time() a, lbs = sess.run([out_op, lb_op]) ed_t = time.time() print(ed_t - st_t) if rst_matrix is None: rst_matrix = a rst_labels = lbs else: rst_matrix = np.concatenate((rst_matrix, a)) rst_labels = np.concatenate((rst_labels, lbs)) print(k) img_producer.stop() np.save('out_X.npy', rst_matrix) np.save('out_labels.npy', rst_labels) exit(0) no = np.linalg.norm(rst_matrix, axis=1) aft = np.divide(rst_matrix.transpose(), no) coss = np.matmul(aft.transpose(), aft) # coss = np.abs(coss) z = rst_labels z = np.repeat(np.expand_dims(z, 1), n_test_examples, axis=1) z = np.equal(z, rst_labels) same_type = z.astype(np.int32) total_top = np.sum(np.sum(same_type, axis=1) > 1) # top-1 rt = 0 for i in range(n_test_examples): if i == 0: rt += same_type[i][np.argmax(coss[i][1:])] elif i == n_test_examples - 1: rt += same_type[i][np.argmax(coss[i][:-1])] else: k1 = np.argmax(coss[i][0:i]) k2 = np.argmax(coss[i][i + 1:]) if coss[i][k1] > coss[i][k2 + i + 1]: rt += same_type[i][k1] else: rt += same_type[i][k2 + i + 1] print("top1 : %.2f%%" % (rt * 1.0 / total_top * 100)) print("positive pairs = %d" % total_top) # ROC print(same_type.shape) print(coss.shape) from sklearn import metrics fpr, tpr, thr = metrics.roc_curve( same_type.reshape(1, n_test_examples * n_test_examples).tolist()[0], coss.reshape(1, n_test_examples * n_test_examples).tolist()[0]) print('auc : %f' % (metrics.auc(fpr, tpr))) for i in range(len(fpr)): if fpr[i] * 100000 > 1: break print('tpr : %f' % (tpr[i])) print('thr : %f' % (thr[i])) aa = coss > 0.4594 print((np.sum(aa) - n_test_examples) / (n_test_examples * n_test_examples - n_test_examples)) import matplotlib.pyplot as plt plt.figure() plt.plot(fpr, tpr) plt.show()
def classify(model_data_path, image_pathFolder): '''Classify the given images using AlexNet.''' print(model_data_path) print(image_pathFolder) image_paths = [] for filename in os.listdir(image_pathFolder): image_paths.append(image_pathFolder + filename) print(image_paths) #if(True) #sys.exit(0) # Get the data specifications for the AlexNet model spec = models.get_data_spec(model_class=models.AlexNet) #print(spec) # Create a placeholder for the input image input_node = tf.placeholder(tf.float32, shape=(None, spec.crop_size, spec.crop_size, spec.channels)) print(input_node) # Construct the network net = models.AlexNet({'data': input_node}) print("net---------------------") # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) print(image_producer) os.environ["TF_CPP_MIN_LOG_LEVEL"] = '1' with tf.Session() as sesh: print( 'start -----------------------------------------------------------------%s' % datetime.now()) sesh.run(tf.global_variables_initializer()) # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sesh, coordinator=coordinator) # Load the converted parameters print( 'Loading the model -----------------------------------------------------------------%s' % datetime.now()) net.load(model_data_path, sesh) # Load the input image print( 'Loading the images-----------------------------------------------------------------%s' % datetime.now()) indices, input_images = image_producer.get(sesh) # Perform a forward pass through the network to get the class probabilities print( 'Classifying -----------------------------------------------------------------%s' % datetime.now()) probs = sesh.run(net.get_output(), feed_dict={input_node: input_images}) print( 'Classifying END -----------------------------------------------------------------%s' % datetime.now()) display_results([image_paths[i] for i in indices], probs) # Stop the worker threads coordinator.request_stop() coordinator.join(threads, stop_grace_period_secs=2)
def classify(model_data_path, image_pathFolder): '''Classify the given images using VGG16.''' #print(model_data_path) #print(image_pathFolder) image_paths = [] for filename in os.listdir(image_pathFolder): image_paths.append(image_pathFolder + filename) #print(image_paths) # Get the data specifications for the VggNet model spec = models.get_data_spec(model_class=models.VGG16) ##print(spec) # Create a placeholder for the input image input_node = tf.placeholder(tf.float32, shape=(None, spec.crop_size, spec.crop_size, spec.channels)) #print(input_node) # Construct the network net = models.VGG16({'data': input_node}) #print("net---------------------") # Create an image producer (loads and processes images in parallel) image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) #print(image_producer) config = tf.ConfigProto() config.gpu_options.allow_growth = True #tf.ConfigProto() log_device_placement = True # 是否打印设备分配日志 allow_soft_placement = False # 如果你指定的设备不存在,允许TF自动分配设备 config = tf.ConfigProto(log_device_placement=True, allow_soft_placement=False) with tf.Session(config=config) as sesh: #print('start -----------------------------------------------------------------%s' % datetime.now()) #sesh.run(tf.global_variables_initializer()) # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sesh, coordinator=coordinator) # Load the converted parameters #print('Loading the model -----------------------------------------------------------------%s' % datetime.now()) net.load(model_data_path, sesh) # Load the input image #print('Loading the images-----------------------------------------------------------------%s' % datetime.now()) indices, input_images = image_producer.get(sesh) # Perform a forward pass through the network to get the class probabilities print( 'Classifying -----------------------------------------------------------------%s' % datetime.now()) probs = sesh.run(net.get_output(), feed_dict={input_node: input_images}) print( 'Classifying END -----------------------------------------------------------------%s' % datetime.now()) display_results([image_paths[i] for i in indices], probs) # Stop the worker threads coordinator.request_stop() coordinator.join(threads, stop_grace_period_secs=2)