def draw(model_body, class_names, anchors, image_data, image_set='val', weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' if image_set == 'train': image_data = np.array([ np.expand_dims(image, axis=0) for image in image_data[:int(len(image_data) * .9)] ]) elif image_set == 'val': image_data = np.array([ np.expand_dims(image, axis=0) for image in image_data[int(len(image_data) * .9):] ]) elif image_set == 'all': image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) else: ValueError("draw argument image_set must be 'train', 'val', or 'all'") # model.load_weights(weights_name) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=0.07, iou_threshold=0) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. if not os.path.exists(out_path): os.makedirs(out_path) for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, class_names, out_scores) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path, str(i) + '.png'))
def get_bounding_boxes(self, image): image_shape = (416, 416) resized_image = image.resize(tuple(image_shape), PIL.Image.BICUBIC) image_data = np.array(resized_image, dtype='float32') image_data /= 255. image_data = np.expand_dims(image_data, 0) sess = K.get_session() out_boxes, out_scores, out_classes = sess.run( [self.boxes, self.scores, self.classes], feed_dict={ self.yolo_model_body.input: image_data, self.yolo_input_image_shape: [image_data.shape[1], image_data.shape[2]], K.learning_phase(): 0 }) # Convert pred on 416 to actual image size resized_boxes = out_boxes / 416 w, h = image.size box_resize_dim = [h, w, h, w] resized_boxes = resized_boxes * box_resize_dim orig_image_data = np.array(image, dtype='float32') orig_image_with_boxes = draw_boxes(orig_image_data, resized_boxes, out_classes, class_names, out_scores, "rand") return resized_boxes, out_classes, orig_image_with_boxes
def draw(model_body, class_names, anchors, partition, images_path, image_set='validation', weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' # load validation data hdf5_file_images = h5py.File(images_path, "r") image_data = hdf5_file_images["images"][partition[image_set], ...] hdf5_file_images.close() image_data = np.expand_dims(image_data, axis=1) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=0.5, iou_threshold=0.5) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. if not os.path.exists(out_path): os.makedirs(out_path) for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0].astype(np.uint8) * 255, out_boxes, out_classes, class_names, out_scores) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path, str(i) + '.png'))
def get_bounding_boxes(yolo_model_body, boxes, scores, classes, yolo_input_image_shape, img_path, class_names, out_path, save=True): image_shape = (416, 416) image = PIL.Image.open(img_path) resized_image = image.resize(tuple(image_shape), PIL.Image.BICUBIC) image_data = np.array(resized_image, dtype='float32') image_data /= 255. image_data = np.expand_dims(image_data, 0) sess = K.get_session() out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ yolo_model_body.input: image_data, yolo_input_image_shape: [image_data.shape[1], image_data.shape[2]], K.learning_phase(): 0 }) _, tail = ntpath.split(img_path) tail = os.path.splitext(tail)[0] print("file Name:" + tail) orig_img_name = out_path + "\\" + tail + ".jpg" # image_with_boxes = draw_boxes(image_data[0], out_boxes, out_classes, class_names, out_scores,orig_img_name) # Convert pred on 416 to actual image size resized_boxes = out_boxes / 416 w, h = image.size box_resize_dim = [h, w, h, w] resized_boxes = resized_boxes * box_resize_dim orig_image_data = np.array(image, dtype='float32') orig_image_with_boxes = draw_boxes(orig_image_data, resized_boxes, out_classes, class_names, out_scores, orig_img_name) # Save the image: if save: orig_image = PIL.Image.fromarray(orig_image_with_boxes) orig_image.save(orig_img_name) return resized_boxes, out_classes
def draw(model_body, class_names, anchors, image_data, image_set='val', weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' if image_set == 'train': image_data = np.array([np.expand_dims(image, axis=0) for image in image_data[:int(len(image_data)*.9)]]) elif image_set == 'val': image_data = np.array([np.expand_dims(image, axis=0) for image in image_data[int(len(image_data)*.9):]]) elif image_set == 'all': image_data = np.array([np.expand_dims(image, axis=0) for image in image_data]) else: ValueError("draw argument image_set must be 'train', 'val', or 'all'") # model.load_weights(weights_name) print(image_data.shape) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval( yolo_outputs, input_image_shape, score_threshold=0.07, iou_threshold=0) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. if not os.path.exists(out_path): os.makedirs(out_path) for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, class_names, out_scores) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path,str(i)+'.png'))
def draw(model_body, class_names, anchors, image_data, weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' # model.load_weights(weights_name) print(image_data.shape) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval( yolo_outputs, input_image_shape, score_threshold=0.07, iou_threshold=0.0) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. if not os.path.exists(out_path): os.makedirs(out_path) for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, class_names, out_scores) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path,str(i)+'.png')) # To display (pauses the program): plt.imshow(image_with_boxes, interpolation='nearest') plt.show()
def draw(out_boxes, out_scores, out_classes, image, name, class_names, display=True): if len(out_boxes) != 0: # np.swapaxes(image, 0, 1) # opencv convention is to access image as (row, column) image = draw_boxes(image, out_boxes, out_classes, class_names, scores=out_scores, rectify=False) # np.swapaxes(image, 0, 1) if display: cv2.imshow(name, image) cv2.waitKey(3) return image
def draw(boxes, scores, classes, model_body, class_names, image_data): ''' Draw bounding boxes on image datac ''' global input_image_shape, imageQueue, q global buffer global next_route, IsCalling, Mob_Name, ans, music_state, direc, arrived, speed image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) sess = K.get_session() # TODO: Remove dependence on Tensorflow session. for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [416, 416], K.learning_phase(): 0 #testing phase }) if AR_Mode: classes_to_be_shown = average_classes(out_classes) buffer[6], buffer[7], buffer[8], buffer[9], buffer[10], buffer[ 11] = WriteBuffer(out_boxes, out_classes, classes_to_be_shown) image_with_boxes = DrawDirection(buffer, IsFrame=True, FramePath=None, Frame=image_data[i][0]) image_with_boxes = image_with_boxes.resize((416, 416), Image.ANTIALIAS) cv2.imwrite( 'Video_Images/{}.jpg'.format(q), cv2.cvtColor(np.array(image_with_boxes), cv2.COLOR_BGR2RGB)) else: image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, class_names, out_scores) imageQueue.put(np.array(image_with_boxes)) #queue image_with_boxes to imageQueue. return out_classes
def draw(self, test_model_path=None, image_set='validation', weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): """ Draw bounding boxes on image data """ if test_model_path is None: self.model_body.load_weights(weights_name) else: self.model_body = load_model(test_model_path) if self.overfit_single_image: partition_eval = self.partition["train"][[0, 0]] else: partition_eval = self.partition[image_set] # load validation data # only annotate 100 images max if len(partition_eval) > 100: partition_eval = np.random.choice(partition_eval, (100, )) files_to_load = self.file_list[partition_eval] print(files_to_load.shape) image_data = [np.load(file)['image'] for file in files_to_load] image_data = process_data(image_data) image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) # Create output variables for prediction. yolo_outputs = yolo_head(self.model_body.output, self.anchors, len(self.class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=0.5, iou_threshold=0.5) # Run prediction images. sess = K.get_session() if not os.path.exists(out_path): os.makedirs(out_path) for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ self.model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, self.class_names, out_scores) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path, str(i) + '.tif'))
def draw(model_body, class_names, anchors, image_data, image_data_original, truth_boxes, image_set='val', weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' image_size_orig = tuple(reversed( image_data_original.shape[1:3])) # width, height image_data_size = tuple(reversed(image_data.shape[1:3])) # width, height print(image_size_orig) print(image_data_size) plotter = BoxPlotter(image_size_orig) if image_set == 'train': image_data = np.array([ np.expand_dims(image, axis=0) for image in image_data[:int(len(image_data) * .9)] ]) elif image_set == 'val': image_data = np.array([ np.expand_dims(image, axis=0) for image in image_data[int(len(image_data) * .9):] ]) elif image_set == 'all': image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) else: ValueError("draw argument image_set must be 'train', 'val', or 'all'") # model.load_weights(weights_name) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=0.07, iou_threshold=0.5) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. if not os.path.exists(out_path): os.makedirs(out_path) for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_size_orig[1], image_size_orig[0]], # height, width K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) # outboxes = [ymin, xmin, ymax, xmax] out_boxes2 = out_boxes[:, [1, 0, 3, 2]] image = image_data_original[i] image = image / np.max(image) * 255 image = image.astype(np.uint8) y = plotter.package_data(truth_boxes[i][:, 1:], truth_boxes[i][:, 0].astype(np.int)) yhat = plotter.package_data(out_boxes2, out_classes.astype(np.int), out_scores) plotter.comparison(y, yhat, image) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data_original[i], out_boxes, out_classes, class_names, out_scores) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path, str(i) + '.png')) # To display (pauses the program): # plt.imshow(image_with_boxes, interpolation='nearest') # plt.show() input("Enter for next image")
def predict_draw(model_body, class_names, anchors, img_path, weights_name='trained_stage_3_best.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' head, tail = ntpath.split(img_path) image = PIL.Image.open(img_path) resized_image = image.resize(tuple(image_shape), PIL.Image.BICUBIC) image_data = np.array(resized_image, dtype='float32') image_data /= 255. image_data = np.expand_dims(image_data, 0) print(image_data.shape) # model.load_weights(weights_name) # print(image_data.shape) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, max_boxes=3, score_threshold=.7, iou_threshold=0.05) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. logging = TensorBoard() if not os.path.exists(out_path): os.makedirs(out_path) #for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data, input_image_shape: [image_data.shape[1], image_data.shape[2]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[0], out_boxes, out_classes, class_names, out_scores, out_path + "\\" + tail) # Save the image: if save_all or (len(out_boxes) > 0): image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join(out_path, tail + '.png')) # To display (pauses the program): plt.imshow(image_with_boxes, interpolation='nearest') plt.show()
def _main(args): voc_path = os.path.expanduser(args.data_path) #classes_path = os.path.expanduser(args.classes_path) anchors_path = os.path.expanduser(args.anchors_path) #with open(classes_path) as f: # class_names = f.readlines() #class_names = [c.strip() for c in class_names] class_names = ['circle', 'square'] if os.path.isfile(anchors_path): with open(anchors_path) as f: anchors = f.readline() anchors = [float(x) for x in anchors.split(',')] anchors = np.array(anchors).reshape(-1, 2) else: anchors = YOLO_ANCHORS ''' file load '' voc = h5py.File(voc_path, 'r') image = PIL.Image.open(io.BytesIO(voc['train/images'][28])) orig_size = np.array([image.width, image.height]) orig_size = np.expand_dims(orig_size, axis=0) # Image preprocessing. image = image.resize((416, 416), PIL.Image.BICUBIC) image_data = np.array(image, dtype=np.float) image_data /= 255. ''' # Generate shape w/pymrt image_data = np.empty((2, 416, 416, 3), dtype=np.float) circ = geo.circle(shape=(416, 416), radius=40, position=0.5) image_data[0, :, :, 0] = circ image_data[0, :, :, 1] = circ image_data[0, :, :, 2] = circ sq = geo.square(shape=(416, 416), side=40, position=0.5) image_data[1, :, :, 0] = sq image_data[1, :, :, 1] = sq image_data[1, :, :, 2] = sq #image = image_data orig_size = np.array([416, 416]) # Box preprocessing. # Original boxes stored as 1D list of class, x_min, y_min, x_max, y_max. ## boxes = voc['train/boxes'][28] boxes = np.asarray([[0, 168, 168, 248, 248], [1, 168, 168, 248, 248]]) boxes = boxes.reshape((-1, 5)) # Get extents as y_min, x_min, y_max, x_max, class for comparision with # model output. boxes_extents = boxes[:, [2, 1, 4, 3, 0]] # Get box parameters as x_center, y_center, box_width, box_height, class. boxes_xy = 0.5 * (boxes[:, 3:5] + boxes[:, 1:3]) boxes_wh = boxes[:, 3:5] - boxes[:, 1:3] boxes_xy = boxes_xy / orig_size # convert to relative coordinates boxes_wh = boxes_wh / orig_size boxes = np.concatenate((boxes_xy, boxes_wh, boxes[:, 0:1]), axis=1) # Precompute detectors_mask and matching_true_boxes for training. # Detectors mask is 1 for each spatial position in the final conv layer and # anchor that should be active for the given boxes and 0 otherwise. # Matching true boxes gives the regression targets for the ground truth box # that caused a detector to be active or 0 otherwise. detectors_mask_shape = (13, 13, 5, 1) matching_boxes_shape = (13, 13, 5, 5) def get_detector_mask(boxes, anchors): detectors_mask = [0 for i in range(len(boxes))] matching_true_boxes = [0 for i in range(len(boxes))] for i, box in enumerate(boxes): box = box.reshape((-1, 5)) detectors_mask[i], matching_true_boxes[i] = preprocess_true_boxes( box, anchors, [416, 416]) return np.array(detectors_mask), np.array(matching_true_boxes) detectors_mask, matching_true_boxes = get_detector_mask(boxes, anchors) #detectors_mask, matching_true_boxes = preprocess_true_boxes(boxes, anchors, # [416, 416]) # Create model input layers. image_input = Input(shape=(416, 416, 3)) boxes_input = Input(shape=(None, 5)) detectors_mask_input = Input(shape=detectors_mask_shape) matching_boxes_input = Input(shape=matching_boxes_shape) #import pdb; pdb.set_trace() print('Boxes:') print(boxes) ##print('Box corners:') ##print(boxes_extents) print('Active detectors:') print(np.where(detectors_mask == 1)[:-1]) print('Matching boxes for active detectors:') print(matching_true_boxes[np.where(detectors_mask == 1)[:-1]]) # Create model body. model_body = yolo_body(image_input, len(anchors), len(class_names)) model_body = Model(image_input, model_body.output) # Place model loss on CPU to reduce GPU memory usage. with tf.device('/cpu:0'): # TODO: Replace Lambda with custom Keras layer for loss. model_loss = Lambda(yolo_loss, output_shape=(1, ), name='yolo_loss', arguments={ 'anchors': anchors, 'num_classes': len(class_names) })([ model_body.output, boxes_input, detectors_mask_input, matching_boxes_input ]) model = Model( [image_input, boxes_input, detectors_mask_input, matching_boxes_input], model_loss) model.compile( optimizer='adam', loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # This is a hack to use the custom loss function in the last layer. # Add batch dimension for training. #image_data = image_data[0,:,:,:] #image_data = np.expand_dims(image_data, axis=0) boxes = np.expand_dims(boxes, axis=1) #detectors_mask = np.expand_dims(detectors_mask, axis=0) #matching_true_boxes = np.expand_dims(matching_true_boxes, axis=0) num_steps = 1000 # TODO: For full training, put preprocessing inside training loop. # for i in range(num_steps): # loss = model.train_on_batch( # [image_data, boxes, detectors_mask, matching_true_boxes], # np.zeros(len(image_data))) #import pdb; pdb.set_trace() model.fit([image_data, boxes, detectors_mask, matching_true_boxes], np.zeros(len(image_data)), batch_size=2, epochs=num_steps) model.save_weights('overfit_circle_square_weights.h5') #model.load_weights('overfit_circle_square_weights.h5') #model.load_weights('overfit_weights.h5') # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=.3, iou_threshold=.9) # Run prediction on overfit image. num_shapes = 10 image_data = np.empty((1, 416, 416, 3), dtype=np.float) #for sh in range(num_shape) circ2 = geo.circle(shape=(416, 416), radius=40, position=(0.4, 0.4)) #circ3 = geo.circle(shape=(416,416),radius=40,position=0.8) #sq2 = geo.square(shape=(416,416),side=40,position=0.2) sq3 = geo.square(shape=(416, 416), side=40, position=0.8) image_data = np.empty((1, 416, 416, 3), dtype=np.float) image_data[0, :, :, 0] = circ2 + sq3 image_data[0, :, :, 1] = circ2 + sq3 image_data[0, :, :, 2] = circ2 + sq3 sess = K.get_session() # TODO: Remove dependence on Tensorflow session. out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data, #input_image_shape: [image.size[1], image.size[0]], input_image_shape: [416, 416], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[0], out_boxes, out_classes, class_names, out_scores) plt.imshow(image_with_boxes, interpolation='nearest') plt.show()
def draw(model_body, class_names, anchors, image_set='val', weights_name='trained_stage_1.h5', out_path="output_images", save_all=True): ''' Draw bounding boxes on image data ''' if image_set == 'train': image_names = glob.glob("./DATA/00001/*.ppm") image_data = np.array([cv2.imread(image) for image in image_names]) image_data = process_data(images=image_data, boxes=None) image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) elif image_set == 'val': image_names = glob.glob("./DATA/validation/*.ppm") image_data = np.array([cv2.imread(image) for image in image_names]) image_data = process_data(images=image_data, boxes=None) image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) elif image_set == 'all': image_names = glob.glob("./DATA/00001/*.ppm") image_data = np.array([cv2.imread(image) for image in image_names]) image_data = process_data(images=image_data, boxes=None) image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) else: ValueError("draw argument image_set must be 'train', 'val', or 'all'") # model.load_weights(weights_name) print(image_data.shape) model_body.load_weights(weights_name) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=0.07, iou_threshold=0.0) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. if not os.path.exists(out_path): os.makedirs(out_path) #running the session to get boxes ,scores and corresponding classes to be used in drawing boxes. for i in range(len(image_data)): out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, class_names, out_scores) # Save the image: if save_all or ( len(out_boxes) > 0 ): # if no boxes are found so don't save the image.(you can change >0 to >=0 to save also images with no boxes to be able to see images that your model couldn't find the objects in it) image = PIL.Image.fromarray(image_with_boxes) image.save(os.path.join( out_path, str(i) + '.png')) #Save images to output path passed in arguments.
def predict(model_body, class_names, anchors, image_data, weights_name, dir_list, non_best_sup=False, results_dir='results', save=False, training=False): '''Runs the detection algorithm on image_data. Inputs: model_body: the body of the model as returned by the create_model function. class_names: a list containing the class names. anchors: a np array containing the anchor boxes dimension. image_data: np array of shape (#images,side,side,channels) containing the images. dir_list: the image data names' list. weights_name: the name of the weight file that we want to load. non_best_sup: wether or not to perform non best suppression during predictions. results_dir: directory where the results will be saved. save: wether or not to save the output images. Returns: boxes_dict: the dictionnary containing the bounding boxes and scores. boxes_dict = {filename : {'bladder': [[xA,yA,xB,yB,score],[...]], 'rectum': [..], 'prostate': [..]}, filename : {...},...} ''' # Creating missing directories if not os.path.exists(results_dir): os.makedirs(results_dir) if not os.path.exists(os.path.join(results_dir, 'images')): os.makedirs(os.path.join(results_dir, 'images')) if not os.path.exists(os.path.join(results_dir, 'predictions')): os.makedirs(os.path.join(results_dir, 'predictions')) # Loading image data in the right format image_data = np.array( [np.expand_dims(image, axis=0) for image in image_data]) # Loading weights if training: model_body.load_weights( os.path.join(results_dir, 'models', weights_name)) else: model_body.load_weights(os.path.join('models', weights_name)) # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=0.07, iou_threshold=0.0) # Dictionnary to export the predicted bounding boxes boxes_dict = {} # Run prediction sess = K.get_session() # TODO: Remove dependence on Tensorflow session. for i in range(len(image_data)): print('predicting boxes for {}'.format(dir_list[i])) out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data[i], input_image_shape: [image_data.shape[2], image_data.shape[3]], K.learning_phase(): 0 }) if non_best_sup: (new_out_boxes, new_out_classes, new_out_scores) = non_best_suppression(out_boxes, out_classes, out_scores) # Plot image with predicted boxes. if save: image_with_boxes = draw_boxes(image_data[i][0], new_out_boxes, new_out_classes, class_names, new_out_scores) image = PIL.Image.fromarray(image_with_boxes) image.save( os.path.join(results_dir, 'images', dir_list[i] + '.png')) elif save: # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[i][0], out_boxes, out_classes, class_names, out_scores) image = PIL.Image.fromarray(image_with_boxes) image.save( os.path.join(results_dir, 'images', dir_list[i] + '.png')) # Updates dictionnary boxes_dict.update({dir_list[i]: {}}) for c in class_names: boxes_dict[dir_list[i]].update({c: []}) for j in range(len(out_boxes)): organ = class_names[out_classes[j]] new_box = list(out_boxes[j]) new_box.append(out_scores[j]) boxes_dict[dir_list[i]][organ].append(new_box) # Saving boxes return boxes_dict
def _main(): voc_path = os.path.expanduser( '/Users/ss/Data/VOCdevkit/pascal_voc_07_07.hdf5') classes_path = os.path.expanduser('model_data/pascal_classes.txt') with open(classes_path) as f: class_names = f.readlines() class_names = [c.strip() for c in class_names] voc = h5py.File(voc_path, 'r') image = PIL.Image.open(io.BytesIO(voc['train/images'][28])) orig_size = np.array([image.width, image.height]) orig_size = np.expand_dims(orig_size, axis=0) # Image preprocessing. image = image.resize((416, 416), PIL.Image.BICUBIC) image_data = np.array(image, dtype=np.float) image_data /= 255. # Box preprocessing. # Original boxes stored as 1D list of class, x_min, y_min, x_max, y_max. boxes = voc['train/boxes'][28] boxes = boxes.reshape((-1, 5)) # Get extents as y_min, x_min, y_max, x_max, class for comparision with # model output. boxes_extents = boxes[:, [2, 1, 4, 3, 0]] # Get box parameters as x_center, y_center, box_width, box_height, class. boxes_xy = 0.5 * (boxes[:, 3:5] + boxes[:, 1:3]) boxes_wh = boxes[:, 3:5] - boxes[:, 1:3] boxes_xy = boxes_xy / orig_size boxes_wh = boxes_wh / orig_size boxes = np.concatenate((boxes_xy, boxes_wh, boxes[:, 0:1]), axis=1) # Precompute detectors_mask and matching_true_boxes for training. # Detectors mask is 1 for each spatial position in the final conv layer and # anchor that should be active for the given boxes and 0 otherwise. # Matching true boxes gives the regression targets for the ground truth box # that caused a detector to be active or 0 otherwise. anchors = COCO_ANCHORS detectors_mask_shape = (13, 13, 5, 1) matching_boxes_shape = (13, 13, 5, 5) detectors_mask, matching_true_boxes = preprocess_true_boxes( boxes, anchors, [416, 416]) # Create model input layers. image_input = Input(shape=(416, 416, 3)) boxes_input = Input(shape=(None, 5)) detectors_mask_input = Input(shape=detectors_mask_shape) matching_boxes_input = Input(shape=matching_boxes_shape) print(boxes) print(boxes_extents) print(np.where(detectors_mask == 1)[:-1]) print(matching_true_boxes[np.where(detectors_mask == 1)[:-1]]) # Create model body. model_body = yolo_body(image_input, len(anchors), len(class_names)) model_body = Model(image_input, model_body.output) # Place model loss on CPU to reduce GPU memory usage. with tf.device('/cpu:0'): # TODO: Replace Lambda with custom Keras layer for loss. model_loss = Lambda(yolo_loss, output_shape=(1, ), name='yolo_loss', arguments={ 'anchors': anchors, 'num_classes': len(class_names) })([ model_body.output, boxes_input, detectors_mask_input, matching_boxes_input ]) model = Model( [image_input, boxes_input, detectors_mask_input, matching_boxes_input], model_loss) model.compile( optimizer='adam', loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # This is a hack to use the custom loss function in the last layer. # Add batch dimension for training. image_data = np.expand_dims(image_data, axis=0) boxes = np.expand_dims(boxes, axis=0) detectors_mask = np.expand_dims(detectors_mask, axis=0) matching_true_boxes = np.expand_dims(matching_true_boxes, axis=0) num_steps = 1000 # TODO: For full training, put preprocessing inside training loop. # for i in range(num_steps): # loss = model.train_on_batch( # [image_data, boxes, detectors_mask, matching_true_boxes], # np.zeros(len(image_data))) model.fit([image_data, boxes, detectors_mask, matching_true_boxes], np.zeros(len(image_data)), batch_size=1, epochs=num_steps) model.save_weights('overfit_weights.h5') # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=.3, iou_threshold=.9) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data, input_image_shape: [image.size[1], image.size[0]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[0], out_boxes, out_classes, class_names, out_scores) plt.imshow(image_with_boxes, interpolation='nearest') plt.show()
def _main(args): #訓練データセットに対する情報の読み込みfrom voc_to_hdf5 voc_path = os.path.expanduser(args.data_path) #ラベル情報.txtへのpath classes_path = os.path.expanduser(args.classes_path) #アスペクト比の格納? anchors_path = os.path.expanduser(args.anchors_path) #クラス名のリストを作成 with open(classes_path) as f: class_names = f.readlines() class_names = [c.strip() for c in class_names] if os.path.isfile(anchors_path): with open(anchors_path) as f: anchors = f.readline() anchors = [float(x) for x in anchors.split(',')] anchors = np.array(anchors).reshape(-1, 2) else: anchors = YOLO_ANCHORS voc = h5py.File(voc_path, 'r') image = PIL.Image.open(io.BytesIO(voc['test/images'][0])) orig_size = np.array([image.width, image.height]) orig_size = np.expand_dims(orig_size, axis=0) # Image preprocessing. image = image.resize((416, 416), PIL.Image.BICUBIC) image_data = np.array(image, dtype=np.float) image_data /= 255. # Box preprocessing. # Original boxes stored as 1D list of class, x_min, y_min, x_max, y_max. boxes = voc['test/boxes'][0] boxes = boxes.reshape((-1, 5)) # Get extents as y_min, x_min, y_max, x_max, class for comparision with # model output. boxes_extents = boxes[:, [2, 1, 4, 3, 0]] # Get box parameters as x_center, y_center, box_width, box_height, class. boxes_xy = 0.5 * (boxes[:, 3:5] + boxes[:, 1:3]) boxes_wh = boxes[:, 3:5] - boxes[:, 1:3] boxes_xy = boxes_xy / orig_size boxes_wh = boxes_wh / orig_size #annotation部分のxy座標、幅 boxes = np.concatenate((boxes_xy, boxes_wh, boxes[:, 0:1]), axis=1) # Precompute detectors_mask and matching_true_boxes for training. # Detectors mask is 1 for each spatial position in the final conv layer and # anchor that should be active for the given boxes and 0 otherwise. # Matching true boxes gives the regression targets for the ground truth box # that caused a detector to be active or 0 otherwise. detectors_mask_shape = (13, 13, 5, 1) matching_boxes_shape = (13, 13, 5, 5) detectors_mask, matching_true_boxes = preprocess_true_boxes( boxes, anchors, [416, 416]) # Create model input layers. image_input = Input(shape=(416, 416, 3)) boxes_input = Input(shape=(None, 5)) detectors_mask_input = Input(shape=detectors_mask_shape) matching_boxes_input = Input(shape=matching_boxes_shape) print('Boxes:') print(boxes) print('Box corners:') print(boxes_extents) print('Active detectors:') print(np.where(detectors_mask == 1)[:-1]) print('Matching boxes for active detectors:') print(matching_true_boxes[np.where(detectors_mask == 1)[:-1]]) # Create model body. model_body = yolo_body(image_input, len(anchors), len(class_names)) model_body = Model(image_input, model_body.output) # Place model loss on CPU to reduce GPU memory usage. with tf.device('/cpu:0'): # TODO: Replace Lambda with custom Keras layer for loss. model_loss = Lambda(yolo_loss, output_shape=(1, ), name='yolo_loss', arguments={ 'anchors': anchors, 'num_classes': len(class_names) })([ model_body.output, boxes_input, detectors_mask_input, matching_boxes_input ]) model = Model( [image_input, boxes_input, detectors_mask_input, matching_boxes_input], model_loss) model.compile( optimizer='adam', loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # This is a hack to use the custom loss function in the last layer. # Add batch dimension for training. image_data = np.expand_dims(image_data, axis=0) boxes = np.expand_dims(boxes, axis=0) detectors_mask = np.expand_dims(detectors_mask, axis=0) matching_true_boxes = np.expand_dims(matching_true_boxes, axis=0) num_steps = 50 #checkpoint = ModelCheckpoint('model1.h5', monitor='val_loss', verbose=1, #save_best_only=True, save_weights_only=False, mode='auto', period=1) # TODO: For full training, put preprocessing inside training loop. # for i in range(num_steps): # loss = model.train_on_batch( # [image_data, boxes, detectors_mask, matching_true_boxes], # np.zeros(len(image_data))) model.fit( [image_data, boxes, detectors_mask, matching_true_boxes], np.zeros(len(image_data)), batch_size=1, epochs=num_steps, #callbacks=[checkpoint] ) model.save('model.h5') model.save_weights('overfit_weights.h5') #model_json_str = model.to_json() #open('mlp_model.json', 'w').write(model_json_str) #model.save_weights('mlp_weights.h5'); # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval(yolo_outputs, input_image_shape, score_threshold=.3, iou_threshold=.9) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data, input_image_shape: [image.size[1], image.size[0]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[0], out_boxes, out_classes, class_names, out_scores) plt.imshow(image_with_boxes, interpolation='nearest') plt.show()
def _main(args): voc_path = os.path.expanduser(args.data_path) classes_path = os.path.expanduser(args.classes_path) anchors_path = os.path.expanduser(args.anchors_path) with open(classes_path) as f: class_names = f.readlines() class_names = [c.strip() for c in class_names] if os.path.isfile(anchors_path): with open(anchors_path) as f: anchors = f.readline() anchors = [float(x) for x in anchors.split(',')] anchors = np.array(anchors).reshape(-1, 2) else: anchors = YOLO_ANCHORS voc = h5py.File(voc_path, 'r') image = PIL.Image.open(io.BytesIO(voc['train/images'][28])) orig_size = np.array([image.width, image.height]) orig_size = np.expand_dims(orig_size, axis=0) # Image preprocessing. image = image.resize((416, 416), PIL.Image.BICUBIC) image_data = np.array(image, dtype=np.float) image_data /= 255. # Box preprocessing. # Original boxes stored as 1D list of class, x_min, y_min, x_max, y_max. boxes = voc['train/boxes'][28] boxes = boxes.reshape((-1, 5)) # Get extents as y_min, x_min, y_max, x_max, class for comparision with # model output. boxes_extents = boxes[:, [2, 1, 4, 3, 0]] # Get box parameters as x_center, y_center, box_width, box_height, class. boxes_xy = 0.5 * (boxes[:, 3:5] + boxes[:, 1:3]) boxes_wh = boxes[:, 3:5] - boxes[:, 1:3] boxes_xy = boxes_xy / orig_size boxes_wh = boxes_wh / orig_size boxes = np.concatenate((boxes_xy, boxes_wh, boxes[:, 0:1]), axis=1) # Precompute detectors_mask and matching_true_boxes for training. # Detectors mask is 1 for each spatial position in the final conv layer and # anchor that should be active for the given boxes and 0 otherwise. # Matching true boxes gives the regression targets for the ground truth box # that caused a detector to be active or 0 otherwise. detectors_mask_shape = (13, 13, 5, 1) matching_boxes_shape = (13, 13, 5, 5) detectors_mask, matching_true_boxes = preprocess_true_boxes(boxes, anchors, [416, 416]) # Create model input layers. image_input = Input(shape=(416, 416, 3)) boxes_input = Input(shape=(None, 5)) detectors_mask_input = Input(shape=detectors_mask_shape) matching_boxes_input = Input(shape=matching_boxes_shape) print('Boxes:') print(boxes) print('Box corners:') print(boxes_extents) print('Active detectors:') print(np.where(detectors_mask == 1)[:-1]) print('Matching boxes for active detectors:') print(matching_true_boxes[np.where(detectors_mask == 1)[:-1]]) # Create model body. model_body = yolo_body(image_input, len(anchors), len(class_names)) model_body = Model(image_input, model_body.output) # Place model loss on CPU to reduce GPU memory usage. with tf.device('/cpu:0'): # TODO: Replace Lambda with custom Keras layer for loss. model_loss = Lambda( yolo_loss, output_shape=(1, ), name='yolo_loss', arguments={'anchors': anchors, 'num_classes': len(class_names)})([ model_body.output, boxes_input, detectors_mask_input, matching_boxes_input ]) model = Model( [image_input, boxes_input, detectors_mask_input, matching_boxes_input], model_loss) model.compile( optimizer='adam', loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # This is a hack to use the custom loss function in the last layer. # Add batch dimension for training. image_data = np.expand_dims(image_data, axis=0) boxes = np.expand_dims(boxes, axis=0) detectors_mask = np.expand_dims(detectors_mask, axis=0) matching_true_boxes = np.expand_dims(matching_true_boxes, axis=0) num_steps = 1000 # TODO: For full training, put preprocessing inside training loop. # for i in range(num_steps): # loss = model.train_on_batch( # [image_data, boxes, detectors_mask, matching_true_boxes], # np.zeros(len(image_data))) model.fit([image_data, boxes, detectors_mask, matching_true_boxes], np.zeros(len(image_data)), batch_size=1, epochs=num_steps) model.save_weights('overfit_weights.h5') # Create output variables for prediction. yolo_outputs = yolo_head(model_body.output, anchors, len(class_names)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval( yolo_outputs, input_image_shape, score_threshold=.3, iou_threshold=.9) # Run prediction on overfit image. sess = K.get_session() # TODO: Remove dependence on Tensorflow session. out_boxes, out_scores, out_classes = sess.run( [boxes, scores, classes], feed_dict={ model_body.input: image_data, input_image_shape: [image.size[1], image.size[0]], K.learning_phase(): 0 }) print('Found {} boxes for image.'.format(len(out_boxes))) print(out_boxes) # Plot image with predicted boxes. image_with_boxes = draw_boxes(image_data[0], out_boxes, out_classes, class_names, out_scores) plt.imshow(image_with_boxes, interpolation='nearest') plt.show()