def initialize(self):
print('Initialization in progress...!\n')
start = time.time()
yolo = YOLO(**{"model_path": self.model_path,
"anchors_path": self.anchors,
"classes_path": self.yolo_classes_path,
"score" : self.confidence,
"gpu_num" : self.gpu_num,
"model_image_size" : (416, 416),
})
# load pre-processed features database
features, _, _ = load_features(self.recog_model)
with open(self.classes_path, 'rb') as f:
#img_input, input_labels = pickle.load(f)
input_feats, input_labels = pickle.load(f)
# load pre-trained recognition model
model, preprocessed, input_shape = load_extractor_model(self.recog_model)
my_preprocess = lambda x: preprocessed(pad_image(x, input_shape))
#input_feat = extract_features(img_input, model, my_preprocess)
sim_cutoff, (bins, cdf_list) = similarity_cutoff(input_feats, features, 0.95)
print("Done...! It tooks {:.3f} mins\n".format((time.time() - start)/60))
self.model_preproc = (yolo, model, my_preprocess)
self.params = (input_feats, sim_cutoff, bins, cdf_list, input_labels)
return True
def initialize(filename):
print('Initialization in progress...!\n')
start = time.time()
yolo = YOLO(
**{
"model_path":
'./model/keras_yolo3/model_data/yolo_weights_logos.h5',
"anchors_path": './model/keras_yolo3/model_data/yolo_anchors.txt',
"classes_path": './data/preprocessed/classes.txt',
"score": 0.05,
"gpu_num": 1,
"model_image_size": (416, 416),
})
# get Inception/VGG16 model and flavor from filename
model_name, flavor = model_flavor_from_name(filename)
## load pre-processed features database
features, brand_map, input_shape = load_features(filename)
## load inception model
model, preprocess_input, input_shape = load_extractor_model(
model_name, flavor)
my_preprocess = lambda x: preprocess_input(utils.pad_image(x, input_shape))
with open('./data/preprocessed/trained_brands.pkl', 'rb') as f:
img_input, input_labels = pickle.load(f)
(img_input, feat_input, sim_cutoff,
(bins, cdf_list)) = load_brands_compute_cutoffs(img_input,
(model, my_preprocess),
features, sim_threshold)
print('Done! It tooks {:.2f} mins.\n'.format((time.time() - start) / 60))
return (yolo, model, my_preprocess), (feat_input, sim_cutoff, bins,
cdf_list, input_labels)
def initialize(yolo, model_name, DB_path):
print("\n\nInitialization in progress...!\n")
start = time.time()
# load pre-processed features database
features, _, _ = load_features(model_name)
with open(args.classes_path, 'rb') as f:
#img_input, input_labels = pickle.load(f)
input_feats, input_labels = pickle.load(f)
# load pre-trained recognition model
model, preprocessed, input_shape = load_extractor_model(model_name)
my_preprocess = lambda x: preprocessed(pad_image(x, input_shape))
#input_feats = extract_features(img_input, model, my_preprocess)
sim_cutoff, (bins, cdf_list) = similarity_cutoff(input_feats, features, 0.95)
print("Done...! It tooks {:.3f} mins\n".format((time.time() - start)/60))
return (yolo, model, my_preprocess), (input_feats, sim_cutoff, bins, cdf_list, input_labels)
def main(args):
img_input, input_feats, input_labels = [], [], []
model, preprocessed, input_shape = load_extractor_model(args.recog_model)
my_preprocess = lambda x: preprocessed(pad_image(x, input_shape))
cat_path = list(Path(args.roi_path).iterdir())
for cat in tqdm(cat_path):
label = os.path.basename(str(cat))
imgs = list(Path(cat).iterdir())
for img in imgs:
img = cv2.imread(str(img))
if img is None:
continue
img_input.append(img)
input_labels.append(label)
input_feats = extract_features(img_input, model, my_preprocess)
with open(os.path.join(args.result_path, 'trained_brands.pkl'), 'wb') as f:
pickle.dump((input_feats, input_labels), f)
print('Done...!')
def test(filename):
"""
Test function: runs pipeline for a small set of input images and input
brands.
"""
yolo = YOLO(**{"model_path": 'keras_yolo3/yolo_weights_logos.h5',
"anchors_path": 'keras_yolo3/model_data/yolo_anchors.txt',
"classes_path": 'data_classes.txt',
"score" : 0.05,
"gpu_num" : 1,
"model_image_size" : (416, 416),
}
)
save_img_logo, save_img_match = True, True
test_dir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'data/test')
# get Inception/VGG16 model and flavor from filename
model_name, flavor = model_flavor_from_name(filename)
## load pre-processed features database
features, brand_map, input_shape = load_features(filename)
## load inception model
model, preprocess_input, input_shape = load_extractor_model(model_name, flavor)
my_preprocess = lambda x: preprocess_input(utils.pad_image(x, input_shape).astype(np.float32))
## load sample images of logos to test against
input_paths = ['test_batman.jpg', 'test_robin.png', 'test_lexus.png', 'test_champions.jpg',
'test_duff.jpg', 'test_underarmour.jpg', 'test_golden_state.jpg']
input_labels = [ s.split('test_')[-1].split('.')[0] for s in input_paths]
input_paths = [os.path.join(test_dir, 'test_brands/', p) for p in input_paths]
# compute cosine similarity between input brand images and all LogosInTheWild logos
( img_input, feat_input, sim_cutoff, (bins, cdf_list)
) = load_brands_compute_cutoffs(input_paths, (model, my_preprocess), features, sim_threshold, timing=True)
images = [ p for p in os.listdir(os.path.join(test_dir, 'sample_in/')) if p.endswith('.jpg')]
images_path = [ os.path.join(test_dir, 'sample_in/',p) for p in images]
start = timer()
times_list = []
img_size_list = []
candidate_len_list = []
for i, img_path in enumerate(images_path):
outtxt = img_path
## find candidate logos in image
prediction, image = detect_logo(yolo, img_path, save_img = True,
save_img_path = test_dir, postfix='_logo')
## match candidate logos to input
outtxt, times = match_logo(image, prediction, (model, my_preprocess),
outtxt, (feat_input, sim_cutoff, bins, cdf_list, input_labels),
save_img = save_img_match, save_img_path=test_dir, timing=True)
img_size_list.append(np.sqrt(np.prod(image.size)))
candidate_len_list.append(len(prediction))
times_list.append(times)
end = timer()
print('Processed {} images in {:.1f}sec - {:.1f}FPS'.format(
len(images_path), end-start, len(images_path)/(end-start)
))
fig, axes = plt.subplots(1,2, figsize=(9,4))
for iax in range(2):
for i in range(len(times_list[0])):
axes[iax].scatter([candidate_len_list, img_size_list][iax], np.array(times_list)[:,i])
axes[iax].legend(['read img','get box','get features','match','draw','save'])
axes[iax].set(xlabel=['number of candidates', 'image size'][iax], ylabel='Time [sec]')
plt.savefig(os.path.join(test_dir, 'timing_test.png'))
})
input_paths = sorted(FLAGS.input_brands)
# labels to draw on images - could also be read from filename
input_labels = [
os.path.basename(s).split('test_')[-1].split('.')[0]
for s in input_paths
]
# get Inception/VGG16 model and flavor from filename
model_name, flavor = model_flavor_from_name(FLAGS.features)
## load pre-processed LITW features database
features, brand_map, input_shape = load_features(FLAGS.features)
## load inception model
model, preprocess_input, input_shape = load_extractor_model(
model_name, flavor)
my_preprocess = lambda x: preprocess_input(
utils.pad_image(x, input_shape))
# compute cosine similarity between input brand images and all LogosInTheWild logos
(img_input, feat_input, sim_cutoff,
(bins,
cdf_list)) = load_brands_compute_cutoffs(input_paths,
(model, my_preprocess),
features, sim_threshold)
start = timer()
# cycle trough input images, look for logos and then match them against inputs
text_out = ''
for i, img_path in enumerate(FLAGS.input_images):
text = img_path
path-to-file2.jpg xmin,ymin,xmax,ymax,class_id[,confidence]
Returns:
features: (n_logos, n_features)-shaped np.array of features
all_logos: list of np.arrays for each logo
brand_map: brand id (in range 0,...,n_brands) for each extracted logo
"""
all_logos, brand_map = extract_litw_logos(filename)
features = utils.features_from_image(all_logos, model, my_preprocess)
return features, all_logos, brand_map
if __name__ == '__main__':
model, preprocess_input, input_shape = utils.load_extractor_model('InceptionV3', flavor=0)
my_preprocess = lambda x: preprocess_input(utils.pad_image(x, input_shape))
print('Extracting features from LogosInTheWild database (train set) - this will take a while (~5 minutes)')
features, all_logos, brand_map = extract_litw_features('data_all_train.txt', model, my_preprocess)
print('Processed {} logos, transformed into feature vectors'.format(len(features)))
# save inception features at default size 299*299
utils.save_features('./model_poi/inception_logo_features.hdf5', features, brand_map, input_shape)
# save features for Inception with smaller input: 200 instead of 299 - last layer is 4*4 instead of 8*8
# Extract features at last layer as well as after last 3 inception blocks (mixed9,8,7)
input_shape = (200,200,3)
new_preprocess = lambda x: preprocess_input(utils.pad_image(x, input_shape))
def test(filename, timestamp):
"""
Test function: runs pipeline for a small set of input images and input
brands.
"""
yolo = YOLO(
**{
"model_path":
'./model/keras_yolo3/model_data/yolo_weights_logos.h5',
"anchors_path": './model/keras_yolo3/model_data/yolo_anchors.txt',
"classes_path": './data/preprocessed/classes.txt',
"score": 0.05,
"gpu_num": 1,
"model_image_size": (416, 416),
})
save_img_logo, save_img_match = True, True
test_dir = os.path.join(os.path.dirname(__file__), 'data/test')
# get Inception/VGG16 model and flavor from filename
model_name, flavor = model_flavor_from_name(filename)
## load pre-processed features database
features, brand_map, input_shape = load_features(filename)
## load inception model
model, preprocess_input, input_shape = load_extractor_model(
model_name, flavor)
my_preprocess = lambda x: preprocess_input(utils.pad_image(x, input_shape))
images = [p for p in os.listdir(os.path.join(test_dir, 'input/'))
] #if p.endswith('.jpg')]
images_path = [os.path.join(test_dir, 'input/', p) for p in images]
#with open('./data/preprocessed/input_paths.pkl', 'r') as f:
# input_paths = pickle.load(f)
#(img_input, feat_input, sim_cutoff, (bins, cdf_list)) = load_brands_compute_cutoffs(
# input_paths, (model, my_preprocess), features, sim_threshold)
start = timer()
img_size_list = []
candidate_len_list = []
for i, img_path in enumerate(images_path):
outtxt = img_path
## find candidate logos in image
prediction, image = detect_logo(yolo,
img_path,
save_img=True,
save_img_path=test_dir,
postfix='_logo')
## match candidate logos to input
#logo_txt = match_logo(image, prediction, (model, my_preprocess),
# outtxt, (feat_input, sim_cutoff, bins, cdf_list, input_labels),
# save_img = True, save_img_path=test_dir, timing=True)
img_size_list.append(np.sqrt(np.prod(image.size)))
candidate_len_list.append(len(prediction))
#times_list.append(times)
end = timer()
print('Processed {} images in {:.1f}sec - {:.1f}FPS'.format(
len(images_path), end - start,
len(images_path) / (end - start)))
print('Timestamp : {timestamp}')
"""
all_logos, brand_map = extract_litw_logos(filename)
# for i in all_logos:
# print(np.array(i).shape)
# logo.append(cv2.resize(i,(128,128)))
print("**************************************")
print(np.array(all_logos).shape)
features = utils.features_from_image(all_logos, model, my_preprocess)
return features, all_logos, brand_map
if __name__ == '__main__':
model, preprocess_input, input_shape = utils.load_extractor_model('NASNet',
flavor=0)
my_preprocess = lambda x: preprocess_input(utils.pad_image(x, input_shape))
print(
'Extracting features from LogosInTheWild database (train set) - this will take a while (~5 minutes)'
)
features, all_logos, brand_map = extract_litw_features(
'data_all_train.txt', model, my_preprocess)
print('Processed {} logos, transformed into feature vectors'.format(
len(features)))
# # save inception features at default size 299*299
# utils.save_features('inception_logo_features.hdf5', features, brand_map, input_shape)
#
# # save features for Inception with smaller input: 200 instead of 299 - last layer is 4*4 instead of 8*8
# # Extract features at last layer as well as after last 3 inception blocks (mixed9,8,7)
