def create_tiny_model(input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2,
weights_path='model_data/tiny_yolo_weights.h5'):
'''create the training model, for Tiny YOLOv3'''
K.clear_session() # get a new session
image_input = Input(shape=(None, None, 3))
h, w = input_shape
num_anchors = len(anchors)
y_true = [Input(shape=(h//{0:32, 1:16}[l], w//{0:32, 1:16}[l], \
num_anchors//2, num_classes+5)) for l in range(2)]
model_body = tiny_yolo_body(image_input, num_anchors//2, num_classes)
print('Create Tiny YOLOv3 model with {} anchors and {} classes.'.format(num_anchors, num_classes))
if load_pretrained:
model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)
print('Load weights {}.'.format(weights_path))
if freeze_body in [1, 2]:
# Freeze the darknet body or freeze all but 2 output layers.
num = (20, len(model_body.layers)-2)[freeze_body-1]
for i in range(num): model_body.layers[i].trainable = False
print('Freeze the first {} layers of total {} layers.'.format(num, len(model_body.layers)))
model_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss',
arguments={'anchors': anchors, 'num_classes': num_classes, 'ignore_thresh': 0.7})(
[*model_body.output, *y_true])
model = Model([model_body.input, *y_true], model_loss)
return model
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors==6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num>=2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
def get_model(cls, model_path='../model'):
modelpath = os.path.join(model_path, 'YOLOv3_608_cl2_ep013_val_loss51.h5')
class_names = cls._get_class()
anchors = cls._get_anchors()
# Load model, or construct model and load weights.
num_anchors = len(anchors)
num_classes = len(class_names)
is_tiny_version = num_anchors == 6 # default setting
cls.yolo_model = tiny_yolo_body(Input(shape=(None, None, 3)), num_anchors // 2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None, None, 3)), num_anchors // 3, num_classes)
cls.yolo_model.load_weights(modelpath) # make sure model, anchors and classes match
return True
def generate(self):
# 加载模型
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith(
'.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors == 6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except:
self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
self.yolo_model.load_weights(
self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(
self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num >= 2:
self.yolo_model = multi_gpu_model(self.yolo_model,
gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output,
self.anchors,
len(self.class_names),
self.input_image_shape,
score_threshold=self.score,
iou_threshold=self.iou)
return boxes, scores, classes
def get_model(cls, model_path='../model'):
cls.IDvalue = 0 # Reset Object ID
cls.Mem_IDvalue = 0 # Reset Memory Object ID
cls.trackers = cv2.MultiTracker_create()#Multi Object tracker init
modelpath = os.path.join(model_path, 'YOLOv3_608_cl10_val_loss71.h5')
class_names = cls._get_class()
anchors = cls._get_anchors()
# Load model, or construct model and load weights.
num_anchors = len(anchors)
num_classes = len(class_names)
is_tiny_version = num_anchors == 6 # default setting
cls.yolo_model = tiny_yolo_body(Input(shape=(None, None, 3)), num_anchors // 2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None, None, 3)), num_anchors // 3, num_classes)
cls.yolo_model.load_weights(modelpath) # make sure model, anchors and classes match
return True
def __init__(self):
# Input parameters
anchors_path = 'model_data/tiny_yolo_anchors.txt'
classes_path = 'model_data/coco_classes.txt'
model_path = 'model_data/yolov3-tiny.h5'
score_threshold = 0.3
iou_threshold = 0.45
self.SELECTED_CLASS = 9
# Start session
self.sess = K.get_session()
# Preprare model
anchors = get_anchors(anchors_path)
classes = get_class(classes_path)
self.model= tiny_yolo_body(Input(shape=(None,None,3)), len(anchors)//2, len(classes))
self.model.load_weights(model_path)
# Prepare placeholders
self.input_image_shape = K.placeholder(shape=(2, ))
self.ph_boxes, self.ph_scores, self.ph_classes = yolo_eval(self.model.output, anchors, len(classes), (416,416),
score_threshold=score_threshold, iou_threshold=iou_threshold)
def __init__(self, score_threshold=0.3, iou_threshold=0.45):
# Input parameters
anchors_path = './data/tiny_yolo_anchors.txt'
classes_path = './data/coco_classes.txt'
model_path = './data/yolov3-tiny.h5'
self.SELECTED_CLASS = 9
# Start session
config = tf.ConfigProto(gpu_options=tf.GPUOptions(
per_process_gpu_memory_fraction=0.5))
config.gpu_options.allow_growth = True
self.graph = Graph()
with self.graph.as_default():
self.session = tf.Session(config=config)
with self.session.as_default():
self.sess = K.get_session()
self.K_learning_phase = K.learning_phase()
# Preprare model
anchors = get_anchors(anchors_path)
classes = get_class(classes_path)
self.model = tiny_yolo_body(Input(shape=(None, None, 3)),
len(anchors) // 2, len(classes))
self.model.load_weights(model_path)
# Prepare placeholders
self.input_image_shape = K.placeholder(shape=(2, ))
self.ph_boxes, self.ph_scores, self.ph_classes = yolo_eval(
self.model.output,
anchors,
len(classes), (416, 416),
score_threshold=score_threshold,
iou_threshold=iou_threshold)
