def create_model( input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2, weights_path="keras_yolo3/model_data/yolo_weights.h5", ): """create the training model""" 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, 2: 8}[l], w // {0: 32, 1: 16, 2: 8}[l], num_anchors // 3, num_classes + 5, ) ) for l in range(3) ] model_body = yolo_body(image_input, num_anchors // 3, num_classes) print( "Create 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 darknet53 body or freeze all but 3 output layers. num = (185, len(model_body.layers) - 3)[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.5, }, )([*model_body.output, *y_true]) model = Model([model_body.input, *y_true], model_loss) return model
def create_model(input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2, weights_path='keras_yolo3/model_data/yolo_weights.h5'): '''create the training model Parameters: input_shape = [416,416] num_class = 1 ''' 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, 2: 8}[l], w // {0: 32, 1: 16, 2: 8}[l], \ num_anchors // 3, num_classes + 5)) for l in range(3)] model_body = yolo_body(image_input, num_anchors // 3, num_classes) # get yolo body print('Create 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 darknet53 body or freeze all but 3 output layers. num = (185, len(model_body.layers) - 3)[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.5})( [*model_body.output, *y_true]) model = Model([model_body.input, *y_true], model_loss) return model
def create_model(is_tiny, input_shape, anchors, n_classes, load_pretrained=True, freeze_body=2, weights_path='model/keras_yolo3/model_data/yolo_weights.h5'): K.clear_session() # get a new session img = Input(shape=(None, None, 3)) h, w = input_shape n_anchors = len(anchors) if not is_tiny: y_true = [Input(shape=(h//{0:32, 1:16, 2:8}[l], w//{0:32, 1:16, 2:8}[l], \ n_anchors//3, n_classes+5)) for l in range(3)] model_body = yolo_body(img, n_anchors // 3, n_classes) ignore_thresh = 0.5 else: # 'tiny' y_true = [Input(shape=(h//{0:32, 1:16}[l], w//{0:32, 1:16}[l],\ n_anchors//2, n_classes+5)) for l in range(2)] model_body = tiny_yolo_body(img, n_anchors // 2, n_classes) ignore_thresh = 0.7 print( f'Create YOLOv3 model with {n_anchors} anchors and {n_classes} classes' ) if load_pretrained: model_body.load_weights(weights_path, by_name=True, skip_mismatch=True) print(f'Load weights from {weights_path}') if freeze_body in [1, 2]: # Freeze darknet53 body or freeze all but 3 output layers. if not is_tiny: num = (185, len(model_body.layers) - 3)[freeze_body - 1] else: num = (20, len(model_body.layers) - 2)[freeze_body - 1] for i in range(num): model_body.layers[i].trainable = False print( f'Freeze the first {num} layers of total {model_body.layers} layers.' ) model_loss = Lambda(yolo_loss, output_shape=(1, ), name='yolo_loss', arguments={ 'anchors': anchors, 'num_classes': n_classes, 'ignore_thresh': ignore_thresh })([*model_body.output, *y_true]) model = Model([model_body.input, *y_true], model_loss) return model
def generate(self): model_path = 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 create_model(input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2, weights_path='model_data/yolo_weights.h5'): '''create the training model''' 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, 2:8}[l], w//{0:32, 1:16, 2:8}[l], \ num_anchors//3, num_classes+5)) for l in range(3)] model_body = yolo_body(image_input, num_anchors//3, num_classes) print('Create 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 darknet53 body or freeze all but 3 output layers. num = (185, len(model_body.layers)-3)[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))) # get output of second last layers and create bottleneck model of it out1=model_body.layers[246].output out2=model_body.layers[247].output out3=model_body.layers[248].output bottleneck_model = Model([model_body.input, *y_true], [out1, out2, out3]) # create last layer model of last layers from yolo model in0 = Input(shape=bottleneck_model.output[0].shape[1:].as_list()) in1 = Input(shape=bottleneck_model.output[1].shape[1:].as_list()) in2 = Input(shape=bottleneck_model.output[2].shape[1:].as_list()) last_out0=model_body.layers[249](in0) last_out1=model_body.layers[250](in1) last_out2=model_body.layers[251](in2) model_last=Model(inputs=[in0, in1, in2], outputs=[last_out0, last_out1, last_out2]) model_loss_last =Lambda(yolo_loss, output_shape=(1,), name='yolo_loss', arguments={'anchors': anchors, 'num_classes': num_classes, 'ignore_thresh': 0.5})( [*model_last.output, *y_true]) last_layer_model = Model([in0,in1,in2, *y_true], model_loss_last) model_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss', arguments={'anchors': anchors, 'num_classes': num_classes, 'ignore_thresh': 0.5})( [*model_body.output, *y_true]) model = Model([model_body.input, *y_true], model_loss) return model, bottleneck_model, last_layer_model