def __init__(self, args):
self.colorImage = None
self.img = None
self.pilImg = None
self.yolo = YOLO(**vars(args))
self.publishers = []
self.callback_list = []
self.detection_info_msg = detection_info()
self.pub_detection = rospy.Publisher("/detection_info_publisher", detection_info)
self.pub_color_image = rospy.Publisher("/detection_color", Image)
self.pub_color_info = rospy.Publisher("/detection_color_info", CameraInfo)
self.pub_depth_image = rospy.Publisher("/detection_depth", Image)
self.pub_depth_info = rospy.Publisher("/detection_depth_info", CameraInfo)
#self.publishers[0] = rospy.Publisher("/detection_info_publisher", detection_info)
#self.publishers[1] = rospy.Publisher("/detection_color", Image)
#self.publishers[2] = rospy.Publisher("/detection_color_info", CameraInfo)
#self.publishers[3] = rospy.Publisher("/detection_depth", Image)
#self.publishers[4] = rospy.Publisher("/detection_depth_info", CameraInfo)
self.bridge = CvBridge()
#self.image_sub = rospy.Subscriber("/kinect2/qhd/image_color_rect", Image, self.callback)
self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.video = cv2.VideoWriter("/home/erlendb/Programmering/PCL/kinect_ws/test.avi", self.fourcc, 30, (960, 540))
self.running = None
#FPS variables
self.accum_time = 0
self.curr_fps = 0
self.prev_time = timer()
self.fps = "FPS: ??"
def process(path_to_image, out_file):
""" Apply detection and classification ML model to the input image IN and stores the result to
output file OUT.
"""
from keras_yolo3.yolo import YOLO
from PIL import Image
# Create an instance of YOLO. In fact, its name is YOLO but this implementation already contains
# the custom network for classification, hence it returns a image already with the classification!
yolo_model = YOLO()
# Notice that there will be some warnings displayed regarding instantiating YOLO, but it's not
# important by now, it should work fine
# Load image
image = Image.open(path_to_image)
# Apply network to image
image_result, result_list = yolo_model.detect_image(image)
# Save the generated image on same directory, with name: "result_image.jpg"
print("***")
print("Saving image to: '{}'".format(out_file))
try:
image_result.save(out_file)
print("Success! Image saved at: {}".format(out_file))
except Exception as e:
print(
"An error occurred while trying to save image to '{}': {}".format(
out_file, str(e)))
def __init__(self):
min_confidence = 0.25
is_tiny = False
if is_tiny and anchors_path:
anchors_path = os.path.join(
os.path.dirname(anchors_path), "yolo-tiny_anchors.txt"
)
anchors_path = os.path.join(src_path, "keras_yolo3", "model_data", "yolo_anchors.txt")
anchors = get_anchors(anchors_path)
# define YOLO detector
self.yolo = YOLO(
**{
"model_path": model_weights,
"anchors_path": anchors_path,
"classes_path": model_classes,
"score": min_confidence,
"gpu_num": 0,
"model_image_size": (416, 416),
}
)
# labels to draw on images
class_file = open(model_classes, "r")
self.input_labels = [line.rstrip("\n") for line in class_file.readlines()]
def detect_object(imageFolder='imagesToDetect/', postfix=""):
gpu_options = tf.compat.v1.GPUOptions(allow_growth=True)
session = tf.compat.v1.InteractiveSession(config=tf.compat.v1.ConfigProto(
gpu_options=gpu_options))
"""
Calls the YOLO face detector on a folder and saves results to detectedImages folder
Args:
imageFolder: string
folder where the images to detect are stored
postfix: string
appends string to filenames
Returns:
detections: a list of bounding boxes in format [filename,[(xmin,ymin,xmax,ymax,class_id,confidence]]
"""
save_img = True #always save the images for now
#keeping the output folder static for time being
save_img_path = 'boxedImages/'
#get detection output folder from params
detect_path = imageFolder
#make the yolo model
yolo = YOLO()
# list for min
detections = []
#iterate over all images in detect folder, try to open image and detect
for img_path in os.listdir('imagesToDetect'):
try:
image = Image.open(detect_path + img_path)
if image.mode != "RGB":
image = image.convert("RGB")
image_array = np.array(image)
# thrown if file can't be opened, return None if this is the case
except:
print("File Open Error! Try again!")
return None
# make Prediction using yolo network
prediction, new_image = yolo.detect_image(image)
# add faces detected to be returned
detections.append([img_path, prediction])
# save image in output folder
img_out = postfix.join(os.path.splitext(os.path.basename(img_path)))
if save_img:
new_image.save(os.path.join(save_img_path, img_out))
session.close()
return detections
def __init__(self):
self.depth_estimator = Depth(path['FCRN'])
self.detector = YOLO(path['YOLO'], path['YOLO_anchor'], path['YOLO_classes'])
#self.segmentator = KittiSeg(default_run=path['KITTI_MODEL'], runs_dir=path['KITTI_RUNS'], hype_path=path['KITTI_HYPES'], data_dir=path['KITTI_DATA_DIR'])
self.zebra_detector = Zebra()
self.traffic_light_pool = LightPool()
self.obstacle_pool = Obstacles()
self.state = 'LIGHT_WAIT'
self.alert = None
self.zebra_contours = []
self.is_stable = False
"""
def __init__(self):
# Yolo setup
self.yolo = YOLO(
**{
"model_path": CONFIG["model_path"],
"anchors_path": CONFIG["anchors_path"],
"classes_path": CONFIG["classes_path"],
"score": CONFIG["score"],
"gpu_num": CONFIG["gpu_num"],
"model_image_size": (416, 416),
})
# Make a dataframe for the prediction outputs
self.out_df = pd.DataFrame(columns=OUT_COLS)
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 arg_params_yolo():
# class YOLO defines the default value, so suppress any default HERE
parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
# Command line options
parser.add_argument('-w',
'--path_weights',
type=str,
help='path to model weight file')
parser.add_argument('-a',
'--path_anchors',
type=str,
help='path to anchor definitions')
parser.add_argument('-c',
'--path_classes',
type=str,
help='path to class definitions')
parser.add_argument('--nb_gpu',
type=int,
help='Number of GPU to use',
default=str(YOLO.get_defaults("nb_gpu")))
parser.add_argument('-o',
'--path_output',
required=False,
type=str,
default='.',
help='path to the output directory')
return parser
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 main(args):
yolo = YOLO(**{'model_path': args.model_path,
'anchors_path': args.anchors,
'classes_path': args.yolo_classes_path,
'score': args.score,
'gpu_num': args.gpu_num,
'model_image_size': (416, 416),
})
if not os.path.exists(args.result_path):
os.mkdir(args.result_path)
if args.mode.lower() == 'detect':
img_list = list(Path(args.input_path).iterdir())
elapsed_t = 0
img_cnt = 0
for img_path in img_list:
pred, _, t = detect_logo_only(str(img_path), yolo,
save_img=args.save_img,
save_img_path=args.result_path,
crop=args.crop)
'''
for p in pred:
x1 = p[0]
y1 = p[1]
x2 = p[2]
y2 = p[3]
roi = img[y1:y2, x1:x2]
'''
if t == 0:
continue
elapsed_t += t
img_cnt += 1
print('\nDetecting Logos from images completed! It tooks {:.3f} FPS'.format(img_cnt/elapsed_t))
elif args.mode.lower() == 'recog':
model_preproc, params = initialize(yolo, args.recog_model,
args.DB_path)
img_list = list(Path(args.input_path).iterdir())
elapsed_t = 0
img_cnt = 0
for img_path in img_list:
_, _, t = detect_and_match(str(img_path), model_preproc, params,
save_img=args.save_img, save_img_path=args.result_path)
if t == 0:
continue
elapsed_t += t
img_cnt += 1
print('\nDetecting and Recognizing Logos from images completed! It tooks {:.3f} FPS'.format(img_cnt/elapsed_t))
else: # args.model == 'DB'
construct_DB(args.DB_list, args.recog_model, args.DB_path)
print("Done...!")
def parser():
parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
'''
Command line options
'''
parser.add_argument(
'--model', type=str,
help='path to model weight file, default ' + YOLO.get_defaults("model_path")
)
parser.add_argument(
'--anchors', type=str,
help='path to anchor definitions, default ' + YOLO.get_defaults("anchors_path")
)
parser.add_argument(
'--classes', type=str,
help='path to class definitions, default ' + YOLO.get_defaults("classes_path")
)
parser.add_argument(
'--gpu_num', type=int,
help='Number of GPU to use, default ' + str(YOLO.get_defaults("gpu_num"))
)
parser.add_argument(
'--image', default=True, action="store_true",
help='Image detection mode, will ignore all positional arguments'
)
'''
Command line positional arguments -- for video detection mode
'''
parser.add_argument(
"--input", nargs='?', type=str,required=False,default='./path2your_video',
help = "Video input path"
)
parser.add_argument(
"--output", nargs='?', type=str, default="",
help = "[Optional] Video output path"
)
return parser.parse_args()
def init_yolo(model_weights, anchors_path, score, gpu_num, model_image_size):
yolo = YOLO(
**{
"model_path": model_weights,
"anchors_path": anchors_path,
"classes_path": classes_path,
"score": score,
"gpu_num": gpu_num,
"model_image_size": model_image_size,
})
print("MODELSERVER: Model initialized")
return yolo
def classify_baby_yolo(baby_url):
img_data = requests.get(baby_url).content
image = Image.open(io.BytesIO(img_data))
print('image loaded!', image.size)
from keras_yolo3.yolo import YOLO
yolo_obj = YOLO()
print('YOLO loaded!')
image_post_yolo, result = yolo_obj.detect_image(image)
print('YOLO applied!', result)
print(result[0])
#result[0].show()
'''imgs = []
for obj in result[1]:
if obj['predicted_class'] == 'person' and obj['score']>0.33:
border = tuple(obj['box']) # left, up, right, bottom
img_cropped = image.crop(border)
imgs.append(img_cropped)
print('Babies found: ',len(imgs))'''
import keras
keras.backend.clear_session()
return result
def __init__(self):
#TODO load classifier
model_data_path = os.path.dirname(os.path.abspath(__file__))
self.detector = YOLO(anchors_path=model_data_path +
'/keras_yolo3/model_data/tiny_yolo_anchors.txt',
model_path=model_data_path +
'/model_data/tiny_yolo.h5',
class_name='traffic light',
height=240,
width=120)
model_name = model_data_path + '/model_data/lenet_traffic_light.h5'
f = h5py.File(model_name, mode='r')
model_version = f.attrs.get('keras_version')
keras_version = str(keras.__version__).encode('utf8')
if model_version != keras_version:
print('You are using Keras version ', keras_version,
', but the model was built using ', model_version)
self.classifier = load_model(
model_name, custom_objects={'Normalization': Normalization()})
global graph
graph = tf.get_default_graph()
def main(args):
ic = Receiver(args)
rospy.init_node("Receiver", anonymous=True)
try:
ic.start()
except KeyboardInterrupt:
print("Shutting down")
print(YOLO.get_defaults("model_path"))
def _main():
with open(DATASET_DIR + "annotations_train.json") as file:
annotations = json.load(file)
model_path = "/floyd/input/yolo_weights/trained_weights_final.h5"
anchors_path = "keras_yolo3/model_data/tiny_yolo_anchors.txt"
classes_path = "keras_yolo3/model_data/vrd_classes.txt"
detector = YOLO(model_path=model_path,
anchors_path=anchors_path,
classes_path=classes_path)
classifier = PredicateClassifier()
train_classifier(annotations, detector, classifier)
def _main(image):
model_path = DATASET_DIR + "trained_weights_final.h5"
anchors_path = "keras_yolo3/model_data/tiny_yolo_anchors.txt"
classes_path = "keras_yolo3/model_data/vrd_classes.txt"
detector = YOLO(model_path=model_path,
anchors_path=anchors_path,
classes_path=classes_path)
classifier = PredicateClassifier(save_path=DATASET_DIR + "pred_cls.ckpt")
annotations = evaluate_relations(image, detector, classifier)
print(annotations)
return annotations
def listener():
global image
yolo = YOLO(**vars(FLAGS))
rospy.init_node('yolo', anonymous=True)
pub = rospy.Publisher('yolo_res', String, queue_size=10)
rospy.Subscriber("/camera/rgb/image_raw", msg.Image, callback)
print("Waiting ...")
while True:
if image != None:
res, rimage = yolo.detect_image(image)
rimage.show()
image = None
message = "{ "
for obj in res:
top, left, bottom, right, label, score = obj
message = message + "{top : " + str(top) + ", left : " + str(
left) + ", bottom : " + str(bottom)
message = message + ", right : " + str(
right) + ", label : " + str(label) + ", score : " + str(
score) + "},"
message = message[:-1]
message = message + "}"
rospy.loginfo(message)
pub.publish(message)
def _main(path_weights, path_anchors, path_classes, path_output, nb_gpu=0, **kwargs):
yolo = YOLO(weights_path=path_weights, anchors_path=path_anchors,
classes_path=path_classes, nb_gpu=nb_gpu)
logging.info('Start image/video processing..')
if 'path_image' in kwargs:
paths_img = expand_file_paths(kwargs['path_image'])
for path_img in tqdm.tqdm(paths_img, desc='images'):
logging.debug('processing: "%s"', path_img)
predict_image(yolo, path_img, path_output)
if 'path_video' in kwargs:
paths_vid = expand_file_paths(kwargs['path_image'])
for path_vid in tqdm.tqdm(paths_vid, desc='videos'):
logging.debug('processing: "%s"', path_vid)
predict_video(yolo, path_vid, path_output)
def __init__(self,
n_predicates,
n_object_categories,
yolo_model=YOLO_PATH,
yolo_anchors=ANCHORS_PATH,
yolo_classes=CLASSES_PATH,
target_update_frequency=10000,
discount_factor=0.9,
learning_rate=0.001,
max_memory=2048,
batch_size=64,
save_path="./checkpoints/VRL.ckpt"):
"""Build online and target networks, initialize replay memory."""
# RL hyperparameters
self.target_update_frequency = target_update_frequency
self.discount_factor = discount_factor
# initialize object detector
self.detector = YOLO(model_path=yolo_model,
anchors_path=yolo_anchors,
classes_path=yolo_classes)
# build network
network_args = [n_predicates, n_object_categories, learning_rate]
tf.reset_default_graph()
self.DQN = DQN(*network_args, save_path=self.save_path)
self.target_DQN = DQN(*network_args, var_scope="target_DQN")
# initialize experience replay buffer
self.memory = Memory(max_memory)
self.batch_size = batch_size
# initialize tensorflow session
self.sess = tf.Session()
if os.path.isfile(self.save_path + ".index"):
self.DQN.load(self.sess)
else:
self.sess.run(tf.global_variables_initializer())
self._update_target_network()
class Yolo():
def __init__(self):
# Yolo setup
self.yolo = YOLO(
**{
"model_path": CONFIG["model_path"],
"anchors_path": CONFIG["anchors_path"],
"classes_path": CONFIG["classes_path"],
"score": CONFIG["score"],
"gpu_num": CONFIG["gpu_num"],
"model_image_size": (416, 416),
})
# Make a dataframe for the prediction outputs
self.out_df = pd.DataFrame(columns=OUT_COLS)
def predict(self, img_path, out_dir):
class_file = open(CONFIG["classes_path"], "r")
input_labels = [line.rstrip("\n") for line in class_file.readlines()]
self.out_df = pd.DataFrame(columns=OUT_COLS)
total = len(os.listdir(img_path))
for i, filename in enumerate(os.listdir(img_path)):
print("\rDetecting image ", i, " of ", total, end="", flush=True)
image = open_image(os.path.join(img_path, filename))
prediction, predict_image = self.yolo.detect_image(image)
y_size, x_size, _ = np.array(predict_image).shape
for single_prediction in prediction:
self.out_df = self.out_df.append(
pd.DataFrame(
[[
filename,
img_path.rstrip("\n"),
] + single_prediction + [x_size, y_size]],
columns=OUT_COLS,
))
self.out_df.to_csv(out_dir, index=False)
def _main(path_weights,
path_anchors,
path_classes,
nb_gpu,
path_output=None,
images=False,
videos=False,
stream=False):
assert any([images, videos, stream]), 'nothing to do...'
yolo = YOLO(path_weights, path_anchors, path_classes, nb_gpu=nb_gpu)
if images:
# Image detection mode, disregard any remaining command line arguments
logging.info('Image detection mode')
loop_detect_image(yolo, path_output)
elif videos:
logging.info('Video detection mode')
loop_detect_video(yolo, path_output)
elif stream:
logging.info('Video detection mode')
loop_detect_stream(yolo, path_output)
def __init__(self, package_name, **kwargs):
"""
Init package attributes here
:param kwargs: config params
:return:
"""
if not os.path.isdir('model_data'):
os.makedirs('model_data')
# download artifacts
package = dl.packages.get(package_name=package_name)
if not os.path.isfile('model_data/yolo.h5'):
artifact = package.project.artifacts.get(package_name=package_name,
artifact_name='yolo.h5')
artifact.download(local_path='model_data')
if not os.path.isfile('model_data/yolo_anchors.txt'):
artifact = package.project.artifacts.get(
package_name=package_name, artifact_name='yolo_anchors.txt')
artifact.download(local_path='model_data')
if not os.path.isfile('model_data/coco_classes.txt'):
artifact = package.project.artifacts.get(
package_name=package_name, artifact_name='coco_classes.txt')
artifact.download(local_path='model_data')
if not os.path.isfile('model_data/mars-small128.pb'):
artifact = package.project.artifacts.get(
package_name=package_name, artifact_name='mars-small128.pb')
artifact.download(local_path='model_data')
###############
# load models #
###############
self.yolo = YOLO()
self.encoder = gdet.create_box_encoder('model_data/mars-small128.pb',
batch_size=1)
self.graph = tf.get_default_graph()
save_img = not FLAGS.no_save_img
input_image_paths = GetFileList(FLAGS.input_images)
print('Found {} input images: {}...'.format(len(input_image_paths), [ os.path.basename(f) for f in input_image_paths[:5]]))
output_path = FLAGS.output
if not os.path.exists(output_path):
os.makedirs(output_path)
# define YOLO detector
yolo = YOLO(**{"model_path": FLAGS.model_path,
"anchors_path": FLAGS.anchors_path,
"classes_path": FLAGS.classes_path,
"score" : FLAGS.score,
"gpu_num" : FLAGS.gpu_num,
"model_image_size" : (416, 416),
}
)
# Make a dataframe for the prediction outputs
out_df = pd.DataFrame(columns=['image', 'image_path','xmin', 'ymin', 'xmax', 'ymax', 'label','confidence','x_size','y_size'])
# labels to draw on images
class_file = open(FLAGS.classes_path, 'r')
input_labels = [line.rstrip('\n') for line in class_file.readlines()]
print('Found {} input labels: {}...'.format(len(input_labels), input_labels))
start = timer()
text_out = ''
from keras_yolo3.yolo import YOLO
from PIL import Image
from libs.utils import *
import cv2
import numpy as np
import yaml
import serial
import time
# Read configuration
with open("config.yml", 'r') as ymlfile:
config = yaml.load(ymlfile)
yolo = YOLO()
bt = serial.Serial('/dev/rfcomm0', 19200)
while True:
in_data = bt.read_until().decode()
if in_data[:-2] == "a":
bt.write("b".encode())
break
print("Connected!")
try:
# Input video stream
vid = cv2.VideoCapture(0)
if not vid.isOpened():
raise IOError("Couldn't open webcam or video")
video_size = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)))
class YoloModel:
def __init__(self):
min_confidence = 0.25
is_tiny = False
if is_tiny and anchors_path:
anchors_path = os.path.join(
os.path.dirname(anchors_path), "yolo-tiny_anchors.txt"
)
anchors_path = os.path.join(src_path, "keras_yolo3", "model_data", "yolo_anchors.txt")
anchors = get_anchors(anchors_path)
# define YOLO detector
self.yolo = YOLO(
**{
"model_path": model_weights,
"anchors_path": anchors_path,
"classes_path": model_classes,
"score": min_confidence,
"gpu_num": 0,
"model_image_size": (416, 416),
}
)
# labels to draw on images
class_file = open(model_classes, "r")
self.input_labels = [line.rstrip("\n") for line in class_file.readlines()]
def __del__(self):
# Close the current yolo session
self.yolo.close_session()
def detect(self, img, show_stats=True):
start = timer()
prediction, detected_img = self.yolo.detect_image(img, show_stats=show_stats)
detected_img = np.asarray(detected_img)
y_size, x_size, _ = detected_img.shape
# Make a dataframe for the prediction outputs
out_df = pd.DataFrame(
columns=[
"xmin",
"ymin",
"xmax",
"ymax",
"label",
"confidence",
"x_size",
"y_size",
]
)
for single_prediction in prediction:
out_df = out_df.append(
pd.DataFrame(
[
single_prediction
+ [x_size, y_size]
],
columns=[
"xmin",
"ymin",
"xmax",
"ymax",
"label",
"confidence",
"x_size",
"y_size",
],
)
)
end = timer()
if show_stats:
print(f"Yolo v3 detection took {end-start:.2f} s")
return out_df, detected_img
def model(data):
return YOLO(**data)
import cv2
import numpy as np
from keras_yolo3.yolo import YOLO
from tf_crnn.tf_predict import CRNN
crnn = CRNN()
yolo3 = YOLO()
def ocr_predict(image):
text1 = []
text3 = []
detect_img = image.copy()
for label, score, img, box in yolo3.get_text_box_area(image):
cv2.rectangle(detect_img, box[0], box[1], (0, 0, 255), thickness=2)
if label == 'text1':
text1.append((score, img))
elif label == 'text3':
text3.append((score, img))
text1 = sorted(text1, key=lambda x: -x[0])[:1]
text3 = sorted(text3, key=lambda x: -x[0])[:2]
predict = crnn.predict(np.asarray(text1 + text3)[:, 1])
return predict, detect_img
if __name__ == '__main__':
while True:
command = input('Please input image path: ')
if command == 'quit':
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'))
from skimage.io import imread
from evaluate import evaluate_relations
from keras_yolo3.yolo import YOLO
from relation_model.predicate_classifier import PredicateClassifier
ALLOWED_EXTENSIONS = set(['jpg', 'jpeg'])
app = Flask(__name__)
model_path = "/floyd/input/weights/trained_weights_final.h5"
anchors_path = "keras_yolo3/model_data/tiny_yolo_anchors.txt"
classes_path = "keras_yolo3/model_data/vrd_classes.txt"
detector = YOLO(model_path=model_path,
anchors_path=anchors_path,
classes_path=classes_path)
classifier = PredicateClassifier()
@app.route('/', methods=["GET", "POST"])
def evaluate():
"""Take the input image and style transfer it."""
# check if the post request has the file part
input_file = request.files.get('file')
if not input_file:
return BadRequest("File not present in request")
filename = secure_filename(input_file.filename)
if filename == '':
