def sample_save(self, step):
        test_files = glob(os.path.join(self.data_dir, 'test', '*'))

        # [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save
        # self.attr_keys = ['Male', 'Female', 'KizunaAI', 'Nekomasu', 'Mirai', 'Shiro', 'Kaguya']
        testA_list = test_files[:50]
        testB_list = test_files[:50]
        attrA_list = [np.load(val)['attr'] for val in testA_list]
        attrB_list = [self.binary_attrs] * len(testB_list)
        #phaseA_list = [np.load(val)['phase'] for val in testA_list]

        # get batch images and labels
        attrA, attrB = preprocess_attr(self.attr_names, attrA_list, attrB_list,
                                       self.attr_keys)
        imgA, imgB = preprocess_image(testA_list,
                                      testB_list,
                                      self.image_size,
                                      phase='test')
        dataA, _ = preprocess_input(imgA, imgB, attrA, attrB, self.image_size,
                                    self.n_label)

        # generate fakeB
        feed = {self.real_A: dataA}
        fake_B = self.sess.run(self.fake_B, feed_dict=feed)

        # save samples
        sample_file = os.path.join(self.sample_dir, '%06d' % (step))
        #save_wav(imgA, imgB, fake_B, self.image_size, sample_file, phaseA_list, num=10)
        save_wav_ceps(fake_B, './data_test_mcep/test.wav', sample_file)
def main(_):
  if FLAGS.model == 'resnet50':
    image_size = 224
  elif FLAGS.model == 'inceptionv3':
    image_size = 299
  else:
    print('Please specify model as either resnet50 or inceptionv3.')
    sys.exit(-1)

  if FLAGS.image:
    with open(FLAGS.image, 'rb') as f:
      data = f.read()
  else:
    # Download the image URL if a path is not provided as input
    dl_request = requests.get(IMAGE_URL, stream=True)
    dl_request.raise_for_status()
    data = dl_request.content

  channel = grpc.insecure_channel(FLAGS.server)
  stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
  request = predict_pb2.PredictRequest()
  request.model_spec.name = FLAGS.model
  request.model_spec.signature_name = 'serving_default'
  image_data = tf.reshape(preprocess_image(data, FLAGS.model, image_size), [1, image_size, image_size, 3])

  # Run the graph
  with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    image_data = (sess.run(image_data))

  request.inputs['input'].CopyFrom(tf.contrib.util.make_tensor_proto(image_data, shape=[1, image_size, image_size, 3]))
  result = stub.Predict(request)
  print(result)
  print('Predicted class: ', str(np.argmax(result.outputs['predict'].float_val)))
Beispiel #3
0
    def sample_save(self, step):
        test_files = glob(os.path.join(self.data_dir, 'test', '*'))

        # [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save
        testA_list = random.sample(test_files, 10)
        testB_list = random.sample(test_files, 10)
        attrA_list = [
            self.attr_list[os.path.basename(val)] for val in testA_list
        ]
        attrB_list = [
            self.attr_list[os.path.basename(val)] for val in testB_list
        ]

        # get batch images and labels
        attrA, attrB = preprocess_attr(self.attr_names, attrA_list, attrB_list,
                                       self.attr_keys)
        imgA, imgB = preprocess_image(testA_list,
                                      testB_list,
                                      self.image_size,
                                      phase='test')
        dataA, dataB = preprocess_input(imgA, imgB, attrA, attrB,
                                        self.image_size, self.n_label)

        # generate fakeB
        feed = {self.real_A: dataA}
        fake_B = self.sess.run(self.fake_B, feed_dict=feed)

        # save samples
        sample_file = os.path.join(self.sample_dir, '%06d.jpg' % (step))
        save_images(imgA, imgB, fake_B, self.image_size, sample_file, num=10)
Beispiel #4
0
def create_sub_set_rand(persons, count):
    targets = np.zeros((count))
    ids = np.zeros((count))
    data = np.zeros((count, 32, 32))
    keys = []
    counter = 0

    # construct keys
    shuffle_keys = persons.keys()
    np.random.shuffle(shuffle_keys)

    for key in shuffle_keys:
        for i in range(len(persons[key].expressions)):
            if (counter < count):
                targets[counter] = persons[key].expressions[i]
                ids[counter] = persons[key].id

                data[counter] = persons[key].data[i]

                counter += 1
            else:
                if (i == 0):
                    keys.append(key)
                    data = util.preprocess_image(data)
                    return targets.reshape(1, targets.shape[0]), ids.reshape(1, ids.shape[0]), data, keys
                else:
                    while (i > 0):
                        targets = np.delete(targets, -1)
                        ids = np.delete(ids,-1)
                        data = np.delete(data, -1, axis=0)
                        i -= 1
#                     keys.append(key)

                    data = util.preprocess_image(data)
                    return targets.reshape(1, targets.shape[0]), ids.reshape(1, ids.shape[0]), data, keys
        keys.append(key)
    # in this case all persons finished
    # in case count >> the number of samples, remove zeros in the return arrays
    while(counter < count - 1):
        targets = np.delete(targets, -1)
        ids = np.delete(ids, -1)
        data = np.delete(data, -1, axis=0)
        counter += 1

    data = util.preprocess_image(data)
    return targets.reshape(1, targets.shape[0]), ids.reshape(1, ids.shape[0]), data, keys
def cache_FCN8s_results(config, VOCopts):
    log('start caching FCN-8s results and score')

    ## initialization
    cmap = scipy.io.loadmat(config['cmap'])['cmap']

    ## initialize caffe
    log('initializing caffe..')
    caffe.set_mode_gpu()
    caffe.set_device(config['gpuNum'])
    net = caffe.Net(config['Path.CNN.model_proto'],
                    config['Path.CNN.model_data'], caffe.TEST)
    log('done')

    ## initialize paths
    save_res_dir = path_join(config['save_root'], 'FCN8s/results')
    save_res_path = path_join(save_res_dir, '{}.png')
    save_score_dir = path_join(config['save_root'], 'FCN8s/scores')
    save_score_path = path_join(save_score_dir, '{}.npy')

    ## create directory
    if config['write_file']:
        create_dir(save_res_dir)
        create_dir(save_score_dir)

    ## load image set
    ids = textread(VOCopts['seg.imgsetpath'].format(config['imageset']))

    for i in range(1):
        #for i in range(len(ids)):
        log_inline('progress: {}/{} [{}]...'.format(i, len(ids), ids[i]))
        start = time.clock()

        # read image
        I = img_as_ubyte(imread(VOCopts['imgpath'].format(
            ids[i])))  # TODO does load correctly?
        #I = Image.open(VOCopts['imgpath'].format(ids[i]))
        input_data = preprocess_image(I, config['im_sz'])

        net.blobs['data'].reshape(1, *input_data.shape)
        net.blobs['data'].data[...] = input_data
        net.forward()
        cnn_output = net.blobs['upscore'].data[0]

        tr_result = cnn_output.transpose((1, 2, 0))
        score = tr_result[0:I.shape[0], 0:I.shape[1], :]
        result_seg = np.argmax(score, axis=2)
        #result_seg -= 1 # TODO necessary?

        if config['write_file']:
            imsave(save_res_path.format(ids[i]),
                   label2rgb(result_seg, colors=cmap))
            np.save(save_score_path.format(ids[i]), score)

        end = time.clock()
        print str(end - start) + " s"
def cache_FCN8s_results(config, VOCopts):
  log('start caching FCN-8s results and score')
  
  ## initialization
  cmap = scipy.io.loadmat(config['cmap'])['cmap']

  ## initialize caffe
  log('initializing caffe..')
  caffe.set_mode_gpu()
  caffe.set_device(config['gpuNum'])
  net = caffe.Net(config['Path.CNN.model_proto'], config['Path.CNN.model_data'], caffe.TEST)
  log('done')
  
  ## initialize paths
  save_res_dir = path_join(config['save_root'], 'FCN8s/results')
  save_res_path = path_join(save_res_dir, '{}.png')
  save_score_dir = path_join(config['save_root'], 'FCN8s/scores')
  save_score_path = path_join(save_score_dir, '{}.npy')
  
  ## create directory
  if config['write_file']:
    create_dir(save_res_dir)
    create_dir(save_score_dir)
  
  ## load image set
  ids = textread(VOCopts['seg.imgsetpath'].format(config['imageset']))
  
  for i in range(1):
  #for i in range(len(ids)):
      log_inline('progress: {}/{} [{}]...'.format(i, len(ids), ids[i]))
      start = time.clock()
  
      # read image
      I = img_as_ubyte(imread(VOCopts['imgpath'].format(ids[i]))) # TODO does load correctly?
      #I = Image.open(VOCopts['imgpath'].format(ids[i]))
      input_data = preprocess_image(I, config['im_sz']) 

      net.blobs['data'].reshape(1, *input_data.shape)
      net.blobs['data'].data[...] = input_data 
      net.forward()
      cnn_output = net.blobs['upscore'].data[0]

      tr_result = cnn_output.transpose((1,2,0))
      score = tr_result[0:I.shape[0], 0:I.shape[1], :]
      result_seg = np.argmax(score, axis=2)
      #result_seg -= 1 # TODO necessary?
      
      if config['write_file']:
        imsave(save_res_path.format(ids[i]), label2rgb(result_seg, colors=cmap))
        np.save(save_score_path.format(ids[i]), score)

      end = time.clock()
      print str(end - start) + " s"
Beispiel #7
0
def test():
    CLASSES = []
    label_map_path = '../models/labelmap.prototxt'

    with open(label_map_path) as f:
        lines = f.readlines()
    for x in range(3, len(lines), 5):
        CLASSES.append(
            ((lines[x].split(": "))[1]).replace("\"", "").replace("\n", ""))
    print(CLASSES)

    COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))

    # frame dimensions should be sqaure
    PREPROCESS_DIMS = (300, 300)
    DISPLAY_DIMS = (900, 900)

    # calculate the multiplier needed to scale the bounding boxes
    DISP_MULTIPLIER = DISPLAY_DIMS[0] // PREPROCESS_DIMS[0]

    # Load the model
    net = cv2.dnn.readNet('../models/no_bn.xml', '../models/no_bn.bin')

    # Specify target device
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)

    for filename in ["test1.png", "test2.jpg", "test3.jpg"]:

        image = cv2.imread(filename)
        origimg = np.copy(image)
        image = util.preprocess_image(image)

        #image = image.transpose((2, 0, 1))
        #blob = cv2.dnn.blobFromImage(image, size=PREPROCESS_DIMS)

        net.setInput(image)
        outputs = net.forward()

        box, conf, cls = util.postprocess(origimg, outputs)

        for i in range(len(box)):
            p1 = (box[i][0], box[i][1])
            p2 = (box[i][2], box[i][3])
            cv2.rectangle(origimg, p1, p2, (0, 255, 0))
            p3 = (max(p1[0], 15), max(p1[1], 15))
            title = "%s:%.2f" % (CLASSES[int(cls[i])], conf[i])
            cv2.putText(origimg, title, p3, cv2.FONT_ITALIC, 0.6, (0, 255, 0),
                        1)

        cv2.imwrite(filename.split(".")[0] + "SSD.jpg", origimg)
def sample_images(image_size):
    """Pull a random batch of images from FLAGS.data_dir containing TF record formatted ImageNet validation set
    Returns:
        ndarray of float32 with shape [FLAGS.batch_size, image_size, image_size, 3]
    """

    sample_file = random.choice(os.listdir(FLAGS.data_dir))
    dataset = tf.data.TFRecordDataset(os.path.join(FLAGS.data_dir, sample_file))
    dataset = dataset.map(lambda x: parse_example_proto(x)).shuffle(True).batch(FLAGS.batch_size)
    iterator = dataset.make_one_shot_iterator()
    next_element = iterator.get_next()
    with tf.Session() as sess:
        images, labels = sess.run(next_element)
        images = np.array([sess.run(preprocess_image(x, FLAGS.model, image_size)) for x in images])

    return images
Beispiel #9
0
def get_test_data(csv_path, data_path):
    test = pd.read_csv(csv_path, sep=';')
    X_test = []
    y_test = []

    i = 0
    for file_name, class_id in zip(list(test['Filename']),
                                   list(test['ClassId'])):
        img_path = os.path.join(data_path, file_name)
        X_test.append(preprocess_image(io.imread(img_path), IMG_SIZE))
        y_test.append(class_id)
        i = i + 1
        print('loaded image {}'.format(i))

    X_test = np.array(X_test)
    y_test = np.array(y_test)

    return X_test, y_test
Beispiel #10
0
 def train(self):
     # summary setting
     self.summary()
     
     # load train data list & load attribute data
     dataA_files = load_data_list(self.data_dir)
     dataB_files = np.copy(dataA_files)
     attr_names, attr_list = attr_extract(self.data_dir)
     
     # variable initialize
     self.sess.run(tf.global_variables_initializer())
     
     # load or not checkpoint
     if self.continue_train and self.checkpoint_load():
         print(" [*] before training, Load SUCCESS ")
     else:
         print(" [!] before training, no need to Load ")
     
     batch_idxs = len(dataA_files) // self.batch_size # 182599
     #train
     for epoch in range(self.epoch):
         np.random.shuffle(dataA_files)
         np.random.shuffle(dataB_files)
         
         for idx in tqdm(range(batch_idxs)):
             # 
             dataA_list = dataA_files[idx * self.batch_size : (idx+1) * self.batch_size]
             dataB_list = dataB_files[idx * self.batch_size : (idx+1) * self.batch_size]
             attrA_list = [attr_list[os.path.basename(val)] for val in dataA_list]
             attrB_list = [attr_list[os.path.basename(val)] for val in dataB_list]
             # get batch images and labels
             attrA, attrB = preprocess_attr(attr_names, attrA_list, attrB_list)
             imgA, imgB = preprocess_image(dataA_list, dataB_list, self.image_size)
             dataA, dataB = preprocess_input(imgA, imgB, attrA, attrB, self.image_size)
             
             # updatae G network
             feed = { self.real_A: dataA, self.real_B: dataB }
             fake_B, _, summary = self.sess.run([self.fake_B, self.g_optim, self.g_sum], 
                                        feed_dict = feed)
             
             #update D network
             feed = { self.real_B: dataB, self.fake_B_sample: fake_B }
             _, summary = self.sess.run([self.d_optim, self.d_sum])
    def test(self):
        # check if attribute available
        # binary_attrsでtagを指定しているので長さは同じに
        if not len(self.binary_attrs) == self.n_label:
            print(
                "binary_attr length is wrong! The length should be {}".format(
                    self.n_label))
            return

        # variable initialize
        self.sess.run(tf.global_variables_initializer())

        # load or not checkpoint
        if self.phase == 'test' and self.checkpoint_load():
            print(" [*] before training, Load SUCCESS ")
        else:
            print(" [!] before training, no need to Load ")

        # [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save
        # data_dirから適当なサンプルを十持ってきている
        # 音声データだから連続的に適当な範囲を持ってくる
        test_files = glob(os.path.join(self.data_dir, 'test', '*'))
        testA_list = random.sample(test_files, 10)

        # get batch images and labels
        #        self.attr_keys = ['Black_Hair','Blond_Hair','Brown_Hair', 'Male', 'Young','Mustache','Pale_Skin']
        attrA = [float(i) for i in list(self.binary_attrs)] * len(testA_list)
        imgA, _ = preprocess_image(testA_list,
                                   testA_list,
                                   self.image_size,
                                   phase='test')
        dataA, _ = preprocess_input(imgA, imgA, attrA, attrA, self.image_size,
                                    self.n_label)

        # generate fakeB
        # 生成結果はfake_Bの中
        feed = {self.real_A: dataA}
        fake_B = self.sess.run(self.fake_B, feed_dict=feed)

        # save samples
        test_file = os.path.join(self.test_dir, 'test.jpg')
        save_images(imgA, imgA, fake_B, self.image_size, test_file, num=10)
Beispiel #12
0
def get_training_data(data_path, num_classes, img_size):
    images = []
    labels = []

    all_image_paths = glob.glob(os.path.join(data_path, '*/*.ppm'))
    np.random.shuffle(all_image_paths)
    print(data_path)
    i = 0
    for image_path in all_image_paths:
        try:
            img = preprocess_image(io.imread(image_path), img_size)
            label = get_label_from_image_path(image_path, data_path)
            images.append(img)
            labels.append(label)
            print("load images: {}".format(i))
            i = i + 1
        except (IOError, OSError):
            print("failed to process {}".format(image_path))

    X = np.array(images, dtype='float32')
    y = np.eye(num_classes, dtype='uint8')[labels]

    return X, y
Beispiel #13
0
 def __getitem__(self, idx):
     if torch.is_tensor(idx):
         idx = idx.tolist()
     
     # Get image name
     idx, labels = self.df.values[idx]
     img_name = self.root_dir.format(idx)
     
     # Augmentation
     flip = False
     if self.training:
         flip = np.random.randint(2) == 1
     
     # Read image
     img0 = imread(img_name, True)
     img = preprocess_image(img0, flip=flip)
     img = np.rollaxis(img, 2, 0)
     
     # Get mask and regression maps
     #print("img_name: {}, labels = {}".format(img_name, labels))
     mask, regr = get_mask_and_regr(img0, labels, flip=False)
     regr = np.rollaxis(regr, 2, 0)
     
     return [img, mask, regr]
Beispiel #14
0
                       feature_module=model.layer4,
                       target_layer_names=["2"],
                       use_cuda=True)
    test_img_dir = os.path.join(cwd, 'test_image')
    GradCAM_dir = os.path.join(cwd, SAVED_NAME)
    if not os.path.isdir(GradCAM_dir):
        os.makedirs(GradCAM_dir)

    idx_to_class = {}
    class_names = os.listdir(os.path.join(cwd, 'data', 'train'))
    for idx, label in enumerate(class_names):
        idx_to_class[idx] = label
    print(class_names)
    print(idx_to_class)
    cnt = 1
    for image in os.listdir(test_img_dir):
        img = cv2.imread(os.path.join(test_img_dir, image), 1)
        # 예측한 클래스를 파일의 제목으로 지정
        predicted_class = predict(model, Image.fromarray(img))
        # predicted_class = "no_class"

        img = np.float32(cv2.resize(img, (224, 224))) / 255
        input = preprocess_image(img)
        target_index = None
        mask = grad_cam(input, target_index)
        cam = show_cam_on_image(img, mask)
        saved_name = os.path.join(GradCAM_dir,
                                  str(cnt) + "_" + predicted_class + ".jpg")
        cv2.imwrite(saved_name, np.uint8(255 * cam))
        cnt += 1
Beispiel #15
0
def DecoupledNet_inference(config):
    ## start DecoupledNet inference
    log('Start of DecoupledNet inference [{}]'.format(config['model_name']))

    ## initialization
    cmap = scipy.io.loadmat(config['cmap'])['cmap']

    ## initialize caffe
    log('Initializing caffe')
    caffe.set_mode_gpu()
    caffe.set_device(config['gpuNum'])
    net = caffe.Net(config['Path.CNN.model_proto'],
                    config['Path.CNN.model_data'], caffe.TEST)
    log('Initialization of caffe complete')

    ## initialize paths
    save_res_dir = path_join(config['save_root'], config['model_name'])
    save_res_path = path_join(save_res_dir, '{}.png')

    ## create directory
    if config['write_file']:
        create_dir(save_res_dir)

    log('Start generating result')
    log('Caffe model: {}'.format(config['Path.CNN.model_proto']))
    log('Caffe weight: {}'.format(config['Path.CNN.model_data']))

    ## read VOC2012 TEST image set
    ids = textread(VOCopts['seg.imgsetpath'].format(config['imageset']))

    for i in range(len(ids)):
        log_inline('{}/{} [{}]... '.format(i, len(ids), ids[i]))
        start = time.clock()

        # read image
        I = img_as_ubyte(imread(VOCopts['imgpath'].format(ids[i])))

        im_sz = max(I.shape[0], I.shape[1])
        offset = ((0, im_sz - I.shape[0]), (0, im_sz - I.shape[1]), (0, 0))
        caffe_im = np.pad(I, offset, 'constant', constant_values=(0))
        caffe_im = preprocess_image(caffe_im, config['im_sz'])
        label = np.zeros((config['num_classes'], 1, 1))

        net.blobs['data'].reshape(1, *caffe_im.shape)
        net.blobs['data'].data[...] = caffe_im
        net.blobs['cls-score-masked'].reshape(1, *label.shape)
        net.blobs['cls-score-masked'].data[...] = label
        net.forward()

        cls_score = net.blobs['cls-score-sigmoid'].data[0]

        score_map = np.zeros(
            (config['im_sz'], config['im_sz'],
             config['num_classes'] + 1))  # N classes + background

        ## compute bkg prob
        label = cls_score * (cls_score > config['thres'])

        net.blobs['cls-score-masked'].reshape(1, *label.shape)
        net.blobs['cls-score-masked'].data[...] = label
        net.forward()

        cls_score = net.blobs['cls-score-sigmoid'].data[0]
        seg_score = net.blobs['seg-score'].data[0].transpose((1, 2, 0))

        softmax_score = softmax(seg_score)
        score_map[:, :, 0] = softmax_score[:, :, 0]

        detected_classes = np.where(cls_score > config['thres'])[0]

        for j in detected_classes:
            label = np.zeros((config['num_classes'], 1, 1))
            label[j] = cls_score[j]
            net.blobs['cls-score-masked'].reshape(1, *label.shape)
            net.blobs['cls-score-masked'].data[...] = label
            net.forward()
            seg_score = net.blobs['seg-score'].data[0].transpose((1, 2, 0))

            softmax_score = softmax(seg_score)
            score_map[:, :, j + 1] = softmax_score[:, :, 1]

        cidx = np.hstack((0, detected_classes + 1))
        score_map[:, :, cidx] += np.sum(
            score_map, axis=2)[:, :, None] <= 0  # TODO what is it good for?

        norm_score_map = score_map / np.sum(score_map, axis=2)[:, :, None]
        resize_score_map = arrresize_ndim(
            norm_score_map, (im_sz, im_sz, config['num_classes'] + 1),
            'bilinear')  # N classes + background
        cropped_score_map = resize_score_map[0:I.shape[0], 0:I.shape[1], :]
        segmask = np.argmax(cropped_score_map, axis=2)

        if config['write_file']:
            imsave(save_res_path.format(ids[i]), label2rgb(segmask,
                                                           colors=cmap))

        log_basic('{}s\n'.format(time.clock() - start))
Beispiel #16
0
def get_require_direction(indir):
    base_folder = indir[:indir.rfind('/')]
    user_id = indir.split('/')[-1]
    outdir_name = 'tmp_out_' + user_id
    outdir = os.path.join(base_folder, outdir_name)

    raw_upload = os.path.join(config.face_upload_raw, user_id)
    if not os.path.exists(raw_upload):
        os.makedirs(raw_upload)
    # os.system("rm -rf " + outdir)
    if not os.path.exists(outdir):
        os.makedirs(outdir)
    if DEBUG:
        test_outdir = '/home/cuong/VNG/temp/face_system/data/test_data/test_result'
        tmp_test_outdir = '/home/cuong/VNG/temp/face_system/data/test_data/tmp_test_outdir'
        os.system("rm -rf " + test_outdir)
        os.system("mkdir " + test_outdir)
        os.system("rm -rf " + tmp_test_outdir)
        os.system("mkdir " + tmp_test_outdir)

    four_drawed_region_counter = [0] * 5
    four_drawed_region_files = dict()
    for i in range(5):
        four_drawed_region_files[i] = []
    vecto_length_each_region = dict()
    for i in range(5):
        vecto_length_each_region[i] = []
    list_images_file = glob.glob(os.path.join(indir, '*/*.jpg')) + glob.glob(
        os.path.join(indir, '*.jpg'))
    ignore_img_count = 0
    rotation_angle = None

    new_file_count = 0
    for image_file in list_images_file:
        filename = os.path.split(image_file)[-1]
        filename = filename[:filename.rfind('.')]
        postfix = filename.split('_')
        if len(postfix) >= 3 and postfix[-1] == 'processed':
            direction = int(postfix[-3])
            vector_length = float(postfix[-2])
            four_drawed_region_counter[direction] += 1
            four_drawed_region_files[direction].append(image_file)
            vecto_length_each_region[direction].append(vector_length)
            continue
        else:
            new_file_count += 1

        img = cv2.imread(image_file)
        img = cv2.resize(img, (960, 540))
        try:
            shutil.move(image_file, raw_upload)
        except:
            try:
                random_name = np.random.randint(0, 10000)
                cv2.imwrite(
                    os.path.join(raw_upload,
                                 str(random_name) + '.jpg'), img)
                os.remove(image_file)
            except:
                pass
        # padding_img = add_padding_to_img(img, 50)
        img = preprocess_image(img, image_size=config.MAX_IMAGE_SIZE)

        if rotation_angle is None:
            location, points, angle = detect_face_all_directions(
                img, MIN_SIZE, MAX_SIZE)
            rotation_angle = angle
            if rotation_angle is None:
                continue
            img = preprocess_image(img, rotation_angle=rotation_angle)
        else:
            img = preprocess_image(img, rotation_angle=rotation_angle)
            location, points = detect_face(img, MIN_SIZE, MAX_SIZE)

        if len(location) > 0:

            max_size = -1
            best_index = -1
            for i in range(len(location)):
                (l, t, r, b) = location[i]
                size = (r - l) * (b - t)
                if size > max_size:
                    max_size = size
                    best_index = i

            face_location = location[best_index]

            face = img[t:b, l:r]
            cv2.imwrite(image_file, face)
            if face.shape[0] > 0 and face.shape[1] > 0:
                is_low_quality = util.low_quality(face)
                if not is_low_quality:
                    (x1, y1), (x2,
                               y2), (x3,
                                     y3), (x4,
                                           y4), (x_nose,
                                                 y_nose) = get_point_coords(
                                                     points[:, best_index])

                    new_region, vector_length = evaluate_region_direction(
                        face_location, (x1, y1), (x2, y2), (x3, y3), (x4, y4),
                        (x_nose, y_nose), img)
                    four_drawed_region_counter[new_region] += 1
                    four_drawed_region_files[new_region].append(image_file)
                    vecto_length_each_region[new_region].append(vector_length)

                    if DEBUG:
                        basename = os.path.basename(image_file)
                        basename = basename[:basename.rfind('.')]
                        test_write_file = os.path.join(
                            test_outdir,
                            basename + '_' + str(new_region) + '.jpg')
                        cv2.imwrite(test_write_file, img)
                        tmp_test_write_file = os.path.join(
                            tmp_test_outdir,
                            basename + '_' + str(new_region) + '.jpg')
                        cv2.imwrite(tmp_test_write_file, img)
            else:
                # print(image_file)
                ignore_img_count += 1
        else:
            # print(image_file)
            ignore_img_count += 1
    # print 'file ignore = ', ignore_img_count
    # print 'new file =', new_file_count
    # print 'file consider = ', len(list_images_file) - ignore_img_count

    final_four_drawed_region_files = dict()
    for i in range(5):
        final_four_drawed_region_files[i] = []
    final_vecto_length_each_region = dict()
    for i in range(5):
        final_vecto_length_each_region[i] = []

    require_direction = []
    for i in [0, 1, 2, 3, 4]:
        if check_false_condition(i, four_drawed_region_counter):
            require_direction.append(i)
            end_index = four_drawed_region_counter[i]
        else:
            end_index = min(MIN_FACE_DIRECTION_DICT[i] + 4,
                            four_drawed_region_counter[i])
        if i == 0:
            reverse = False
        else:
            reverse = True
        file_and_vector_length = [
            [f, vector_length] for f, vector_length in zip(
                four_drawed_region_files[i], vecto_length_each_region[i])
        ]
        file_and_vector_length = sorted(file_and_vector_length,
                                        key=lambda element: element[1],
                                        reverse=reverse)
        if len(file_and_vector_length) > 0:
            for image_file_and_vector_length in file_and_vector_length[:
                                                                       end_index]:
                image_file, vector_length = image_file_and_vector_length
                final_four_drawed_region_files[i].append(image_file)
                final_vecto_length_each_region[i].append(vector_length)

    image_number = 0
    for i in range(5):
        # print 'Huong ' + str(i) + ': ', four_drawed_region_counter[i], len(final_four_drawed_region_files[i])
        image_number += len(final_four_drawed_region_files[i])
    # print 'image_number = ', image_number

    for i in range(5):
        for image_file, vector_length in zip(
                final_four_drawed_region_files[i],
                final_vecto_length_each_region[i]):
            basename = os.path.basename(image_file)
            basename = basename[:basename.rfind('.')]
            postfix = basename.split('_')
            if len(postfix) >= 3 and postfix[-1] == 'processed':
                write_file = os.path.join(outdir, basename + '.jpg')
            else:
                basename = basename + str(np.random.randint(0, 1000))
                write_file = os.path.join(
                    outdir, basename + '_' + str(i) + '_' +
                    str(vector_length)[:min(5, len(str(vector_length)))] +
                    '_processed' + '.jpg')
            img = cv2.imread(image_file)
            cv2.imwrite(write_file, img)

    if DEBUG:
        for i in range(5):
            for test_image_file in set(four_drawed_region_files[i]) - set(
                    final_four_drawed_region_files[i]):
                basename = os.path.basename(test_image_file)
                basename = basename[:basename.rfind('.')]
                os.rename(
                    os.path.join(test_outdir,
                                 basename + '_' + str(i) + '.jpg'),
                    os.path.join(test_outdir,
                                 basename + '_' + str(i) + 'x.jpg'))

    os.system("rm -rf " + indir)
    os.rename(outdir, indir)
    return require_direction
Beispiel #17
0
    def train(self):
        # summary setting
        self.summary()

        # load train data list & load attribute data
        dataA_files = load_data_list(self.data_dir)
        dataB_files = np.copy(dataA_files)
        self.attr_names, self.attr_list = attr_extract(self.data_dir)

        # variable initialize
        self.sess.run(tf.global_variables_initializer())

        # load or not checkpoint
        if self.continue_train and self.checkpoint_load():
            print(" [*] before training, Load SUCCESS ")
        else:
            print(" [!] before training, no need to Load ")

        batch_idxs = len(dataA_files) // self.batch_size  # 182599
        count = 0
        #train
        for epoch in range(self.epoch):
            # get lr_decay
            if epoch < self.epoch / 2:
                lr_decay = 1.0
            else:
                lr_decay = (self.epoch - epoch) / (self.epoch / 2)

            # data shuffle
            np.random.shuffle(dataA_files)
            np.random.shuffle(dataB_files)

            for idx in tqdm(range(batch_idxs)):
                count += 1
                #
                dataA_list = dataA_files[idx * self.batch_size:(idx + 1) *
                                         self.batch_size]
                dataB_list = dataB_files[idx * self.batch_size:(idx + 1) *
                                         self.batch_size]
                attrA_list = [
                    self.attr_list[os.path.basename(val)] for val in dataA_list
                ]
                attrB_list = [
                    self.attr_list[os.path.basename(val)] for val in dataB_list
                ]

                # get batch images and labels
                attrA, attrB = preprocess_attr(self.attr_names, attrA_list,
                                               attrB_list, self.attr_keys)
                imgA, imgB = preprocess_image(dataA_list,
                                              dataB_list,
                                              self.image_size,
                                              phase='train')
                dataA, dataB = preprocess_input(imgA, imgB, attrA, attrB,
                                                self.image_size, self.n_label)

                # generate fake_B
                feed = {self.real_A: dataA}
                fake_B = self.sess.run(self.fake_B, feed_dict=feed)

                # update D network for 5 times
                for _ in range(5):
                    epsilon = np.random.rand(self.batch_size, 1, 1, 1)
                    feed = {
                        self.fake_B_sample: fake_B,
                        self.real_B: dataB,
                        self.attr_B: np.array(attrB),
                        self.epsilon: epsilon,
                        self.lr_decay: lr_decay
                    }
                    _, d_loss, d_summary = self.sess.run(
                        [self.d_optim, self.d_loss, self.d_sum],
                        feed_dict=feed)

                # updatae G network for 1 time
                feed = {
                    self.real_A: dataA,
                    self.real_B: dataB,
                    self.attr_B: np.array(attrB),
                    self.lr_decay: lr_decay
                }
                _, g_loss, g_summary = self.sess.run(
                    [self.g_optim, self.g_loss, self.g_sum], feed_dict=feed)

                # summary
                self.writer.add_summary(g_summary, count)
                self.writer.add_summary(d_summary, count)

                # save checkpoint and samples
                if count % self.snapshot == 0:
                    print("Iter: %06d, g_loss: %4.4f, d_loss: %4.4f" %
                          (count, g_loss, d_loss))

                    # checkpoint
                    self.checkpoint_save(count)

                    # save samples (from test dataset)
                    self.sample_save(count)
def DecoupledNet_inference(config):
  ## start DecoupledNet inference
  log('Start of DecoupledNet inference [{}]'.format(config['model_name']))
  
  ## initialization
  cmap = scipy.io.loadmat(config['cmap'])['cmap']
  
  ## initialize caffe
  log('Initializing caffe')
  caffe.set_mode_gpu()
  caffe.set_device(config['gpuNum'])
  net = caffe.Net(config['Path.CNN.model_proto'], config['Path.CNN.model_data'], caffe.TEST)
  log('Initialization of caffe complete')
  
  ## initialize paths
  save_res_dir = path_join(config['save_root'], config['model_name'])
  save_res_path = path_join(save_res_dir, '{}.png')
  
  ## create directory
  if config['write_file']:
    create_dir(save_res_dir)
  
  log('Start generating result')
  log('Caffe model: {}'.format(config['Path.CNN.model_proto']))
  log('Caffe weight: {}'.format(config['Path.CNN.model_data']))
  
  ## read VOC2012 TEST image set
  ids = textread(VOCopts['seg.imgsetpath'].format(config['imageset']))

  for i in range(len(ids)):
    log_inline('{}/{} [{}]... '.format(i, len(ids), ids[i]))
    start = time.clock()
      
    # read image
    I = img_as_ubyte(imread(VOCopts['imgpath'].format(ids[i])))
      
    im_sz = max(I.shape[0], I.shape[1])
    offset = ((0, im_sz-I.shape[0]), (0, im_sz-I.shape[1]), (0, 0))
    caffe_im = np.pad(I, offset, 'constant', constant_values=(0))
    caffe_im = preprocess_image(caffe_im, config['im_sz'])
    label = np.zeros((config['num_classes'],1,1))

    net.blobs['data'].reshape(1, *caffe_im.shape)
    net.blobs['data'].data[...] = caffe_im 
    net.blobs['cls-score-masked'].reshape(1, *label.shape)
    net.blobs['cls-score-masked'].data[...] = label 
    net.forward()

    cls_score = net.blobs['cls-score-sigmoid'].data[0]
          
    score_map = np.zeros((config['im_sz'], config['im_sz'], config['num_classes']+1)) # N classes + background
      
    ## compute bkg prob
    label = cls_score * (cls_score > config['thres'])

    net.blobs['cls-score-masked'].reshape(1, *label.shape)
    net.blobs['cls-score-masked'].data[...] = label 
    net.forward()

    cls_score = net.blobs['cls-score-sigmoid'].data[0]
    seg_score = net.blobs['seg-score'].data[0].transpose((1,2,0))
            
    softmax_score = softmax(seg_score)
    score_map[:,:,0] = softmax_score[:,:,0]
          
    detected_classes = np.where(cls_score > config['thres'])[0]

    for j in detected_classes:
      label = np.zeros((config['num_classes'],1,1))
      label[j] = cls_score[j]
      net.blobs['cls-score-masked'].reshape(1, *label.shape)
      net.blobs['cls-score-masked'].data[...] = label
      net.forward()
      seg_score = net.blobs['seg-score'].data[0].transpose((1,2,0))
      
      softmax_score = softmax(seg_score)
      score_map[:,:,j+1] = softmax_score[:,:,1]
      
    cidx = np.hstack((0, detected_classes+1))
    score_map[:,:,cidx] += np.sum(score_map, axis=2)[:,:,None] <= 0 # TODO what is it good for?

    norm_score_map = score_map / np.sum(score_map, axis=2)[:,:,None]
    resize_score_map = arrresize_ndim(norm_score_map, (im_sz, im_sz, config['num_classes']+1), 'bilinear') # N classes + background
    cropped_score_map = resize_score_map[0:I.shape[0], 0:I.shape[1], :]
    segmask = np.argmax(cropped_score_map, axis=2)
                  
    if config['write_file']:
      imsave(save_res_path.format(ids[i]), label2rgb(segmask, colors=cmap))

    log_basic('{}s\n'.format(time.clock() - start))
Beispiel #19
0
 def __getitem__(self, i):
     image = Image.fromarray(
         imread(os.path.join(self.set_dir, "%s.jpg" % str(i).zfill(4))))
     if self.preprocess:
         image = preprocess_image(image)
     return image_to_tensor(image)
Beispiel #20
0
def get_require_direction(indir):
    base_folder = indir[:indir.rfind('/')]
    indir_name = indir[:indir.rfind('/')]
    outdir_name = 'tmp_out'
    outdir = os.path.join(base_folder, outdir_name)
    # os.system("rm -rf " + outdir)
    if not os.path.exists(outdir):
        os.makedirs(outdir)
    if DEBUG:
        test_outdir = '/home/cuong/VNG/temp/face_system/data/test_data/test_result'
        tmp_test_outdir = '/home/cuong/VNG/temp/face_system/data/test_data/tmp_test_outdir'
        os.system("rm -rf " + test_outdir)
        os.system("mkdir " + test_outdir)
        os.system("rm -rf " + tmp_test_outdir)
        os.system("mkdir " + tmp_test_outdir)

    four_drawed_region_counter = [0] * 5
    four_drawed_region_files = dict()
    for i in range(5):
        four_drawed_region_files[i] = []
    vecto_length_each_region = dict()
    for i in range(5):
        vecto_length_each_region[i] = []
    list_images_file = glob.glob(os.path.join(indir, '*/*.jpg')) + glob.glob(
        os.path.join(indir, '*.jpg'))
    ignore_img_count = 0
    rotation_angle = None

    new_file_count = 0
    for image_file in list_images_file:
        filename = os.path.split(image_file)[-1]
        filename = filename[:filename.rfind('.')]
        postfix = filename.split('_')
        if len(postfix) >= 3 and postfix[-1] == 'processed':
            direction = int(postfix[-3])
            vector_length = float(postfix[-2])
            four_drawed_region_counter[direction] += 1
            four_drawed_region_files[direction].append(image_file)
            vecto_length_each_region[direction].append(vector_length)
            continue
        else:
            new_file_count += 1

        img = cv2.imread(image_file)
        padding_img = add_padding_to_img(img, 50)
        if rotation_angle is None:
            location, points, angle = detect_face_all_directions(
                padding_img, MIN_SIZE, MAX_SIZE)
            rotation_angle = angle
            if rotation_angle is None:
                continue
            img = preprocess_image(img, rotation_angle=rotation_angle)
        else:
            img = preprocess_image(img, rotation_angle=rotation_angle)
            location, points = detect_face(padding_img, MIN_SIZE, MAX_SIZE)
        cv2.imwrite(image_file, img)

        if len(location) > 0:

            max_size = -1
            best_index = -1
            for i in range(len(location)):
                (l, t, r, b) = location[i]
                size = (r - l) * (b - t)
                if size > max_size:
                    max_size = size
                    best_index = i

            face_location = location[best_index]

            face = img[t:b, l:r]
            if face.shape[0] > 0 and face.shape[1] > 0:

                # (x1,y1), (x2,y2), (x3,y3), (x4, y4), (x_nose, y_nose) = util.get_point_coords(points[:, best_index])
                (x1, y1), (x2, y2), (x3,
                                     y3), (x4,
                                           y4), (x_nose,
                                                 y_nose) = get_point_coords(
                                                     points[:, best_index])

                new_region, vector_length = evaluate_region_direction(
                    face_location, (x1, y1), (x2, y2), (x3, y3), (x4, y4),
                    (x_nose, y_nose), img)
                four_drawed_region_counter[new_region] += 1
                four_drawed_region_files[new_region].append(image_file)
                vecto_length_each_region[new_region].append(vector_length)

                if DEBUG:
                    basename = os.path.basename(image_file)
                    basename = basename[:basename.rfind('.')]
                    test_write_file = os.path.join(
                        test_outdir, basename + '_' + str(new_region) + '.jpg')
                    cv2.imwrite(test_write_file, img)
                    tmp_test_write_file = os.path.join(
                        tmp_test_outdir,
                        basename + '_' + str(new_region) + '.jpg')
                    cv2.imwrite(tmp_test_write_file, img)
            else:
                print(image_file)
                ignore_img_count += 1
        else:
            print(image_file)
            ignore_img_count += 1
    print 'file ignore = ', ignore_img_count
    print 'new file =', new_file_count
    print 'file consider = ', len(list_images_file) - ignore_img_count

    final_four_drawed_region_files = dict()
    for i in range(5):
        final_four_drawed_region_files[i] = []
    final_vecto_length_each_region = dict()
    for i in range(5):
        final_vecto_length_each_region[i] = []

    require_direction = []
    for i in [0, 1, 2, 3, 4]:
        if check_false_condition(i, four_drawed_region_counter):
            require_direction.append(i)
            end_index = four_drawed_region_counter[i]
        else:
            end_index = min(MIN_FACE_DIRECTION_DICT[i] + 4,
                            four_drawed_region_counter[i])
        if i == 0:
            reverse = False
        else:
            reverse = True
        file_and_vector_length = [
            [f, vector_length] for f, vector_length in zip(
                four_drawed_region_files[i], vecto_length_each_region[i])
        ]
        file_and_vector_length = sorted(file_and_vector_length,
                                        key=lambda element: element[1],
                                        reverse=reverse)
        if len(file_and_vector_length) > 0:
            for image_file_and_vector_length in file_and_vector_length[:
                                                                       end_index]:
                image_file, vector_length = image_file_and_vector_length
                final_four_drawed_region_files[i].append(image_file)
                final_vecto_length_each_region[i].append(vector_length)

    image_number = 0
    for i in range(5):
        print 'Huong ' + str(i) + ': ', four_drawed_region_counter[i], len(
            final_four_drawed_region_files[i])
        image_number += len(final_four_drawed_region_files[i])
    print 'image_number = ', image_number

    for i in range(5):
        for image_file, vector_length in zip(
                final_four_drawed_region_files[i],
                final_vecto_length_each_region[i]):
            basename = os.path.basename(image_file)
            basename = basename[:basename.rfind('.')]
            postfix = basename.split('_')
            if len(postfix) >= 3 and postfix[-1] == 'processed':
                write_file = os.path.join(outdir, basename + '.jpg')
            else:
                write_file = os.path.join(
                    outdir, basename + '_' + str(i) + '_' +
                    str(vector_length)[:min(5, len(str(vector_length)))] +
                    '_processed' + '.jpg')
            img = cv2.imread(image_file)
            cv2.imwrite(write_file, img)

    if DEBUG:
        for i in range(5):
            for test_image_file in set(four_drawed_region_files[i]) - set(
                    final_four_drawed_region_files[i]):
                basename = os.path.basename(test_image_file)
                basename = basename[:basename.rfind('.')]
                os.rename(
                    os.path.join(test_outdir,
                                 basename + '_' + str(i) + '.jpg'),
                    os.path.join(test_outdir,
                                 basename + '_' + str(i) + 'x.jpg'))
    '''

	remain_region_files = []
	remain_vector_length = []

	for i in range(5):
		for f, vector_length in zip(four_drawed_region_files[i], vecto_length_each_region[i]):
			if f not in final_four_drawed_region_files[i]:
				remain_region_files.append(f)
				remain_vector_length.append(f)

	add_final_four_drawed_region_files = []
	file_and_vector_length = [[f, vector_length] for f, vector_length in zip(remain_region_files, remain_vector_length)]
	file_and_vector_length = sorted(file_and_vector_length, key=lambda element:element[1], reverse=True)
	if len(file_and_vector_length) > 0:
		for image_file_and_vector_length in file_and_vector_length[:min(80 - image_number, len(file_and_vector_length))]:
			image_file = image_file_and_vector_length[0]
			add_final_four_drawed_region_files.append(image_file)

	for image_file in add_final_four_drawed_region_files:
		basename = os.path.basename(image_file)
		basename = basename[:basename.rfind('.')]
		write_file = os.path.join(outdir, basename  + '_' +str(i) +'.jpg')
		img = cv2.imread(image_file)
		cv2.imwrite(write_file ,img)
	#	new_write_file = glob.glob(os.path.join(test_outdir, basename) + '*')[0]
	# 	not_extend_write_file = new_write_file[:new_write_file.rfind('.')]
	# 	os.rename(new_write_file, not_extend_write_file +'o.jpg')

	for i in range(5):
		not_satify_set = set(four_drawed_region_files[i]) - set(final_four_drawed_region_files[i]) - set(add_final_four_drawed_region_files)
		for test_image_file in not_satify_set:
			basename = os.path.basename(test_image_file)
			basename = basename[:basename.rfind('.')]
			# new_write_file = glob.glob(os.path.join(test_outdir, basename) + '*')[0]
			# writefile_basename = os.path.basename(new_write_file)
			# writefile_basename = writefile_basename[:writefile_basename.rfind('x.')]
			# os.remove(os.path.join(tmp_test_outdir, writefile_basename)  +'.jpg')
	
	print 'added image number = ', len(add_final_four_drawed_region_files) 
	print 'final image_number = ', image_number + len(add_final_four_drawed_region_files) 
	
	'''

    os.system("rm -rf " + indir)
    os.rename(outdir, indir)
    return require_direction