def predict(self, chips, windows):
"""Return predictions for a chip using model.
Args:
chips: [[height, width, channels], ...] numpy array of chips
windows: List of boxes that are the windows aligned with the chips.
Return:
Labels object containing predictions
"""
if self.learner is None:
self.load_model()
batch_out = self.learner.numpy_predict(chips, raw_out=False)
labels = ObjectDetectionLabels.make_empty()
for chip_ind, out in enumerate(batch_out):
window = windows[chip_ind]
boxes = out['boxes']
class_ids = out['class_ids']
scores = out['scores']
boxes = ObjectDetectionLabels.local_to_global(boxes, window)
labels += ObjectDetectionLabels(boxes, class_ids, scores=scores)
return labels
def _make_chip_pos_windows(image_extent, label_store, chip_size):
chip_size = chip_size
pos_windows = []
boxes = label_store.get_labels().get_boxes()
done_boxes = set()
# Get a random window around each box. If a box was previously included
# in a window, then it is skipped.
for box in boxes:
if box.tuple_format() not in done_boxes:
# If this object is bigger than the chip,
# don't use this box.
if chip_size < box.get_width() or chip_size < box.get_height():
log.warning('Label is larger than chip size: {} '
'Skipping this label'.format(box.tuple_format()))
continue
window = box.make_random_square_container(chip_size)
pos_windows.append(window)
# Get boxes that lie completely within window
window_boxes = label_store.get_labels(window=window)
window_boxes = ObjectDetectionLabels.get_overlapping(
window_boxes, window, ioa_thresh=1.0)
window_boxes = window_boxes.get_boxes()
window_boxes = [box.tuple_format() for box in window_boxes]
done_boxes.update(window_boxes)
return pos_windows
def get_train_labels(self, window, scene):
window_labels = scene.ground_truth_label_source.get_labels(
window=window)
return ObjectDetectionLabels.get_overlapping(
window_labels,
window,
ioa_thresh=self.config.chip_options.ioa_thresh,
clip=True)
def __init__(self, vector_source, extent=None):
"""Constructor.
Args:
vector_source: (VectorSource)
extent: Box used to filter the labels by extent
"""
self.labels = ObjectDetectionLabels.from_geojson(
vector_source.get_geojson(), extent=extent)
def make_neg_windows(raster_source, label_store, chip_size, nb_windows,
max_attempts, filter_windows):
extent = raster_source.get_extent()
neg_windows = []
for _ in range(max_attempts):
for _ in range(max_attempts):
window = extent.make_random_square(chip_size)
if any(filter_windows([window])):
break
chip = raster_source.get_chip(window)
labels = ObjectDetectionLabels.get_overlapping(
label_store.get_labels(), window, ioa_thresh=0.2)
# If no labels and not blank, append the chip
if len(labels) == 0 and np.sum(chip.ravel()) > 0:
neg_windows.append(window)
if len(neg_windows) == nb_windows:
break
return list(neg_windows)
def write_sample(self, sample: DataSample):
"""
This writes a training or validation sample to
(train|valid)/img/{scene_id}-{ind}.png and updates
some COCO data structures.
"""
split = 'train' if sample.is_train else 'valid'
split_dir = join(self.sample_dir, split)
img_dir = join(split_dir, 'img')
make_dir(img_dir)
img_fn = '{}-{}.png'.format(sample.scene_id, self.sample_ind)
img_path = join(img_dir, img_fn)
save_img(sample.chip, img_path)
images = self.splits[split]['images']
annotations = self.splits[split]['annotations']
images.append({
'file_name': img_fn,
'id': self.sample_ind,
'height': sample.chip.shape[0],
'width': sample.chip.shape[1]
})
npboxes = sample.labels.get_npboxes()
npboxes = ObjectDetectionLabels.global_to_local(npboxes, sample.window)
for box_ind, (box, class_id) in enumerate(
zip(npboxes, sample.labels.get_class_ids())):
bbox = [box[1], box[0], box[3] - box[1], box[2] - box[0]]
bbox = [int(i) for i in bbox]
annotations.append({
'id': '{}-{}'.format(self.sample_ind, box_ind),
'image_id': self.sample_ind,
'bbox': bbox,
'category_id': int(class_id)
})
self.sample_ind += 1
def get_labels(self, window=None):
if window is None:
return self.labels
return ObjectDetectionLabels.get_overlapping(self.labels, window)
def post_process_predictions(self, labels, scene):
return ObjectDetectionLabels.prune_duplicates(
labels,
score_thresh=self.config.predict_options.score_thresh,
merge_thresh=self.config.predict_options.merge_thresh)
def empty_labels(self):
return ObjectDetectionLabels.make_empty()
def get_labels(self):
vector_source = GeoJSONVectorSourceConfig(uri=self.uri,
default_class_id=None).build(
self.class_config,
self.crs_transformer)
return ObjectDetectionLabels.from_geojson(vector_source.get_geojson())